react-native-audio-browser 0.2.0-next.2 → 0.2.0-next.21

package/ios/Tests/TrackSelectorTests.swift

@@ -12,15 +12,15 @@ private final class BrowserMock: TrackSelectionBrowser {
 
   // Record calls for verification
   var trackLoadEvents: [TrackLoadEvent] = []
-  var expandedUrls: [String] = []
+  var expandedPaths: [String] = []
 
   func awaitTrackLoadHandler(event: TrackLoadEvent) async -> Bool {
     trackLoadEvents.append(event)
     return trackLoadHandlerResult
   }
 
-  func expandQueueFromContextualUrl(_ url: String) async throws -> (tracks: [Track], selectedIndex: Int)? {
-    expandedUrls.append(url)
+  func expandQueueFromContextualPath(_ path: String) async throws -> (tracks: [Track], selectedIndex: Int)? {
+    expandedPaths.append(path)
     if let error = expandQueueError {
       throw error
     }
@@ -53,23 +53,23 @@ private func makeSelector() -> (TrackSelector, BrowserMock, PlayerMock) {
 @Suite("browsable track")
 @MainActor
 struct BrowsableTrackTests {
-  @Test func urlOnly_returnsBrowse() async {
+  @Test func pathOnly_returnsBrowse() async {
     let (selector, _, player) = makeSelector()
-    let track = Track(id: "t1", url: "/some/path")
+    let track = Track(id: "t1", path: "/some/path")
     let result = await selector.select(track: track, player: player)
-    guard case let .browse(url) = result else {
+    guard case let .browse(path) = result else {
       Issue.record("expected .browse, got \(result)")
       return
     }
-    #expect(url == "/some/path")
+    #expect(path == "/some/path")
   }
 }
 
-// MARK: - No src or url
+// MARK: - No src or path
 
-@Suite("no src or url")
+@Suite("no src or path")
 @MainActor
-struct NoSrcOrUrlTests {
+struct NoSrcOrPathTests {
   @Test func returnsNone() async {
     let (selector, _, player) = makeSelector()
     let track = Track(id: "t1")
@@ -115,25 +115,56 @@ struct PlayableTrackTests {
   }
 }
 
-// MARK: - Contextual URL Queue Reuse
+// MARK: - Contextual path Queue Reuse
 
-@Suite("contextual URL queue reuse")
+@Suite("contextual path queue reuse")
 @MainActor
-struct ContextualUrlQueueReuseTests {
+struct ContextualPathQueueReuseTests {
   @Test func matchingQueueSourcePath_returnsSkipTo() async {
     let (selector, browser, player) = makeSelector()
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+
+    // Id-less queue tracks: identity falls back to src.
+    player.queueSourcePath = parentPath
+    player.tracks = [
+      Track(src: "other.mp3"),
+      Track(src: "song.mp3"),
+      Track(src: "another.mp3"),
+    ]
+
+    let track = Track(path: contextualPath, src: trackSrc)
+    let result = await selector.select(track: track, player: player)
+    guard case let .play(intent) = result else {
+      Issue.record("expected .play, got \(result)")
+      return
+    }
+    guard case let .skipTo(index) = intent else {
+      Issue.record("expected .skipTo, got \(intent)")
+      return
+    }
+    #expect(index == 1)
+    #expect(browser.trackLoadEvents.count == 1)
+    #expect(browser.expandedPaths.isEmpty)
+  }
+
+  // Skip-in-place matches by id when queue tracks carry ids: the contextual
+  // trackId is the row's identity (its id), and the queue row is found even
+  // though its src differs textually from the tapped track's.
+  @Test func matchingQueueSourcePath_skipsToTrackByIdWhenSrcDiffers() async {
+    let (selector, browser, player) = makeSelector()
+    let parentPath = "/library/radio"
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: "b")
 
     player.queueSourcePath = parentPath
     player.tracks = [
       Track(id: "a", src: "other.mp3"),
-      Track(id: "b", src: "song.mp3"),
+      Track(id: "b", src: "https://cdn.example/song.mp3?token=queue"),
       Track(id: "c", src: "another.mp3"),
     ]
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(id: "b", path: contextualPath, src: "song.mp3")
     let result = await selector.select(track: track, player: player)
     guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
@@ -144,8 +175,7 @@ struct ContextualUrlQueueReuseTests {
       return
     }
     #expect(index == 1)
-    #expect(browser.trackLoadEvents.count == 1)
-    #expect(browser.expandedUrls.isEmpty)
+    #expect(browser.expandedPaths.isEmpty)
   }
 
   @Test func handlerIntercepts_returnsIntercepted() async {
@@ -153,32 +183,93 @@ struct ContextualUrlQueueReuseTests {
     browser.trackLoadHandlerResult = true
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
 
     player.queueSourcePath = parentPath
     player.tracks = [
-      Track(id: "a", src: "song.mp3"),
+      Track(src: "song.mp3"),
     ]
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(path: contextualPath, src: trackSrc)
     let result = await selector.select(track: track, player: player)
     guard case .intercepted = result else {
       Issue.record("expected .intercepted, got \(result)")
       return
     }
+    #expect(browser.expandedPaths.isEmpty)
+  }
+
+  // A queue holding the same identity twice (normal for music playlists):
+  // exact contextual-path equality — which carries the stamped page index —
+  // pins the tapped copy instead of the first one.
+  @Test func duplicateIdentityInQueue_pathMatchPinsTheTappedCopy() async {
+    let (selector, browser, player) = makeSelector()
+    let parentPath = "/playlist"
+    func stamped(_ id: String, _ index: Int) -> String {
+      BrowserPathHelper.build(parentPath: parentPath, trackId: id, index: index)
+    }
+
+    player.queueSourcePath = parentPath
+    player.tracks = [
+      Track(path: stamped("a", 0), src: "a"),
+      Track(path: stamped("b", 1), src: "b"),
+      Track(path: stamped("a", 2), src: "a"),
+    ]
+
+    let track = Track(path: stamped("a", 2), src: "a")
+    let result = await selector.select(track: track, player: player)
+    guard case let .play(.skipTo(index)) = result else {
+      Issue.record("expected .play(.skipTo), got \(result)")
+      return
+    }
+    #expect(index == 2)
+    #expect(browser.expandedPaths.isEmpty)
+  }
+
+  // A tap in section B whose identity also sits in the active section-A
+  // queue: the exact surface is not in the queue, so the selection
+  // re-expands (re-scoping to the tapped section) instead of silently
+  // skipping inside the old section's queue.
+  @Test func indexStampedPathNotInQueue_reExpandsInsteadOfIdentitySkip() async {
+    let (selector, browser, player) = makeSelector()
+    let parentPath = "/city"
+    func stamped(_ id: String, _ index: Int) -> String {
+      BrowserPathHelper.build(parentPath: parentPath, trackId: id, index: index)
+    }
+
+    player.queueSourcePath = parentPath
+    player.tracks = [
+      Track(path: stamped("dup", 0), src: "dup"),
+      Track(path: stamped("x", 1), src: "x"),
+    ]
+    browser.expandQueueResult = (
+      tracks: [Track(path: stamped("y", 4), src: "y"), Track(path: stamped("dup", 5), src: "dup")],
+      selectedIndex: 1,
+    )
+
+    let track = Track(path: stamped("dup", 5), src: "dup")
+    let result = await selector.select(track: track, player: player)
+    guard case let .play(.setQueue(tracks, startIndex, sourcePath)) = result else {
+      Issue.record("expected .play(.setQueue), got \(result)")
+      return
+    }
+    #expect(tracks.count == 2)
+    #expect(startIndex == 1)
+    #expect(sourcePath == parentPath)
+    #expect(browser.expandedPaths == [stamped("dup", 5)])
   }
 }
 
-// MARK: - Contextual URL Expansion
+// MARK: - Contextual path Expansion
 
-@Suite("contextual URL expansion")
+@Suite("contextual path expansion")
 @MainActor
-struct ContextualUrlExpansionTests {
+struct ContextualPathExpansionTests {
   @Test func expands_returnsSetQueue() async {
     let (selector, browser, player) = makeSelector()
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
 
     let expandedTracks = [
       Track(id: "a", src: "first.mp3"),
@@ -187,7 +278,7 @@ struct ContextualUrlExpansionTests {
     ]
     browser.expandQueueResult = (tracks: expandedTracks, selectedIndex: 1)
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(id: "t1", path: contextualPath, src: trackSrc)
     let result = await selector.select(track: track, player: player)
     guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
@@ -200,7 +291,7 @@ struct ContextualUrlExpansionTests {
     #expect(tracks.count == 3)
     #expect(startIndex == 1)
     #expect(sourcePath == parentPath)
-    #expect(browser.expandedUrls == [contextualUrl])
+    #expect(browser.expandedPaths == [contextualPath])
     #expect(browser.trackLoadEvents.count == 1)
   }
 
@@ -209,14 +300,14 @@ struct ContextualUrlExpansionTests {
     browser.trackLoadHandlerResult = true
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
 
     browser.expandQueueResult = (
       tracks: [Track(id: "a", src: "song.mp3")],
       selectedIndex: 0,
     )
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(id: "t1", path: contextualPath, src: trackSrc)
     let result = await selector.select(track: track, player: player)
     guard case .intercepted = result else {
       Issue.record("expected .intercepted, got \(result)")
@@ -228,11 +319,11 @@ struct ContextualUrlExpansionTests {
     let (selector, browser, player) = makeSelector()
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
 
     browser.expandQueueResult = nil
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(id: "t1", path: contextualPath, src: trackSrc)
     let result = await selector.select(track: track, player: player)
     guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
@@ -249,11 +340,11 @@ struct ContextualUrlExpansionTests {
     let (selector, browser, player) = makeSelector()
     let parentPath = "/library/radio"
     let trackSrc = "song.mp3"
-    let contextualUrl = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
+    let contextualPath = BrowserPathHelper.build(parentPath: parentPath, trackId: trackSrc)
 
     browser.expandQueueError = MockError.expansion
 
-    let track = Track(id: "t1", url: contextualUrl, src: trackSrc)
+    let track = Track(id: "t1", path: contextualPath, src: trackSrc)
     let result = await selector.select(track: track, player: player)
     guard case let .play(intent) = result else {
       Issue.record("expected .play, got \(result)")
@@ -266,3 +357,47 @@ struct ContextualUrlExpansionTests {
     #expect(loaded.src == trackSrc)
   }
 }
+
+// MARK: - Disabled Track
+
+@Suite("disabled track")
+@MainActor
+struct DisabledTrackTests {
+  @Test func disabledPlayable_returnsNone() async {
+    let (selector, browser, player) = makeSelector()
+    let track = Track(id: "t1", src: "https://example.com/a.mp3", disabled: true)
+    let result = await selector.select(track: track, player: player)
+    guard case .none = result else {
+      Issue.record("Expected .none for a disabled track, got \(result)")
+      return
+    }
+    // Refused outright: not even the JS load handler hears about it.
+    #expect(browser.trackLoadEvents.isEmpty)
+  }
+
+  @Test func disabledBrowsable_returnsNone() async {
+    // Unavailable means unavailable — a disabled browsable doesn't navigate
+    // either (the ladder grays or hides it; a delivered tap stays inert).
+    let (selector, _, player) = makeSelector()
+    let track = Track(id: "t1", path: "/gone", disabled: true)
+    let result = await selector.select(track: track, player: player)
+    guard case .none = result else {
+      Issue.record("Expected .none for a disabled browsable, got \(result)")
+      return
+    }
+  }
+
+  @Test func disabledContextual_neverExpands() async {
+    let (selector, browser, player) = makeSelector()
+    browser.expandQueueResult = (tracks: [Track(id: "a", src: "a")], selectedIndex: 0)
+    let track = Track(
+      id: "t1", path: "/home?__trackId=t1", src: "https://example.com/a.mp3", disabled: true,
+    )
+    let result = await selector.select(track: track, player: player)
+    guard case .none = result else {
+      Issue.record("Expected .none, got \(result)")
+      return
+    }
+    #expect(browser.expandedPaths.isEmpty)
+  }
+}

package/ios/TrackPlayer.swift

@@ -136,7 +136,7 @@ class TrackPlayer {
   var previousTracks: [Track] { coordinator.previousTracks }
   var isLastInPlaybackOrder: Bool { coordinator.isLastInPlaybackOrder }
   var playbackActive: Bool { coordinator.playbackActive }
-  var sleepTimerManager: SleepTimerManager { coordinator.sleepTimerManager as! SleepTimerManager }
+  var sleepTimerManager: any SleepTimerHandling { coordinator.sleepTimerManager }
   var queue: QueueManager { coordinator.queue }
   var loadSeekCoordinator: LoadSeekCoordinator { coordinator.loadSeekCoordinator }
   var playingStateManager: PlayingStateManager { coordinator.playingStateManager }
@@ -195,12 +195,14 @@ class TrackPlayer {
     return seconds.isNaN ? 0 : seconds
   }
 
+  /// The current item's duration, or 0 when it has none (a live stream).
+  ///
+  /// Don't reintroduce `item.asset.duration`: it is deprecated as of the iOS 16
+  /// minimum and blocks the main actor fetching a remote asset's duration. Read
+  /// on every progress tick.
   var duration: Double {
     guard let item = avPlayer.currentItem else { return 0.0 }
 
-    if !item.asset.duration.seconds.isNaN {
-      return item.asset.duration.seconds
-    }
     if !item.duration.seconds.isNaN {
       return item.duration.seconds
     }
@@ -252,8 +254,22 @@ class TrackPlayer {
   var rate: Float {
     get { coordinator.rate }
     set {
+      // A non-positive rate leaves the player unable to play at all — and would
+      // poison the next play() through `defaultRate` below. Rejected here, at
+      // the one setter every source funnels through (JS, remote command, CarPlay
+      // rate cycling, a restored snapshot), rather than at each of them.
+      guard newValue > 0 else { return }
       coordinator.rate = newValue
-      avPlayer.rate = newValue
+      // Assigning a nonzero `AVPlayer.rate` IS `play()` — so setting the speed
+      // while paused would start audible playback behind the user's back, with
+      // `playWhenReady` still false (the lock screen would read "paused" over
+      // sound). On Android and web the speed control is independent of the play
+      // intent; this keeps iOS the same.
+      avPlayer.defaultRate = newValue
+      if playWhenReady { avPlayer.rate = newValue }
+      // Same reason as the repeat/shuffle edges below — a speed changed while
+      // paused would otherwise not reach the snapshot the cold resume restores.
+      persistPlaybackState()
     }
   }
 
@@ -312,17 +328,6 @@ class TrackPlayer {
     coordinator.load(track, playWhenReady: playWhenReady)
   }
 
-  func togglePlaying() {
-    switch avPlayer.timeControlStatus {
-    case .playing, .waitingToPlayAtSpecifiedRate:
-      pause()
-    case .paused:
-      play()
-    @unknown default:
-      fatalError("Unknown AVPlayer.timeControlStatus")
-    }
-  }
-
   func play() { coordinator.play() }
   func pause() { coordinator.pause() }
   func togglePlayback() { coordinator.togglePlayback() }
@@ -456,13 +461,22 @@ class TrackPlayer {
     )
   }
 
+  /// Empties the queue and the published now-playing info. Unlinking the
+  /// session belongs in `destroy()`: `avPlayer` survives a clear, and only
+  /// `setupAVPlayer()` re-links.
   func clear() {
     coordinator.clear()
-    nowPlayingInfoController.unlinkPlayer()
   }
 
   func destroy() {
     clear()
+    // The player is going away for good — now the session must go with it.
+    nowPlayingInfoController.unlinkPlayer()
+    // An AVPlayer retains its time observers: one left registered is still attached when the
+    // player is released, and outlives this object.
+    playerTimeObserver.unregisterForBoundaryTimeEvents()
+    playerObserver.stopObserving()
+    stopObservingAVPlayerItem()
     remoteCommandController.disableAll()
   }
 
@@ -545,10 +559,12 @@ class TrackPlayer {
 
     nowPlayingInfoController.linkPlayer(avPlayer)
 
+    // Stage the rate unconditionally, so a freshly recreated player carries it
+    // before anything plays — `rate`'s setter holds the same invariant, and on
+    // the playWhenReady branch below `defaultRate` was previously left at 1.0.
+    avPlayer.defaultRate = rate
     if playWhenReady {
       startPlayback()
-    } else {
-      avPlayer.defaultRate = rate
     }
   }
 
@@ -750,13 +766,28 @@ extension TrackPlayer {
       PersistedPlaybackState(
         track: JsonTrack(from: track),
         positionMs: positionMs,
-        repeatMode: repeatMode.persistedString,
+        repeatMode: repeatMode.stringValue,
         shuffleEnabled: shuffleEnabled,
         playbackSpeed: rate,
-      )
+      ),
     )
   }
 
+  /// Applies the player settings a snapshot carries — the inverse of
+  /// `persistPlaybackState()`, and the twin of the Kotlin store's `restore()`.
+  ///
+  /// Call BEFORE building the queue: `setQueue` rebuilds the shuffle order
+  /// pinned to the starting track, so shuffle has to be set for that order to
+  /// be the one playback uses (and the mode events then precede the
+  /// queue-changed event, as on Android). An unrecognized repeat mode restores
+  /// as `.off` rather than failing the whole resume over one field; a
+  /// non-positive speed is rejected by `rate`'s own setter.
+  func restorePlaybackSettings(from state: PersistedPlaybackState) {
+    repeatMode = RepeatMode(fromString: state.repeatMode) ?? .off
+    shuffleEnabled = state.shuffleEnabled
+    rate = state.playbackSpeed
+  }
+
   /// Start a 5 s repeating save while playback is active. A previous task is
   /// cancelled first so there is never more than one running at a time.
   private func startPeriodicSave() {
@@ -776,17 +807,6 @@ extension TrackPlayer {
   }
 }
 
-private extension RepeatMode {
-  /// String representation stored in `PersistedPlaybackState.repeatMode`.
-  var persistedString: String {
-    switch self {
-    case .off: "off"
-    case .track: "track"
-    case .queue: "queue"
-    }
-  }
-}
-
 // MARK: - PlaybackEffectHandler
 
 extension TrackPlayer: PlaybackEffectHandler {
@@ -852,15 +872,23 @@ extension TrackPlayer: PlaybackEffectHandler {
   }
 
   func clearNowPlaying() {
-    nowPlayingInfoController.clear()
+    nowPlayingUpdater.clearNowPlaying()
   }
 
+  // Both persist: a snapshot is otherwise only written on track load, on pause,
+  // and every 5s while playing, so a mode toggled while paused was lost — the
+  // cold-start resume would restore the value from before the toggle. Android
+  // persists on every setting change (`PlayerListener.onRepeatModeChanged` /
+  // `onShuffleModeEnabledChanged`); these are the same two edges, and the
+  // coordinator only calls them on a real change.
   func updateRemoteRepeatMode(_ mode: RepeatMode) {
     remoteCommandController.updateRepeatMode(mode)
+    persistPlaybackState()
   }
 
   func updateRemoteShuffleMode(_ enabled: Bool) {
     remoteCommandController.updateShuffleMode(enabled)
+    persistPlaybackState()
   }
 
   func updateSkipAvailability(canNext: Bool, canPrevious: Bool) {
@@ -879,8 +907,8 @@ extension TrackPlayer: TrackSelectionPlayer {}
 // MARK: - Queue Methods (thin forwarders)
 
 extension TrackPlayer {
-  func replace(_ index: Int, _ track: Track) {
-    coordinator.replace(index, track)
+  func replace(_ index: Int, _ track: Track) throws {
+    try coordinator.replace(index, track)
   }
 
   func setQueue(

package/ios/TrackPlayerCallbacks.swift

@@ -9,10 +9,11 @@ import NitroModules
 /// Note: Method names are prefixed to avoid conflicts with JS callback property names.
 /// All callbacks are called from the main actor since TrackPlayer is @MainActor.
 ///
-/// Extends PlaybackCoordinatorCallbacks for the state machine / coordinator callbacks,
-/// then adds metadata, seek, remote, and configuration callbacks that are TrackPlayer-specific.
+/// Extends PlaybackCoordinatorCallbacks for the state machine / coordinator callbacks
+/// and RemoteCommandCallbacks for the remote-command events, then adds metadata,
+/// seek, and configuration callbacks that are TrackPlayer-specific.
 @MainActor
-protocol TrackPlayerCallbacks: PlaybackCoordinatorCallbacks {
+protocol TrackPlayerCallbacks: PlaybackCoordinatorCallbacks, RemoteCommandCallbacks {
   // MARK: - Metadata Events
 
   /// Called when common metadata is received.
@@ -34,32 +35,7 @@ protocol TrackPlayerCallbacks: PlaybackCoordinatorCallbacks {
 
   // MARK: - Remote Control Events
 
-  /// Called when play is triggered remotely.
-  func remotePlay()
-
-  /// Called when pause is triggered remotely.
-  func remotePause()
-
-  /// Called when stop is triggered remotely.
-  func remoteStop()
-
-  /// Called when toggle play/pause is triggered remotely.
-  func remotePlayPause()
-
-  /// Called when next is triggered remotely.
-  func remoteNext()
-
-  /// Called when previous is triggered remotely.
-  func remotePrevious()
-
-  /// Called when jump forward is triggered remotely.
-  func remoteJumpForward(interval: Double)
-
-  /// Called when jump backward is triggered remotely.
-  func remoteJumpBackward(interval: Double)
-
-  /// Called when seek is triggered remotely.
-  func remoteSeek(position: Double)
+  // The command-center events live in RemoteCommandCallbacks, inherited above.
 
   /// Called when change playback position is triggered remotely.
   func remoteChangePlaybackPosition(position: Double)
@@ -70,15 +46,6 @@ protocol TrackPlayerCallbacks: PlaybackCoordinatorCallbacks {
   /// Called when play from search is triggered remotely.
   func remotePlaySearch(query: String)
 
-  /// Called when repeat mode change is triggered remotely (CarPlay/lock screen).
-  func remoteChangeRepeatMode(mode: RepeatMode)
-
-  /// Called when shuffle mode change is triggered remotely (CarPlay/lock screen).
-  func remoteChangeShuffleMode(enabled: Bool)
-
-  /// Called when playback rate change is triggered remotely (CarPlay/lock screen).
-  func remoteChangePlaybackRate(rate: Float)
-
   // MARK: - Configuration Events
 
   /// Called when options are changed.