react-native-queue-player 1.1.2 → 2.0.0

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

@@ -0,0 +1,258 @@
+package com.margelo.nitro.queueplayer
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+/**
+ * Coverage for [ReplayGainData.merge] — the all-or-nothing, per-item
+ * choice between consumer-supplied ReplayGain and values detected from
+ * the file. Mirrors the iOS `ReplayGainMergeTests` matrix row for row,
+ * with the same fixtures, so both platforms hold the same rule.
+ *
+ * The rule is one predicate on the item, not two pair decisions and not
+ * four field decisions: a claimed track's ReplayGain comes solely from
+ * the consumer and detection is discarded in full — including for the
+ * mode the consumer said nothing about. `merge` takes the claim and the
+ * surviving values as two separate inputs; which fields make a claim and
+ * which values survive is [SuppliedReplayGain]'s job, covered in
+ * `SuppliedReplayGainTest`.
+ *
+ * Supplied and detected fixtures carry different values in every field,
+ * so a row that returned the wrong source cannot pass.
+ */
+class ReplayGainMergeTest {
+
+  // region Fixtures
+
+  private val detectedAll = ReplayGainData(
+    trackGainDb = -20.0f, trackPeak = 0.5f,
+    albumGainDb = -6.0f, albumPeak = 0.6f,
+  )
+  private val detectedTrackOnly = ReplayGainData(
+    trackGainDb = -20.0f, trackPeak = 0.5f,
+    albumGainDb = null, albumPeak = null,
+  )
+  private val detectedAlbumOnly = ReplayGainData(
+    trackGainDb = null, trackPeak = null,
+    albumGainDb = -6.0f, albumPeak = 0.6f,
+  )
+
+  private val suppliedAll = ReplayGainData(
+    trackGainDb = -3.0f, trackPeak = 0.25f,
+    albumGainDb = -9.0f, albumPeak = 0.3f,
+  )
+  private val suppliedTrackGain = ReplayGainData(
+    trackGainDb = -3.0f, trackPeak = null,
+    albumGainDb = null, albumPeak = null,
+  )
+  private val suppliedAlbumGain = ReplayGainData(
+    trackGainDb = null, trackPeak = null,
+    albumGainDb = -9.0f, albumPeak = null,
+  )
+  private val suppliedTrackPeak = ReplayGainData(
+    trackGainDb = null, trackPeak = 0.25f,
+    albumGainDb = null, albumPeak = null,
+  )
+  private val suppliedAlbumPeak = ReplayGainData(
+    trackGainDb = null, trackPeak = null,
+    albumGainDb = null, albumPeak = 0.3f,
+  )
+  private val suppliedTrackPair = ReplayGainData(
+    trackGainDb = -3.0f, trackPeak = 0.25f,
+    albumGainDb = null, albumPeak = null,
+  )
+  private val suppliedAlbumPair = ReplayGainData(
+    trackGainDb = null, trackPeak = null,
+    albumGainDb = -9.0f, albumPeak = 0.3f,
+  )
+
+  // endregion
+
+  // region No claim — detection is used verbatim
+
+  @Test
+  fun `an unclaimed track uses every detected field`() {
+    assertMerge(
+      claimed = false, supplied = null, detected = detectedAll,
+      expected = detectedAll,
+      message = "no supplied field means detection is used, all four",
+    )
+  }
+
+  @Test
+  fun `an unclaimed track with no detection has no ReplayGain`() {
+    assertMerge(
+      claimed = false, supplied = null, detected = null,
+      expected = null,
+      message = "nothing supplied and nothing detected is no ReplayGain",
+    )
+  }
+
+  @Test
+  fun `an unclaimed track keeps a track-only detection`() {
+    assertMerge(
+      claimed = false, supplied = null, detected = detectedTrackOnly,
+      expected = detectedTrackOnly,
+      message = "a partial detection is used as-is, not padded",
+    )
+  }
+
+  @Test
+  fun `an unclaimed track keeps an album-only detection`() {
+    assertMerge(
+      claimed = false, supplied = null, detected = detectedAlbumOnly,
+      expected = detectedAlbumOnly,
+      message = "the mirrored partial-detection case",
+    )
+  }
+
+  // endregion
+
+  // region Claimed — one supplied field discards all detection
+
+  @Test
+  fun `a supplied track gain discards every detected field`() {
+    assertMerge(
+      claimed = true, supplied = suppliedTrackGain, detected = detectedAll,
+      expected = suppliedTrackGain,
+      message = "supplied trackGain applies; detected peak and album pair are dropped",
+    )
+  }
+
+  @Test
+  fun `a supplied album gain discards every detected field`() {
+    assertMerge(
+      claimed = true, supplied = suppliedAlbumGain, detected = detectedAll,
+      expected = suppliedAlbumGain,
+      message = "supplied albumGain applies; detected track pair and album peak are dropped",
+    )
+  }
+
+  @Test
+  fun `a supplied track peak alone leaves no gain anywhere`() {
+    assertMerge(
+      claimed = true, supplied = suppliedTrackPeak, detected = detectedAll,
+      expected = suppliedTrackPeak,
+      message = "a peak with no gain is ownership with nothing to apply",
+    )
+  }
+
+  @Test
+  fun `a supplied album peak alone leaves no gain anywhere`() {
+    assertMerge(
+      claimed = true, supplied = suppliedAlbumPeak, detected = detectedAll,
+      expected = suppliedAlbumPeak,
+      message = "the mirrored peak-only case",
+    )
+  }
+
+  @Test
+  fun `a supplied track pair discards the detected album pair`() {
+    assertMerge(
+      claimed = true, supplied = suppliedTrackPair, detected = detectedAll,
+      expected = suppliedTrackPair,
+      message = "album mode plays at unity even though the file carries album tags",
+    )
+  }
+
+  @Test
+  fun `a supplied album pair discards the detected track pair`() {
+    assertMerge(
+      claimed = true, supplied = suppliedAlbumPair, detected = detectedAll,
+      expected = suppliedAlbumPair,
+      message = "track mode plays at unity even though the file carries track tags",
+    )
+  }
+
+  @Test
+  fun `a fully supplied set replaces a fully detected set`() {
+    assertMerge(
+      claimed = true, supplied = suppliedAll, detected = detectedAll,
+      expected = suppliedAll,
+      message = "all four supplied values win over all four detected values",
+    )
+  }
+
+  @Test
+  fun `a supplied track gain discards an album-only detection`() {
+    assertMerge(
+      claimed = true, supplied = suppliedTrackGain, detected = detectedAlbumOnly,
+      expected = suppliedTrackGain,
+      message = "detection is discarded even where supplied and detected do not overlap",
+    )
+  }
+
+  // endregion
+
+  // region Claimed with no detection to discard
+
+  @Test
+  fun `a fully supplied set applies to an untagged file`() {
+    assertMerge(
+      claimed = true, supplied = suppliedAll, detected = null,
+      expected = suppliedAll,
+      message = "a supplied set is applied where the file carries no tags",
+    )
+  }
+
+  @Test
+  fun `a supplied track gain applies to an untagged file`() {
+    assertMerge(
+      claimed = true, supplied = suppliedTrackGain, detected = null,
+      expected = suppliedTrackGain,
+      message = "a single supplied field on an untagged file applies alone",
+    )
+  }
+
+  // endregion
+
+  // region Claimed but nothing usable — ownership without a value
+
+  @Test
+  fun `a claim with no usable value discards a full detection`() {
+    assertMerge(
+      claimed = true, supplied = null, detected = detectedAll,
+      expected = null,
+      message = "a claim discards detection even when it carries no value",
+    )
+  }
+
+  @Test
+  fun `a claim with no usable value discards a partial detection`() {
+    assertMerge(
+      claimed = true, supplied = null, detected = detectedTrackOnly,
+      expected = null,
+      message = "a partial detection is discarded by a claim just as a full one is",
+    )
+  }
+
+  @Test
+  fun `a claim with no usable value and no detection has no ReplayGain`() {
+    assertMerge(
+      claimed = true, supplied = null, detected = null,
+      expected = null,
+      message = "ownership claimed, nothing supplied, nothing detected",
+    )
+  }
+
+  // endregion
+
+  // region Helper
+
+  private fun assertMerge(
+    claimed: Boolean,
+    supplied: ReplayGainData?,
+    detected: ReplayGainData?,
+    expected: ReplayGainData?,
+    message: String,
+  ) {
+    val actual = ReplayGainData.merge(
+      suppliedClaimed = claimed,
+      supplied = supplied,
+      detected = detected,
+    )
+    assertEquals(message, expected, actual)
+  }
+
+  // endregion
+}

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

