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

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),
     )
   }

package/ios/Player/NowPlayingLines.swift

@@ -0,0 +1,36 @@
+#if canImport(NitroModules)
+  import NitroModules
+#endif
+
+/// The title, artist and album lines the now-playing surface shows.
+struct NowPlayingLines: Equatable {
+  let title: String
+  let artist: String?
+  let album: String?
+
+  /// Each line from the first of `flash`, `formatted` and `override` that sets it, else the
+  /// track's own.
+  static func resolve(
+    track: Track,
+    flash: NowPlayingUpdate? = nil,
+    formatted: NowPlayingUpdate? = nil,
+    override: NowPlayingUpdate? = nil,
+  ) -> NowPlayingLines {
+    let layers = [flash, formatted, override].compactMap(\.self)
+    return NowPlayingLines(
+      title: layers.lazy.compactMap(\.title).first ?? track.title,
+      artist: layers.lazy.compactMap(\.artist).first ?? track.artist,
+      album: layers.lazy.compactMap(\.album).first ?? track.album,
+    )
+  }
+}
+
+/// What the now-playing surface renders from: the player's track and state.
+@MainActor
+protocol NowPlayingSource: AnyObject {
+  var currentTrack: Track? { get }
+  var currentTime: Double { get }
+  var playWhenReady: Bool { get }
+  var isStalled: Bool { get }
+  var nitroPlaybackError: PlaybackError? { get }
+}

package/ios/Player/NowPlayingUpdater.swift

@@ -3,16 +3,6 @@ import MediaPlayer
 import NitroModules
 import os.log
 
-/// What the now-playing surface renders from: the player's track and state.
-@MainActor
-protocol NowPlayingSource: AnyObject {
-  var currentTrack: Track? { get }
-  var currentTime: Double { get }
-  var playWhenReady: Bool { get }
-  var isStalled: Bool { get }
-  var nitroPlaybackError: PlaybackError? { get }
-}
-
 /// Owns the now-playing surface: publishes a track's static fields + artwork, and renders the
 /// title/artist line — a flash, else the formatter's result, else the override or the track's own
 /// fields. Holds that state (override, flash, latest timed metadata, formatter) and reports each
@@ -86,26 +76,10 @@ final class NowPlayingUpdater {
   }
 
   /// The metadata JS sees for the current track, before any formatter result.
+  /// Applies the override whether or not `enabled` is set.
   var nowPlaying: NowPlayingMetadata? {
     guard let track = source?.currentTrack else { return nil }
-    let lines = defaultLines(for: track)
-    return metadata(track: track, title: lines.title, artist: lines.artist, album: lines.album)
-  }
-
-  /// Re-renders the text lines for the current track and state. Called on every playback
-  /// transition; unchanged lines are not re-published.
-  func render() {
-    guard let source, let track = source.currentTrack else { return }
-    render(
-      track: track,
-      timedMetadata: timedMetadata,
-      playWhenReady: source.playWhenReady,
-      stalled: source.isStalled ? (isOnline ? .buffering : .offline) : nil,
-      error: source.nitroPlaybackError,
-      flash: flash,
-      override: enabled ? override : nil,
-      formatter: enabled ? formatter : nil,
-    )
+    return metadata(track: track, lines: .resolve(track: track, flash: flash, override: override))
   }
 
   /// Empties the now-playing surface and drops any artwork fetch or formatter result in flight.
