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

package/android/src/test/java/com/audiobrowser/util/ArtworkUrisTest.kt

@@ -0,0 +1,34 @@
+package com.audiobrowser.util
+
+import android.net.Uri
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class ArtworkUrisTest {
+  @Test
+  fun `tokenFor is deterministic and opaque`() {
+    val url = "https://cdn.example.com/a.png?sig=abc&x=1"
+    assertEquals(ArtworkUris.tokenFor(url), ArtworkUris.tokenFor(url))
+    // token does not leak the url
+    assert(!ArtworkUris.tokenFor(url).contains("cdn.example.com"))
+  }
+
+  @Test
+  fun `contentUri round-trips through parseToken`() {
+    val authority = ArtworkUris.authorityFor("com.myapp")
+    val token = ArtworkUris.tokenFor("https://cdn.example.com/a.svg")
+    val uri = ArtworkUris.contentUri(authority, token)
+    assertEquals("content://com.myapp.audiobrowser.artwork/art/$token", uri)
+    assertEquals(token, ArtworkUris.parseToken(Uri.parse(uri)))
+  }
+
+  @Test
+  fun `parseToken rejects malformed uris`() {
+    assertNull(ArtworkUris.parseToken(Uri.parse("content://com.myapp.audiobrowser.artwork/nope")))
+    assertNull(ArtworkUris.parseToken(Uri.parse("https://example.com/art/x")))
+  }
+}

package/android/src/test/java/com/audiobrowser/util/BrowserPathHelperTest.kt

@@ -0,0 +1,28 @@
+package com.audiobrowser.util
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class BrowserPathHelperTest {
+
+  @Test
+  fun `containsSegment matches a uid as a full path segment`() {
+    val path = "/listen/amsterdam-funk-channel/Gw0LGB8j"
+    assertTrue(BrowserPathHelper.containsSegment(path, "Gw0LGB8j"))
+    assertTrue(BrowserPathHelper.containsSegment(path, "amsterdam-funk-channel"))
+    assertTrue(BrowserPathHelper.containsSegment(path, "listen"))
+    assertTrue(BrowserPathHelper.containsSegment("/listen/x/Gw0LGB8j?hl=en", "Gw0LGB8j"))
+    assertTrue(BrowserPathHelper.containsSegment("/listen/x/Gw0LGB8j#frag", "Gw0LGB8j"))
+  }
+
+  @Test
+  fun `containsSegment rejects partial-segment and missing matches`() {
+    val path = "/listen/amsterdam-funk-channel/Gw0LGB8j"
+    assertFalse(BrowserPathHelper.containsSegment(path, "Gw0LGB8"))
+    assertFalse(BrowserPathHelper.containsSegment(path, "funk"))
+    assertFalse(BrowserPathHelper.containsSegment(path, "msterdam-funk-channe"))
+    assertFalse(BrowserPathHelper.containsSegment(path, "NopeNope"))
+    assertFalse(BrowserPathHelper.containsSegment(path, ""))
+  }
+}

package/android/src/test/java/com/audiobrowser/util/CoilArtworkLoaderHolderTest.kt

@@ -0,0 +1,53 @@
+package com.audiobrowser.util
+
+import android.graphics.Bitmap
+import com.audiobrowser.browser.BrowseArtworkRegistry
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import org.junit.After
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertSame
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class CoilArtworkLoaderHolderTest {
+  private fun deps() =
+    ArtworkProviderDeps(
+      loader =
+        CoilArtworkLoader(
+          RuntimeEnvironment.getApplication(),
+          FakeImageLoader(
+            RuntimeEnvironment.getApplication(),
+            Bitmap.createBitmap(1, 1, Bitmap.Config.RGB_565),
+          ) {},
+        ),
+      registry = BrowseArtworkRegistry(),
+      scope = CoroutineScope(Dispatchers.Unconfined),
+    )
+
+  @After
+  fun tearDown() =
+    CoilArtworkLoaderHolder.get()?.let { CoilArtworkLoaderHolder.clearIf(it) } ?: Unit
+
+  @Test
+  fun `get returns what was set`() {
+    val d = deps()
+    CoilArtworkLoaderHolder.set(d)
+    assertSame(d, CoilArtworkLoaderHolder.get())
+  }
+
+  @Test
+  fun `clearIf only clears the matching instance`() {
+    val first = deps()
+    val second = deps()
+    CoilArtworkLoaderHolder.set(first)
+    CoilArtworkLoaderHolder.set(second)
+    CoilArtworkLoaderHolder.clearIf(first) // stale instance — must NOT clear
+    assertSame(second, CoilArtworkLoaderHolder.get())
+    CoilArtworkLoaderHolder.clearIf(second)
+    assertNull(CoilArtworkLoaderHolder.get())
+  }
+}

