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

package/ios/Observer/PlayerTimeObserver.swift

@@ -2,28 +2,48 @@ import AVFoundation
 import Foundation
 
 /**
- Observes the player's audio-start boundary and invokes the callback passed at initialization.
+ Observes time-based player events and invokes callbacks passed at initialization.
  */
 @MainActor class PlayerTimeObserver {
   /// The time to use as start boundary time. Cannot be zero.
   private static let startBoundaryTime: CMTime = .init(value: 1, timescale: 1000)
 
   var boundaryTimeStartObserverToken: Any?
+  var periodicTimeObserverToken: Any?
 
   weak var avPlayer: AVPlayer? {
     willSet {
       unregisterForBoundaryTimeEvents()
+      unregisterForPeriodicEvents()
+    }
+  }
+
+  /// The frequency to receive periodic time events.
+  /// Setting this to a new value will trigger a re-registering to the periodic events of the
+  /// player.
+  var periodicObserverTimeInterval: CMTime {
+    didSet {
+      if oldValue != periodicObserverTimeInterval {
+        registerForPeriodicTimeEvents()
+      }
     }
   }
 
   private let onAudioDidStart: @MainActor () -> Void
+  private let onSecondElapsed: @MainActor (Double) -> Void
 
-  init(onAudioDidStart: @escaping @MainActor () -> Void) {
+  init(
+    periodicObserverTimeInterval: CMTime,
+    onAudioDidStart: @escaping @MainActor () -> Void,
+    onSecondElapsed: @escaping @MainActor (Double) -> Void,
+  ) {
+    self.periodicObserverTimeInterval = periodicObserverTimeInterval
     self.onAudioDidStart = onAudioDidStart
+    self.onSecondElapsed = onSecondElapsed
   }
 
   /**
-   Will register for the AVPlayer BoundaryTimeEvents, to trigger the audio-start event.
+   Will register for the AVPlayer BoundaryTimeEvents, to trigger start and complete events.
    */
   func registerForBoundaryTimeEvents() {
     guard let avPlayer else {
@@ -52,4 +72,34 @@ import Foundation
     avPlayer.removeTimeObserver(boundaryTimeStartObserverToken)
     self.boundaryTimeStartObserverToken = nil
   }
+
+  /**
+   Start observing periodic time events.
+   Will trigger unregisterForPeriodicEvents() first to avoid multiple subscriptions.
+   */
+  func registerForPeriodicTimeEvents() {
+    guard let avPlayer else {
+      return
+    }
+    unregisterForPeriodicEvents()
+    periodicTimeObserverToken = avPlayer.addPeriodicTimeObserver(
+      forInterval: periodicObserverTimeInterval,
+      queue: nil,
+      using: { [weak self] time in
+        let seconds = time.seconds
+        Task { @MainActor in self?.onSecondElapsed(seconds) }
+      },
+    )
+  }
+
+  /**
+   Unregister for periodic events.
+   */
+  func unregisterForPeriodicEvents() {
+    guard let avPlayer, let periodicTimeObserverToken else {
+      return
+    }
+    avPlayer.removeTimeObserver(periodicTimeObserverToken)
+    self.periodicTimeObserverToken = nil
+  }
 }

package/ios/Option/SessionCategories.swift

@@ -31,7 +31,11 @@ enum SessionCategoryPolicy: String {
     case .longFormAudio:
       .longFormAudio
     case .longFormVideo:
-      .longFormVideo
+      if #available(iOS 13.0, *) {
+        .longFormVideo
+      } else {
+        .longFormAudio
+      }
     }
   }
 }
@@ -59,7 +63,12 @@ enum SessionCategoryMode: String {
     case .voiceChat:
       .voiceChat
     case .voicePrompt:
-      .voicePrompt
+      if #available(iOS 12.0, *) {
+        .voicePrompt
+      } else {
+        // Do Nothing
+        .default
+      }
     }
   }
 }
@@ -89,35 +98,3 @@ enum SessionCategoryOptions: String {
     }
   }
 }