@@ -41,13 +41,17 @@ import org.robolectric.android.controller.ServiceController
  * enforces a unique session ID per JVM and a leaked session
  * blocks the next [PlaybackService.onCreate] in the same run.
  *
- * Standard Robolectric service-lifecycle plumbing — no test
- * injection seam on the lib side.
+ * Standard Robolectric service-lifecycle driving — no test
+ * injection point on the lib side.
  */
 @UnstableApi
 internal class PlaybackServiceTestHandle(
-  private val controller: ServiceController<PlaybackService>
+  private val controller: ServiceController<PlaybackService>,
+  private val binder: PlaybackService.LocalBinder,
 ) {
+  /** The bound service's live engine, for asserting local-path transport. */
+  val engine: PlaybackEngine get() = binder.engine
+
   fun destroy() {
     controller.destroy()
   }
@@ -79,5 +83,5 @@ internal fun bindPlaybackServiceForTest(
     deferred.await()
   }
 
-  return PlaybackServiceTestHandle(controller)
+  return PlaybackServiceTestHandle(controller, binder as PlaybackService.LocalBinder)
 }

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

@@ -27,7 +27,7 @@ import org.robolectric.annotation.Config
  *
  * The wrapper's `handle*` overrides are `protected` on a `final`
  * Kotlin class, so the suite drives them through [HandleDriver] — a
