react-native-audio-browser 0.2.0-next.10 → 0.2.0-next.12

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

@@ -2,30 +2,31 @@ package com.audiobrowser.util
 
 import android.os.Bundle
 import androidx.media.utils.MediaConstants
-import com.margelo.nitro.audiobrowser.ResolvedTrack
+import com.margelo.nitro.audiobrowser.Section
+import com.margelo.nitro.audiobrowser.StyleDisplay
 import com.margelo.nitro.audiobrowser.Track
-import com.margelo.nitro.audiobrowser.TrackStyle
 
 /** Builds MediaMetadata extras bundle for Android Auto/AAOS content styling. */
 object MediaExtrasBuilder {
 
   /**
-   * Maps TrackStyle to MediaConstants content style value. When artwork is an android.resource://
-   * URI, uses CATEGORY_* variants which add margins around icons (better for small vector icons).
+   * Maps a display mode to the MediaConstants content style value. When artwork is an
+   * android.resource:// URI, uses CATEGORY_* variants which add margins around icons (better for
+   * small vector icons).
    *
    * @see <a href="https://developer.android.com/training/cars/media#default-content-style">Default
    *   content style</a>
    */
-  private fun TrackStyle.toContentStyleValue(artwork: String?): Int {
+  private fun StyleDisplay.toContentStyleValue(artwork: String?): Int {
     val isAndroidResource = artwork?.startsWith("android.resource://") == true
     return when (this) {
-      TrackStyle.LIST ->
+      StyleDisplay.LIST ->
         if (isAndroidResource) {
           MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_CATEGORY_LIST_ITEM
         } else {
           MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_LIST_ITEM
         }
-      TrackStyle.GRID ->
+      StyleDisplay.GRID ->
         if (isAndroidResource) {
           MediaConstants.DESCRIPTION_EXTRAS_VALUE_CONTENT_STYLE_CATEGORY_GRID_ITEM
         } else {
@@ -34,39 +35,43 @@ object MediaExtrasBuilder {
     }
   }
 
-  fun build(track: Track): Bundle =
+  /**
+   * Extras for a track rendered on a browse surface. The owning [section] supplies the Android Auto
+   * group-title header hint (grouping is a per-item advisory in the flat MediaBrowser protocol —
+   * the section dies here, ADR 0010) and, from its page-folded style block, the per-item display
+   * hint: per-item hints derive from the section resolution, never from the track's own `display`,
+   * which is positional (ADR 0011).
+   *
+   * The track's own declared `display` is the page-layout *promise* for the page a browsable track
+   * opens — emitted as the parent-level BROWSABLE/PLAYABLE hint, the only below-root hint
+   * AOSP-derived AAOS media UIs honor. Declared or it doesn't exist: the library never derives a
+   * promise from pages it hasn't resolved, and never back-fills from ones it has.
+   */
+  fun build(track: Track, section: Section? = null): Bundle =
     build(
-      groupTitle = track.groupTitle,
-      style = track.style,
-      childrenStyle = track.childrenStyle,
+      groupTitle = section?.title,
+      itemDisplay = section?.style?.display,
+      promisedDisplay = if (track.src == null) track.style?.display else null,
       artwork = track.artwork?.url,
     )
 
-  fun build(resolvedTrack: ResolvedTrack): Bundle =
-    build(
-      groupTitle = resolvedTrack.groupTitle,
-      style = resolvedTrack.style,
-      childrenStyle = resolvedTrack.childrenStyle,
-      artwork = resolvedTrack.artwork?.url,
-    )
-
   private fun build(
     groupTitle: String?,
-    style: TrackStyle?,
-    childrenStyle: TrackStyle?,
+    itemDisplay: StyleDisplay?,
+    promisedDisplay: StyleDisplay?,
     artwork: String?,
   ): Bundle =
     Bundle().apply {
       groupTitle?.let {
         putString(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_GROUP_TITLE, it)
       }
-      style?.let {
+      itemDisplay?.let {
         putInt(
           MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_SINGLE_ITEM,
           it.toContentStyleValue(artwork),
         )
       }
-      childrenStyle?.let {
+      promisedDisplay?.let {
         val styleValue = it.toContentStyleValue(artwork)
         putInt(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_BROWSABLE, styleValue)
         putInt(MediaConstants.DESCRIPTION_EXTRAS_KEY_CONTENT_STYLE_PLAYABLE, styleValue)

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

@@ -0,0 +1,35 @@
+package com.audiobrowser.util
+
+import com.margelo.nitro.audiobrowser.ArtworkRendering
+import com.margelo.nitro.audiobrowser.StyleDisplay
+
+/**
+ * The style block's wire strings (ADR 0011) ↔ Nitro enums, shared by the browse decoder and the
+ * playback-state store. Inbound mapping is lenient: an unknown or empty value is "no declaration",
+ * never an error.
+ */
+internal fun StyleDisplay.toWireString(): String =
+  when (this) {
+    StyleDisplay.LIST -> "list"
+    StyleDisplay.GRID -> "grid"
+  }
+
+internal fun ArtworkRendering.toWireString(): String =
+  when (this) {
+    ArtworkRendering.ORIGINAL -> "original"
+    ArtworkRendering.STENCIL -> "stencil"
+  }
+
+internal fun String?.toStyleDisplay(): StyleDisplay? =
+  when (this?.takeIf { it.isNotEmpty() }?.lowercase()) {
+    "list" -> StyleDisplay.LIST
+    "grid" -> StyleDisplay.GRID
+    else -> null
+  }
+
+internal fun String?.toArtworkRendering(): ArtworkRendering? =
+  when (this?.takeIf { it.isNotEmpty() }?.lowercase()) {
+    "original" -> ArtworkRendering.ORIGINAL
+    "stencil" -> ArtworkRendering.STENCIL
+    else -> null
+  }

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

@@ -7,17 +7,16 @@ import androidx.media3.common.MediaItem
 import androidx.media3.common.MediaMetadata
 import com.audiobrowser.browser.BrowseArtworkRegistry
 import com.audiobrowser.browser.ResolvedArtwork
-import com.margelo.nitro.audiobrowser.ImageRowItem
+import com.margelo.nitro.audiobrowser.Section
 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
+ * and the mediaId is the stable `id` for playable tracks, falling back to `path` then `src` (a
+ * Track must have one of the latter two — see the `src` vs `path` 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 {
@@ -26,49 +25,35 @@ object TrackFactory {
   }
 
   /**
-   * 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.
+   * A synthetic browsable Track for a section's "view all" surface — the section has a path, title,
+   * and label, but no Track (ADR 0010). It carries the section's declared item block as its own,
+   * `display` included: the section's declaration about this content's layout is the only declared
+   * promise the "view all" page can ever have (there is no consumer-authored handle to declare one
+   * on), and without it Android Auto would always render that page as a list.
    */
-  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 =
+  fun navigationTrack(section: Section): 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,
+      id = null,
+      path = section.path,
+      src = null,
+      artwork = null,
+      artworkSource = null,
+      request = null,
+      title = section.title ?: "",
+      subtitle = section.subtitle,
+      artist = null,
+      albumPath = null,
+      album = null,
       description = null,
       genre = null,
       duration = null,
-      style = TrackStyle.GRID,
-      childrenStyle = null,
+      style =
+        section.style?.let {
+          TrackStyle(display = it.display, artworkRendering = it.artworkRendering)
+        },
+      disabled = null,
       favorited = null,
-      groupTitle = groupTitle,
-      live = live,
-      imageRow = null,
+      live = null,
     )
 
   fun toMedia3(tracks: Array<Track>): List<MediaItem> {
@@ -90,10 +75,11 @@ object TrackFactory {
     track: Track,
     registry: BrowseArtworkRegistry,
     authority: String,
+    section: Section? = null,
   ): MediaItem {
     val rawUrl = artworkUri(track) // artworkSource.uri ?: artwork
     val scheme = rawUrl?.let { Uri.parse(it).scheme?.lowercase() }
-    val builder = metadataBuilder(track)
+    val builder = metadataBuilder(track, section)
     if (rawUrl != null && (scheme == "http" || scheme == "https")) {
       val isSvg =
         SvgArtworkRenderer.isSvgUrl(rawUrl) || SvgArtworkRenderer.isSvgUrl(track.artwork?.url)
@@ -109,8 +95,11 @@ object TrackFactory {
   /** The transformed artworkSource wins over the raw artwork field. */
   private fun artworkUri(track: Track): String? = track.artworkSource?.uri ?: track.artwork?.url
 
-  /** All metadata except artwork. */
-  private fun metadataBuilder(track: Track): MediaMetadata.Builder =
+  /**
+   * All metadata except artwork. The owning [section] (browse surfaces only) supplies the
+   * group-title header hint and the per-item style default (ADR 0010).
+   */
+  private fun metadataBuilder(track: Track, section: Section? = null): MediaMetadata.Builder =
     MediaMetadata.Builder()
       .setTitle(track.title)
       .setArtist(track.subtitle)
@@ -119,26 +108,29 @@ object TrackFactory {
       .setGenre(track.genre)
       .setIsBrowsable(track.src == null)
       .setIsPlayable(track.src != null)
-      .setExtras(MediaExtrasBuilder.build(track))
+      .setExtras(MediaExtrasBuilder.build(track, section))
       .apply { track.favorited?.let { setUserRating(HeartRating(it)) } }
 
   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
+    // A playable track's mediaId is the consumer's stable `id` when it has one —
+    // the identity rule (id when non-blank, else src; see Track.identity /
+    // ADR 0008), except that an id-less playable track prefers its contextual
+    // `path` over `src` here, so this is deliberately NOT expressed via
+    // Track.identity. 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.
+    // `path` so navigation parentIds stay resolvable paths.
     val stableId = if (track.src != null) track.id?.takeUnless { it.isBlank() } else null
     val mediaId =
       stableId
-        ?: track.url
+        ?: track.path
         ?: track.src
         ?: throw IllegalArgumentException(
-          "Track must have either url or src defined. Track: title='${track.title}', artist='${track.artist}'"
+          "Track must have either path or src defined. Track: title='${track.title}', artist='${track.artist}'"
         )
     return MediaItem.Builder()
       .setMediaId(mediaId)

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

@@ -3,9 +3,12 @@ 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.NativeRouteEntry
+import com.margelo.nitro.audiobrowser.ResolvedTrack
+import com.margelo.nitro.audiobrowser.Section
+import com.margelo.nitro.audiobrowser.SectionStyle
 import com.margelo.nitro.audiobrowser.Track
 import com.margelo.nitro.audiobrowser.TransformableRequestConfig
 
@@ -24,47 +27,37 @@ object TestFixtures {
     artist: String? = null,
     album: String? = null,
     favorited: Boolean? = null,
-    groupTitle: String? = null,
-    imageRow: Array<ImageRowItem>? = null,
+    disabled: Boolean? = null,
   ) =
     Track(
       id = id,
-      url = null,
+      path = null,
       src = src,
       artwork = artworkOf(artwork),
       artworkSource = null,
       request = null,
-      artworkCarPlayTinted = null,
       title = title,
       subtitle = null,
       artist = artist,
-      albumUrl = null,
+      albumPath = null,
       album = album,
       description = null,
       genre = null,
       duration = null,
       style = null,
-      childrenStyle = null,
+      disabled = disabled,
       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,
-    )
+  /** A page [Section] — plain list by default. */
+  fun section(
+    children: Array<Track>,
+    title: String? = null,
+    subtitle: String? = null,
+    style: SectionStyle? = null,
+    path: String? = null,
+  ) = Section(title = title, subtitle = subtitle, style = style, path = path, children = children)
 
   fun transformableConfig(
     baseUrl: String? = null,
@@ -113,32 +106,78 @@ object TestFixtures {
    */
   fun browseTrack(
     title: String = "T",
-    url: String = "https://api.example.com/channel/abc",
+    path: String = "https://api.example.com/channel/abc",
     artwork: String? = null,
     artworkSource: ImageSource? = null,
   ) =
     Track(
       id = null,
-      url = url,
+      path = path,
       src = null, // browsable, not playable
       artwork = artworkOf(artwork),
       artworkSource = artworkSource,
       request = null,
-      artworkCarPlayTinted = null,
       title = title,
       subtitle = null,
       artist = null,
-      albumUrl = null,
+      albumPath = null,
       album = null,
       description = null,
       genre = null,
       duration = null,
       style = null,
-      childrenStyle = null,
+      disabled = null,
       favorited = null,
-      groupTitle = null,
       live = null,
-      imageRow = null,
+    )
+
+  /** A container [ResolvedTrack] — what a browse route hands back for a path. */
+  fun resolvedTrack(
+    path: String = "/container",
+    title: String = "Container",
+    children: Array<Track>? = null,
+    sections: Array<Section>? = null,
+    style: SectionStyle? = null,
+  ) =
+    ResolvedTrack(
+      path = path,
+      style = style,
+      sections = sections,
+      children = children,
+      carPlaySiriListButton = null,
+      id = null,
+      src = null,
+      artwork = null,
+      artworkSource = null,
+      request = null,
+      title = title,
+      subtitle = null,
+      artist = null,
+      albumPath = null,
+      album = null,
+      description = null,
+      genre = null,
+      duration = null,
+      disabled = null,
+      favorited = null,
+      live = null,
+    )
+
+  /**
+   * A route serving [browseStatic] verbatim. `browseStatic` is the only one of the three browse
+   * arms (callback > config > static) that needs neither the JNI bridge nor HTTP, so it is how a
+   * unit test gives [com.audiobrowser.browser.BrowserManager] page content to resolve.
+   */
+  fun staticRoute(path: String, browseStatic: ResolvedTrack) =
+    NativeRouteEntry(
+      path = path,
+      browseCallback = null,
+      browseConfig = null,
+      browseStatic = browseStatic,
+      searchCallback = null,
+      searchConfig = null,
+      media = null,
+      artwork = null,
     )
 
   fun artworkConfig(

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

@@ -0,0 +1,153 @@
+package com.audiobrowser.browser
+
+import com.audiobrowser.TestFixtures.resolvedTrack
+import com.audiobrowser.TestFixtures.staticRoute
+import com.audiobrowser.TestFixtures.track
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+/**
+ * Favorite hydration keyed by track identity (id when non-blank, else src — see Track.identity /
+ * ADR 0008). Hydration is exercised through [BrowserManager.resolve], the path every browse page
+ * takes.
+ *
+ * Routes serve `browseStatic` (no JNI/HTTP); Robolectric is required for `android.util.LruCache`
+ * and `android.net.Uri`.
+ */
+@RunWith(RobolectricTestRunner::class)
+class BrowserManagerFavoritesTest {
+
+  private lateinit var browserManager: BrowserManager
+
+  @Before
+  fun setup() {
+    browserManager = BrowserManager()
+  }
+
+  private fun servePage(path: String, vararg children: com.margelo.nitro.audiobrowser.Track) {
+    browserManager.config =
+      BrowserConfig(
+        routes =
+          arrayOf(staticRoute(path, resolvedTrack(path = path, children = arrayOf(*children))))
+      )
+  }
+
+  private fun favoritedByTitle(children: Array<com.margelo.nitro.audiobrowser.Track>?) =
+    children?.associate { it.title to it.favorited }
+
+  @Test
+  fun `hydrates by id when the track has one`() = runBlocking {
+    servePage(
+      "/home",
+      track(title = "A", id = "stable-a", src = "https://s/a.mp3"),
+      track(title = "B", id = "stable-b", src = "https://s/b.mp3"),
+    )
+    browserManager.setFavoriteEnabled(true)
+    browserManager.setFavorites(listOf("stable-b"))
+
+    val resolved = browserManager.resolve("/home")
+
+    assertEquals(
+      mapOf("A" to false, "B" to true),
+      favoritedByTitle(resolved.flattenedChildren?.toTypedArray()),
+    )
+  }
+
+  @Test
+  fun `falls back to src for id-less tracks`() = runBlocking {
+    servePage(
+      "/home",
+      track(title = "A", src = "https://s/a.mp3"),
+      track(title = "B", src = "https://s/b.mp3"),
+    )
+    browserManager.setFavoriteEnabled(true)
+    browserManager.setFavorites(listOf("https://s/b.mp3"))
+
+    val resolved = browserManager.resolve("/home")
+
+    assertEquals(
+      mapOf("A" to false, "B" to true),
+      favoritedByTitle(resolved.flattenedChildren?.toTypedArray()),
+    )
+  }
+
+  @Test
+  fun `a favorite stored under src does not match an id-bearing track`() = runBlocking {
+    // The identity is the id when present — a src-keyed entry must not light up
+    // a track whose identity is its id (one rule, no partial matching).
+    servePage("/home", track(title = "A", id = "stable-a", src = "https://s/a.mp3"))
+    browserManager.setFavoriteEnabled(true)
+    browserManager.setFavorites(listOf("https://s/a.mp3"))
+
+    val resolved = browserManager.resolve("/home")
+
+    assertEquals(mapOf("A" to false), favoritedByTitle(resolved.flattenedChildren?.toTypedArray()))
+  }
+
+  @Test
+  fun `caller-set favorited wins over hydration`() = runBlocking {
+    servePage(
+      "/home",
+      track(title = "A", id = "stable-a", src = "https://s/a.mp3", favorited = false),
+    )
+    browserManager.setFavoriteEnabled(true)
+    browserManager.setFavorites(listOf("stable-a"))
+
+    val resolved = browserManager.resolve("/home")
+
+    // API-provided value is never overwritten, even when the identity is favorited.
+    assertEquals(mapOf("A" to false), favoritedByTitle(resolved.flattenedChildren?.toTypedArray()))
+  }
+
+  @Test
+  fun `disabled favoriting leaves tracks untouched`() = runBlocking {
+    servePage("/home", track(title = "A", id = "stable-a", src = "https://s/a.mp3"))
+    // favoriteEnabled defaults to false
+    browserManager.setFavorites(listOf("stable-a"))
+
+    val resolved = browserManager.resolve("/home")
+
+    assertEquals(
+      mapOf<String, Boolean?>("A" to null),
+      favoritedByTitle(resolved.flattenedChildren?.toTypedArray()),
+    )
+  }
+
+  @Test
+  fun `updateFavorite adds and removes by identity`() = runBlocking {
+    servePage("/home", track(title = "A", id = "stable-a", src = "https://s/a.mp3"))
+    browserManager.setFavoriteEnabled(true)
+
+    assertEquals(
+      mapOf("A" to false),
+      favoritedByTitle(browserManager.resolve("/home").flattenedChildren?.toTypedArray()),
+    )
+
+    browserManager.updateFavorite("stable-a", true)
+    assertEquals(
+      mapOf("A" to true),
+      favoritedByTitle(browserManager.resolve("/home").flattenedChildren?.toTypedArray()),
+    )
+
+    browserManager.updateFavorite("stable-a", false)
+    assertEquals(
+      mapOf("A" to false),
+      favoritedByTitle(browserManager.resolve("/home").flattenedChildren?.toTypedArray()),
+    )
+  }
+
+  @Test
+  fun `getCachedTrack re-hydrates favorites by identity`() = runBlocking {
+    servePage("/home", track(title = "A", id = "stable-a", src = "https://s/a.mp3"))
+    browserManager.setFavoriteEnabled(true)
+    browserManager.resolve("/home")
+
+    browserManager.updateFavorite("stable-a", true)
+
+    assertEquals(true, browserManager.getCachedTrack("stable-a")?.favorited)
+  }
+}

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

@@ -8,6 +8,8 @@ import org.junit.Assert.assertNull
 import org.junit.Assert.assertSame
 import org.junit.Before
 import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
 
 /**
  * Tests the request/browse layer resolution + caching introduced for resolver thunks.
@@ -26,7 +28,11 @@ import org.junit.Test
  * bump, no in-flight cache) is identical for the static and resolver paths — `resolveLayer` only
  * differs in how it produces the `TransformableRequestConfig` — so the guard is fully covered here.
  * The resolver-await path is covered by the TS/web-stub tests and on iOS.
+ *
+ * Runs under Robolectric for [BrowserManager]'s `android.util.LruCache` fields: `clearContentCache`
+ * calls `evictAll()`, which a plain JVM test cannot execute.
  */
+@RunWith(RobolectricTestRunner::class)
 class BrowserManagerLayerResolutionTest {
 
   private lateinit var browserManager: BrowserManager