react-native-audio-browser 0.2.0-next.28 → 0.2.0-next.29

package/ios/HybridAudioBrowser+Browser.swift

@@ -0,0 +1,153 @@
+import AVFoundation
+import AVKit
+import Foundation
+import MediaPlayer
+import NitroModules
+import os.log
+
+public extension HybridAudioBrowser {
+  /// Navigates the in-app browser, reporting a failure as the navigation error. A clear is
+  /// synchronous: JS hears it before the navigation that may set the error again.
+  internal func navigate(_ path: String, clearError: Bool) {
+    if clearError { onMainActor { navigationError.clear() } }
+    Task { @MainActor in
+      do {
+        try await browserManager.load(path)
+      } catch {
+        await reportNavigationError(error, path: path)
+      }
+    }
+  }
+
+  @MainActor
+  private func reportNavigationError(_ error: Error, path: String) async {
+    await navigationError.report(NavigationError.from(error)) { [browserManager] in
+      await browserManager.formatted($0, path: path)
+    }
+  }
+
+  // MARK: - Browser Methods
+
+  func navigatePath(path: String) throws {
+    navigate(path, clearError: true)
+  }
+
+  func navigateTrack(track: Track) throws {
+    // @MainActor: `player` is main-confined, and `trackSelector.select` is
+    // MainActor anyway — a bare Task read the reference off the cooperative
+    // pool, racing the assignment in `setupPlayer`.
+    Task { @MainActor in
+      guard let player else { return }
+      let result = await trackSelector.select(track: track, player: player)
+      switch result {
+      case let .play(intent):
+        player.execute(intent)
+      case .intercepted:
+        break
+      case let .browse(path):
+        navigate(path, clearError: true)
+      case .none:
+        break
+      }
+    }
+  }
+
+  func search(query: String) throws -> Promise<[Track]> {
+    Promise.async { [weak self] in
+      guard let self else { return [] }
+      let resolved = try await browserManager.search(query)
+      return resolved.flattenedChildren ?? []
+    }
+  }
+
+  func getContent() throws -> ResolvedTrack? {
+    onMainActor { browserManager.content }
+  }
+
+  func getNavigationError() throws -> NavigationError? {
+    onMainActor { navigationError.error }
+  }
+
+  func getFormattedNavigationError() throws -> FormattedNavigationError? {
+    onMainActor { navigationError.formatted }
+  }
+
+  /// Internal signal sent on `externalContentChangedEmitter` to tell CarPlay to
+  /// refresh every displayed template. Not a real path (paths are always
+  /// `/…`), so it can't collide with one; kept internal — the public API is
+  /// `invalidateAllContent()`.
+  internal static let invalidateAllSentinel = "__rnab_invalidate_all__"
+
+  func notifyContentChanged(path: String) throws {
+    // Throws on a contextual path (matching Android's `require`) — the caller
+    // must pass the container path, or the invalidation silently hits nothing.
+    try onMainActor { try browserManager.invalidateContentCache(path) }
+
+    // Notify external controllers (CarPlay) that content changed
+    externalContentChangedEmitter.emit(path)
+
+    // Re-resolve the path if it's the current browser path
+    if onMainActor({ browserManager.path }) == path {
+      navigate(path, clearError: false)
+    }
+  }
+
+  func invalidateAllContent() throws {
+    onMainActor { browserManager.clearContentCache() }
+
+    // Tell external controllers (CarPlay) to refresh every displayed template.
+    externalContentChangedEmitter.emit(Self.invalidateAllSentinel)
+
+    // Re-query the tabs source too: a callback source can resolve to new
+    // titles after an invalidation (e.g. a locale switch). BrowserManager
+    // emits tabsChanged only when the result actually differs, and a failed
+    // re-query keeps the current tabs. (Android needs no equivalent — its
+    // root re-query already runs queryTabs(); the web stub re-queries tabs on
+    // the re-navigation.)
+    Task {
+      _ = try? await browserManager.queryTabs()
+    }
+
+    // Re-resolve the JS-facing current path with the cache cleared.
+    Task { @MainActor in
+      do {
+        try await browserManager.load(browserManager.path, bypassCache: true)
+      } catch {
+        await reportNavigationError(error, path: browserManager.path)
+      }
+    }
+  }
+
+  func setFavorites(favorites: [String]) throws {
+    onMainActor { browserManager.setFavorites(favorites) }
+  }
+
+  // MARK: - Gate
+
+  func setGate(gate: Gate?, hasResolver: Bool) throws {
+    onMainActor { browseGate.set(chrome: gate, hasResolver: hasResolver) }
+  }
+
+  func clearGate() throws {
+    onMainActor { browseGate.clear() }
+  }
+
+  // MARK: - Car Connection (CarPlay)
+
+  /// Static because the CarPlay scene can connect before the JS runtime
+  /// creates the shared instance (cold start in the car).
+  internal nonisolated(unsafe) static var carPlayConnected = false
+
+  /// Called by the CarPlay scene delegate (via `RNABCarPlayController`) on
+  /// scene connect/disconnect — not from controller start/stop, which also
+  /// cycle on a JS reload and would emit spurious connection changes.
+  internal static func setCarPlayConnected(_ connected: Bool) {
+    guard carPlayConnected != connected else { return }
+    carPlayConnected = connected
+    shared?.onCarConnectedChanged(connected)
+  }
+
+  func isCarConnected() throws -> Bool {
+    HybridAudioBrowser.carPlayConnected
+  }
+}