package/android/src/test/java/com/audiobrowser/util/CoilArtworkLoaderTest.kt

@@ -0,0 +1,58 @@
+package com.audiobrowser.util
+
+import android.graphics.Bitmap
+import coil3.network.httpHeaders
+import coil3.request.ImageRequest
+import coil3.size.Dimension
+import coil3.size.Size
+import kotlinx.coroutines.test.runTest
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class CoilArtworkLoaderTest {
+  @Test
+  fun `load applies size hint and headers to the request`() = runTest {
+    val context = RuntimeEnvironment.getApplication()
+    var captured: ImageRequest? = null
+    val fakeBitmap = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888)
+    // FakeImageLoader records the request and returns a known bitmap.
+    val imageLoader = FakeImageLoader(context, fakeBitmap) { captured = it }
+
+    val loader = CoilArtworkLoader(context, imageLoader, defaultSizePixels = 512)
+    val bmp =
+      loader.load(
+        finalUrl = "https://cdn.example.com/a.png",
+        headers = mapOf("Authorization" to "Bearer t"),
+        sizeHintPixels = 256,
+        isSvg = false,
+      )
+
+    assertEquals(fakeBitmap, bmp)
+    assertNotNull(captured)
+    // data is the finalUrl
+    assertEquals("https://cdn.example.com/a.png", captured!!.data)
+    // OOM-prevention downsample: .size(256) must have been applied
+    assertEquals(Size(Dimension.Pixels(256), Dimension.Pixels(256)), captured!!.sizeResolver.size())
+    // Custom headers must reach the request via httpHeaders extras
+    assertEquals("Bearer t", captured!!.httpHeaders["Authorization"])
+  }
+
+  @Test
+  fun `load falls back to default size when hint is null`() = runTest {
+    val context = RuntimeEnvironment.getApplication()
+    var captured: ImageRequest? = null
+    val fakeBitmap = Bitmap.createBitmap(8, 8, Bitmap.Config.ARGB_8888)
+    val imageLoader = FakeImageLoader(context, fakeBitmap) { captured = it }
+    val loader = CoilArtworkLoader(context, imageLoader, defaultSizePixels = 512)
+    val bmp = loader.load("https://cdn.example.com/a.png", null, null, false)
+    assertEquals(fakeBitmap, bmp)
+    assertNotNull(captured)
+    // When sizeHintPixels is null, defaultSizePixels (512) must be used
+    assertEquals(Size(Dimension.Pixels(512), Dimension.Pixels(512)), captured!!.sizeResolver.size())
+  }
+}

package/android/src/test/java/com/audiobrowser/util/FakeImageLoader.kt

