react-native-audio-browser 0.1.1 → 0.2.0-next.10

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

@@ -0,0 +1,38 @@
+package com.audiobrowser
+
+import com.facebook.react.bridge.BaseJavaModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.turbomodule.core.interfaces.TurboModule
+import timber.log.Timber
+
+/**
+ * Tears the live [AudioBrowser] down when the React instance goes away.
+ *
+ * Nitro's `dispose()` is reachable only from an explicit `dispose()` call in JS — it is *not* run
+ * when the runtime is destroyed. Without this, a reload leaves the previous instance registered
+ * with the Service, the process lifecycle and the car-connection observer, so it stays reachable
+ * (and keeps receiving player callbacks over a dead JSI runtime) forever.
+ *
+ * [invalidate] is what React Native calls on instance teardown, so it is the hook that actually
+ * fires. The module exists only for that callback and exposes nothing to JS, so it has to be
+ * created without JS ever asking for it: `TurboModuleManager.invalidate` only invalidates modules
+ * in its holder map, and under bridgeless a module reaches that map eagerly only if it is *both*
+ * `needsEagerInit` and `isTurboModule`
+ * (`ReactPackageTurboModuleManagerDelegate.getEagerInitModuleNames`). Hence the marker interface —
+ * a plain legacy module is created solely on request from JS, which for this one never comes.
+ */
+internal class AudioBrowserLifecycleModule(reactContext: ReactApplicationContext) :
+  BaseJavaModule(reactContext), TurboModule {
+
+  override fun getName(): String = NAME
+
+  override fun invalidate() {
+    Timber.d("React instance going away — disposing the live AudioBrowser")
+    AudioBrowser.disposeCurrent()
+    super.invalidate()
+  }
+
+  companion object {
+    const val NAME: String = "AudioBrowserLifecycle"
+  }
+}

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