package/ios/HybridAudioBrowser+Options.swift

@@ -0,0 +1,144 @@
+import AVFoundation
+import AVKit
+import Foundation
+import MediaPlayer
+import NitroModules
+import os.log
+
+public extension HybridAudioBrowser {
+  // MARK: - Player Setup
+
+  func setupPlayer(options: NativeSetupPlayerOptions) throws -> Promise<Void> {
+    Promise.async {
+      // Create player and configure on main actor
+      await MainActor.run { [weak self] in
+        guard let self else { return }
+        // Set the category now, but activate only when playback produces output.
+        self.audioSession.configure(options.ios)
+
+        // A re-setup REPLACES the player, so the outgoing one has to be torn down
+        // and un-published first. No-op on first setup.
+        destroyPlayer()
+
+        let newEngine = AVPlayerEngine(callbacks: self, resolver: browserManager.requests)
+        if let buffer = options.ios?.buffer { newEngine.bufferDuration = buffer }
+        newEngine.nowPlayingUpdater.enabled = options.autoUpdateNowPlayingMetadata ?? true
+        newEngine.nowPlayingUpdater.formatter = options.nowPlayingMetadataFormatter
+        newEngine.nowPlayingUpdater.isOnline = networkMonitor.isOnline
+        let newPlayer = Player(engine: newEngine)
+        newPlayer.callbacks = self
+        newPlayer.retry.networkMonitor = networkMonitor
+        if let retry = options.retry { newPlayer.retry.updatePolicy(from: retry) }
+        newEngine.nowPlayingUpdater.source = newPlayer
+        engine = newEngine
+        player = newPlayer
+        audioSession.player = newPlayer
+
+        // Connectivity fans out here, whether or not JS subscribes: the JS event, the
+        // now-playing stall line, and reconnecting a stalled stream. The monitor mutates on main.
+        networkMonitor.onChanged = { [weak self] isOnline in
+          MainActor.assumeIsolated {
+            self?.onOnlineChanged(isOnline)
+            self?.engine?.nowPlayingUpdater.isOnline = isOnline
+            if isOnline { self?.player?.networkDidReturn() }
+          }
+        }
+
+        // `options.keepSessionAliveOnError` is deliberately ignored here: iOS needs no masking.
+        // A terminal error keeps the now-playing info (never cleared on error), and next/previous
+        // stay enabled (gated on queue position, not state). So the
+        // session stays controllable through errors by default — the behavior Android achieves via
+        // InterceptingPlayer is already the iOS norm.
+
+        // The bundled runtime options and initial state are part of the atomic launch
+        // description. Stage the state first so setup options and earlier pre-setup setter
+        // calls resolve by strict last-write-wins, then apply everything to the live player.
+        if let bundled = options.options {
+          updateOptions(options: bundled)
+        } else {
+          // updateOptions applies remote commands itself; without bundled options, apply the
+          // defaults (play, pause, next, previous, seekTo) here.
+          applyRemoteCommands()
+        }
+        if let mode = options.repeatMode { pendingRepeatMode = mode }
+        if let intent = options.playWhenReady { pendingPlayWhenReady = intent }
+        applyPendingPlayerState()
+
+        // Push the resolved event cadence unconditionally. `updateOptions` applies
+        // the interval only when it *differs* from the stored one, but the store
+        // outlives the player — so on a re-setup with unchanged options the new
+        // player would come up with no progress timer at all.
+        player?.setProgressUpdateInterval(playerOptions.progressUpdateEventInterval)
+        player?.setPlaybackIntervalEnabled(playbackIntervalEnabled)
+
+        // Notify listeners that player is ready (e.g., CarPlay)
+        playerAndConfiguredBrowser.check()
+      }
+    }
+  }
+
+  /// Applies initial player state staged before the player existed — from setup options or the
+  /// imperative setters called pre-setup. Consumed on apply so a later re-setup doesn't replay
+  /// stale state.
+  @MainActor
+  private func applyPendingPlayerState() {
+    guard let player else { return }
+    if let mode = pendingRepeatMode {
+      player.repeatMode = mode
+      pendingRepeatMode = nil
+    }
+    if let intent = pendingPlayWhenReady {
+      player.setPlayWhenReady(intent)
+      pendingPlayWhenReady = nil
+    }
+  }
+
+  func updateOptions(options: NativeUpdateOptions) {
+    onMainActor {
+      let previousInterval = playerOptions.progressUpdateEventInterval
+
+      // Update stored options
+      playerOptions.update(from: options)
+
+      // Propagate the favorite flag to the browser so it can hydrate
+      // row hearts (the `favorite` capability is the single favoriting switch).
+      browserManager.setFavoriteEnabled(playerOptions.capabilities.favoriteEnabled)
+
+      // Apply remote commands to player
+      applyRemoteCommands()
+
+      // Apply progress update interval if changed
+      if playerOptions.progressUpdateEventInterval != previousInterval {
+        player?.setProgressUpdateInterval(playerOptions.progressUpdateEventInterval)
+      }
+
+      onOptionsChanged(playerOptions.toOptions())
+      playerOptionsChangedEmitter.emit(())
+    }
+  }
+
+  /// Converts capabilities to remote commands and applies them to the player
+  @MainActor
+  private func applyRemoteCommands() {
+    guard let engine else { return }
+
+    let remoteCommands = playerOptions.capabilities.buildRemoteCommands(
+      forwardJumpInterval: NSNumber(value: playerOptions.forwardJumpInterval),
+      backwardJumpInterval: NSNumber(value: playerOptions.backwardJumpInterval),
+      playbackRates: playerOptions.playbackRates,
+    )
+
+    engine.remoteCommands = remoteCommands
+  }
+
+  func getOptions() throws -> Options {
+    onMainActor { playerOptions.toOptions() }
+  }
+
+  func setPlaybackIntervalEnabled(enabled: Bool) {
+    onMainActor {
+      playbackIntervalEnabled = enabled
+      player?.setPlaybackIntervalEnabled(enabled)
+    }
+  }
+}

