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

package/ios/Tests/LoadSeekCoordinatorTests.swift

@@ -246,7 +246,9 @@ struct ResetTests {
     c.capture(position: 25.0)
 
     // Let the (immediately-cancelled, itemless) seek completion drain.
-    for _ in 0 ..< 20 { await Task.yield() }
+    for _ in 0 ..< 20 {
+      await Task.yield()
+    }
 
     #expect(spy.calls.isEmpty)
     #expect(c.pendingTime == 25.0)

package/ios/Tests/MediaIntentCriteriaTests.swift

@@ -57,12 +57,12 @@ struct MediaIntentCriteriaFromTests {
     mediaTypeMode: String? = nil,
     reference: MediaIntentCriteria.Reference = .unknown,
     hasMediaType: Bool = false,
-    appName: String? = "Radio Garden"
+    appName: String? = "Radio Garden",
   ) -> MediaIntentCriteria {
     MediaIntentCriteria.from(
       mediaName: mediaName, genreNames: genreNames, artistName: artistName,
       albumName: albumName, mediaTypeMode: mediaTypeMode,
-      reference: reference, hasMediaType: hasMediaType, appName: appName
+      reference: reference, hasMediaType: hasMediaType, appName: appName,
     )
   }
 

package/ios/Tests/PlaybackCoordinatorTests.swift

@@ -120,7 +120,7 @@ struct TransitionTests {
 @MainActor
 private func makeRetrying() -> (
   PlaybackCoordinator, MockRetryHandling, MockPlaybackCoordinatorCallbacks,
-  MockPlaybackEffectHandler
+  MockPlaybackEffectHandler,
 ) {
   let retryHandler = MockRetryHandling()
   retryHandler.isRetryableResult = true

package/ios/Tests/PlaybackErrorHandlerTests.swift

@@ -14,9 +14,11 @@ private final class MockRetryHandler: RetryHandling {
   var attemptRetryResult = false
   var attemptRetryCallCount = 0
   var lastStartFromCurrentTime: Bool?
+  var lastHTTPStatusCode: Int??
   var resetCallCount = 0
 
-  func isRetryable(_ error: Error?) -> Bool {
+  func isRetryable(_ error: Error?, httpStatusCode: Int?) -> Bool {
+    lastHTTPStatusCode = .some(httpStatusCode)
     guard let error else { return false }
     let code = (error as NSError).code
     return retryableErrors.contains(code)

package/ios/Tests/PlaybackStateStoreTests.swift

@@ -14,10 +14,11 @@ struct PlaybackStateStoreTests {
 
   private func sampleTrack() -> JsonTrack {
     JsonTrack(
-      id: "abc", url: nil, title: "Test FM", subtitle: nil, artwork: nil,
-      artist: "City, Country", albumUrl: nil, album: nil, description: nil,
+      id: "abc", path: nil, title: "Test FM", subtitle: nil, artwork: nil,
+      artist: "City, Country", albumPath: nil, album: nil, description: nil,
       genre: nil, duration: nil, src: "/listen/abc/channel.mp3", request: nil,
-      style: nil, childrenStyle: nil, groupTitle: nil, live: true, imageRow: nil,
+      style: JsonStyle(display: "grid", artworkRendering: "stencil"),
+      disabled: false, live: true, icyCharset: "windows-1251",
     )
   }
 

package/ios/Tests/PlayerTimeObserverTests.swift

@@ -0,0 +1,37 @@
+import AVFoundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@MainActor
+@Suite("PlayerTimeObserver")
+struct PlayerTimeObserverTests {
+  /// An AVPlayer retains its time observers, so one left registered outlives both this object and
+  /// the caller's interest in it (#96).
+  @Test func unregisteringDropsTheToken() {
+    // Held: `avPlayer` is weak, so a temporary is gone before the next line.
+    let player = AVPlayer()
+    let observer = PlayerTimeObserver(onAudioDidStart: {})
+    observer.avPlayer = player
+
+    observer.registerForBoundaryTimeEvents()
+    #expect(observer.boundaryTimeStartObserverToken != nil)
+
+    observer.unregisterForBoundaryTimeEvents()
+    #expect(observer.boundaryTimeStartObserverToken == nil)
+  }
+
+  /// Swapping players has to unregister from the outgoing one — it is a different AVPlayer, and
+  /// the token cannot be removed from it afterwards.
+  @Test func swappingPlayersUnregistersFromThePrevious() {
+    let first = AVPlayer()
+    let second = AVPlayer()
+    let observer = PlayerTimeObserver(onAudioDidStart: {})
+    observer.avPlayer = first
+    observer.registerForBoundaryTimeEvents()
+
+    observer.avPlayer = second
+
+    #expect(observer.boundaryTimeStartObserverToken == nil)
+  }
+}

package/ios/Tests/QueueManagerTests.swift

@@ -74,6 +74,87 @@ struct NextTests {
     #expect(q.currentIndex == 0)
   }
 
+  /// The start track must be first in the shuffle order, not wherever the permutation put it —
+  /// otherwise auto-advance ends the queue as soon as it is reached (#96).
+  @Test func shuffle_startTrackLeadsTheOrder() {
+    for start in 0 ..< 6 {
+      let q = QueueManager()
+      q.setQueue(tracks("a", "b", "c", "d", "e", "f"), initialIndex: start)
+      q.shuffleEnabled = true
+
+      #expect(q.shuffleOrder.isFirst(start))
+      #expect(!q.isLastInPlaybackOrder)
+      #expect(q.nextTracks.count == 5)
+      #expect(q.previousTracks.isEmpty)
+    }
+  }
+
+  /// Same hazard on enabling shuffle mid-queue: the existing order has the current track wherever
+  /// it landed, so without re-pinning, turning shuffle on can immediately report end-of-queue.
+  @Test func shuffle_enablingMidQueueLeadsFromCurrent() {
+    for start in 0 ..< 6 {
+      let q = QueueManager()
+      q.setQueue(tracks("a", "b", "c", "d", "e", "f"))
+      _ = try? q.skipTo(start)
+
+      q.shuffleEnabled = true
+
+      #expect(q.shuffleOrder.isFirst(start))
+      #expect(!q.isLastInPlaybackOrder)
+      #expect(q.nextTracks.count == 5)
+    }
+  }
+
+  /// Re-pinning happens on enable only — flipping it off and on again must not renege on the
+  /// order mid-listen, and a redundant `= true` must not reshuffle under the listener.
+  @Test func shuffle_redundantEnableKeepsTheOrder() {
+    let q = QueueManager()
+    q.setQueue(tracks("a", "b", "c", "d", "e", "f"))
+    q.shuffleEnabled = true
+    let order = q.shuffleOrder.shuffled
+
+    q.shuffleEnabled = true
+    #expect(q.shuffleOrder.shuffled == order)
+
+    q.shuffleEnabled = false
+    #expect(q.shuffleOrder.shuffled == order)
+  }
+
+  /// A queue reorder permutes positions, not identities, so it must leave the
+  /// shuffled playback order alone. Re-inserting at a random shuffle position
+  /// would silently reshuffle under the listener.
+  @Test func shuffle_moveKeepsThePlaybackOrder() {
+    for target in 0 ..< 5 {
+      let q = QueueManager()
+      q.setQueue(tracks("a", "b", "c", "d", "e"))
+      q.shuffleEnabled = true
+      let before = q.shuffleOrder.shuffled.map { q.tracks[$0].id }
+
+      _ = try? q.move(fromIndex: 0, toIndex: target)
+
+      #expect(q.shuffleOrder.shuffled.map { q.tracks[$0].id } == before)
+    }
+  }
+
+  /// The same hazard as `shuffle_startTrackLeadsTheOrder`, reached by moving the
+  /// *playing* track: a random re-insert can drop it last in the shuffle order,
+  /// which reads as `isLastInPlaybackOrder` and ends the queue at the next track
+  /// boundary with tracks still unplayed.
+  @Test func shuffle_movingCurrentTrackDoesNotEndTheQueue() {
+    for target in 1 ..< 6 {
+      let q = QueueManager()
+      q.setQueue(tracks("a", "b", "c", "d", "e", "f"), initialIndex: 0)
+      q.shuffleEnabled = true // pins "a" first in the order
+      #expect(!q.isLastInPlaybackOrder)
+
+      _ = try? q.move(fromIndex: 0, toIndex: target)
+
+      #expect(q.currentTrack?.id == "a")
+      #expect(!q.isLastInPlaybackOrder)
+      #expect(q.nextTracks.count == 5)
+    }
+  }
+
   @Test func shuffle_visitsAllTracks() {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c", "d"))
@@ -336,6 +417,25 @@ struct AddTests {
     #expect(q.tracks[2].id == "c")
     #expect(q.tracks[3].id == "d")
   }
+
+  /// Filling an empty queue must pin the start track to the head of the shuffle
+  /// order, exactly as `setQueue` does — `insert(at:count:)` places new indices
+  /// at random positions, so without the pin the start track can land last and
+  /// the queue reports end-of-queue as soon as it finishes. `shuffleEnabled`'s
+  /// didSet only re-pins on the off→on edge, so shuffle-already-on gets nothing
+  /// from it.
+  @Test func toEmptyQueue_withShuffleAlreadyOn_startTrackLeadsTheOrder() {
+    for start in 0 ..< 6 {
+      let q = QueueManager()
+      q.shuffleEnabled = true
+      q.add(tracks("a", "b", "c", "d", "e", "f"), initialIndex: start)
+
+      #expect(q.shuffleOrder.isFirst(start))
+      #expect(!q.isLastInPlaybackOrder)
+      #expect(q.nextTracks.count == 5)
+      #expect(q.previousTracks.isEmpty)
+    }
+  }
 }
 
 // MARK: - Mutations: addAt()
@@ -368,6 +468,18 @@ struct AddAtTests {
     #expect(q.currentIndex == 0)
   }
 
+  /// Same pinning requirement as `add()` into an empty queue — see its twin.
+  @Test func toEmptyQueue_withShuffleAlreadyOn_startTrackLeadsTheOrder() throws {
+    let q = QueueManager()
+    q.shuffleEnabled = true
+    try q.addAt(tracks("a", "b", "c", "d", "e", "f"), at: 0)
+
+    #expect(q.shuffleOrder.isFirst(0))
+    #expect(!q.isLastInPlaybackOrder)
+    #expect(q.nextTracks.count == 5)
+    #expect(q.previousTracks.isEmpty)
+  }
+
   @Test func invalidIndex_throws() {
     let q = QueueManager()
     q.setQueue(tracks("a"))
@@ -645,10 +757,10 @@ struct ClearTests {
 @Suite("replace & removeUpcomingTracks")
 @MainActor
 struct OtherMutationTests {
-  @Test func replace_updatesTrackAtIndex() {
+  @Test func replace_updatesTrackAtIndex() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"))
-    q.replace(1, Track(id: "B"))
+    try q.replace(1, Track(id: "B"))
     #expect(q.tracks[1].id == "B")
   }
 
@@ -692,10 +804,10 @@ struct OtherMutationTests {
     #expect(q.tracks[0].id == "a")
   }
 
-  @Test func replace_currentTrack_reflectsInCurrentTrack() {
+  @Test func replace_currentTrack_reflectsInCurrentTrack() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c"), initialIndex: 1)
-    q.replace(1, Track(id: "B"))
+    try q.replace(1, Track(id: "B"))
     #expect(q.currentTrack?.id == "B")
     #expect(q.currentIndex == 1)
   }
@@ -767,13 +879,13 @@ struct ComputedPropertyTests {
     let q = QueueManager()
     q.setQueue(tracks("a", "b", "c", "d"))
     q.shuffleEnabled = true
-    let nextFromProp = q.nextTracks.map(\.id)
+    let nextFromProp = q.nextTracks.map { $0.id! }
     // Navigate forward only as many times as nextTracks reports
     // (nextTracks does not include wrapped tracks)
     var nextFromNav: [String] = []
     for _ in 0 ..< nextFromProp.count {
       _ = q.next()
-      nextFromNav.append(q.currentTrack!.id)
+      nextFromNav.append(q.currentTrack!.id!)
     }
     #expect(nextFromProp == nextFromNav)
   }
@@ -786,12 +898,12 @@ struct ComputedPropertyTests {
     for _ in 0 ..< 3 {
       _ = q.next()
     }
-    let prevFromProp = q.previousTracks.map(\.id)
+    let prevFromProp = q.previousTracks.map { $0.id! }
     // Navigate backward the same number of times
     var prevFromNav: [String] = []
     for _ in 0 ..< prevFromProp.count {
       _ = q.previous()
-      prevFromNav.insert(q.currentTrack!.id, at: 0)
+      prevFromNav.insert(q.currentTrack!.id!, at: 0)
     }
     #expect(prevFromProp == prevFromNav)
   }
@@ -880,12 +992,12 @@ struct DelegateTests {
     #expect(spy.calls.count == 1)
   }
 
-  @Test func queueDidChangeTracks_firesOnReplace() {
+  @Test func queueDidChangeTracks_firesOnReplace() throws {
     let q = QueueManager()
     q.setQueue(tracks("a", "b"))
     let spy = DelegateSpy()
     q.delegate = spy
-    q.replace(0, Track(id: "A"))
+    try q.replace(0, Track(id: "A"))
     #expect(spy.calls.count == 1)
   }
 

package/ios/Tests/RemoteCommandControllerTests.swift

@@ -0,0 +1,172 @@
+import Foundation
+import MediaPlayer
+import Testing
+
+@testable import AudioBrowserTestable
+
+/// Exercises the controller against the real `MPRemoteCommandCenter`.
+///
+/// `MPRemoteCommandCenter`'s `init()` is unavailable, so `shared()` — a
+/// process-wide singleton — is the only center available. The suite is
+/// `.serialized` because of that shared state, and every test resets the
+/// commands it touches through `reset()`.
+@Suite("RemoteCommandController", .serialized)
+@MainActor
+struct RemoteCommandControllerTests {
+  final class SpyCallbacks: RemoteCommandCallbacks {
+    var events: [String] = []
+    func remotePlay() { events.append("play") }
+    func remotePause() { events.append("pause") }
+    func remoteStop() { events.append("stop") }
+    func remotePlayPause() { events.append("playPause") }
+    func remoteNext() { events.append("next") }
+    func remotePrevious() { events.append("previous") }
+    func remoteJumpForward(interval: Double) { events.append("jumpForward:\(interval)") }
+    func remoteJumpBackward(interval: Double) { events.append("jumpBackward:\(interval)") }
+    func remoteSeek(position: Double) { events.append("seek:\(position)") }
+    func remoteChangeRepeatMode(mode: RepeatMode) { events.append("repeat:\(mode)") }
+    func remoteChangeShuffleMode(enabled: Bool) { events.append("shuffle:\(enabled)") }
+    func remoteChangePlaybackRate(rate: Float) { events.append("rate:\(rate)") }
+  }
+
+  /// Clears every command on the shared center so a test starts from a known
+  /// state regardless of what ran before it.
+  private func makeController() -> (RemoteCommandController, SpyCallbacks) {
+    let center = MPRemoteCommandCenter.shared()
+    let reset = RemoteCommandController(remoteCommandCenter: center)
+    reset.enable(commands: RemoteCommand.all())
+    reset.disableAll()
+
+    let spy = SpyCallbacks()
+    return (RemoteCommandController(remoteCommandCenter: center, callbacks: spy), spy)
+  }
+
+  /// The reported bug: a changed jump interval used to disable the very command
+  /// it had just re-enabled, removing the skip button from the lock screen,
+  /// Control Center and CarPlay while `enabledCommands` still reported it on.
+  @Test func changedJumpIntervalKeepsCommandEnabled() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [
+      .play, .skipForward(preferredIntervals: [15]), .skipBackward(preferredIntervals: [15]),
+    ])
+    #expect(center.skipForwardCommand.isEnabled)
+
+    controller.enable(commands: [
+      .play, .skipForward(preferredIntervals: [30]), .skipBackward(preferredIntervals: [30]),
+    ])
+
+    #expect(center.skipForwardCommand.isEnabled)
+    #expect(center.skipBackwardCommand.isEnabled)
+    #expect(controller.commandTargetPointers["skipForward"] != nil)
+    #expect(controller.commandTargetPointers["skipBackward"] != nil)
+    #expect(center.skipForwardCommand.preferredIntervals == [30])
+    #expect(center.skipBackwardCommand.preferredIntervals == [30])
+  }
+
+  @Test func changedPlaybackRatesKeepCommandEnabled() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.changePlaybackRate(supportedPlaybackRates: [1.0])])
+    controller.enable(commands: [.changePlaybackRate(supportedPlaybackRates: [1.0, 1.5, 2.0])])
+
+    #expect(center.changePlaybackRateCommand.isEnabled)
+    #expect(controller.commandTargetPointers["changePlaybackRate"] != nil)
+    #expect(center.changePlaybackRateCommand.supportedPlaybackRates == [1.0, 1.5, 2.0])
+  }
+
+  @Test func removedCommandIsDisabledAndUntargeted() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.play, .pause, .next])
+    #expect(center.nextTrackCommand.isEnabled)
+
+    controller.enable(commands: [.play, .pause])
+
+    #expect(!center.nextTrackCommand.isEnabled)
+    #expect(controller.commandTargetPointers["nextTrack"] == nil)
+    #expect(center.playCommand.isEnabled)
+    #expect(controller.commandTargetPointers["play"] != nil)
+  }
+
+  @Test func disableAllClearsEveryTarget() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.play, .pause, .skipForward(preferredIntervals: [15])])
+    controller.disableAll()
+
+    #expect(controller.commandTargetPointers.isEmpty)
+    #expect(!center.playCommand.isEnabled)
+    #expect(!center.pauseCommand.isEnabled)
+    #expect(!center.skipForwardCommand.isEnabled)
+  }
+
+  /// Re-enabling the same set must not accumulate handlers: `enableRemoteCommand`
+  /// removes the previous target before adding the new one.
+  @Test func reEnablingKeepsOneTargetPerCommand() {
+    let (controller, _) = makeController()
+
+    controller.enable(commands: [.play, .pause])
+    let first = controller.commandTargetPointers["play"]
+    controller.enable(commands: [.play, .pause])
+    let second = controller.commandTargetPointers["play"]
+
+    #expect(controller.commandTargetPointers.count == 2)
+    #expect(first as AnyObject? !== second as AnyObject?)
+  }
+
+  /// `setSkipAvailability` greys out next/previous when the queue has nowhere to
+  /// go, and the state must survive a later `enable(commands:)`.
+  @Test func skipAvailabilitySurvivesReEnable() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.next, .previous])
+    controller.setSkipAvailability(canNext: false, canPrevious: true)
+    #expect(!center.nextTrackCommand.isEnabled)
+    #expect(center.previousTrackCommand.isEnabled)
+
+    controller.enable(commands: [.next, .previous, .play])
+
+    #expect(!center.nextTrackCommand.isEnabled)
+    #expect(center.previousTrackCommand.isEnabled)
+  }
+
+  /// The handler properties must not capture the controller strongly. Assigning a
+  /// bare method reference (`= handlePlayCommandDefault`) curries to
+  /// `{ [self] in self.method($0) }`, and storing that back on self is a permanent
+  /// cycle — one leaked controller per player instance, across every JS reload.
+  @Test func doesNotRetainItselfThroughHandlers() {
+    weak var weakController: RemoteCommandController?
+    autoreleasepool {
+      let (controller, _) = makeController()
+      // Forces every lazy handler to initialize, which is what closes the cycle.
+      controller.enable(commands: RemoteCommand.all())
+      controller.disableAll()
+      weakController = controller
+    }
+    #expect(weakController == nil)
+  }
+
+  @Test func shuffleAndRepeatStateSurviveCommandCenterSwitch() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.changeShuffleMode, .changeRepeatMode])
+    controller.updateShuffleMode(true)
+    controller.updateRepeatMode(.queue)
+
+    // Same center — switchCommandCenter no-ops, but the restore path is the
+    // interesting part: state is re-applied from the stored values.
+    controller.switchCommandCenter(center)
+
+    #expect(center.changeShuffleModeCommand.currentShuffleType == .items)
+    #expect(center.changeRepeatModeCommand.currentRepeatType == .all)
+    #expect(center.changeShuffleModeCommand.isEnabled)
+    #expect(controller.commandTargetPointers["changeShuffleMode"] != nil)
+  }
+}

