react-native-audio-browser 0.2.0-next.7 → 0.2.0-next.9

package/android/build.gradle

@@ -33,13 +33,19 @@ if (isNewArchitectureEnabled()) {
   apply plugin: "com.facebook.react"
 }
 
-ktfmt {  googleStyle()
+ktfmt {
+  googleStyle()
 }
 
 tasks.register("format") {
   dependsOn "ktfmtFormat"
 }
 
+// Fails instead of rewriting — what CI runs.
+tasks.register("formatCheck") {
+  dependsOn "ktfmtCheck"
+}
+
 def getExtOrDefault(name) {
   return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["AudioBrowser_" + name]
 }

package/android/src/main/java/com/audiobrowser/AudioBrowser.kt

@@ -90,6 +90,7 @@ import kotlin.coroutines.suspendCoroutine
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Job
 import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.cancel
 import kotlinx.coroutines.cancelChildren
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -100,10 +101,37 @@ import timber.log.Timber
 @DoNotStrip
 class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
 
-  /** Called by Nitro when the JS object is destroyed (incl. JS runtime reloads). */
+  /**
+   * Called by Nitro when the JS object is destroyed (incl. JS runtime reloads).
+   *
+   * The Service outlives this object, so everything registered in `init` or on connect has to be
+   * undone here. Left alone, the running [Player] goes on invoking callbacks into a dead JSI
+   * runtime, and every reload strands another ServiceConnection and lifecycle observer, each
+   * retaining a BrowserManager.
+   */
   override fun dispose() {
     systemVolumeMonitor.destroy()
     outputMonitor.destroy()
+
+    connectedService?.let { service ->
+      service.player.setCallbacks(null)
+      service.player.browser = null
+      service.onBatteryWarningPendingChanged = null
+    }
+    connectedService = null
+    mediaBrowserFuture = null
+
+    serviceBinding.unbind(this)
+
+    // Only when still ours: on a reload the replacement instance may already own the slot.
+    if (carConnectionTarget === onCarConnectedChanged) carConnectionTarget = null
+
+    // Drop queued work first, then post the removal — LifecycleRegistry is main-thread only,
+    // which is why the observer is added the same way.
+    handler.removeCallbacksAndMessages(null)
+    handler.post { ProcessLifecycleOwner.get().lifecycle.removeObserver(lifecycleObserver) }
+
+    mainScope.cancel()
     super.dispose()
   }
 
@@ -150,6 +178,8 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
   private var mediaBrowserFuture: ListenableFuture<MediaBrowser>? = null
   private var setupOptions = PlayerSetupOptions()
   private var connectedService: Service? = null
+
+  private val serviceBinding = ServiceBinding(context)
   private var setupPromise: ((Unit) -> Unit)? = null
 
   // Initial player state staged before the player exists — from setup options or the imperative
@@ -244,7 +274,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
       try {
         Timber.d("Attempting to auto-bind to existing AudioBrowserService from AudioBrowser")
         val intent = Intent(context, Service::class.java)
-        val bound = context.bindService(intent, this@AudioBrowser, Context.BIND_AUTO_CREATE)
+        val bound = serviceBinding.bind(intent, this@AudioBrowser)
         Timber.d("Auto-bind result: $bound")
 
         if (!bound) {
@@ -811,12 +841,7 @@ class AudioBrowser : HybridAudioBrowserSpec(), ServiceConnection {
       // Service not connected yet, bind to service
       suspendCoroutine<Unit> { continuation ->
         Timber.d("Binding to AudioBrowserService")
-        val bound =
-          context.bindService(
-            Intent(context, Service::class.java),
-            this@AudioBrowser,
-            Context.BIND_AUTO_CREATE,
-          )
+        val bound = serviceBinding.bind(Intent(context, Service::class.java), this@AudioBrowser)
 
         if (!bound) {
           continuation.resumeWithException(

package/android/src/main/java/com/audiobrowser/ServiceBinding.kt

@@ -0,0 +1,46 @@
+package com.audiobrowser
+
+import android.content.Context
+import android.content.Intent
+import android.content.ServiceConnection
+import timber.log.Timber
+
+/**
+ * Exactly-once bookkeeping for a [ServiceConnection].
+ *
+ * `bindService` may be called from more than one place — an auto-bind at construction and again
+ * from setup — but the binding must be released exactly once, and only if one was ever taken:
+ * [Context.unbindService] throws when the connection was never registered. Kept apart from the
+ * caller so the rule is one object's job, and so it can be tested without a JSI runtime.
+ */
+internal class ServiceBinding(private val context: Context) {
+
+  @Volatile
+  var isBound: Boolean = false
+    private set
+
+  /**
+   * Binds if not already bound, and returns whether a binding is held afterwards. A second call
+   * while bound is a no-op: Android would otherwise count the extra bind and expect a matching
+   * unbind.
+   */
+  fun bind(intent: Intent, connection: ServiceConnection): Boolean {
+    if (isBound) return true
+    val bound = context.bindService(intent, connection, Context.BIND_AUTO_CREATE)
+    if (bound) isBound = true
+    return bound
+  }
+
+  /**
+   * Releases the binding if one is held. Safe to call repeatedly, and safe when the service has
+   * already died — [onServiceDisconnected][ServiceConnection.onServiceDisconnected] means the
+   * service went away, not that the binding did, so the unbind is still required.
+   */
+  fun unbind(connection: ServiceConnection) {
+    if (!isBound) return
+    isBound = false
+    // Throws if the binding is somehow already gone, which is the outcome we wanted anyway.
+    runCatching { context.unbindService(connection) }
+      .onFailure { Timber.w(it, "unbindService failed") }
+  }
+}

package/android/src/main/java/com/audiobrowser/browser/BrowserManager.kt

@@ -1,7 +1,5 @@
 package com.audiobrowser.browser
 
-import com.audiobrowser.util.artworkOf
-
 import android.util.LruCache
 import androidx.media3.common.MediaItem
 import androidx.media3.session.MediaSession
@@ -9,6 +7,7 @@ import com.audiobrowser.http.HttpClient
 import com.audiobrowser.http.RequestConfigBuilder
 import com.audiobrowser.util.BrowserPathHelper
 import com.audiobrowser.util.TrackFactory
+import com.audiobrowser.util.artworkOf
 import com.margelo.nitro.audiobrowser.ArtworkRequestConfig
 import com.margelo.nitro.audiobrowser.BrowserSourceCallbackParam
 import com.margelo.nitro.audiobrowser.FavoritesMatchMode

package/android/src/main/java/com/audiobrowser/browser/BrowserUrlResolution.kt

@@ -1,8 +1,7 @@
 package com.audiobrowser.browser
 
-import com.audiobrowser.util.url
-
 import com.audiobrowser.http.RequestConfigBuilder
+import com.audiobrowser.util.url
 import com.margelo.nitro.audiobrowser.ArtworkRequestConfig
 import com.margelo.nitro.audiobrowser.ImageContext
 import com.margelo.nitro.audiobrowser.ImageQueryParams

package/android/src/main/java/com/audiobrowser/browser/SectionScope.kt

@@ -4,9 +4,9 @@ import com.margelo.nitro.audiobrowser.ImageRowItem
 import com.margelo.nitro.audiobrowser.Track
 
 /**
- * Queue scope is the tapped section, not the whole page (ADR 0006): the
- * playback context a listener expects is the list they tapped in — a page
- * aggregating several sections must not leak next/previous across them.
+ * Queue scope is the tapped section, not the whole page (ADR 0006): the playback context a listener
+ * expects is the list they tapped in — a page aggregating several sections must not leak
+ * next/previous across them.
  */
 object SectionScope {
   sealed class Section {
@@ -14,15 +14,14 @@ object SectionScope {
     data class ImageRow(val items: List<ImageRowItem>) : Section()
 
     /**
-     * The contiguous `groupTitle` run around the tapped child (items with no
-     * group title form runs of their own).
+     * The contiguous `groupTitle` run around the tapped child (items with no group title form runs
+     * of their own).
      */
     data class Run(val tracks: List<Track>) : Section()
   }
 
   /**
-   * The section of [children] containing the playable [trackId], or null
-   * when the id is not found.
+   * The section of [children] containing the playable [trackId], or null when the id is not found.
    */
   fun section(children: List<Track>, trackId: String): Section? {
     for (child in children) {

package/android/src/main/java/com/audiobrowser/player/NowPlayingUpdater.kt

@@ -1,7 +1,6 @@
 package com.audiobrowser.player
 
 import com.audiobrowser.util.url
-
 import com.margelo.nitro.audiobrowser.FormatNowPlayingParams
 import com.margelo.nitro.audiobrowser.NowPlayingMetadata
 import com.margelo.nitro.audiobrowser.NowPlayingUpdate

package/android/src/main/java/com/audiobrowser/player/PlaybackStateStore.kt

@@ -1,13 +1,11 @@
 package com.audiobrowser.player
 
-import com.audiobrowser.util.artworkOf
-
-import com.audiobrowser.util.url
-
 import android.content.Context
 import android.content.SharedPreferences
 import androidx.core.content.edit
 import androidx.media3.common.C
+import com.audiobrowser.util.artworkOf
+import com.audiobrowser.util.url
 import com.margelo.nitro.audiobrowser.PlaybackState
 import com.margelo.nitro.audiobrowser.RepeatMode
 import com.margelo.nitro.audiobrowser.Track

package/android/src/main/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicy.kt

@@ -107,7 +107,8 @@ class RetryLoadErrorHandlingPolicy(
    */
   private fun exhaustedBudget(currentTime: Long): String? {
     firstErrorTime?.let { start ->
-      if (currentTime - start >= maxRetryDurationMs) return "max retry duration ($maxRetryDurationMs ms)"
+      if (currentTime - start >= maxRetryDurationMs)
+        return "max retry duration ($maxRetryDurationMs ms)"
     }
     if (!hasPlayed() && isOnline()) {
       firstOnlineErrorTime?.let { start ->

package/android/src/main/java/com/audiobrowser/util/ArtworkVariant.kt

@@ -5,11 +5,10 @@ import com.margelo.nitro.audiobrowser.Variant_String_ArtworkVariants
 /**
  * Reading `Track.artwork`, which is either one URL or a URL per appearance.
  *
- * Android Auto is dark-only, so there is nothing here to choose: a pair always
- * resolves to its dark URL, which is also what a single-URL track would have
- * shipped. The per-appearance half of the feature is iOS/CarPlay only — see
- * `ios/Extension/Variant+Artwork.swift`, where both URLs are kept so a
- * `UIImageAsset` can swap them without a re-fetch.
+ * Android Auto is dark-only, so there is nothing here to choose: a pair always resolves to its dark
+ * URL, which is also what a single-URL track would have shipped. The per-appearance half of the
+ * feature is iOS/CarPlay only — see `ios/Extension/Variant+Artwork.swift`, where both URLs are kept
+ * so a `UIImageAsset` can swap them without a re-fetch.
  */
 val Variant_String_ArtworkVariants.url: String
   get() = match(first = { it }, second = { it.dark })
@@ -17,10 +16,9 @@ val Variant_String_ArtworkVariants.url: String
 /**
  * Wraps a plain URL as the single-URL side of the union.
  *
- * For the places that build a `Track` from something that only ever has one
- * image — restored persistence, a `MediaMetadata` handed back by the platform.
- * Restoring collapses a pair to its dark URL, which costs nothing here: Android
- * Auto would have rendered that one anyway.
+ * For the places that build a `Track` from something that only ever has one image — restored
+ * persistence, a `MediaMetadata` handed back by the platform. Restoring collapses a pair to its
+ * dark URL, which costs nothing here: Android Auto would have rendered that one anyway.
  */
 fun artworkOf(url: String?): Variant_String_ArtworkVariants? =
   url?.let { Variant_String_ArtworkVariants.First(it) }

package/android/src/main/java/com/audiobrowser/util/TrackFactory.kt

@@ -26,12 +26,12 @@ object TrackFactory {
   }
 
   /**
-   * Android Auto has no image-row rendering; its closest equivalent is a grid of artwork
-   * tiles. A track carrying `imageRow` expands into its items as grid-styled rows (the
-   * per-item content-style hint — hosts that ignore it fall back to list rows) grouped under
-   * the row's title, followed by the row itself as a browsable "view all" link when it has a
-   * `url` (a url-less row is a pure preview and contributes only its items). Tracks without
-   * an `imageRow` pass through unchanged.
+   * Android Auto has no image-row rendering; its closest equivalent is a grid of artwork tiles. A
+   * track carrying `imageRow` expands into its items as grid-styled rows (the per-item
+   * content-style hint — hosts that ignore it fall back to list rows) grouped under the row's
+   * title, followed by the row itself as a browsable "view all" link when it has a `url` (a
+   * url-less row is a pure preview and contributes only its items). Tracks without an `imageRow`
+   * pass through unchanged.
    */
   fun expandImageRows(tracks: List<Track>): List<Track> =
     tracks.flatMap { track ->
@@ -95,7 +95,8 @@ object TrackFactory {
     val scheme = rawUrl?.let { Uri.parse(it).scheme?.lowercase() }
     val builder = metadataBuilder(track)
     if (rawUrl != null && (scheme == "http" || scheme == "https")) {
-      val isSvg = SvgArtworkRenderer.isSvgUrl(rawUrl) || SvgArtworkRenderer.isSvgUrl(track.artwork?.url)
+      val isSvg =
+        SvgArtworkRenderer.isSvgUrl(rawUrl) || SvgArtworkRenderer.isSvgUrl(track.artwork?.url)
       val token = ArtworkUris.tokenFor(rawUrl)
       registry.register(token, ResolvedArtwork(rawUrl, track.artworkSource?.headers, isSvg))
       builder.setArtworkUri(ArtworkUris.contentUri(authority, token).toUri())

package/android/src/test/java/com/audiobrowser/ServiceBindingTest.kt

@@ -0,0 +1,68 @@
+package com.audiobrowser
+
+import android.content.ComponentName
+import android.content.Intent
+import android.content.ServiceConnection
+import android.os.IBinder
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+import org.robolectric.Shadows.shadowOf
+
+// Robolectric: bindService/unbindService only exist under the framework, and ShadowApplication
+// records both sides — which is precisely the leak being guarded against.
+@RunWith(RobolectricTestRunner::class)
+class ServiceBindingTest {
+
+  private val app = RuntimeEnvironment.getApplication()
+  private val intent = Intent(app, Service::class.java)
+
+  private val connection =
+    object : ServiceConnection {
+      override fun onServiceConnected(name: ComponentName?, service: IBinder?) = Unit
+
+      override fun onServiceDisconnected(name: ComponentName?) = Unit
+    }
+
+  /** Both the auto-bind at construction and setup's bind reach the same object. */
+  @Test
+  fun bindingTwiceTakesOnlyOneBinding() {
+    val binding = ServiceBinding(app)
+
+    assertTrue(binding.bind(intent, connection))
+    assertTrue(binding.bind(intent, connection))
+
+    assertEquals(1, shadowOf(app).boundServiceConnections.size)
+
+    binding.unbind(connection)
+
+    assertTrue(shadowOf(app).boundServiceConnections.isEmpty())
+    assertEquals(1, shadowOf(app).unboundServiceConnections.size)
+  }
+
+  /** dispose() must not throw, and Android throws when unbinding a connection it never had. */
+  @Test
+  fun unbindWithoutBindIsANoOp() {
+    val binding = ServiceBinding(app)
+
+    binding.unbind(connection)
+
+    assertFalse(binding.isBound)
+    assertTrue(shadowOf(app).unboundServiceConnections.isEmpty())
+  }
+
+  @Test
+  fun unbindIsIdempotent() {
+    val binding = ServiceBinding(app)
+    binding.bind(intent, connection)
+
+    binding.unbind(connection)
+    binding.unbind(connection)
+
+    assertEquals(1, shadowOf(app).unboundServiceConnections.size)
+  }
+}

package/android/src/test/java/com/audiobrowser/TestFixtures.kt

@@ -1,7 +1,6 @@
 package com.audiobrowser
 
 import com.audiobrowser.util.artworkOf
-
 import com.margelo.nitro.audiobrowser.ArtworkRequestConfig
 import com.margelo.nitro.audiobrowser.ImageQueryParams
 import com.margelo.nitro.audiobrowser.ImageRowItem

package/android/src/test/java/com/audiobrowser/browser/JsonArtworkTest.kt

@@ -10,7 +10,8 @@ class JsonArtworkTest {
 
   @Test
   fun `decodes a single url`() {
-    val track = json.decodeFromString<JsonTrack>("""{"title":"X","artwork":"https://e.example/a.png"}""")
+    val track =
+      json.decodeFromString<JsonTrack>("""{"title":"X","artwork":"https://e.example/a.png"}""")
     assertEquals(
       Variant_String_ArtworkVariants.First("https://e.example/a.png"),
       track.toNitro().artwork,

package/android/src/test/java/com/audiobrowser/browser/SectionScopeTest.kt

@@ -59,8 +59,7 @@ class SectionScopeTest {
     val row = track(title = "Most Played", src = null, imageRow = items)
     val children = listOf(row, track(src = "a"))
 
-    val section =
-      SectionScope.section(children, "s2") as SectionScope.Section.ImageRow
+    val section = SectionScope.section(children, "s2") as SectionScope.Section.ImageRow
     assertEquals(listOf("s1", "s2"), section.items.map { it.src })
   }
 
@@ -76,8 +75,7 @@ class SectionScopeTest {
     val row = track(title = "Row", src = null, imageRow = arrayOf(imageRowItem("dup")))
     val children = listOf(row, track(src = "dup"), track(src = "b"))
 
-    val section =
-      SectionScope.section(children, "dup") as SectionScope.Section.ImageRow
+    val section = SectionScope.section(children, "dup") as SectionScope.Section.ImageRow
     assertEquals(listOf("dup"), section.items.map { it.src })
   }
 

package/android/src/test/java/com/audiobrowser/player/PlaybackErrorClassifierTest.kt

@@ -132,8 +132,8 @@ class PlaybackErrorClassifierTest {
 
   /**
    * Load errors are raw IOExceptions from the transport layer; the policy only retries network
-   * ones, so the advisory classification is UNREACHABLE unless the device is offline or the
-   * server actually answered.
+   * ones, so the advisory classification is UNREACHABLE unless the device is offline or the server
+   * actually answered.
    */
   @Test
   fun `retrying transport failure is unreachable`() {
@@ -158,8 +158,7 @@ class PlaybackErrorClassifierTest {
   /** The HTTP status is dug out of the cause chain and mapped through the shared status table. */
   @Test
   fun `retrying HTTP failure carries the status`() {
-    val error =
-      PlaybackErrorClassifier.retryingLoadError(httpException(503), online = true)
+    val error = PlaybackErrorClassifier.retryingLoadError(httpException(503), online = true)
     assertEquals(PlaybackErrorKind.SERVER_ERROR, error.kind)
     assertEquals(503.0, error.statusCode!!, 0.0)
     assertEquals(true, error.retrying)

package/android/src/test/java/com/audiobrowser/player/RetryLoadErrorHandlingPolicyTest.kt

@@ -201,9 +201,9 @@ class RetryLoadErrorHandlingPolicyBudgetTest {
   }
 
   /**
-   * Offline failures must not burn the first-connect budget (a station tapped in a tunnel parks
-   * for connectivity); the budget's clock starts at the first error observed online, so a dead
-   * station still gets a fast verdict after restoration.
+   * Offline failures must not burn the first-connect budget (a station tapped in a tunnel parks for
+   * connectivity); the budget's clock starts at the first error observed online, so a dead station
+   * still gets a fast verdict after restoration.
    */
   @Test
   fun `offline time does not burn the first-connect budget`() {

package/ios/Browser/BrowserManager.swift

@@ -770,9 +770,9 @@ final class BrowserManager {
     // silently queueing the changed list would resume the wrong station.
     let sectionTracks: [Track]
     switch SectionScope.section(of: children, containing: trackId) {
-    case .imageRow(let items):
+    case let .imageRow(items):
       sectionTracks = items.map { $0.toTrack() }
-    case .run(let tracks):
+    case let .run(tracks):
       sectionTracks = tracks
     case nil:
       return nil

package/ios/Browser/SearchDrillIn.swift

@@ -20,7 +20,7 @@ enum SearchDrillIn {
   /// yields nothing. Returns nil when nothing is playable.
   static func playable<Item: PlayableSearchItem>(
     from children: [Item],
-    resolveChildren: sending (String) async throws -> [Item]
+    resolveChildren: sending (String) async throws -> [Item],
   ) async throws -> [Item]? {
     guard !children.isEmpty else { return nil }
 

package/ios/CarPlay/RNABMediaAddHandler.swift

@@ -22,8 +22,8 @@ class RNABMediaAddHandler: NSObject, INAddMediaIntentHandling {
   private static let logger = Logger(subsystem: "com.audiobrowser", category: "MediaAddHandler")
 
   func handle(
-    intent: INAddMediaIntent,
-    completion: @escaping @Sendable (INAddMediaIntentResponse) -> Void
+    intent _: INAddMediaIntent,
+    completion: @escaping @Sendable (INAddMediaIntentResponse) -> Void,
   ) {
     Self.logger.info("Add media — favorite current track")
 
@@ -57,7 +57,7 @@ class RNABMediaAddHandler: NSObject, INAddMediaIntentHandling {
   @objc(resolveMediaItemsForAddMedia:withCompletion:)
   func resolveMediaItems(
     for intent: INAddMediaIntent,
-    with completion: @escaping ([INAddMediaMediaItemResolutionResult]) -> Void
+    with completion: @escaping ([INAddMediaMediaItemResolutionResult]) -> Void,
   ) {
     let name = intent.mediaSearch?.mediaName ?? ""
     let item = INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)
@@ -66,10 +66,10 @@ class RNABMediaAddHandler: NSObject, INAddMediaIntentHandling {
 
   @objc(resolveMediaDestinationForAddMedia:withCompletion:)
   func resolveMediaDestination(
-    for intent: INAddMediaIntent,
-    with completion: @escaping (INAddMediaMediaDestinationResolutionResult) -> Void
+    for _: INAddMediaIntent,
+    with completion: @escaping (INAddMediaMediaDestinationResolutionResult) -> Void,
   ) {
     // One flat favorites collection — always the user's library, no playlists.
-      completion(.success(with: INMediaDestination.library))
+    completion(.success(with: INMediaDestination.library))
   }
 }

package/ios/CarPlay/RNABMediaAffinityHandler.swift

@@ -21,7 +21,7 @@ class RNABMediaAffinityHandler: NSObject, INUpdateMediaAffinityIntentHandling {
 
   func handle(
     intent: INUpdateMediaAffinityIntent,
-    completion: @escaping @Sendable (INUpdateMediaAffinityIntentResponse) -> Void
+    completion: @escaping @Sendable (INUpdateMediaAffinityIntentResponse) -> Void,
   ) {
     let affinity = intent.affinityType
     Self.logger.info("Update media affinity — type=\(affinity.rawValue)")
@@ -60,7 +60,7 @@ class RNABMediaAffinityHandler: NSObject, INUpdateMediaAffinityIntentHandling {
   @objc(resolveMediaItemsForUpdateMediaAffinity:withCompletion:)
   func resolveMediaItems(
     for intent: INUpdateMediaAffinityIntent,
-    with completion: @escaping ([INUpdateMediaAffinityMediaItemResolutionResult]) -> Void
+    with completion: @escaping ([INUpdateMediaAffinityMediaItemResolutionResult]) -> Void,
   ) {
     let name = intent.mediaSearch?.mediaName ?? ""
     let item = INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)

package/ios/CarPlay/RNABMediaIntentHandler.swift

@@ -21,7 +21,7 @@ class RNABMediaIntentHandler: NSObject, INPlayMediaIntentHandling {
       mediaTypeMode: Self.mediaTypeMode(s?.mediaType ?? .unknown),
       reference: Self.reference(s?.reference ?? .unknown),
       hasMediaType: (s?.mediaType ?? .unknown) != .unknown,
-      appName: Self.hostAppName()
+      appName: Self.hostAppName(),
     )
     Self.logger.info("Play media intent — query=\(criteria.query) matchesApp=\(criteria.matchesAppName) resume=\(criteria.isResume)")
 
@@ -37,18 +37,18 @@ class RNABMediaIntentHandler: NSObject, INPlayMediaIntentHandling {
   /// `album` are filters, not verticals — they yield no mode.
   private static func mediaTypeMode(_ type: INMediaItemType) -> String? {
     switch type {
-    case .station, .radioStation, .algorithmicRadioStation, .musicStation: return "station"
-    case .podcastShow, .podcastEpisode, .podcastPlaylist, .podcastStation:  return "podcast"
-    case .audioBook:       return "audiobook"
-    case .news:            return "news"
-    case .music:           return "music"
-    case .song:            return "song"
-    case .playlist:        return "playlist"
-    case .musicVideo:      return "music-video"
-    case .movie:           return "movie"
-    case .tvShow:          return "tv-show"
-    case .tvShowEpisode:   return "tv-show-episode"
-    default:               return nil   // album/artist/genre/unknown
+    case .station, .radioStation, .algorithmicRadioStation, .musicStation: "station"
+    case .podcastShow, .podcastEpisode, .podcastPlaylist, .podcastStation: "podcast"
+    case .audioBook: "audiobook"
+    case .news: "news"
+    case .music: "music"
+    case .song: "song"
+    case .playlist: "playlist"
+    case .musicVideo: "music-video"
+    case .movie: "movie"
+    case .tvShow: "tv-show"
+    case .tvShowEpisode: "tv-show-episode"
+    default: nil // album/artist/genre/unknown
     }
   }
 
@@ -56,9 +56,9 @@ class RNABMediaIntentHandler: NSObject, INPlayMediaIntentHandling {
   /// routes to native resume; `.my` to the consumer; everything else is unknown.
   private static func reference(_ ref: INMediaReference) -> MediaIntentCriteria.Reference {
     switch ref {
-    case .currentlyPlaying: return .currentlyPlaying
-    case .my:               return .my
-    default:                return .unknown
+    case .currentlyPlaying: .currentlyPlaying
+    case .my: .my
+    default: .unknown
     }
   }