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

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

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

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

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

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

@@ -1,157 +1,125 @@
 package com.audiobrowser.util
 
-import android.net.Uri
+import android.content.Context
 import androidx.core.net.toUri
 import androidx.media3.common.HeartRating
 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 coil3.ImageLoader
 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 metadata = metadataBuilder(track).setArtworkUri(artworkUri(track)?.toUri()).build()
-    return buildMediaItem(track, metadata)
+    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()
   }
 
   /**
-   * 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.
+   * 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
    */
-  fun toBrowseMediaItem(
+  suspend fun toMedia3WithSvgSupport(
     track: Track,
-    registry: BrowseArtworkRegistry,
-    authority: String,
+    context: Context,
+    imageLoader: ImageLoader,
   ): MediaItem {
-    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())
-  }
+    val extras = MediaExtrasBuilder.build(track)
 
-  /** The transformed artworkSource wins over the raw artwork field. */
-  private fun artworkUri(track: Track): String? = track.artworkSource?.uri ?: track.artwork?.url
+    // Use transformed artworkSource.uri if available, otherwise fall back to original artwork
+    val artworkUrl = track.artworkSource?.uri ?: track.artwork
 
-  /** All metadata except artwork. */
-  private fun metadataBuilder(track: Track): MediaMetadata.Builder =
-    MediaMetadata.Builder()
+    // Build metadata with SVG support
+    val metadataBuilder = MediaMetadata.Builder()
       .setTitle(track.title)
-      .setArtist(track.subtitle)
+      .setArtist(track.artist)
       .setAlbumTitle(track.album)
       .setDescription(track.description)
       .setGenre(track.genre)
       .setIsBrowsable(track.src == null)
       .setIsPlayable(track.src != null)
-      .setExtras(MediaExtrasBuilder.build(track))
+      .setExtras(extras)
       .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
-    // 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
+    // Apply artwork with SVG pre-rendering if needed
+    SvgArtworkRenderer.applyArtwork(metadataBuilder, artworkUrl, context, imageLoader)
+
+    val mediaMetadata = metadataBuilder.build()
+
     val mediaId =
-      stableId
-        ?: track.url
+      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)
-      // 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)
+      .setMediaMetadata(mediaMetadata)
       .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,8 +3,4 @@
     <!-- 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/browser/BrowserManagerTest.kt

@@ -8,10 +8,6 @@ import org.junit.runner.RunWith
 import org.robolectric.RobolectricTestRunner
 
 // TODO: Most tests disabled — BrowserConfig API changed (routes is now Array<NativeRouteEntry>).
-// When revived, add expandQueueFromContextualUrl glue tests: found id → its
-// SectionScope section as the queue; vanished id → null (single-track
-// fallback). The section logic and the caller fallback are covered
-// (SectionScopeTest, TrackSelectorTests); the wiring between them is not.
 // Tests that used BrowserSource/BrowserList need to be rewritten.
 
 @RunWith(RobolectricTestRunner::class)

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

@@ -109,7 +109,8 @@ class SimpleRouterTest {
 
   @Test
   fun `works with parameters before tail wildcard`() {
-    val result = router.findBestMatch("/api/v1/users/list", mapOf("/api/{version}/**" to true))
+    val result =
+      router.findBestMatch("/api/v1/users/list", mapOf("/api/{version}/**" to true))
     assertNotNull(result)
     assertEquals(mapOf("version" to "v1", "tail" to "users/list"), result!!.second.params)
   }

package/android/src/test/java/com/audiobrowser/http/RequestConfigBuilderTest.kt

@@ -1,7 +1,5 @@
 package com.audiobrowser.http
 
-import com.audiobrowser.TestFixtures.mediaConfig
-import com.audiobrowser.TestFixtures.transformableConfig
 import com.margelo.nitro.audiobrowser.HttpMethod
 import com.margelo.nitro.audiobrowser.RequestConfig
 import kotlinx.coroutines.test.runTest
@@ -239,74 +237,4 @@ class RequestConfigBuilderTest {
 
     assertEquals("https://api.example.com/albums", result.url) // No query string
   }
-
-  // Run-both composition: the sync/async split replaced the old ambiguous variant.
-
-  @Test
-  fun `composeResolved merges async then sync with sync winning`() {
-    val async =
-      RequestConfig(null, null, "https://async.example.com", null, null, null, null, "ASYNC")
-    val sync = RequestConfig(null, null, null, null, null, null, null, "SYNC")
-
-    val merged = RequestConfigBuilder.composeResolved(async, sync)
-
-    assertEquals("SYNC", merged?.userAgent) // sync wins
-    assertEquals("https://async.example.com", merged?.baseUrl) // async's baseUrl survives
-  }
-
-  @Test
-  fun `composeResolved returns the single present side, or null for neither`() {
-    val cfg = RequestConfig(null, null, null, null, null, null, null, "ONLY")
-
-    assertEquals("ONLY", RequestConfigBuilder.composeResolved(cfg, null)?.userAgent)
-    assertEquals("ONLY", RequestConfigBuilder.composeResolved(null, cfg)?.userAgent)
-    assertNull(RequestConfigBuilder.composeResolved(null, null))
-  }
-
-  @Test
-  fun `mergeConfig MediaRequestConfig static fields merge over base and preserve callbacks`() =
-    runTest {
-      val base =
-        RequestConfig(
-          method = null,
-          path = "/stream.mp3",
-          baseUrl = "https://media.example.com",
-          headers = mapOf("x-base" to "1"),
-          query = null,
-          body = null,
-          contentType = null,
-          userAgent = "base-ua",
-        )
-      val override = mediaConfig(headers = mapOf("x-media" to "2"), query = mapOf("token" to "abc"))
-      val merged = RequestConfigBuilder.mergeConfig(base, override)
-      assertEquals("/stream.mp3", merged.path)
-      assertEquals("https://media.example.com", merged.baseUrl)
-      assertEquals("1", merged.headers?.get("x-base"))
-      assertEquals("2", merged.headers?.get("x-media"))
-      assertEquals("abc", merged.query?.get("token"))
-      assertEquals("base-ua", merged.userAgent)
-    }
-
-  // Request-Config Layer rule (mirrors iOS applyLayer and the web stub): a
-  // layer's static `path` never overrides the base path — the path is carried
-  // from the base; only a Transform may change it.
-
-  @Test
-  fun `mergeConfig TransformableRequestConfig carries the base path over a static layer path`() =
-    runTest {
-      val base =
-        RequestConfig(null, "/navigated", "https://api.example.com", null, null, null, null, null)
-      val layer = transformableConfig(path = "/static-layer-path")
-      val merged = RequestConfigBuilder.mergeConfig(base, layer, emptyMap())
-      assertEquals("/navigated", merged.path)
-    }
-
-  @Test
-  fun `mergeConfig MediaRequestConfig carries the base path over a static media path`() = runTest {
-    val base =
-      RequestConfig(null, "/stream/123", "https://api.example.com", null, null, null, null, null)
-    val media = mediaConfig(path = "/static-media-path")
-    val merged = RequestConfigBuilder.mergeConfig(base, media)
-    assertEquals("/stream/123", merged.path)
-  }
 }