@@ -0,0 +1,57 @@
+package com.audiobrowser.util
+
+import android.content.Context
+import android.graphics.Bitmap
+import coil3.ComponentRegistry
+import coil3.ImageLoader
+import coil3.asImage
+import coil3.disk.DiskCache
+import coil3.memory.MemoryCache
+import coil3.request.Disposable
+import coil3.request.ImageRequest
+import coil3.request.ImageResult
+import coil3.request.SuccessResult
+import kotlinx.coroutines.CompletableDeferred
+
+/**
+ * Minimal [ImageLoader] test double. Records each executed [ImageRequest] via [onRequest] and
+ * returns a [SuccessResult] wrapping [fakeBitmap].
+ */
+class FakeImageLoader(
+  private val context: Context,
+  private val fakeBitmap: Bitmap,
+  private val onRequest: (ImageRequest) -> Unit,
+) : ImageLoader {
+
+  override val defaults: ImageRequest.Defaults = ImageRequest.Defaults.DEFAULT
+
+  override val components: ComponentRegistry = ComponentRegistry()
+
+  override val memoryCache: MemoryCache? = null
+
+  override val diskCache: DiskCache? = null
+
+  override suspend fun execute(request: ImageRequest): ImageResult {
+    onRequest(request)
+    return SuccessResult(image = fakeBitmap.asImage(), request = request)
+  }
+
+  override fun enqueue(request: ImageRequest): Disposable {
+    val deferred =
+      CompletableDeferred<ImageResult>(
+        SuccessResult(image = fakeBitmap.asImage(), request = request)
+      )
+    return object : Disposable {
+      override val isDisposed: Boolean
+        get() = true
+
+      override fun dispose() {}
+
+      override val job = deferred
+    }
+  }
+
+  override fun shutdown() {}
+
+  override fun newBuilder(): ImageLoader.Builder = ImageLoader.Builder(context)
+}

package/android/src/test/java/com/audiobrowser/util/PlayingStateFactoryTest.kt

@@ -0,0 +1,40 @@
+package com.audiobrowser.util
+
+import com.margelo.nitro.audiobrowser.PlaybackState
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Truth table for the PlayingState derivation — the single transition function behind
+ * `onPlaybackPlayingState` (see Player.refreshPlayingState, its only production caller path).
+ */
+class PlayingStateFactoryTest {
+
+  @Test
+  fun `playWhenReady false is never playing nor buffering`() {
+    for (state in PlaybackState.entries) {
+      val derived = PlayingStateFactory.derive(playWhenReady = false, playbackState = state)
+      assertEquals("playing for $state", false, derived.playing)
+      assertEquals("buffering for $state", false, derived.buffering)
+    }
+  }
+
+  @Test
+  fun `playWhenReady true plays except in terminal or empty states`() {
+    val notPlaying =
+      setOf(PlaybackState.ERROR, PlaybackState.ENDED, PlaybackState.NONE, PlaybackState.STOPPED)
+    for (state in PlaybackState.entries) {
+      val derived = PlayingStateFactory.derive(playWhenReady = true, playbackState = state)
+      assertEquals("playing for $state", state !in notPlaying, derived.playing)
+    }
+  }
+
+  @Test
+  fun `buffering only while loading or rebuffering with playWhenReady`() {
+    val buffering = setOf(PlaybackState.LOADING, PlaybackState.BUFFERING)
+    for (state in PlaybackState.entries) {
+      val derived = PlayingStateFactory.derive(playWhenReady = true, playbackState = state)
+      assertEquals("buffering for $state", state in buffering, derived.buffering)
+    }
+  }
+}

package/android/src/test/java/com/audiobrowser/util/RatingFavoritesTest.kt

@@ -0,0 +1,34 @@
+package com.audiobrowser.util
+
+import androidx.media3.common.HeartRating
+import androidx.media3.common.StarRating
+import androidx.media3.common.ThumbRating
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class RatingFavoritesTest {
+  @Test
+  fun `rated heart up maps to favorited true`() {
+    assertEquals(true, RatingFavorites.favoritedFor(HeartRating(true)))
+  }
+
+  @Test
+  fun `rated heart down maps to favorited false`() {
+    assertEquals(false, RatingFavorites.favoritedFor(HeartRating(false)))
+  }
+
+  @Test
+  fun `unrated heart carries no favorite intent`() {
+    assertNull(RatingFavorites.favoritedFor(HeartRating()))
+  }
+
+  @Test
+  fun `non-heart ratings carry no favorite intent`() {
+    assertNull(RatingFavorites.favoritedFor(ThumbRating(true)))
+    assertNull(RatingFavorites.favoritedFor(StarRating(5, 4f)))
+  }
+}

package/android/src/test/java/com/audiobrowser/util/TrackFactoryBrowseTest.kt

