react-native-audio-browser 0.1.1 → 0.2.0-next.10

package/ios/Player/RetryManager.swift

@@ -1,10 +1,27 @@
+import AVFoundation
 import Foundation
-import NitroModules
+#if canImport(NitroModules)
+  import NitroModules
+#endif
 import os.log
 
+/// Abstracts `NetworkMonitor` so tests can fake connectivity. Sendable because
+/// the network-restore race reads it from a task-group child.
+protocol NetworkStatusProviding: AnyObject, Sendable {
+  var isOnline: Bool { get }
+}
+
 /// Manages retry logic for media load errors with exponential backoff.
 /// Similar to Android's RetryLoadErrorHandlingPolicy.
 ///
+/// Two duration budgets apply, chosen by whether the current load has ever
+/// produced audio (`hasPlayed`): a short first-connect budget — a stream that
+/// fails before ever playing is usually dead, and the listener is actively
+/// waiting for a verdict — and the full recovery budget for a stream that
+/// played and then dropped (tunnels, handovers, encoder restarts). The short
+/// budget counts only online time, so a station tapped in a tunnel still gets
+/// its online seconds once connectivity returns.
+///
 /// When a network monitor is provided and the device is offline, the retry will
 /// trigger immediately when connectivity is restored instead of waiting for the
 /// full backoff delay.
@@ -19,28 +36,53 @@ class RetryManager {
   }
 
   private static let defaultMaxRetryDurationMs: Double = 120_000 // 2 minutes
+  private static let defaultFirstConnectMaxRetryDurationMs: Double = 12_000
 
   /// Prevents surprising playback resumption after long periods offline.
   private var maxRetryDuration: TimeInterval = defaultMaxRetryDurationMs / 1000
 
+  /// Bounds retries of a load that has never produced audio, while online.
+  private var firstConnectMaxRetryDuration: TimeInterval = defaultFirstConnectMaxRetryDurationMs / 1000
+
+  /// True once the current load has produced audio; selects between the
+  /// first-connect and recovery budgets. Set by the owner when audio starts and
+  /// cleared by the owner when a new track loads — deliberately NOT cleared in
+  /// `reset()`, which the healthy-playback budget refill also calls mid-play.
+  var hasPlayed = false
+
+  /// First failure observed while online for the current load — the
+  /// first-connect budget's clock. Never set while offline, and wiped by any
+  /// offline observation, so an offline stretch cannot burn the short budget:
+  /// the clock restarts at the next failure observed online.
+  private var firstOnlineRetryTime: Date?
+
   private var policy: Policy = .disabled
   private var attemptCount = 0
   private var firstRetryTime: Date?
 
-  weak var networkMonitor: NetworkMonitor?
-  private var isWaitingForNetwork = false
+  weak var networkMonitor: (any NetworkStatusProviding)?
+  /// True only while a scheduled retry is parked polling for connectivity to return. Exposed so the
+  /// player's stall-driven reconnect can defer to an in-flight error retry (which owns its own
+  /// reload) and avoid a double load.
+  private(set) var isWaitingForNetwork = false
   /// Invalidates in-flight retries when reset() is called (e.g. track change)
   private var generation: Int = 0
 
   var shouldRetry: () -> Bool = { true }
   var onRetry: ((Bool) -> Void)?
 
