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

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/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,
+)