-
-extension NativeIOSSetupOptions {
-  /// The resolved `AVAudioSession` category configuration from the iOS setup options. Each field
-  /// falls back to a playback default when it's absent or unrecognised, so a consumer's
-  /// `categoryOptions` (e.g. `allowBluetooth` / `allowAirPlay`), `mode`, and route `policy` are
-  /// actually honoured at setup instead of being dropped.
-  func resolveAudioSessionConfig() -> (
-    category: AVAudioSession.Category,
-    mode: AVAudioSession.Mode,
-    policy: AVAudioSession.RouteSharingPolicy,
-    options: AVAudioSession.CategoryOptions,
-  ) {
-    let category = self.category
-      .flatMap { SessionCategory(rawValue: $0.stringValue) }?
-      .mapConfigToAVAudioSessionCategory() ?? .playback
-    let mode = self.categoryMode
-      .flatMap { SessionCategoryMode(rawValue: $0.stringValue) }?
-      .mapConfigToAVAudioSessionCategoryMode() ?? .default
-    let policy = self.categoryPolicy
-      .flatMap { SessionCategoryPolicy(rawValue: $0.stringValue) }?
-      .toRouteSharingPolicy() ?? .default
-    let options = (self.categoryOptions ?? [])
-      .reduce(into: AVAudioSession.CategoryOptions()) { acc, option in
-        if let mapped = SessionCategoryOptions(rawValue: option.stringValue)?
-          .mapConfigToAVAudioSessionCategoryOptions()
-        {
-          acc.insert(mapped)
-        }
-      }
-    return (category, mode, policy, options)
-  }
-}

package/ios/Player/LoadSeekCoordinator.swift

