react-native-queue-player 1.0.0

package/android/src/test/java/com/margelo/nitro/queueplayer/VisualizerKtTest.kt

@@ -0,0 +1,202 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.audio.TeeAudioProcessor
+import com.margelo.nitro.core.ArrayBuffer
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.util.concurrent.CopyOnWriteArrayList
+
+/**
+ * Wiring coverage for the [Visualizer] HybridObject — subscriber
+ * refcount, attach/detach lifecycle against a [PlaybackEngine],
+ * engine swap behaviour. Audio-thread frame emission is covered by
+ * [FFTProcessorTeeTest]; this test exercises only the Hybrid surface
+ * and the PlaybackEngine attach contract.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class VisualizerKtTest {
+
+  @After
+  fun clearStaticReference() {
+    Visualizer.current?.unwireFromPlaybackEngine()
+    Visualizer.current = null
+  }
+
+  private fun makeViz(): Visualizer = Visualizer()
+
+  private fun makeConfig(): VisualizerConfig =
+    VisualizerConfig(fftSize = 256.0, updateIntervalMs = 16.0, includeSamples = false)
+
+  @Test
+  fun `getSubscriberCount tracks subscribe and dispose`() {
+    val viz = makeViz()
+    assertEquals(0.0, viz.getSubscriberCount(), 0.0)
+    val d1 = viz.subscribe(makeConfig(), { _ -> }, { _ -> })
+    assertEquals(1.0, viz.getSubscriberCount(), 0.0)
+    val d2 = viz.subscribe(makeConfig(), { _ -> }, { _ -> })
+    assertEquals(2.0, viz.getSubscriberCount(), 0.0)
+    d1()
+    assertEquals(1.0, viz.getSubscriberCount(), 0.0)
+    d2()
+    assertEquals(0.0, viz.getSubscriberCount(), 0.0)
+  }
+
+  @Test
+  fun `dispose is idempotent and does not double-detach from the engine`() {
+    val viz = makeViz()
+    val engine = FakePlaybackEngineWithSinks()
+    viz.wireToPlaybackEngine(engine)
+    val d = viz.subscribe(makeConfig(), { _ -> }, { _ -> })
+    assertEquals(1.0, viz.getSubscriberCount(), 0.0)
+    assertEquals(1, engine.attachCount)
+    d()
+    d() // second call is a no-op
+    assertEquals(0.0, viz.getSubscriberCount(), 0.0)
+    assertEquals("detach must fire exactly once for one subscription", 1, engine.detachCount)
+  }
+
+  @Test
+  fun `subscribe before wire queues the processor and attaches on wire`() {
+    val viz = makeViz()
+    viz.subscribe(makeConfig(), { _ -> }, { _ -> })
+    val engine = FakePlaybackEngineWithSinks()
+    viz.wireToPlaybackEngine(engine)
+    assertEquals(1, engine.attachedSinks.size)
+  }
+
+  @Test
+  fun `subscribe after wire attaches immediately`() {
+    val viz = makeViz()
+    val engine = FakePlaybackEngineWithSinks()
+    viz.wireToPlaybackEngine(engine)
+    viz.subscribe(makeConfig(), { _ -> }, { _ -> })
+    assertEquals(1, engine.attachedSinks.size)
+  }
+
+  @Test
+  fun `dispose detaches from the wired engine`() {
+    val viz = makeViz()
+    val engine = FakePlaybackEngineWithSinks()
+    viz.wireToPlaybackEngine(engine)
+    val d = viz.subscribe(makeConfig(), { _ -> }, { _ -> })
+    assertEquals(1, engine.attachedSinks.size)
+    d()
+    assertEquals(0, engine.attachedSinks.size)
+  }
+
+  @Test
+  fun `wireToPlaybackEngine moves subscriptions across engine swaps`() {
+    val viz = makeViz()
+    viz.subscribe(makeConfig(), { _ -> }, { _ -> })
+    val first = FakePlaybackEngineWithSinks()
+    viz.wireToPlaybackEngine(first)
+    assertEquals(1, first.attachedSinks.size)
+
+    val second = FakePlaybackEngineWithSinks()
+    viz.wireToPlaybackEngine(second)
+    assertEquals("first engine should be detached on swap", 0, first.attachedSinks.size)
+    assertEquals("second engine should pick up the subscription", 1, second.attachedSinks.size)
+  }
+
+  @Test
+  fun `unwireFromPlaybackEngine detaches from the engine but keeps subscriptions`() {
+    val viz = makeViz()
+    val engine = FakePlaybackEngineWithSinks()
+    viz.wireToPlaybackEngine(engine)
+    viz.subscribe(makeConfig(), { _ -> }, { _ -> })
+    assertEquals(1, engine.attachedSinks.size)
+    viz.unwireFromPlaybackEngine()
+    assertEquals(0, engine.attachedSinks.size)
+    assertEquals("subscriber list survives unwire", 1.0, viz.getSubscriberCount(), 0.0)
+  }
+
+  @Test
+  fun `static current is set on construction and overwrites on rebuild`() {
+    val first = makeViz()
+    assertEquals(first, Visualizer.current)
+    val second = makeViz()
+    assertEquals(second, Visualizer.current)
+  }
+
+  @Test
+  fun `second construction tears down prior wiring before stealing static reference`() {
+    val first = makeViz()
+    val firstEngine = FakePlaybackEngineWithSinks()
+    first.wireToPlaybackEngine(firstEngine)
+    first.subscribe(makeConfig(), { _ -> }, { _ -> })
+    assertEquals(1, firstEngine.attachedSinks.size)
+
+    makeViz() // construction should clean up `first`'s wiring
+    assertEquals(
+      "prior instance's processor should be detached so audio-thread callbacks don't fire into stale JS",
+      0,
+      firstEngine.attachedSinks.size,
+    )
+    assertEquals(
+      "prior instance's subscriber list should be cleared so it can't re-attach if its disposers are called later",
+      0.0,
+      first.getSubscriberCount(),
+      0.0,
+    )
+  }
+}
+
+@UnstableApi
+private class FakePlaybackEngineWithSinks : PlaybackEngine {
+  val attachedSinks = CopyOnWriteArrayList<TeeAudioProcessor.AudioBufferSink>()
+  var attachCount: Int = 0
+    private set
+  var detachCount: Int = 0
+    private set
+
+  override val mediaSessionPlayer: androidx.media3.exoplayer.ExoPlayer
+    get() = error("not used in test")
+  override suspend fun prepare(
+    mediaItems: List<androidx.media3.common.MediaItem>, startIndex: Int, startPositionMs: Long,
+  ) = error("not used in test")
+  override fun release() = error("not used in test")
+  override fun setMediaItems(items: List<androidx.media3.common.MediaItem>, startIndex: Int, startPositionMs: Long) = error("not used in test")
+  override fun addMediaItems(items: List<androidx.media3.common.MediaItem>, insertBefore: Int) = error("not used in test")
+  override fun removeMediaItems(indices: IntArray) = error("not used in test")
+  override fun moveMediaItem(fromIndex: Int, toIndex: Int) = error("not used in test")
+  override fun play() = error("not used in test")
+  override fun pause() = error("not used in test")
+  override fun stop() = error("not used in test")
+  override fun seekTo(index: Int, positionMs: Long) = error("not used in test")
+  override fun skipToNext() = error("not used in test")
+  override fun skipToPrevious() = error("not used in test")
+  override fun setVolume(volume: Float) = error("not used in test")
+  override fun setPlaybackSpeed(speed: Float) = error("not used in test")
+  override fun setRepeatMode(mode: RepeatMode) = error("not used in test")
+  override fun setPitchCorrectionMode(mode: PitchCorrectionMode) = error("not used in test")
+  override fun setWakeMode(mode: Int) = error("not used in test")
+  override val currentMediaItemIndex: Int get() = error("not used in test")
+  override val currentPositionMs: Long get() = error("not used in test")
+  override val currentDurationMs: Long get() = error("not used in test")
+  override val bufferedPositionMs: Long get() = error("not used in test")
+  override val isPlaying: Boolean get() = error("not used in test")
+  override val currentMediaItem: androidx.media3.common.MediaItem? get() = error("not used in test")
+  override val allMediaItems: List<androidx.media3.common.MediaItem> get() = error("not used in test")
+  override fun currentAudioSessionIds(): IntArray = IntArray(0)
+  override fun addAudioSessionIdListener(listener: (IntArray) -> Unit): () -> Unit = { /* noop */ }
+  override fun attachAudioBufferSink(sink: TeeAudioProcessor.AudioBufferSink) {
+    if (attachedSinks.addIfAbsent(sink)) attachCount++
+  }
+  override fun detachAudioBufferSink(sink: TeeAudioProcessor.AudioBufferSink) {
+    if (attachedSinks.remove(sink)) detachCount++
+  }
+  override suspend fun handoff(to: PlaybackEngine, atTrackBoundary: Boolean) = error("not used in test")
+  override var delegate: PlaybackEngineDelegate? = null
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/VoiceSearchExtrasParserTest.kt

