react-native-nitro-player 1.7.0-alpha.2 → 1.7.0-alpha.4

package/android/src/main/java/com/margelo/nitro/nitroplayer/playlist/PlaylistManager.kt

@@ -249,6 +249,61 @@ class PlaylistManager private constructor(
         return true
     }
 
+    /** Removed count; null when the playlist does not exist. Unknown ids are ignored. */
+    fun removeTracksFromPlaylist(
+        playlistId: String,
+        trackIds: List<String>,
+    ): Int? {
+        val ids = trackIds.toHashSet()
+        var removed = 0
+        val found =
+            playlists.computeIfPresent(playlistId) { _, playlist ->
+                val tracks = playlist.tracks.toMutableList()
+                val before = tracks.size
+                if (tracks.removeAll { it.id in ids }) {
+                    removed = before - tracks.size
+                    playlist.copy(tracks = tracks)
+                } else {
+                    playlist
+                }
+            } != null
+        if (!found) return null
+        if (removed > 0) {
+            scheduleSave()
+            notifyPlaylistChanged(playlistId, QueueOperation.REMOVE)
+            NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
+        }
+        return removed
+    }
+
+    /** Fisher-Yates; [firstTrackId] is pinned at index 0. Null when the playlist does not exist. */
+    fun shufflePlaylist(
+        playlistId: String,
+        firstTrackId: String?,
+    ): Boolean? {
+        var changed = false
+        val found =
+            playlists.computeIfPresent(playlistId) { _, playlist ->
+                val tracks = playlist.tracks.toMutableList()
+                val pinned = tracks.indexOfFirst { it.id == firstTrackId }.takeIf { it >= 0 }?.let { tracks.removeAt(it) }
+                tracks.shuffle()
+                pinned?.let { tracks.add(0, it) }
+                if (tracks.map { it.id } == playlist.tracks.map { it.id }) {
+                    playlist
+                } else {
+                    changed = true
+                    playlist.copy(tracks = tracks)
+                }
+            } != null
+        if (!found) return null
+        if (changed) {
+            scheduleSave()
+            notifyPlaylistChanged(playlistId, QueueOperation.UPDATE)
+            NitroPlayerMediaBrowserService.getInstance()?.onPlaylistUpdated(playlistId)
+        }
+        return changed
+    }
+
     /**
      * Update entire track objects across all playlists
      * Matches by track.id and replaces the entire track object
@@ -317,6 +372,11 @@ class PlaylistManager private constructor(
         return true
     }
 
+    /** Mirrors the core's current playlist (playSong bypasses loadPlaylist); Android Auto and persistence read this. */
+    fun setCurrentPlaylistId(playlistId: String?) {
+        currentPlaylistId = playlistId
+    }
+
     /**
      * Get the current playlist ID
      */

package/ios/cast/CastQueueDiff.swift

@@ -0,0 +1,58 @@
+// Pure receiver-queue diff: no Cast SDK types, no operation ever contains the current item.
+
+import Foundation
+
+enum CastQueueOp: Equatable {
+  case remove([String])
+  case insert([String])
+  case moveToEnd([String])
+  case moveBefore([String], anchor: String)
+}
+
+enum CastQueueDiff {
+  /// Converges in at most 4 ops. Caller guarantees `currentId` occurs exactly once in both lists.
+  static func nextOp(existing: [String], desired: [String], currentId: String) -> CastQueueOp? {
+    let desiredSet = Set(desired)
+    let existingSet = Set(existing)
+
+    let toRemove = existing.filter { !desiredSet.contains($0) }
+    if !toRemove.isEmpty { return .remove(toRemove) }
+
+    let toInsert = desired.filter { !existingSet.contains($0) }
+    if !toInsert.isEmpty { return .insert(toInsert) }
+
+    if existing == desired { return nil }
+    guard let cur = desired.firstIndex(of: currentId) else { return nil }
+
+    let after = Array(desired[(cur + 1)...])
+    if !after.isEmpty, Array(existing.suffix(after.count)) != after { return .moveToEnd(after) }
+
+    let before = Array(desired[..<cur])
+    if !before.isEmpty, Array(existing.prefix(before.count)) != before {
+      return .moveBefore(before, anchor: currentId)
+    }
+    return nil
+  }
+
+  static func apply(_ op: CastQueueOp, to existing: [String]) -> [String] {
+    switch op {
+    case .remove(let ids):
+      let dropped = Set(ids)
+      return existing.filter { !dropped.contains($0) }
+    case .insert(let ids):
+      return existing + ids
+    case .moveToEnd(let ids):
+      let moved = Set(ids)
+      return existing.filter { !moved.contains($0) } + ids
+    case .moveBefore(let ids, let anchor):
+      let moved = Set(ids)
+      var out: [String] = []
+      out.reserveCapacity(existing.count)
+      for id in existing where !moved.contains(id) {
+        if id == anchor { out.append(contentsOf: ids) }
+        out.append(id)
+      }
+      return out
+    }
+  }
+}