@@ -0,0 +1,50 @@
+package com.audiobrowser.util
+
+import android.net.Uri
+import com.audiobrowser.TestFixtures
+import com.audiobrowser.browser.BrowseArtworkRegistry
+import com.margelo.nitro.audiobrowser.ImageSource
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class TrackFactoryBrowseTest {
+  private val authority = ArtworkUris.authorityFor("com.test")
+
+  @Test
+  fun `http artwork is wrapped in a content uri and registered`() {
+    val reg = BrowseArtworkRegistry()
+    val track =
+      TestFixtures.browseTrack(
+        artworkSource =
+          ImageSource(
+            uri = "https://cdn/a.svg",
+            method = null,
+            headers = mapOf("Authorization" to "Bearer t"),
+            body = null,
+          )
+      )
+    val item = TrackFactory.toBrowseMediaItem(track, reg, authority)
+
+    val artUri = Uri.parse(item.mediaMetadata.artworkUri.toString())
+    assertEquals("content", artUri.scheme)
+    val token = ArtworkUris.parseToken(artUri)
+    assertNotNull(token)
+    val entry = reg.lookup(token!!)!!
+    assertEquals("https://cdn/a.svg", entry.finalUrl)
+    assertEquals("Bearer t", entry.headers!!["Authorization"])
+    assertEquals(true, entry.isSvg) // detected from the .svg url
+  }
+
+  @Test
+  fun `android resource artwork is passed through unchanged`() {
+    val reg = BrowseArtworkRegistry()
+    val resUri = "android.resource://com.test/drawable/ic_folder"
+    val track = TestFixtures.browseTrack(artwork = resUri, artworkSource = null)
+    val item = TrackFactory.toBrowseMediaItem(track, reg, authority)
+    assertEquals(resUri, item.mediaMetadata.artworkUri.toString())
+  }
+}

package/android/src/test/java/com/audiobrowser/util/TrackFactoryMediaIdTest.kt

@@ -0,0 +1,63 @@
+package com.audiobrowser.util
+
+import com.audiobrowser.TestFixtures
+import org.junit.Assert.assertEquals
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * The mediaId is the item's identity on car surfaces: Android Auto marks the "now playing" browse
+ * row by exact mediaId equality between rows and the player's current item, so a playable track
+ * with a stable `id` must use it on both — a consumer-loaded track's `src` can differ textually
+ * from the browse row's for the same item.
+ */
+@RunWith(RobolectricTestRunner::class)
+class TrackFactoryMediaIdTest {
+
+  @Test
+  fun `playable track with id uses the stable id as mediaId`() {
+    val track = TestFixtures.track(id = "abc123", src = "/listen/abc123/channel.mp3")
+    assertEquals("abc123", TrackFactory.toMedia3(track).mediaId)
+  }
+
+  @Test
+  fun `stable id wins over the contextual url for playable tracks`() {
+    val track =
+      TestFixtures.track(id = "abc123", src = "/listen/abc123/channel.mp3")
+        .copy(url = "/home?__trackId=%2Flisten%2Fabc123%2Fchannel.mp3")
+    assertEquals("abc123", TrackFactory.toMedia3(track).mediaId)
+  }
+
+  @Test
+  fun `playable track without id falls back to url then src`() {
+    val withUrl = TestFixtures.track(src = "/a.mp3").copy(url = "/home?__trackId=%2Fa.mp3")
+    assertEquals("/home?__trackId=%2Fa.mp3", TrackFactory.toMedia3(withUrl).mediaId)
+
+    val srcOnly = TestFixtures.track(src = "/a.mp3")
+    assertEquals("/a.mp3", TrackFactory.toMedia3(srcOnly).mediaId)
+  }
+
+  @Test
+  fun `browsable-only track keeps url as mediaId even with an id`() {
+    // Navigation parentIds must stay resolvable paths, so a container's id is
+    // never its mediaId.
+    val track = TestFixtures.browseTrack(url = "/stations").copy(id = "abc123")
+    assertEquals("/stations", TrackFactory.toMedia3(track).mediaId)
+  }
+
+  @Test
+  fun `blank id is ignored`() {
+    val track = TestFixtures.track(id = " ", src = "/a.mp3")
+    assertEquals("/a.mp3", TrackFactory.toMedia3(track).mediaId)
+  }
+
+  @Test
+  fun `playable uri rides in requestMetadata for replay after process death`() {
+    val track = TestFixtures.track(id = "abc123", src = "https://s/a.mp3")
+    assertEquals(
+      "https://s/a.mp3",
+      TrackFactory.toMedia3(track).requestMetadata.mediaUri.toString(),
+    )
+  }
+}

