react-native-queue-player 1.1.2 → 1.2.0

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

@@ -0,0 +1,122 @@
+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.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.annotation.Config
+
+/**
+ * `getState()` reports the receiver while a cast session owns playback. The
+ * local player is parked and paused for the session's duration, so reading it
+ * would describe nothing the user can hear.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class TrackPlayerCastStateTest {
+
+  private lateinit var player: TrackPlayer
+  private lateinit var serviceHandle: PlaybackServiceTestHandle
+  private val remote = FakeRemotePlayer()
+
+  private fun context() = ApplicationProvider.getApplicationContext<android.content.Context>()
+
+  @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,
+        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 `reports the receiver's playing state during a cast session`() {
+    remote.reportState(RemotePlaybackState.PLAYING)
+    PlaybackStateRouter.setActive(remote)
+
+    assertEquals(PlayerState.PLAYING, player.getState())
+  }
+
+  @Test
+  fun `reports the receiver's paused state during a cast session`() {
+    remote.reportState(RemotePlaybackState.PAUSED)
+    PlaybackStateRouter.setActive(remote)
+
+    assertEquals(PlayerState.PAUSED, player.getState())
+  }
+
+  @Test
+  fun `maps a buffering receiver to buffering`() {
+    remote.reportState(RemotePlaybackState.BUFFERING)
+    PlaybackStateRouter.setActive(remote)
+
+    assertEquals(PlayerState.BUFFERING, player.getState())
+  }
+
+  @Test
+  fun `maps an ended receiver to ended`() {
+    remote.reportState(RemotePlaybackState.ENDED)
+    PlaybackStateRouter.setActive(remote)
+
+    assertEquals(PlayerState.ENDED, player.getState())
+  }
+
+  @Test
+  fun `reads the local player until the receiver reports`() {
+    // Session activating: the receiver holds a state it has not reported, so
+    // the local player answers. The staged PLAYING makes the two distinct —
+    // with no queue configured the local read is NONE.
+    remote.backingState.value = RemotePlaybackState.PLAYING
+    PlaybackStateRouter.setActive(remote)
+
+    assertFalse(remote.hasReportedState)
+    assertEquals(PlayerState.NONE, player.getState())
+  }
+
+  @Test
+  fun `keeps reading the receiver once it has reported`() {
+    // A receiver that has spoken stays authoritative: a later idle means it
+    // genuinely has nothing loaded, not that it is still activating.
+    remote.reportState(RemotePlaybackState.PLAYING)
+    remote.backingState.value = RemotePlaybackState.IDLE
+    PlaybackStateRouter.setActive(remote)
+
+    assertTrue(remote.hasReportedState)
+    assertEquals(PlayerState.NONE, player.getState())
+  }
+
+  @Test
+  fun `reads the local player when no cast session is active`() {
+    // An unregistered session must not be consulted, however it reports.
+    remote.reportState(RemotePlaybackState.PLAYING)
+
+    assertEquals(PlayerState.NONE, player.getState())
+  }
+}

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

@@ -9,10 +9,11 @@ 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.
+ * Test double for [CastSession.RemotePlayer]. Transport calls record their
+ * name in [transportCalls]; the StateFlows are driveable via the public
+ * backing fields, or via [reportState] to mirror the real session's
+ * [hasReportedState] latch; [mediaSessionPlayer] is injectable so bind tests
+ * can assert the MediaSession swaps to it.
  */
 internal class FakeRemotePlayer(
   private val player: Player? = null,
@@ -36,15 +37,30 @@ internal class FakeRemotePlayer(
   override val mediaError: SharedFlow<RemoteMediaError> = backingError.asSharedFlow()
   override val seekCompleted: SharedFlow<Long> = backingSeek.asSharedFlow()
 
+  /** Transport calls in the order they arrived, for routing assertions. */
+  val transportCalls = mutableListOf<String>()
+
+  override var hasReportedState: Boolean = false
+
+  /**
+   * Drive the receiver state the way a live session does: a non-idle report
+   * latches [hasReportedState]. Set [backingState] directly to stage a state
+   * the receiver has not reported yet.
+   */
+  fun reportState(state: RemotePlaybackState) {
+    if (state != RemotePlaybackState.IDLE) hasReportedState = true
+    backingState.value = state
+  }
+
   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 play() { transportCalls += "play" }
+  override fun pause() { transportCalls += "pause" }
+  override fun stop() { transportCalls += "stop" }
+  override fun seekTo(positionMs: Long) { transportCalls += "seekTo:$positionMs" }
+  override fun queueNext() { transportCalls += "queueNext" }
+  override fun queuePrev() { transportCalls += "queuePrev" }
+  override fun skipToQueueIndex(index: Int) { transportCalls += "skipToQueueIndex:$index" }
   override fun setPlaybackRate(rate: Float) {}
   override fun setRepeatMode(mode: RemoteRepeatMode) {}
 

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

@@ -0,0 +1,303 @@
+package com.margelo.nitro.queueplayer.cast.airplay
+
+import android.net.Uri
+import android.os.Looper
+import androidx.media3.common.MediaItem
+import androidx.media3.common.MediaMetadata
+import androidx.media3.common.Player
+import androidx.media3.common.SimpleBasePlayer
+import androidx.media3.common.util.UnstableApi
+import androidx.test.core.app.ApplicationProvider
+import com.google.common.collect.ImmutableList
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.cancel
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import java.io.File
+import java.util.Base64
+import java.time.Duration
+import java.util.concurrent.CopyOnWriteArrayList
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+
+/**
+ * Receiver-display sync lifecycle: what reaches the receiver while a sync is
+ * running, and that nothing reaches it once the session has been torn down.
+ *
+ * The teardown cases drive `stop()` from a non-looper thread, which is where
+ * it comes from in production — the JS thread on a user disconnect, the
+ * native drain thread on receiver death.
+ */
+@RunWith(RobolectricTestRunner::class)
+@Config(sdk = [34])
+@UnstableApi
+class AirPlayMetadataSyncTest {
+
+  private lateinit var player: FakePlayer
+  private lateinit var target: RecordingTarget
+  private lateinit var sync: AirPlayMetadataSync
+  private val scope = CoroutineScope(Dispatchers.Main.immediate)
+
+  private fun context() = ApplicationProvider.getApplicationContext<android.content.Context>()
+
+  private fun idle() = shadowOf(Looper.getMainLooper()).idle()
+
+  private fun idleFor(ms: Long) =
+    shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(ms))
+
+  /** Runs [block] off the looper and waits for it, as a real teardown does. */
+  private fun offLooper(block: () -> Unit) {
+    val executor = Executors.newSingleThreadExecutor()
+    try {
+      executor.submit(block).get(5, TimeUnit.SECONDS)
+    } finally {
+      executor.shutdownNow()
+    }
+  }
+
+  /** Waits for work dispatched off the looper, e.g. the artwork fetch. */
+  private fun awaitTrue(timeoutMs: Long = 5_000, condition: () -> Boolean): Boolean {
+    val deadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(timeoutMs)
+    while (System.nanoTime() < deadline) {
+      idle()
+      if (condition()) return true
+      Thread.sleep(20)
+    }
+    return condition()
+  }
+
+  @Before
+  fun setUp() {
+    player = FakePlayer(Looper.getMainLooper())
+    target = RecordingTarget()
+    sync = AirPlayMetadataSync(context(), target, player, scope)
+  }
+
+  @After
+  fun tearDown() {
+    sync.stop()
+    idle()
+    scope.cancel()
+  }
+
+  @Test
+  fun `start sends the current track metadata`() {
+    sync.start()
+    idle()
+
+    assertEquals(
+      listOf(Triple("Everlong", "Foo Fighters", "The Colour and the Shape")),
+      target.metadata,
+    )
+  }
+
+  @Test
+  fun `progress is pushed while playing`() {
+    sync.start()
+    idle()
+    val afterStart = target.progress.size
+
+    idleFor(11_000)
+
+    assertTrue(
+      "expected progress pushes while playing, got ${target.progress.size - afterStart}",
+      target.progress.size - afterStart >= 2,
+    )
+  }
+
+  @Test
+  fun `stop from another thread halts the progress loop`() {
+    sync.start()
+    idle()
+    idleFor(6_000)
+    assertTrue(target.progress.isNotEmpty())
+
+    offLooper { sync.stop() }
+    idle()
+    val atStop = target.progress.size
+
+    idleFor(30_000)
+
+    assertEquals(atStop, target.progress.size)
+  }
+
+  @Test
+  fun `a resume callback arriving after stop starts no progress loop`() {
+    sync.start()
+    idle()
+    player.emitPlayWhenReady(false)
+    idle()
+
+    // The resume lands while listener removal is still queued behind the
+    // off-looper stop, so it reaches startProgressTimer on a spent sync.
+    offLooper { sync.stop() }
+    player.emitPlayWhenReady(true)
+    idle()
+    val atStop = target.progress.size
+
+    idleFor(30_000)
+
+    assertEquals(atStop, target.progress.size)
+  }
+
+  @Test
+  fun `a track change arriving after stop pushes nothing`() {
+    sync.start()
+    idle()
+    val atStop = target.metadata.size
+
+    offLooper { sync.stop() }
+    player.emitTrackChange(trackMediaItem("Monkey Wrench", "Foo Fighters", "TCATS"))
+    idle()
+
+    assertEquals(atStop, target.metadata.size)
+  }
+
+  @Test
+  fun `artwork from a local file reaches the receiver while running`() {
+    player.emitTrackChange(
+      trackMediaItem("Everlong", "Foo Fighters", "TCATS", artworkUri = artworkFile())
+    )
+
+    sync.start()
+
+    assertTrue("artwork never arrived", awaitTrue { target.artwork.isNotEmpty() })
+  }
+
+  @Test
+  fun `artwork is not fetched after stop`() {
+    sync.start()
+    idle()
+
+    // Fired while listener removal is still queued behind the off-looper
+    // stop, so the fetch is reached on a spent sync.
+    offLooper { sync.stop() }
+    player.emitTrackChange(
+      trackMediaItem("Monkey Wrench", "Foo Fighters", "TCATS", artworkUri = artworkFile())
+    )
+
+    // Real elapsed time, not looper time: the fetch runs on Dispatchers.IO,
+    // so advancing the looper clock proves nothing about whether it ran.
+    assertFalse(
+      "artwork reached the receiver after stop",
+      awaitTrue(2_000) { target.artwork.isNotEmpty() },
+    )
+  }
+
+  @Test
+  fun `start after stop does nothing`() {
+    sync.start()
+    idle()
+    offLooper { sync.stop() }
+    idle()
+    val atStop = target.progress.size + target.metadata.size
+
+    sync.start()
+    idle()
+    idleFor(30_000)
+
+    assertEquals(atStop, target.progress.size + target.metadata.size)
+  }
+
+  private fun artworkFile(): Uri {
+    val file = File(context().cacheDir, "artwork.png")
+    if (!file.exists()) file.writeBytes(PNG_1X1)
+    return Uri.fromFile(file)
+  }
+
+  private class RecordingTarget : MetadataSyncTarget {
+    // The artwork fetch runs on Dispatchers.IO while the test thread reads
+    // these, so plain ArrayLists would be shared unsynchronised.
+    val metadata = CopyOnWriteArrayList<Triple<String?, String?, String?>>()
+    val progress = CopyOnWriteArrayList<Pair<Int, Int>>()
+    val artwork = CopyOnWriteArrayList<Int>()
+
+    override fun setMetadata(title: String?, artist: String?, album: String?) {
+      metadata += Triple(title, artist, album)
+    }
+
+    override fun setProgress(elapsedMs: Int, durationMs: Int) {
+      progress += elapsedMs to durationMs
+    }
+
+    override fun setArtwork(imageData: ByteArray, contentType: String) {
+      artwork += imageData.size
+    }
+  }
+
+  /**
+   * Player double exposing exactly what the sync reads: the current item's
+   * metadata, position, duration and whether playback is running. Each item
+   * carries its own period uid, so replacing it is delivered as a media-item
+   * transition rather than a timeline change.
+   */
+  private class FakePlayer(looper: Looper) : SimpleBasePlayer(looper) {
+    private var item: MediaItem =
+      trackMediaItem("Everlong", "Foo Fighters", "The Colour and the Shape")
+    private var playing = true
+
+    fun emitTrackChange(next: MediaItem) {
+      item = next
+      invalidateState()
+    }
+
+    fun emitPlayWhenReady(value: Boolean) {
+      playing = value
+      invalidateState()
+    }
+
+    override fun getState(): State =
+      State.Builder()
+        .setAvailableCommands(Player.Commands.Builder().addAllCommands().build())
+        .setPlaybackState(Player.STATE_READY)
+        .setPlayWhenReady(playing, Player.PLAY_WHEN_READY_CHANGE_REASON_USER_REQUEST)
+        .setPlaylist(
+          ImmutableList.of(
+            MediaItemData.Builder(item)
+              .setMediaItem(item)
+              .setDurationUs(300_000_000L)
+              .build()
+          )
+        )
+        .setCurrentMediaItemIndex(0)
+        .setContentPositionMs(1_000L)
+        .build()
+  }
+
+  private companion object {
+    /**
+     * A real 1x1 PNG — Robolectric decodes artwork through ImageIO, so a
+     * stub header fails to decode and the fetch reports no artwork.
+     */
+    val PNG_1X1: ByteArray = Base64.getDecoder().decode(
+      "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg=="
+    )
+
+    fun trackMediaItem(
+      title: String,
+      artist: String,
+      album: String,
+      artworkUri: Uri? = null,
+    ): MediaItem =
+      MediaItem.Builder()
+        .setUri("https://example.invalid/${title.replace(' ', '-')}.mp3")
+        .setMediaMetadata(
+          MediaMetadata.Builder()
+            .setTitle(title)
+            .setArtist(artist)
+            .setAlbumTitle(album)
+            .apply { artworkUri?.let { setArtworkUri(it) } }
+            .build()
+        )
+        .build()
+  }
+}

package/ios/Cast/Chromecast/ChromecastSession.swift

@@ -40,10 +40,16 @@ final class ChromecastSession: NSObject, CastSessionRemotePlayer {
   private var _lastVolume: Float = .nan
   private var _lastVolumeEmitted: Float = .nan
 
+  private var _hasReportedState = false
+
   var lastState: RemotePlaybackStateKind {
     stateLock.lock(); defer { stateLock.unlock() }
     return _lastState
   }
+  var hasReportedState: Bool {
+    stateLock.lock(); defer { stateLock.unlock() }
+    return _hasReportedState
+  }
   var lastPositionMs: Int64 {
     stateLock.lock(); defer { stateLock.unlock() }
     return _lastPositionMs
@@ -143,8 +149,15 @@ final class ChromecastSession: NSObject, CastSessionRemotePlayer {
 
   private func updateState(_ s: RemotePlaybackStateKind) {
     stateLock.lock()
+    let previous = _lastState
     _lastState = s
+    if s != .idle { _hasReportedState = true }
     stateLock.unlock()
+    #if DEBUG
+    if previous != s {
+      NSLog("[ChromecastSession] receiver state \(previous) -> \(s)")
+    }
+    #endif
     fireOnEach(stateListeners) { $0(s) }
   }
 
@@ -302,11 +315,14 @@ final class ChromecastSession: NSObject, CastSessionRemotePlayer {
     }
   }
 
-  func play() { fireRemote("play") { _ = $0.play() } }
-  func pause() { fireRemote("pause") { _ = $0.pause() } }
-  func stop() { fireRemote("stop") { _ = $0.stop() } }
-  func queueNext() { fireRemote("queueNext") { _ = $0.queueNextItem() } }
-  func queuePrev() { fireRemote("queuePrev") { _ = $0.queuePreviousItem() } }
+  // No bitmask flag gates `play` — the mask models pause, not resume.
+  func play() { fireRemote("play") { $0.play() } }
+  func pause() { fireRemote("pause", requires: kGCKMediaCommandPause) { $0.pause() } }
+  func stop() { fireRemote("stop") { $0.stop() } }
+  func queueNext() { fireRemote("queueNext", requires: kGCKMediaCommandQueueNext) { $0.queueNextItem() } }
+  func queuePrev() {
+    fireRemote("queuePrev", requires: kGCKMediaCommandQueuePrevious) { $0.queuePreviousItem() }
+  }
   func skipToQueueIndex(index: Int) {
     guard index >= 0 else { return }
     // Resolve the absolute lib index to the receiver's itemId via the full
@@ -315,13 +331,15 @@ final class ChromecastSession: NSObject, CastSessionRemotePlayer {
     // model hasn't synced that slot yet; skip rather than jump blind.
     fireRemote("skipToQueueIndex") { client in
       let itemId = client.mediaQueue.itemID(at: UInt(index))
-      guard itemId != kGCKMediaQueueInvalidItemID else { return }
-      _ = client.queueJumpToItem(withID: itemId)
+      guard itemId != kGCKMediaQueueInvalidItemID else { return nil }
+      return client.queueJumpToItem(withID: itemId)
     }
   }
 
   func setPlaybackRate(_ rate: Float) {
-    fireRemote("setPlaybackRate") { _ = $0.setPlaybackRate(rate) }
+    fireRemote("setPlaybackRate", requires: kGCKMediaCommandSetPlaybackRate) {
+      $0.setPlaybackRate(rate)
+    }
   }
 
   func setRepeatMode(_ mode: RemoteRepeatMode) {
@@ -331,7 +349,7 @@ final class ChromecastSession: NSObject, CastSessionRemotePlayer {
     case .single: sdkMode = .single
     case .all: sdkMode = .all
     }
-    fireRemote("setRepeatMode") { _ = $0.queueSetRepeatMode(sdkMode) }
+    fireRemote("setRepeatMode") { $0.queueSetRepeatMode(sdkMode) }
   }
 
   func seekTo(positionMs: Int64) {
@@ -589,9 +607,21 @@ final class ChromecastSession: NSObject, CastSessionRemotePlayer {
   /// `GCKRemoteMediaClient`. Silently skips when the session is closed
   /// or the client is unavailable (log only — transport calls are
   /// fire-and-forget).
+  ///
+  /// `block` returns the `GCKRequest` the SDK scheduled, or `nil` when it
+  /// declined to issue one. A returned request gets a delegate so a
+  /// receiver-side rejection is reported instead of vanishing — without it
+  /// a refused command is indistinguishable from one the receiver honoured.
+  ///
+  /// `requires` names the `GCKMediaStatus` command bitmask flag the receiver
+  /// must advertise for this command (`nil` for commands not gated by the
+  /// mask). The receiver publishes support per media item, so an item can
+  /// accept queue commands while refusing `pause` — worth a warning, since
+  /// the command is otherwise dropped in silence.
   private func fireRemote(
     _ label: String,
-    _ block: @escaping (GCKRemoteMediaClient) -> Void
+    requires command: NSInteger? = nil,
+    _ block: @escaping (GCKRemoteMediaClient) -> GCKRequest?
   ) {
     if closed { return }
     runOnMain { [weak self] in
@@ -600,7 +630,28 @@ final class ChromecastSession: NSObject, CastSessionRemotePlayer {
         NSLog("[ChromecastSession] \(label): no GCKRemoteMediaClient — session not fully live?")
         return
       }
-      block(client)
+      if let command = command,
+         let status = client.mediaStatus,
+         !status.isMediaCommandSupported(command) {
+        NSLog(
+          "[ChromecastSession] \(label): receiver does not advertise support for this command; sending anyway"
+        )
+      }
+      #if DEBUG
+      NSLog("[ChromecastSession] \(label): issuing")
+      #endif
+      // `nil` means this call site declined to issue anything — the only such
+      // case is a queue index the receiver's model hasn't synced yet, which is
+      // a normal transient, not a fault.
+      guard let request = block(client) else {
+        #if DEBUG
+        NSLog("[ChromecastSession] \(label): no request issued")
+        #endif
+        return
+      }
+      let delegate = TransportRequestDelegate(label: label, owner: self)
+      self.retain(delegate)
+      request.delegate = delegate
     }
   }
 
@@ -707,6 +758,34 @@ fileprivate final class RequestContinuation: NSObject, GCKRequestDelegate {
   }
 }
 
+/// Reports the outcome of a fire-and-forget transport request. The caller
+/// doesn't await these, so without a delegate a receiver that refuses a
+/// command leaves no trace at all.
+fileprivate final class TransportRequestDelegate: NSObject, GCKRequestDelegate {
+  let label: String
+  weak var owner: ChromecastSession?
+
+  init(label: String, owner: ChromecastSession) {
+    self.label = label
+    self.owner = owner
+    super.init()
+  }
+
+  func requestDidComplete(_ request: GCKRequest) {
+    owner?.drop(self)
+  }
+
+  func request(_ request: GCKRequest, didFailWithError error: GCKError) {
+    NSLog("[ChromecastSession] \(label) failed: \(error.localizedDescription)")
+    owner?.drop(self)
+  }
+
+  func request(_ request: GCKRequest, didAbortWith abortReason: GCKRequestAbortReason) {
+    NSLog("[ChromecastSession] \(label) aborted: \(abortReason.rawValue)")
+    owner?.drop(self)
+  }
+}
+
 /// Bridge `seek(with:)`'s `GCKRequest` into the session's
 /// `onSeekCompleted` listener fan-out. Fire-and-forget — failures are
 /// logged but do not surface as JS errors (the lib has no "seek-

package/ios/Cast/Core/CastSession.swift

@@ -45,6 +45,17 @@ protocol CastSessionRemotePlayer: CastSession {
   /// Snapshot of most-recent receiver-driven state.
   var lastState: RemotePlaybackStateKind { get }
 
+  /// `true` once the receiver has reported any state other than `.idle`.
+  /// Latches on the first such report and stays set for the session's
+  /// lifetime.
+  ///
+  /// State reads use this to decide whether the receiver can answer yet: a
+  /// session that has just activated still holds its initial `.idle`, and the
+  /// local engine is the better answer until the receiver speaks. Once it
+  /// has, the receiver is authoritative — including a later `.idle`, which
+  /// means it genuinely has nothing loaded.
+  var hasReportedState: Bool { get }
+
   /// Most-recent receiver-reported stream position in milliseconds.
   /// `0` before the first status arrives.
   var lastPositionMs: Int64 { get }

package/ios/Tests/CastNowPlayingControllerTests.swift

@@ -177,6 +177,7 @@ final class ControllableRemoteSession: CastSessionRemotePlayer {
   var isPushSink: Bool { pushSink }
 
   var lastState: RemotePlaybackStateKind = .idle
+  var hasReportedState: Bool = false
   var lastPositionMs: Int64 = 0
   var lastDurationMs: Int64 = 0
   var lastBufferedMs: Int64 = 0
@@ -186,8 +187,12 @@ final class ControllableRemoteSession: CastSessionRemotePlayer {
   private var stateCb: ((RemotePlaybackStateKind) -> Void)?
   private var positionCb: ((Int64, Int64, Int64) -> Void)?
 
+  /// Drive the receiver state the way a live session does: a non-idle report
+  /// latches `hasReportedState`. Set `lastState` directly to stage a state the
+  /// receiver has not reported yet.
   func fireState(_ state: RemotePlaybackStateKind) {
     lastState = state
+    if state != .idle { hasReportedState = true }
     stateCb?(state)
   }
 

package/ios/Tests/PlaybackStateRouterTests.swift

@@ -124,6 +124,7 @@ final class FakeRemoteSession: CastSessionRemotePlayer {
   var isPushSink: Bool { false }
 
   var lastState: RemotePlaybackStateKind = .idle
+  var hasReportedState: Bool = false
   var lastPositionMs: Int64 = 0
   var lastDurationMs: Int64 = 0
   var lastBufferedMs: Int64 = 0