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

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

@@ -11,8 +11,8 @@ import com.margelo.nitro.audiobrowser.TrackMetadata
 sealed class MetadataAdapter {
   companion object {
     /**
-     * Extracts chapter metadata from ID3 ChapterFrames.
-     * Returns a list of ChapterMetadata, one per chapter.
+     * Extracts chapter metadata from ID3 ChapterFrames. Returns a list of ChapterMetadata, one per
+     * chapter.
      */
     fun extractChapters(metadata: Metadata): List<ChapterMetadata> {
       val chapters = mutableListOf<ChapterMetadata>()
@@ -31,7 +31,8 @@ sealed class MetadataAdapter {
             when (val subFrame = entry.getSubFrame(j)) {
               is TextInformationFrame -> {
                 when (subFrame.id.uppercase()) {
-                  "TIT2", "TT2" -> title = subFrame.values.firstOrNull()
+                  "TIT2",
+                  "TT2" -> title = subFrame.values.firstOrNull()
                 }
               }
               is UrlLinkFrame -> {

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

@@ -0,0 +1,211 @@
+package com.audiobrowser.util
+
+import android.content.Context
+import android.media.AudioAttributes
+import android.media.AudioDeviceCallback
+import android.media.AudioDeviceInfo
+import android.media.AudioManager
+import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import androidx.lifecycle.DefaultLifecycleObserver
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.ProcessLifecycleOwner
+import com.margelo.nitro.audiobrowser.Output
+import com.margelo.nitro.audiobrowser.OutputType
+import timber.log.Timber
+
+/**
+ * Monitors the current system audio output — the device audio is **actually being rendered to right
+ * now** — and notifies listeners when it changes.
+ *
+ * On API 33+ the source of truth is [AudioManager.getAudioDevicesForAttributes] for `USAGE_MEDIA`,
+ * which reports the device media audio is *actively routed to*. Crucially this reflects a **manual
+ * reroute** — e.g. moving audio to the phone speaker via the system output switcher while Bluetooth
+ * headphones stay connected — which neither `isBluetoothA2dpOn` nor MediaRouter's selected route
+ * track (both report the merely *connected* device).
+ *
+ * Change detection:
+ * - [AudioDeviceCallback] fires immediately on device connect/disconnect/plug, and stays registered
+ *   the whole time (works in the background too).
+ * - A poll catches a **manual reroute** (the active stream moved to another already-connected
+ *   device via the system output switcher). This is the only way to detect that case, verified the
+ *   hard way: it emits no public event — [AudioDeviceCallback] is device add/remove only,
+ *   `AudioPlaybackCallback` fires on start/stop only, `MediaRouter`'s selected route stays stuck on
+ *   the connected device, and [getAudioDevicesForAttributes] has no public listener. The player's
+ *   `AudioTrack` routing listener would catch it, but only while a track is playing — polling is
+ *   the only mechanism that also works when nothing is playing. The poll runs **only while the app
+ *   is in the foreground** (gated on [ProcessLifecycleOwner]) and fires once immediately on
+ *   foreground entry, so a reroute made while backgrounded is reflected the moment the user
+ *   returns. Each tick is a cheap binder query (no wakelock).
+ *
+ * On API < 33 [getAudioDevicesForAttributes] is unavailable, so we fall back to a coarse heuristic
+ * over the connected output devices; that fallback cannot detect a manual reroute while a device
+ * stays connected (the long-standing limitation).
+ *
+ * Threading: [AudioManager] queries are thread-safe, so [current] recomputes live on read (safe
+ * from the JS thread's `getOutput()`); emitted change events come from the main-thread
+ * callbacks/poll.
+ */
+class OutputMonitor(private val context: Context) : DefaultLifecycleObserver {
+
+  private val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+  private val mainHandler = Handler(Looper.getMainLooper())
+
+  private val mediaAttributes =
+    AudioAttributes.Builder()
+      .setUsage(AudioAttributes.USAGE_MEDIA)
+      .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+      .build()
+
+  // Last emitted value; the change dedupe baseline. Read from any thread.
+  @Volatile private var cached: Output? = null
+
+  private var onOutputChanged: ((Output) -> Unit)? = null
+
+  /** The current audio output, recomputed live, or null when undeterminable. */
+  val current: Output?
+    get() = computeOutput() ?: cached
+
+  fun setOnOutputChanged(callback: (Output) -> Unit) {
+    onOutputChanged = callback
+  }
+
+  private val deviceCallback =
+    object : AudioDeviceCallback() {
+      override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>?) =
+        recompute("device-added")
+
+      override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>?) =
+        recompute("device-removed")
+    }
+
+  // Backstop for manual reroutes, which emit no public event (see class doc).
+  // Only scheduled while in the foreground.
+  private val poll =
+    object : Runnable {
+      override fun run() {
+        recompute("poll")
+        mainHandler.postDelayed(this, POLL_INTERVAL_MS)
+      }
+    }
+
+  /** Begins monitoring. Safe to call from any thread (defers to the main thread). */
+  fun start() {
+    mainHandler.post {
+      audioManager.registerAudioDeviceCallback(deviceCallback, mainHandler)
+      // Delivers onStart synchronously if already foreground, kicking off the poll.
+      ProcessLifecycleOwner.get().lifecycle.addObserver(this)
+    }
+  }
+
+  /** App entered the foreground: read once now, then poll while foregrounded. */
+  override fun onStart(owner: LifecycleOwner) {
+    recompute("foreground")
+    mainHandler.removeCallbacks(poll)
+    mainHandler.postDelayed(poll, POLL_INTERVAL_MS)
+  }
+
+  /** App left the foreground: stop polling (AudioDeviceCallback stays registered). */
+  override fun onStop(owner: LifecycleOwner) {
+    mainHandler.removeCallbacks(poll)
+  }
+
+  /**
+   * Stops monitoring. Must be called from the owner's teardown (AudioBrowser.dispose) so the
+   * callbacks don't leak across JS runtime reloads.
+   */
+  fun destroy() {
+    mainHandler.post {
+      mainHandler.removeCallbacks(poll)
+      ProcessLifecycleOwner.get().lifecycle.removeObserver(this)
+      audioManager.unregisterAudioDeviceCallback(deviceCallback)
+    }
+  }
+
+  private fun recompute(reason: String) {
+    val output = computeOutput() ?: return
+    if (output == cached) return
+    cached = output
+    Timber.d("OutputMonitor [%s]: type=%s name=%s", reason, output.type, output.name)
+    onOutputChanged?.invoke(output)
+  }
+
+  private fun computeOutput(): Output? {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      val device =
+        audioManager.getAudioDevicesForAttributes(mediaAttributes).firstOrNull { it.isSink }
+          ?: return null
+      val type = outputTypeOf(device.type)
+      return Output(type = type, name = deviceName(device, type), external = isExternal(type))
+    }
+    return computeOutputLegacy()
+  }
+
+  /**
+   * API < 33 fallback: pick from the connected output devices. Cannot tell which is *actively*
+   * rendering, so it mirrors the old `isBluetoothA2dpOn` heuristic.
+   */
+  @Suppress("DEPRECATION")
+  private fun computeOutputLegacy(): Output? {
+    val outputs = audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS).filterNotNull()
+    val device =
+      when {
+        audioManager.isBluetoothA2dpOn ->
+          outputs.firstOrNull { outputTypeOf(it.type) == OutputType.BLUETOOTH }
+        else ->
+          outputs.firstOrNull { outputTypeOf(it.type) == OutputType.HEADPHONES }
+            ?: outputs.firstOrNull { it.type == AudioDeviceInfo.TYPE_BUILTIN_SPEAKER }
+      } ?: return null
+    val type = outputTypeOf(device.type)
+    return Output(type = type, name = deviceName(device, type), external = isExternal(type))
+  }
+
+  private fun deviceName(device: AudioDeviceInfo, type: OutputType): String =
+    device.productName?.toString()?.ifBlank { null } ?: defaultName(type)
+
+  private fun isExternal(type: OutputType): Boolean =
+    type != OutputType.SPEAKER && type != OutputType.RECEIVER
+
+  private fun defaultName(type: OutputType): String =
+    when (type) {
+      OutputType.BLUETOOTH -> "Bluetooth"
+      OutputType.HEADPHONES -> "Headphones"
+      OutputType.USB -> "USB"
+      OutputType.HDMI -> "HDMI"
+      OutputType.RECEIVER -> "Earpiece"
+      else -> "Phone speaker"
+    }
+
+  companion object {
+    private const val POLL_INTERVAL_MS = 1000L
+
+    /** Maps an [AudioDeviceInfo] type to a cross-platform [OutputType]. */
+    fun outputTypeOf(deviceType: Int): OutputType =
+      when (deviceType) {
+        AudioDeviceInfo.TYPE_BLUETOOTH_A2DP,
+        AudioDeviceInfo.TYPE_BLE_HEADSET,
+        AudioDeviceInfo.TYPE_BLE_SPEAKER,
+        AudioDeviceInfo.TYPE_BLE_BROADCAST,
+        AudioDeviceInfo.TYPE_HEARING_AID -> OutputType.BLUETOOTH
+
+        AudioDeviceInfo.TYPE_WIRED_HEADPHONES,
+        AudioDeviceInfo.TYPE_WIRED_HEADSET,
+        AudioDeviceInfo.TYPE_USB_HEADSET -> OutputType.HEADPHONES
+
+        AudioDeviceInfo.TYPE_USB_DEVICE,
+        AudioDeviceInfo.TYPE_USB_ACCESSORY -> OutputType.USB
+
+        AudioDeviceInfo.TYPE_HDMI,
+        AudioDeviceInfo.TYPE_HDMI_ARC,
+        AudioDeviceInfo.TYPE_HDMI_EARC -> OutputType.HDMI
+
+        AudioDeviceInfo.TYPE_BUILTIN_EARPIECE -> OutputType.RECEIVER
+
+        AudioDeviceInfo.TYPE_BUILTIN_SPEAKER,
+        AudioDeviceInfo.TYPE_BUILTIN_SPEAKER_SAFE -> OutputType.SPEAKER
+
+        else -> OutputType.OTHER
+      }
+  }
+}

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

@@ -0,0 +1,58 @@
+package com.audiobrowser.util
+
+import android.content.Context
+import android.content.Intent
+import android.media.MediaRouter2
+import android.os.Build
+import timber.log.Timber
+
+/**
+ * Presents the system audio **Output Switcher** — the picker users know from the media
+ * notification: paired Bluetooth devices, the phone speaker, wired output, Cast targets.
+ * System-rendered; the app does not own its look.
+ *
+ * Availability is Android 11+ (API 30, [isSupported]): API 34+ has the direct
+ * `MediaRouter2.showSystemOutputSwitcher()` call, and API 30–33 open the `MEDIA_OUTPUT` settings
+ * panel. Below 30 there is no system switcher, so callers should hide the control rather than call
+ * [open] (which no-ops + logs).
+ *
+ * (Android, unlike iOS, does not let an app force media to an arbitrary specific Bluetooth device —
+ * route selection is the system's job, which is exactly what this switcher hands off to.)
+ */
+object OutputSwitcher {
+  fun isSupported(): Boolean = Build.VERSION.SDK_INT >= Build.VERSION_CODES.R
+
+  fun open(context: Context) {
+    when {
+      Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE -> {
+        // API 34+: the framework call. Returns false if it couldn't be shown
+        // (e.g. no eligible routes); fall back to the settings panel.
+        val shown =
+          runCatching { MediaRouter2.getInstance(context).showSystemOutputSwitcher() }
+            .getOrDefault(false)
+        if (!shown) openSettingsPanel(context)
+      }
+      Build.VERSION.SDK_INT >= Build.VERSION_CODES.R -> openSettingsPanel(context)
+      else -> Timber.w("OutputSwitcher.open ignored: system switcher needs Android 11+")
+    }
+  }
+
+  // The MEDIA_OUTPUT settings panel (the rich switcher on Android 11+). There is
+  // no public SDK constant for this action below API 34 — apps use the framework
+  // settings-panel action string. Launched from the application context, so it
+  // needs NEW_TASK. The package extra scopes the switcher to this app's media
+  // routing; harmless if the panel ignores it.
+  private fun openSettingsPanel(context: Context) {
+    val intent =
+      Intent(ACTION_MEDIA_OUTPUT)
+        .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        .putExtra(EXTRA_OUTPUT_SWITCHER_PACKAGE, context.packageName)
+    runCatching { context.startActivity(intent) }
+      .onFailure { Timber.e(it, "OutputSwitcher: failed to open MEDIA_OUTPUT panel") }
+  }
+
+  // Framework settings-panel action + package extra for the media-output switcher.
+  // Not public SDK symbols — verify on device.
+  private const val ACTION_MEDIA_OUTPUT = "com.android.settings.panel.action.MEDIA_OUTPUT"
+  private const val EXTRA_OUTPUT_SWITCHER_PACKAGE = "com.android.settings.panel.extra.PACKAGE_NAME"
+}

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

@@ -16,7 +16,8 @@ object PlayingStateFactory {
       playWhenReady &&
         !(playbackState == PlaybackState.ERROR ||
           playbackState == PlaybackState.ENDED ||
-          playbackState == PlaybackState.NONE)
+          playbackState == PlaybackState.NONE ||
+          playbackState == PlaybackState.STOPPED)
     val buffering =
       playWhenReady &&
         (playbackState == PlaybackState.LOADING || playbackState == PlaybackState.BUFFERING)

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

@@ -0,0 +1,14 @@
+package com.audiobrowser.util
+
+import androidx.media3.common.HeartRating
+import androidx.media3.common.Rating
+
+/**
+ * Maps a Media3 [Rating] arriving from a controller (e.g. Google Assistant "I like this") to a
+ * favorite intent. Only an explicitly-rated heart carries favorite intent: a thumbs / star /
+ * percentage rating, or an unrated (cleared) heart, returns null — no favorite change.
+ */
+object RatingFavorites {
+  fun favoritedFor(rating: Rating): Boolean? =
+    (rating as? HeartRating)?.takeIf { it.isRated }?.isHeart
+}

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

@@ -1,36 +1,18 @@
 package com.audiobrowser.util
 
-import android.content.Context
-import android.graphics.Bitmap
 import android.net.Uri
-import androidx.media3.common.MediaMetadata
-import coil3.ImageLoader
-import coil3.request.ImageRequest
-import coil3.request.allowHardware
-import coil3.svg.SvgDecoder
-import coil3.toBitmap
-import java.io.ByteArrayOutputStream
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.withContext
-import timber.log.Timber
 
 /**
- * Utility for pre-rendering SVG artwork to bitmaps for Android Auto compatibility.
+ * Utility for SVG artwork detection.
  *
- * Android Auto loads artwork from URLs directly and doesn't support SVG format.
- * This class pre-renders SVG images to PNG bitmaps that can be embedded in MediaMetadata
- * using setArtworkData().
- *
- * Note: SVGs are rendered as-is without tinting. Content providers should provide
- * appropriately colored icons for Android Auto's dark UI (e.g., white icons).
+ * Artwork delivery for Android Auto browse items is handled via the content:// provider
+ * (ArtworkContentProvider + CoilArtworkLoader), which supports SVG natively in-process. This object
+ * retains [isSvgUrl] which is still used by [TrackFactory.toBrowseMediaItem] and
+ * [CoilArtworkLoader] to tag registrations with the correct decoder hint.
  */
 object SvgArtworkRenderer {
 
-  private const val DEFAULT_SIZE = 256 // Default size for rendered SVGs
-
-  /**
-   * Checks if a URL points to an SVG image.
-   */
+  /** Checks if a URL points to an SVG image. */
   fun isSvgUrl(url: String?): Boolean {
     if (url == null) return false
     return try {
@@ -40,91 +22,4 @@ object SvgArtworkRenderer {
       false
     }
   }
-
-  /**
-   * Pre-renders an SVG URL to PNG bitmap bytes.
-   *
-   * The SVG is rendered as-is without color modification. Content providers
-   * should provide icons in the appropriate color for the target UI (e.g.,
-   * white icons for Android Auto's dark background).
-   *
-   * @param context Android context
-   * @param imageLoader Coil ImageLoader instance
-   * @param url The SVG URL to render
-   * @param size Target size in pixels (width and height)
-   * @return PNG bitmap bytes, or null if rendering fails
-   */
-  suspend fun renderSvgToBytes(
-    context: Context,
-    imageLoader: ImageLoader,
-    url: String,
-    size: Int = DEFAULT_SIZE,
-  ): ByteArray? = withContext(Dispatchers.IO) {
-    try {
-      Timber.d("Pre-rendering SVG: $url")
-
-      val request = ImageRequest.Builder(context)
-        .data(url)
-        .size(size)
-        .allowHardware(false)
-        .decoderFactory { result, options, _ ->
-          SvgDecoder(result.source, options)
-        }
-        .build()
-
-      val result = imageLoader.execute(request)
-      val bitmap = result.image?.toBitmap()
-
-      if (bitmap != null) {
-        Timber.d("SVG rendered successfully: ${bitmap.width}x${bitmap.height}")
-
-        val stream = ByteArrayOutputStream()
-        bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream)
-        stream.toByteArray()
-      } else {
-        Timber.e("Failed to render SVG: result.image was null")
-        null
-      }
-    } catch (e: Exception) {
-      Timber.e(e, "Error pre-rendering SVG: $url")
-      null
-    }
-  }
-
-  /**
-   * Applies artwork to MediaMetadata.Builder, pre-rendering SVGs as needed.
-   *
-   * For SVG URLs, this renders the image to PNG and uses setArtworkData().
-   * For other URLs, this uses setArtworkUri() as normal.
-   *
-   * @param builder The MediaMetadata.Builder to modify
-   * @param artworkUrl The artwork URL (may be SVG or other format)
-   * @param context Android context (required for SVG rendering)
-   * @param imageLoader Coil ImageLoader (required for SVG rendering)
-   * @return The modified builder
-   */
-  suspend fun applyArtwork(
-    builder: MediaMetadata.Builder,
-    artworkUrl: String?,
-    context: Context?,
-    imageLoader: ImageLoader?,
-  ): MediaMetadata.Builder {
-    if (artworkUrl == null) {
-      return builder
-    }
-
-    // Check if this is an SVG that needs pre-rendering
-    if (isSvgUrl(artworkUrl) && context != null && imageLoader != null) {
-      val bytes = renderSvgToBytes(context, imageLoader, artworkUrl)
-      if (bytes != null) {
-        Timber.d("Using pre-rendered SVG artwork (${bytes.size} bytes)")
-        return builder.setArtworkData(bytes, MediaMetadata.PICTURE_TYPE_FRONT_COVER)
-      }
-      // Fall through to setArtworkUri if rendering fails
-      Timber.w("SVG pre-rendering failed, falling back to URI")
-    }
-
-    // Use URI for non-SVG or if SVG rendering failed
-    return builder.setArtworkUri(Uri.parse(artworkUrl))
-  }
 }

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

@@ -9,8 +9,8 @@ import android.media.AudioManager
 /**
  * Monitors system volume state and notifies listeners when the volume changes.
  *
- * Uses a BroadcastReceiver for VOLUME_CHANGED_ACTION to detect volume changes.
- * Reports volume as a normalized value between 0.0 and 1.0.
+ * Uses a BroadcastReceiver for VOLUME_CHANGED_ACTION to detect volume changes. Reports volume as a
+ * normalized value between 0.0 and 1.0.
  */
 class SystemVolumeMonitor(private val context: Context) {
   private val audioManager = context.getSystemService(Context.AUDIO_SERVICE) as AudioManager
@@ -35,16 +35,30 @@ class SystemVolumeMonitor(private val context: Context) {
     return if (maxVolume > 0) currentVolume.toDouble() / maxVolume else 0.0
   }
 
-  private val volumeReceiver = object : BroadcastReceiver() {
-    override fun onReceive(context: Context, intent: Intent) {
-      val streamType = intent.getIntExtra("android.media.EXTRA_VOLUME_STREAM_TYPE", -1)
-      if (streamType == AudioManager.STREAM_MUSIC) {
-        onVolumeChanged?.invoke(getCurrentVolume())
+  private val volumeReceiver =
+    object : BroadcastReceiver() {
+      override fun onReceive(context: Context, intent: Intent) {
+        val streamType = intent.getIntExtra("android.media.EXTRA_VOLUME_STREAM_TYPE", -1)
+        if (streamType == AudioManager.STREAM_MUSIC) {
+          onVolumeChanged?.invoke(getCurrentVolume())
+        }
       }
     }
-  }
 
   init {
     context.registerReceiver(volumeReceiver, IntentFilter("android.media.VOLUME_CHANGED_ACTION"))
   }
+
+  /**
+   * Unregisters the volume receiver. Must be called when the owner is torn down
+   * (AudioBrowser.dispose) — without it the receiver leaks across JS runtime reloads. Safe to call
+   * more than once.
+   */
+  fun destroy() {
+    try {
+      context.unregisterReceiver(volumeReceiver)
+    } catch (_: IllegalArgumentException) {
+      // already unregistered
+    }
+  }
 }