- * thin reflection seam onto the exact overridden methods — to assert
+ * thin reflection helper into the exact overridden methods — to assert
  * the routing directly without standing up a live `MediaController`.
  *
  * Controller-vs-internal gating turns on whether
@@ -422,7 +422,7 @@ class SessionCommandForwardingPlayerTest {
   }
 
   /**
-   * Reflection seam onto a [SessionCommandForwardingPlayer]'s
+   * Reflection helper into a [SessionCommandForwardingPlayer]'s
    * `protected` `handle*` overrides. The wrapper is a `final` Kotlin
    * class so it cannot be subclassed; reflecting straight onto the
    * declared overrides invokes the exact production methods without

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

@@ -0,0 +1,19 @@
+package com.margelo.nitro.queueplayer
+
+import android.media.audiofx.DynamicsProcessing
+import org.robolectric.annotation.Implements
+import org.robolectric.shadows.ShadowDynamicsProcessing
+
+/**
+ * A [DynamicsProcessing] whose construction and band writes succeed and
+ * whose `setEnabled` throws. The framework constructor never calls
+ * `setEnabled`; the engine does, after applying the bands and before
+ * recording the attach — so this is the one call that fails an attach
+ * inside its configure step rather than at construction.
+ */
+@Implements(DynamicsProcessing::class)
+class ShadowDynamicsProcessingRejectingEnable : ShadowDynamicsProcessing() {
+
+  override fun native_setEnabled(enabled: Boolean): Int =
+    throw IllegalStateException("setEnabled() called on uninitialized AudioEffect")
+}

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