@@ -0,0 +1,211 @@
+package com.margelo.nitro.queueplayer
+
+import android.os.Bundle
+import android.provider.MediaStore
+import androidx.media3.common.util.UnstableApi
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNull
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * Coverage for [VoiceSearchExtrasParser]. Robolectric is required
+ * because the Bundle access path uses the Android shadow.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class VoiceSearchExtrasParserTest {
+
+  private companion object {
+    // Wire value Assistant/Android Auto send for the playlist slot,
+    // held as a literal so this test independently pins the key the
+    // parser reads (the platform's MediaStore constant is deprecated).
+    const val EXTRA_MEDIA_PLAYLIST = "android.intent.extra.playlist"
+  }
+
+  // --- mediaSearchTypeFor — focus MIME taxonomy
+
+  @Test
+  fun `artist focus maps to ARTIST`() {
+    assertEquals(
+      MediaSearchType.ARTIST,
+      VoiceSearchExtrasParser.mediaSearchTypeFor("vnd.android.cursor.item/artist")
+    )
+  }
+
+  @Test
+  fun `album focus maps to ALBUM`() {
+    assertEquals(
+      MediaSearchType.ALBUM,
+      VoiceSearchExtrasParser.mediaSearchTypeFor("vnd.android.cursor.item/album")
+    )
+  }
+
+  @Test
+  fun `audio focus maps to SONG`() {
+    assertEquals(
+      MediaSearchType.SONG,
+      VoiceSearchExtrasParser.mediaSearchTypeFor("vnd.android.cursor.item/audio")
+    )
+  }
+
+  @Test
+  fun `playlist focus maps to PLAYLIST`() {
+    assertEquals(
+      MediaSearchType.PLAYLIST,
+      VoiceSearchExtrasParser.mediaSearchTypeFor("vnd.android.cursor.item/playlist")
+    )
+  }
+
+  @Test
+  fun `genre focus maps to GENRE`() {
+    assertEquals(
+      MediaSearchType.GENRE,
+      VoiceSearchExtrasParser.mediaSearchTypeFor("vnd.android.cursor.item/genre")
+    )
+  }
+
+  @Test
+  fun `unrecognised focus returns null type`() {
+    assertNull(VoiceSearchExtrasParser.mediaSearchTypeFor("vnd.android.cursor.item/something"))
+    assertNull(VoiceSearchExtrasParser.mediaSearchTypeFor(""))
+    assertNull(VoiceSearchExtrasParser.mediaSearchTypeFor(null))
+  }
+
+  // --- parse — full request shape
+
+  @Test
+  fun `null extras yields query-only request with all named slots null`() {
+    val r = VoiceSearchExtrasParser.parse("rock anthems", extras = null)
+    assertEquals("rock anthems", r.query)
+    assertNull(r.type)
+    assertNull(r.artist)
+    assertNull(r.album)
+    assertNull(r.song)
+    assertNull(r.playlist)
+    assertNull(r.genre)
+  }
+
+  @Test
+  fun `empty extras yields query-only request`() {
+    val r = VoiceSearchExtrasParser.parse("rock", extras = Bundle())
+    assertEquals("rock", r.query)
+    assertNull(r.type)
+    assertNull(r.artist)
+  }
+
+  @Test
+  fun `artist focus + EXTRA_MEDIA_ARTIST populates artist field`() {
+    val extras = Bundle().apply {
+      putString(MediaStore.EXTRA_MEDIA_FOCUS, "vnd.android.cursor.item/artist")
+      putString(MediaStore.EXTRA_MEDIA_ARTIST, "The xx")
+    }
+    val r = VoiceSearchExtrasParser.parse("The xx", extras)
+    assertEquals(MediaSearchType.ARTIST, r.type)
+    assertEquals("The xx", r.artist)
+  }
+
+  @Test
+  fun `album focus + EXTRA_MEDIA_ALBUM populates album field`() {
+    val extras = Bundle().apply {
+      putString(MediaStore.EXTRA_MEDIA_FOCUS, "vnd.android.cursor.item/album")
+      putString(MediaStore.EXTRA_MEDIA_ALBUM, "xx")
+      putString(MediaStore.EXTRA_MEDIA_ARTIST, "The xx")
+    }
+    val r = VoiceSearchExtrasParser.parse("xx by The xx", extras)
+    assertEquals(MediaSearchType.ALBUM, r.type)
+    assertEquals("xx", r.album)
+    assertEquals("The xx", r.artist)
+  }
+
+  @Test
+  fun `audio focus + EXTRA_MEDIA_TITLE populates song field`() {
+    val extras = Bundle().apply {
+      putString(MediaStore.EXTRA_MEDIA_FOCUS, "vnd.android.cursor.item/audio")
+      putString(MediaStore.EXTRA_MEDIA_TITLE, "Intro")
+      putString(MediaStore.EXTRA_MEDIA_ARTIST, "The xx")
+      putString(MediaStore.EXTRA_MEDIA_ALBUM, "xx")
+    }
+    val r = VoiceSearchExtrasParser.parse("Intro by The xx", extras)
+    assertEquals(MediaSearchType.SONG, r.type)
+    assertEquals("Intro", r.song)
+    assertEquals("The xx", r.artist)
+    assertEquals("xx", r.album)
+  }
+
+  @Test
+  fun `playlist focus + EXTRA_MEDIA_PLAYLIST populates playlist field`() {
+    val extras = Bundle().apply {
+      putString(MediaStore.EXTRA_MEDIA_FOCUS, "vnd.android.cursor.item/playlist")
+      putString(EXTRA_MEDIA_PLAYLIST, "Workout Mix")
+    }
+    val r = VoiceSearchExtrasParser.parse("Workout Mix", extras)
+    assertEquals(MediaSearchType.PLAYLIST, r.type)
+    assertEquals("Workout Mix", r.playlist)
+  }
+
+  @Test
+  fun `genre focus + EXTRA_MEDIA_GENRE populates genre field`() {
+    val extras = Bundle().apply {
+      putString(MediaStore.EXTRA_MEDIA_FOCUS, "vnd.android.cursor.item/genre")
+      putString(MediaStore.EXTRA_MEDIA_GENRE, "Indie Rock")
+    }
+    val r = VoiceSearchExtrasParser.parse("Indie Rock", extras)
+    assertEquals(MediaSearchType.GENRE, r.type)
+    assertEquals("Indie Rock", r.genre)
+  }
+
+  @Test
+  fun `unknown focus + named slots still surface the slot values`() {
+    // The catch-all "vnd.android.cursor.item/*" focus arrives when
+    // Assistant recognised slots but couldn't pin a category. Slot
+    // fields should still surface so consumers can fuzzy-match.
+    val extras = Bundle().apply {
+      putString(MediaStore.EXTRA_MEDIA_FOCUS, "vnd.android.cursor.item/*")
+      putString(MediaStore.EXTRA_MEDIA_ARTIST, "Some Artist")
+      putString(MediaStore.EXTRA_MEDIA_ALBUM, "Some Album")
+    }
+    val r = VoiceSearchExtrasParser.parse("query", extras)
+    assertNull(r.type)
+    assertEquals("Some Artist", r.artist)
+    assertEquals("Some Album", r.album)
+  }
+
+  @Test
+  fun `extras with no focus key returns null type but still reads named slots`() {
+    val extras = Bundle().apply {
+      putString(MediaStore.EXTRA_MEDIA_ARTIST, "Standalone Artist")
+    }
+    val r = VoiceSearchExtrasParser.parse("query", extras)
+    assertNull(r.type)
+    assertEquals("Standalone Artist", r.artist)
+  }
+
+  @Test
+  fun `empty query is preserved through the parse`() {
+    val r = VoiceSearchExtrasParser.parse("", null)
+    assertEquals("", r.query)
+  }
+
+  @Test
+  fun `every named slot can populate from a single extras bundle`() {
+    val extras = Bundle().apply {
+      putString(MediaStore.EXTRA_MEDIA_FOCUS, "vnd.android.cursor.item/audio")
+      putString(MediaStore.EXTRA_MEDIA_ARTIST, "A")
+      putString(MediaStore.EXTRA_MEDIA_ALBUM, "B")
+      putString(MediaStore.EXTRA_MEDIA_TITLE, "C")
+      putString(EXTRA_MEDIA_PLAYLIST, "D")
+      putString(MediaStore.EXTRA_MEDIA_GENRE, "E")
+    }
+    val r = VoiceSearchExtrasParser.parse("query", extras)
+    assertEquals(MediaSearchType.SONG, r.type)
+    assertEquals("A", r.artist)
+    assertEquals("B", r.album)
+    assertEquals("C", r.song)
+    assertEquals("D", r.playlist)
+    assertEquals("E", r.genre)
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/cast/CastSinkRouterTest.kt

@@ -0,0 +1,120 @@
+package com.margelo.nitro.queueplayer.cast
+
+import android.media.AudioDeviceInfo
+import androidx.media3.common.AudioAttributes
+import androidx.media3.common.AuxEffectInfo
+import androidx.media3.common.Format
+import androidx.media3.common.PlaybackParameters
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.audio.AudioOffloadSupport
+import androidx.media3.exoplayer.audio.AudioSink
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+import java.nio.ByteBuffer
+
+/**
+ * Unit coverage for [CastSinkRouter] — the route-change signal hub +
+ * active-session holder for AirPlay push-PCM sessions. The audio itself is
+ * carried by the dedicated `AirPlayEngine`; this object just records the active
+ * session and broadcasts activate/deactivate transitions.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class CastSinkRouterTest {
+
+  @After
+  fun teardown() {
+    // Singleton state survives across tests; clear so the next starts clean.
+    CastSinkRouter.clearActiveSession()
+  }
+
+  @Test
+  fun `setActiveSession marks remote active and records the session`() {
+    assertFalse("no remote before activate", CastSinkRouter.isRemoteActive())
+
+    val session = FakePcmStreamSession(FakeAudioSink())
+    CastSinkRouter.setActiveSession(session)
+
+    assertTrue("remote active after setActiveSession", CastSinkRouter.isRemoteActive())
+    assertSame("activeSession returns the recorded session", session, CastSinkRouter.activeSession())
+
+    CastSinkRouter.clearActiveSession()
+    assertFalse("no remote after clear", CastSinkRouter.isRemoteActive())
+    assertEquals("activeSession null after clear", null, CastSinkRouter.activeSession())
+  }
+
+  @Test
+  fun `setActiveSession + clearActiveSession fire route-change listeners`() {
+    val transitions = mutableListOf<Boolean>()
+    val dispose = CastSinkRouter.addRouteChangeListener { active -> transitions.add(active) }
+    try {
+      CastSinkRouter.setActiveSession(FakePcmStreamSession(FakeAudioSink()))
+      CastSinkRouter.clearActiveSession()
+      assertEquals("router fires activate then deactivate", listOf(true, false), transitions)
+    } finally {
+      dispose()
+    }
+  }
+
+  @Test
+  fun `addRouteChangeListener does not replay current state on subscribe`() {
+    CastSinkRouter.setActiveSession(FakePcmStreamSession(FakeAudioSink()))
+
+    val seen = mutableListOf<Boolean>()
+    val dispose = CastSinkRouter.addRouteChangeListener { active -> seen.add(active) }
+    try {
+      assertTrue("no synchronous replay — subscribe is a pure transition stream", seen.isEmpty())
+    } finally {
+      dispose()
+    }
+  }
+
+  // ----- Test fakes -----
+
+  private class FakePcmStreamSession(private val sink: AudioSink) : CastSession.PcmStream() {
+    override fun audioSink(): AudioSink = sink
+    override fun setVolume(value: Float) { /* no-op */ }
+    override fun close() { /* no-op */ }
+  }
+
+  /** Minimal no-op [AudioSink] — only needed to satisfy `audioSink()`. */
+  private class FakeAudioSink : AudioSink {
+    override fun setListener(listener: AudioSink.Listener) {}
+    override fun supportsFormat(format: Format): Boolean = true
+    override fun getFormatSupport(format: Format): Int = AudioSink.SINK_FORMAT_SUPPORTED_DIRECTLY
+    override fun configure(inputFormat: Format, specifiedBufferSize: Int, outputChannels: IntArray?) {}
+    override fun play() {}
+    override fun handleDiscontinuity() {}
+    override fun handleBuffer(buffer: ByteBuffer, presentationTimeUs: Long, encodedAccessUnitCount: Int): Boolean = true
+    override fun playToEndOfStream() {}
+    override fun isEnded(): Boolean = false
+    override fun hasPendingData(): Boolean = false
+    override fun getCurrentPositionUs(sourceEnded: Boolean): Long = 0L
+    override fun flush() {}
+    override fun reset() {}
+    override fun release() {}
+    override fun pause() {}
+    override fun setPlaybackParameters(playbackParameters: PlaybackParameters) {}
+    override fun getPlaybackParameters(): PlaybackParameters = PlaybackParameters.DEFAULT
+    override fun setSkipSilenceEnabled(skipSilenceEnabled: Boolean) {}
+    override fun getSkipSilenceEnabled(): Boolean = false
+    override fun setAudioAttributes(audioAttributes: AudioAttributes) {}
+    override fun getAudioAttributes(): AudioAttributes? = null
+    override fun setAudioSessionId(audioSessionId: Int) {}
+    override fun setAuxEffectInfo(auxEffectInfo: AuxEffectInfo) {}
+    override fun setPreferredDevice(audioDeviceInfo: AudioDeviceInfo?) {}
+    override fun setVolume(volume: Float) {}
+    override fun enableTunnelingV21() {}
+    override fun disableTunneling() {}
+    override fun getFormatOffloadSupport(format: Format): AudioOffloadSupport = AudioOffloadSupport.DEFAULT_UNSUPPORTED
+    override fun getAudioTrackBufferSizeUs(): Long = 0L
+  }
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/cast/FakeRemotePlayer.kt

