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

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/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.34",
   "description": "react-native-audio-browser is a react native package built with Nitro",
   "keywords": [
     "react-native",

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"])
-  }
-}