package/android/src/test/java/com/audiobrowser/util/TrackFactoryRatingTest.kt

@@ -0,0 +1,35 @@
+package com.audiobrowser.util
+
+import androidx.media3.common.HeartRating
+import com.audiobrowser.TestFixtures
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class TrackFactoryRatingTest {
+  @Test
+  fun `favorited true advertises a rated, hearted userRating`() {
+    val item = TrackFactory.toMedia3(TestFixtures.track(favorited = true))
+    val rating = item.mediaMetadata.userRating as HeartRating
+    assertTrue(rating.isRated)
+    assertTrue(rating.isHeart)
+  }
+
+  @Test
+  fun `favorited false advertises a rated, un-hearted userRating`() {
+    val item = TrackFactory.toMedia3(TestFixtures.track(favorited = false))
+    val rating = item.mediaMetadata.userRating as HeartRating
+    assertTrue(rating.isRated)
+    assertEquals(false, rating.isHeart)
+  }
+
+  @Test
+  fun `favorited null advertises no userRating (favoriting disabled)`() {
+    val item = TrackFactory.toMedia3(TestFixtures.track(favorited = null))
+    assertNull(item.mediaMetadata.userRating)
+  }
+}

package/android/src/test/resources/certs/isrg-root-x1.pem

@@ -0,0 +1,31 @@
+-----BEGIN CERTIFICATE-----
+MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw
+TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh
+cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4
+WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu
+ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY
+MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc
+h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+
+0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U
+A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW
+T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH
+B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC
+B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv
+KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn
+OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn
+jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw
+qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI
+rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq
+hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL
+ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ
+3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK
+NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5
+ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur
+TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC
+jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc
+oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq
+4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA
+mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d
+emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=
+-----END CERTIFICATE-----

package/android/src/test/resources/certs/letsencrypt-r13.pem

@@ -0,0 +1,29 @@
+-----BEGIN CERTIFICATE-----
+MIIFBTCCAu2gAwIBAgIQWgDyEtjUtIDzkkFX6imDBTANBgkqhkiG9w0BAQsFADBP
+MQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFy
+Y2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBYMTAeFw0yNDAzMTMwMDAwMDBa
+Fw0yNzAzMTIyMzU5NTlaMDMxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBF
+bmNyeXB0MQwwCgYDVQQDEwNSMTMwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEK
+AoIBAQClZ3CN0FaBZBUXYc25BtStGZCMJlA3mBZjklTb2cyEBZPs0+wIG6BgUUNI
+fSvHSJaetC3ancgnO1ehn6vw1g7UDjDKb5ux0daknTI+WE41b0VYaHEX/D7YXYKg
+L7JRbLAaXbhZzjVlyIuhrxA3/+OcXcJJFzT/jCuLjfC8cSyTDB0FxLrHzarJXnzR
+yQH3nAP2/Apd9Np75tt2QnDr9E0i2gB3b9bJXxf92nUupVcM9upctuBzpWjPoXTi
+dYJ+EJ/B9aLrAek4sQpEzNPCifVJNYIKNLMc6YjCR06CDgo28EdPivEpBHXazeGa
+XP9enZiVuppD0EqiFwUBBDDTMrOPAgMBAAGjgfgwgfUwDgYDVR0PAQH/BAQDAgGG
+MB0GA1UdJQQWMBQGCCsGAQUFBwMCBggrBgEFBQcDATASBgNVHRMBAf8ECDAGAQH/
+AgEAMB0GA1UdDgQWBBTnq58PLDOgU9NeT3jIsoQOO9aSMzAfBgNVHSMEGDAWgBR5
+tFnme7bl5AFzgAiIyBpY9umbbjAyBggrBgEFBQcBAQQmMCQwIgYIKwYBBQUHMAKG
+Fmh0dHA6Ly94MS5pLmxlbmNyLm9yZy8wEwYDVR0gBAwwCjAIBgZngQwBAgEwJwYD
+VR0fBCAwHjAcoBqgGIYWaHR0cDovL3gxLmMubGVuY3Iub3JnLzANBgkqhkiG9w0B
+AQsFAAOCAgEAUTdYUqEimzW7TbrOypLqCfL7VOwYf/Q79OH5cHLCZeggfQhDconl
+k7Kgh8b0vi+/XuWu7CN8n/UPeg1vo3G+taXirrytthQinAHGwc/UdbOygJa9zuBc
+VyqoH3CXTXDInT+8a+c3aEVMJ2St+pSn4ed+WkDp8ijsijvEyFwE47hulW0Ltzjg
+9fOV5Pmrg/zxWbRuL+k0DBDHEJennCsAen7c35Pmx7jpmJ/HtgRhcnz0yjSBvyIw
+6L1QIupkCv2SBODT/xDD3gfQQyKv6roV4G2EhfEyAsWpmojxjCUCGiyg97FvDtm/
+NK2LSc9lybKxB73I2+P2G3CaWpvvpAiHCVu30jW8GCxKdfhsXtnIy2imskQqVZ2m
+0Pmxobb28Tucr7xBK7CtwvPrb79os7u2XP3O5f9b/H66GNyRrglRXlrYjI1oGYL/
+f4I1n/Sgusda6WvA6C190kxjU15Y12mHU4+BxyR9cx2hhGS9fAjMZKJss28qxvz6
+Axu4CaDmRNZpK/pQrXF17yXCXkmEWgvSOEZy6Z9pcbLIVEGckV/iVeq0AOo2pkg9
+p4QRIy0tK2diRENLSF2KysFwbY6B26BFeFs3v1sYVRhFW9nLkOrQVporCS0KyZmf
+wVD89qSTlnctLcZnIavjKsKUu1nA1iU0yYMdYepKR7lWbnwhdx3ewok=
+-----END CERTIFICATE-----