@@ -0,0 +1,62 @@
+package com.margelo.nitro.queueplayer.cast
+
+import androidx.media3.common.Player
+import kotlinx.coroutines.flow.MutableSharedFlow
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.SharedFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asSharedFlow
+import kotlinx.coroutines.flow.asStateFlow
+
+/**
+ * Test double for [CastSession.RemotePlayer]. Transport calls are no-ops;
+ * the StateFlows are driveable via the public `_`-prefixed backing
+ * fields; [mediaSessionPlayer] is injectable so bind tests can assert the
+ * MediaSession swaps to it.
+ */
+internal class FakeRemotePlayer(
+  private val player: Player? = null,
+) : CastSession.RemotePlayer() {
+
+  override val mediaSessionPlayer: Player? get() = player
+
+  val backingState = MutableStateFlow(RemotePlaybackState.IDLE)
+  val backingPositionMs = MutableStateFlow(0L)
+  val backingDurationMs = MutableStateFlow(0L)
+  val backingCurrentTrackIndex = MutableStateFlow(-1)
+  private val backingEnded = MutableSharedFlow<RemoteEndReason>(extraBufferCapacity = 4)
+  private val backingError = MutableSharedFlow<RemoteMediaError>(extraBufferCapacity = 4)
+  private val backingSeek = MutableSharedFlow<Long>(extraBufferCapacity = 4)
+
+  override val state: StateFlow<RemotePlaybackState> = backingState.asStateFlow()
+  override val positionMs: StateFlow<Long> = backingPositionMs.asStateFlow()
+  override val durationMs: StateFlow<Long> = backingDurationMs.asStateFlow()
+  override val currentTrackIndex: StateFlow<Int> = backingCurrentTrackIndex.asStateFlow()
+  override val endedReason: SharedFlow<RemoteEndReason> = backingEnded.asSharedFlow()
+  override val mediaError: SharedFlow<RemoteMediaError> = backingError.asSharedFlow()
+  override val seekCompleted: SharedFlow<Long> = backingSeek.asSharedFlow()
+
+  override fun setVolume(value: Float) {}
+  override fun close() {}
+  override fun play() {}
+  override fun pause() {}
+  override fun stop() {}
+  override fun seekTo(positionMs: Long) {}
+  override fun queueNext() {}
+  override fun queuePrev() {}
+  override fun skipToQueueIndex(index: Int) {}
+  override fun setPlaybackRate(rate: Float) {}
+  override fun setRepeatMode(mode: RemoteRepeatMode) {}
+
+  override suspend fun load(
+    items: List<CastMediaItem>,
+    startIndex: Int,
+    startPositionMs: Long,
+    playWhenReady: Boolean,
+  ) {}
+
+  override suspend fun queueInsert(items: List<CastMediaItem>, beforeIndex: Int?) {}
+  override suspend fun queueRemove(indices: List<Int>) {}
+  override suspend fun queueMove(fromIndex: Int, toIndex: Int) {}
+  override suspend fun queueClear() {}
+}

