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

package/ios/AVPlayerEngine.swift

@@ -13,6 +13,7 @@ final class AVPlayerEngine: PlayerEngine {
 
   var onEvent: (@MainActor (EngineEvent) -> Void)?
   private weak var callbacks: AVPlayerEngineCallbacks?
+  private weak var audioSession: AudioSessionController?
 
   let nowPlayingInfoController: NowPlayingInfoController
   let nowPlayingUpdater: NowPlayingUpdater
@@ -25,25 +26,40 @@ final class AVPlayerEngine: PlayerEngine {
   private var itemObserver: ItemObserver?
   private var rate: Float = 1
   private var skipAvailability = (canNext: false, canPrevious: false)
-
-  var remoteCommands: [RemoteCommand] = [] {
-    didSet { remoteCommandController.enable(commands: remoteCommands) }
-  }
-
-  /// - Parameter resolver: Resolves media URLs and now-playing artwork.
+  /// The charset of the track last loaded, for its ICY titles.
+  private var icyCharset: String?
+  private let bufferDuration: Double
+
+  /// - Parameters:
+  ///   - resolver: Resolves media URLs and now-playing artwork.
+  ///   - bufferDuration: 0 lets AVPlayer choose, minimising stalls.
+  ///   - nowPlayingEnabled: When false the now-playing surface ignores the override and formatter.
   init(
     callbacks: AVPlayerEngineCallbacks?,
     resolver: MediaResolving?,
+    audioSession: AudioSessionController,
+    networkStatus: (any NetworkStatusProviding)?,
+    bufferDuration: Double,
+    nowPlayingEnabled: Bool,
+    nowPlayingFormatter: ((FormatNowPlayingParams) -> Promise<NowPlayingUpdate?>)?,
     nowPlayingInfoController: NowPlayingInfoController = NowPlayingInfoController(),
   ) {
     self.callbacks = callbacks
+    self.audioSession = audioSession
+    self.bufferDuration = bufferDuration
     self.nowPlayingInfoController = nowPlayingInfoController
-    nowPlayingUpdater = NowPlayingUpdater(nowPlayingInfoController: nowPlayingInfoController)
+    nowPlayingUpdater = NowPlayingUpdater(
+      nowPlayingInfoController: nowPlayingInfoController,
+      networkStatus: networkStatus,
+      enabled: nowPlayingEnabled,
+      formatter: nowPlayingFormatter,
+    )
     remoteCommandController = RemoteCommandController(callbacks: callbacks)
     mediaLoader = MediaLoader { [weak resolver] src, track in
       await resolver?.resolveMediaUrl(src, track: track) ?? MediaResolvedUrl(url: src, headers: nil, userAgent: nil)
     }
 
+    mediaLoader.bufferDuration = bufferDuration
     mediaLoader.onEvent = { [weak self] in self?.mediaLoaderDidEmit($0) }
     nowPlayingUpdater.artworkUrlResolver = { [weak resolver] track, imageContext in
       await resolver?.resolveNowPlayingArtwork(track: track, imageContext: imageContext)
@@ -65,21 +81,6 @@ final class AVPlayerEngine: PlayerEngine {
     stopObservingItem()
   }
 
-  /// Re-requests the now-playing election, which the system may have declined at link time while
-  /// the audio session was still inactive.
-  func reactivateNowPlayingSession() {
-    nowPlayingInfoController.reactivateSessionIfNeeded()
-  }
-
-  // MARK: - Buffering
-
-  var bufferDuration: Double = 0 {
-    didSet {
-      avPlayer.automaticallyWaitsToMinimizeStalling = bufferDuration == 0
-      mediaLoader.bufferDuration = bufferDuration
-    }
-  }
-
   // MARK: - The Current Item
 
   var hasItem: Bool {
@@ -141,6 +142,7 @@ final class AVPlayerEngine: PlayerEngine {
   // MARK: - Loading
 
   func resolveAndLoad(src: String, track: Track) {
+    icyCharset = track.icyCharset
     mediaLoader.resolveAndLoad(src: src, track: track)
   }
 
@@ -221,6 +223,18 @@ final class AVPlayerEngine: PlayerEngine {
     nowPlayingUpdater.clearNowPlaying()
   }
 
+  func renderNowPlaying() {
+    nowPlayingUpdater.render()
+  }
+
+  func nowPlayingTrackChanged() {
+    nowPlayingUpdater.trackChanged()
+  }
+
+  func applyTimedMetadata(_ metadata: TimedMetadata) {
+    nowPlayingUpdater.receivedTimedMetadata(metadata)
+  }
+
   func updateRemoteRepeatMode(_ mode: RepeatMode) {
     remoteCommandController.updateRepeatMode(mode)
   }
@@ -234,6 +248,20 @@ final class AVPlayerEngine: PlayerEngine {
     remoteCommandController.refreshSkipAvailability()
   }
 
+  // MARK: - Audio Session
+
+  func activateAudioSession() {
+    audioSession?.activate { [weak self] in self?.nowPlayingInfoController.reactivateSessionIfNeeded() }
+  }
+
+  func cancelAudioSessionRelease() {
+    audioSession?.cancelRelease()
+  }
+
+  func scheduleAudioSessionRelease() {
+    audioSession?.scheduleRelease()
+  }
+
   // MARK: - Observed Events
 
   private func playerDidEmit(_ event: PlayerObserver.Event) {
@@ -260,7 +288,7 @@ final class AVPlayerEngine: PlayerEngine {
     case let .failed(error), let .failedToPlayToEnd(error): reportFailure(error)
     case .playedToEnd: onEvent?(.playedToEnd)
     case .stalled: onEvent?(.stalled)
-    case let .timedMetadata(groups): callbacks?.playerDidReceiveTimedMetadata(groups)
+    case let .timedMetadata(groups): reportTimedMetadata(groups)
     }
   }
 
@@ -299,7 +327,15 @@ final class AVPlayerEngine: PlayerEngine {
     case let .chapterMetadata(groups):
       callbacks?.playerDidReceiveChapterMetadata(groups)
     case let .timedMetadata(groups):
-      callbacks?.playerDidReceiveTimedMetadata(groups)
+      reportTimedMetadata(groups)
+    }
+  }
+
+  private func reportTimedMetadata(_ groups: [AVTimedMetadataGroup]) {
+    for group in groups {
+      if let metadata = TimedMetadata.from(items: group.items, icyCharset: icyCharset) {
+        onEvent?(.timedMetadata(metadata))
+      }
     }
   }
 

package/ios/AVPlayerEngineCallbacks.swift

@@ -8,7 +8,6 @@ import NitroModules
 @MainActor
 protocol AVPlayerEngineCallbacks: RemoteCommandCallbacks {
   func playerDidReceiveCommonMetadata(_ metadata: [AVMetadataItem])
-  func playerDidReceiveTimedMetadata(_ metadata: [AVTimedMetadataGroup])
   func playerDidReceiveChapterMetadata(_ metadata: [AVTimedMetadataGroup])
   /// The now-playing lines or track changed; carries the metadata JS sees.
   func playerDidChangeNowPlaying(_ metadata: NowPlayingMetadata)

package/ios/CarPlay/CarPlayNowPlayingManager.swift

@@ -11,7 +11,7 @@ final class CarPlayNowPlayingManager {
   private let interfaceController: CPInterfaceController
   private let audioBrowser: HybridAudioBrowser
   /// Read on each use: a re-setup replaces the bridge's player.
-  private var player: Player? { audioBrowser.getPlayer() }
+  private var player: Player? { audioBrowser.player }
   private let listItem: (Track, ((CPSelectableListItem, @escaping () -> Void) -> Void)?) -> CPListItem
   /// Pushes a browse destination: the album line's.
   private let navigate: (_ path: String, _ title: String) -> Void
@@ -131,7 +131,7 @@ final class CarPlayNowPlayingManager {
   private func refreshButtons() {
     // A gate hides the custom buttons; the transport controls stay, as a gate never blocks
     // playback.
-    let configured = audioBrowser.browseGate.isActive ? [] : audioBrowser.carPlayNowPlayingButtons
+    let configured = audioBrowser.browseGate.isActive ? [] : audioBrowser.playerOptions.carPlayNowPlayingButtons
     // The template caps custom buttons at 5 (CPNowPlayingTemplate.h) and says
     // nothing about overflow — unlike lists (trim) or the tab bar (throw). The
     // config comes straight from JS, where duplicates and excess are
@@ -319,7 +319,7 @@ final class CarPlayNowPlayingManager {
   }
 
   private func handlePlaybackRateButtonTapped() {
-    let rates = audioBrowser.playbackRates
+    let rates = audioBrowser.playerOptions.playbackRates
     guard !rates.isEmpty, let player else { return }
 
     let currentRate = Double(player.rate)
@@ -349,7 +349,7 @@ final class CarPlayNowPlayingManager {
   }
 
   private func updateUpNextButton() {
-    CPNowPlayingTemplate.shared.isUpNextButtonEnabled = audioBrowser.carPlayUpNextButton && (player?.tracks.count ?? 0) > 1
+    CPNowPlayingTemplate.shared.isUpNextButtonEnabled = audioBrowser.playerOptions.carPlayUpNextButton && (player?.tracks.count ?? 0) > 1
   }
 
   fileprivate func handleUpNextButtonTapped() {

package/ios/CarPlay/CarPlaySession.swift

@@ -12,7 +12,7 @@ final class CarPlaySession {
   let interfaceController: CPInterfaceController
   let audioBrowser: HybridAudioBrowser
   /// Read on each use: a re-setup replaces the bridge's player.
-  var player: Player? { audioBrowser.getPlayer() }
+  var player: Player? { audioBrowser.player }
   let trackSelector: TrackSelector
   let imageLoader: CarPlayImageLoader
   let listItemFactory: CarPlayListItemFactory
@@ -58,7 +58,7 @@ final class CarPlaySession {
     )
     listItemFactory = CarPlayListItemFactory(
       isActiveTrack: { [weak audioBrowser] identity in
-        identity != nil && audioBrowser?.getPlayer()?.currentTrack?.identity == identity
+        identity != nil && audioBrowser?.player?.currentTrack?.identity == identity
       },
     )
     listItemFactory.imageLoader = imageLoader
@@ -156,7 +156,7 @@ final class CarPlaySession {
   // MARK: - Playing Indicators
 
   var playingIndicatorLocation: CPListItemPlayingIndicatorLocation {
-    switch audioBrowser.carPlayPlayingIndicatorLocation {
+    switch audioBrowser.playerOptions.carPlayPlayingIndicatorLocation {
     case .trailing: .trailing
     case .leading: .leading
     }

package/ios/CarPlay/MediaIntentPlayback.swift

@@ -69,6 +69,6 @@ enum MediaIntentPlayback {
   /// destroyed player.
   @MainActor
   private static func livePlayer(of browser: HybridAudioBrowser) -> Player? {
-    HybridAudioBrowser.shared === browser ? browser.getPlayer() : nil
+    HybridAudioBrowser.shared === browser ? browser.player : nil
   }
 }

package/ios/Extension/Capability+RemoteCommand.swift

@@ -1,74 +1,27 @@
 import Foundation
-import NitroModules
 
-/// Extension to build RemoteCommands from PlayerCapabilities
-extension PlayerCapabilities {
-  /// Build array of enabled RemoteCommands based on capabilities
-  /// All capabilities are enabled by default - only false values disable them
-  func buildRemoteCommands(
-    forwardJumpInterval: NSNumber?,
-    backwardJumpInterval: NSNumber?,
-    playbackRates: [Double],
-  ) -> [RemoteCommand] {
-    var commands: [RemoteCommand] = []
-
-    // Play/Pause/Stop
-    if play != false {
-      commands.append(.play)
-    }
-    if pause != false {
-      commands.append(.pause)
-    }
-    if stop != false {
-      commands.append(.stop)
-    }
-
-    // Navigation
-    if skipToNext != false {
-      commands.append(.next)
-    }
-    if skipToPrevious != false {
-      commands.append(.previous)
-    }
-
-    // Seeking
-    if seekTo != false {
-      commands.append(.changePlaybackPosition)
-    }
+#if canImport(NitroModules)
+  import NitroModules
+#endif
 
-    // Jump forward/backward
-    if jumpForward != false {
-      commands.append(.skipForward(
-        preferredIntervals: [(forwardJumpInterval ?? backwardJumpInterval) ?? 15],
-      ))
-    }
-    if jumpBackward != false {
-      commands.append(.skipBackward(
-        preferredIntervals: [(backwardJumpInterval ?? forwardJumpInterval) ?? 15],
-      ))
-    }
-
-    // NOTE: We deliberately do NOT register MPRemoteCommandCenter.likeCommand for the
-    // `favorite` capability. That MPFeedbackCommand had a single system surface — a
-    // pre-iOS-15 lock-screen menu shown in place of the previous-track button — which
-    // Apple silently removed. On the iOS 16+ target it can never be invoked: CarPlay
-    // uses its own CPNowPlayingButton heart, and Siri "I like this" routes through
-    // INUpdateMediaAffinityIntent. The `favorite` capability still drives the
-    // favorite row indicators via setFavoriteEnabled. See issues #67 / #71.
-
-    // Mode controls
-    if shuffleMode != false {
-      commands.append(.changeShuffleMode)
-    }
-    if repeatMode != false {
-      commands.append(.changeRepeatMode)
-    }
-    if playbackRate != false {
-      commands.append(.changePlaybackRate(
-        supportedPlaybackRates: playbackRates.map { NSNumber(value: $0) },
-      ))
-    }
-
-    return commands
+extension PlayerCapabilities {
+  /// The remote commands the capabilities enable: each one unless set to false. `favorite`
+  /// enables none: no iOS 16+ surface invokes `likeCommand`; CarPlay has its own heart button and
+  /// Siri its affinity intent.
+  var remoteCommands: Set<RemoteCommand> {
+    let enabled: [(Bool?, RemoteCommand)] = [
+      (play, .play),
+      (pause, .pause),
+      (stop, .stop),
+      (skipToNext, .next),
+      (skipToPrevious, .previous),
+      (seekTo, .changePlaybackPosition),
+      (jumpForward, .skipForward),
+      (jumpBackward, .skipBackward),
+      (shuffleMode, .changeShuffleMode),
+      (repeatMode, .changeRepeatMode),
+      (playbackRate, .changePlaybackRate),
+    ]
+    return Set(enabled.compactMap { $0.0 == false ? nil : $0.1 })
   }
 }

package/ios/Extension/Track+AVPlayer.swift

@@ -4,22 +4,6 @@ import NitroModules
 
 /// Extension to make Nitro Track work with AVPlayer
 extension Track {
-  /// The URL for AVPlayer playback (uses src for playback URL)
-  var playbackUrl: URL? {
-    guard let src else { return nil }
-    return URL(string: src)
-  }
-
-  /// Whether this is a local file URL
-  var isLocalFile: Bool {
-    playbackUrl?.isFileURL ?? false
-  }
-
-  /// The source type (file or stream) based on the URL scheme
-  var sourceType: SourceType {
-    isLocalFile ? .file : .stream
-  }
-
   /// Builds an `ImageSource` from the track's artwork fields, skipping SF Symbol strings.
   var artworkImageSource: ImageSource? {
     if let source = artworkSource {

package/ios/HybridAudioBrowser+Browser.swift

@@ -10,12 +10,16 @@ public extension HybridAudioBrowser {
   /// 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)
-      }
+    Task { @MainActor in await loadPath(path) }
+  }
+
+  /// Loads `path` into the browser, reporting a failure as the navigation error.
+  @MainActor
+  private func loadPath(_ path: String) async {
+    do {
+      try await browserManager.load(path)
+    } catch {
+      await reportNavigationError(error, path: path)
     }
   }
 
@@ -33,9 +37,7 @@ public extension HybridAudioBrowser {
   }
 
   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`.
+    // @MainActor: `player` is main-confined.
     Task { @MainActor in
       guard let player else { return }
       let result = await trackSelector.select(track: track, player: player)
@@ -81,15 +83,12 @@ public extension HybridAudioBrowser {
   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)
+    let isCurrentPath = try onMainActor {
+      try browserManager.invalidateContentCache(path)
+      return browserManager.path == path
     }
+    externalContentChangedEmitter.emit(path)
+    if isCurrentPath { navigate(path, clearError: false) }
   }
 
   func invalidateAllContent() throws {

package/ios/HybridAudioBrowser+Options.swift

@@ -10,7 +10,6 @@ public extension HybridAudioBrowser {
 
   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.
@@ -20,58 +19,34 @@ public extension HybridAudioBrowser {
         // 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
+        let newEngine = AVPlayerEngine(
+          callbacks: self,
+          resolver: browserManager.requests,
+          audioSession: audioSession,
+          networkStatus: networkMonitor,
+          bufferDuration: options.ios?.buffer ?? 0,
+          nowPlayingEnabled: options.autoUpdateNowPlayingMetadata ?? true,
+          nowPlayingFormatter: options.nowPlayingMetadataFormatter,
+        )
+        let newPlayer = Player(engine: newEngine, callbacks: self, retry: RetryLoop(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.
+        // `options.keepSessionAliveOnError` is ignored: on iOS an error never clears the now-playing
+        // info, and next/previous follow the queue, not the state.
 
         // 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 bundled = options.options { updateOptions(options: bundled) }
         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)
+        // The stored options outlive the player, so a re-setup applies them to the new one.
+        applyOptions()
         playerAndConfiguredBrowser.check()
       }
     }
@@ -95,40 +70,26 @@ public extension HybridAudioBrowser {
 
   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)
-      }
-
+      applyOptions()
       onOptionsChanged(playerOptions.toOptions())
       playerOptionsChangedEmitter.emit(())
     }
   }
 
-  /// Converts capabilities to remote commands and applies them to the player
+  /// Applies the stored options to the browser, the player and its engine. Idempotent.
   @MainActor
-  private func applyRemoteCommands() {
-    guard let engine else { return }
-
-    let remoteCommands = playerOptions.capabilities.buildRemoteCommands(
-      forwardJumpInterval: NSNumber(value: playerOptions.forwardJumpInterval),
-      backwardJumpInterval: NSNumber(value: playerOptions.backwardJumpInterval),
+  private func applyOptions() {
+    // The `favorite` capability is the one favoriting switch: it also drives the row hearts.
+    browserManager.setFavoriteEnabled(playerOptions.capabilities.favoriteEnabled)
+    engine?.remoteCommandController.enable(
+      commands: playerOptions.capabilities.remoteCommands,
+      forwardJumpInterval: playerOptions.forwardJumpInterval,
+      backwardJumpInterval: playerOptions.backwardJumpInterval,
       playbackRates: playerOptions.playbackRates,
     )
-
-    engine.remoteCommands = remoteCommands
+    player?.setProgressUpdateInterval(playerOptions.progressUpdateEventInterval)
+    player?.setPlaybackIntervalEnabled(playerOptions.playbackIntervalEnabled)
   }
 
   func getOptions() throws -> Options {
@@ -137,7 +98,7 @@ public extension HybridAudioBrowser {
 
   func setPlaybackIntervalEnabled(enabled: Bool) {
     onMainActor {
-      playbackIntervalEnabled = enabled
+      playerOptions.playbackIntervalEnabled = enabled
       player?.setPlaybackIntervalEnabled(enabled)
     }
   }

package/ios/HybridAudioBrowser+Player.swift

@@ -230,7 +230,9 @@ public extension HybridAudioBrowser {
       try player.replace(player.queue.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))
+      let event = FavoriteChangedEvent(track: updated, favorited: favorited)
+      onFavoriteChanged(event)
+      favoriteChangedEmitter.emit(event)
       return true
     }
   }
@@ -334,64 +336,6 @@ public extension HybridAudioBrowser {
   }
 
   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)]"
+    DispatchQueue.main.async { OutputPicker.present() }
   }
 }