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

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

@@ -0,0 +1,198 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.Player as MediaPlayer
+import com.margelo.nitro.audiobrowser.PlaybackState
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Truth table for the playback state transitions — the Android analog of iOS's
+ * `nextPlaybackState(from:on:)`, previously inline branching in PlayerListener.onEvents. Guards
+ * here are state-related; context guards arrive as event fields captured at the call site.
+ */
+class PlaybackStateMachineTest {
+
+  private fun on(
+    event: PlaybackEvent,
+    from: PlaybackState = PlaybackState.PLAYING,
+  ): List<PlaybackState> = PlaybackStateMachine.transitions(from, event)
+
+  // MARK: ExoPlayer state changes
+
+  @Test
+  fun `buffering maps directly`() {
+    assertEquals(
+      listOf(PlaybackState.BUFFERING),
+      on(
+        PlaybackEvent.ExoPlaybackStateChanged(
+          MediaPlayer.STATE_BUFFERING,
+          mediaItemCount = 1,
+          playWhenReady = true,
+        )
+      ),
+    )
+  }
+
+  @Test
+  fun `ready is emitted only while paused, suppressed while playing`() {
+    // Paused (playWhenReady=false): READY is the settled signal consumers need to
+    // clear a spinner from a buffer that finished while paused (mono#3325).
+    assertEquals(
+      listOf(PlaybackState.READY),
+      on(
+        PlaybackEvent.ExoPlaybackStateChanged(
+          MediaPlayer.STATE_READY,
+          mediaItemCount = 1,
+          playWhenReady = false,
+        ),
+        from = PlaybackState.BUFFERING,
+      ),
+    )
+    // Playing (playWhenReady=true): READY is a transient before PLAYING — suppressed
+    // so consumers don't flash a settled/non-loading state mid-startup.
+    assertEquals(
+      emptyList<PlaybackState>(),
+      on(
+        PlaybackEvent.ExoPlaybackStateChanged(
+          MediaPlayer.STATE_READY,
+          mediaItemCount = 1,
+          playWhenReady = true,
+        ),
+        from = PlaybackState.BUFFERING,
+      ),
+    )
+  }
+
+  @Test
+  fun `idle maps to none except from error or stopped`() {
+    val idle =
+      PlaybackEvent.ExoPlaybackStateChanged(
+        MediaPlayer.STATE_IDLE,
+        mediaItemCount = 1,
+        playWhenReady = false,
+      )
+    assertEquals(listOf(PlaybackState.NONE), on(idle, from = PlaybackState.PLAYING))
+    // A terminal error idles ExoPlayer; transitioning to NONE would clear the ERROR state the
+    // session is rendering. Same for an explicit stop.
+    assertEquals(emptyList<PlaybackState>(), on(idle, from = PlaybackState.ERROR))
+    assertEquals(emptyList<PlaybackState>(), on(idle, from = PlaybackState.STOPPED))
+  }
+
+  @Test
+  fun `ended maps to ended only while the queue has items`() {
+    assertEquals(
+      listOf(PlaybackState.ENDED),
+      on(
+        PlaybackEvent.ExoPlaybackStateChanged(
+          MediaPlayer.STATE_ENDED,
+          mediaItemCount = 3,
+          playWhenReady = false,
+        )
+      ),
+    )
+    // An emptied queue also reports STATE_ENDED; that is "nothing loaded", not "played to end".
+    assertEquals(
+      listOf(PlaybackState.NONE),
+      on(
+        PlaybackEvent.ExoPlaybackStateChanged(
+          MediaPlayer.STATE_ENDED,
+          mediaItemCount = 0,
+          playWhenReady = false,
+        )
+      ),
+    )
+  }
+
+  @Test
+  fun `recovery out of error is allowed`() {
+    // The asymmetry that makes the session-error mask work: IDLE is suppressed from ERROR (the
+    // error keeps rendering), but a real recovery (re-prepare reaching BUFFERING/READY) must
+    // transition out of ERROR.
+    assertEquals(
+      listOf(PlaybackState.BUFFERING),
+      on(
+        PlaybackEvent.ExoPlaybackStateChanged(
+          MediaPlayer.STATE_BUFFERING,
+          mediaItemCount = 1,
+          playWhenReady = true,
+        ),
+        from = PlaybackState.ERROR,
+      ),
+    )
+    // A paused recovery reaching READY (playWhenReady=false) also leaves ERROR.
+    assertEquals(
+      listOf(PlaybackState.READY),
+      on(
+        PlaybackEvent.ExoPlaybackStateChanged(
+          MediaPlayer.STATE_READY,
+          mediaItemCount = 1,
+          playWhenReady = false,
+        ),
+        from = PlaybackState.ERROR,
+      ),
+    )
+  }
+
+  @Test
+  fun `an unmapped exo state is a no-op`() {
+    assertEquals(
+      emptyList<PlaybackState>(),
+      on(
+        PlaybackEvent.ExoPlaybackStateChanged(
+          exoState = 99,
+          mediaItemCount = 1,
+          playWhenReady = false,
+        )
+      ),
+    )
+  }
+
+  // MARK: media item transitions
+
+  @Test
+  fun `a transition to a track synthesizes the loading burst`() {
+    assertEquals(
+      listOf(PlaybackState.LOADING),
+      on(PlaybackEvent.MediaItemTransition(hasTrack = true, isPlaying = false)),
+    )
+    // Already audibly playing (gapless auto-advance): run the full burst so consumers see the
+    // canonical sequence rather than staying stuck on LOADING.
+    assertEquals(
+      listOf(PlaybackState.LOADING, PlaybackState.READY, PlaybackState.PLAYING),
+      on(PlaybackEvent.MediaItemTransition(hasTrack = true, isPlaying = true)),
+    )
+  }
+
+  @Test
+  fun `a transition without a track is suppressed`() {
+    assertEquals(
+      emptyList<PlaybackState>(),
+      on(PlaybackEvent.MediaItemTransition(hasTrack = false, isPlaying = true)),
+    )
+  }
+
+  // MARK: playWhenReady / isPlaying
+
+  @Test
+  fun `losing playWhenReady pauses except from stopped or ended`() {
+    val paused = PlaybackEvent.PlayWhenReadyChanged(playWhenReady = false)
+    assertEquals(listOf(PlaybackState.PAUSED), on(paused, from = PlaybackState.PLAYING))
+    assertEquals(emptyList<PlaybackState>(), on(paused, from = PlaybackState.STOPPED))
+    // ENDED is terminal the same way: dropping the intent after a natural end (the
+    // clear at ENDED, or a dead toggle press) must not re-report the state as PAUSED.
+    assertEquals(emptyList<PlaybackState>(), on(paused, from = PlaybackState.ENDED))
+    assertEquals(
+      emptyList<PlaybackState>(),
+      on(PlaybackEvent.PlayWhenReadyChanged(playWhenReady = true)),
+    )
+  }
+
+  @Test
+  fun `audible playback maps to playing`() {
+    assertEquals(
+      listOf(PlaybackState.PLAYING),
+      on(PlaybackEvent.IsPlayingChanged(isPlaying = true), from = PlaybackState.READY),
+    )
+    assertEquals(emptyList<PlaybackState>(), on(PlaybackEvent.IsPlayingChanged(isPlaying = false)))
+  }
+}

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