+  var isEnabled: Bool {
+    if case .disabled = policy { return false }
+    return true
+  }
+
   // MARK: - Configuration
 
   func updatePolicy(from config: Variant_Bool_RetryConfig?) {
     guard let config else {
       policy = .disabled
       maxRetryDuration = Self.defaultMaxRetryDurationMs / 1000
+      firstConnectMaxRetryDuration = Self.defaultFirstConnectMaxRetryDurationMs / 1000
       logger.debug("Retry policy: disabled")
       return
     }
@@ -49,13 +91,22 @@ class RetryManager {
     case let .first(enabled):
       policy = enabled ? .infinite : .disabled
       maxRetryDuration = Self.defaultMaxRetryDurationMs / 1000
+      firstConnectMaxRetryDuration = Self.defaultFirstConnectMaxRetryDurationMs / 1000
       logger.debug("Retry policy: \(enabled ? "infinite" : "disabled")")
     case let .second(retryConfig):
-      let maxRetries = Int(retryConfig.maxRetries)
-      policy = .limited(maxRetries: maxRetries)
       let durationMs = retryConfig.maxRetryDurationMs ?? Self.defaultMaxRetryDurationMs
       maxRetryDuration = durationMs / 1000
-      logger.debug("Retry policy: limited to \(maxRetries) retries, max duration \(self.maxRetryDuration)s")
+      let firstConnectMs = retryConfig.firstConnectMaxRetryDurationMs
+        ?? Self.defaultFirstConnectMaxRetryDurationMs
+      firstConnectMaxRetryDuration = firstConnectMs / 1000
+      // No attempt cap = retry indefinitely, bounded only by the duration.
+      if let maxRetries = retryConfig.maxRetries.map(Int.init) {
+        policy = .limited(maxRetries: maxRetries)
+        logger.debug("Retry policy: limited to \(maxRetries) retries, max duration \(self.maxRetryDuration)s")
+      } else {
+        policy = .infinite
+        logger.debug("Retry policy: infinite, max duration \(self.maxRetryDuration)s")
+      }
     }
   }
 
