react-native-audio-browser 0.2.0-next.33 → 0.2.0-next.34

package/ios/Player/RetryLoop.swift

@@ -101,7 +101,11 @@ final class RetryLoop {
   private let sleep: @Sendable (TimeInterval) async throws -> Void
 
   /// - Parameter sleep: Waits out a backoff or a connectivity poll; tests make it instant.
-  init(sleep: @escaping @Sendable (TimeInterval) async throws -> Void = { try await Task.sleep(for: .seconds($0)) }) {
+  init(
+    networkMonitor: (any NetworkStatusProviding)? = nil,
+    sleep: @escaping @Sendable (TimeInterval) async throws -> Void = { try await Task.sleep(for: .seconds($0)) },
+  ) {
+    self.networkMonitor = networkMonitor
     self.sleep = sleep
   }
 

package/ios/RemoteCommand/RemoteCommandCallbacks.swift

@@ -17,9 +17,6 @@
   /// 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()
 

package/ios/RemoteCommand/RemoteCommandController.swift

@@ -39,7 +39,10 @@ final class RemoteCommandController {
 
   weak var callbacks: RemoteCommandCallbacks?
 
-  private var enabledCommands: [RemoteCommand] = []
+  private var enabledCommands: Set<RemoteCommand> = []
+  private var forwardJumpInterval: Double = 15
+  private var backwardJumpInterval: Double = 15
+  private var playbackRates: [Double] = []
 
   /// Whether the queue has a next / previous track; read whenever those commands are enabled.
   var skipAvailability: @MainActor () -> (canNext: Bool, canPrevious: Bool) = { (true, true) }
@@ -62,18 +65,27 @@ final class RemoteCommandController {
   func switchCommandCenter(_ newCenter: MPRemoteCommandCenter) {
     guard newCenter !== center else { return }
     let commands = enabledCommands
-    disableAll()
+    commands.forEach(disable)
     center = newCenter
-    enable(commands: commands)
+    commands.forEach(enable)
     center.changeShuffleModeCommand.currentShuffleType = shuffleEnabled.mpShuffleType
     center.changeRepeatModeCommand.currentRepeatType = repeatMode.mpRepeatType
     logger.info("Switched command center, re-enabled \(commands.count) commands")
   }
 
-  /// Enables exactly `commands`, disabling any enabled command they no longer include.
-  func enable(commands: [RemoteCommand]) {
-    RemoteCommand.commandsToDisable(enabled: enabledCommands, replacedBy: commands).forEach(disable)
+  /// Enables exactly `commands`, disabling any enabled command they no longer include. The skip
+  /// commands offer their interval, the rate command `playbackRates`.
+  func enable(
+    commands: Set<RemoteCommand>,
+    forwardJumpInterval: Double = 15,
+    backwardJumpInterval: Double = 15,
+    playbackRates: [Double] = [],
+  ) {
+    enabledCommands.subtracting(commands).forEach(disable)
     enabledCommands = commands
+    self.forwardJumpInterval = forwardJumpInterval
+    self.backwardJumpInterval = backwardJumpInterval
+    self.playbackRates = playbackRates
     commands.forEach(enable)
   }
 
@@ -106,7 +118,6 @@ final class RemoteCommandController {
     case .play: center.playCommand
     case .pause: center.pauseCommand
     case .stop: center.stopCommand
-    case .togglePlayPause: center.togglePlayPauseCommand
     case .next: center.nextTrackCommand
     case .previous: center.previousTrackCommand
     case .changePlaybackPosition: center.changePlaybackPositionCommand
@@ -120,9 +131,10 @@ final class RemoteCommandController {
 
   private func enable(_ command: RemoteCommand) {
     switch command {
-    case let .skipForward(intervals): center.skipForwardCommand.preferredIntervals = intervals
-    case let .skipBackward(intervals): center.skipBackwardCommand.preferredIntervals = intervals
-    case let .changePlaybackRate(rates): center.changePlaybackRateCommand.supportedPlaybackRates = rates
+    case .skipForward: center.skipForwardCommand.preferredIntervals = [NSNumber(value: forwardJumpInterval)]
+    case .skipBackward: center.skipBackwardCommand.preferredIntervals = [NSNumber(value: backwardJumpInterval)]
+    case .changePlaybackRate:
+      center.changePlaybackRateCommand.supportedPlaybackRates = playbackRates.map { NSNumber(value: $0) }
     default: break
     }
     let mpCommand = mpCommand(for: command)
@@ -148,14 +160,13 @@ final class RemoteCommandController {
     case .play: callbacks?.remotePlay()
     case .pause: callbacks?.remotePause()
     case .stop: callbacks?.remoteStop()
-    case .togglePlayPause: callbacks?.remotePlayPause()
     case .next: callbacks?.remoteNext()
     case .previous: callbacks?.remotePrevious()
     case .skipForward, .skipBackward:
       guard let interval = (event.command as? MPSkipIntervalCommand)?.preferredIntervals.first else {
         return .commandFailed
       }
-      if case .skipForward = command {
+      if command == .skipForward {
         callbacks?.remoteJumpForward(interval: interval.doubleValue)
       } else {
         callbacks?.remoteJumpBackward(interval: interval.doubleValue)

package/ios/Tests/CapabilityRemoteCommandTests.swift

@@ -0,0 +1,35 @@
+import Testing
+
+@testable import AudioBrowserTestable
+
+@Suite("PlayerCapabilities.remoteCommands")
+struct CapabilityRemoteCommandTests {
+  @Test func everyCommandIsEnabledUnlessSetToFalse() {
+    #expect(PlayerCapabilities().remoteCommands == Set(RemoteCommand.allCases))
+  }
+
+  @Test func eachCapabilitySetToFalseDropsExactlyItsCommand() {
+    let pairs: [(WritableKeyPath<PlayerCapabilities, Bool?>, RemoteCommand)] = [
+      (\.play, .play),
+      (\.pause, .pause),
+      (\.stop, .stop),
+      (\.skipToNext, .next),
+      (\.skipToPrevious, .previous),
+      (\.seekTo, .changePlaybackPosition),
+      (\.jumpForward, .skipForward),
+      (\.jumpBackward, .skipBackward),
+      (\.shuffleMode, .changeShuffleMode),
+      (\.repeatMode, .changeRepeatMode),
+      (\.playbackRate, .changePlaybackRate),
+    ]
+    for (capability, command) in pairs {
+      var capabilities = PlayerCapabilities()
+      capabilities[keyPath: capability] = false
+      #expect(capabilities.remoteCommands == Set(RemoteCommand.allCases).subtracting([command]), "\(command)")
+    }
+  }
+
+  @Test func favoriteEnablesNoCommand() {
+    #expect(PlayerCapabilities(favorite: false).remoteCommands == Set(RemoteCommand.allCases))
+  }
+}

package/ios/Tests/EmitterTests.swift

@@ -69,55 +69,12 @@ struct RemoveListenerTests {
 
   @Test func doubleRemoveSameTokenIsSafe() {
     let emitter = Emitter<Int>()
-    let token = emitter.addListener { _ in }
+    var received = [Int]()
+    let token = emitter.addListener { received.append($0) }
     emitter.removeListener(token)
     emitter.removeListener(token)
-    #expect(emitter.listenerCount == 0)
-  }
-}
-
-// MARK: - removeAllListeners
-
-@Suite("removeAllListeners")
-struct RemoveAllListenersTests {
-  @Test func clearsAllAndCountGoesToZero() {
-    let emitter = Emitter<Int>()
-    emitter.addListener { _ in }
-    emitter.addListener { _ in }
-    emitter.addListener { _ in }
-    emitter.removeAllListeners()
-    #expect(emitter.listenerCount == 0)
-  }
-
-  @Test func previouslyAddedListenersStopReceiving() {
-    let emitter = Emitter<Int>()
-    var called = false
-    emitter.addListener { _ in called = true }
-    emitter.removeAllListeners()
     emitter.emit(1)
-    #expect(called == false)
-  }
-}
-
-// MARK: - listenerCount
-
-@Suite("listenerCount")
-struct ListenerCountTests {
-  @Test func reflectsAddsAndRemoves() {
-    let emitter = Emitter<Int>()
-    #expect(emitter.listenerCount == 0)
-
-    let t1 = emitter.addListener { _ in }
-    #expect(emitter.listenerCount == 1)
-
-    let t2 = emitter.addListener { _ in }
-    #expect(emitter.listenerCount == 2)
-
-    emitter.removeListener(t1)
-    #expect(emitter.listenerCount == 1)
-
-    emitter.removeListener(t2)
-    #expect(emitter.listenerCount == 0)
+    #expect(received.isEmpty)
   }
 }
 
@@ -133,7 +90,6 @@ struct SubscribeTests {
     subscription.cancel()
     emitter.emit(2)
     #expect(received == [1])
-    #expect(emitter.listenerCount == 0)
   }
 
   @Test func releasingTheSubscriptionRemovesTheListener() {
@@ -146,6 +102,5 @@ struct SubscribeTests {
     }
     emitter.emit(2)
     #expect(received == [1])
-    #expect(emitter.listenerCount == 0)
   }
 }

package/ios/Tests/PlayerPolicyTests.swift

@@ -177,18 +177,42 @@ struct PlayerRecoveringTests {
     let (player, engine, _) = makePlaying()
     player.transition(.avPlayerWaiting)
     #expect(player.state == .buffering)
-    player.networkDidReturn()
+    player.networkStatusDidChange(isOnline: true)
     #expect(engine.resolveAndLoadCalls.count == 2)
   }
 
   @Test func theNetworkReturningLeavesAPausedOrPlayingStreamAlone() {
     let (player, engine, _) = makePlaying()
-    player.networkDidReturn()
+    player.networkStatusDidChange(isOnline: true)
     player.pause()
-    player.networkDidReturn()
+    player.networkStatusDidChange(isOnline: true)
     #expect(engine.resolveAndLoadCalls.count == 1)
   }
 
+  @Test func theNetworkGoingReRendersTheStallLineWithoutReconnecting() {
+    let (player, engine, _) = makePlaying()
+    player.transition(.avPlayerWaiting)
+    engine.nowPlayingRenderCount = 0
+
+    player.networkStatusDidChange(isOnline: false)
+
+    #expect(engine.nowPlayingRenderCount == 1)
+    #expect(engine.resolveAndLoadCalls.count == 1)
+  }
+
+  @Test func theNetworkReturningReRendersBeforeReconnecting() {
+    let (player, engine, _) = makePlaying()
+    player.transition(.avPlayerWaiting)
+    var order: [String] = []
+    engine.onSeamCall = { order.append($0) }
+    let loadsBefore = engine.resolveAndLoadCalls.count
+
+    player.networkStatusDidChange(isOnline: true)
+
+    #expect(order.first == "renderNowPlaying")
+    #expect(engine.resolveAndLoadCalls.count == loadsBefore + 1)
+  }
+
   /// A restart from a terminal error is a new Load: fresh retry budgets, unproven playback, the
   /// primer allowed again; a retry within a Load keeps its Load.
   @Test func aRestartFromAnErrorBeginsANewLoad() async {

package/ios/Tests/PlayerTests.swift

@@ -681,13 +681,13 @@ struct NaturalEndPlayIntentTests {
 
   @Test @MainActor
   func naturalEnd_requestsSessionRelease() {
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
-    callbacks.releaseSessionCount = 0
+    eh.scheduleAudioSessionReleaseCount = 0
 
     eh.emit(.playedToEnd)
 
-    #expect(callbacks.releaseSessionCount == 1)
+    #expect(eh.scheduleAudioSessionReleaseCount == 1)
   }
 
   /// play() from .ended must reload from the start — startPlayback() alone is a
@@ -1272,48 +1272,126 @@ struct StopCancelsRetryTests {
 struct SessionReleaseTests {
   @Test @MainActor
   func deliberatePause_requestsRelease() {
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
-    callbacks.releaseSessionCount = 0
+    eh.scheduleAudioSessionReleaseCount = 0
     c.pause()
-    #expect(callbacks.releaseSessionCount == 1)
+    #expect(eh.scheduleAudioSessionReleaseCount == 1)
   }
 
   @Test @MainActor
   func play_doesNotRequestRelease() {
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
-    #expect(callbacks.releaseSessionCount == 0)
+    #expect(eh.scheduleAudioSessionReleaseCount == 0)
   }
 
   @Test @MainActor
   func interruptionBegan_doesNotRequestRelease() {
     // A phone call pauses (playWhenReady → false) but is meant to resume, so the session must be
     // held — the exact race the intent-gating design exists to avoid.
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
-    callbacks.releaseSessionCount = 0
+    eh.scheduleAudioSessionReleaseCount = 0
     c.handleInterruptionBegan()
-    #expect(callbacks.releaseSessionCount == 0)
+    #expect(eh.scheduleAudioSessionReleaseCount == 0)
   }
 
   @Test @MainActor
   func interruptionEnded_withResume_doesNotRequestRelease() {
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
     c.handleInterruptionBegan()
-    callbacks.releaseSessionCount = 0
+    eh.scheduleAudioSessionReleaseCount = 0
     c.handleInterruptionEnded(shouldResume: true)
-    #expect(callbacks.releaseSessionCount == 0)
+    #expect(eh.scheduleAudioSessionReleaseCount == 0)
   }
 
   @Test @MainActor
   func interruptionEnded_withoutResume_requestsRelease() {
-    let (c, eh, callbacks, _) = makeCoordinator()
+    let (c, eh, _, _) = makeCoordinator()
     startPlaying(c, eh)
     c.handleInterruptionBegan()
-    callbacks.releaseSessionCount = 0
+    eh.scheduleAudioSessionReleaseCount = 0
     c.handleInterruptionEnded(shouldResume: false)
-    #expect(callbacks.releaseSessionCount == 1)
+    #expect(eh.scheduleAudioSessionReleaseCount == 1)
+  }
+}
+
+// MARK: - Media-stack effects of a publish
+
+/// The audio-session and now-playing effects the Player drives through its engine, in their
+/// order relative to the callbacks JS hears.
+@Suite("Player - media-stack effects")
+struct MediaStackEffectTests {
+  @MainActor
+  private func makeTraced() -> (Player, MockPlayerEngine, MockPlayerCallbacks) {
+    let (c, eh, cb, _) = makeCoordinator()
+    eh.onSeamCall = { [weak cb] in cb?.publishOrder.append($0) }
+    return (c, eh, cb)
+  }
+
+  @Test @MainActor
+  func playIntent_cancelsTheReleaseBeforeJSHearsIt_thenActivatesOnOutput() {
+    let (c, _, cb) = makeTraced()
+    loadTrack(c)
+    cb.publishOrder.removeAll()
+
+    c.setPlayWhenReady(true)
+
+    #expect(cb.publishOrder == [
+      "cancelAudioSessionRelease", "playWhenReady",
+      "playingState", "activateAudioSession", "renderNowPlaying",
+    ])
+  }
+
+  @Test @MainActor
+  func pause_rendersWithoutActivating_thenSchedulesTheRelease() {
+    let (c, eh, cb) = makeTraced()
+    startPlaying(c, eh)
+    cb.publishOrder.removeAll()
+
+    c.pause()
+
+    #expect(cb.publishOrder == [
+      "playWhenReady", "playingState", "renderNowPlaying", "scheduleAudioSessionRelease",
+    ])
+  }
+
+  @Test @MainActor
+  func playbackChange_rendersAfterJSHearsIt() {
+    let (c, _, cb) = makeTraced()
+    loadTrack(c)
+    cb.publishOrder.removeAll()
+
+    c.transition(.errorOccurred(.playbackFailed))
+
+    #expect(cb.publishOrder == ["playback", "renderNowPlaying"])
+  }
+
+  @Test @MainActor
+  func activeTrackChange_resetsTheNowPlayingLinesAfterJSHearsIt() {
+    let (c, eh, cb, _) = makeCoordinator()
+    eh.onSeamCall = { [weak cb] call in
+      if call == "nowPlayingTrackChanged" { cb?.queueAndTrackOrder.append(call) }
+    }
+
+    c.setQueue([Track(id: "t1", src: "https://example.com/a.mp3", title: "A")])
+
+    #expect(cb.queueAndTrackOrder == ["queue", "activeTrack", "nowPlayingTrackChanged"])
+    #expect(eh.nowPlayingTrackChangedCount == 1)
+  }
+
+  @Test @MainActor
+  func timedMetadata_reachesJSThenTheNowPlayingLines() {
+    let (c, eh, cb) = makeTraced()
+    let metadata = TimedMetadata(title: "Song", artist: "Artist")
+
+    eh.emit(.timedMetadata(metadata))
+    withExtendedLifetime(c) {}
+
+    #expect(cb.publishOrder == ["timedMetadata", "applyTimedMetadata"])
+    #expect(cb.timedMetadata == [metadata])
+    #expect(eh.appliedTimedMetadata == [metadata])
   }
 }

package/ios/Tests/RemoteCommandControllerTests.swift

@@ -18,7 +18,6 @@ struct RemoteCommandControllerTests {
     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)") }
@@ -34,28 +33,23 @@ struct RemoteCommandControllerTests {
   private func makeController() -> (RemoteCommandController, SpyCallbacks) {
     let center = MPRemoteCommandCenter.shared()
     let reset = RemoteCommandController(remoteCommandCenter: center)
-    reset.enable(commands: RemoteCommand.all())
+    reset.enable(commands: Set(RemoteCommand.allCases))
     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]),
-    ])
+    controller.enable(commands: [.play, .skipForward, .skipBackward])
     #expect(center.skipForwardCommand.isEnabled)
 
-    controller.enable(commands: [
-      .play, .skipForward(preferredIntervals: [30]), .skipBackward(preferredIntervals: [30]),
-    ])
+    controller.enable(
+      commands: [.play, .skipForward, .skipBackward], forwardJumpInterval: 30, backwardJumpInterval: 30,
+    )
 
     #expect(center.skipForwardCommand.isEnabled)
     #expect(center.skipBackwardCommand.isEnabled)
@@ -67,8 +61,8 @@ struct RemoteCommandControllerTests {
     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])])
+    controller.enable(commands: [.changePlaybackRate], playbackRates: [1.0])
+    controller.enable(commands: [.changePlaybackRate], playbackRates: [1.0, 1.5, 2.0])
 
     #expect(center.changePlaybackRateCommand.isEnabled)
     #expect(center.changePlaybackRateCommand.supportedPlaybackRates == [1.0, 1.5, 2.0])
@@ -87,11 +81,46 @@ struct RemoteCommandControllerTests {
     #expect(center.playCommand.isEnabled)
   }
 
+  @Test func retainedCommandStaysEnabledWhenOthersAreAdded() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.play, .pause])
+    controller.enable(commands: [.play, .pause, .stop])
+
+    #expect(center.playCommand.isEnabled)
+    #expect(center.pauseCommand.isEnabled)
+    #expect(center.stopCommand.isEnabled)
+  }
+
+  @Test func droppedJumpCommandIsDisabled() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: [.play, .skipForward])
+    controller.enable(commands: [.play])
+
+    #expect(!center.skipForwardCommand.isEnabled)
+    #expect(center.playCommand.isEnabled)
+  }
+
+  @Test func enablingNoCommandsDisablesEveryOne() {
+    let (controller, _) = makeController()
+    let center = MPRemoteCommandCenter.shared()
+
+    controller.enable(commands: Set(RemoteCommand.allCases))
+    controller.enable(commands: [])
+
+    #expect(!center.playCommand.isEnabled)
+    #expect(!center.skipBackwardCommand.isEnabled)
+    #expect(!center.changePlaybackRateCommand.isEnabled)
+  }
+
   @Test func disableAllClearsEveryTarget() {
     let (controller, _) = makeController()
     let center = MPRemoteCommandCenter.shared()
 
-    controller.enable(commands: [.play, .pause, .skipForward(preferredIntervals: [15])])
+    controller.enable(commands: [.play, .pause, .skipForward])
     controller.disableAll()
 
     #expect(!center.playCommand.isEnabled)
@@ -126,7 +155,7 @@ struct RemoteCommandControllerTests {
     weak var weakController: RemoteCommandController?
     autoreleasepool {
       let (controller, _) = makeController()
-      controller.enable(commands: RemoteCommand.all())
+      controller.enable(commands: Set(RemoteCommand.allCases))
       controller.disableAll()
       weakController = controller
     }

package/ios/Tests/Support/TestTypes.swift

@@ -109,6 +109,46 @@ final class MockPlayerEngine: PlayerEngine {
   func updateSkipAvailability(canNext: Bool, canPrevious: Bool) {
     updateSkipAvailabilityCalls.append((canNext, canPrevious))
   }
+
+  // Now-playing lines and the audio session, in the order the Player drove them
+  var nowPlayingRenderCount = 0
+  var nowPlayingTrackChangedCount = 0
+  var appliedTimedMetadata: [TimedMetadata] = []
+  var activateAudioSessionCount = 0
+  var cancelAudioSessionReleaseCount = 0
+  var scheduleAudioSessionReleaseCount = 0
+  /// Called with the name of each of these calls, so a test can interleave them with callbacks.
+  var onSeamCall: ((String) -> Void)?
+
+  func renderNowPlaying() {
+    nowPlayingRenderCount += 1
+    onSeamCall?("renderNowPlaying")
+  }
+
+  func nowPlayingTrackChanged() {
+    nowPlayingTrackChangedCount += 1
+    onSeamCall?("nowPlayingTrackChanged")
+  }
+
+  func applyTimedMetadata(_ metadata: TimedMetadata) {
+    appliedTimedMetadata.append(metadata)
+    onSeamCall?("applyTimedMetadata")
+  }
+
+  func activateAudioSession() {
+    activateAudioSessionCount += 1
+    onSeamCall?("activateAudioSession")
+  }
+
+  func cancelAudioSessionRelease() {
+    cancelAudioSessionReleaseCount += 1
+    onSeamCall?("cancelAudioSessionRelease")
+  }
+
+  func scheduleAudioSessionRelease() {
+    scheduleAudioSessionReleaseCount += 1
+    onSeamCall?("scheduleAudioSessionRelease")
+  }
 }
 
 /// A Player over `engine` whose retries reload while `retries` and otherwise give up, keeping
@@ -146,7 +186,7 @@ final class MockPlayerCallbacks: PlayerCallbacks {
   var shuffleEnabledChanges: [Bool] = []
   var errorEvents: [PlaybackErrorEvent] = []
   var playbackIntervalFiredCount = 0
-  var releaseSessionCount = 0
+  var timedMetadata: [TimedMetadata] = []
 
   /// The order playback, intent and playing-state changes arrived in.
   var publishOrder: [String] = []
@@ -200,8 +240,9 @@ final class MockPlayerCallbacks: PlayerCallbacks {
     errorEvents.append(event)
   }
 
-  func playerShouldReleaseSession() {
-    releaseSessionCount += 1
+  func playerDidReceiveTimedMetadata(_ metadata: TimedMetadata) {
+    publishOrder.append("timedMetadata")
+    timedMetadata.append(metadata)
   }
 
   var sleepTimerChanges: [SleepTimerState?] = []