@@ -0,0 +1,137 @@
+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 PlaybackTimerTest {
+
+  @Before
+  fun setup() {
+    Dispatchers.setMain(UnconfinedTestDispatcher())
+  }
+
+  @After
+  fun tearDown() {
+    Dispatchers.resetMain()
+  }
+
+  private fun playingTimer(onTick: () -> Unit) =
+    PlaybackTimer(isActive = { it == PlaybackState.PLAYING }, onTick = onTick)
+
+  @Test
+  fun `interval set but not active does not emit`() = runTest {
+    var callCount = 0
+    val timer = playingTimer { callCount++ }
+
+    timer.setInterval(0.1) // active is still false (no state change)
+
+    advanceTimeBy(500)
+    assertEquals(0, callCount)
+  }
+
+  @Test
+  fun `active without interval does nothing`() = runTest {
+    var callCount = 0
+    val timer = playingTimer { callCount++ }
+
+    timer.onPlaybackStateChanged(PlaybackState.PLAYING)
+
+    advanceTimeBy(500)
+    assertEquals(0, callCount)
+  }
+
+  @Test
+  fun `active and interval set begins emitting, leaving active ceases`() = runTest {
+    var callCount = 0
+    val timer = playingTimer { callCount++ }
+
+    timer.setInterval(0.1)
+    timer.onPlaybackStateChanged(PlaybackState.PLAYING)
+
+    advanceTimeBy(350)
+    assertTrue("Expected events while active", callCount > 0)
+
+    timer.onPlaybackStateChanged(PlaybackState.PAUSED)
+    val afterPause = callCount
+
+    advanceTimeBy(500)
+    assertEquals(afterPause, callCount)
+  }
+
+  @Test
+  fun `changing interval while running restarts with new interval`() = runTest {
+    var callCount = 0
+    val timer = playingTimer { callCount++ }
+
+    timer.setInterval(0.1)
+    timer.onPlaybackStateChanged(PlaybackState.PLAYING)
+    advanceTimeBy(350)
+    assertTrue("Expected events while running, got $callCount", callCount > 0)
+
+    val before = callCount
+    timer.setInterval(0.2) // different value — should restart
+    advanceTimeBy(500)
+    assertTrue("Expected more events after interval change", callCount > before)
+
+    timer.setInterval(null)
+  }
+
+  @Test
+  fun `nil interval stops`() = runTest {
+    var callCount = 0
+    val timer = playingTimer { callCount++ }
+
+    timer.setInterval(0.1)
+    timer.onPlaybackStateChanged(PlaybackState.PLAYING)
+    advanceTimeBy(350)
+    assertTrue("Expected events before clearing", callCount > 0)
+
+    timer.setInterval(null)
+    val afterNil = callCount
+
+    advanceTimeBy(500)
+    assertEquals(afterNil, callCount)
+  }
+
+  @Test
+  fun `isActive predicate gates which states run`() = runTest {
+    // playing-only timer must NOT tick while buffering...
+    var playingOnly = 0
+    val strict = playingTimer { playingOnly++ }
+    strict.setInterval(0.1)
+    strict.onPlaybackStateChanged(PlaybackState.BUFFERING)
+    advanceTimeBy(350)
+    assertEquals(0, playingOnly)
+    strict.setInterval(null)
+
+    // ...while a progress-style predicate that includes buffering does.
+    var progress = 0
+    val lenient =
+      PlaybackTimer(
+        isActive = {
+          it == PlaybackState.LOADING ||
+            it == PlaybackState.BUFFERING ||
+            it == PlaybackState.PLAYING
+        }
+      ) {
+        progress++
+      }
+    lenient.setInterval(0.1)
+    lenient.onPlaybackStateChanged(PlaybackState.BUFFERING)
+    advanceTimeBy(350)
+    assertTrue("Expected events when buffering with lenient predicate", progress > 0)
+    lenient.setInterval(null)
+  }
+}

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

