react-native-audio-browser 0.2.0-next.30 → 0.2.0-next.32

package/ios/AVPlayerEngine.swift

@@ -17,7 +17,7 @@ final class AVPlayerEngine: PlayerEngine {
   let nowPlayingInfoController: NowPlayingInfoController
   let nowPlayingUpdater: NowPlayingUpdater
   let remoteCommandController: RemoteCommandController
-  private let mediaLoader = MediaLoader()
+  private let mediaLoader: MediaLoader
   private let silentAudioPrimer = SilentAudioPrimer()
 
   private var avPlayer = AVPlayer()
@@ -40,11 +40,11 @@ final class AVPlayerEngine: PlayerEngine {
     self.nowPlayingInfoController = nowPlayingInfoController
     nowPlayingUpdater = NowPlayingUpdater(nowPlayingInfoController: nowPlayingInfoController)
     remoteCommandController = RemoteCommandController(callbacks: callbacks)
-
-    mediaLoader.onEvent = { [weak self] in self?.mediaLoaderDidEmit($0) }
-    mediaLoader.mediaUrlResolver = { [weak resolver] src, track in
+    mediaLoader = MediaLoader { [weak resolver] src, track in
       await resolver?.resolveMediaUrl(src, track: track) ?? MediaResolvedUrl(url: src, headers: nil, userAgent: nil)
     }
+
+    mediaLoader.onEvent = { [weak self] in self?.mediaLoaderDidEmit($0) }
     nowPlayingUpdater.artworkUrlResolver = { [weak resolver] track, imageContext in
       await resolver?.resolveNowPlayingArtwork(track: track, imageContext: imageContext)
     }
@@ -318,10 +318,6 @@ final class AVPlayerEngine: PlayerEngine {
   }
 }
 
-extension Player: AudioSessionPlayer {}
-
-extension Player: NowPlayingSource {}
-
 /// Resolves the URLs the player fetches.
 @MainActor
 protocol MediaResolving: AnyObject {

package/ios/Browser/JsonModels.swift

@@ -258,11 +258,9 @@ struct JsonTrackRequest: Codable {
   let headers: [String: String]?
   let query: [String: String]?
 
-  #if canImport(NitroModules)
-    func toNitro() -> TrackRequest {
-      TrackRequest(userAgent: userAgent, headers: headers, query: query)
-    }
-  #endif
+  func toNitro() -> TrackRequest {
+    TrackRequest(userAgent: userAgent, headers: headers, query: query)
+  }
 }
 
 /// JSON model for resolved track (container with children).
@@ -391,191 +389,104 @@ struct JsonTrack: Codable {
 
 // MARK: - Snapshot live Nitro types back to JSON models (for persistence)
 
-#if canImport(NitroModules)
-
-  extension JsonTrackRequest {
-    /// Snapshot a live TrackRequest back to its JSON model.
-    init(from request: TrackRequest) {
-      self.init(userAgent: request.userAgent, headers: request.headers, query: request.query)
-    }
-  }
-
-  extension JsonTrack {
-    /// Snapshot the persistable subset of a live Track (inverse of `toNitro()`).
-    /// The track's own declared style block and `disabled` persist (ADR 0011);
-    /// section/page-inherited values are never stamped onto tracks and
-    /// re-resolve at render, exactly as they do live.
-    init(from track: Track) {
-      self.init(
-        id: track.id,
-        path: track.path,
-        title: track.title,
-        subtitle: track.subtitle,
-        artwork: JsonArtwork(track.artwork),
-        artist: track.artist,
-        albumPath: track.albumPath,
-        album: track.album,
-        description: track.description,
-        genre: track.genre,
-        duration: track.duration,
-        src: track.src,
-        request: track.request.map(JsonTrackRequest.init(from:)),
-        style: JsonStyle(track.style),
-        disabled: track.disabled,
-        live: track.live,
-        icyCharset: track.icyCharset,
-      )
-    }
-  }
-
-#else
-
-  extension JsonTrackRequest {
-    /// Snapshot a live TrackRequest back to its JSON model (SPM test-target stub).
-    init(from request: TrackRequest) {
-      self.init(userAgent: request.userAgent, headers: request.headers, query: request.query)
-    }
+extension JsonTrackRequest {
+  /// Snapshot a live TrackRequest back to its JSON model.
+  init(from request: TrackRequest) {
+    self.init(userAgent: request.userAgent, headers: request.headers, query: request.query)
   }
+}
 
-  extension JsonTrack {
-    /// Snapshot the persistable subset of a live Track (inverse of `toNitro()`).
-    /// SPM test-target stub — only fields present on the minimal `Track` stub.
-    init(from track: Track) {
-      self.init(
-        id: track.id,
-        path: track.path,
-        title: track.title,
-        artwork: JsonArtwork(track.artwork),
-        artist: track.artist,
-        albumPath: track.albumPath,
-        album: track.album,
-        src: track.src,
-        request: track.request.map(JsonTrackRequest.init(from:)),
-        style: JsonStyle(track.style),
-        disabled: track.disabled,
-        live: track.live,
-        icyCharset: track.icyCharset,
-      )
-    }
+extension JsonTrack {
+  /// Snapshot the persistable subset of a live Track (inverse of `toNitro()`).
+  /// The track's own declared style block and `disabled` persist (ADR 0011);
+  /// section/page-inherited values are never stamped onto tracks and
+  /// re-resolve at render, exactly as they do live.
+  init(from track: Track) {
+    self.init(
+      id: track.id,
+      path: track.path,
+      title: track.title,
+      subtitle: track.subtitle,
+      artwork: JsonArtwork(track.artwork),
+      artist: track.artist,
+      albumPath: track.albumPath,
+      album: track.album,
+      description: track.description,
+      genre: track.genre,
+      duration: track.duration,
+      src: track.src,
+      request: track.request.map(JsonTrackRequest.init(from:)),
+      style: JsonStyle(track.style),
+      disabled: track.disabled,
+      live: track.live,
+      icyCharset: track.icyCharset,
+    )
   }
-
-#endif
+}
 
 // MARK: - Convert JSON models to Nitro types
 
-#if canImport(NitroModules)
-
-  extension JsonSection {
-    func toNitro() -> Section {
-      Section(
-        title: title,
-        style: style?.toSectionStyle(),
-        path: path,
-        children: children.map { $0.toNitro() },
-      )
-    }
-  }
-
-  extension JsonResolvedTrack {
-    func toNitro() -> ResolvedTrack {
-      ResolvedTrack(
-        path: path,
-        style: style?.toSectionStyle(),
-        sections: sections?.map { $0.toNitro() },
-        children: children?.map { $0.toNitro() },
-        carPlaySiriListButton: carPlaySiriListButton.flatMap { CarPlaySiriListButtonPosition(fromString: $0) },
-        id: id,
-        src: src,
-        artwork: artwork?.toNitro(),
-        artworkSource: nil, request: nil,
-        title: title,
-        subtitle: subtitle,
-        artist: artist,
-        albumPath: albumPath,
-        album: album,
-        description: description,
-        genre: genre,
-        duration: duration,
-        disabled: disabled,
-        favorited: nil,
-        live: live,
-        icyCharset: icyCharset,
-      )
-    }
-  }
-
-  extension JsonTrack {
-    func toNitro() -> Track {
-      Track(
-        id: id,
-        path: path,
-        src: src,
-        artwork: artwork?.toNitro(),
-        artworkSource: nil,
-        request: request?.toNitro(),
-        title: title,
-        subtitle: subtitle,
-        artist: artist,
-        albumPath: albumPath,
-        album: album,
-        description: description,
-        genre: genre,
-        duration: duration,
-        style: style?.toTrackStyle(),
-        disabled: disabled,
-        favorited: nil,
-        live: live,
-        icyCharset: icyCharset,
-      )
-    }
-  }
-
-#else
-
-  // Test-only path: construct minimal stubs for SPM test builds.
-  extension JsonTrack {
-    func toNitro() -> Track {
-      Track(
-        id: id ?? "",
-        path: path,
-        src: src,
-        artwork: artwork?.toNitro(),
-        request: request.map { TrackRequest(userAgent: $0.userAgent, headers: $0.headers, query: $0.query) },
-        title: title,
-        artist: artist,
-        albumPath: albumPath,
-        album: album,
-        style: style?.toTrackStyle(),
-        disabled: disabled,
-        live: live,
-        icyCharset: icyCharset,
-      )
-    }
+extension JsonSection {
+  func toNitro() -> Section {
+    Section(
+      title: title,
+      style: style?.toSectionStyle(),
+      path: path,
+      children: children.map { $0.toNitro() },
+    )
   }
+}
 
-  extension JsonSection {
-    func toNitro() -> Section {
-      Section(
-        title: title,
-        style: style?.toSectionStyle(),
-        path: path,
-        children: children.map { $0.toNitro() },
-      )
-    }
+extension JsonResolvedTrack {
+  func toNitro() -> ResolvedTrack {
+    ResolvedTrack(
+      path: path,
+      style: style?.toSectionStyle(),
+      sections: sections?.map { $0.toNitro() },
+      children: children?.map { $0.toNitro() },
+      carPlaySiriListButton: carPlaySiriListButton.flatMap { CarPlaySiriListButtonPosition(fromString: $0) },
+      id: id,
+      src: src,
+      artwork: artwork?.toNitro(),
+      artworkSource: nil, request: nil,
+      title: title,
+      subtitle: subtitle,
+      artist: artist,
+      albumPath: albumPath,
+      album: album,
+      description: description,
+      genre: genre,
+      duration: duration,
+      disabled: disabled,
+      favorited: nil,
+      live: live,
+      icyCharset: icyCharset,
+    )
   }
+}
 
-  extension JsonResolvedTrack {
-    func toNitro() -> ResolvedTrack {
-      ResolvedTrack(
-        path: path,
-        style: style?.toSectionStyle(),
-        sections: sections?.map { $0.toNitro() },
-        children: children?.map { $0.toNitro() },
-        artwork: artwork?.toNitro(),
-        title: title,
-        disabled: disabled,
-      )
-    }
+extension JsonTrack {
+  func toNitro() -> Track {
+    Track(
+      id: id,
+      path: path,
+      src: src,
+      artwork: artwork?.toNitro(),
+      artworkSource: nil,
+      request: request?.toNitro(),
+      title: title,
+      subtitle: subtitle,
+      artist: artist,
+      albumPath: albumPath,
+      album: album,
+      description: description,
+      genre: genre,
+      duration: duration,
+      style: style?.toTrackStyle(),
+      disabled: disabled,
+      favorited: nil,
+      live: live,
+      icyCharset: icyCharset,
+    )
   }
-
-#endif
+}

package/ios/HybridAudioBrowser+Player.swift

@@ -131,7 +131,7 @@ public extension HybridAudioBrowser {
 
   func getSleepTimer() throws -> SleepTimer {
     onMainActor {
-      player?.sleepTimer ?? .first(NullType.null)
+      player?.sleepTimerManager.get() ?? .first(NullType.null)
     }
   }
 
@@ -227,7 +227,7 @@ public extension HybridAudioBrowser {
       browserManager.setFavorited(identity: identity, favorited: favorited)
       // Back in the queue carrying the flag, since hydration never overrides a track's own value.
       let updated = track.copying(favorited: favorited)
-      try player.replace(player.currentIndex, updated)
+      try player.replace(player.queue.currentIndex, updated)
       // The only emit: a favorite toggle mutates the active track in place, so
       // onPlaybackActiveTrackChanged stays transition-only.
       favoriteChangedEmitter.emit(FavoriteChangedEvent(track: updated, favorited: favorited))
@@ -271,7 +271,7 @@ public extension HybridAudioBrowser {
 
   func getActiveTrackIndex() throws -> Double? {
     onMainActor {
-      guard let index = player?.currentIndex, index >= 0 else { return nil }
+      guard let index = player?.queue.currentIndex, index >= 0 else { return nil }
       return Double(index)
     }
   }

package/ios/HybridAudioBrowser+PlayerCallbacks.swift

@@ -52,12 +52,11 @@ extension HybridAudioBrowser: PlayerCallbacks, AVPlayerEngineCallbacks {
     // can be set at setup (before any track) while output only begins here. Idempotent:
     // `setActive(true)` is a no-op when the session is already active.
     if state.playing || state.buffering {
-      audioSession.activate()
       // The now-playing session's activation request at link time predates this
       // (the audio session was still inactive, and the system may have declined);
-      // re-request now so the surface can appear even if playback never produces
-      // audio (first-ever load failing on a dead stream).
-      engine?.reactivateNowPlayingSession()
+      // re-request once the audio session is active, so the surface can appear even if
+      // playback never produces audio (first-ever load failing on a dead stream).
+      audioSession.activate { [weak self] in self?.engine?.reactivateNowPlayingSession() }
     }
     // A stall starting or recovering may not change the Player state.
     engine?.nowPlayingUpdater.render()

package/ios/Model/NitroTypeStubs.swift

@@ -28,6 +28,8 @@
     var query: [String: String]?
   }
 
+  /// Every property of the generated type, in its init's order, so the shared conversions in
+  /// JsonModels compile against both.
   struct Track: Equatable {
     var id: String?
     var path: String?
@@ -36,15 +38,26 @@
     var artworkSource: ImageSource?
     var request: TrackRequest?
     var title: String = ""
+    var subtitle: String?
     var artist: String?
     var albumPath: String?
     var album: String?
+    var description: String?
+    var genre: String?
+    var duration: Double?
     var style: TrackStyle?
     var disabled: Bool?
+    var favorited: Bool?
     var live: Bool?
     var icyCharset: String?
   }
 
+  struct NowPlayingUpdate: Equatable {
+    var title: String?
+    var artist: String?
+    var album: String?
+  }
+
   struct TrackLoadEvent {
     var track: Track
     var queue: [Track]

package/ios/Player/AudioSessionController.swift

@@ -12,6 +12,8 @@ protocol AudioSessionPlayer: AnyObject {
   func mediaServicesWereReset()
 }
 
+extension Player: AudioSessionPlayer {}
+
 /// Owns the app's `AVAudioSession`: its category, activation and release, and the interruption,
 /// route-change, media-services-reset and volume observers, installed once at init.
 ///
@@ -35,6 +37,11 @@ final class AudioSessionController {
 
   private var releaseWork: DispatchWorkItem?
 
+  /// Where `setActive` runs: it blocks until the system has changed the session, which can take
+  /// long enough to stall the main thread. Serial, so a release and a quick re-activation keep
+  /// their order.
+  private let activationQueue = DispatchQueue(label: "com.audiobrowser.audio-session", qos: .userInitiated)
+
   /// Touched only by `init` and `deinit`.
   private nonisolated(unsafe) var observers: [NSObjectProtocol] = []
   private var volumeObservation: NSKeyValueObservation?
@@ -86,10 +93,14 @@ final class AudioSessionController {
     applyCategory()
   }
 
-  /// Activates the session for output and cancels a pending release.
-  func activate() {
-    try? session.setActive(true)
+  /// Activates the session for output and cancels a pending release. `then` runs on the main
+  /// actor once the activation has run, whether or not it succeeded.
+  func activate(then: (@MainActor @Sendable () -> Void)? = nil) {
     cancelRelease()
+    activationQueue.async {
+      try? AVAudioSession.sharedInstance().setActive(true)
+      if let then { Task { @MainActor in then() } }
+    }
   }
 
   /// Releases the session after 3 s unless playback resumes, so other apps' audio can come back.
@@ -100,7 +111,9 @@ final class AudioSessionController {
     let release = DispatchWorkItem { [weak self] in
       guard let self, player?.playWhenReady == false else { return }
       releaseWork = nil
-      try? session.setActive(false, options: .notifyOthersOnDeactivation)
+      activationQueue.async {
+        try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+      }
     }
     releaseWork = release
     DispatchQueue.main.asyncAfter(deadline: .now() + 3, execute: release)
@@ -155,12 +168,13 @@ final class AudioSessionController {
       player?.handleInterruptionBegan()
     case .ended:
       let shouldResume = options.map { AVAudioSession.InterruptionOptions(rawValue: $0).contains(.shouldResume) } ?? false
-      // Reactivate only when a resume follows: activating while staying paused would hold a
-      // non-mixable session with nothing to release it.
+      // Reactivate only when a resume follows, and resume once it is active: activating while
+      // staying paused would hold a non-mixable session with nothing to release it.
       if shouldResume, player?.willResumeAfterInterruption == true {
-        try? session.setActive(true)
+        activate { [weak self] in self?.player?.handleInterruptionEnded(shouldResume: true) }
+      } else {
+        player?.handleInterruptionEnded(shouldResume: shouldResume)
       }
-      player?.handleInterruptionEnded(shouldResume: shouldResume)
     @unknown default:
       break
     }

package/ios/Player/ErrorStatus.swift

@@ -7,12 +7,13 @@
 enum ErrorStatus: Equatable {
   case none
   case retrying(TrackPlayerError.PlaybackError)
-  case terminal(TrackPlayerError.PlaybackError)
+  /// `report` tells each terminal report from the last, so a repeat of the same error is a change.
+  case terminal(TrackPlayerError.PlaybackError, report: UInt)
 
   var error: TrackPlayerError.PlaybackError? {
     switch self {
     case .none: nil
-    case let .retrying(error), let .terminal(error): error
+    case let .retrying(error), let .terminal(error, _): error
     }
   }
 
@@ -24,4 +25,26 @@ enum ErrorStatus: Equatable {
   var nitroError: PlaybackError? {
     error?.toNitroError(retrying: isRetrying)
   }
+
+  /// The status once `event` moves the state from `old` to `new`: an error event is a new
+  /// terminal report; leaving `.error`, or reaching a state without an advisory error, clears it.
+  func after(event: PlaybackEvent, from old: PlaybackState, to new: PlaybackState) -> ErrorStatus {
+    if case let .errorOccurred(error) = event {
+      return .terminal(error, report: terminalReport &+ 1)
+    }
+    if old == .error || (isRetrying && !new.carriesAdvisoryError) { return .none }
+    return self
+  }
+
+  private var terminalReport: UInt {
+    if case let .terminal(_, report) = self { report } else { 0 }
+  }
+}
+
+extension PlaybackState {
+  /// Whether a retrying error shows over this state: the listener is waiting on it, and no audio
+  /// is playing to contradict it.
+  var carriesAdvisoryError: Bool {
+    self == .loading || self == .buffering || self == .paused
+  }
 }

package/ios/Player/MediaLoader.swift

@@ -15,7 +15,11 @@ final class MediaLoader {
   /// Resolves a playback src into a concrete URL + headers/user-agent.
   /// The `Track` is threaded through so the resolver can invoke the
   /// consumer-supplied `media.resolve(track)` as the final media layer.
-  var mediaUrlResolver: ((String, Track?) async -> MediaResolvedUrl)?
+  private let resolveUrl: (String, Track?) async -> MediaResolvedUrl
+
+  init(resolveUrl: @escaping (String, Track?) async -> MediaResolvedUrl) {
+    self.resolveUrl = resolveUrl
+  }
 
   /// Internal access so AVPlayerEngine can read it.
   private(set) var asset: AVURLAsset?
@@ -47,51 +51,14 @@ final class MediaLoader {
   // MARK: - Public API
 
   func resolveAndLoad(src: String, track: Track? = nil) {
-    if let resolver = mediaUrlResolver {
-      mediaResolverTask?.cancel()
-      // `[weak self]` like the sibling load tasks below: the resolver is
-      // consumer-supplied and `cancelAll()` cannot force an in-flight `await`
-      // to return, so a strong capture let a resolver that never settles pin
-      // this loader (which also retains the task) indefinitely.
-      // `Logger` is a value type, so capturing it directly keeps the logging
-      // off `self` — and `self` weak, so a consumer resolver that never settles
-      // can't pin the loader (`cancelAll()` can't force an in-flight `await` to
-      // return).
-      let logger = logger
-      mediaResolverTask = Task { [weak self] in
-        logger.debug("resolveAndLoad: starting resolution for \(src)")
-
-        guard !Task.isCancelled else {
-          logger.debug("resolveAndLoad: cancelled before start")
-          return
-        }
-
-        logger.debug("resolveAndLoad: calling resolver...")
-        let resolved = await resolver(src, track)
-
-        guard !Task.isCancelled, let self else {
-          logger.debug("resolveAndLoad: cancelled after resolver returned")
-          return
-        }
-
-        self.logger.debug("resolveAndLoad: resolver returned, resolved URL: \(resolved.url)")
-        if let headers = resolved.headers {
-          self.logger.debug("  headers: \(headers)")
-        }
-        if let userAgent = resolved.userAgent {
-          self.logger.debug("  userAgent: \(userAgent)")
-        }
-
-        await MainActor.run {
-          guard !Task.isCancelled else {
-            self.logger.debug("resolveAndLoad: cancelled before loadWithResolvedUrl")
-            return
-          }
-          self.loadWithResolvedUrl(resolved)
-        }
-      }
-    } else {
-      let resolved = MediaResolvedUrl(url: src, headers: nil, userAgent: nil)
+    mediaResolverTask?.cancel()
+    // `self` stays weak across the await: a consumer resolver that never settles must not pin
+    // the loader, and cancellation cannot force its `await` to return.
+    let resolveUrl = resolveUrl
+    mediaResolverTask = Task { [weak self] in
+      guard !Task.isCancelled else { return }
+      let resolved = await resolveUrl(src, track)
+      guard !Task.isCancelled, let self else { return }
       loadWithResolvedUrl(resolved)
     }
   }
@@ -149,28 +116,17 @@ final class MediaLoader {
 
       do {
         let isPlayable = try await pendingAsset.load(.isPlayable)
-
-        guard !Task.isCancelled else { return }
-
-        await MainActor.run {
-          guard pendingAsset == self.asset else { return }
-
-          if !isPlayable {
-            self.onEvent?(.unplayable)
-            return
-          }
-
-          let avItem = AVPlayerItem(asset: pendingAsset)
-          avItem.preferredForwardBufferDuration = self.bufferDuration / 1000.0
-          self.onEvent?(.prepared(avItem))
+        guard isCurrent(pendingAsset) else { return }
+        guard isPlayable else {
+          onEvent?(.unplayable)
+          return
         }
+        let avItem = AVPlayerItem(asset: pendingAsset)
+        avItem.preferredForwardBufferDuration = bufferDuration / 1000.0
+        onEvent?(.prepared(avItem))
       } catch {
-        guard !Task.isCancelled else { return }
-
-        await MainActor.run {
-          guard pendingAsset == self.asset else { return }
-          self.onEvent?(.failed(error))
-        }
+        guard isCurrent(pendingAsset) else { return }
+        onEvent?(.failed(error))
       }
     }
   }
@@ -232,12 +188,8 @@ final class MediaLoader {
       return
     }
 
-    let isLocalFile = mediaUrl.isFileURL
-    logger.debug("  final playbackUrl: \(mediaUrl.absoluteString)")
-    logger.debug("  isLocalFile: \(isLocalFile)")
-
     loadAsset(
-      url: isLocalFile ? URL(fileURLWithPath: mediaUrl.path) : mediaUrl,
+      url: mediaUrl.isFileURL ? URL(fileURLWithPath: mediaUrl.path) : mediaUrl,
       options: Self.buildAssetOptions(headers: resolved.headers, userAgent: resolved.userAgent),
     )
   }