react-native-queue-player 1.1.2 → 2.0.0

package/ios/CarPlayCoordinator.swift

@@ -52,6 +52,7 @@ final class CarPlayCoordinator {
 
   // MARK: - Connection state
 
+  private let connectionLock = NSLock()
   /// Whether the CarPlay scene is currently connected. Written by
   /// [CarPlaySceneDelegate] at scene attach / detach — the same points that
   /// fire the `onCarConnect` / `onCarDisconnect` callbacks — and read by the
@@ -63,7 +64,6 @@ final class CarPlayCoordinator {
   /// attached/detached flag rather than a connection count (the Android side
   /// counts because its headless controllers — Auto / Wear / Assistant — can
   /// overlap).
-  private let connectionLock = NSLock()
   private var carConnectedFlag = false
 
   var isCarConnected: Bool {
@@ -72,9 +72,25 @@ final class CarPlayCoordinator {
     return carConnectedFlag
   }
 
+  /// Invoked on the main queue when a scene attaches. `TrackPlayer` uses it
+  /// to rebuild the queue mirror, which is only maintained while a car is
+  /// attached — without this a car connecting mid-session would show whatever
+  /// the mirror held when it was last connected.
+  var onCarAttached: (() -> Void)? {
+    get { connectionLock.withLock { carAttachedCallback } }
+    set { connectionLock.withLock { carAttachedCallback = newValue } }
+  }
+  /// Written by `TrackPlayer` on its player queue, read here on main.
+  private var carAttachedCallback: (() -> Void)?
+
   func setCarConnected(_ connected: Bool) {
     connectionLock.lock()
-    defer { connectionLock.unlock() }
+    let wasConnected = carConnectedFlag
     carConnectedFlag = connected
+    let attached = carAttachedCallback
+    connectionLock.unlock()
+    if connected, !wasConnected {
+      attached?()
+    }
   }
 }

package/ios/CarPlaySceneDelegate.swift

@@ -16,8 +16,8 @@ import Foundation
 /// the live `BrowseDataProvider`, `CarPlayBridge`,
 /// `PendingBrowseRequests`, and `ArtworkLoader` — all of which are
 /// also written from the JS-side `TrackPlayer` Hybrid path, so the
-/// scene delegate sees fresh data without needing a constructor
-/// injection seam.
+/// scene delegate sees fresh data without anything being injected
+/// through its initialiser.
 /// **Class is `internal` (not `public`) and uses `@objc(<bare-name>)`:**
 /// the auto-generated `<Module>-Swift.h` only emits public Swift
 /// classes; `internal` keeps this one out of the bridging header so

package/ios/Cast/AirPlayRouteState.swift

@@ -71,14 +71,15 @@ final class AirPlayRouteState {
   /// dispatching a tap to the picker's internal UIButton. Used by
   /// `CastManager.showSystemPicker()`.
   ///
-  /// Caveat: the internal button is private layout, walked via
-  /// recursive subview search rather than direct child lookup so the
-  /// picker keeps working when Apple reshapes the view hierarchy
-  /// (iOS 15 nested the button one level deeper; further reshuffles
-  /// are likely). The mitigation here is "best-effort + fail-quiet":
-  /// when no UIButton is found the call is a no-op and the consumer
-  /// can fall back to rendering its own `AVRoutePickerView` in app UI
-  /// (Apple's recommended pattern).
+  /// Workaround: `AVRoutePickerView` has no public API to present its
+  /// sheet, so this walks the view's subviews for its `UIButton` and
+  /// fires its `.touchUpInside` actions. The walk is recursive rather
+  /// than a direct child lookup because the button's depth has changed
+  /// between iOS releases. When no button is found the call is a no-op;
+  /// a consumer that needs a guaranteed sheet renders its own
+  /// `AVRoutePickerView`, which is the supported pattern.
+  /// TODO: monitor upstream for fixes — https://github.com/react-native-video/react-native-video/issues/3119
+  /// (the same subview walk, and the request for a public entry point).
   func showSystemPicker() {
     DispatchQueue.main.async {
       let picker = self.getOrCreatePicker()

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/CastEventBridge.swift

@@ -15,6 +15,14 @@ import NitroModules
 /// `setActive`: once a session is removed from the router and its
 /// listeners are disposed, no further events from it can fire
 /// `owner.emitRemoteState`.
+///
+/// The listener and session fields are main-thread state: the Cast SDK
+/// delivers session and listener callbacks on main, and the owner's `start`
+/// and `stop` hop there from its player queue rather than touching the fields
+/// where they are called. The deactivation snapshot is the exception — it is
+/// written from the player queue at handoff and has to be visible to a
+/// deactivation that lands on main right after, so it sits behind a lock.
+/// `seedStartMetadata` reads the owner's track list on the owner's queue.
 final class CastEventBridge {
 
   private weak var owner: TrackPlayer?
@@ -37,11 +45,21 @@ final class CastEventBridge {
   /// Receiver position at the moment the active session was cleared.
   /// The local engine can read this to resume from where the
   /// receiver was. Cleared when a new session activates.
-  private(set) var lastPositionMsOnDeactivate: Int64 = 0
+  private(set) var lastPositionMsOnDeactivate: Int64 {
+    get { snapshotLock.withLock { positionMsOnDeactivate } }
+    set { snapshotLock.withLock { positionMsOnDeactivate = newValue } }
+  }
 
   /// Receiver-side current track index at deactivation. `-1` when
   /// unknown.
-  private(set) var lastTrackIndexOnDeactivate: Int = -1
+  private(set) var lastTrackIndexOnDeactivate: Int {
+    get { snapshotLock.withLock { trackIndexOnDeactivate } }
+    set { snapshotLock.withLock { trackIndexOnDeactivate = newValue } }
+  }
+
+  private let snapshotLock = NSLock()
+  private var positionMsOnDeactivate: Int64 = 0
+  private var trackIndexOnDeactivate: Int = -1
 
   /// Last lib index emitted for the receiver's current item. Dedups
   /// repeat receiver statuses carrying the same resolved index so
@@ -54,19 +72,34 @@ final class CastEventBridge {
   }
 
   func start() {
-    if activeChangeDisposer != nil { return }
-    activeChangeDisposer = PlaybackStateRouter.shared.addActiveChangeListener {
-      [weak self] session in
-      self?.handleActiveSessionChange(to: session)
+    onMain { [self] in
+      if self.activeChangeDisposer != nil { return }
+      self.activeChangeDisposer = PlaybackStateRouter.shared.addActiveChangeListener {
+        [weak self] session in
+        self?.handleActiveSessionChange(to: session)
+      }
     }
   }
 
   func stop() {
-    activeChangeDisposer?()
-    activeChangeDisposer = nil
-    sessionListenerDisposers.forEach { $0() }
-    sessionListenerDisposers.removeAll()
-    currentActiveSession = nil
+    onMain {
+      self.activeChangeDisposer?()
+      self.activeChangeDisposer = nil
+      self.sessionListenerDisposers.forEach { $0() }
+      self.sessionListenerDisposers.removeAll()
+      self.currentActiveSession = nil
+    }
+  }
+
+  /// Runs `body` on main, in order with the SDK callbacks that own this
+  /// object's state; inline when already there so a caller on main sees its
+  /// effect before returning.
+  private func onMain(_ body: @escaping () -> Void) {
+    if Thread.isMainThread {
+      body()
+    } else {
+      DispatchQueue.main.async(execute: body)
+    }
   }
 
   /// Seed the deactivation snapshot from the local pre-handoff position +
@@ -75,13 +108,18 @@ final class CastEventBridge {
   /// lands local on the right spot. A receiver item resolved at
   /// deactivation takes precedence.
   func seedDeactivationSnapshot(trackIndex: Int, positionMs: Int64) {
-    lastTrackIndexOnDeactivate = trackIndex
-    lastPositionMsOnDeactivate = positionMs
+    snapshotLock.withLock {
+      trackIndexOnDeactivate = trackIndex
+      positionMsOnDeactivate = positionMs
+    }
   }
 
   // MARK: - Active-flow observer
 
   private func handleActiveSessionChange(to newSession: CastSessionRemotePlayer?) {
+    // The router fires listeners on the caller's thread; every caller today
+    // is on main, and the fields below are read and written on that basis.
+    dispatchPrecondition(condition: .onQueue(.main))
     let prior = currentActiveSession
     if newSession == nil, let prior = prior {
       // Capture deactivation snapshot BEFORE tearing down listeners so
@@ -152,8 +190,7 @@ final class CastEventBridge {
   // MARK: - Lockscreen metadata mirror
 
   /// Seed the start track's lockscreen metadata after a `setQueue` so the
-  /// surface doesn't wait for the first receiver status. Called on the
-  /// main thread from `TrackPlayer.setQueue`.
+  /// surface doesn't wait for the first receiver status.
   func seedStartMetadata(startIndex: Int) {
     pushMetadata(forIndex: startIndex)
   }
@@ -175,19 +212,22 @@ final class CastEventBridge {
 
   /// Resolve a lib track index to its `TrackItem` and push its metadata
   /// to the cast lockscreen controller. Out-of-range indices are
-  /// ignored (the controller keeps its prior snapshot).
+  /// ignored (the controller keeps its prior snapshot). The track list is
+  /// read on the queue that owns it, whichever thread this is called from.
   private func pushMetadata(forIndex index: Int) {
     guard let owner = owner else { return }
-    let tracks = owner.tracks
-    guard index >= 0, index < tracks.count else { return }
-    let track = tracks[index]
-    CastNowPlayingController.shared.updateTrackMetadata(
-      title: track.title,
-      artist: track.artist,
-      album: track.album,
-      durationSec: track.duration ?? 0,
-      artworkUrl: track.artworkUrl
-    )
+    owner.playerQueue.async {
+      guard index >= 0, index < owner.tracks.count else { return }
+      let track = owner.tracks[index]
+      // The controller hops to main itself.
+      CastNowPlayingController.shared.updateTrackMetadata(
+        title: track.title,
+        artist: track.artist,
+        album: track.album,
+        durationSec: track.duration ?? 0,
+        artworkUrl: track.artworkUrl
+      )
+    }
   }
 
 }

package/ios/Cast/Core/CastNowPlayingController.swift

@@ -66,19 +66,34 @@ final class CastNowPlayingController {
   /// no-ops. Called from `TrackPlayer.configure` after the engine is
   /// set up.
   func start() {
-    if activeChangeDisposer != nil { return }
-    activeChangeDisposer = PlaybackStateRouter.shared.addActiveChangeListener {
-      [weak self] session in
-      self?.handleActiveChange(to: session)
+    onMain { [self] in
+      if self.activeChangeDisposer != nil { return }
+      self.activeChangeDisposer = PlaybackStateRouter.shared.addActiveChangeListener {
+        [weak self] session in
+        self?.handleActiveChange(to: session)
+      }
+    }
+  }
+
+  /// Every field here is main-thread state — the router and session
+  /// callbacks arrive on main — so the owner's entry points, called on its
+  /// player queue, hop rather than touch the fields where they are called.
+  private func onMain(_ body: @escaping () -> Void) {
+    if Thread.isMainThread {
+      body()
+    } else {
+      DispatchQueue.main.async(execute: body)
     }
   }
 
   /// Stop observing + tear down any active mirror. Called from
   /// `TrackPlayer.internalDestroy`.
   func stop() {
-    deactivate()
-    activeChangeDisposer?()
-    activeChangeDisposer = nil
+    onMain {
+      self.deactivate()
+      self.activeChangeDisposer?()
+      self.activeChangeDisposer = nil
+    }
   }
 
   /// Push current-track metadata. Called by `TrackPlayer` when the
@@ -92,26 +107,33 @@ final class CastNowPlayingController {
     durationSec: Double,
     artworkUrl: String?
   ) {
-    currentMetadata = TrackMetadata(
-      title: title, artist: artist, album: album,
-      durationSec: durationSec, artworkUrl: artworkUrl
-    )
-    if currentSession != nil {
-      refreshNowPlayingInfo()
-      resolveArtwork()
+    onMain {
+      self.currentMetadata = TrackMetadata(
+        title: title, artist: artist, album: album,
+        durationSec: durationSec, artworkUrl: artworkUrl
+      )
+      if self.currentSession != nil {
+        self.refreshNowPlayingInfo()
+        self.resolveArtwork()
+      }
     }
   }
 
   /// Forward the player's artwork HTTP config so authenticated artwork
   /// URLs resolve during cast. Called from `TrackPlayer.configure`.
   func configureArtwork(headers: [String: String]?, userAgent: String?) {
-    artworkResolver.configHeaders = headers
-    artworkResolver.configUserAgent = userAgent
+    onMain {
+      self.artworkResolver.configHeaders = headers
+      self.artworkResolver.configUserAgent = userAgent
+    }
   }
 
   // MARK: - Active-flow observer
 
   private func handleActiveChange(to session: CastSessionRemotePlayer?) {
+    // The router fires listeners on the caller's thread; every caller today
+    // is on main, and the fields here are read and written on that basis.
+    dispatchPrecondition(condition: .onQueue(.main))
     if let session, !session.isPushSink {
       activate(with: session)
     } else {

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`.
+  /// Set by the first such report and stays set for the session's lifetime;
+  /// nothing clears it.
+  ///
+  /// 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/Cast/Core/CastTransportRouter.swift

@@ -15,27 +15,38 @@ import Foundation
 /// Mirrors Android's `internal object CastTransportRouter`.
 enum CastTransportRouter {
 
+  /// Hands a receiver command to main. The Cast SDK is main-only, while the
+  /// decision above it — whether a remote session is live — reads a
+  /// lock-guarded snapshot and is safe from any thread, so only the command
+  /// itself crosses.
+  /// Always asynchronous, never inline-when-already-on-main: mixing the two
+  /// lets a command issued later run before one issued earlier — a CarPlay tap
+  /// arriving on main would overtake a JS seek that is still enqueued.
+  private static func onMain(_ body: @escaping () -> Void) {
+    DispatchQueue.main.async(execute: body)
+  }
+
   static func routePlay() -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.play()
+    onMain { remote.play() }
     return true
   }
 
   static func routePause() -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.pause()
+    onMain { remote.pause() }
     return true
   }
 
   static func routeStop() -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.stop()
+    onMain { remote.stop() }
     return true
   }
 
   static func routeSeekTo(positionMs: Int64) -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.seekTo(positionMs: positionMs)
+    onMain { remote.seekTo(positionMs: positionMs) }
     return true
   }
 
@@ -46,31 +57,32 @@ enum CastTransportRouter {
   /// session for AirPlay/local, where the caller seeks the local engine).
   static func routeSeekBy(deltaMs: Int64) -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.seekBy(deltaMs: deltaMs)
+    onMain { remote.seekBy(deltaMs: deltaMs) }
     return true
   }
 
   static func routeSkipToNext() -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.queueNext()
+    onMain { remote.queueNext() }
     return true
   }
 
   static func routeSkipToPrevious() -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.queuePrev()
+    onMain { remote.queuePrev() }
     return true
   }
 
   static func routeSkipToIndex(index: Int) -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.skipToQueueIndex(index: index)
+    onMain { remote.skipToQueueIndex(index: index) }
     return true
   }
 
   static func routeSetVolume(value: Double) -> Bool {
     guard let remote = PlaybackStateRouter.shared.activeRemote() else { return false }
-    remote.setVolume(Float(max(0.0, min(1.0, value))))
+    let clamped = Float(max(0.0, min(1.0, value)))
+    onMain { remote.setVolume(clamped) }
     return true
   }