@@ -0,0 +1,68 @@
+package com.margelo.nitro.queueplayer
+
+import android.media.audiofx.Equalizer
+import org.robolectric.annotation.Implements
+import org.robolectric.shadows.ShadowAudioEffect
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import java.util.Optional
+
+/**
+ * Models a five-band hardware equalizer so the legacy attach path resolves
+ * the same way on every run.
+ *
+ * [ShadowAudioEffect] answers the AudioEffect surface but falls back to a
+ * four-byte zero for any parameter it does not know, which the constructor's
+ * `short` reads cannot hold — so constructing an [Equalizer] throws before
+ * any band is queried. Supplying the parameters it reads makes a real attach
+ * distinguishable from a failed one. Levels written with `setBandLevel` land
+ * in the base shadow's parameter map, so they read back through the ordinary
+ * [Equalizer] API.
+ */
+@Implements(Equalizer::class)
+open class ShadowEqualizer : ShadowAudioEffect() {
+
+  override fun getDefaultParameter(parameter: ByteBuffer): Optional<ByteBuffer> {
+    val key = parameter.duplicate().order(ByteOrder.nativeOrder())
+    if (key.remaining() < Int.SIZE_BYTES) return Optional.empty()
+    return when (key.int) {
+      PARAM_NUM_BANDS -> Optional.of(shorts(BAND_COUNT))
+      PARAM_LEVEL_RANGE -> Optional.of(shorts(MIN_LEVEL_MB, MAX_LEVEL_MB))
+      PARAM_BAND_LEVEL -> Optional.of(shorts(0))
+      PARAM_GET_NUM_OF_PRESETS -> Optional.of(shorts(0))
+      PARAM_CENTER_FREQ -> {
+        val band = if (key.remaining() >= Int.SIZE_BYTES) key.int else 0
+        Optional.of(ints(CENTER_FREQS_MILLI_HZ[band.coerceIn(0, BAND_COUNT - 1)]))
+      }
+      else -> Optional.empty()
+    }
+  }
+
+  private fun shorts(vararg values: Int): ByteBuffer =
+    ByteBuffer.allocate(values.size * Short.SIZE_BYTES).order(ByteOrder.nativeOrder()).apply {
+      values.forEach { putShort(it.toShort()) }
+      flip()
+    }
+
+  private fun ints(vararg values: Int): ByteBuffer =
+    ByteBuffer.allocate(values.size * Int.SIZE_BYTES).order(ByteOrder.nativeOrder()).apply {
+      values.forEach { putInt(it) }
+      flip()
+    }
+
+  companion object {
+    const val BAND_COUNT = 5
+    const val MIN_LEVEL_MB = -1500
+    const val MAX_LEVEL_MB = 1500
+
+    /** Centre frequencies in milliHz, matching a typical OEM five-band set. */
+    private val CENTER_FREQS_MILLI_HZ =
+      intArrayOf(60_000, 230_000, 910_000, 3_600_000, 14_000_000)
+
+    private const val PARAM_NUM_BANDS = 0
+    private const val PARAM_LEVEL_RANGE = 1
+    private const val PARAM_BAND_LEVEL = 2
+    private const val PARAM_CENTER_FREQ = 3
+    private const val PARAM_GET_NUM_OF_PRESETS = 7
+  }
+}

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

@@ -0,0 +1,27 @@
+package com.margelo.nitro.queueplayer
+
+import android.media.audiofx.AudioEffect
+import android.media.audiofx.Equalizer
+import org.robolectric.annotation.Implements
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+/**
+ * A five-band equalizer whose construction and parameter reads succeed and
+ * whose first band-level write fails, so an attach reaches its configure
+ * step and throws there. `Equalizer.setBandLevel` routes the returned error
+ * through `checkStatus`, which raises `RuntimeException`.
+ */
+@Implements(Equalizer::class)
+class ShadowEqualizerRejectingBandWrites : ShadowEqualizer() {
+
+  override fun native_setParameter(psize: Int, param: ByteArray, vsize: Int, value: ByteArray): Int {
+    val id = ByteBuffer.wrap(param).order(ByteOrder.nativeOrder()).int
+    if (id == PARAM_BAND_LEVEL) return AudioEffect.ERROR_INVALID_OPERATION
+    return super.native_setParameter(psize, param, vsize, value)
+  }
+
+  private companion object {
+    const val PARAM_BAND_LEVEL = 2
+  }
+}

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

