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

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

@@ -1,125 +1,156 @@
 package com.audiobrowser.util
 
-import android.content.Context
+import android.net.Uri
 import androidx.core.net.toUri
 import androidx.media3.common.HeartRating
 import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
-import coil3.ImageLoader
+import com.audiobrowser.browser.BrowseArtworkRegistry
+import com.audiobrowser.browser.ResolvedArtwork
+import com.margelo.nitro.audiobrowser.ImageRowItem
 import com.margelo.nitro.audiobrowser.Track
-
+import com.margelo.nitro.audiobrowser.TrackStyle
+import com.margelo.nitro.audiobrowser.Variant_String_ArtworkVariants
+
+/**
+ * The single Track → Media3 [MediaItem] conversion. Owns the two easy-to-drift fallbacks: the
+ * displayed artwork is the transformed `artworkSource.uri` falling back to the raw `artwork` field,
+ * and the mediaId is the stable `id` for playable tracks, falling back to `url` then `src` (a Track
+ * must have one of the latter two — see the `src` vs `url` note in CONTEXT.md). The list line
+ * renders from `subtitle` (the now-playing line is re-stamped from `artist` by the now-playing
+ * pipeline; see the Now Playing Metadata guide).
+ */
 object TrackFactory {
   fun fromMedia3(mediaItem: MediaItem): Track {
     return mediaItem.localConfiguration!!.tag as Track
   }
 
+  /**
+   * 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 ->
+      val items = track.imageRow
+      if (items.isNullOrEmpty()) return@flatMap listOf(track)
+      val expanded = items.map { it.toTrack(groupTitle = track.title) }
+      if (track.url != null) {
+        expanded + track.copy(imageRow = null, groupTitle = track.title)
+      } else {
+        expanded
+      }
+    }
+
+  /** The row-item equivalent of a full Track, for surfaces that render items as plain rows. */
+  fun ImageRowItem.toTrack(groupTitle: String?): Track =
+    Track(
+      id = id,
+      url = url,
+      src = src,
+      artwork = artwork?.let { Variant_String_ArtworkVariants.First(it) },
+      artworkSource = artworkSource,
+      request = request,
+      artworkCarPlayTinted = null,
+      title = title,
+      subtitle = null,
+      artist = artist,
+      albumUrl = albumUrl,
+      album = album,
+      description = null,
+      genre = null,
+      duration = null,
+      style = TrackStyle.GRID,
+      childrenStyle = null,
+      favorited = null,
+      groupTitle = groupTitle,
+      live = live,
+      imageRow = null,
+    )
+
   fun toMedia3(tracks: Array<Track>): List<MediaItem> {
     return tracks.map { toMedia3(it) }
   }
 
-  /**
-   * Converts a Track to a Media3 MediaItem.
-   *
-   * Note: This synchronous version uses setArtworkUri() which doesn't support SVG.
-   * For Android Auto browse items with SVG artwork, use [toMedia3WithSvgSupport] instead.
-   */
   fun toMedia3(track: Track): MediaItem {
-    val extras = MediaExtrasBuilder.build(track)
-
-    // Use transformed artworkSource.uri if available, otherwise fall back to original artwork
-    val artworkUri = track.artworkSource?.uri ?: track.artwork
-
-    val mediaMetadata =
-      MediaMetadata.Builder()
-        .setTitle(track.title)
-        .setArtist(track.artist)
-        .setAlbumTitle(track.album)
-        .setDescription(track.description)
-        .setGenre(track.genre)
-        .setArtworkUri(artworkUri?.toUri())
-        .setIsBrowsable(track.src == null)
-        .setIsPlayable(track.src != null)
-        .setExtras(extras)
-        .apply { track.favorited?.let { setUserRating(HeartRating(it)) } }
-        .build()
-
-    val mediaId =
-      track.url
-        ?: track.src
-        ?: throw IllegalArgumentException(
-          "Track must have either url or src defined. Track: title='${track.title}', artist='${track.artist}'"
-        )
-
-    return MediaItem.Builder()
-      .setMediaId(mediaId)
-      .setUri(track.src)
-      .setMediaMetadata(mediaMetadata)
-      .setTag(track)
-      .build()
+    val metadata = metadataBuilder(track).setArtworkUri(artworkUri(track)?.toUri()).build()
+    return buildMediaItem(track, metadata)
   }
 
   /**
-   * Converts a Track to a Media3 MediaItem with SVG artwork support.
-   *
-   * For SVG artwork URLs, this pre-renders the image to PNG and embeds it
-   * using setArtworkData(). This is necessary for Android Auto which doesn't
-   * support loading SVG images from URLs.
-   *
-   * @param track The track to convert
-   * @param context Android context for image loading
-   * @param imageLoader Coil ImageLoader for SVG rendering
-   * @return MediaItem with embedded artwork for SVGs, or URI-based artwork for other formats
+   * Browse-surface conversion. Routes http(s) artwork through the content:// provider (so headers +
+   * SVG apply in our process, and no bytes cross the Binder), registering it in [registry].
+   * Non-http artwork (android.resource:// tab icons, file://) passes through to setArtworkUri
+   * unchanged so vector/category icons survive. Plain toMedia3 (queue/now-playing) is unaffected.
    */
-  suspend fun toMedia3WithSvgSupport(
+  fun toBrowseMediaItem(
     track: Track,
-    context: Context,
-    imageLoader: ImageLoader,
+    registry: BrowseArtworkRegistry,
+    authority: String,
   ): MediaItem {
-    val extras = MediaExtrasBuilder.build(track)
+    val rawUrl = artworkUri(track) // artworkSource.uri ?: artwork
+    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 token = ArtworkUris.tokenFor(rawUrl)
+      registry.register(token, ResolvedArtwork(rawUrl, track.artworkSource?.headers, isSvg))
+      builder.setArtworkUri(ArtworkUris.contentUri(authority, token).toUri())
+    } else if (rawUrl != null) {
+      builder.setArtworkUri(rawUrl.toUri())
+    }
+    return buildMediaItem(track, builder.build())
+  }
 
-    // Use transformed artworkSource.uri if available, otherwise fall back to original artwork
-    val artworkUrl = track.artworkSource?.uri ?: track.artwork
+  /** The transformed artworkSource wins over the raw artwork field. */
+  private fun artworkUri(track: Track): String? = track.artworkSource?.uri ?: track.artwork?.url
 
-    // Build metadata with SVG support
-    val metadataBuilder = MediaMetadata.Builder()
+  /** All metadata except artwork. */
+  private fun metadataBuilder(track: Track): MediaMetadata.Builder =
+    MediaMetadata.Builder()
       .setTitle(track.title)
-      .setArtist(track.artist)
+      .setArtist(track.subtitle)
       .setAlbumTitle(track.album)
       .setDescription(track.description)
       .setGenre(track.genre)
       .setIsBrowsable(track.src == null)
       .setIsPlayable(track.src != null)
-      .setExtras(extras)
+      .setExtras(MediaExtrasBuilder.build(track))
       .apply { track.favorited?.let { setUserRating(HeartRating(it)) } }
 
-    // Apply artwork with SVG pre-rendering if needed
-    SvgArtworkRenderer.applyArtwork(metadataBuilder, artworkUrl, context, imageLoader)
-
-    val mediaMetadata = metadataBuilder.build()
-
+  private fun buildMediaItem(track: Track, metadata: MediaMetadata): MediaItem {
+    // A playable track's mediaId is the consumer's stable `id` when it has one.
+    // Android Auto marks the "now playing" browse row by exact mediaId equality
+    // between the row and the player's current item (media3 announces
+    // `currentMediaItem.mediaId` in the legacy playback state), and a
+    // consumer-loaded track's `src` can differ textually from the browse row's
+    // for the same item (absolute vs relative, extra query params) — the id is
+    // the one string both sides share. It is also context-free, so the same
+    // station gets the same mediaId in every tab. Browsable-only tracks keep
+    // `url` so navigation parentIds stay resolvable paths.
+    val stableId = if (track.src != null) track.id?.takeUnless { it.isBlank() } else null
     val mediaId =
-      track.url
+      stableId
+        ?: track.url
         ?: track.src
         ?: throw IllegalArgumentException(
           "Track must have either url or src defined. Track: title='${track.title}', artist='${track.artist}'"
         )
-
     return MediaItem.Builder()
       .setMediaId(mediaId)
       .setUri(track.src)
-      .setMediaMetadata(mediaMetadata)
+      // The playable uri also rides in requestMetadata: a controller replaying
+      // this item after process death (track cache empty) round-trips only
+      // mediaId + requestMetadata, and a stable-id mediaId is not playable by
+      // itself — resolveMediaItemToTrack rebuilds a minimal track from this.
+      .setRequestMetadata(
+        MediaItem.RequestMetadata.Builder().setMediaUri(track.src?.toUri()).build()
+      )
+      .setMediaMetadata(metadata)
       .setTag(track)
       .build()
   }
-
-  /**
-   * Converts multiple Tracks to Media3 MediaItems with SVG artwork support.
-   */
-  suspend fun toMedia3WithSvgSupport(
-    tracks: Array<Track>,
-    context: Context,
-    imageLoader: ImageLoader,
-  ): List<MediaItem> {
-    return tracks.map { toMedia3WithSvgSupport(it, context, imageLoader) }
-  }
 }