package/android/src/test/java/com/margelo/nitro/queueplayer/cast/PlaybackStateRouterTest.kt

@@ -0,0 +1,43 @@
+package com.margelo.nitro.queueplayer.cast
+
+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.annotation.Config
+
+/**
+ * `PlaybackStateRouter.clearActive` is a compare-and-clear: it clears the
+ * active session only when it still matches the expected one, so a newer
+ * session that registered in parallel isn't wiped out by a closing
+ * session's teardown.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+class PlaybackStateRouterTest {
+
+  @After
+  fun tearDown() {
+    PlaybackStateRouter.setActive(null)
+  }
+
+  @Test
+  fun `clearActive clears the matching session`() {
+    val session = FakeRemotePlayer()
+    PlaybackStateRouter.setActive(session)
+    assertSame(session, PlaybackStateRouter.activeRemote())
+    PlaybackStateRouter.clearActive(session)
+    assertNull(PlaybackStateRouter.activeRemote())
+  }
+
+  @Test
+  fun `clearActive leaves a non-matching session active`() {
+    val active = FakeRemotePlayer()
+    val unrelated = FakeRemotePlayer()
+    PlaybackStateRouter.setActive(active)
+    PlaybackStateRouter.clearActive(unrelated)
+    assertSame(active, PlaybackStateRouter.activeRemote())
+  }
+}