@@ -0,0 +1,36 @@
+package com.audiobrowser.player
+
+import com.audiobrowser.model.PlayerSetupOptions
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/** Pins the buffer-config mapping — the one decision inside engine construction. */
+class PlayerEngineFactoryTest {
+
+  @Test
+  fun `maps the buffer fields and converts to Int millis`() {
+    val config =
+      bufferConfig(
+        PlayerSetupOptions(
+          minBuffer = 1000.0,
+          maxBuffer = 5000.0,
+          playBuffer = 1500.0,
+          backBuffer = 2000.0,
+          rebufferBuffer = 3000.0,
+        )
+      )
+    assertEquals(1000, config.minBufferMs)
+    assertEquals(5000, config.maxBufferMs)
+    assertEquals(1500, config.bufferForPlaybackMs)
+    assertEquals(3000, config.bufferForPlaybackAfterRebufferMs)
+    assertEquals(2000, config.backBufferMs)
+  }
+
+  @Test
+  fun `automatic rebuffer falls back to playBuffer`() {
+    // rebufferBuffer unset = automatic: start post-rebuffer playback at playBuffer and let
+    // AutomaticBufferManager adjust from there.
+    val config = bufferConfig(PlayerSetupOptions(playBuffer = 1500.0, rebufferBuffer = null))
+    assertEquals(1500, config.bufferForPlaybackAfterRebufferMs)
+  }
+}

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