package/android/src/main/res/values/strings.xml

@@ -3,4 +3,8 @@
     <!-- Error message shown in Android Auto when network is offline -->
     <string name="audio_browser_offline_error">No internet connection</string>
     <string name="audio_browser_offline_error_subtitle">Check your connection and try again</string>
+
+    <!-- Generic error message shown in Android Auto when browsing fails -->
+    <string name="audio_browser_browse_error">Something went wrong</string>
+    <string name="audio_browser_browse_error_subtitle">Please try again later</string>
 </resources>

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

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

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

@@ -0,0 +1,39 @@
+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)
+  }
+}

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

@@ -0,0 +1,114 @@
+package com.audiobrowser.browser
+
+import com.audiobrowser.TestFixtures.transformableConfig
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Assert.fail
+import org.junit.Before
+import org.junit.Test
+
+/**
+ * Tests [BrowserManager.buildApiRequest] — the single request-building path for browse and search
+ * (the Kotlin port of iOS `buildApiRequest`). Static layers only: Nitro Promises
+ * (transforms/resolvers) cannot be constructed on the JVM; transform semantics are covered by
+ * RequestConfigBuilderTest and the Swift suite.
+ */
+class BrowserManagerBuildApiRequestTest {
+
+  private lateinit var bm: BrowserManager
+
+  @Before
+  fun setup() {
+    bm = BrowserManager()
+  }
+
+  @Test
+  fun `layers apply request then kind then route, override-wins`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request =
+          transformableConfig(baseUrl = "https://api.example.com", query = mapOf("a" to "request"))
+      )
+    val request =
+      bm.buildApiRequest(
+        kindConfig = transformableConfig(query = mapOf("a" to "kind", "b" to "kind")),
+        routeConfig = transformableConfig(query = mapOf("b" to "route")),
+        path = "/stations",
+        params = emptyMap(),
+      )
+    assertTrue(request.url, request.url.startsWith("https://api.example.com/stations?"))
+    assertTrue(request.url, request.url.contains("a=kind"))
+    assertTrue(request.url, request.url.contains("b=route"))
+  }
+
+  @Test
+  fun `initialQuery seeds the base so it reaches the final URL`() = runTest {
+    bm.config = BrowserConfig(request = transformableConfig(baseUrl = "https://api.example.com"))
+    val request =
+      bm.buildApiRequest(
+        kindConfig = transformableConfig(query = mapOf("extra" to "1")),
+        routeConfig = null,
+        // The caller seeds the kind's path onto the base (as search does) — a
+        // layer's own static path never applies.
+        path = "/search",
+        params = emptyMap(),
+        initialQuery = mapOf("q" to "jazz", "mode" to "genre"),
+      )
+    assertTrue(request.url, request.url.contains("q=jazz"))
+    assertTrue(request.url, request.url.contains("mode=genre"))
+    assertTrue(request.url, request.url.startsWith("https://api.example.com/search?"))
+  }
+
+  @Test
+  fun `a layer's static path does not override the base path`() = runTest {
+    // Mirrors iOS applyLayer and the web stub: the path is carried from the
+    // base through every Request-Config Layer; only a Transform may change it.
+    bm.config = BrowserConfig(request = transformableConfig(baseUrl = "https://api.example.com"))
+    val request =
+      bm.buildApiRequest(
+        kindConfig = transformableConfig(path = "/kind-path"),
+        routeConfig = transformableConfig(path = "/route-path"),
+        path = "/stations",
+        params = emptyMap(),
+      )
+    assertTrue(request.url, request.url.startsWith("https://api.example.com/stations"))
+  }
+
+  @Test
+  fun `headers merge across layers with later layers winning`() = runTest {
+    bm.config =
+      BrowserConfig(
+        request =
+          transformableConfig(
+            baseUrl = "https://api.example.com",
+            headers = mapOf("x-a" to "request", "x-b" to "request"),
+          )
+      )
+    val request =
+      bm.buildApiRequest(
+        kindConfig = transformableConfig(headers = mapOf("x-b" to "kind")),
+        routeConfig = null,
+        path = "/p",
+        params = emptyMap(),
+      )
+    assertEquals("request", request.headers?.get("x-a"))
+    assertEquals("kind", request.headers?.get("x-b"))
+  }
+
+  @Test
+  fun `missing baseUrl throws ContentNotFoundException`() = runTest {
+    bm.config = BrowserConfig(request = transformableConfig(query = mapOf("a" to "1")))
+    try {
+      bm.buildApiRequest(
+        kindConfig = null,
+        routeConfig = null,
+        path = "/nowhere",
+        params = emptyMap(),
+      )
+      fail("expected ContentNotFoundException")
+    } catch (e: ContentNotFoundException) {
+      assertEquals("/nowhere", e.path)
+    }
+  }
+}