@@ -17,17 +17,6 @@ final class LoadSeekCoordinator {
   private let logger = Logger(subsystem: "com.audiobrowser", category: "LoadSeekCoordinator")
   private(set) var state: State = .idle
 
-  /// Identifies the item epoch a seek was issued against. `reset()` (called on
-  /// track/queue changes) bumps it, so the completion of a seek issued against
-  /// the previous item can recognize itself as stale and be dropped — a
-  /// cancelled cross-item completion arriving after the new track's start
-  /// position was captured would otherwise consume or prematurely resolve it.
-  private(set) var generation = 0
-
-  func isCurrentGeneration(_ generation: Int) -> Bool {
-    generation == self.generation
-  }
-
   /// Used by `seekBy()` to offset from the deferred position.
   var pendingTime: TimeInterval? {
     switch state {
@@ -60,12 +49,9 @@ final class LoadSeekCoordinator {
     state = .seekInFlight(time: time)
 
     let cmTime = CMTime(seconds: time, preferredTimescale: 1000)
-    let generation = generation
     player
-      .seek(to: cmTime, toleranceBefore: CMTime.zero, toleranceAfter: CMTime.zero) {
-        [weak self] finished in
+      .seek(to: cmTime, toleranceBefore: CMTime.zero, toleranceAfter: CMTime.zero) { finished in
         Task { @MainActor in
-          guard let self, self.isCurrentGeneration(generation) else { return }
           delegate?.handleSeekCompleted(to: time, didFinish: finished)
         }
       }
@@ -94,6 +80,5 @@ final class LoadSeekCoordinator {
 
   func reset() {
     state = .idle
-    generation += 1
   }
 }

package/ios/Player/MediaLoader.swift

@@ -12,10 +12,7 @@ struct MediaResolvedUrl {
 final class MediaLoader {
   private let logger = Logger(subsystem: "com.audiobrowser", category: "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)?
+  var mediaUrlResolver: ((String) async -> MediaResolvedUrl)?
 
   /// Internal access so TrackPlayer can read it for observer guards.
   private(set) var asset: AVURLAsset?
@@ -25,9 +22,7 @@ final class MediaLoader {
 
   weak var delegate: MediaLoaderDelegate?
 
-  /// The in-flight resolve. Readable so tests can await the resolve-then-load
-  /// chain instead of sleeping past it; only this type starts and cancels it.
-  private(set) var mediaResolverTask: Task<Void, Never>?
+  private var mediaResolverTask: Task<Void, Never>?
   private var metadataLoadTask: Task<Void, Never>?
   private var playableLoadTask: Task<Void, Never>?
   private var url: URL?
@@ -35,7 +30,7 @@ final class MediaLoader {
 
   // MARK: - Public API
 
-  func resolveAndLoad(src: String, track: Track? = nil) {
+  func resolveAndLoad(src: String) {
     if let resolver = mediaUrlResolver {
       mediaResolverTask?.cancel()
       mediaResolverTask = Task {
@@ -47,7 +42,7 @@ final class MediaLoader {
         }
 
         self.logger.debug("resolveAndLoad: calling resolver...")
-        let resolved = await resolver(src, track)
+        let resolved = await resolver(src)
 
         guard !Task.isCancelled else {
           self.logger.debug("resolveAndLoad: cancelled after resolver returned")
@@ -77,12 +72,7 @@ final class MediaLoader {
   }
 
   func loadAsset() {
-    guard let url else {
-      // Callers (reload-from-terminal) have already transitioned to .loading;
-      // a silent return would strand that state with no load in flight.
-      delegate?.mediaLoaderDidFailWithError(.invalidSourceUrl("nil"))
-      return
-    }
+    guard let url else { return }
     let pendingAsset = AVURLAsset(url: url, options: urlOptions)
     asset = pendingAsset
 
@@ -181,21 +171,6 @@ final class MediaLoader {
     asset = nil
   }
 
-  /// Builds AVURLAsset options, merging any explicit headers with a resolved
-  /// User-Agent. An explicit `User-Agent` in `headers` wins (mirrors the artwork
-  /// path in BrowserManager+URLResolution). A nil/empty userAgent contributes
-  /// nothing, so "no UA configured" still falls through to AVPlayer's default.
-  nonisolated static func buildAssetOptions(
-    headers: [String: String]?,
-    userAgent: String?,
-  ) -> [String: Any]? {
-    var merged = headers ?? [:]
-    if let userAgent, !userAgent.isEmpty, merged["User-Agent"] == nil {
-      merged["User-Agent"] = userAgent
-    }
-    return merged.isEmpty ? nil : ["AVURLAssetHTTPHeaderFieldsKey": merged]
-  }
-
   // MARK: - Private
 
   private func loadWithResolvedUrl(_ resolved: MediaResolvedUrl) {
@@ -205,9 +180,14 @@ final class MediaLoader {
       return
     }
 
+    var options: [String: Any] = [:]
+    if let headers = resolved.headers, !headers.isEmpty {
+      options["AVURLAssetHTTPHeaderFieldsKey"] = headers
+    }
+
     let isLocalFile = mediaUrl.isFileURL
     url = isLocalFile ? URL(fileURLWithPath: mediaUrl.path) : mediaUrl
-    urlOptions = Self.buildAssetOptions(headers: resolved.headers, userAgent: resolved.userAgent)
+    urlOptions = options.isEmpty ? nil : options
 
     logger.debug("  final playbackUrl: \(mediaUrl.absoluteString)")
     logger.debug("  isLocalFile: \(isLocalFile)")

package/ios/Player/NowPlayingUpdater.swift

@@ -3,153 +3,59 @@ import MediaPlayer
 import NitroModules
 import os.log
 
-/// Owns the now-playing surface: publishes a track's static fields + artwork, and renders the
-/// title/artist line — the formatter's result, or the track/override default. The single writer of
-/// the title/artist fields, with a publish-dedupe so the frequent re-renders stay cheap.
-///
-/// Does not exclusively own NowPlayingInfoController -- other callers (e.g. HybridAudioBrowser for
-/// overrides) can still access it directly.
+/// Does not exclusively own NowPlayingInfoController -- other callers
+/// (e.g. HybridAudioBrowser for overrides) can still access it directly.
 @MainActor
 final class NowPlayingUpdater {
   private let logger = Logger(subsystem: "com.audiobrowser", category: "NowPlayingUpdater")
   private let nowPlayingInfoController: NowPlayingInfoController
 
   var artworkUrlResolver: ((Track, ImageContext?) async -> ImageSource?)?
-  /// Invoked when the published title/artist actually change, so the owner can emit the JS
-  /// `onNowPlayingChanged` event (which it shapes with elapsed time / artwork / etc.).
-  var onChanged: (@MainActor (_ track: Track, _ title: String, _ artist: String?, _ album: String?) -> Void)?
 
   private var artworkLoadTask: Task<Void, Never>?
   private var artworkGeneration: UInt = 0
 
-  /// Last published text lines, to dedupe redundant writes (render runs on every transition).
-  private struct Published: Equatable {
-    let trackId: String?
-    let title: String?
-    let artist: String?
-    let album: String?
-  }
-
-  private var lastPublished: Published?
-
-  /// Bumped on every `render`; an async formatter result applies only if its render is still the
-  /// latest (latest-render-wins — drops a result whose track skipped or whose state moved on while
-  /// the formatter was in flight).
-  private var renderGeneration: UInt = 0
-
   init(nowPlayingInfoController: NowPlayingInfoController) {
     self.nowPlayingInfoController = nowPlayingInfoController
   }
 
-  /// 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
-  /// renders).
-  func loadMetaValues(for track: Track) {
+  func loadMetaValues(for track: Track, rate: Float) {
     nowPlayingInfoController.set(keyValues: [
+      MediaItemProperty.artist(track.artist),
+      MediaItemProperty.title(track.title),
+      MediaItemProperty.albumTitle(track.album),
+      NowPlayingInfoProperty.playbackRate(Double(rate)),
       NowPlayingInfoProperty.isLiveStream(track.live),
     ])
-    applyFields(track: track, title: track.title, artist: track.artist, album: track.album)
     loadArtwork(for: track)
   }
 
-  /// Renders the now-playing text lines (title, artist, album): the default (`override ?? track`)
-  /// 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.
-  func render(
-    track: Track,
-    timedMetadata: TimedMetadata?,
-    playWhenReady: Bool,
-    stalled: StallReason?,
-    error: PlaybackError?,
-    flash: NowPlayingUpdate? = nil,
-    override: NowPlayingUpdate?,
-    formatter: ((_ params: FormatNowPlayingParams) -> Promise<NowPlayingUpdate?>)?,
-  ) {
-    renderGeneration &+= 1
-    let generation = renderGeneration
-
-    let defaultTitle = override?.title ?? track.title
-    let defaultSecondary = override?.artist ?? track.artist
-    let defaultAlbum = override?.album ?? track.album
-
-    if let flash {
-      applyFields(
-        track: track,
-        title: flash.title ?? defaultTitle,
-        artist: flash.artist ?? defaultSecondary,
-        album: flash.album ?? defaultAlbum,
-      )
-      return
-    }
+  func updatePlaybackValues(duration: Double, rate: Float, currentTime: Double) {
+    logger.debug("updatePlaybackValues: duration=\(duration), rate=\(rate), currentTime=\(currentTime)")
+    nowPlayingInfoController.set(keyValues: [
+      MediaItemProperty.duration(duration),
+      NowPlayingInfoProperty.playbackRate(Double(rate)),
+      NowPlayingInfoProperty.elapsedPlaybackTime(currentTime),
+    ])
+  }
 
-    applyFields(track: track, title: defaultTitle, artist: defaultSecondary, album: defaultAlbum)
+  /// Separate from playbackRate — required for CarPlay to show correct play/pause button.
+  func updatePlaybackState(playWhenReady: Bool) {
+    let state: MPNowPlayingPlaybackState = playWhenReady ? .playing : .paused
+    logger.debug("updatePlaybackState: \(state.rawValue) (playWhenReady=\(playWhenReady))")
+    nowPlayingInfoController.setPlaybackState(state)
+  }
 
-    guard let formatter else { return }
-    let params = FormatNowPlayingParams(
-      track: track,
-      timedMetadata: timedMetadata,
-      playWhenReady: playWhenReady,
-      stalled: stalled,
-      error: error,
+  func setCurrentTime(seconds: Double) {
+    nowPlayingInfoController.set(
+      keyValue: NowPlayingInfoProperty.elapsedPlaybackTime(seconds),
     )
-    // `@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
-    // in `_swift_task_checkIsolated`). Hop back to the main actor to apply (same pattern as the
-    // artwork callback below).
-    formatter(params)
-      .then { @Sendable [weak self] formatted in
-        guard let self, let formatted else { return }
-        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,
-          )
-        }
-      }
-      .catch { @Sendable [weak self] error in
-        let message = error.localizedDescription
-        Task { @MainActor in
-          self?.logger.error("nowPlayingMetadataFormatter failed: \(message)")
-        }
-      }
   }
 
   // MARK: - Private
 
-  /// Stamps the title/artist/album (each falling back to the track's own) onto
-  /// NowPlayingInfoCenter, deduped against the last publish, and notifies `onChanged`.
-  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
-    let published = Published(
-      trackId: track.src ?? track.url,
-      title: resolvedTitle,
-      artist: resolvedArtist,
-      album: resolvedAlbum,
-    )
-    guard published != lastPublished else { return }
-    lastPublished = published
-
-    nowPlayingInfoController.set(keyValues: [
-      MediaItemProperty.title(resolvedTitle),
-      MediaItemProperty.artist(resolvedArtist),
-      MediaItemProperty.albumTitle(resolvedAlbum),
-    ])
-    onChanged?(track, resolvedTitle, resolvedArtist, resolvedAlbum)
-  }
-
   private func loadArtwork(for track: Track) {
-    // Now-playing is a single image with no appearance to key off, so a pair
-    // collapses to its dark URL (see `Variant_String_ArtworkVariants.url`).
-    let artworkUrl = track.artworkSource?.uri ?? track.artwork?.url
+    let artworkUrl = track.artworkSource?.uri ?? track.artwork
     logger.debug("loadArtwork: \(track.title), artworkUrl: \(artworkUrl ?? "nil")")
 
     // Now Playing artwork: use screen width in pixels, capped at 1200px
@@ -196,4 +102,5 @@ final class NowPlayingUpdater {
       }
     }
   }
+
 }