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

package/ios/Tests/Support/TestTypes.swift

@@ -109,6 +109,46 @@ final class MockPlayerEngine: PlayerEngine {
   func updateSkipAvailability(canNext: Bool, canPrevious: Bool) {
     updateSkipAvailabilityCalls.append((canNext, canPrevious))
   }
+
+  // Now-playing lines and the audio session, in the order the Player drove them
+  var nowPlayingRenderCount = 0
+  var nowPlayingTrackChangedCount = 0
+  var appliedTimedMetadata: [TimedMetadata] = []
+  var activateAudioSessionCount = 0
+  var cancelAudioSessionReleaseCount = 0
+  var scheduleAudioSessionReleaseCount = 0
+  /// Called with the name of each of these calls, so a test can interleave them with callbacks.
+  var onSeamCall: ((String) -> Void)?
+
+  func renderNowPlaying() {
+    nowPlayingRenderCount += 1
+    onSeamCall?("renderNowPlaying")
+  }
+
+  func nowPlayingTrackChanged() {
+    nowPlayingTrackChangedCount += 1
+    onSeamCall?("nowPlayingTrackChanged")
+  }
+
+  func applyTimedMetadata(_ metadata: TimedMetadata) {
+    appliedTimedMetadata.append(metadata)
+    onSeamCall?("applyTimedMetadata")
+  }
+
+  func activateAudioSession() {
+    activateAudioSessionCount += 1
+    onSeamCall?("activateAudioSession")
+  }
+
+  func cancelAudioSessionRelease() {
+    cancelAudioSessionReleaseCount += 1
+    onSeamCall?("cancelAudioSessionRelease")
+  }
+
+  func scheduleAudioSessionRelease() {
+    scheduleAudioSessionReleaseCount += 1
+    onSeamCall?("scheduleAudioSessionRelease")
+  }
 }
 
 /// A Player over `engine` whose retries reload while `retries` and otherwise give up, keeping