@@ -0,0 +1,61 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.util.UnstableApi
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertNotNull
+import org.junit.Assert.assertNull
+import org.junit.Test
+
+/**
+ * [SuppliedReplayGain.from] separates the consumer's claim over a track
+ * from the values that survive validation: any present field claims the
+ * track, and only accepted values are carried.
+ */
+@UnstableApi
+class SuppliedReplayGainTest {
+
+  @Test
+  fun `a track with no ReplayGain field makes no claim`() {
+    assertNull(SuppliedReplayGain.from(track()))
+  }
+
+  @Test
+  fun `one valid field claims the track and is carried`() {
+    val claim = SuppliedReplayGain.from(track(trackGain = -3.0))
+
+    assertNotNull(claim)
+    assertEquals(
+      ReplayGainData(trackGainDb = -3.0f, trackPeak = null, albumGainDb = null, albumPeak = null),
+      claim?.data)
+  }
+
+  @Test
+  fun `only invalid fields still claim the track but carry nothing`() {
+    val claim = SuppliedReplayGain.from(
+      track(trackGain = Double.NaN, trackPeak = 5.0, albumGain = Double.POSITIVE_INFINITY, albumPeak = 0.0))
+
+    assertNotNull("presence claims the track, whatever the values", claim)
+    assertNull("no value passed acceptance, so there is nothing to apply", claim?.data)
+  }
+
+  @Test
+  fun `a mix carries the accepted fields and drops the rest`() {
+    val claim = SuppliedReplayGain.from(
+      track(trackGain = -3.0, trackPeak = 5.0, albumGain = -9.0, albumPeak = 0.3))
+
+    assertEquals(
+      ReplayGainData(trackGainDb = -3.0f, trackPeak = null, albumGainDb = -9.0f, albumPeak = 0.3f),
+      claim?.data)
+  }
+
+  private fun track(
+    trackGain: Double? = null,
+    trackPeak: Double? = null,
+    albumGain: Double? = null,
+    albumPeak: Double? = null,
+  ) = TrackItem(
+    id = null, url = "https://example.com/a.mp3", title = null, artist = null, album = null,
+    duration = null, artworkUrl = null, extras = null,
+    replayGainTrackGain = trackGain, replayGainTrackPeak = trackPeak,
+    replayGainAlbumGain = albumGain, replayGainAlbumPeak = albumPeak)
+}

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

@@ -38,7 +38,7 @@ import java.nio.ByteBuffer
  * stopped when the AirPlay engine is released or the session closes
  * (`MetadataAwareSession.onDeactivated`).
  *
- * The route flip is driven through the production seam — `CastSinkRouter`'s
+ * The route flip is driven through the production path — `CastSinkRouter`'s
  * activate/deactivate transitions, which `TrackPlayer`'s route listener turns
  * into a posted `applyEngineSwapForMode`. The sync itself is observed through a
  * fake [CastSession.PcmStream] that also implements [MetadataAwareSession] and
