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

package/ios/Player/PlaybackErrorHandler.swift

@@ -1,13 +1,8 @@
-import AVFoundation
 import Foundation
 import os.log
 
 /// Abstracts RetryManager for testability.
 @MainActor public protocol RetryHandling: AnyObject {
-  /// False when the configured policy is `disabled` — every error is then terminal.
-  var isEnabled: Bool { get }
-  /// Whether the current load has produced audio — selects the retry budget.
-  var hasPlayed: Bool { get set }
   func isRetryable(_ error: Error?) -> Bool
   func attemptRetry(startFromCurrentTime: Bool) async -> Bool
   func reset()
@@ -23,15 +18,15 @@ public enum PlaybackErrorContext {
 
   var startFromCurrentTime: Bool {
     switch self {
-    case .playback: true
-    case .mediaLoad: false
+    case .playback:   true
+    case .mediaLoad:  false
     }
   }
 
   var fallbackError: TrackPlayerError.PlaybackError {
     switch self {
-    case .playback: .playbackFailed
-    case .mediaLoad: .failedToLoadKeyValue
+    case .playback:   .playbackFailed
+    case .mediaLoad:  .failedToLoadKeyValue
     }
   }
 }
@@ -42,11 +37,6 @@ public enum PlaybackErrorContext {
   private let logger = Logger(subsystem: "com.audiobrowser", category: "PlaybackErrorHandler")
 
   var onError: ((TrackPlayerError.PlaybackError) -> Void)?
-  /// A failure the retry loop is still working on. Fired when a retry is
-  /// scheduled, before its backoff elapses, so UIs can show the cause while
-  /// the playback state stays non-terminal. `onError` still fires if the
-  /// retries give up.
-  var onRetryingError: ((TrackPlayerError.PlaybackError) -> Void)?
   private(set) var pendingRetryTask: Task<Void, Never>?
   private let retryHandler: any RetryHandling
 
@@ -54,7 +44,7 @@ public enum PlaybackErrorContext {
     self.retryHandler = retryHandler
   }
 
-  func handleError(_ error: Error?, context: PlaybackErrorContext, httpStatusCode: Int? = nil) {
+  func handleError(_ error: Error?, context: PlaybackErrorContext) {
     if let error {
       let nsError = error as NSError
       logger.error("[\(String(describing: context))] failure: domain=\(nsError.domain), code=\(nsError.code), localizedDescription=\(error.localizedDescription)")
@@ -62,30 +52,21 @@ public enum PlaybackErrorContext {
       logger.error("[\(String(describing: context))] failure with nil error")
     }
 
-    if retryHandler.isEnabled, retryHandler.isRetryable(error) {
-      onRetryingError?(PlaybackErrorHandler.classify(
-        error: error, fallback: context.fallbackError, httpStatusCode: httpStatusCode,
-      ))
+    if retryHandler.isRetryable(error) {
       pendingRetryTask?.cancel()
       pendingRetryTask = Task { [weak self] in
         guard let self else { return }
         let retried = await retryHandler.attemptRetry(startFromCurrentTime: context.startFromCurrentTime)
-        // Cancelled (track change / stop): stay silent — attemptRetry returns
-        // false on a cancelled wait, and surfacing that would flip the new
-        // track or a deliberate stop to .error. The canceller owns the handle.
-        if Task.isCancelled { return }
         if !retried {
-          let classified = PlaybackErrorHandler.classify(error: error, fallback: context.fallbackError, httpStatusCode: httpStatusCode)
+          let classified = PlaybackErrorHandler.classify(error: error, fallback: context.fallbackError)
           self.onError?(classified)
         }
-        // Clear the handle: session release is gated on no pending retry.
-        pendingRetryTask = nil
       }
       return
     }
 
     logger.warning("Error not retryable, surfacing \(String(describing: context.fallbackError))")
-    let classified = PlaybackErrorHandler.classify(error: error, fallback: context.fallbackError, httpStatusCode: httpStatusCode)
+    let classified = PlaybackErrorHandler.classify(error: error, fallback: context.fallbackError)
     onError?(classified)
   }
 
@@ -99,77 +80,12 @@ public enum PlaybackErrorContext {
     retryHandler.reset()
   }
 
-  /// A restart from a terminal error begins a new load of the same track:
-  /// fresh budgets and unproven playback, so the user's tap yields a visible
-  /// first-connect retry window instead of a single silent attempt — the same
-  /// behavior as re-selecting the track (ADR 0004).
-  func resetForNewLoad() {
-    resetRetry()
-    retryHandler.hasPlayed = false
-  }
-
-  /// Classifies an error into the narrowest case the evidence supports, so JS
-  /// receives a real `kind` rather than a context fallback.
-  ///
-  /// Order matters: a transport failure means we never got a response, so it
-  /// outranks any status left in the item's error log. AVFoundation reports
-  /// HTTP failures as opaque CoreMedia errors, which is why `httpStatusCode`
-  /// is passed in separately by the caller rather than read off `error`.
-  public static func classify(
-    error: Error?,
-    fallback: TrackPlayerError.PlaybackError,
-    httpStatusCode: Int? = nil,
-  ) -> TrackPlayerError.PlaybackError {
-    // `as?` bridges plain `NSError`s in `NSURLErrorDomain` too, which is the
-    // form AVFoundation usually hands back.
-    if let urlError = error as? URLError {
-      switch urlError.code {
-      case .notConnectedToInternet:
-        return .notConnectedToInternet
-      case .timedOut,
-           .cannotFindHost,
-           .cannotConnectToHost,
-           .networkConnectionLost,
-           .dnsLookupFailed,
-           .secureConnectionFailed:
-        return .hostUnreachable
-      default:
-        break
-      }
-    }
-
-    if let httpStatusCode, !(200 ... 299).contains(httpStatusCode) {
-      return .httpStatus(httpStatusCode)
-    }
-
-    if isUnplayableMedia(error) {
-      return .trackWasUnplayable
+  /// Classifies an error, checking for internet connectivity issues before falling back.
+  public static func classify(error: Error?, fallback: TrackPlayerError.PlaybackError) -> TrackPlayerError.PlaybackError {
+    let nsError = error as NSError?
+    if nsError?.code == URLError.notConnectedToInternet.rawValue {
+      return .notConnectedToInternet
     }
-
     return fallback
   }
-
-  /// Picks the HTTP status out of an `AVPlayerItem` error log's status codes.
-  ///
-  /// `errorStatusCode` is a mixed space — negative OSStatus values share it
-  /// with HTTP statuses — so only in-range values count, and the newest wins:
-  /// a live stream reconnects, and older entries describe earlier attempts.
-  public static func httpStatusCode(fromErrorStatusCodes codes: [Int]) -> Int? {
-    codes.last { (100 ... 599).contains($0) }
-  }
-
-  /// The stream was fetched but cannot be decoded — unknown container,
-  /// unsupported codec, or a decoder that refused it.
-  private static func isUnplayableMedia(_ error: Error?) -> Bool {
-    guard let nsError = error as NSError? else { return false }
-    guard nsError.domain == AVFoundationErrorDomain else { return false }
-    return [
-      AVError.fileFormatNotRecognized,
-      AVError.failedToParse,
-      AVError.decoderNotFound,
-      AVError.decoderTemporarilyUnavailable,
-      AVError.formatUnsupported,
-      AVError.contentIsUnavailable,
-    ].contains { $0.rawValue == nsError.code }
-  }
 }

package/ios/Player/PlaybackProgressUpdateManager.swift

@@ -0,0 +1,68 @@
+import Foundation
+#if canImport(NitroModules)
+import NitroModules
+#endif
+
+/**
+ Manages periodic progress updates during playback.
+ Emits progress events at configurable intervals based on playback state.
+ */
+@MainActor
+class PlaybackProgressUpdateManager {
+  // nonisolated(unsafe) for deinit cleanup — Timer must be invalidated to
+  // break RunLoop retain, and deinit is always nonisolated in Swift 6.
+  nonisolated(unsafe) private var timer: Timer?
+  private var updateInterval: TimeInterval?
+  private let onProgressUpdate: () -> Void
+
+  init(onProgressUpdate: @escaping () -> Void) {
+    self.onProgressUpdate = onProgressUpdate
+  }
+
+  deinit {
+    timer?.invalidate()
+  }
+
+  func setUpdateInterval(_ interval: TimeInterval?) {
+    if interval == updateInterval { return }
+    let wasRunning = timer != nil
+    updateInterval = (interval != nil && interval! > 0) ? interval : nil
+    stop()
+    if updateInterval != nil, wasRunning {
+      start()
+    }
+  }
+
+  func start() {
+    guard timer == nil, let interval = updateInterval else { return }
+    timer = Timer.scheduledTimer(
+      withTimeInterval: interval,
+      repeats: true,
+    ) { [weak self] _ in
+      MainActor.assumeIsolated {
+        self?.onProgressUpdate()
+      }
+    }
+  }
+
+  func stop() {
+    timer?.invalidate()
+    timer = nil
+  }
+
+  func onPlaybackStateChanged(_ state: PlaybackState) {
+    switch state {
+    // Start when playback is set to resume (loading, buffering) or playing
+    case .loading, .buffering, .playing:
+      start()
+
+    // Stop when playback pauses, stops, or errors
+    case .paused, .stopped, .ended, .error:
+      stop()
+
+    // No action for ready, none
+    default:
+      break
+    }
+  }
+}

package/ios/Player/PlaybackStateMachine.swift

@@ -5,32 +5,27 @@
 /// site and decide whether to fire the event at all.
 func nextPlaybackState(from current: PlaybackState, on event: PlaybackEvent) -> PlaybackState? {
   switch event {
-  case .stopped: return .stopped
-  case .trackLoading: return .loading
-  case .trackUnloaded: return PlaybackState.none
+  case .stopped:             return .stopped
+  case .trackLoading:        return .loading
+  case .trackUnloaded:       return PlaybackState.none
   case .trackEndedNaturally: return .ended
-  case .avPlayerWaiting: return .buffering
-  case .avPlayerPlaying: return .playing
-  case .audioFrameDecoded: return .playing
-  case .errorOccurred: return .error
+  case .avPlayerWaiting:     return .buffering
+  case .avPlayerPlaying:     return .playing
+  case .audioFrameDecoded:   return .playing
+  case .errorOccurred:       return .error
+
   case .loadSeekCompleted:
     guard current == .loading else { return nil }
     return .ready
-  case let .avPlayerPaused(hasAsset):
+
+  case .avPlayerPaused(let hasAsset):
     guard current != .stopped else { return nil }
     if !hasAsset { return PlaybackState.none }
-    // .error and .ended own their state against stray pause observations —
-    // reachable from .ended since the natural-end intent clear opens the
-    // call site's `!playWhenReady` gate.
-    guard current != .error, current != .ended else { return nil }
+    guard current != .error else { return nil }
     return .paused
+
   case .bufferingSufficient:
-    // Terminal states must not drift back to .ready on a buffer refill: .ended
-    // would restart the completed track (playWhenReady is still true), and
-    // .stopped/.error would skip the reload-on-play path, which only triggers
-    // from those states. Leaving them requires an explicit load or reload.
-    guard current != .playing, current != .ended, current != .stopped, current != .error
-    else { return nil }
+    guard current != .playing, current != .ended else { return nil }
     return .ready
   }
 }

package/ios/Player/PlayingStateManager.swift

@@ -1,6 +1,6 @@
 import Foundation
 #if canImport(NitroModules)
-  import NitroModules
+import NitroModules
 #endif
 
 /// Manages the playing state (playing and buffering flags) and notifies when they change.
@@ -16,8 +16,7 @@ class PlayingStateManager {
   }
 
   func update(playWhenReady: Bool, state: PlaybackState) {
-    let newPlaying =
-      playWhenReady && !(state == .error || state == .ended || state == .none || state == .stopped)
+    let newPlaying = playWhenReady && !(state == .error || state == .ended || state == .none)
     let newBuffering = playWhenReady && (state == .loading || state == .buffering)
 
     if newPlaying != playing || newBuffering != buffering {

package/ios/Player/QueueManager.swift

@@ -1,6 +1,6 @@
 import Foundation
 #if canImport(NitroModules)
-  import NitroModules
+import NitroModules
 #endif
 
 /// Notifies the owner when the track list changes.
@@ -40,7 +40,7 @@ class QueueManager {
   }
 
   /// The shuffle order for randomized playback.
-  private(set) var shuffleOrder = ShuffleOrder()
+  private var shuffleOrder = ShuffleOrder()
 
   /// The repeat mode for the queue. Plain property — no side effects.
   var repeatMode: RepeatMode = .off
@@ -101,14 +101,6 @@ class QueueManager {
     return currentIndex == tracks.count - 1
   }
 
-  /// Whether `next()` would move to a distinct track — drives remote/CarPlay
-  /// next-button enablement. Shares `nextIndex` with `next()` so the button
-  /// state and the actual navigation can't diverge (shuffle/repeat-wrap aware).
-  var canNext: Bool { nextIndex != nil }
-
-  /// Whether `previous()` would move to a distinct track. Symmetric to `canNext`.
-  var canPrevious: Bool { previousIndex != nil }
-
   // MARK: - Validation
 
   private func throwIfQueueEmpty() throws {
@@ -121,69 +113,82 @@ class QueueManager {
     index: Int,
     name: String = "index",
     min: Int? = nil,
-    max: Int? = nil,
+    max: Int? = nil
   ) throws {
     guard index >= (min ?? 0), (max ?? tracks.count) > index else {
       throw TrackPlayerError.QueueError.invalidIndex(
         index: index,
-        message: "\(name) must be non-negative and less than \(tracks.count)",
+        message: "\(name) must be non-negative and less than \(tracks.count)"
       )
     }
   }
 
   // MARK: - Navigation (returns QueueNavigationResult)
 
-  /// The index `next()` will move to — a distinct track in playback order, or
-  /// nil when there's nowhere to go (empty/single-track queue, or a real end
-  /// with no wrap). Single source of truth shared by `next()` and `canNext`, so
-  /// the button state and the actual navigation can't disagree. Shuffle wraps
-  /// the order unconditionally (like Media3); sequential wraps only on repeat-all.
-  private var nextIndex: Int? {
-    guard currentTrack != nil, tracks.count > 1 else { return nil }
-    let candidate: Int? = if shuffleEnabled {
-      shuffleOrder.getNextIndex(after: currentIndex) ?? shuffleOrder.firstIndex
-    } else if currentIndex + 1 < tracks.count {
-      currentIndex + 1
-    } else {
-      repeatMode == .queue ? 0 : nil
+  /// Step to the next track in the queue.
+  func next() -> QueueNavigationResult {
+    guard currentTrack != nil, !tracks.isEmpty else { return .noChange }
+
+    if tracks.count == 1 {
+      return repeatMode == .queue ? .sameTrackReplay : .noChange
     }
-    guard let candidate, candidate != currentIndex else { return nil }
-    return candidate
-  }
 
-  /// The index `previous()` will move to. Symmetric to `nextIndex`.
-  private var previousIndex: Int? {
-    guard currentTrack != nil, tracks.count > 1 else { return nil }
-    let candidate: Int? = if shuffleEnabled {
-      shuffleOrder.getPreviousIndex(before: currentIndex) ?? shuffleOrder.lastIndex
-    } else if currentIndex - 1 >= 0 {
-      currentIndex - 1
+    var newIndex: Int?
+    if shuffleEnabled {
+      // Use shuffle order for navigation
+      newIndex = shuffleOrder.getNextIndex(after: currentIndex)
+      if newIndex == nil {
+        // Wrap to start of shuffle order unconditionally (same order, like Media3)
+        newIndex = shuffleOrder.firstIndex
+      }
     } else {
-      repeatMode == .queue ? tracks.count - 1 : nil
+      // Sequential navigation
+      let nextIdx = currentIndex + 1
+      if nextIdx < tracks.count {
+        newIndex = nextIdx
+      } else if repeatMode == .queue {
+        newIndex = 0
+      }
     }
-    guard let candidate, candidate != currentIndex else { return nil }
-    return candidate
-  }
 
-  /// Step to the next track in the queue.
-  func next() -> QueueNavigationResult {
-    guard currentTrack != nil, !tracks.isEmpty else { return .noChange }
-    if let nextIndex {
-      currentIndex = nextIndex
+    if let newIndex, newIndex != currentIndex {
+      currentIndex = newIndex
       return .trackChanged
     }
-    // No distinct next: single-track + repeat-all replays; otherwise a real end.
-    return tracks.count == 1 && repeatMode == .queue ? .sameTrackReplay : .noChange
+    return .noChange
   }
 
   /// Step to the previous track in the queue.
   func previous() -> QueueNavigationResult {
     guard currentTrack != nil, !tracks.isEmpty else { return .noChange }
-    if let previousIndex {
-      currentIndex = previousIndex
+
+    if tracks.count == 1 {
+      return repeatMode == .queue ? .sameTrackReplay : .noChange
+    }
+
+    var newIndex: Int?
+    if shuffleEnabled {
+      // Use shuffle order for navigation
+      newIndex = shuffleOrder.getPreviousIndex(before: currentIndex)
+      if newIndex == nil {
+        // Wrap to end of shuffle order unconditionally (same order, like Media3)
+        newIndex = shuffleOrder.lastIndex
+      }
+    } else {
+      // Sequential navigation
+      let prevIdx = currentIndex - 1
+      if prevIdx >= 0 {
+        newIndex = prevIdx
+      } else if repeatMode == .queue {
+        newIndex = tracks.count - 1
+      }
+    }
+
+    if let newIndex, newIndex != currentIndex {
+      currentIndex = newIndex
       return .trackChanged
     }
-    return tracks.count == 1 && repeatMode == .queue ? .sameTrackReplay : .noChange
+    return .noChange
   }
 
   /// Skip to a specific track in the queue.
@@ -234,12 +239,12 @@ class QueueManager {
     guard index >= 0, tracks.count >= index else {
       throw TrackPlayerError.QueueError.invalidIndex(
         index: index,
-        message: "Index to insert at has to be non-negative and equal to or smaller than the number of tracks: (\(tracks.count))",
+        message: "Index to insert at has to be non-negative and equal to or smaller than the number of tracks: (\(tracks.count))"
       )
     }
     let wasEmpty = tracks.isEmpty
     // Correct index when tracks were inserted in front of it:
-    if currentIndex >= 0, currentIndex >= index {
+    if tracks.count > 1, currentIndex >= index {
       currentIndex += newTracks.count
     }
     tracks.insert(contentsOf: newTracks, at: index)
@@ -278,19 +283,11 @@ class QueueManager {
     // Mutate a copy and assign once to trigger didSet only once
     var newTracks = tracks
     let track = newTracks.remove(at: fromIndex)
-    let insertion = min(newTracks.count, toIndex)
-    newTracks.insert(track, at: insertion)
+    newTracks.insert(track, at: min(newTracks.count, toIndex))
     tracks = newTracks
-    shuffleOrder.remove(from: fromIndex, to: fromIndex + 1)
-    shuffleOrder.insert(at: insertion, count: 1)
-    // The pointer follows the playing track; its identity never changes on a
-    // move, so no caller needs to reload (returning true reloads).
-    if currentIndex == fromIndex {
-      currentIndex = insertion
-    } else if fromIndex < currentIndex, insertion >= currentIndex {
-      currentIndex -= 1
-    } else if fromIndex > currentIndex, insertion <= currentIndex {
-      currentIndex += 1
+    if fromIndex == currentIndex {
+      currentIndex = toIndex
+      return true
     }
     return false
   }
@@ -302,7 +299,6 @@ class QueueManager {
     guard currentIndex != -1 else { return false }
     currentIndex = -1
     tracks.removeAll()
-    shuffleOrder.clear()
     queueSourcePath = nil
     return true
   }
@@ -319,8 +315,6 @@ class QueueManager {
     guard !tracks.isEmpty else { return }
     let nextIndex = currentIndex + 1
     guard nextIndex < tracks.count else { return }
-    let end = tracks.count
-    tracks.removeSubrange(nextIndex ..< end)
-    shuffleOrder.remove(from: nextIndex, to: end)
+    tracks.removeSubrange(nextIndex ..< tracks.count)
   }
 }