@@ -146,7 +186,7 @@ final class MockPlayerCallbacks: PlayerCallbacks {
   var shuffleEnabledChanges: [Bool] = []
   var errorEvents: [PlaybackErrorEvent] = []
   var playbackIntervalFiredCount = 0
-  var releaseSessionCount = 0
+  var timedMetadata: [TimedMetadata] = []
 
   /// The order playback, intent and playing-state changes arrived in.
   var publishOrder: [String] = []
@@ -200,8 +240,9 @@ final class MockPlayerCallbacks: PlayerCallbacks {
     errorEvents.append(event)
   }
 
-  func playerShouldReleaseSession() {
-    releaseSessionCount += 1
+  func playerDidReceiveTimedMetadata(_ metadata: TimedMetadata) {
+    publishOrder.append("timedMetadata")
+    timedMetadata.append(metadata)
   }
 
   var sleepTimerChanges: [SleepTimerState?] = []

package/ios/TrackSelector.swift

@@ -65,34 +65,42 @@ class TrackSelector {
       return .none
     }
 
-    let path = track.path
-
-    // 1. Contextual path (playable-only track with queue context)
-    if let path, BrowserPathHelper.isContextual(path) {
-      return await handleContextualPath(path, track: track, player: player)
-    }
-
-    // 2. Has src — single playable track
-    if track.src != nil {
-      return await handlePlayableTrack(track, player: player)
-    }
-
-    // 3. Has path — browsable
-    if let path {
+    let playback: PlannedPlayback
+    if let path = track.path, BrowserPathHelper.isContextual(path) {
+      playback = await contextualPlayback(path, track: track, player: player)
+    } else if track.src != nil {
+      playback = .single(track)
+    } else if let path = track.path {
       return .browse(path: path)
+    } else {
+      return .none
     }
 
-    // 4. Neither
-    return .none
+    let event = TrackLoadEvent(track: track, queue: playback.queue, startIndex: Double(playback.index))
+    if await browserManager.awaitTrackLoadHandler(event: event) {
+      return .intercepted
+    }
+    return .play(playback.intent)
   }
 
   // MARK: - Private Helpers
 
-  private func handleContextualPath(
+  /// What a selection plays, and the queue and index the track-load handler is shown.
+  private struct PlannedPlayback {
+    let queue: [Track]
+    let index: Int
+    let intent: PlaybackIntent
+
+    static func single(_ track: Track) -> PlannedPlayback {
+      PlannedPlayback(queue: [track], index: 0, intent: .loadTrack(track))
+    }
+  }
+
+  private func contextualPlayback(
     _ path: String,
     track: Track,
     player: some TrackSelectionPlayer,
-  ) async -> SelectionResult {
+  ) async -> PlannedPlayback {
     let parentPath = BrowserPathHelper.stripTrackId(path)
     let trackId = BrowserPathHelper.extractTrackId(path)
 
@@ -110,47 +118,21 @@ class TrackSelector {
       }
       if let index = skipIndex {
         logger.debug("Queue already from \(parentPath), skipping to index \(index)")
-        let queue = player.tracks
-        let event = TrackLoadEvent(track: track, queue: queue, startIndex: Double(index))
-        if await browserManager.awaitTrackLoadHandler(event: event) {
-          return .intercepted
-        }
-        return .play(.skipTo(index: index))
+        return PlannedPlayback(queue: player.tracks, index: index, intent: .skipTo(index: index))
       }
     }
 
-    // Expand the queue from the contextual path
     do {
-      if let expanded = try await browserManager.expandQueueFromContextualPath(path) {
-        let (tracks, startIndex) = expanded
-        let event = TrackLoadEvent(track: track, queue: tracks, startIndex: Double(startIndex))
-        if await browserManager.awaitTrackLoadHandler(event: event) {
-          return .intercepted
-        }
-        return .play(.setQueue(tracks: tracks, startIndex: startIndex, sourcePath: parentPath))
-      } else {
-        // Fallback: single track
-        return await singleTrackResult(track)
+      guard let (tracks, startIndex) = try await browserManager.expandQueueFromContextualPath(path) else {
+        return .single(track)
       }
+      return PlannedPlayback(
+        queue: tracks, index: startIndex,
+        intent: .setQueue(tracks: tracks, startIndex: startIndex, sourcePath: parentPath),
+      )
     } catch {
       logger.error("Error expanding queue: \(error.localizedDescription)")
-      // Fallback to single track
-      return await singleTrackResult(track)
-    }
-  }
-
-  private func handlePlayableTrack(
-    _ track: Track,
-    player _: some TrackSelectionPlayer,
-  ) async -> SelectionResult {
-    await singleTrackResult(track)
-  }
-
-  private func singleTrackResult(_ track: Track) async -> SelectionResult {
-    let event = TrackLoadEvent(track: track, queue: [track], startIndex: 0)
-    if await browserManager.awaitTrackLoadHandler(event: event) {
-      return .intercepted
+      return .single(track)
     }
-    return .play(.loadTrack(track))
   }
 }

package/ios/Util/ConcurrentMap.swift

@@ -0,0 +1,19 @@
+extension Array where Element: Sendable {
+  /// `transform` over every element at once, with the results in element order. Cancelling the
+  /// caller cancels every transform still running.
+  func concurrentMap<T: Sendable>(_ transform: @escaping @MainActor (Element) async -> T) async -> [T] {
+    await withTaskGroup(of: (Int, T).self) { group in
+      for (index, element) in enumerated() {
+        group.addTask {
+          let result = await transform(element)
+          return (index, result)
+        }
+      }
+      var results: [(Int, T)] = []
+      for await result in group {
+        results.append(result)
+      }
+      return results.sorted { $0.0 < $1.0 }.map(\.1)
+    }
+  }
+}

package/ios/Util/Emitter.swift

@@ -40,13 +40,6 @@ public final class Emitter<T>: @unchecked Sendable {
     snapshot = next
   }
 
-  /// Removes all listeners
-  public func removeAllListeners() {
-    lock.lock()
-    defer { lock.unlock() }
-    snapshot = []
-  }
-
   /// Emits an event to all registered listeners
   /// - Parameter event: The event data to emit
   public func emit(_ event: T) {
@@ -58,13 +51,6 @@ public final class Emitter<T>: @unchecked Sendable {
       entry.handler(event)
     }
   }
-
-  /// Returns the number of registered listeners
-  public var listenerCount: Int {
-    lock.lock()
-    defer { lock.unlock() }
-    return snapshot.count
-  }
 }
 
 /// A listener registration that ends when cancelled or released.

package/ios/Util/NetworkMonitor.swift

@@ -2,8 +2,7 @@ import Foundation
 import Network
 import os.log
 
-/// Monitors network connectivity state using NWPathMonitor.
-/// Notifies listeners when the connection state changes.
+/// The device's connectivity, from NWPathMonitor; `changed` emits each change on the main thread.
 final class NetworkMonitor: @unchecked Sendable {
   // MARK: - Properties
 
@@ -11,25 +10,17 @@ final class NetworkMonitor: @unchecked Sendable {
   private let monitor: NWPathMonitor
   private let queue = DispatchQueue(label: "com.audiobrowser.networkmonitor")
 
-  /// Guards `_isOnline` only. Never held across `onChanged` — see `apply`.
+  /// Guards `_isOnline` only; never held across an emit.
   private let lock = NSLock()
   private var _isOnline = false
 
-  /// Current network connectivity state. Readable from any thread: the value is
-  /// lock-protected rather than confined, so callers on the JS thread (Nitro's
-  /// `getOnline`) don't have to block on a main-queue hop to read a Bool.
-  ///
-  /// The broadcast is main-confined even though the value isn't — `onChanged`
-  /// fans out to the JS bridge, a now-playing re-render and a player reload, so
-  /// it must not run under the lock (reentrancy) or off the main actor.
+  /// Readable from any thread, so the JS thread's `getOnline` needs no main-queue hop.
   var isOnline: Bool {
     lock.lock()
     defer { lock.unlock() }
     return _isOnline
   }
 
-  /// Stores a new status and, if it actually changed, broadcasts on main —
-  /// outside the lock.
   private func apply(_ newStatus: Bool) {
     lock.lock()
     let changed = _isOnline != newStatus
@@ -40,28 +31,20 @@ final class NetworkMonitor: @unchecked Sendable {
     guard changed else { return }
     logger.notice("Network status changed: \(oldValue) -> \(newStatus)")
     DispatchQueue.main.async { [weak self] in
-      self?.onChanged?(newStatus)
+      self?.changed.emit(newStatus)
     }
   }
 
-  /// Invoked on every connectivity change. Wired centrally in `HybridAudioBrowser.setupPlayer` and
-  /// fans out to the JS event bridge, the now-playing re-render (so the offline/online label tracks
-  /// connectivity), and the player's reconnect-reload.
-  var onChanged: ((Bool) -> Void)?
+  let changed = Emitter<Bool>()
 
   // MARK: - Initialization
 
   init() {
     monitor = NWPathMonitor()
 
-    // Seed BEFORE `start`. `start` publishes `self` to the monitor queue, so any
-    // write after it races the handler's locked write — and would clobber a real
-    // update with a `currentPath` the monitor hasn't finished evaluating. Nothing
-    // recovers from that: the handler has already fired, `onChanged` isn't wired
-    // until setupPlayer, and the stale value then drives `getOnline()`, the JS
-    // event, and RetryLoop's offline parking until the next genuine path
-    // change. Seeding first is a best-effort guess; the handler fires shortly
-    // after `start` and is the authoritative last writer.
+    // Seeded before `start`: a write after it races the handler's, and would clobber a real
+    // update with a `currentPath` the monitor hasn't finished evaluating. The handler, which
+    // fires shortly after `start`, is the last writer.
     let initialStatus = monitor.currentPath.status == .satisfied
     logger.notice("NetworkMonitor initialized, initial isOnline=\(initialStatus)")
     _isOnline = initialStatus

package/ios/Util/OutputPicker.swift

@@ -0,0 +1,48 @@
+import AVKit
+import os.log
+import UIKit
+
+/// Presents the system audio route picker over the topmost view controller.
+@MainActor
+enum OutputPicker {
+  private static let logger = Logger(subsystem: "com.audiobrowser", category: "OutputPicker")
+
+  static func present() {
+    guard let windowScene = UIApplication.shared.activeWindowScene,
+          let window = windowScene.windows.first(where: { $0.isKeyWindow }),
+          var topController = window.rootViewController
+    else {
+      logger.error("openOutputPicker: no active window scene / root view controller")
+      return
+    }
+    while let presented = topController.presentedViewController {
+      topController = presented
+    }
+
+    // AVRoutePickerView has no API to present its picker, so its internal button is tapped. The
+    // view must be visible to the system (a hidden source view suppresses the picker), and the
+    // button can sit below the top-level subviews.
+    let routePicker = AVRoutePickerView(frame: CGRect(x: 0, y: 0, width: 1, height: 1))
+    routePicker.alpha = 0.01
+    topController.view.addSubview(routePicker)
+
+    if let button = firstButton(in: routePicker) {
+      button.sendActions(for: .touchUpInside)
+    } else {
+      logger.error("openOutputPicker: no UIButton found inside AVRoutePickerView")
+    }
+
+    // On iPad the picker's popover anchors to this view.
+    DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
+      routePicker.removeFromSuperview()
+    }
+  }
+
+  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
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-browser",
-  "version": "0.2.0-next.33",
+  "version": "0.2.0-next.35",
   "description": "react-native-audio-browser is a react native package built with Nitro",
   "keywords": [
     "react-native",

package/ios/CarPlay/HybridAudioBrowser+IntentFavorite.swift

@@ -1,20 +0,0 @@
-import Foundation
-import os.log
-
-private let intentLogger = Logger(subsystem: "com.audiobrowser", category: "MediaIntent")
-
-extension HybridAudioBrowser {
-  /// Sets the favorite state of the playing track for a Siri intent, through the same path as
-  /// the CarPlay favorite button. False when nothing is playing, the playing track has no
-  /// identity to favorite, or the change throws.
-  @MainActor
-  static func favoriteCurrentTrack(_ favorited: Bool) -> Bool {
-    guard let browser = shared else { return false }
-    do {
-      return try browser.favoriteActiveTrack(favorited)
-    } catch {
-      intentLogger.error("favoriteCurrentTrack(\(favorited)) failed: \(error.localizedDescription)")
-      return false
-    }
-  }
-}

package/ios/CarPlay/RNABMediaAddHandler.swift

@@ -1,59 +0,0 @@
-import Foundation
-import Intents
-import os.log
-
-/// In-app `INAddMediaIntent` handler — "Hey Siri, add this to my favorites."
-/// Adding to the user's collection maps onto the library-managed favorite state
-/// of the **currently playing** track via `setActiveTrackFavorited` — the same
-/// path as the CarPlay favorite button and the `INUpdateMediaAffinityIntent`
-/// "like", so it flips the now-playing heart and fires `onFavoriteChanged` for
-/// the consumer to persist. No extra config beyond the `favorite` capability.
-///
-/// We expose a single flat favorites collection (no named playlists), so the
-/// destination always resolves to the user's library. Adding a *named* item
-/// that isn't currently playing needs the structured-intent consumer callback
-/// and is out of scope here — like the named play-by-search case.
-///
-/// Internal (keeps Intents types out of the generated header), exposed to the
-/// ObjC runtime via `@objc(RNABMediaAddHandler)` and vended from
-/// `RNABAudioBrowser.handlerForIntent(_:)`.
-@objc(RNABMediaAddHandler)
-class RNABMediaAddHandler: NSObject, INAddMediaIntentHandling {
-  private static let logger = Logger(subsystem: "com.audiobrowser", category: "MediaAddHandler")
-
-  func handle(
-    intent _: INAddMediaIntent,
-    completion: @escaping @Sendable (INAddMediaIntentResponse) -> Void,
-  ) {
-    Self.logger.info("Add media — favorite current track")
-
-    Task { @MainActor in
-      let applied = HybridAudioBrowser.favoriteCurrentTrack(true)
-      completion(INAddMediaIntentResponse(code: applied ? .success : .failure, userActivity: nil))
-    }
-  }
-
-  // Siri runs a resolve phase before `handle`; without a resolution method it
-  // errors ("Unable to find implementation of resolution method"). These are
-  // *optional* @objc protocol methods, so pin the exact selectors SiriKit
-  // dispatches to (otherwise they aren't exposed and are "not found"). We act on
-  // the currently-playing track / our single library, so pass both through.
-  @objc(resolveMediaItemsForAddMedia:withCompletion:)
-  func resolveMediaItems(
-    for intent: INAddMediaIntent,
-    with completion: @escaping ([INAddMediaMediaItemResolutionResult]) -> Void,
-  ) {
-    let name = intent.mediaSearch?.mediaName ?? ""
-    let item = INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)
-    completion([.success(with: item)])
-  }
-
-  @objc(resolveMediaDestinationForAddMedia:withCompletion:)
-  func resolveMediaDestination(
-    for _: INAddMediaIntent,
-    with completion: @escaping (INAddMediaMediaDestinationResolutionResult) -> Void,
-  ) {
-    // One flat favorites collection — always the user's library, no playlists.
-    completion(.success(with: INMediaDestination.library))
-  }
-}

package/ios/CarPlay/RNABMediaAffinityHandler.swift

@@ -1,53 +0,0 @@
-import Foundation
-import Intents
-import os.log
-
-/// In-app `INUpdateMediaAffinityIntent` handler — "Hey Siri, I like / don't like
-/// this." Maps the affinity onto the library-managed favorite state of the
-/// **currently playing** track via `setActiveTrackFavorited` — the same path as
-/// the CarPlay favorite button — so it flips the now-playing heart and fires
-/// `onFavoriteChanged` for the consumer to persist. Like → favorited, dislike →
-/// unfavorited. No extra config beyond the `favorite` capability.
-///
-/// Internal (keeps Intents types out of the generated header), exposed to the
-/// ObjC runtime via `@objc(RNABMediaAffinityHandler)` and vended from
-/// `RNABAudioBrowser.handlerForIntent(_:)`.
-///
-/// Affinity for a *named* item ("I like «station»") is out of scope here — that
-/// needs the structured-intent consumer callback.
-@objc(RNABMediaAffinityHandler)
-class RNABMediaAffinityHandler: NSObject, INUpdateMediaAffinityIntentHandling {
-  private static let logger = Logger(subsystem: "com.audiobrowser", category: "MediaAffinityHandler")
-
-  func handle(
-    intent: INUpdateMediaAffinityIntent,
-    completion: @escaping @Sendable (INUpdateMediaAffinityIntentResponse) -> Void,
-  ) {
-    let affinity = intent.affinityType
-    Self.logger.info("Update media affinity — type=\(affinity.rawValue)")
-
-    Task { @MainActor in
-      let applied = switch affinity {
-      case .like: HybridAudioBrowser.favoriteCurrentTrack(true)
-      case .dislike: HybridAudioBrowser.favoriteCurrentTrack(false)
-      default: false
-      }
-      completion(INUpdateMediaAffinityIntentResponse(code: applied ? .success : .failure, userActivity: nil))
-    }
-  }
-
-  // Siri runs a resolve phase before `handle`; without a resolution method it
-  // errors ("Unable to find implementation of resolution method"). This is an
-  // *optional* @objc protocol method, so pin the exact selector SiriKit dispatches
-  // to (otherwise it isn't exposed and is "not found"). We act on the currently
-  // playing track regardless, so pass the spoken item straight through.
-  @objc(resolveMediaItemsForUpdateMediaAffinity:withCompletion:)
-  func resolveMediaItems(
-    for intent: INUpdateMediaAffinityIntent,
-    with completion: @escaping ([INUpdateMediaAffinityMediaItemResolutionResult]) -> Void,
-  ) {
-    let name = intent.mediaSearch?.mediaName ?? ""
-    let item = INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)
-    completion([.success(with: item)])
-  }
-}

package/ios/Model/SourceType.swift

@@ -1,6 +0,0 @@
-import Foundation
-
-public enum SourceType {
-  case stream
-  case file
-}

package/ios/Tests/RemoteCommandTests.swift

@@ -1,65 +0,0 @@
-import Foundation
-import Testing
-
-@testable import AudioBrowserTestable
-
-@Suite("RemoteCommand")
-struct RemoteCommandTests {
-  @Test func removedCommandsAreDisabled() {
-    let toDisable = RemoteCommand.commandsToDisable(
-      enabled: [.play, .pause, .next, .previous],
-      replacedBy: [.play, .pause],
-    )
-    #expect(toDisable.map(\.key) == ["nextTrack", "previousTrack"])
-  }
-
-  @Test func retainedCommandsAreNotDisabled() {
-    let toDisable = RemoteCommand.commandsToDisable(
-      enabled: [.play, .pause],
-      replacedBy: [.play, .pause, .stop],
-    )
-    #expect(toDisable.isEmpty)
-  }
-
-  /// A changed jump interval is the same command with a new associated value —
-  /// diffing by `==` would report it as removed and disable the button that the
-  /// update had just re-enabled.
-  @Test func changedJumpIntervalIsNotDisabled() {
-    let toDisable = RemoteCommand.commandsToDisable(
-      enabled: [.skipForward(preferredIntervals: [15]), .skipBackward(preferredIntervals: [15])],
-      replacedBy: [.skipForward(preferredIntervals: [30]), .skipBackward(preferredIntervals: [30])],
-    )
-    #expect(toDisable.isEmpty)
-  }
-
-  @Test func changedPlaybackRatesAreNotDisabled() {
-    let toDisable = RemoteCommand.commandsToDisable(
-      enabled: [.changePlaybackRate(supportedPlaybackRates: [1.0])],
-      replacedBy: [.changePlaybackRate(supportedPlaybackRates: [1.0, 1.5, 2.0])],
-    )
-    #expect(toDisable.isEmpty)
-  }
-
-  @Test func everyCommandIsDisabledWhenNoneRemain() {
-    let toDisable = RemoteCommand.commandsToDisable(
-      enabled: RemoteCommand.all(),
-      replacedBy: [],
-    )
-    #expect(toDisable.count == RemoteCommand.all().count)
-  }
-
-  /// `key` is the identity the diff above compares; two cases sharing a key would
-  /// disable each other.
-  @Test func keysAreUnique() {
-    let all = RemoteCommand.all()
-    #expect(Set(all.map(\.key)).count == all.count)
-  }
-
-  @Test func droppedJumpCommandIsStillDisabled() {
-    let toDisable = RemoteCommand.commandsToDisable(
-      enabled: [.play, .skipForward(preferredIntervals: [15])],
-      replacedBy: [.play],
-    )
-    #expect(toDisable.map(\.key) == ["skipForward"])
-  }
-}