react-native-audio-browser 0.2.0-next.8 → 0.2.0

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

@@ -1,49 +0,0 @@
-package com.audiobrowser.util
-
-import android.content.Context
-import android.graphics.Bitmap
-import coil3.ImageLoader
-import coil3.network.NetworkHeaders
-import coil3.network.httpHeaders
-import coil3.request.ImageRequest
-import coil3.request.allowHardware
-import coil3.svg.SvgDecoder
-import coil3.toBitmap
-
-/**
- * Shared "resolved source → Bitmap" core. Used by both [CoilBitmapLoader] (now-playing) and
- * [ArtworkContentProvider] (browse). Adds `.size()` so raster decodes are downsampled to the hint
- * (the prior loadBitmap path decoded at full resolution). SVG is forced via [isSvg], carried from
- * build time rather than re-derived from a possibly-suffixless transformed URL.
- */
-class CoilArtworkLoader(
-  private val context: Context,
-  private val imageLoader: ImageLoader,
-  private val defaultSizePixels: Int = 512,
-) {
-  suspend fun load(
-    finalUrl: String,
-    headers: Map<String, String>?,
-    sizeHintPixels: Int?,
-    isSvg: Boolean,
-  ): Bitmap {
-    val builder =
-      ImageRequest.Builder(context)
-        .data(finalUrl)
-        .size(sizeHintPixels ?: defaultSizePixels)
-        .allowHardware(false) // required for Media3 notification compatibility
-
-    if (!headers.isNullOrEmpty()) {
-      val net = NetworkHeaders.Builder()
-      headers.forEach { (k, v) -> net.add(k, v) }
-      builder.httpHeaders(net.build())
-    }
-    if (isSvg) {
-      builder.decoderFactory { result, options, _ -> SvgDecoder(result.source, options) }
-    }
-
-    val result = imageLoader.execute(builder.build())
-    return result.image?.toBitmap()
-      ?: throw IllegalStateException("Failed to decode artwork from $finalUrl")
-  }
-}

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

@@ -1,36 +0,0 @@
-package com.audiobrowser.util
-
-import com.audiobrowser.browser.BrowseArtworkRegistry
-import kotlinx.coroutines.CoroutineScope
-
-/** Dependencies the exported [ArtworkContentProvider] needs, published by the media Service. */
-data class ArtworkProviderDeps(
-  val loader: CoilArtworkLoader,
-  val registry: BrowseArtworkRegistry,
-  val scope: CoroutineScope,
-  val artworkSizeHint: () -> Int? = { null },
-)
-
-/**
- * Process-wide handoff between the media Service (which builds the deps) and the ContentProvider
- * (which the OS may instantiate before the Service exists). `@Volatile` publishes the reference
- * safely across the binder/main threads.
- */
-object CoilArtworkLoaderHolder {
-  @Volatile private var deps: ArtworkProviderDeps? = null
-
-  fun set(deps: ArtworkProviderDeps) {
-    this.deps = deps
-  }
-
-  fun get(): ArtworkProviderDeps? = deps
-
-  /**
-   * Clears only if [deps] is still the current one — prevents a stale Service from blanking a
-   * newer.
-   */
-  @Synchronized
-  fun clearIf(deps: ArtworkProviderDeps) {
-    if (this.deps === deps) this.deps = null
-  }
-}

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

@@ -1,211 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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/RatingFavorites.kt

@@ -1,14 +0,0 @@
-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/test/java/com/audiobrowser/TestFixtures.kt