package/android/src/test/resources/certs/stationplaylist-leaf.pem

@@ -0,0 +1,34 @@
+-----BEGIN CERTIFICATE-----
+MIIFzTCCBLWgAwIBAgISBnksyiUzN0zFeuPj4pd0++hxMA0GCSqGSIb3DQEBCwUA
+MDMxCzAJBgNVBAYTAlVTMRYwFAYDVQQKEw1MZXQncyBFbmNyeXB0MQwwCgYDVQQD
+EwNSMTMwHhcNMjYwNTEwMDYwMjE2WhcNMjYwODA4MDYwMjE1WjAeMRwwGgYDVQQD
+ExNzdGF0aW9ucGxheWxpc3QuY29tMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+igKCAYEAkxrvDDxzwvpMgRfuGHn+BWaqwom3YeZdql+JVjUh/5Yp4VBD/lAKSQbF
+hr9I7r7pZRyht1R/h2RnbAsrncM0e+Q+03H21gLns7jK3FjOSQKKIzu1hf+ciS7i
+52omAcaQDtPPGmnuWw8AOjkPCqyZsMBU34LL57IPM3bmjFfeOxptXFKDdNgrcwxx
+3j9uiZKeb/9oiXV8Tg3mJM2WVexKGk8AwgvxaJCXyfkiunZ1JmY1QrI3fjNW89kQ
+HiUzTUsTWlra20c3VRkJ5i0xL/TOn8xyH4kZGYXJRNog4LL/dRMwVDdYML0QkhtY
+kcagjwXLWKRcqZd5FrT9rGvUxMNpgev+IpAJQ8yPtRIz4bP/iR8mOQi6Ll1aVK4I
+9UY3ZaK3aDwCMN8zyfOBr4gZhvRUQL4GYCm9+b8BE1r/F/wbz+0P/ryp+s3S8OTW
+C7evThLZnd9xBB87dornrc+N5af0PfOAFYI51cyXaV88Jnz2CV931rbcosZh5n/N
+K75JalDNAgMBAAGjggJuMIICajAOBgNVHQ8BAf8EBAMCBaAwEwYDVR0lBAwwCgYI
+KwYBBQUHAwEwDAYDVR0TAQH/BAIwADAdBgNVHQ4EFgQUVdx3iWpmKuHwao2EBsEa
+xwFEUz8wHwYDVR0jBBgwFoAU56ufDywzoFPTXk94yLKEDjvWkjMwMwYIKwYBBQUH
+AQEEJzAlMCMGCCsGAQUFBzAChhdodHRwOi8vcjEzLmkubGVuY3Iub3JnLzBpBgNV
+HREEYjBgghhtYWlsLnN0YXRpb25wbGF5bGlzdC5jb22CFnMyLnN0YXRpb25wbGF5
+bGlzdC5jb22CE3N0YXRpb25wbGF5bGlzdC5jb22CF3d3dy5zdGF0aW9ucGxheWxp
+c3QuY29tMBMGA1UdIAQMMAowCAYGZ4EMAQIBMC8GA1UdHwQoMCYwJKAioCCGHmh0
+dHA6Ly9yMTMuYy5sZW5jci5vcmcvMTE0LmNybDCCAQ0GCisGAQQB1nkCBAIEgf4E
+gfsA+QB2AMijxH/Hs625NWsBP2p6Em3jOk5DpcZG+ZetOXWZHc+aAAABnhCwQOoA
+AAQDAEcwRQIhAKAeZF1TIhcXX46ZVxgvetzSMbpqMGV5pDZhEq3/EZP7AiBOTSbQ
+B96fqkNPzRnHVoBfet0Bg2wlAyXp/d6K0V7Z/wB/AEavhj07PuWfpXfeqCRdNrDZ
+7SKiI/Rhd0EilFLulVBfAAABnhCwQZoACAAABQAGMUJNBAMASDBGAiEAj2ZfUeUs
+dDMwGC1u2KbaAzEONCFe8G/IuYSFkTo41poCIQDBt1NOS8qJRNx2azto0deCaqT2
+MVq2UrAGzp9xTwdpqTANBgkqhkiG9w0BAQsFAAOCAQEAHbGgp5JI1AyA+bab91AW
+HDZ7rjRQ9KoSKrmjchtxguOBJRU4i3wmjIqZe0rRmAJik3648VwfEng3ky+N7Jo0
+01AK+amwd7lNQk/dkAHgCDN0AAXrVbLxhm2zRaOO60PuRQxqVdxF+UP1sGeq/8z1
+piJTiWdr6Fy8IlgobDkFI8E2y7ZfpL2rF0tB1zXpUCUWYNA1RsciwBUMwe3vntrM
+XX35Z9JXULEzBcx7XTyZa/FBrzO6mQBm/04F2TtfXxHeagsYAZzL7tq7dnwwwN0K
+q/Uj+luERWsXdhzSDmZB7PlZP21KYf0uP9sKMl2oKbQhDS1WPLC8CnGRA+o/qWGb
+Pw==
+-----END CERTIFICATE-----