@@ -148,11 +122,11 @@ final class NowPlayingUpdater {
   private static let maxArtworkPixelWidth: CGFloat = 1200
 
   /// Publishes the static, per-track fields + artwork on a track change. The title/artist/album
-  /// lines are owned by `render` (routed through `applyFields` here so it dedupes against later
+  /// lines are owned by `render` (routed through `apply` here so it dedupes against later
   /// renders).
   func loadMetaValues(for track: Track) {
     nowPlayingInfoController.set([MPNowPlayingInfoPropertyIsLiveStream: track.live])
-    applyFields(track: track, title: track.title, artist: track.artist, album: track.album)
+    apply(.resolve(track: track), for: track)
     loadArtwork(for: track)
   }
 
@@ -160,34 +134,19 @@ final class NowPlayingUpdater {
   /// immediately, then — when a formatter is configured — its async result overlaid (each field
   /// falling back to the default). A `flash` (transient line, e.g. feedback for a refused remote
   /// command) outranks both: while one is active the formatter pass is skipped entirely, so its
-  /// async result can't land on top. Safe to call on every playback transition; redundant writes
-  /// are deduped.
-  private func render(
-    track: Track,
-    timedMetadata: TimedMetadata?,
-    playWhenReady: Bool,
-    stalled: StallReason?,
-    error: PlaybackError?,
-    flash: NowPlayingUpdate?,
-    override: NowPlayingUpdate?,
-    formatter: ((_ params: FormatNowPlayingParams) -> Promise<NowPlayingUpdate?>)?,
-  ) {
+  /// async result can't land on top. Called on every playback transition; unchanged lines are not
+  /// re-published.
+  func render() {
+    guard let source, let track = source.currentTrack else { return }
+    let override = enabled ? self.override : nil
+    let formatter = enabled ? self.formatter : nil
     renderGeneration &+= 1
     let generation = renderGeneration
 
-    let defaultTitle = override?.title ?? track.title
-    let defaultSecondary = override?.artist ?? track.artist
-    let defaultAlbum = override?.album ?? track.album
-
     let trackId = track.identity ?? track.path
 
     if let flash {
-      applyFields(
-        track: track,
-        title: flash.title ?? defaultTitle,
-        artist: flash.artist ?? defaultSecondary,
-        album: flash.album ?? defaultAlbum,
-      )
+      apply(.resolve(track: track, flash: flash, override: override), for: track)
       // The flash replaced the formatter's line, so the surface no longer shows
       // one: the render that follows the flash reverting must publish the default
       // immediately rather than sit on stale flash text awaiting the formatter.
@@ -202,16 +161,16 @@ final class NowPlayingUpdater {
     // until the async result lands, since the two differ by construction on a live
     // stream (station name vs. song line).
     if formatter == nil || formattedTrackId != trackId {
-      applyFields(track: track, title: defaultTitle, artist: defaultSecondary, album: defaultAlbum)
+      apply(.resolve(track: track, override: override), for: track)
     }
 
     guard let formatter else { return }
     let params = FormatNowPlayingParams(
       track: track,
       timedMetadata: timedMetadata,
-      playWhenReady: playWhenReady,
-      stalled: stalled,
-      error: error,
+      playWhenReady: source.playWhenReady,
+      stalled: source.isStalled ? (isOnline ? .buffering : .offline) : nil,
+      error: source.nitroPlaybackError,
     )
     // `@Sendable` breaks the @MainActor isolation inheritance: Nitro resolves the promise on the JS
     // thread, so the resolver must NOT be main-isolated (a main-isolated closure run off-main traps
@@ -223,12 +182,7 @@ final class NowPlayingUpdater {
         Task { @MainActor in
           // Apply only if no newer render has superseded this one (fast skip / state moved on).
           guard self.renderGeneration == generation else { return }
-          self.applyFields(
-            track: track,
-            title: formatted.title ?? defaultTitle,
-            artist: formatted.artist ?? defaultSecondary,
-            album: formatted.album ?? defaultAlbum,
-          )
+          self.apply(.resolve(track: track, formatted: formatted, override: override), for: track)
           // A formatter result now owns the surface for this track, so later
           // renders skip the interim default write.
           self.formattedTrackId = trackId
@@ -244,21 +198,18 @@ final class NowPlayingUpdater {
 
   // MARK: - Private
 
-  /// Stamps the title/artist/album (each falling back to the track's own) onto the now-playing
-  /// surface, and notifies `onChanged` when the text or the track changed.
-  private func applyFields(track: Track, title: String?, artist: String?, album: String?) {
-    let resolvedTitle = title ?? track.title
-    let resolvedArtist = artist ?? track.artist
-    let resolvedAlbum = album ?? track.album
+  /// Stamps the lines onto the now-playing surface, and notifies `onChanged` when the text or the
+  /// track changed.
+  private func apply(_ lines: NowPlayingLines, for track: Track) {
     let textChanged = nowPlayingInfoController.set([
-      MPMediaItemPropertyTitle: resolvedTitle,
-      MPMediaItemPropertyArtist: resolvedArtist,
-      MPMediaItemPropertyAlbumTitle: resolvedAlbum,
+      MPMediaItemPropertyTitle: lines.title,
+      MPMediaItemPropertyArtist: lines.artist,
+      MPMediaItemPropertyAlbumTitle: lines.album,
     ])
     let trackId = track.identity ?? track.path
     guard textChanged || trackId != publishedTrackId else { return }
     publishedTrackId = trackId
-    onChanged?(metadata(track: track, title: resolvedTitle, artist: resolvedArtist, album: resolvedAlbum))
+    onChanged?(metadata(track: track, lines: lines))
   }
 
   private func cancelFlash() {
@@ -267,21 +218,12 @@ final class NowPlayingUpdater {
     flash = nil
   }
 
-  /// Flash over override over the track's own fields.
-  private func defaultLines(for track: Track) -> (title: String, artist: String?, album: String?) {
-    (
-      flash?.title ?? override?.title ?? track.title,
-      flash?.artist ?? override?.artist ?? track.artist,
-      flash?.album ?? override?.album ?? track.album,
-    )
-  }
-
-  private func metadata(track: Track, title: String, artist: String?, album: String?) -> NowPlayingMetadata {
+  private func metadata(track: Track, lines: NowPlayingLines) -> NowPlayingMetadata {
     NowPlayingMetadata(
       elapsedTime: source?.currentTime,
-      title: title,
-      album: album,
-      artist: artist,
+      title: lines.title,
+      album: lines.album,
+      artist: lines.artist,
       duration: track.duration,
       artwork: Self.jsArtwork(for: track),
       description: track.description,