package/ios/Tests/RemoteCommandTests.swift

@@ -0,0 +1,67 @@
+import Foundation
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("RemoteCommand")
+struct RemoteCommandTests {
+  @Test func removedCommandsAreDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.play, .pause, .next, .previous],
+      replacedBy: [.play, .pause],
+    )
+    #expect(toDisable.map(\.key) == ["nextTrack", "previousTrack"])
+  }
+
+  @Test func retainedCommandsAreNotDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.play, .pause],
+      replacedBy: [.play, .pause, .stop],
+    )
+    #expect(toDisable.isEmpty)
+  }
+
+  /// A changed jump interval is the same command with a new associated value —
+  /// diffing by `==` would report it as removed and disable the button that the
+  /// update had just re-enabled.
+  @Test func changedJumpIntervalIsNotDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.skipForward(preferredIntervals: [15]), .skipBackward(preferredIntervals: [15])],
+      replacedBy: [.skipForward(preferredIntervals: [30]), .skipBackward(preferredIntervals: [30])],
+    )
+    #expect(toDisable.isEmpty)
+  }
+
+  @Test func changedPlaybackRatesAreNotDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.changePlaybackRate(supportedPlaybackRates: [1.0])],
+      replacedBy: [.changePlaybackRate(supportedPlaybackRates: [1.0, 1.5, 2.0])],
+    )
+    #expect(toDisable.isEmpty)
+  }
+
+  @Test func everyCommandIsDisabledWhenNoneRemain() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: RemoteCommand.all(),
+      replacedBy: [],
+    )
+    #expect(toDisable.count == RemoteCommand.all().count)
+  }
+
+  /// `key` is the identity used both for the diff above and for the
+  /// `commandTargetPointers` slot each command's handler lives in. Two cases
+  /// sharing a key would silently share one slot: enabling one would remove the
+  /// other's handler.
+  @Test func keysAreUnique() {
+    let all = RemoteCommand.all()
+    #expect(Set(all.map(\.key)).count == all.count)
+  }
+
+  @Test func droppedJumpCommandIsStillDisabled() {
+    let toDisable = RemoteCommand.commandsToDisable(
+      enabled: [.play, .skipForward(preferredIntervals: [15])],
+      replacedBy: [.play],
+    )
+    #expect(toDisable.map(\.key) == ["skipForward"])
+  }
+}