@@ -0,0 +1,268 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.C
+import androidx.media3.common.ParserException
+import androidx.media3.datasource.DataSourceException
+import androidx.media3.datasource.DataSpec
+import androidx.media3.datasource.HttpDataSource
+import androidx.media3.exoplayer.source.LoadEventInfo
+import androidx.media3.exoplayer.source.MediaLoadData
+import androidx.media3.exoplayer.upstream.LoadErrorHandlingPolicy
+import androidx.media3.exoplayer.upstream.Loader
+import java.io.FileNotFoundException
+import java.io.IOException
+import java.net.SocketTimeoutException
+import java.net.UnknownHostException
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotEquals
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.mockito.Mockito.mock
+
+class RetryLoadErrorHandlingPolicyTest {
+  // LoadEventInfo requires a DataSpec (Android Uri) to construct, so mock it.
+  // MediaLoadData has a dependency-free constructor. The policy only ever reads
+  // LoadErrorInfo.exception and LoadErrorInfo.errorCount.
+  private val loadEventInfo = mock(LoadEventInfo::class.java)
+  private val mediaLoadData = MediaLoadData(C.DATA_TYPE_MEDIA)
+
+  private fun errorInfo(exception: IOException, errorCount: Int = 1) =
+    LoadErrorHandlingPolicy.LoadErrorInfo(loadEventInfo, mediaLoadData, exception, errorCount)
+
+  /** Builds an [HttpDataSource.InvalidResponseCodeException] for the given HTTP status code. */
+  private fun httpError(responseCode: Int): HttpDataSource.InvalidResponseCodeException =
+    HttpDataSource.InvalidResponseCodeException(
+      responseCode,
+      "response message",
+      /* cause= */ null,
+      emptyMap(),
+      mock(DataSpec::class.java),
+      ByteArray(0),
+    )
+
+  /**
+   * Asserts the given error is classified non-recoverable: the default policy gives up (no retry is
+   * scheduled) and the network-retry callback is never armed.
+   */
+  private fun assertNonRecoverable(exception: IOException) {
+    var pendingNetwork: Boolean? = null
+    val policy =
+      RetryLoadErrorHandlingPolicy(
+        onRetryPending = { _, isNetworkError -> pendingNetwork = isNetworkError }
+      )
+    val delay = policy.getRetryDelayMsFor(errorInfo(exception))
+    assertEquals(C.TIME_UNSET, delay)
+    assertNull(pendingNetwork)
+  }
+
+  @Test
+  fun `offline network IOException is retried and arms the network-retry callback`() {
+    var pendingNetwork: Boolean? = null
+    val policy =
+      RetryLoadErrorHandlingPolicy(
+        maxRetries = null,
+        isOnline = { false },
+        onRetryPending = { _, isNetworkError -> pendingNetwork = isNetworkError },
+      )
+
+    // A wifi drop surfaces as a raw IOException from the socket/DNS layer, NOT a
+    // PlaybackException. This must still be treated as a recoverable network error.
+    val delay = policy.getRetryDelayMsFor(errorInfo(UnknownHostException("Unable to resolve host")))
+
+    // Recoverable -> a real (non-TIME_UNSET) retry delay is scheduled.
+    assertNotEquals(C.TIME_UNSET, delay)
+    // While offline we use the short fixed delay so reconnect can accelerate.
+    assertEquals(1000L, delay)
+    // The network-retry callback must be armed so connectivity restoration can
+    // trigger an immediate exoPlayer.prepare().
+    assertEquals(true, pendingNetwork)
+  }
+
+  @Test
+  fun `socket timeout is classified as a recoverable network error`() {
+    var pendingNetwork: Boolean? = null
+    val policy =
+      RetryLoadErrorHandlingPolicy(
+        isOnline = { true },
+        onRetryPending = { _, isNetworkError -> pendingNetwork = isNetworkError },
+      )
+
+    val delay = policy.getRetryDelayMsFor(errorInfo(SocketTimeoutException("timeout")))
+
+    assertNotEquals(C.TIME_UNSET, delay)
+    assertTrue("expected a positive retry delay, got $delay", delay > 0)
+    assertEquals(true, pendingNetwork)
+  }
+
+  @Test
+  fun `retry is skipped when shouldRetry is false`() {
+    val policy = RetryLoadErrorHandlingPolicy(shouldRetry = { false })
+    val delay = policy.getRetryDelayMsFor(errorInfo(UnknownHostException("offline")))
+    assertEquals(C.TIME_UNSET, delay)
+  }
+
+  @Test
+  fun `retry stops once max retries is exceeded`() {
+    val policy = RetryLoadErrorHandlingPolicy(maxRetries = 3)
+    val delay =
+      policy.getRetryDelayMsFor(errorInfo(UnknownHostException("offline"), errorCount = 4))
+    assertEquals(C.TIME_UNSET, delay)
+  }
+
+  @Test
+  fun `retryable HTTP status (503) is recoverable and arms the network-retry callback`() {
+    var pendingNetwork: Boolean? = null
+    val policy =
+      RetryLoadErrorHandlingPolicy(
+        isOnline = { true },
+        onRetryPending = { _, isNetworkError -> pendingNetwork = isNetworkError },
+      )
+
+    val delay = policy.getRetryDelayMsFor(errorInfo(httpError(503)))
+
+    assertNotEquals(C.TIME_UNSET, delay)
+    assertEquals(true, pendingNetwork)
+  }
+
+  @Test
+  fun `non-retryable HTTP status (404) is not retried`() {
+    var pendingNetwork: Boolean? = null
+    val policy =
+      RetryLoadErrorHandlingPolicy(
+        onRetryPending = { _, isNetworkError -> pendingNetwork = isNetworkError }
+      )
+
+    val delay = policy.getRetryDelayMsFor(errorInfo(httpError(404)))
+
+    // A 404 will never succeed on retry: stop immediately rather than spinning until the
+    // max-retry-duration timeout, and never arm the connectivity-restoration path.
+    assertEquals(C.TIME_UNSET, delay)
+    assertNull(pendingNetwork)
+  }
+
+  @Test
+  fun `parser errors are non-recoverable`() {
+    assertNonRecoverable(ParserException.createForMalformedContainer("bad container", null))
+  }
+
+  @Test
+  fun `file-not-found errors are non-recoverable`() {
+    assertNonRecoverable(FileNotFoundException("missing"))
+  }
+
+  @Test
+  fun `unexpected loader errors are non-recoverable`() {
+    assertNonRecoverable(Loader.UnexpectedLoaderException(IllegalStateException("boom")))
+  }
+
+  @Test
+  @Suppress("DEPRECATION") // DataSourceException(reason) is the only way to build this in a test
+  fun `reads past the available position are non-recoverable`() {
+    assertNonRecoverable(DataSourceException(DataSourceException.POSITION_OUT_OF_RANGE))
+  }
+}
+
+/**
+ * The two duration budgets: a never-played load gives up fast while online; a load that produced
+ * audio — or a device that is offline — keeps the full recovery budget. Clock-based: budgets are
+ * 100ms and the tests sleep 150ms between errors, comfortable margins in both directions.
+ */
+class RetryLoadErrorHandlingPolicyBudgetTest {
+  private val loadEventInfo = org.mockito.Mockito.mock(LoadEventInfo::class.java)
+  private val mediaLoadData = MediaLoadData(C.DATA_TYPE_MEDIA)
+
+  private fun errorInfo(errorCount: Int = 1) =
+    LoadErrorHandlingPolicy.LoadErrorInfo(
+      loadEventInfo,
+      mediaLoadData,
+      UnknownHostException("dead host"),
+      errorCount,
+    )
+
+  @Test
+  fun `never-played load gives up after the first-connect budget`() {
+    val policy =
+      RetryLoadErrorHandlingPolicy(firstConnectMaxRetryDurationMs = 100, hasPlayed = { false })
+
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
+    Thread.sleep(150)
+    assertEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 2)))
+  }
+
+  @Test
+  fun `played load ignores the first-connect budget`() {
+    val policy =
+      RetryLoadErrorHandlingPolicy(firstConnectMaxRetryDurationMs = 100, hasPlayed = { true })
+
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
+    Thread.sleep(150)
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 2)))
+  }
+
+  /**
+   * Offline failures must not burn the first-connect budget (a station tapped in a tunnel parks for
+   * connectivity); the budget's clock starts at the first error observed online, so a dead station
+   * still gets a fast verdict after restoration.
+   */
+  @Test
+  fun `offline time does not burn the first-connect budget`() {
+    var online = false
+    val policy =
+      RetryLoadErrorHandlingPolicy(
+        firstConnectMaxRetryDurationMs = 100,
+        isOnline = { online },
+        hasPlayed = { false },
+      )
+
+    // Offline: the short budget never engages.
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
+    Thread.sleep(150)
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 2)))
+
+    // Connectivity returns: the short clock starts now — one more error is
+    // retried, then the budget is spent.
+    online = true
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 3)))
+    Thread.sleep(150)
+    assertEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 4)))
+  }
+
+  /**
+   * An offline stretch in the middle of the budget must not count against it: any offline
+   * observation wipes the clock, which restarts at the next error observed online.
+   */
+  @Test
+  fun `offline stretch mid-budget restarts the first-connect clock`() {
+    var online = true
+    val policy =
+      RetryLoadErrorHandlingPolicy(
+        firstConnectMaxRetryDurationMs = 100,
+        isOnline = { online },
+        hasPlayed = { false },
+      )
+
+    // Online failure starts the clock, then the budget elapses while offline.
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
+    Thread.sleep(150)
+    online = false
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 2)))
+
+    // Back online: the clock restarted — a full budget remains.
+    online = true
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 3)))
+    Thread.sleep(150)
+    assertEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo(errorCount = 4)))
+  }
+
+  @Test
+  fun `reset restarts the first-connect clock`() {
+    val policy =
+      RetryLoadErrorHandlingPolicy(firstConnectMaxRetryDurationMs = 100, hasPlayed = { false })
+
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
+    Thread.sleep(150)
+    policy.reset()
+    assertNotEquals(C.TIME_UNSET, policy.getRetryDelayMsFor(errorInfo()))
+  }
+}

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