package/ios/cast/CastQueueReconciler.swift

@@ -0,0 +1,228 @@
+// Pure state machine: one receiver request in flight at a time, newest desired state wins.
+
+import Foundation
+
+typealias CastItemID = UInt
+
+struct CastQueueLoad {
+  let tracks: [TrackItem]
+  let startIndex: Int
+  let position: Double
+  let autoplay: Bool
+  let repeatMode: RepeatMode
+}
+
+enum CastQueueEffect {
+  case none
+  case send(CastQueueOp)
+  case sendLoad(CastQueueLoad)
+  case sendUnload
+  case recover(String)
+}
+
+final class CastQueueReconciler {
+
+  private struct Busy {
+    enum Kind {
+      case load(CastQueueLoad)
+      case unload
+      case op(CastQueueOp)
+    }
+    let kind: Kind
+    let expected: [String]
+    var request: Int?
+    var completed = false
+    var observed = false
+  }
+
+  private struct Desired {
+    let generation: UInt64
+    let ids: [String]
+    let currentId: String
+  }
+
+  private enum PendingLoad {
+    case load(CastQueueLoad)
+    case unload
+  }
+
+  private(set) var order: [CastItemID] = []
+  /// Learned from our own completed operations, never guessed.
+  private(set) var trackOf: [CastItemID: String] = [:]
+  private(set) var unverified: Set<CastItemID> = []
+
+  private var valid = false
+  private var busy: Busy?
+  private var pendingLoad: PendingLoad?
+  private var latest: Desired?
+  private var generationCounter: UInt64 = 0
+
+  var orderedTrackIds: [String] { order.compactMap { trackOf[$0] } }
+
+  var hasInFlightRequest: Bool { busy != nil }
+
+  // MARK: - Inputs
+
+  func desired(ids: [String], currentId: String) -> CastQueueEffect {
+    generationCounter &+= 1
+    latest = Desired(generation: generationCounter, ids: ids, currentId: currentId)
+    guard busy == nil else { return .none }
+    return dispatch()
+  }
+
+  func loadRequested(_ load: CastQueueLoad) -> CastQueueEffect {
+    pendingLoad = .load(load)
+    guard busy == nil else { return .none }
+    return dispatch()
+  }
+
+  func unloadRequested() -> CastQueueEffect {
+    pendingLoad = .unload
+    guard busy == nil else { return .none }
+    return dispatch()
+  }
+
+  func requestAssigned(_ requestId: Int) {
+    busy?.request = requestId
+  }
+
+  func requestCompleted(_ requestId: Int) -> CastQueueEffect {
+    guard var current = busy, current.request == requestId else { return .none }
+    current.completed = true
+    busy = current
+    return finishIfReady()
+  }
+
+  func requestFailed(_ requestId: Int, reason: String) -> CastQueueEffect {
+    guard let current = busy, current.request == requestId else { return .none }
+    busy = nil
+    valid = false
+    return .recover(reason)
+  }
+
+  func queueObserved(_ ids: [CastItemID]) -> CastQueueEffect {
+    guard var current = busy else {
+      // Another sender changed the queue: reconstruct from the map rather than reloading.
+      if ids.contains(where: { trackOf[$0] == nil }) {
+        valid = false
+        return .recover("foreign receiver item")
+      }
+      order = ids
+      return latest == nil ? .none : plan()
+    }
+
+    guard ids.count == current.expected.count else { return .none }
+    var learned: [CastItemID: String] = [:]
+    for (index, id) in ids.enumerated() {
+      if let known = trackOf[id] {
+        if known != current.expected[index] { return .none }
+      } else {
+        learned[id] = current.expected[index]
+      }
+    }
+    let introduced = introducedCount(current)
+    if learned.count != introduced {
+      if learned.isEmpty {
+        order = ids
+        return .none
+      }
+      busy = nil
+      valid = false
+      return .recover("foreign receiver item")
+    }
+    for (id, trackId) in learned {
+      trackOf[id] = trackId
+      unverified.insert(id)
+    }
+    order = ids
+    current.observed = true
+    busy = current
+    return finishIfReady()
+  }
+
+  func verified(_ id: CastItemID, trackId: String) -> CastQueueEffect {
+    guard let known = trackOf[id] else { return .none }
+    unverified.remove(id)
+    guard known != trackId else { return .none }
+    busy = nil
+    valid = false
+    return .recover("id map mismatch")
+  }
+
+  func sessionEnded() {
+    order = []
+    trackOf = [:]
+    unverified = []
+    valid = false
+    busy = nil
+    pendingLoad = nil
+    latest = nil
+  }
+
+  // MARK: - Internals
+
+  private func introducedCount(_ current: Busy) -> Int {
+    switch current.kind {
+    case .load: return current.expected.count
+    case .unload: return 0
+    case .op(let op):
+      if case .insert(let ids) = op { return ids.count }
+      return 0
+    }
+  }
+
+  private func finishIfReady() -> CastQueueEffect {
+    guard let current = busy, current.completed, current.observed else { return .none }
+    busy = nil
+    return dispatch()
+  }
+
+  /// Loads win over diffs: they are jumps or recoveries, and they reset the id map.
+  private func dispatch() -> CastQueueEffect {
+    guard busy == nil else { return .none }
+    if let pending = pendingLoad {
+      pendingLoad = nil
+      order = []
+      trackOf = [:]
+      unverified = []
+      valid = true
+      switch pending {
+      case .load(let load):
+        busy = Busy(kind: .load(load), expected: load.tracks.map(\.id))
+        return .sendLoad(load)
+      case .unload:
+        busy = Busy(kind: .unload, expected: [])
+        return .sendUnload
+      }
+    }
+    return plan()
+  }
+
+  private func plan() -> CastQueueEffect {
+    while true {
+      guard valid, let target = latest else { return .none }
+      let existing = orderedTrackIds
+      guard existing.count == order.count else {
+        valid = false
+        return .recover("unmapped receiver item")
+      }
+      guard existing.filter({ $0 == target.currentId }).count == 1,
+        target.ids.filter({ $0 == target.currentId }).count == 1
+      else {
+        valid = false
+        return .recover("current id precondition")
+      }
+      guard
+        let op = CastQueueDiff.nextOp(
+          existing: existing, desired: target.ids, currentId: target.currentId)
+      else {
+        // Clear only the generation we planned for; a newer one is planned instead.
+        guard let newest = latest, newest.generation == target.generation else { continue }
+        latest = nil
+        return .none
+      }
+      busy = Busy(kind: .op(op), expected: CastQueueDiff.apply(op, to: existing))
+      return .send(op)
+    }
+  }
+}