package/android/src/test/java/com/audiobrowser/player/PlaybackProgressUpdateManagerTest.kt

@@ -0,0 +1,146 @@
+package com.audiobrowser.player
+
+import com.margelo.nitro.audiobrowser.PlaybackState
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.UnconfinedTestDispatcher
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.resetMain
+import kotlinx.coroutines.test.runTest
+import kotlinx.coroutines.test.setMain
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+
+@OptIn(ExperimentalCoroutinesApi::class)
+class PlaybackProgressUpdateManagerTest {
+
+  @Before
+  fun setup() {
+    Dispatchers.setMain(UnconfinedTestDispatcher())
+  }
+
+  @After
+  fun tearDown() {
+    Dispatchers.resetMain()
+  }
+
+  @Test
+  fun `setUpdateInterval before playback does not emit events`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+
+    advanceTimeBy(500)
+    assertEquals(0, callCount)
+    manager.stop()
+  }
+
+  @Test
+  fun `setUpdateInterval while running restarts with new interval`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+    manager.start()
+
+    advanceTimeBy(350)
+    assertTrue("Expected events while running, got $callCount", callCount > 0)
+
+    val countBefore = callCount
+    manager.setUpdateInterval(0.2) // different value — should restart
+    advanceTimeBy(500)
+    assertTrue("Expected more events after interval change", callCount > countBefore)
+
+    manager.stop()
+  }
+
+  @Test
+  fun `start begins emitting, stop ceases emitting`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+    manager.start()
+
+    advanceTimeBy(350)
+    assertTrue("Expected events after start", callCount > 0)
+
+    manager.stop()
+    val countAfterStop = callCount
+
+    advanceTimeBy(500)
+    assertEquals(countAfterStop, callCount)
+  }
+
+  @Test
+  fun `start without interval does nothing`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.start()
+
+    advanceTimeBy(500)
+    assertEquals(0, callCount)
+  }
+
+  @Test
+  fun `playing state starts timer, paused stops it`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+    manager.onPlaybackStateChanged(PlaybackState.PLAYING)
+
+    advanceTimeBy(350)
+    assertTrue("Expected events when playing", callCount > 0)
+
+    manager.onPlaybackStateChanged(PlaybackState.PAUSED)
+    val countAfterPause = callCount
+
+    advanceTimeBy(500)
+    assertEquals(countAfterPause, callCount)
+  }
+
+  @Test
+  fun `loading and buffering states also start timer`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+
+    manager.onPlaybackStateChanged(PlaybackState.LOADING)
+    advanceTimeBy(350)
+    assertTrue("Expected events when loading", callCount > 0)
+
+    manager.onPlaybackStateChanged(PlaybackState.STOPPED)
+    val afterStop = callCount
+
+    manager.onPlaybackStateChanged(PlaybackState.BUFFERING)
+    advanceTimeBy(350)
+    assertTrue("Expected events when buffering", callCount > afterStop)
+
+    manager.stop()
+  }
+
+  @Test
+  fun `setting nil interval stops timer`() = runTest {
+    var callCount = 0
+    val manager = PlaybackProgressUpdateManager { callCount++ }
+
+    manager.setUpdateInterval(0.1)
+    manager.start()
+
+    advanceTimeBy(350)
+    assertTrue("Expected events before clearing", callCount > 0)
+
+    manager.setUpdateInterval(null)
+    val afterNil = callCount
+
+    advanceTimeBy(500)
+    assertEquals(afterNil, callCount)
+  }
+}