@@ -0,0 +1,68 @@
+package com.audiobrowser.player
+
+import androidx.media3.common.Player as MediaPlayer
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Truth table for the session-error masking that keeps the platform session alive through a
+ * terminal load error (Android Auto reads STATE_NONE as "nothing playing" and tears down the
+ * now-playing screen): idle+error masks to paused-but-ready, everything else passes through.
+ */
+class SessionErrorMaskTest {
+
+  @Test
+  fun `idle with an error masks to ready while keep-alive is on`() {
+    assertEquals(
+      MediaPlayer.STATE_READY,
+      SessionErrorMask.playbackState(MediaPlayer.STATE_IDLE, hasError = true, keepAlive = true),
+    )
+    assertEquals(
+      false,
+      SessionErrorMask.playWhenReady(
+        raw = true,
+        state = MediaPlayer.STATE_IDLE,
+        hasError = true,
+        keepAlive = true,
+      ),
+    )
+  }
+
+  @Test
+  fun `no masking without keep-alive`() {
+    assertEquals(
+      MediaPlayer.STATE_IDLE,
+      SessionErrorMask.playbackState(MediaPlayer.STATE_IDLE, hasError = true, keepAlive = false),
+    )
+    assertEquals(
+      true,
+      SessionErrorMask.playWhenReady(
+        raw = true,
+        state = MediaPlayer.STATE_IDLE,
+        hasError = true,
+        keepAlive = false,
+      ),
+    )
+  }
+
+  @Test
+  fun `no masking without an error or outside idle`() {
+    assertEquals(
+      MediaPlayer.STATE_IDLE,
+      SessionErrorMask.playbackState(MediaPlayer.STATE_IDLE, hasError = false, keepAlive = true),
+    )
+    assertEquals(
+      MediaPlayer.STATE_BUFFERING,
+      SessionErrorMask.playbackState(MediaPlayer.STATE_BUFFERING, hasError = true, keepAlive = true),
+    )
+    assertEquals(
+      true,
+      SessionErrorMask.playWhenReady(
+        raw = true,
+        state = MediaPlayer.STATE_READY,
+        hasError = true,
+        keepAlive = true,
+      ),
+    )
+  }
+}