@@ -3,14 +3,30 @@ package com.audiobrowser
 import com.facebook.react.TurboReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
 import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.margelo.nitro.audiobrowser.AudioBrowserOnLoad
 
 public class AudioBrowserPackage : TurboReactPackage() {
-  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? = null
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    if (name == AudioBrowserLifecycleModule.NAME) AudioBrowserLifecycleModule(reactContext)
+    else null
 
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider = ReactModuleInfoProvider {
-    emptyMap()
+    mapOf(
+      AudioBrowserLifecycleModule.NAME to
+        ReactModuleInfo(
+          AudioBrowserLifecycleModule.NAME,
+          AudioBrowserLifecycleModule::class.java.name,
+          false, // canOverrideExistingModule
+          // Eager + TurboModule: nothing in JS imports this module, and its only job is the
+          // teardown callback, which never arrives if the module is never created. Both flags are
+          // required for that — see the note on the module.
+          true, // needsEagerInit
+          false, // isCxxModule
+          ReactModuleInfo.classIsTurboModule(AudioBrowserLifecycleModule::class.java),
+        )
+    )
   }
 
   companion object {

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

@@ -2,8 +2,6 @@ package com.audiobrowser
 
 import com.audiobrowser.model.PlayerUpdateOptions
 import com.margelo.nitro.audiobrowser.ChapterMetadata
-import com.margelo.nitro.audiobrowser.TimedMetadata
-import com.margelo.nitro.audiobrowser.TrackMetadata
 import com.margelo.nitro.audiobrowser.EqualizerSettings
 import com.margelo.nitro.audiobrowser.FavoriteChangedEvent
 import com.margelo.nitro.audiobrowser.NowPlayingMetadata
@@ -17,10 +15,11 @@ import com.margelo.nitro.audiobrowser.PlayingState
 import com.margelo.nitro.audiobrowser.RemoteJumpBackwardEvent
 import com.margelo.nitro.audiobrowser.RemoteJumpForwardEvent
 import com.margelo.nitro.audiobrowser.RemoteSeekEvent
-import com.margelo.nitro.audiobrowser.RemoteSetRatingEvent
 import com.margelo.nitro.audiobrowser.RepeatMode
 import com.margelo.nitro.audiobrowser.SleepTimer
+import com.margelo.nitro.audiobrowser.TimedMetadata
 import com.margelo.nitro.audiobrowser.Track
+import com.margelo.nitro.audiobrowser.TrackMetadata
 
 /** Callbacks for all player events. */
 interface Callbacks {
@@ -31,6 +30,8 @@ interface Callbacks {
 
   fun onPlaybackProgressUpdated(event: PlaybackProgressUpdatedEvent)
 
+  fun onPlaybackInterval()
+
   fun onPlaybackPlayWhenReadyChanged(event: PlaybackPlayWhenReadyChangedEvent)
 
   fun onPlaybackPlayingState(event: PlayingState)
@@ -69,9 +70,6 @@ interface Callbacks {
 
   fun handleRemoteSeek(event: RemoteSeekEvent): Boolean
 
-  // Rating events (listener only, not handler)
-  fun onRemoteSetRating(event: RemoteSetRatingEvent)
-
   // Configuration events
   fun onOptionsChanged(options: PlayerUpdateOptions)
 

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

@@ -23,12 +23,19 @@ import coil3.disk.directory
 import coil3.svg.SvgDecoder
 import com.audiobrowser.model.PlayerSetupOptions
 import com.audiobrowser.player.Player
+import com.audiobrowser.util.ArtworkProviderDeps
 import com.audiobrowser.util.BatteryWarningStore
+import com.audiobrowser.util.CoilArtworkLoader
+import com.audiobrowser.util.CoilArtworkLoaderHolder
 import com.audiobrowser.util.CoilBitmapLoader
 import com.margelo.nitro.audiobrowser.AppKilledPlaybackBehavior
+import com.margelo.nitro.audiobrowser.MediaReference
 import com.margelo.nitro.audiobrowser.SearchMode
 import com.margelo.nitro.audiobrowser.SearchParams
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.MainScope
+import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.cancel
 import kotlinx.coroutines.launch
 import timber.log.Timber
@@ -52,7 +59,10 @@ class Service : MediaLibraryService(), MediaSessionService.Listener {
   // Callback for battery warning events to notify JS layer
   var onBatteryWarningPendingChanged: ((Boolean) -> Unit)? = null
 
+  private var artworkProviderDeps: ArtworkProviderDeps? = null
+
   // Headless service binding
+  private var headlessBound = false
   private val headlessConnection: ServiceConnection =
     object : ServiceConnection {
       override fun onServiceConnected(className: ComponentName, service: IBinder) {}
@@ -103,7 +113,7 @@ class Service : MediaLibraryService(), MediaSessionService.Listener {
       CoilBitmapLoader(
         context = this,
         imageLoader = imageLoader,
-        getArtworkConfig = { player.browser?.getArtworkConfig() },
+        resolveDisplayArtwork = { uri, sizeHint -> player.resolveDisplayArtwork(uri, sizeHint) },
         getArtworkSizeHint = { player.artworkSizeHintPixels },
       )
 
@@ -111,6 +121,25 @@ class Service : MediaLibraryService(), MediaSessionService.Listener {
     player.coilBitmapLoader = coilBitmapLoader
     player.imageLoader = imageLoader
 
+    // Populate the artwork content provider holder so ArtworkContentProvider can serve
+    // browse artwork to Android Auto / AAOS over content:// URIs.
+    val artworkScope = CoroutineScope(SupervisorJob() + Dispatchers.IO)
+    artworkProviderDeps =
+      ArtworkProviderDeps(
+        loader = CoilArtworkLoader(this, imageLoader),
+        registry = player.browseArtworkRegistry,
+        scope = artworkScope,
+        artworkSizeHint = { player.artworkSizeHintPixels },
+      )
+    CoilArtworkLoaderHolder.set(artworkProviderDeps!!)
+    // Best-effort: clear stale artwork cache from previous process so the disk doesn't grow
+    // unboundedly across restarts. Fresh files will be re-fetched on demand.
+    runCatching {
+      java.io
+        .File(cacheDir, com.audiobrowser.util.ArtworkContentProvider.ARTWORK_SUBDIR)
+        .deleteRecursively()
+    }
+
     val openAppIntent =
       packageManager.getLaunchIntentForPackage(packageName)?.apply {
         flags = Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
@@ -140,8 +169,8 @@ class Service : MediaLibraryService(), MediaSessionService.Listener {
     // Bind headless service once at startup for JS task execution
     Intent(applicationContext, HeadlessTaskService::class.java).also { headlessIntent ->
       Timber.d("Binding to HeadlessTaskService for JS execution")
-      val bound = bindService(headlessIntent, headlessConnection, BIND_AUTO_CREATE)
-      Timber.d("HeadlessTaskService bind result: $bound")
+      headlessBound = bindService(headlessIntent, headlessConnection, BIND_AUTO_CREATE)
+      Timber.d("HeadlessTaskService bind result: $headlessBound")
     }
   }
 
@@ -182,19 +211,16 @@ class Service : MediaLibraryService(), MediaSessionService.Listener {
     // Get the media focus type (what kind of media to search for)
     val mediaFocus = intent.getStringExtra(MediaStore.EXTRA_MEDIA_FOCUS)
 
-    // Determine search mode based on media focus type
+    // Determine search mode (container vertical) from the media focus. Genre/
+    // artist/album focuses are FILTERS, not verticals — they yield no mode; the
+    // extras below carry them. Android has no station/podcast/etc. focus, so
+    // those verticals are iOS-only.
     val mode =
       when (mediaFocus) {
-        "vnd.android.cursor.item/*" -> {
-          // Generic audio content - could be "play music" or unstructured search
-          if (query.isEmpty()) SearchMode.ANY else null
-        }
-        MediaStore.Audio.Genres.ENTRY_CONTENT_TYPE -> SearchMode.GENRE
-        MediaStore.Audio.Artists.ENTRY_CONTENT_TYPE -> SearchMode.ARTIST
-        MediaStore.Audio.Albums.ENTRY_CONTENT_TYPE -> SearchMode.ALBUM
+        "vnd.android.cursor.item/*" -> if (query.isEmpty()) SearchMode.ANY else null
         "vnd.android.cursor.item/audio" -> SearchMode.SONG
         MediaStore.Audio.Playlists.ENTRY_CONTENT_TYPE -> SearchMode.PLAYLIST
-        else -> null // No media focus or unknown - unstructured search
+        else -> null // genre/artist/album/unknown focus → no vertical
       }
 
     // Extract structured metadata fields
@@ -212,6 +238,7 @@ class Service : MediaLibraryService(), MediaSessionService.Listener {
       album = album,
       title = title,
       playlist = playlist,
+      reference = MediaReference.UNKNOWN,
     )
   }
 
@@ -263,6 +290,7 @@ class Service : MediaLibraryService(), MediaSessionService.Listener {
             }
             player.clear()
             player.stop()
+            tearDownArtworkProvider()
             player.destroy()
             scope.cancel()
             stopForeground(STOP_FOREGROUND_REMOVE)
@@ -285,12 +313,12 @@ class Service : MediaLibraryService(), MediaSessionService.Listener {
   override fun onGetSession(controllerInfo: MediaSession.ControllerInfo): MediaLibrarySession {
     Timber.d("onGetSession requested by: ${controllerInfo.packageName}")
 
-    // Ensure player is properly set up for external controllers like Android Auto
-    // Only call setup if callbacks haven't been installed yet (meaning React Native hasn't
-    // connected)
+    // The player is always set up by onCreate. Don't re-run setup() here for controllers that
+    // connect before React Native does: setup() releases and recreates the ExoPlayer, which would
+    // kill in-progress playback (e.g. playback resumption from a car/Bluetooth controller) when a
+    // second controller connects while JS is still booting.
     if (player.getCallbacks() == null) {
       Timber.w("External controller connecting before React Native setup - using default options")
-      player.setup(PlayerSetupOptions())
     }
 
     return mediaSession
@@ -313,11 +341,32 @@ class Service : MediaLibraryService(), MediaSessionService.Listener {
     onBatteryWarningPendingChanged?.invoke(true)
   }
 
+  /**
+   * Cancels the artwork-provider coroutine scope and clears the Coil loader holder. Idempotent —
+   * safe to call more than once; the second call is a no-op because the field is null after the
+   * first. Must be called BEFORE player.destroy() on every teardown path.
+   */
+  private fun tearDownArtworkProvider() {
+    artworkProviderDeps?.let {
+      it.scope.cancel()
+      CoilArtworkLoaderHolder.clearIf(it)
+    }
+    artworkProviderDeps = null
+  }
+
   override fun onDestroy() {
     Timber.d("onDestroy called")
 
-    // Unbind from HeadlessTaskService to avoid ServiceConnection leak
-    unbindService(headlessConnection)
+    // Unbind from HeadlessTaskService to avoid ServiceConnection leak.
+    // Unbinding a connection that never bound throws IllegalArgumentException.
+    if (headlessBound) {
+      unbindService(headlessConnection)
+      headlessBound = false
+    }
+
+    // Tear down artwork provider deps before player is destroyed so no in-flight
+    // coroutine can deref a torn-down player.
+    tearDownArtworkProvider()
 
     Timber.d("Releasing media session and destroying player")
     if (::mediaSession.isInitialized) {

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

@@ -0,0 +1,48 @@
+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
+    // Marked bound whatever the result: Android registers the connection before it asks the
+    // ActivityManager, so a false return still leaves one to release — "regardless of the return
+    // value, you should later call unbindService()".
+    isBound = true
+    return context.bindService(intent, connection, Context.BIND_AUTO_CREATE)
+  }
+
+  /**
+   * 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/ArtworkResolutionRegistry.kt

@@ -0,0 +1,37 @@
+package com.audiobrowser.browser
+
+import com.margelo.nitro.audiobrowser.ArtworkRequestConfig
+import com.margelo.nitro.audiobrowser.Track
+
+/**
+ * Remembers how an artwork URI was produced (which Track, which artwork-config kind) so the
+ * display-time bitmap loader can re-resolve it Track-first with a real size hint — instead of
+ * re-running the artwork Transform on an already-transformed URL, which is only safe for idempotent
+ * transforms. Bounded LRU; thread-safe (registered from browse coroutines and the now-playing
+ * scope, read from the bitmap loader's IO scope).
+ */
+class ArtworkResolutionRegistry(private val maxEntries: Int = 256) {
+
+  data class Entry(val track: Track, val perRouteConfig: ArtworkRequestConfig?)
+
+  private val entries =
+    object : LinkedHashMap<String, Entry>(16, 0.75f, true) {
+      override fun removeEldestEntry(eldest: MutableMap.MutableEntry<String, Entry>): Boolean =
+        size > maxEntries
+    }
+
+  @Synchronized
+  fun register(uri: String, track: Track, perRouteConfig: ArtworkRequestConfig?) {
+    entries[uri] = Entry(track, perRouteConfig)
+  }
+
+  @Synchronized fun lookup(uri: String): Entry? = entries[uri]
+
+  /**
+   * Drops all entries. Must run whenever the browser config is replaced or content is invalidated:
+   * entries pin Tracks and ArtworkRequestConfigs whose transform/resolve fields are Nitro handles
+   * to JS closures — keeping them past their config's lifetime both retains dead closures and
+   * resolves display-time artwork through stale callbacks.
+   */
+  @Synchronized fun clear() = entries.clear()
+}

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

@@ -0,0 +1,34 @@
+package com.audiobrowser.browser
+
+/**
+ * Token → resolved browse artwork, the [com.audiobrowser.util.ArtworkContentProvider]'s only data
+ * source. Stores plain resolved data (no Track / Nitro handles), so unlike
+ * [ArtworkResolutionRegistry] it pins no JS closures and can be sized generously. Cleared when the
+ * browser config is replaced or content is invalidated. Thread-safe: written from browse
+ * coroutines, read from the provider's IO scope.
+ */
+class BrowseArtworkRegistry(private val maxEntries: Int = 2048) {
+
+  private val entries =
+    object : LinkedHashMap<String, ResolvedArtwork>(16, 0.75f, true) {
+      override fun removeEldestEntry(
+        eldest: MutableMap.MutableEntry<String, ResolvedArtwork>
+      ): Boolean = size > maxEntries
+    }
+
+  @Synchronized
+  fun register(token: String, artwork: ResolvedArtwork) {
+    entries[token] = artwork
+  }
+
+  @Synchronized fun lookup(token: String): ResolvedArtwork? = entries[token]
+
+  @Synchronized fun clear() = entries.clear()
+}
+
+/** Everything the provider needs to fetch one artwork, resolved at browse-build time. */
+data class ResolvedArtwork(
+  val finalUrl: String,
+  val headers: Map<String, String>?,
+  val isSvg: Boolean,
+)