react-native-audio-browser 0.2.0-next.8 → 0.2.0

package/ios/TrackPlayer.swift

@@ -17,12 +17,6 @@ class TrackPlayer {
   let nowPlayingInfoController: NowPlayingInfoController
   let remoteCommandController: RemoteCommandController
   private let retryManager = RetryManager()
-  private let playbackStateStore = PlaybackStateStore()
-
-  // MARK: - Periodic Persist
-
-  /// Cancelled when playback stops; recreated when it starts.
-  private var periodicSaveTask: Task<Void, Never>?
 
   /// Retry configuration for load errors (network failures, timeouts, etc.)
   var retryConfig: Variant_Bool_RetryConfig? {
@@ -58,27 +52,23 @@ class TrackPlayer {
   )
 
   private lazy var playerTimeObserver: PlayerTimeObserver = .init(
+    periodicObserverTimeInterval: CMTime(seconds: 1, preferredTimescale: 1000),
     onAudioDidStart: { [weak self] in
-      // Audio rendered: this load has proven itself — retries from here on get
-      // the full recovery budget, not the short first-connect one.
-      self?.retryManager.hasPlayed = true
       self?.coordinator.audioDidStart()
     },
+    onSecondElapsed: { [weak self] seconds in
+      self?.nowPlayingUpdater.setCurrentTime(seconds: seconds)
+    },
   )
 
   private lazy var playerItemNotificationObserver: PlayerItemNotificationObserver = .init(
-    onDidPlayToEndTime: { [weak self] in self?.handleDidPlayToEndTime() },
+    onDidPlayToEndTime: { [weak self] in
+      self?.coordinator.handleTrackDidPlayToEndTime()
+    },
     onFailedToPlayToEndTime: { [weak self] error in
       let effectiveError = error ?? self?.avPlayer.currentItem?.error
-      self?.coordinator.errorHandler.handleError(
-        effectiveError,
-        context: .playback,
-        httpStatusCode: self?.currentItemHttpStatusCode,
-      )
+      self?.coordinator.errorHandler.handleError(effectiveError, context: .playback)
     },
-    // Buffer emptied mid-playback: nudge the player, but don't reconnect — a
-    // genuine drop is recovered by the retry / network-restore paths.
-    onPlaybackStalled: { [weak self] in self?.recoverFromStall(reconnectIfLive: false) },
   )
 
   private lazy var playerItemObserver: PlayerItemPropertyObserver = .init(
@@ -96,12 +86,6 @@ class TrackPlayer {
     },
   )
 
-  // MARK: - Now-Playing Election
-
-  private let silentAudioPrimer = SilentAudioPrimer()
-  /// Latched on the first failure of each load; reset when a new track loads.
-  private var didPrimeNowPlayingElection = false
-
   // MARK: - Callbacks
 
   weak var callbacks: TrackPlayerCallbacks? {
@@ -117,17 +101,14 @@ class TrackPlayer {
     get { coordinator.playbackError }
     set { coordinator.playbackError = newValue }
   }
-
   var lastIndex: Int {
     get { coordinator.lastIndex }
     set { coordinator.lastIndex = newValue }
   }
-
   var lastTrack: Track? {
     get { coordinator.lastTrack }
     set { coordinator.lastTrack = newValue }
   }
-
   var tracks: [Track] { coordinator.tracks }
   var currentIndex: Int { coordinator.currentIndex }
   var currentTrack: Track? { coordinator.currentTrack }
@@ -157,19 +138,6 @@ class TrackPlayer {
     set { coordinator.playWhenReady = newValue }
   }
 
-  /// Time playback must have progressed before a buffer dip counts as a stall, so the initial
-  /// connect / a seek doesn't read as one. iOS has no native rebuffer-vs-initial signal.
-  private static let stallGraceSeconds: TimeInterval = 0.5
-
-  /// True while ongoing playback has stalled waiting for data. Approximated from
-  /// `isPlaybackLikelyToKeepUp`, gated on having actually started and the play intent (so an
-  /// initial connect / seek doesn't read as a stall). Mirrors the Android `stalled` signal, which
-  /// the load control distinguishes natively.
-  var isStalled: Bool {
-    guard let item = avPlayer.currentItem else { return false }
-    return currentTime > Self.stallGraceSeconds && playWhenReady && !item.isPlaybackLikelyToKeepUp
-  }
-
   /**
    Controls the time pitch algorithm applied to each track loaded into the player.
    */
@@ -254,6 +222,7 @@ class TrackPlayer {
     set {
       coordinator.rate = newValue
       avPlayer.rate = newValue
+      nowPlayingUpdater.updatePlaybackValues(duration: duration, rate: newValue, currentTime: currentTime)
     }
   }
 
@@ -280,9 +249,7 @@ class TrackPlayer {
       self?.playWhenReady ?? false
     }
     retryManager.onRetry = { [weak self] startFromCurrentTime in
-      // Re-resolve rather than replay the cached URL: a retry may be recovering
-      // from an expired short-lived URL/token that only a fresh resolve fixes.
-      self?.reloadResolving(startFromCurrentTime: startFromCurrentTime)
+      self?.reload(startFromCurrentTime: startFromCurrentTime)
     }
 
     // Handle command center changes when MPNowPlayingSession is created/destroyed (iOS 16+)
@@ -303,7 +270,6 @@ class TrackPlayer {
   func handlePlayWhenReady(_ playWhenReady: Bool?, action: () throws -> Void) rethrows {
     try coordinator.handlePlayWhenReady(playWhenReady, action: action)
   }
-
   func transition(_ event: PlaybackEvent) { coordinator.transition(event) }
 
   // MARK: - Player Actions
@@ -327,13 +293,6 @@ class TrackPlayer {
   func pause() { coordinator.pause() }
   func togglePlayback() { coordinator.togglePlayback() }
 
-  func handleInterruptionBegan() { coordinator.handleInterruptionBegan() }
-  func handleRouteDisconnected() { coordinator.handleRouteDisconnected() }
-  var willResumeAfterInterruption: Bool { coordinator.willResumeAfterInterruption }
-  func handleInterruptionEnded(shouldResume: Bool) {
-    coordinator.handleInterruptionEnded(shouldResume: shouldResume)
-  }
-
   func stop() {
     coordinator.stop()
     if currentTrack?.live != true {
@@ -342,62 +301,20 @@ class TrackPlayer {
   }
 
   func reload(startFromCurrentTime: Bool) {
-    let time = startFromCurrentTime ? resumeTime() : nil
+    var time: Double? = nil
+    if startFromCurrentTime {
+      if let currentItem = avPlayer.currentItem {
+        if !currentItem.duration.isIndefinite {
+          time = currentItem.currentTime().seconds
+        }
+      }
+    }
     loadAVPlayer()
     if let time {
       seekTo(time)
     }
   }
 
-  /// Playback position to resume from on reload, or nil when there is nothing
-  /// seekable to resume (no item, or an indefinite/live duration).
-  private func resumeTime() -> Double? {
-    guard let currentItem = avPlayer.currentItem, !currentItem.duration.isIndefinite else {
-      return nil
-    }
-    return currentItem.currentTime().seconds
-  }
-
-  /// Re-establish a stalled stream when connectivity is restored.
-  ///
-  /// AVPlayer doesn't reliably surface a mid-stream connectivity loss on a live stream as an item
-  /// failure — it sits in `.waitingToPlayAtSpecifiedRate` (a buffering stall) with no error, so the
-  /// error-driven `RetryManager` never engages. Without this, the stream stays "reconnecting"
-  /// indefinitely after the network returns. Mirrors Android, where ExoPlayer surfaces the drop as a
-  /// retryable load error and re-prepares on restore.
-  ///
-  /// Guards: reload only while actually stalled (`.buffering`) with play intent — so a user-initiated
-  /// pause, or a retry that already gave up (`.error`, past the max retry duration) isn't surprisingly
-  /// resumed. Skipped when `RetryManager` is already parked waiting for the network: an error *did*
-  /// schedule a retry that owns its own reload, so we'd otherwise load twice.
-  func handleNetworkRestored() {
-    guard playWhenReady,
-          coordinator.state == .buffering,
-          !retryManager.isWaitingForNetwork
-    else { return }
-    logger.info("Connectivity restored while stalled — re-resolving to reconnect")
-    // Re-resolve rather than replay the cached URL: a resolver that mints a short-lived URL/token
-    // may have had it expire during the offline gap, so reconnecting with the stale URL would just
-    // fail (then recover only via the error path). Matches the error-retry path here, and Android,
-    // which re-resolves on its network-error reconnect. `reloadResolving` falls back to a plain
-    // reload when there's no track `src` to resolve.
-    reloadResolving(startFromCurrentTime: true)
-  }
-
-  /// Jump to the live edge. No-op for non-live tracks. Live with a seekable
-  /// window (HLS) seeks to the window end; live without one (non-seekable, e.g.
-  /// ICY) has no window to seek within, so reconnect to rejoin live.
-  func seekToLiveEdge() {
-    guard currentTrack?.live == true, let item = avPlayer.currentItem else { return }
-    if let range = item.seekableTimeRanges.last?.timeRangeValue, range.duration.seconds > 0 {
-      avPlayer.seek(to: range.end, toleranceBefore: .zero, toleranceAfter: .zero)
-    } else {
-      // Re-resolve on reconnect: this is the stall-recovery path for non-seekable live
-      // streams, where a short-lived stream URL may have expired during the outage.
-      reloadResolving(startFromCurrentTime: false)
-    }
-  }
-
   func seekTo(_ seconds: TimeInterval) {
     seekTo(seconds, completion: { _ in })
   }
@@ -409,22 +326,10 @@ class TrackPlayer {
     } else if avPlayer.currentItem != nil {
       let time = CMTime(seconds: seconds, preferredTimescale: 1000)
       let seekSeconds = seconds
-      let generation = loadSeekCoordinator.generation
       avPlayer
         .seek(to: time, toleranceBefore: CMTime.zero, toleranceAfter: CMTime.zero) { [weak self] finished in
           Task { @MainActor in
-            guard let self else {
-              completion(false)
-              return
-            }
-            // A completion from before a track change (reset() bumped the
-            // generation) belongs to the old item — delivering it would emit a
-            // bogus seek-completed and consume the new track's pending start seek.
-            guard self.loadSeekCoordinator.isCurrentGeneration(generation) else {
-              completion(false)
-              return
-            }
-            self.handleSeekCompleted(to: Double(seekSeconds), didFinish: finished)
+            self?.handleSeekCompleted(to: Double(seekSeconds), didFinish: finished)
             completion(finished)
           }
         }
@@ -449,11 +354,6 @@ class TrackPlayer {
 
   func enableRemoteCommands(_ commands: [RemoteCommand]) {
     remoteCommandController.enable(commands: commands)
-    // Apply current next/previous availability so re-/late-configured commands
-    // start in the correct enabled state (not unconditionally enabled).
-    remoteCommandController.setSkipAvailability(
-      canNext: coordinator.canNext, canPrevious: coordinator.canPrevious,
-    )
   }
 
   func clear() {
@@ -472,10 +372,6 @@ class TrackPlayer {
     coordinator.setProgressUpdateInterval(interval)
   }
 
-  func setPlaybackIntervalEnabled(_ enabled: Bool) {
-    coordinator.setPlaybackIntervalEnabled(enabled)
-  }
-
   // MARK: - AVPlayer Management
 
   func setTimePitchingAlgorithmForCurrentItem() {
@@ -513,6 +409,7 @@ class TrackPlayer {
   private func recreateAVPlayer() {
     coordinator.playbackError = nil
     playerTimeObserver.unregisterForBoundaryTimeEvents()
+    playerTimeObserver.unregisterForPeriodicEvents()
     playerObserver.stopObserving()
     stopObservingAVPlayerItem()
     clearCurrentAVItem()
@@ -523,17 +420,6 @@ class TrackPlayer {
     setupAVPlayer()
   }
 
-  /// Recover from a media-services reset (`mediaserverd` crashed/reset): every
-  /// AVPlayer/session handle is invalid, so recreate the player and reload the
-  /// current track, preserving play intent, so a live stream reconnects instead
-  /// of going permanently silent. No-op when nothing is loaded.
-  func handleMediaServicesReset() {
-    guard currentTrack != nil else { return }
-    logger.info("Media services were reset — recreating player and reloading current track")
-    recreateAVPlayer()
-    reloadResolving(startFromCurrentTime: false)
-  }
-
   private func setupAVPlayer() {
     avPlayer.allowsExternalPlayback = false
 
@@ -542,31 +428,21 @@ class TrackPlayer {
 
     playerTimeObserver.avPlayer = avPlayer
     playerTimeObserver.registerForBoundaryTimeEvents()
+    playerTimeObserver.registerForPeriodicTimeEvents()
 
     nowPlayingInfoController.linkPlayer(avPlayer)
 
     if playWhenReady {
       startPlayback()
     } else {
-      avPlayer.defaultRate = rate
+      if #available(iOS 16.0, *) {
+        avPlayer.defaultRate = rate
+      }
     }
   }
 
   func loadAVPlayer() {
-    prepareForReload()
-    mediaLoader.loadAsset()
-  }
-
-  /// Teardown shared by the two reload paths: recreate the player after a
-  /// terminal error, otherwise cancel in-flight loading and drop the current
-  /// asset, then enter the loading state.
-  private func prepareForReload() {
     if state == .error {
-      // A restart from terminal error begins a new load of the same track:
-      // fresh budgets, unproven playback (see resetForNewLoad). Automatic
-      // retries never enter this branch — the retry loop keeps the state
-      // non-terminal — so only retry() / play-from-error land here.
-      coordinator.errorHandler.resetForNewLoad()
       recreateAVPlayer()
     } else {
       mediaLoader.cancelAll()
@@ -575,25 +451,7 @@ class TrackPlayer {
       mediaLoader.clearAsset()
     }
     transition(.trackLoading)
-  }
-
-  /// Reload by re-running the resolver (fresh URL / headers / user-agent)
-  /// instead of recreating the asset from the already-resolved URL. Used by the
-  /// retry path so consumers whose resolver mints short-lived URLs or auth
-  /// tokens recover once those expire — a plain `reload()` would replay the
-  /// stale URL and keep failing. Falls back to `reload()` when there's no track
-  /// `src` to resolve.
-  func reloadResolving(startFromCurrentTime: Bool) {
-    guard let track = currentTrack, let src = track.src else {
-      reload(startFromCurrentTime: startFromCurrentTime)
-      return
-    }
-    let time = startFromCurrentTime ? resumeTime() : nil
-    prepareForReload()
-    mediaLoader.resolveAndLoad(src: src, track: track)
-    if let time {
-      seekTo(time)
-    }
+    mediaLoader.loadAsset()
   }
 
   func unloadAVPlayer() {
@@ -603,47 +461,6 @@ class TrackPlayer {
 
   // MARK: - Observer Callbacks (map AVFoundation → coordinator)
 
-  /// Resolve an end-of-item notification: a genuine end advances the queue; a
-  /// dropped live stream or a mid-stream underrun reported as EOF is recovered
-  /// instead of advancing/stopping (see `EndOfTrackJudgement`).
-  private func handleDidPlayToEndTime() {
-    let judgement = EndOfTrackJudgement(
-      isLive: currentTrack?.live == true,
-      currentTime: currentTime,
-      duration: duration,
-    )
-    switch judgement.outcome {
-    case .ended:
-      coordinator.handleTrackDidPlayToEndTime()
-    case .stalled:
-      recoverFromStall(reconnectIfLive: true)
-    }
-  }
-
-  /// Recover from a stall while the play intent still holds. A live stream that
-  /// ran out of data (`reconnectIfLive`) rejoins the edge — reloading when there
-  /// is no seekable window; otherwise just re-issue play() to un-park AVPlayer
-  /// from `.waitingToPlayAtSpecifiedRate` (data may resume on the same
-  /// connection; a genuine drop is handled by the retry / network-restore paths).
-  private func recoverFromStall(reconnectIfLive: Bool) {
-    guard playWhenReady else { return }
-    if reconnectIfLive, currentTrack?.live == true {
-      seekToLiveEdge()
-    } else {
-      startPlayback()
-    }
-  }
-
-  /// Previous time-control transition + whether its wait reason was
-  /// `.noItemToPlay`, retained to detect the AirPlay waiting→paused stall.
-  private var previousTimeControlStatus: PlayerTimeControlStatus?
-  private var previousWaitingReasonWasNoItemToPlay = false
-
-  /// True when the active audio route is AirPlay.
-  private var isAirPlayRoute: Bool {
-    AVAudioSession.sharedInstance().currentRoute.outputs.contains { $0.portType == .airPlay }
-  }
-
   private func avPlayerDidChangeTimeControlStatus(_ status: AVPlayer.TimeControlStatus) {
     let mapped: PlayerTimeControlStatus
     switch status {
@@ -652,36 +469,12 @@ class TrackPlayer {
     case .playing: mapped = .playing
     @unknown default: return
     }
-    recoverIfAirPlayStalled(transitioningTo: mapped)
     coordinator.avPlayerDidChangeTimeControlStatus(mapped)
   }
 
-  /// AVPlayer can silently strand us in .paused after a `.noItemToPlay` wait
-  /// over AirPlay while we still intend to play — re-issue play() on exactly
-  /// that transition. Also records this transition for the next comparison.
-  private func recoverIfAirPlayStalled(transitioningTo current: PlayerTimeControlStatus) {
-    let stalled = AirPlayStallJudgement(
-      previous: previousTimeControlStatus,
-      current: current,
-      previousWaitingReasonWasNoItemToPlay: previousWaitingReasonWasNoItemToPlay,
-      isAirPlay: isAirPlayRoute,
-      playWhenReady: playWhenReady,
-    ).shouldNudge
-    previousTimeControlStatus = current
-    previousWaitingReasonWasNoItemToPlay =
-      current == .waitingToPlayAtSpecifiedRate && avPlayer.reasonForWaitingToPlay == .noItemToPlay
-    if stalled {
-      logger.info("AirPlay waiting→paused stall detected — nudging play()")
-      startPlayback()
-    }
-  }
-
   private func avPlayerStatusDidChange(_ status: AVPlayer.Status) {
     if status == .failed {
-      coordinator.avPlayerStatusDidFail(
-        error: avPlayer.currentItem?.error,
-        httpStatusCode: currentItemHttpStatusCode,
-      )
+      coordinator.avPlayerStatusDidFail(error: avPlayer.currentItem?.error)
     }
   }
 
@@ -693,25 +486,7 @@ class TrackPlayer {
     case .failed: mapped = .failed
     @unknown default: return
     }
-    coordinator.avItemStatusDidChange(
-      mapped,
-      error: error ?? avPlayer.currentItem?.error,
-      httpStatusCode: currentItemHttpStatusCode,
-    )
-  }
-
-  /// The HTTP status the server last answered the current item with, if any.
-  ///
-  /// `AVPlayerItem.error` never carries it — a 404 arrives as an opaque
-  /// CoreMedia error — so the error log is the only place it surfaces. The log
-  /// is per-item, so its entries belong to the track that just failed; picking
-  /// among them is `PlaybackErrorHandler`'s job, where it is testable
-  /// (`AVPlayerItemErrorLogEvent` cannot be constructed).
-  private var currentItemHttpStatusCode: Int? {
-    guard let events = avPlayer.currentItem?.errorLog()?.events else { return nil }
-    return PlaybackErrorHandler.httpStatusCode(
-      fromErrorStatusCodes: events.map(\.errorStatusCode),
-    )
+    coordinator.avItemStatusDidChange(mapped, error: error ?? avPlayer.currentItem?.error)
   }
 
   private func avItemDidUpdatePlaybackLikelyToKeepUp(_ playbackLikelyToKeepUp: Bool) {
@@ -729,64 +504,14 @@ class TrackPlayer {
   func handleSeekCompleted(to seconds: Double, didFinish: Bool) {
     if loadSeekCoordinator.seekDidComplete(on: avPlayer, delegate: self), state == .loading {
       coordinator.handleSeekCompleted(to: seconds, didFinish: didFinish)
+    } else {
+      // Not a load-seek, just update now playing
+      nowPlayingUpdater.setCurrentTime(seconds: seconds)
     }
     callbacks?.playerDidCompleteSeek(position: seconds, didFinish: didFinish)
   }
 }
 
-// MARK: - Playback State Persistence
-
-extension TrackPlayer {
-  /// Snapshot the current player state to UserDefaults so a cold-start resume
-  /// can restore it without the JS runtime. Live streams persist `positionMs = nil`.
-  private func persistPlaybackState() {
-    guard let track = currentTrack else { return }
-    // At .ended the position equals the duration — persisting it would make a
-    // cold-start resume seek to the end and instantly re-end (Android twin:
-    // savePositionZero).
-    let positionMs: Double? =
-      (track.live == true) ? nil : (state == .ended ? 0 : currentTime * 1000)
-    playbackStateStore.save(
-      PersistedPlaybackState(
-        track: JsonTrack(from: track),
-        positionMs: positionMs,
-        repeatMode: repeatMode.persistedString,
-        shuffleEnabled: shuffleEnabled,
-        playbackSpeed: rate,
-      ),
-    )
-  }
-
-  /// Start a 5 s repeating save while playback is active. A previous task is
-  /// cancelled first so there is never more than one running at a time.
-  private func startPeriodicSave() {
-    periodicSaveTask?.cancel()
-    periodicSaveTask = Task { @MainActor [weak self] in
-      while !Task.isCancelled {
-        try? await Task.sleep(nanoseconds: 5_000_000_000)
-        guard !Task.isCancelled else { return }
-        self?.persistPlaybackState()
-      }
-    }
-  }
-
-  private func stopPeriodicSave() {
-    periodicSaveTask?.cancel()
-    periodicSaveTask = nil
-  }
-}
-
-private extension RepeatMode {
-  /// String representation stored in `PersistedPlaybackState.repeatMode`.
-  var persistedString: String {
-    switch self {
-    case .off: "off"
-    case .track: "track"
-    case .queue: "queue"
-    }
-  }
-}
-
 // MARK: - PlaybackEffectHandler
 
 extension TrackPlayer: PlaybackEffectHandler {
@@ -802,20 +527,12 @@ extension TrackPlayer: PlaybackEffectHandler {
     stopObservingAVPlayerItem()
   }
 
-  func loadTrack(src: String, track: Track) {
-    didPrimeNowPlayingElection = false
-    // A new track starts unproven: its failures get the short first-connect
-    // budget until it renders audio. Reloads of the current track (retry,
-    // play-from-error) deliberately keep the flag.
-    retryManager.hasPlayed = false
-    mediaLoader.resolveAndLoad(src: src, track: track)
+  func loadTrack(src: String) {
+    mediaLoader.resolveAndLoad(src: src)
   }
 
   func reloadTrack(startFromCurrentTime: Bool) {
-    // Re-resolve rather than replay the cached URL: play-from-.error typically happens long
-    // after the failure (an expired signed URL would just re-fail, often non-retryably),
-    // matching every other retry path (retry, network restore, media-services reset).
-    reloadResolving(startFromCurrentTime: startFromCurrentTime)
+    reload(startFromCurrentTime: startFromCurrentTime)
   }
 
   func unloadTrack() {
@@ -836,25 +553,37 @@ extension TrackPlayer: PlaybackEffectHandler {
     }
   }
 
+  func updateNowPlayingValues(duration: Double, rate: Float, currentTime: Double) {
+    nowPlayingUpdater.updatePlaybackValues(duration: duration, rate: rate, currentTime: currentTime)
+  }
+
   func updateNowPlayingState(playWhenReady: Bool) {
-    nowPlayingInfoController.setPlaybackState(playing: playWhenReady)
-    if playWhenReady {
-      startPeriodicSave()
-    } else {
-      stopPeriodicSave()
-      persistPlaybackState()
-    }
+    nowPlayingUpdater.updatePlaybackState(playWhenReady: playWhenReady)
+  }
+
+  func loadNowPlayingMetadata(for track: Track, rate: Float) {
+    // Reset playback values without updating, because that will happen in
+    // the nowPlayingUpdater.loadMetaValues call straight after:
+    nowPlayingInfoController.setWithoutUpdate(keyValues: [
+      MediaItemProperty.duration(nil),
+      NowPlayingInfoProperty.playbackRate(nil),
+      NowPlayingInfoProperty.elapsedPlaybackTime(nil),
+    ])
+    nowPlayingUpdater.loadMetaValues(for: track, rate: rate)
   }
 
-  func loadNowPlayingMetadata(for track: Track) {
-    nowPlayingUpdater.loadMetaValues(for: track)
-    persistPlaybackState()
+  func resetNowPlayingValues() {
+    // Intentionally empty — loadNowPlayingMetadata handles the reset
   }
 
   func clearNowPlaying() {
     nowPlayingInfoController.clear()
   }
 
+  func setNowPlayingCurrentTime(seconds: Double) {
+    nowPlayingUpdater.setCurrentTime(seconds: seconds)
+  }
+
   func updateRemoteRepeatMode(_ mode: RepeatMode) {
     remoteCommandController.updateRepeatMode(mode)
   }
@@ -862,10 +591,6 @@ extension TrackPlayer: PlaybackEffectHandler {
   func updateRemoteShuffleMode(_ enabled: Bool) {
     remoteCommandController.updateShuffleMode(enabled)
   }
-
-  func updateSkipAvailability(canNext: Bool, canPrevious: Bool) {
-    remoteCommandController.setSkipAvailability(canNext: canNext, canPrevious: canPrevious)
-  }
 }
 
 // MARK: - SeekCompletionHandler
@@ -883,20 +608,8 @@ extension TrackPlayer {
     coordinator.replace(index, track)
   }
 
-  func setQueue(
-    _ newTracks: [Track],
-    initialIndex: Int = 0,
-    startPositionMs: Double? = nil,
-    playWhenReady: Bool? = nil,
-    sourcePath: String? = nil,
-  ) {
-    coordinator.setQueue(
-      newTracks,
-      initialIndex: initialIndex,
-      startPositionMs: startPositionMs,
-      playWhenReady: playWhenReady,
-      sourcePath: sourcePath,
-    )
+  func setQueue(_ newTracks: [Track], initialIndex: Int = 0, playWhenReady: Bool? = nil, sourcePath: String? = nil) {
+    coordinator.setQueue(newTracks, initialIndex: initialIndex, playWhenReady: playWhenReady, sourcePath: sourcePath)
   }
 
   func add(_ tracks: [Track], initialIndex: Int? = nil, playWhenReady: Bool? = nil) {
@@ -953,50 +666,14 @@ extension TrackPlayer: MediaLoaderDelegate {
   }
 
   func mediaLoaderDidFailWithRetryableError(_ error: Error) {
-    attachPublishingCarrierItemIfNeeded()
-    primeNowPlayingElectionIfNeeded()
     coordinator.errorHandler.handleError(error, context: .mediaLoad)
   }
 
   func mediaLoaderDidFailWithUnplayableTrack() {
-    attachPublishingCarrierItemIfNeeded()
-    primeNowPlayingElectionIfNeeded()
     transition(.errorOccurred(.trackWasUnplayable))
   }
 
-  /// `MPNowPlayingSession` publishes only through the linked player's current item, so
-  /// a load that fails before item creation (a dead host on a cold start) leaves the
-  /// player item-less: the system never surfaces the app on the lock screen / CarPlay
-  /// — no metadata, no transport buttons — and the failure line has nowhere to appear.
-  /// Attach the failed asset's item purely as a publishing carrier. Deliberately not
-  /// observed: its `.failed` status must not re-report the error the loader already
-  /// delivered. A successful load (retry, or the next track) replaces it with the
-  /// real, observed item via `mediaLoaderDidPrepareItem`; retry reloads leave it in
-  /// place (`prepareForReload` drops only the asset), so the surface doesn't flicker.
-  private func attachPublishingCarrierItemIfNeeded() {
-    guard avPlayer.currentItem == nil, let asset = mediaLoader.asset else { return }
-    logger.notice("Attaching publishing-carrier item for failed load")
-    let item = AVPlayerItem(asset: asset)
-    nowPlayingInfoController.prepareItem(item)
-    avPlayer.replaceCurrentItem(with: item)
-  }
-
-  /// A failed load renders no audio, and without rendered audio iOS never elects the
-  /// app onto the system now-playing surfaces — the published failure metadata and
-  /// transport controls stay invisible (see `SilentAudioPrimer`). On the first
-  /// failure of a play-intended load, render a silence burst to claim the surface.
-  /// Once per load: the retry loop re-fails every few seconds, and one burst either
-  /// elected us or never will. Does not touch the retry loop itself.
-  private func primeNowPlayingElectionIfNeeded() {
-    guard playWhenReady, !didPrimeNowPlayingElection else { return }
-    didPrimeNowPlayingElection = true
-    silentAudioPrimer.prime()
-  }
-
   func mediaLoaderDidFailWithError(_ error: TrackPlayerError.PlaybackError) {
-    // No carrier here: an invalid/missing src never produced an asset. The
-    // direct-center publish still carries the metadata once elected.
-    primeNowPlayingElectionIfNeeded()
     transition(.errorOccurred(error))
   }
 
@@ -1012,3 +689,4 @@ extension TrackPlayer: MediaLoaderDelegate {
     callbacks?.playerDidReceiveTimedMetadata(groups)
   }
 }
+