react-native-audio-browser 0.2.0-next.3 → 0.2.0-next.31

package/ios/Player/ShuffleOrder.swift

@@ -39,6 +39,16 @@ struct ShuffleOrder {
     indexInShuffled = Self.buildIndexInShuffled(from: shuffled)
   }
 
+  /// Creates a shuffle order for the given length with `firstIndex` pinned to shuffle position 0.
+  ///
+  /// Playback starts on that track, so leaving it wherever the permutation put it would end the
+  /// queue as soon as it is reached — on average after half the queue, and immediately whenever it
+  /// lands last.
+  init(length: Int, firstIndex: Int) {
+    self.init(length: length)
+    reshuffle(keepingFirst: firstIndex)
+  }
+
   /// Creates a shuffle order with pre-defined indices
   init(shuffledIndices: [Int]) {
     shuffled = shuffledIndices
@@ -91,6 +101,13 @@ struct ShuffleOrder {
     return indexInShuffled[index] == 0
   }
 
+  /// The item's position in the shuffle order, or nil when it has none.
+  func shufflePosition(of index: Int) -> Int? {
+    guard index >= 0, index < indexInShuffled.count else { return nil }
+    let position = indexInShuffled[index]
+    return position >= 0 ? position : nil
+  }
+
   // MARK: - Mutation
 
   /// Inserts items at random positions in the shuffle order
@@ -115,6 +132,22 @@ struct ShuffleOrder {
     indexInShuffled = Self.buildIndexInShuffled(from: shuffled)
   }
 
+  /// Inserts one item at `insertionIndex`, placing it at an explicit shuffle
+  /// position rather than a random one.
+  ///
+  /// Used by a queue `move`, which permutes positions but not identities: the
+  /// item already had a place in the playback order, and re-randomising it
+  /// silently reorders playback. For the *playing* track it can drop it at the
+  /// end of the order, which then reads as `isLastInPlaybackOrder` — the queue
+  /// reports itself over at the next track end, with tracks still unplayed.
+  mutating func insert(at insertionIndex: Int, atShufflePosition position: Int) {
+    for i in 0 ..< shuffled.count where shuffled[i] >= insertionIndex {
+      shuffled[i] += 1
+    }
+    shuffled.insert(insertionIndex, at: min(max(0, position), shuffled.count))
+    indexInShuffled = Self.buildIndexInShuffled(from: shuffled)
+  }
+
   /// Removes items in the specified range from the shuffle order
   mutating func remove(from indexFrom: Int, to indexToExclusive: Int) {
     let removeCount = indexToExclusive - indexFrom

package/ios/Player/SleepTimerManager.swift

@@ -40,7 +40,7 @@ struct MainQueueSleepTimerScheduler: SleepTimerScheduling {
 /// Manages sleep timer functionality for the audio player.
 /// Supports both time-based timers and end-of-track timers.
 @MainActor
-class SleepTimerManager: SleepTimerHandling {
+final class SleepTimerManager {
   // MARK: - Properties
 
   private let scheduler: any SleepTimerScheduling

package/ios/RemoteCommand/RemoteCommandCallbacks.swift

@@ -0,0 +1,46 @@
+#if canImport(NitroModules)
+  import NitroModules
+#endif
+
+/// The callbacks `RemoteCommandController` invokes when the system delivers a
+/// remote command (lock screen, Control Center, CarPlay, headset).
+///
+/// Its own protocol so the controller depends only on what it calls.
+/// `AVPlayerEngineCallbacks` extends it, so conformers implement both at once.
+@MainActor protocol RemoteCommandCallbacks: AnyObject {
+  /// 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)
+
+  /// 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)
+}

package/ios/RemoteCommand/RemoteCommandController.swift

@@ -2,8 +2,6 @@ import Foundation
 import MediaPlayer
 import os.log
 
-typealias RemoteCommandHandler = @MainActor (MPRemoteCommandEvent) -> MPRemoteCommandHandlerStatus
-
 extension RepeatMode {
   /// Convert to MPRepeatType for MPRemoteCommandCenter sync
   var mpRepeatType: MPRepeatType {
@@ -32,391 +30,149 @@ extension Bool {
   }
 }
 
-/**
- Manages MPRemoteCommandCenter integration for media control (lock screen, control center, CarPlay, etc.).
-
- This controller enables/disables remote commands and routes them to handlers. It provides default handlers
- that invoke TrackPlayerCallbacks, but allows customization by setting the lazy handler properties.
-
- Note: This class is @MainActor because it's owned by TrackPlayer (which is @MainActor) and
- MPRemoteCommandCenter handlers are always called on the main thread.
- */
+/// Enables the remote commands (lock screen, Control Center, CarPlay, headset) and routes
+/// each event to `RemoteCommandCallbacks`.
 @MainActor
-class RemoteCommandController {
+final class RemoteCommandController {
   private let logger = Logger(subsystem: "com.audiobrowser", category: "RemoteCommandController")
   private var center: MPRemoteCommandCenter
 
-  weak var callbacks: TrackPlayerCallbacks?
+  weak var callbacks: RemoteCommandCallbacks?
 
-  var commandTargetPointers: [String: Any] = [:]
   private var enabledCommands: [RemoteCommand] = []
 
-  /// Whether there's a next/previous track to skip to. Stored so it survives
-  /// command (re)enable and iOS-16 command-center switches; the next/previous
-  /// commands are enabled in this state rather than unconditionally.
-  private var canNext = true
-  private var canPrevious = true
+  /// Whether the queue has a next / previous track; read whenever those commands are enabled.
+  var skipAvailability: @MainActor () -> (canNext: Bool, canPrevious: Bool) = { (true, true) }
 
-  /// Shuffle/repeat display state, stored so it survives a command-center switch
-  /// (iOS-16 MPNowPlayingSession re-creation). A new center defaults these to
-  /// off; without re-applying, the CarPlay/lock-screen shuffle & repeat buttons
-  /// flash off on every switch.
+  /// The shuffle/repeat display state, kept so it survives a switch to a new command center,
+  /// which starts with both off.
   private var shuffleEnabled = false
   private var repeatMode: RepeatMode = .off
 
-  /**
-   Create a new RemoteCommandController.
-
-   - parameter remoteCommandCenter: The MPRemoteCommandCenter used. Default is `MPRemoteCommandCenter.shared()`
-   - parameter callbacks: The callbacks to invoke for remote command events
-   */
   init(
     remoteCommandCenter: MPRemoteCommandCenter = MPRemoteCommandCenter.shared(),
-    callbacks: TrackPlayerCallbacks? = nil,
+    callbacks: RemoteCommandCallbacks? = nil,
   ) {
     center = remoteCommandCenter
     self.callbacks = callbacks
   }
 
-  /**
-   Switches to a new remote command center.
-   This is used when MPNowPlayingSession is created/destroyed on iOS 16+,
-   as the session has its own command center that must be used instead of the shared one.
-
-   - parameter newCenter: The new MPRemoteCommandCenter to use
-   */
+  /// Moves the enabled commands and their state to `newCenter`: the linked
+  /// `MPNowPlayingSession` has its own command center, which replaces the shared one.
   func switchCommandCenter(_ newCenter: MPRemoteCommandCenter) {
-    guard newCenter !== center else {
-      logger.debug("switchCommandCenter: same command center, skipping")
-      return
-    }
-
-    logger.info("Switching remote command center")
-
-    // Disable all commands on the old center
-    let commandsToReEnable = enabledCommands
-    disable(commands: commandsToReEnable)
-
-    // Switch to new center
+    guard newCenter !== center else { return }
+    let commands = enabledCommands
+    disableAll()
     center = newCenter
-
-    // Re-enable commands on the new center
-    enable(commands: commandsToReEnable)
-
-    // Restore shuffle/repeat display state — the new center defaults them to off,
-    // so without this the shuffle & repeat buttons flash off on every switch.
+    enable(commands: commands)
     center.changeShuffleModeCommand.currentShuffleType = shuffleEnabled.mpShuffleType
     center.changeRepeatModeCommand.currentRepeatType = repeatMode.mpRepeatType
-
-    logger.info("Switched command center, re-enabled \(commandsToReEnable.count) commands")
+    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]) {
-    let commandsToDisable = enabledCommands.filter { command in
-      !commands.contains(command)
-    }
-
+    RemoteCommand.commandsToDisable(enabled: enabledCommands, replacedBy: commands).forEach(disable)
     enabledCommands = commands
-    commands.forEach { self.enable(command: $0) }
-    disable(commands: commandsToDisable)
-  }
-
-  func disable(commands: [RemoteCommand]) {
-    commands.forEach { self.disable(command: $0) }
+    commands.forEach(enable)
   }
 
-  /// Disables all currently enabled remote commands and removes their targets.
   func disableAll() {
-    disable(commands: enabledCommands)
-    enabledCommands.removeAll()
-  }
-
-  /**
-   Enables a remote command by setting it up with the provided handler.
-   Removes any existing target before adding the new one to prevent duplicate handlers.
-   */
-  private func enableRemoteCommand(
-    _ command: MPRemoteCommand,
-    key: String,
-    handler: @escaping RemoteCommandHandler,
-  ) {
-    command.isEnabled = true
-    command.removeTarget(commandTargetPointers[key])
-    commandTargetPointers[key] = command.addTarget(handler: handler)
-  }
-
-  /**
-   Disables a remote command and cleans up its target from the command center.
-   */
-  private func disableRemoteCommand(_ command: MPRemoteCommand, key: String) {
-    command.isEnabled = false
-    command.removeTarget(commandTargetPointers[key])
-    commandTargetPointers.removeValue(forKey: key)
-  }
-
-  private func enable(command: RemoteCommand) {
-    switch command {
-    case .play:
-      enableRemoteCommand(center.playCommand, key: command.key, handler: handlePlayCommand)
-    case .pause:
-      enableRemoteCommand(center.pauseCommand, key: command.key, handler: handlePauseCommand)
-    case .stop:
-      enableRemoteCommand(center.stopCommand, key: command.key, handler: handleStopCommand)
-    case .togglePlayPause:
-      enableRemoteCommand(
-        center.togglePlayPauseCommand,
-        key: command.key,
-        handler: handleTogglePlayPauseCommand,
-      )
-    case .next:
-      enableRemoteCommand(
-        center.nextTrackCommand,
-        key: command.key,
-        handler: handleNextTrackCommand,
-      )
-      center.nextTrackCommand.isEnabled = canNext
-    case .previous:
-      enableRemoteCommand(
-        center.previousTrackCommand,
-        key: command.key,
-        handler: handlePreviousTrackCommand,
-      )
-      center.previousTrackCommand.isEnabled = canPrevious
-    case .changePlaybackPosition:
-      enableRemoteCommand(
-        center.changePlaybackPositionCommand,
-        key: command.key,
-        handler: handleChangePlaybackPositionCommand,
-      )
-    case let .skipForward(preferredIntervals):
-      center.skipForwardCommand.preferredIntervals = preferredIntervals
-      enableRemoteCommand(
-        center.skipForwardCommand,
-        key: command.key,
-        handler: handleSkipForwardCommand,
-      )
-    case let .skipBackward(preferredIntervals):
-      center.skipBackwardCommand.preferredIntervals = preferredIntervals
-      enableRemoteCommand(
-        center.skipBackwardCommand,
-        key: command.key,
-        handler: handleSkipBackwardCommand,
-      )
-    case .changeRepeatMode:
-      enableRemoteCommand(
-        center.changeRepeatModeCommand,
-        key: command.key,
-        handler: handleChangeRepeatModeCommand,
-      )
-    case .changeShuffleMode:
-      enableRemoteCommand(
-        center.changeShuffleModeCommand,
-        key: command.key,
-        handler: handleChangeShuffleModeCommand,
-      )
-    case let .changePlaybackRate(supportedPlaybackRates):
-      center.changePlaybackRateCommand.supportedPlaybackRates = supportedPlaybackRates
-      enableRemoteCommand(
-        center.changePlaybackRateCommand,
-        key: command.key,
-        handler: handleChangePlaybackRateCommand,
-      )
-    }
-  }
-
-  private func disable(command: RemoteCommand) {
-    switch command {
-    case .play:
-      disableRemoteCommand(center.playCommand, key: command.key)
-    case .pause:
-      disableRemoteCommand(center.pauseCommand, key: command.key)
-    case .stop:
-      disableRemoteCommand(center.stopCommand, key: command.key)
-    case .togglePlayPause:
-      disableRemoteCommand(center.togglePlayPauseCommand, key: command.key)
-    case .next:
-      disableRemoteCommand(center.nextTrackCommand, key: command.key)
-    case .previous:
-      disableRemoteCommand(center.previousTrackCommand, key: command.key)
-    case .changePlaybackPosition:
-      disableRemoteCommand(center.changePlaybackPositionCommand, key: command.key)
-    case .skipForward:
-      disableRemoteCommand(center.skipForwardCommand, key: command.key)
-    case .skipBackward:
-      disableRemoteCommand(center.skipBackwardCommand, key: command.key)
-    case .changeRepeatMode:
-      disableRemoteCommand(center.changeRepeatModeCommand, key: command.key)
-    case .changeShuffleMode:
-      disableRemoteCommand(center.changeShuffleModeCommand, key: command.key)
-    case .changePlaybackRate:
-      disableRemoteCommand(center.changePlaybackRateCommand, key: command.key)
-    }
+    enabledCommands.forEach(disable)
+    enabledCommands = []
   }
 
-  // MARK: - Repeat/Shuffle State Sync
-
-  /// Updates the repeat mode state shown on CarPlay and lock screen
   func updateRepeatMode(_ mode: RepeatMode) {
     repeatMode = mode
     center.changeRepeatModeCommand.currentRepeatType = mode.mpRepeatType
   }
 
-  /// Updates the shuffle mode state shown on CarPlay and lock screen
   func updateShuffleMode(_ enabled: Bool) {
     shuffleEnabled = enabled
     center.changeShuffleModeCommand.currentShuffleType = enabled.mpShuffleType
   }
 
-  /// Greys out next/previous (lock screen / Control Center / CarPlay) when the
-  /// queue has nowhere to skip. Applied live when those commands are configured.
-  func setSkipAvailability(canNext: Bool, canPrevious: Bool) {
-    self.canNext = canNext
-    self.canPrevious = canPrevious
+  /// Greys out next/previous when `skipAvailability` says the queue has nowhere to skip.
+  func refreshSkipAvailability() {
+    let (canNext, canPrevious) = skipAvailability()
     if enabledCommands.contains(.next) { center.nextTrackCommand.isEnabled = canNext }
     if enabledCommands.contains(.previous) { center.previousTrackCommand.isEnabled = canPrevious }
   }
 
-  // MARK: - Handlers
-
-  lazy var handlePlayCommand: RemoteCommandHandler = handlePlayCommandDefault
-  lazy var handlePauseCommand: RemoteCommandHandler = handlePauseCommandDefault
-  lazy var handleStopCommand: RemoteCommandHandler = handleStopCommandDefault
-  lazy var handleTogglePlayPauseCommand: RemoteCommandHandler =
-    handleTogglePlayPauseCommandDefault
-  lazy var handleSkipForwardCommand: RemoteCommandHandler = handleSkipForwardCommandDefault
-  lazy var handleSkipBackwardCommand: RemoteCommandHandler = handleSkipBackwardDefault
-  lazy var handleChangePlaybackPositionCommand: RemoteCommandHandler =
-    handleChangePlaybackPositionCommandDefault
-  lazy var handleNextTrackCommand: RemoteCommandHandler = handleNextTrackCommandDefault
-  lazy var handlePreviousTrackCommand: RemoteCommandHandler =
-    handlePreviousTrackCommandDefault
-  lazy var handleChangeRepeatModeCommand: RemoteCommandHandler =
-    handleChangeRepeatModeCommandDefault
-  lazy var handleChangeShuffleModeCommand: RemoteCommandHandler =
-    handleChangeShuffleModeCommandDefault
-  lazy var handleChangePlaybackRateCommand: RemoteCommandHandler =
-    handleChangePlaybackRateCommandDefault
-
-  private func handlePlayCommandDefault(event _: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    callbacks?.remotePlay()
-    return MPRemoteCommandHandlerStatus.success
-  }
-
-  private func handlePauseCommandDefault(event _: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    callbacks?.remotePause()
-    return MPRemoteCommandHandlerStatus.success
-  }
+  // MARK: - Private
 
-  private func handleStopCommandDefault(event _: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    callbacks?.remoteStop()
-    return MPRemoteCommandHandlerStatus.success
-  }
-
-  private func handleTogglePlayPauseCommandDefault(event _: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    callbacks?.remotePlayPause()
-    return MPRemoteCommandHandlerStatus.success
-  }
-
-  private func handleSkipForwardCommandDefault(event: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    if let command = event.command as? MPSkipIntervalCommand,
-       let interval = command.preferredIntervals.first
-    {
-      callbacks?.remoteJumpForward(interval: Double(truncating: interval))
-      return MPRemoteCommandHandlerStatus.success
+  private func mpCommand(for command: RemoteCommand) -> MPRemoteCommand {
+    switch command {
+    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
+    case .skipForward: center.skipForwardCommand
+    case .skipBackward: center.skipBackwardCommand
+    case .changeRepeatMode: center.changeRepeatModeCommand
+    case .changeShuffleMode: center.changeShuffleModeCommand
+    case .changePlaybackRate: center.changePlaybackRateCommand
     }
-    return MPRemoteCommandHandlerStatus.commandFailed
   }
 
-  private func handleSkipBackwardDefault(event: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    if let command = event.command as? MPSkipIntervalCommand,
-       let interval = command.preferredIntervals.first
-    {
-      callbacks?.remoteJumpBackward(interval: Double(truncating: interval))
-      return MPRemoteCommandHandlerStatus.success
+  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
+    default: break
     }
-    return MPRemoteCommandHandlerStatus.commandFailed
-  }
-
-  private func handleChangePlaybackPositionCommandDefault(event: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    if let event = event as? MPChangePlaybackPositionCommandEvent {
-      logger.debug("changePlaybackPosition: \(event.positionTime)")
-      callbacks?.remoteSeek(position: event.positionTime)
-      return MPRemoteCommandHandlerStatus.success
+    let mpCommand = mpCommand(for: command)
+    mpCommand.removeTarget(nil)
+    mpCommand.addTarget { [weak self] event in
+      self?.handle(event, for: command) ?? .commandFailed
     }
-    logger.debug("changePlaybackPosition: failed to cast event")
-    return MPRemoteCommandHandlerStatus.commandFailed
-  }
-
-  private func handleNextTrackCommandDefault(event _: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    callbacks?.remoteNext()
-    return MPRemoteCommandHandlerStatus.success
-  }
-
-  private func handlePreviousTrackCommandDefault(event _: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    callbacks?.remotePrevious()
-    return MPRemoteCommandHandlerStatus.success
-  }
-
-  private func handleChangeRepeatModeCommandDefault(event: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    if let event = event as? MPChangeRepeatModeCommandEvent {
-      let mode = RepeatMode(from: event.repeatType)
-      callbacks?.remoteChangeRepeatMode(mode: mode)
-      // Update the command center state to reflect the new mode
-      center.changeRepeatModeCommand.currentRepeatType = event.repeatType
-      return MPRemoteCommandHandlerStatus.success
+    mpCommand.isEnabled = switch command {
+    case .next: skipAvailability().canNext
+    case .previous: skipAvailability().canPrevious
+    default: true
     }
-    return MPRemoteCommandHandlerStatus.commandFailed
   }
 
-  private func handleChangeShuffleModeCommandDefault(event: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    if let event = event as? MPChangeShuffleModeCommandEvent {
-      let enabled = event.shuffleType != .off
-      callbacks?.remoteChangeShuffleMode(enabled: enabled)
-      // Update the command center state to reflect the new mode
-      center.changeShuffleModeCommand.currentShuffleType = event.shuffleType
-      return MPRemoteCommandHandlerStatus.success
-    }
-    return MPRemoteCommandHandlerStatus.commandFailed
+  private func disable(_ command: RemoteCommand) {
+    let mpCommand = mpCommand(for: command)
+    mpCommand.isEnabled = false
+    mpCommand.removeTarget(nil)
   }
 
-  private func handleChangePlaybackRateCommandDefault(event: MPRemoteCommandEvent)
-    -> MPRemoteCommandHandlerStatus
-  {
-    if let event = event as? MPChangePlaybackRateCommandEvent {
-      let rate = Float(event.playbackRate)
-      callbacks?.remoteChangePlaybackRate(rate: rate)
-      return MPRemoteCommandHandlerStatus.success
+  private func handle(_ event: MPRemoteCommandEvent, for command: RemoteCommand) -> MPRemoteCommandHandlerStatus {
+    switch command {
+    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 {
+        callbacks?.remoteJumpForward(interval: interval.doubleValue)
+      } else {
+        callbacks?.remoteJumpBackward(interval: interval.doubleValue)
+      }
+    case .changePlaybackPosition:
+      guard let event = event as? MPChangePlaybackPositionCommandEvent else { return .commandFailed }
+      callbacks?.remoteSeek(position: event.positionTime)
+    case .changeRepeatMode:
+      guard let event = event as? MPChangeRepeatModeCommandEvent else { return .commandFailed }
+      callbacks?.remoteChangeRepeatMode(mode: RepeatMode(from: event.repeatType))
+    case .changeShuffleMode:
+      guard let event = event as? MPChangeShuffleModeCommandEvent else { return .commandFailed }
+      callbacks?.remoteChangeShuffleMode(enabled: event.shuffleType != .off)
+    case .changePlaybackRate:
+      guard let event = event as? MPChangePlaybackRateCommandEvent else { return .commandFailed }
+      callbacks?.remoteChangePlaybackRate(rate: event.playbackRate)
     }
-    return MPRemoteCommandHandlerStatus.commandFailed
-  }
-
-  private func getRemoteCommandHandlerStatus(forError error: Error)
-    -> MPRemoteCommandHandlerStatus
-  {
-    error is TrackPlayerError.QueueError
-      ? MPRemoteCommandHandlerStatus.noSuchContent
-      : MPRemoteCommandHandlerStatus.commandFailed
+    return .success
   }
 }