package/ios/core/CastSessionManager.swift

@@ -36,12 +36,26 @@ final class CastSessionManager: NSObject {
   private var cachedState: CastState = .noDevicesAvailable
   private var cachedDeviceName: String?
 
+  // MARK: - Receiver queue reconciliation (main thread only)
+
+  /// Serializes every receiver queue mutation and owns the item-id map.
+  private let reconciler = CastQueueReconciler()
+  private var catalog: [String: TrackItem] = [:]
+  private var watchdog: DispatchWorkItem?
+  private static let requestTimeout: TimeInterval = 10
+
   /// Track ID playing on the receiver (or expected to, right after a locally-initiated jump).
   var currentRemoteTrackId: String? {
     stateLock.lock(); defer { stateLock.unlock() }
     return _lastCurrentTrackId
   }
 
+  /// The receiver's current track, resolved from what we last sent it.
+  var currentRemoteTrackItem: TrackItem? {
+    stateLock.lock(); defer { stateLock.unlock() }
+    return _lastCurrentTrackId.flatMap { id in _loadedTracks.first { $0.id == id } }
+  }
+
   /// IDs of the tracks last sent to the receiver, in queue order.
   var loadedTrackIds: [String] {
     stateLock.lock(); defer { stateLock.unlock() }
@@ -225,52 +239,39 @@ final class CastSessionManager: NSObject {
       return had
     }
     guard hadMedia else { return }
-    onMain { self.remoteClient?.stop() }
+    onMain { self.run(self.reconciler.unloadRequested()) }
     #endif
   }
 
-  // MARK: - Queue loading
+  // MARK: - Queue loading / reconciliation
 
-  /// Atomically replace the receiver queue — `tracks` must be castable and start at the item that should play.
-  func loadQueue(tracks: [TrackItem], position: Double, autoplay: Bool, repeatMode: RepeatMode) {
+  /// Serialized with every other receiver mutation. `startIndex` is the item that should play.
+  func loadQueue(
+    tracks: [TrackItem], startIndex: Int, position: Double, autoplay: Bool, repeatMode: RepeatMode
+  ) {
     #if canImport(GoogleCast)
-    guard !tracks.isEmpty else { return }
+    guard !tracks.isEmpty, startIndex >= 0, startIndex < tracks.count else { return }
     withState {
       _loadedTracks = tracks
       _hasLoadedMedia = true // optimistic; corrected by the next media status
-      _lastCurrentTrackId = tracks.first?.id
+      _lastCurrentTrackId = tracks[startIndex].id
     }
     onMain {
-      guard let client = self.remoteClient else { return }
-      let items = tracks.compactMap { self.makeQueueItem(for: $0, autoplay: autoplay) }
-      guard !items.isEmpty else { return }
-
-      let options = GCKMediaQueueLoadOptions()
-      options.startIndex = 0
-      options.playPosition = position.isFinite ? max(0, position) : 0
-      switch repeatMode {
-      case .track: options.repeatMode = .single
-      case .playlist: options.repeatMode = .all
-      default: options.repeatMode = .off
-      }
-      client.queueLoad(items, with: options)
+      for track in tracks { self.catalog[track.id] = track }
+      let load = CastQueueLoad(
+        tracks: tracks, startIndex: startIndex, position: position, autoplay: autoplay,
+        repeatMode: repeatMode)
+      self.run(self.reconciler.loadRequested(load))
     }
     #endif
   }
 
-  /// Append tracks to the END of the receiver queue without touching playback.
-  func appendToQueue(tracks: [TrackItem]) {
+  /// Current-preserving operations, no reload.
+  func reconcileQueue(desired tracks: [TrackItem], currentTrackId: String) {
     #if canImport(GoogleCast)
-    guard !tracks.isEmpty else { return }
-    withState {
-      let known = Set(_loadedTracks.map { $0.id })
-      _loadedTracks.append(contentsOf: tracks.filter { !known.contains($0.id) })
-    }
     onMain {
-      guard let client = self.remoteClient else { return }
-      let items = tracks.compactMap { self.makeQueueItem(for: $0, autoplay: true) }
-      guard !items.isEmpty else { return }
-      client.queueInsert(items, beforeItemWithID: kGCKMediaQueueInvalidItemID)
+      for track in tracks { self.catalog[track.id] = track }
+      self.run(self.reconciler.desired(ids: tracks.map(\.id), currentId: currentTrackId))
     }
     #endif
   }
@@ -428,6 +429,170 @@ final class CastSessionManager: NSObject {
 }
 
 #if canImport(GoogleCast)
+// MARK: - Reconciler host (main thread)
+
+extension CastSessionManager {
+
+  /// Every receiver mutation goes through here.
+  fileprivate func run(_ effect: CastQueueEffect) {
+    switch effect {
+    case .none:
+      publishOrder()
+    case .send(let op):
+      send(op)
+    case .sendLoad(let load):
+      sendLoad(load)
+    case .sendUnload:
+      guard let client = remoteClient else { return recover("no client") }
+      track(client.stop())
+    case .recover(let reason):
+      recover(reason)
+    }
+  }
+
+  private func send(_ op: CastQueueOp) {
+    guard let client = remoteClient else { return recover("no client") }
+    let ids = reconciler.order
+    let trackOf = reconciler.trackOf
+    func itemIDs(_ trackIds: [String]) -> [NSNumber]? {
+      var out: [NSNumber] = []
+      for trackId in trackIds {
+        guard let id = ids.first(where: { trackOf[$0] == trackId }) else { return nil }
+        out.append(NSNumber(value: id))
+      }
+      return out
+    }
+    switch op {
+    case .remove(let trackIds):
+      guard let items = itemIDs(trackIds) else { return recover("unknown item for remove") }
+      track(client.queueRemoveItems(withIDs: items))
+    case .insert(let trackIds):
+      let tracks = trackIds.compactMap { catalog[$0] }
+      guard tracks.count == trackIds.count else { return recover("catalog miss") }
+      let items = tracks.compactMap { makeQueueItem(for: $0, autoplay: true) }
+      guard items.count == tracks.count else { return recover("uncastable item") }
+      track(client.queueInsert(items, beforeItemWithID: kGCKMediaQueueInvalidItemID))
+    case .moveToEnd(let trackIds):
+      guard let items = itemIDs(trackIds) else { return recover("unknown item for reorder") }
+      track(
+        client.queueReorderItems(
+          withIDs: items, insertBeforeItemWithID: kGCKMediaQueueInvalidItemID))
+    case .moveBefore(let trackIds, let anchor):
+      guard let items = itemIDs(trackIds),
+        let anchorId = ids.first(where: { trackOf[$0] == anchor })
+      else { return recover("unknown item for reorder") }
+      track(client.queueReorderItems(withIDs: items, insertBeforeItemWithID: anchorId))
+    }
+  }
+
+  private func sendLoad(_ load: CastQueueLoad) {
+    guard let client = remoteClient else { return recover("no client") }
+    let items = load.tracks.compactMap { makeQueueItem(for: $0, autoplay: load.autoplay) }
+    guard items.count == load.tracks.count else { return recover("uncastable item") }
+    let options = GCKMediaQueueLoadOptions()
+    options.startIndex = UInt(load.startIndex)
+    options.playPosition = load.position.isFinite ? max(0, load.position) : 0
+    switch load.repeatMode {
+    case .track: options.repeatMode = .single
+    case .playlist: options.repeatMode = .all
+    default: options.repeatMode = .off
+    }
+    track(client.queueLoad(items, with: options))
+  }
+
+  /// Bounds the wait so a lost callback cannot stall the queue.
+  private func track(_ request: GCKRequest) {
+    request.delegate = self
+    reconciler.requestAssigned(request.requestID)
+    watchdog?.cancel()
+    let work = DispatchWorkItem { [weak self] in
+      guard let self else { return }
+      self.run(self.reconciler.requestFailed(request.requestID, reason: "request timeout"))
+    }
+    watchdog = work
+    DispatchQueue.main.asyncAfter(deadline: .now() + Self.requestTimeout, execute: work)
+  }
+
+  private func recover(_ reason: String) {
+    watchdog?.cancel()
+    watchdog = nil
+    NitroPlayerLogger.log("CastSessionManager", "Cast queue recovery: \(reason)")
+    guard let core else { return }
+    core.playerQueue.async {
+      core.loadCastQueue(
+        autoplay: core.intendedToPlay,
+        position: self.lastKnownRemotePosition)
+    }
+  }
+
+  fileprivate func observeReceiverQueue(_ client: GCKRemoteMediaClient) {
+    let queue = client.mediaQueue
+    let ids = (0..<queue.itemCount).map { queue.itemID(at: $0) }
+    run(reconciler.queueObserved(ids))
+    sweepVerification(queue)
+  }
+
+  /// Ids the SDK's rolling fetch window drops stay pending and are requested again.
+  private func sweepVerification(_ queue: GCKMediaQueue) {
+    let pending = reconciler.unverified
+    guard !pending.isEmpty else { return }
+    var requested = 0
+    for (index, id) in reconciler.order.enumerated() where pending.contains(id) {
+      if let item = queue.item(at: UInt(index), fetchIfNeeded: true) { verify(item) }
+      requested += 1
+      if requested >= 20 { break }
+    }
+  }
+
+  fileprivate func verify(_ item: GCKMediaQueueItem?) {
+    guard let item,
+      let customData = item.mediaInformation.customData as? [String: Any],
+      let trackId = customData["trackId"] as? String
+    else { return }
+    run(reconciler.verified(item.itemID, trackId: trackId))
+  }
+
+  /// Republish so playerQueue readers see the reconciled order.
+  fileprivate func publishOrder() {
+    let tracks = reconciler.orderedTrackIds.compactMap { catalog[$0] }
+    guard !tracks.isEmpty else { return }
+    withState { _loadedTracks = tracks }
+  }
+}
+
+// MARK: - GCKRequestDelegate
+
+extension CastSessionManager: GCKRequestDelegate {
+  func requestDidComplete(_ request: GCKRequest) {
+    watchdog?.cancel()
+    watchdog = nil
+    run(reconciler.requestCompleted(request.requestID))
+    if let client = remoteClient { observeReceiverQueue(client) }
+  }
+
+  func request(_ request: GCKRequest, didFailWithError error: GCKError) {
+    run(reconciler.requestFailed(request.requestID, reason: "request failed: \(error.code)"))
+  }
+
+  func request(_ request: GCKRequest, didAbortWith abortReason: GCKRequestAbortReason) {
+    run(reconciler.requestFailed(request.requestID, reason: "request aborted: \(abortReason.rawValue)"))
+  }
+}
+
+// MARK: - GCKMediaQueueDelegate
+
+extension CastSessionManager: GCKMediaQueueDelegate {
+  func mediaQueueDidChange(_ queue: GCKMediaQueue) {
+    if let client = remoteClient { observeReceiverQueue(client) }
+  }
+
+  func mediaQueue(_ queue: GCKMediaQueue, didUpdateItemsAtIndexes indexes: [NSNumber]) {
+    for index in indexes {
+      verify(queue.item(at: index.uintValue, fetchIfNeeded: false))
+    }
+  }
+}
+
 // MARK: - GCKSessionManagerListener
 
 extension CastSessionManager: GCKSessionManagerListener {
@@ -445,6 +610,14 @@ extension CastSessionManager: GCKSessionManagerListener {
 
   func sessionManager(_ sessionManager: GCKSessionManager, didEnd session: GCKSession, withError error: Error?) {
     stopProgressTimer()
+    (session as? GCKCastSession)?.remoteMediaClient?.mediaQueue.remove(self)
+    watchdog?.cancel()
+    watchdog = nil
+    // The handler runs asynchronously, so hand it a snapshot taken before the reset.
+    let snapshot = CastTransferSnapshot(
+      trackId: currentRemoteTrackId, position: lastKnownRemotePosition)
+    reconciler.sessionEnded()
+    catalog = [:]
     withState {
       _lastCurrentTrackId = nil
       _loadedTracks = []
@@ -452,12 +625,15 @@ extension CastSessionManager: GCKSessionManagerListener {
       _cachedPlaybackState = .stopped
       _lastEmittedPlaybackState = nil
     }
-    core?.handleCastDisconnected()
+    core?.handleCastDisconnected(snapshot)
     emitCastState()
   }
 
   private func handleSessionStarted(_ session: GCKSession) {
     (session as? GCKCastSession)?.remoteMediaClient?.add(self)
+    (session as? GCKCastSession)?.remoteMediaClient?.mediaQueue.add(self)
+    reconciler.sessionEnded()
+    catalog = [:]
     startProgressTimer()
     core?.handleCastConnected()
     emitCastState()
@@ -494,6 +670,14 @@ extension CastSessionManager: GCKRemoteMediaClientListener {
       }
     }
 
+    observeReceiverQueue(client)
+    if let status = mediaStatus {
+      verify(status.queueItem(withItemID: status.currentItemID))
+      if status.preloadedItemID != kGCKMediaQueueInvalidItemID {
+        verify(status.queueItem(withItemID: status.preloadedItemID))
+      }
+    }
+
     // Playback state — only forward actual changes (status updates are frequent).
     let stateChanged: Bool = withState {
       guard _lastEmittedPlaybackState != state else { return false }