package/ios/Browser/BrowserConfig.swift

@@ -7,15 +7,30 @@ import os.log
 /// This is a convenience wrapper around NativeBrowserConfiguration that
 /// provides easier access to configuration properties.
 struct BrowserConfig {
-  /// Base HTTP request configuration
+  /// Base HTTP request configuration (applied to every request kind)
   let request: TransformableRequestConfig?
 
+  /// Browse-kind request configuration (applied to every browse request,
+  /// layered request → browse → route)
+  let browse: TransformableRequestConfig?
+
+  /// Resolver for the shared request layer (resolved once per content generation).
+  let requestResolver: (() -> Promise<Promise<TransformableRequestConfig>>)?
+
+  /// Resolver for the browse layer (resolved once per content generation).
+  let browseResolver: (() -> Promise<Promise<TransformableRequestConfig>>)?
+
   /// Media URL transformation configuration
   let media: MediaRequestConfig?
 
   /// Artwork URL transformation configuration
   let artwork: ArtworkRequestConfig?
 
+  /// Now-playing-only artwork configuration (lock screen / CarPlay / Android Auto
+  /// now-playing). A distinct kind from `artwork`; the now-playing path falls back to
+  /// `artwork` when this is nil.
+  let nowPlayingArtwork: ArtworkRequestConfig?
+
   /// Routes as array with flattened entries
   /// Includes __tabs__, __search__, and __default__ special routes
   let routes: [NativeRouteEntry]?
@@ -28,11 +43,14 @@ struct BrowserConfig {
 
   // MARK: - CarPlay Options
 
-  /// Enable the "Up Next" button on CarPlay Now Playing screen
-  let carPlayUpNextButton: Bool
+  /// App-localized title for CarPlay loading screens (shown as the centered
+  /// empty state while content resolves; nil leaves them blank)
+  let carPlayLoadingTitle: String?
 
-  /// Custom buttons for CarPlay Now Playing screen (e.g., .repeat, .favorite)
-  let carPlayNowPlayingButtons: [CarPlayNowPlayingButton]
+  /// Resolves a browse path for the CarPlay Now Playing album line when the
+  /// active track has no albumUrl. Invoked on track changes (not at tap) so
+  /// the album line only becomes tappable when a destination exists.
+  let resolveAlbumUrl: ((_ track: Track) -> Promise<String?>)?
 
   /// Custom handler for track load events (overrides default load behavior)
   let handleTrackLoad: ((_ event: TrackLoadEvent) -> Promise<Promise<Void>>)?
@@ -43,39 +61,51 @@ struct BrowserConfig {
 
   init(
     request: TransformableRequestConfig? = nil,
+    browse: TransformableRequestConfig? = nil,
+    requestResolver: (() -> Promise<Promise<TransformableRequestConfig>>)? = nil,
+    browseResolver: (() -> Promise<Promise<TransformableRequestConfig>>)? = nil,
     media: MediaRequestConfig? = nil,
     artwork: ArtworkRequestConfig? = nil,
+    nowPlayingArtwork: ArtworkRequestConfig? = nil,
     routes: [NativeRouteEntry]? = nil,
     singleTrack: Bool = false,
     handleTrackLoad: ((_ event: TrackLoadEvent) -> Promise<Promise<Void>>)? = nil,
     androidControllerOfflineError: Bool = true,
-    carPlayUpNextButton: Bool = true,
-    carPlayNowPlayingButtons: [CarPlayNowPlayingButton] = [],
+    carPlayLoadingTitle: String? = nil,
+    resolveAlbumUrl: ((_ track: Track) -> Promise<String?>)? = nil,
     formatNavigationError: ((_ params: FormatNavigationErrorParams) -> Promise<FormattedNavigationError?>)? = nil,
   ) {
     self.request = request
+    self.browse = browse
+    self.requestResolver = requestResolver
+    self.browseResolver = browseResolver
     self.media = media
     self.artwork = artwork
+    self.nowPlayingArtwork = nowPlayingArtwork
     self.routes = routes
     self.singleTrack = singleTrack
     self.handleTrackLoad = handleTrackLoad
     self.androidControllerOfflineError = androidControllerOfflineError
-    self.carPlayUpNextButton = carPlayUpNextButton
-    self.carPlayNowPlayingButtons = carPlayNowPlayingButtons
+    self.carPlayLoadingTitle = carPlayLoadingTitle
+    self.resolveAlbumUrl = resolveAlbumUrl
     self.formatNavigationError = formatNavigationError
   }
 
   /// Create from NativeBrowserConfiguration
   init(from config: NativeBrowserConfiguration) {
     request = config.request
+    browse = config.browse
+    requestResolver = config.requestResolver
+    browseResolver = config.browseResolver
     media = config.media
     artwork = config.artwork
+    nowPlayingArtwork = config.nowPlayingArtwork
     routes = config.routes
     singleTrack = config.singleTrack ?? false
     handleTrackLoad = config.handleTrackLoad
     androidControllerOfflineError = config.androidControllerOfflineError ?? true
-    carPlayUpNextButton = config.carPlayUpNextButton ?? true
-    carPlayNowPlayingButtons = config.carPlayNowPlayingButtons ?? []
+    carPlayLoadingTitle = config.carPlayLoadingTitle
+    resolveAlbumUrl = config.resolveAlbumUrl
     formatNavigationError = config.formatNavigationError
   }