@@ -64,7 +64,7 @@ class TrackPlayerAirPlayMetadataWiringTest {
       PlayerConfig(
         httpHeaders = null, userAgent = null, autoRetries = null,
         retryBackoffMs = null, networkTimeoutMs = null, audioContentType = null,
-        audioCategoryOptions = null, visualizationEnabled = null,
+        audioCategoryOptions = null, voiceVocabularyDonationEnabled = null, visualizationEnabled = null,
         clampSeekToBuffered = null,
       lookaheadCacheMaxSizeMb = null, lookaheadCacheEvictionPolicy = null, progressUpdateIntervalMs = null, backgroundProgressUpdateIntervalMs = null, placeholderArtworkUri = null, skipToPreviousBehavior = null,
       ),
@@ -74,8 +74,8 @@ class TrackPlayerAirPlayMetadataWiringTest {
     // matching the production path where `onActivated` is fired after the queue
     // install reads a populated player.
     player.tracks = listOf(
-      TrackItem("t1", "https://example.com/1.m4a", null, null, null, null, null, null),
-      TrackItem("t2", "https://example.com/2.m4a", null, null, null, null, null, null),
+      TrackItem("t1", "https://example.com/1.m4a", null, null, null, null, null, null, null, null, null, null),
+      TrackItem("t2", "https://example.com/2.m4a", null, null, null, null, null, null, null, null, null, null),
     )
     player.currentTrackIndex = 0
   }

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

@@ -44,7 +44,7 @@ class TrackPlayerAudioFocusTest {
     player = TrackPlayer()
     serviceHandle = bindPlaybackServiceForTest(player, context())
     player.configureInternal(
-      PlayerConfig(httpHeaders = null, userAgent = null, autoRetries = null, retryBackoffMs = null, networkTimeoutMs = null, audioContentType = null, audioCategoryOptions = null, visualizationEnabled = null, clampSeekToBuffered = null, lookaheadCacheMaxSizeMb = null, lookaheadCacheEvictionPolicy = null, progressUpdateIntervalMs = null, backgroundProgressUpdateIntervalMs = null, placeholderArtworkUri = null, skipToPreviousBehavior = null), context()
+      PlayerConfig(httpHeaders = null, userAgent = null, autoRetries = null, retryBackoffMs = null, networkTimeoutMs = null, audioContentType = null, audioCategoryOptions = null, voiceVocabularyDonationEnabled = null, visualizationEnabled = null, clampSeekToBuffered = null, lookaheadCacheMaxSizeMb = null, lookaheadCacheEvictionPolicy = null, progressUpdateIntervalMs = null, backgroundProgressUpdateIntervalMs = null, placeholderArtworkUri = null, skipToPreviousBehavior = null), context()
     )
   }
 

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

@@ -0,0 +1,163 @@
+package com.margelo.nitro.queueplayer
+
+import androidx.media3.common.util.UnstableApi
+import androidx.test.core.app.ApplicationProvider
+import com.margelo.nitro.queueplayer.cast.FakeRemotePlayer
+import com.margelo.nitro.queueplayer.cast.PlaybackStateRouter
+import com.margelo.nitro.queueplayer.cast.RemotePlaybackState
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * OS-surface transport commands — hardware and Bluetooth media keys, and the
+ * media-session skip callbacks — drive the receiver while a cast session owns
+ * playback. Routing them to the local engine would play the phone speaker over
+ * the receiver, or skip a queue nobody is listening to.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class TrackPlayerCastCommandRoutingTest {
+
+  private lateinit var player: TrackPlayer
+  private lateinit var serviceHandle: PlaybackServiceTestHandle
+  private val remote = FakeRemotePlayer()
+
+  private fun context() = ApplicationProvider.getApplicationContext<android.content.Context>()
+
+  private fun handler() = player.mediaSessionCommandHandler
+
+  @Before
+  fun setUp() {
+    PlaybackStateRouter.setActive(null)
+    player = TrackPlayer()
+    serviceHandle = bindPlaybackServiceForTest(player, context())
+    player.configureInternal(
+      PlayerConfig(
+        httpHeaders = null, userAgent = null, autoRetries = null, retryBackoffMs = null,
+        networkTimeoutMs = null, audioContentType = null, audioCategoryOptions = null,
+        voiceVocabularyDonationEnabled = null,
+      visualizationEnabled = null, clampSeekToBuffered = null,
+        lookaheadCacheMaxSizeMb = null, lookaheadCacheEvictionPolicy = null,
+        progressUpdateIntervalMs = null, backgroundProgressUpdateIntervalMs = null,
+        placeholderArtworkUri = null, skipToPreviousBehavior = null
+      ),
+      context()
+    )
+  }
+
+  @After
+  fun tearDown() {
+    PlaybackStateRouter.setActive(null)
+    player.destroyInternal()
+    serviceHandle.destroy()
+  }
+
+  @Test
+  fun `media play key drives the receiver`() {
+    PlaybackStateRouter.setActive(remote)
+
+    handler().onMediaPlay()
+
+    assertEquals(listOf("play"), remote.transportCalls)
+  }
+
+  @Test
+  fun `media pause key drives the receiver`() {
+    PlaybackStateRouter.setActive(remote)
+
+    handler().onMediaPause()
+
+    assertEquals(listOf("pause"), remote.transportCalls)
+  }
+
+  @Test
+  fun `toggle key pauses a playing receiver`() {
+    remote.reportState(RemotePlaybackState.PLAYING)
+    PlaybackStateRouter.setActive(remote)
+
+    handler().onMediaTogglePlayPause()
+
+    assertEquals(listOf("pause"), remote.transportCalls)
+  }
+
+  @Test
+  fun `toggle key pauses a buffering receiver`() {
+    remote.reportState(RemotePlaybackState.BUFFERING)
+    PlaybackStateRouter.setActive(remote)
+
+    handler().onMediaTogglePlayPause()
+
+    assertEquals(listOf("pause"), remote.transportCalls)
+  }
+
+  @Test
+  fun `toggle key pauses a loading receiver`() {
+    remote.reportState(RemotePlaybackState.LOADING)
+    PlaybackStateRouter.setActive(remote)
+
+    handler().onMediaTogglePlayPause()
+
+    assertEquals(listOf("pause"), remote.transportCalls)
+  }
+
+  @Test
+  fun `toggle key resumes a paused receiver`() {
+    remote.reportState(RemotePlaybackState.PAUSED)
+    PlaybackStateRouter.setActive(remote)
+
+    handler().onMediaTogglePlayPause()
+
+    assertEquals(listOf("play"), remote.transportCalls)
+  }
+
+  @Test
+  fun `media skip keys drive the receiver queue`() {
+    PlaybackStateRouter.setActive(remote)
+
+    handler().onMediaSkipNext()
+    handler().onMediaSkipPrevious()
+
+    assertEquals(listOf("queueNext", "queuePrev"), remote.transportCalls)
+  }
+
+  @Test
+  fun `session skip commands drive the receiver queue and stay claimed`() {
+    PlaybackStateRouter.setActive(remote)
+
+    assertEquals(true, handler().onSkipToNextCommand())
+    assertEquals(true, handler().onSkipToPreviousCommand())
+    assertEquals(listOf("queueNext", "queuePrev"), remote.transportCalls)
+  }
+
+  @Test
+  fun `play key drives the local engine when no cast session is active`() {
+    handler().onMediaPlay()
+
+    assertEquals(true, serviceHandle.engine.mediaSessionPlayer.playWhenReady)
+    assertEquals(emptyList<String>(), remote.transportCalls)
+  }
+
+  @Test
+  fun `pause key drives the local engine when no cast session is active`() {
+    handler().onMediaPlay()
+    handler().onMediaPause()
+
+    assertEquals(false, serviceHandle.engine.mediaSessionPlayer.playWhenReady)
+    assertEquals(emptyList<String>(), remote.transportCalls)
+  }
+
+  @Test
+  fun `toggle key drives the local engine when no cast session is active`() {
+    handler().onMediaPlay()
+    handler().onMediaTogglePlayPause()
+
+    assertEquals(false, serviceHandle.engine.mediaSessionPlayer.playWhenReady)
+    assertEquals(emptyList<String>(), remote.transportCalls)
+  }
+}