@@ -72,30 +123,89 @@ class RetryManager {
 
   // MARK: - Error Classification
 
-  func isRetryable(_ error: Error?) -> Bool {
+  /// HTTP statuses worth another attempt. Same set as Android's
+  /// `RetryLoadErrorHandlingPolicy.RETRYABLE_HTTP_STATUS_CODES`, so a flaky
+  /// server behaves the same on both platforms.
+  private static let retryableHTTPStatusCodes: Set<Int> = [408, 429]
+
+  /// AVFoundation failures a retry cannot fix: the media is unusable rather
+  /// than the transport unreliable. Everything not listed falls through to
+  /// retry — `AVErrorUnknown` especially, which is the wrapper AVFoundation
+  /// puts around opaque CoreMedia transport failures.
+  private static let fatalAVErrorCodes: Set<Int> = [
+    AVError.fileFormatNotRecognized.rawValue,
+    AVError.failedToParse.rawValue,
+    AVError.decodeFailed.rawValue,
+    AVError.contentIsProtected.rawValue,
+    AVError.contentIsNotAuthorized.rawValue,
+  ]
+
+  /// Whether another attempt could plausibly succeed.
+  ///
+  /// Mirrors Android's `classifyError`, including its default: an unrecognized
+  /// failure is treated as *transient* and retried, bounded by the retry
+  /// budgets, rather than being terminal. Defaulting the other way made
+  /// `retry: true` largely inert on iOS, because AVFoundation reports most
+  /// stream failures as opaque `CoreMediaErrorDomain` / `AVFoundationErrorDomain`
+  /// errors rather than `URLError`.
+  ///
+  /// - Parameter httpStatusCode: The status from the item's error log, when the
+  ///   caller has one. `AVPlayerItem.error` never carries it — a 404 arrives as
+  ///   an opaque CoreMedia error — so this is the only reliable HTTP signal and
+  ///   it outranks the error itself.
+  func isRetryable(_ error: Error?, httpStatusCode: Int?) -> Bool {
+    if let status = httpStatusCode {
+      let retryable = Self.retryableHTTPStatusCodes.contains(status) || (500 ... 599).contains(status)
+      logger.debug("HTTP \(status) \(retryable ? "is" : "not") retryable")
+      return retryable
+    }
+
     guard let error else { return false }
 
-    if let urlError = error as? URLError {
-      switch urlError.code {
-      // Transient network errors - safe to retry
-      case .timedOut,
-           .networkConnectionLost,
-           .notConnectedToInternet,
-           .cannotConnectToHost,
-           .cannotFindHost,
-           .dnsLookupFailed:
-        logger.debug("URLError is retryable: code=\(urlError.code.rawValue)")
-        return true
-      default:
-        logger.debug("URLError not retryable: code=\(urlError.code.rawValue)")
+    // Walk the underlying-error chain: AVFoundation routinely wraps the real
+    // cause (a URLError, or a CoreMedia code) in an AVError.
+    for candidate in Self.errorChain(error) {
+      if let urlError = candidate as? URLError {
+        switch urlError.code {
+        // Transient network errors - safe to retry
+        case .timedOut,
+             .networkConnectionLost,
+             .notConnectedToInternet,
+             .cannotConnectToHost,
+             .cannotFindHost,
+             .dnsLookupFailed:
+          logger.debug("URLError is retryable: code=\(urlError.code.rawValue)")
+          return true
+        default:
+          logger.debug("URLError not retryable: code=\(urlError.code.rawValue)")
+          return false
+        }
+      }
+
+      let nsError = candidate as NSError
+      if nsError.domain == AVFoundationErrorDomain,
+         Self.fatalAVErrorCodes.contains(nsError.code)
+      {
+        logger.debug("AVError not retryable: code=\(nsError.code)")
         return false
       }
     }
 
-    // Unknown errors - don't retry
     let nsError = error as NSError
-    logger.debug("Error not retryable: domain=\(nsError.domain), code=\(nsError.code)")
-    return false
+    logger.debug("Treating as transient: domain=\(nsError.domain), code=\(nsError.code)")
+    return true
+  }
+
+  /// The error and its `NSUnderlyingError` ancestors, outermost first.
+  private static func errorChain(_ error: Error) -> [Error] {
+    var chain: [Error] = []
+    var current: Error? = error
+    // Bounded: a malformed cycle must not spin here.
+    while let error = current, chain.count < 8 {
+      chain.append(error)
+      current = (error as NSError).userInfo[NSUnderlyingErrorKey] as? Error
+    }
+    return chain
   }
 
   // MARK: - Retry Management
@@ -103,11 +213,30 @@ class RetryManager {
   func reset() {
     attemptCount = 0
     firstRetryTime = nil
+    firstOnlineRetryTime = nil
     isWaitingForNetwork = false
     generation += 1
     logger.debug("Retry count reset (generation \(self.generation))")
   }
 
+  private var isOnline: Bool { networkMonitor?.isOnline ?? true }
+
+  /// A description of the exhausted budget, or nil while budget remains.
+  /// The recovery duration bounds everything (including offline waits); the
+  /// first-connect duration additionally bounds never-played loads, online only.
+  private func exhaustedBudget() -> String? {
+    let now = Date()
+    if let start = firstRetryTime, now.timeIntervalSince(start) >= maxRetryDuration {
+      return "max retry duration (\(maxRetryDuration)s)"
+    }
+    if !hasPlayed, isOnline, let start = firstOnlineRetryTime,
+       now.timeIntervalSince(start) >= firstConnectMaxRetryDuration
+    {
+      return "first-connect retry duration (\(firstConnectMaxRetryDuration)s)"
+    }
+    return nil
+  }
+
   func attemptRetry(startFromCurrentTime: Bool) async -> Bool {
     if case .disabled = policy {
       logger.debug("Retry disabled, not retrying")
@@ -129,14 +258,20 @@ class RetryManager {
     if firstRetryTime == nil {
       firstRetryTime = Date()
     }
+    if isOnline {
+      if firstOnlineRetryTime == nil { firstOnlineRetryTime = Date() }
+    } else {
+      // Seeing the device offline restarts the first-connect clock: a station
+      // that lost connectivity mid-budget gets its full online seconds again
+      // after restoration, instead of the offline gap counting against it.
+      firstOnlineRetryTime = nil
+    }
 
-    // Check if we've been retrying too long (prevents surprising resumption after long offline periods)
-    if let startTime = firstRetryTime {
-      let elapsed = Date().timeIntervalSince(startTime)
-      if elapsed >= maxRetryDuration {
-        logger.info("Max retry duration (\(self.maxRetryDuration)s) exceeded after \(elapsed)s, giving up")
-        return false
-      }
+    // Check if we've been retrying too long (prevents surprising resumption
+    // after long offline periods, and grants dead-on-arrival streams a fast verdict)
+    if let budget = exhaustedBudget() {
+      logger.info("\(budget) exceeded, giving up")
+      return false
     }
 
     let delaySeconds = calculateDelaySeconds()
@@ -157,18 +292,20 @@ class RetryManager {
       return false
     }
 
+    // Cancellation can land after the sleep completed — without this check a
+    // replaced retry (new error right as the old backoff expires) still fires
+    // onRetry, double-reloading and burning the attempt count twice.
+    guard !Task.isCancelled else { return false }
+
     guard shouldRetry() else {
       logger.debug("shouldRetry returned false after delay, cancelling retry")
       return false
     }
 
-    // Re-check duration — we may have waited a long time for network restoration
-    if let startTime = firstRetryTime {
-      let elapsed = Date().timeIntervalSince(startTime)
-      if elapsed >= maxRetryDuration {
-        logger.info("Max retry duration (\(self.maxRetryDuration)s) exceeded after waiting (\(elapsed)s), giving up")
-        return false
-      }
+    // Re-check the budgets — we may have waited a long time for network restoration
+    if let budget = exhaustedBudget() {
+      logger.info("\(budget) exceeded after waiting, giving up")
+      return false
     }
 
     attemptCount += 1
@@ -218,7 +355,7 @@ class RetryManager {
 
   /// Returns false when network is restored, true if cancelled.
   @MainActor
-  private func waitForNetworkRestored(monitor: NetworkMonitor) async -> Bool {
+  private func waitForNetworkRestored(monitor: any NetworkStatusProviding) async -> Bool {
     if monitor.isOnline {
       return false
     }

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

package/ios/Player/SleepTimerHandling.swift

@@ -1,7 +1,15 @@
+import Foundation
+
 /// Protocol abstracting sleep timer for testability.
 /// PlaybackCoordinator uses this instead of SleepTimerManager directly.
 @MainActor protocol SleepTimerHandling: AnyObject {
   var onComplete: (() -> Void)? { get set }
+  /// Invoked when the fade-out window of a time-based timer begins.
+  var onFadeStart: ((_ duration: TimeInterval) -> Void)? { get set }
+  /// Invoked when a timer is cancelled/replaced while its fade may be running —
+  /// the listener restores the pre-fade volume.
+  var onFadeCancel: (() -> Void)? { get set }
+  @discardableResult func clear() -> Bool
   func onTrackChanged()
   func onTrackPlayedToEnd()
 }

package/ios/Player/SleepTimerManager.swift

@@ -1,17 +1,57 @@
 import Foundation
-import NitroModules
+
+#if canImport(NitroModules)
+  import NitroModules
+#endif
 
 /// Type alias for the Nitro SleepTimer variant type
 typealias SleepTimerState = SleepTimer
 
+/// A scheduled job that has not run yet. `cancel()` is nonisolated so `deinit`
+/// — always nonisolated in Swift 6 — can tear pending work down.
+protocol SleepTimerJob: AnyObject {
+  func cancel()
+}
+
+extension DispatchWorkItem: SleepTimerJob {}
+
+/// Runs work after a delay. Injected into `SleepTimerManager` so tests can
+/// drive the clock instead of racing it: production schedules on the main
+/// queue, tests hand in a scheduler they advance by hand.
+@MainActor
+protocol SleepTimerScheduling {
+  func schedule(
+    after delay: TimeInterval,
+    _ work: @escaping @Sendable @MainActor () -> Void,
+  ) -> any SleepTimerJob
+}
+
+struct MainQueueSleepTimerScheduler: SleepTimerScheduling {
+  func schedule(
+    after delay: TimeInterval,
+    _ work: @escaping @Sendable @MainActor () -> Void,
+  ) -> any SleepTimerJob {
+    let job = DispatchWorkItem { MainActor.assumeIsolated { work() } }
+    DispatchQueue.main.asyncAfter(deadline: .now() + delay, execute: job)
+    return job
+  }
+}
+
 /// Manages sleep timer functionality for the audio player.
 /// Supports both time-based timers and end-of-track timers.
 @MainActor
 class SleepTimerManager: SleepTimerHandling {
   // MARK: - Properties
 
+  private let scheduler: any SleepTimerScheduling
+
   // nonisolated(unsafe) for deinit cleanup — deinit is always nonisolated in Swift 6.
-  nonisolated(unsafe) private var sleepTimerJob: DispatchWorkItem?
+  private nonisolated(unsafe) var sleepTimerJob: (any SleepTimerJob)?
+  private nonisolated(unsafe) var fadeJob: (any SleepTimerJob)?
+
+  init(scheduler: any SleepTimerScheduling = MainQueueSleepTimerScheduler()) {
+    self.scheduler = scheduler
+  }
 
   /// The time when playback should stop (seconds since epoch), or -1 if inactive
   private(set) var sleepTimerTime: TimeInterval = -1 {
@@ -36,6 +76,14 @@ class SleepTimerManager: SleepTimerHandling {
   /// Callback invoked when the sleep timer fires
   var onComplete: (() -> Void)?
 
+  /// Callback invoked when the fade-out window of a time-based timer begins
+  var onFadeStart: ((_ duration: TimeInterval) -> Void)?
+
+  /// Callback invoked when a timer is cancelled/replaced while its fade may be
+  /// running — the listener restores the pre-fade volume. Not invoked on
+  /// completion: there the pause lands first, then the volume is restored.
+  var onFadeCancel: (() -> Void)?
+
   /// Callback invoked when the sleep timer state changes
   var onChanged: ((SleepTimerState) -> Void)?
 
@@ -49,6 +97,7 @@ class SleepTimerManager: SleepTimerHandling {
     if !hasSleepTimer { return false }
     sleepTimerTime = -1
     willSleepWhenCurrentItemReachesEnd = false
+    onFadeCancel?()
     onChanged?(.first(NullType.null))
     return true
   }
@@ -74,17 +123,23 @@ class SleepTimerManager: SleepTimerHandling {
   }
 
   /// Sets a time-based sleep timer.
-  /// - Parameter seconds: Number of seconds until playback stops
-  func set(seconds: TimeInterval) {
+  /// - Parameters:
+  ///   - seconds: Number of seconds until playback stops
+  ///   - fadeDuration: Seconds over which to fade the volume out before the
+  ///     deadline (clamped to `seconds`); silence lands exactly at the deadline
+  func set(seconds: TimeInterval, fadeDuration: TimeInterval? = nil) {
     cancelSleepTimerJob()
-    let job = DispatchWorkItem { [weak self] in
-      MainActor.assumeIsolated {
-        self?.complete()
+    onFadeCancel?()
+    sleepTimerTime = Date().timeIntervalSince1970 + seconds
+    sleepTimerJob = scheduler.schedule(after: seconds) { [weak self] in
+      self?.complete()
+    }
+    if let fadeDuration, fadeDuration > 0 {
+      let fade = min(fadeDuration, seconds)
+      fadeJob = scheduler.schedule(after: seconds - fade) { [weak self] in
+        self?.onFadeStart?(fade)
       }
     }
-    sleepTimerJob = job
-    sleepTimerTime = Date().timeIntervalSince1970 + seconds
-    DispatchQueue.main.asyncAfter(deadline: .now() + seconds, execute: job)
     if let state = get() { onChanged?(state) }
   }
 
@@ -92,7 +147,10 @@ class SleepTimerManager: SleepTimerHandling {
   func setToEndOfTrack() {
     let changed = !willSleepWhenCurrentItemReachesEnd
     willSleepWhenCurrentItemReachesEnd = true
-    if changed, let state = get() { onChanged?(state) }
+    if changed {
+      onFadeCancel?()
+      if let state = get() { onChanged?(state) }
+    }
   }
 
   /// Called when the current track changes. Resets end-of-track timer.
@@ -116,6 +174,8 @@ class SleepTimerManager: SleepTimerHandling {
   private func cancelSleepTimerJob() {
     sleepTimerJob?.cancel()
     sleepTimerJob = nil
+    fadeJob?.cancel()
+    fadeJob = nil
   }
 
   private func complete() {
@@ -127,5 +187,6 @@ class SleepTimerManager: SleepTimerHandling {
 
   deinit {
     sleepTimerJob?.cancel()
+    fadeJob?.cancel()
   }
 }

package/ios/Player/VolumeFader.swift

@@ -0,0 +1,77 @@
+import Foundation
+
+/// Ramps the player volume down over a duration (sleep-timer fade).
+/// The gain follows a squared curve: loudness perception is logarithmic, so a
+/// linear gain ramp sounds like a late cutoff rather than a fade.
+@MainActor
+final class VolumeFader {
+  private static let stepInterval: TimeInterval = 0.05
+
+  private let getVolume: () -> Float
+  private let setVolume: (Float) -> Void
+  // nonisolated(unsafe) for deinit cleanup — deinit is always nonisolated in Swift 6.
+  private nonisolated(unsafe) var timer: Timer?
+
+  /// Volume captured when the fade started; restored after the fade resolves.
+  /// Non-nil from fade start until cancel/completion, even once the ramp has
+  /// reached silence.
+  private(set) var originalVolume: Float?
+
+  var isActive: Bool { originalVolume != nil }
+
+  init(getVolume: @escaping () -> Float, setVolume: @escaping (Float) -> Void) {
+    self.getVolume = getVolume
+    self.setVolume = setVolume
+  }
+
+  func start(duration: TimeInterval) {
+    // If a fade is already running, keep its captured volume as the baseline —
+    // the current (partially faded) volume is not the value to restore.
+    let baseVolume = originalVolume ?? getVolume()
+    cancel(restoringVolume: false)
+    originalVolume = baseVolume
+    guard duration > 0 else { return }
+
+    let startDate = Date()
+    let timer = Timer(timeInterval: Self.stepInterval, repeats: true) { [weak self] _ in
+      MainActor.assumeIsolated {
+        guard let self else { return }
+        let progress = min(1, Date().timeIntervalSince(startDate) / duration)
+        let remaining = Float(1 - progress)
+        self.setVolume(baseVolume * remaining * remaining)
+        if progress >= 1 {
+          self.timer?.invalidate()
+          self.timer = nil
+        }
+      }
+    }
+    self.timer = timer
+    RunLoop.main.add(timer, forMode: .common)
+  }
+
+  /// Stops the ramp. With `restoringVolume` the pre-fade volume is put back
+  /// immediately (cancellation); without it the caller restores after pausing
+  /// (completion path — restoring first would let full-volume audio slip out).
+  func cancel(restoringVolume: Bool) {
+    timer?.invalidate()
+    timer = nil
+    guard let originalVolume else { return }
+    self.originalVolume = nil
+    if restoringVolume { setVolume(originalVolume) }
+  }
+
+  /// Resolves the fade around a halting action: stops the ramp, runs `halt`,
+  /// then restores the pre-fade volume — in that order, because restoring
+  /// before halting would let full-volume audio slip out. The restore is
+  /// skipped when no fade was running.
+  func resolve(around halt: () -> Void) {
+    let preFadeVolume = originalVolume
+    cancel(restoringVolume: false)
+    halt()
+    if let preFadeVolume { setVolume(preFadeVolume) }
+  }
+
+  deinit {
+    timer?.invalidate()
+  }
+}

package/ios/RemoteCommand/RemoteCommandCallbacks.swift

@@ -0,0 +1,47 @@
+#if canImport(NitroModules)
+  import NitroModules
+#endif
+
+/// The callbacks `RemoteCommandController` invokes when the system delivers a
+/// remote command (lock screen, Control Center, CarPlay, headset).
+///
+/// Split out of `TrackPlayerCallbacks` — which the controller does not otherwise
+/// use — so the controller depends only on what it calls. `TrackPlayerCallbacks`
+/// extends this protocol, 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)
+}