@@ -1,165 +0,0 @@
-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
-import com.margelo.nitro.audiobrowser.ImageSource
-import com.margelo.nitro.audiobrowser.MediaRequestConfig
-import com.margelo.nitro.audiobrowser.Track
-import com.margelo.nitro.audiobrowser.TransformableRequestConfig
-
-/**
- * Shared builders for Nitro structs, whose generated constructors require every field. Tests set
- * only what they assert on; a new Track/config field breaks exactly this file instead of every
- * test.
- */
-object TestFixtures {
-
-  fun track(
-    title: String = "T",
-    id: String? = null,
-    src: String? = "https://s/a.mp3",
-    artwork: String? = null,
-    artist: String? = null,
-    album: String? = null,
-    favorited: Boolean? = null,
-    groupTitle: String? = null,
-    imageRow: Array<ImageRowItem>? = null,
-  ) =
-    Track(
-      id = id,
-      url = null,
-      src = src,
-      artwork = artworkOf(artwork),
-      artworkSource = null,
-      request = null,
-      artworkCarPlayTinted = null,
-      title = title,
-      subtitle = null,
-      artist = artist,
-      albumUrl = null,
-      album = album,
-      description = null,
-      genre = null,
-      duration = null,
-      style = null,
-      childrenStyle = null,
-      favorited = favorited,
-      groupTitle = groupTitle,
-      live = null,
-      imageRow = imageRow,
-    )
-
-  fun imageRowItem(src: String, title: String = src) =
-    ImageRowItem(
-      id = null,
-      url = null,
-      src = src,
-      artwork = null,
-      artworkSource = null,
-      title = title,
-      artist = null,
-      album = null,
-      albumUrl = null,
-      live = null,
-      request = null,
-    )
-
-  fun transformableConfig(
-    baseUrl: String? = null,
-    path: String? = null,
-    query: Map<String, String>? = null,
-    headers: Map<String, String>? = null,
-  ) =
-    TransformableRequestConfig(
-      transform = null,
-      transformSync = null,
-      method = null,
-      path = path,
-      baseUrl = baseUrl,
-      headers = headers,
-      query = query,
-      body = null,
-      contentType = null,
-      userAgent = null,
-    )
-
-  fun mediaConfig(
-    baseUrl: String? = null,
-    path: String? = null,
-    query: Map<String, String>? = null,
-    headers: Map<String, String>? = null,
-  ) =
-    MediaRequestConfig(
-      resolve = null,
-      resolveSync = null,
-      transform = null,
-      transformSync = null,
-      method = null,
-      path = path,
-      baseUrl = baseUrl,
-      headers = headers,
-      query = query,
-      body = null,
-      contentType = null,
-      userAgent = null,
-    )
-
-  /**
-   * Builds a minimal browse-only Track (no src → browsable, not playable). Pass [artworkSource] for
-   * a pre-resolved HTTP artwork URL or [artwork] for a raw resource/file URI; omit both for no
-   * artwork.
-   */
-  fun browseTrack(
-    title: String = "T",
-    url: String = "https://api.example.com/channel/abc",
-    artwork: String? = null,
-    artworkSource: ImageSource? = null,
-  ) =
-    Track(
-      id = null,
-      url = url,
-      src = null, // browsable, not playable
-      artwork = artworkOf(artwork),
-      artworkSource = artworkSource,
-      request = null,
-      artworkCarPlayTinted = null,
-      title = title,
-      subtitle = null,
-      artist = null,
-      albumUrl = null,
-      album = null,
-      description = null,
-      genre = null,
-      duration = null,
-      style = null,
-      childrenStyle = null,
-      favorited = null,
-      groupTitle = null,
-      live = null,
-      imageRow = null,
-    )
-
-  fun artworkConfig(
-    path: String? = null,
-    query: Map<String, String>? = null,
-    headers: Map<String, String>? = null,
-    imageQueryParams: ImageQueryParams? = null,
-  ) =
-    ArtworkRequestConfig(
-      resolve = null,
-      resolveSync = null,
-      transform = null,
-      transformSync = null,
-      imageQueryParams = imageQueryParams,
-      method = null,
-      path = path,
-      baseUrl = null,
-      headers = headers,
-      query = query,
-      body = null,
-      contentType = null,
-      userAgent = null,
-    )
-}

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

@@ -1,46 +0,0 @@
-package com.audiobrowser.browser
-
-import com.audiobrowser.TestFixtures.track
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Test
-
-class ArtworkResolutionRegistryTest {
-
-  @Test
-  fun `lookup returns the registered entry`() {
-    val registry = ArtworkResolutionRegistry()
-    registry.register("https://img/a.png?sig=1", track("a"), perRouteConfig = null)
-    assertEquals("a", registry.lookup("https://img/a.png?sig=1")?.track?.title)
-    assertNull(registry.lookup("https://img/unknown.png"))
-  }
-
-  @Test
-  fun `re-registering a uri overwrites the entry`() {
-    val registry = ArtworkResolutionRegistry()
-    registry.register("u", track("old"), null)
-    registry.register("u", track("new"), null)
-    assertEquals("new", registry.lookup("u")?.track?.title)
-  }
-
-  @Test
-  fun `evicts least-recently-used beyond capacity`() {
-    val registry = ArtworkResolutionRegistry(maxEntries = 2)
-    registry.register("u1", track("t1"), null)
-    registry.register("u2", track("t2"), null)
-    registry.lookup("u1") // touch u1 so u2 is eldest
-    registry.register("u3", track("t3"), null)
-    assertEquals("t1", registry.lookup("u1")?.track?.title)
-    assertNull(registry.lookup("u2"))
-  }
-
-  @Test
-  fun `clear drops all entries`() {
-    val registry = ArtworkResolutionRegistry()
-    registry.register("u1", track("t1"), null)
-    registry.register("u2", track("t2"), null)
-    registry.clear()
-    assertNull(registry.lookup("u1"))
-    assertNull(registry.lookup("u2"))
-  }
-}

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

@@ -1,39 +0,0 @@
-package com.audiobrowser.browser
-
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertNull
-import org.junit.Test
-
-class BrowseArtworkRegistryTest {
-  @Test
-  fun `register then lookup returns the entry`() {
-    val reg = BrowseArtworkRegistry()
-    val art =
-      ResolvedArtwork("https://x/a.png", mapOf("Authorization" to "Bearer t"), isSvg = false)
-    reg.register("tok", art)
-    assertEquals(art, reg.lookup("tok"))
-  }
-
-  @Test
-  fun `lookup of unknown token is null`() {
-    assertNull(BrowseArtworkRegistry().lookup("missing"))
-  }
-
-  @Test
-  fun `clear drops entries`() {
-    val reg = BrowseArtworkRegistry()
-    reg.register("tok", ResolvedArtwork("https://x/a.png", null, false))
-    reg.clear()
-    assertNull(reg.lookup("tok"))
-  }
-
-  @Test
-  fun `evicts oldest beyond capacity`() {
-    val reg = BrowseArtworkRegistry(maxEntries = 2)
-    reg.register("a", ResolvedArtwork("https://x/a", null, false))
-    reg.register("b", ResolvedArtwork("https://x/b", null, false))
-    reg.register("c", ResolvedArtwork("https://x/c", null, false))
-    assertNull(reg.lookup("a")) // evicted
-    assertEquals("https://x/c", reg.lookup("c")?.finalUrl)
-  }
-}