package/ios/HybridAudioBrowser+Player.swift

@@ -0,0 +1,397 @@
+import AVFoundation
+import AVKit
+import Foundation
+import MediaPlayer
+import NitroModules
+import os.log
+
+public extension HybridAudioBrowser {
+  // MARK: - Playback Control
+
+  func load(track: Track) throws {
+    try onMainActor {
+      guard let player else {
+        throw NSError(domain: "AudioBrowser", code: 1, userInfo: [NSLocalizedDescriptionKey: "Player not initialized"])
+      }
+      player.load(track)
+    }
+  }
+
+  func reset() throws {
+    onMainActor { player?.clear() }
+  }
+
+  func play() throws {
+    onMainActor { player?.play() }
+  }
+
+  func pause() throws {
+    onMainActor { player?.pause() }
+  }
+
+  func togglePlayback() throws {
+    onMainActor { player?.togglePlayback() }
+  }
+
+  func stop() throws {
+    onMainActor { player?.stop() }
+  }
+
+  func setPlayWhenReady(playWhenReady: Bool) throws {
+    onMainActor {
+      // Pre-setup this stages the intent for the player to come up with — never a no-op.
+      if let player { player.setPlayWhenReady(playWhenReady) }
+      else { pendingPlayWhenReady = playWhenReady }
+    }
+  }
+
+  func getPlayWhenReady() throws -> Bool {
+    onMainActor { player?.playWhenReady ?? pendingPlayWhenReady ?? false }
+  }
+
+  func seekTo(position: Double) throws {
+    onMainActor { player?.seek(to: position) }
+  }
+
+  func seekBy(offset: Double) throws {
+    onMainActor { player?.seek(by: offset) }
+  }
+
+  func seekToLiveEdge() throws {
+    onMainActor { player?.seekToLiveEdge() }
+  }
+
+  func setVolume(level: Double) throws {
+    onMainActor { engine?.volume = Float(level) }
+  }
+
+  func getVolume() throws -> Double {
+    onMainActor { Double(engine?.volume ?? 1.0) }
+  }
+
+  func setRate(rate: Double) throws {
+    onMainActor { player?.rate = Float(rate) }
+  }
+
+  func getRate() throws -> Double {
+    onMainActor { Double(player?.rate ?? 1.0) }
+  }
+
+  func getProgress() throws -> Progress {
+    onMainActor {
+      Progress(
+        position: player?.currentTime ?? 0,
+        duration: engine?.duration ?? 0,
+        buffered: engine?.bufferedPosition ?? 0,
+      )
+    }
+  }
+
+  func getPlayback() throws -> Playback {
+    onMainActor { player?.getPlayback() ?? Playback(state: .none, error: nil) }
+  }
+
+  func getPlayingState() throws -> PlayingState {
+    onMainActor {
+      player?.playingState ?? PlayingState(playing: false, buffering: false)
+    }
+  }
+
+  func getRepeatMode() throws -> RepeatMode {
+    onMainActor { player?.repeatMode ?? pendingRepeatMode ?? .off }
+  }
+
+  func setRepeatMode(mode: RepeatMode) throws {
+    onMainActor {
+      // Pre-setup this stages the mode for the player to come up with — never a no-op.
+      if let player { player.repeatMode = mode }
+      else { pendingRepeatMode = mode }
+    }
+  }
+
+  func getShuffleEnabled() throws -> Bool {
+    onMainActor { player?.shuffleEnabled ?? false }
+  }
+
+  func setShuffleEnabled(enabled: Bool) throws {
+    onMainActor { player?.shuffleEnabled = enabled }
+  }
+
+  func getPlaybackError() throws -> PlaybackError? {
+    onMainActor { player?.nitroPlaybackError }
+  }
+
+  func retry() throws {
+    // Re-resolve rather than replay the cached URL: short-lived URLs/tokens
+    // may have expired since the failure (matches the internal retry path).
+    onMainActor { player?.reloadResolving(startFromCurrentTime: true) }
+  }
+
+  // MARK: - Sleep Timer
+
+  func getSleepTimer() throws -> SleepTimer {
+    onMainActor {
+      player?.sleepTimer ?? .first(NullType.null)
+    }
+  }
+
+  func setSleepTimer(seconds: Double, fadeDuration: Double?) throws {
+    onMainActor {
+      player?.sleepTimerManager.set(seconds: seconds, fadeDuration: fadeDuration)
+    }
+  }
+
+  func setSleepTimerToEndOfTrack() throws {
+    onMainActor {
+      player?.sleepTimerManager.setToEndOfTrack()
+    }
+  }
+
+  func clearSleepTimer() throws -> Bool {
+    onMainActor {
+      player?.sleepTimerManager.clear() ?? false
+    }
+  }
+
+  // MARK: - Queue Management
+
+  func add(tracks: [Track], insertBeforeIndex: Double?) throws {
+    try onMainActor {
+      guard let player else { return }
+      if let index = insertBeforeIndex {
+        try player.add(tracks, at: Int(index))
+      } else {
+        player.add(tracks)
+      }
+    }
+  }
+
+  func move(fromIndex: Double, toIndex: Double) throws {
+    try onMainActor {
+      try player?.move(fromIndex: Int(fromIndex), toIndex: Int(toIndex))
+    }
+  }
+
+  func remove(indexes: [Double]) throws {
+    try onMainActor {
+      guard let player else { return }
+      // Remove in reverse order to maintain index validity
+      for index in indexes.sorted().reversed() {
+        try player.remove(Int(index))
+      }
+    }
+  }
+
+  func removeUpcomingTracks() throws {
+    onMainActor { player?.removeUpcomingTracks() }
+  }
+
+  func skip(index: Double, initialPosition: Double?) throws {
+    try onMainActor {
+      try player?.skipTo(Int(index))
+      if let position = initialPosition {
+        player?.seek(to: position)
+      }
+    }
+  }
+
+  func skipToNext(initialPosition: Double?) throws {
+    onMainActor {
+      player?.next()
+      if let position = initialPosition {
+        player?.seek(to: position)
+      }
+    }
+  }
+
+  func skipToPrevious(initialPosition: Double?) throws {
+    onMainActor {
+      player?.previous()
+      if let position = initialPosition {
+        player?.seek(to: position)
+      }
+    }
+  }
+
+  func setActiveTrackFavorited(favorited: Bool) throws {
+    try favoriteActiveTrack(favorited)
+  }
+
+  /// Sets the active track's favorite state: in the favorite set first, so the now-playing
+  /// heart (hydrated from it) flips at once, then on the queued track. False when nothing is
+  /// playing or the track has no identity.
+  @discardableResult
+  internal func favoriteActiveTrack(_ favorited: Bool) throws -> Bool {
+    try onMainActor {
+      guard let player, let track = player.currentTrack, let identity = track.identity else { return false }
+      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)
+      // The only emit: a favorite toggle mutates the active track in place, so
+      // onPlaybackActiveTrackChanged stays transition-only.
+      favoriteChangedEmitter.emit(FavoriteChangedEvent(track: updated, favorited: favorited))
+      return true
+    }
+  }
+
+  /// Whether the active (now-playing) track is favorited, per the authoritative
+  /// favorite set (via `getActiveTrack`'s hydration).
+  internal func isActiveTrackFavorited() -> Bool {
+    (try? getActiveTrack())?.favorited ?? false
+  }
+
+  func toggleActiveTrackFavorited() throws {
+    try favoriteActiveTrack(!isActiveTrackFavorited())
+  }
+
+  func setQueue(tracks: [Track], startIndex: Double?, startPosition: Double?) throws {
+    onMainActor {
+      guard let player else { return }
+      player.setQueue(
+        tracks,
+        initialIndex: startIndex.map { Int($0) } ?? 0,
+        startPositionMs: startPosition.map { $0 * 1000 },
+      )
+    }
+  }
+
+  func getQueue() throws -> [Track] {
+    onMainActor { player?.tracks ?? [] }
+  }
+
+  func getTrack(index: Double) throws -> Track? {
+    onMainActor {
+      guard let tracks = player?.tracks else { return nil }
+      let i = Int(index)
+      guard i >= 0, i < tracks.count else { return nil }
+      return tracks[i]
+    }
+  }
+
+  func getActiveTrackIndex() throws -> Double? {
+    onMainActor {
+      guard let index = player?.currentIndex, index >= 0 else { return nil }
+      return Double(index)
+    }
+  }
+
+  func getActiveTrack() throws -> Track? {
+    // Hydrate `favorited` from the authoritative favorite set — the now-playing
+    // track is loaded outside the browse cache, so its own flag isn't otherwise
+    // kept in sync as favorites change. This is the single source of truth for
+    // "is the active track favorited" (now-playing heart, toggle direction, JS).
+    onMainActor { player?.currentTrack.map(browserManager.hydrateFavorite) }
+  }
+
+  // MARK: - Now Playing
+
+  func updateNowPlaying(update: NowPlayingUpdate?) throws {
+    onMainActor { engine?.nowPlayingUpdater.setOverride(update) }
+  }
+
+  func flashNowPlaying(update: NowPlayingUpdate, durationMs: Double) throws {
+    onMainActor { engine?.nowPlayingUpdater.flash(update, durationMs: durationMs) }
+  }
+
+  func clearNowPlayingFlash() throws {
+    onMainActor { engine?.nowPlayingUpdater.clearFlash() }
+  }
+
+  func getNowPlaying() throws -> NowPlayingMetadata? {
+    onMainActor { engine?.nowPlayingUpdater.nowPlaying }
+  }
+
+  // MARK: - Network
+
+  func getOnline() throws -> Bool {
+    // No `onMainActor` hop: `isOnline` is lock-protected, so this stays a
+    // cheap read on the JS thread instead of blocking on the main queue.
+    networkMonitor.isOnline
+  }
+
+  // MARK: - System Volume
+
+  func getSystemVolume() throws -> Double {
+    AudioSessionController.volume
+  }
+
+  func setSystemVolume(volume _: Double) throws {
+    // iOS doesn't provide a public API to set system volume programmatically.
+    // Users must adjust volume via hardware buttons or Control Center.
+    logger.debug("setSystemVolume is not supported on iOS - volume must be adjusted via hardware buttons or Control Center")
+  }
+
+  // MARK: - External Audio Output
+
+  func getOutput() throws -> Output? {
+    AudioSessionController.currentOutput
+  }
+
+  func supportsOutputSwitcher() throws -> Bool {
+    // iOS can always present the system route picker (AVRoutePickerView).
+    true
+  }
+
+  func openOutputPicker() throws {
+    DispatchQueue.main.async { [weak self] in
+      guard let self else { return }
+      guard let windowScene = UIApplication.shared.activeWindowScene,
+            let window = windowScene.windows.first(where: { $0.isKeyWindow }),
+            var topController = window.rootViewController
+      else {
+        self.logger.error("openOutputPicker: no active window scene / root view controller")
+        return
+      }
+
+      // Walk up to the topmost presented view controller
+      while let presented = topController.presentedViewController {
+        topController = presented
+      }
+
+      // AVRoutePickerView has no public API to present its picker
+      // programmatically, so we add it to the hierarchy and tap its internal
+      // button. Two requirements that are easy to get wrong:
+      //   1. The view must be *visible* to the system (a `isHidden` source view
+      //      suppresses the presentation), so we keep it transparent instead.
+      //   2. The internal button can be nested below the top-level subviews on
+      //      modern iOS, so we search recursively rather than only direct children.
+      let routePicker = AVRoutePickerView(frame: CGRect(x: 0, y: 0, width: 1, height: 1))
+      routePicker.alpha = 0.01
+      topController.view.addSubview(routePicker)
+
+      let button = Self.firstButton(in: routePicker)
+      self.logger.notice(
+        "openOutputPicker: hierarchy=\(Self.describeHierarchy(routePicker), privacy: .public), buttonFound=\(button != nil, privacy: .public)",
+      )
+
+      if let button {
+        button.sendActions(for: .touchUpInside)
+      } else {
+        self.logger.error("openOutputPicker: no UIButton found inside AVRoutePickerView")
+      }
+
+      // Keep the source view in the hierarchy long enough for the picker to
+      // present (on iPad it anchors a popover to this view).
+      DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
+        routePicker.removeFromSuperview()
+      }
+    }
+  }
+
+  /// Depth-first search for the first `UIButton` inside a view tree.
+  private static func firstButton(in view: UIView) -> UIButton? {
+    if let button = view as? UIButton { return button }
+    for subview in view.subviews {
+      if let button = firstButton(in: subview) { return button }
+    }
+    return nil
+  }
+
+  /// Compact description of a view tree, e.g. `AVRoutePickerView[UIButton[UIImageView]]`.
+  private static func describeHierarchy(_ view: UIView) -> String {
+    let name = String(describing: type(of: view))
+    let children = view.subviews.map(describeHierarchy).joined(separator: ", ")
+    return children.isEmpty ? name : "\(name)[\(children)]"
+  }
+}