@5stones/react-native-audio-browser 0.1.0

package/ios/NowPlayingInfo/NowPlayingInfoController.swift

@@ -0,0 +1,283 @@
+import AVFoundation
+import Foundation
+@preconcurrency import MediaPlayer
+import os.log
+
+// MPRemoteCommandCenter is not Sendable, but we only use it on the main thread
+extension MPRemoteCommandCenter: @retroactive @unchecked Sendable {}
+
+/// Wrapper to pass non-Sendable values across concurrency boundaries.
+/// Only use when you know the value is safe to transfer (e.g., value types, immutable objects).
+private struct UncheckedSendableBox<T>: @unchecked Sendable {
+  let value: T
+}
+
+/// Thread-safe controller for managing Now Playing info.
+///
+/// On iOS 16+, uses `MPNowPlayingSession` with `automaticallyPublishNowPlayingInfo` to let the system
+/// automatically update elapsed time, playback rate, and duration. We still manually set metadata
+/// (title, artist, artwork) which the automatic publishing doesn't handle.
+///
+/// On iOS 15.x, falls back to manual `MPNowPlayingInfoCenter` updates for all properties.
+///
+/// Thread safety is managed via a concurrent DispatchQueue with barriers.
+class NowPlayingInfoController: @unchecked Sendable {
+  private let logger = Logger(subsystem: "com.audiobrowser", category: "NowPlayingInfoController")
+  private var infoQueue = DispatchQueue(
+    label: "NowPlayingInfoController.infoQueue",
+    attributes: .concurrent,
+  )
+
+  private(set) var infoCenter: NowPlayingInfoCenter
+  private var _info: [String: Any] = [:]
+
+  /// Wrapper for MPNowPlayingSession (iOS 16+) to avoid @available on stored property
+  private var _nowPlayingSession: Any?
+
+  /// The linked AVPlayer (iOS 16+)
+  private weak var _linkedPlayer: AVPlayer?
+
+  /// Whether automatic publishing is currently active (iOS 16+ with linked player)
+  private var isAutomaticPublishingEnabled: Bool = false
+
+  /// The current remote command center - either the session's (iOS 16+) or shared
+  private var _remoteCommandCenter: MPRemoteCommandCenter = .shared()
+
+  /// Returns the appropriate remote command center.
+  /// On iOS 16+ with an active session, returns the session's command center.
+  /// Otherwise returns the shared command center.
+  var remoteCommandCenter: MPRemoteCommandCenter {
+    infoQueue.sync { _remoteCommandCenter }
+  }
+
+  /// Thread-safe access to the current Now Playing info dictionary
+  var info: [String: Any] {
+    infoQueue.sync { _info }
+  }
+
+  required init() {
+    infoCenter = MPNowPlayingInfoCenter.default()
+  }
+
+  required init(infoCenter: NowPlayingInfoCenter) {
+    self.infoCenter = infoCenter
+  }
+
+  /// Callback invoked when the remote command center changes (iOS 16+ session created/destroyed)
+  /// Called on the main thread.
+  /// Note: MPRemoteCommandCenter is not Sendable, but this callback is always invoked on main thread
+  nonisolated(unsafe) var onRemoteCommandCenterChanged: ((MPRemoteCommandCenter) -> Void)?
+
+  /// Links an AVPlayer to enable automatic Now Playing publishing on iOS 16+.
+  /// On older iOS versions, this is a no-op.
+  ///
+  /// When linked:
+  /// - System automatically updates elapsed time, playback rate, and duration
+  /// - Metadata (title, artist, artwork) is set via `AVPlayerItem.nowPlayingInfo`
+  /// - The session's `remoteCommandCenter` must be used for remote commands
+  ///
+  /// - Important: On iOS 16+, this creates an `MPNowPlayingSession` with its own `remoteCommandCenter`.
+  ///   The `onRemoteCommandCenterChanged` callback will be invoked with the new command center.
+  func linkPlayer(_ player: AVPlayer) {
+    if #available(iOS 16.0, *) {
+      // Box callback to safely cross concurrency boundary
+      let boxedCallback = UncheckedSendableBox(value: onRemoteCommandCenterChanged)
+      infoQueue.async(flags: .barrier) {
+        self.logger.info("Linking AVPlayer to MPNowPlayingSession for automatic publishing")
+
+        // Store player reference
+        self._linkedPlayer = player
+
+        // Create a new session with the player (players is read-only after init)
+        let session = MPNowPlayingSession(players: [player])
+        self._nowPlayingSession = session
+
+        // Use the session's remote command center instead of the shared one
+        self._remoteCommandCenter = session.remoteCommandCenter
+
+        // Enable automatic publishing - system tracks elapsed time and duration from AVPlayer
+        session.automaticallyPublishesNowPlayingInfo = true
+
+        // Become the active session
+        session.becomeActiveIfPossible { success in
+          self.logger.info("MPNowPlayingSession becomeActiveIfPossible: \(success)")
+        }
+
+        self.isAutomaticPublishingEnabled = true
+
+        // Notify about the command center change on main thread
+        let newCommandCenter = self._remoteCommandCenter
+        DispatchQueue.main.async {
+          boxedCallback.value?(newCommandCenter)
+        }
+      }
+    } else {
+      logger.debug("linkPlayer: iOS 16+ required for automatic publishing, using manual updates")
+    }
+  }
+
+  /// Unlinks the AVPlayer, disabling automatic publishing.
+  func unlinkPlayer() {
+    if #available(iOS 16.0, *) {
+      // Box callback to safely cross concurrency boundary
+      let boxedCallback = UncheckedSendableBox(value: onRemoteCommandCenterChanged)
+      infoQueue.async(flags: .barrier) {
+        self.logger.info("Unlinking AVPlayer from MPNowPlayingSession")
+
+        // Clear player reference
+        self._linkedPlayer = nil
+
+        // Disable automatic publishing and release the session
+        if let session = self._nowPlayingSession as? MPNowPlayingSession {
+          session.automaticallyPublishesNowPlayingInfo = false
+        }
+        self._nowPlayingSession = nil
+        self.isAutomaticPublishingEnabled = false
+
+        // Revert to shared command center
+        self._remoteCommandCenter = MPRemoteCommandCenter.shared()
+
+        // Notify about the command center change on main thread
+        let newCommandCenter = self._remoteCommandCenter
+        DispatchQueue.main.async {
+          boxedCallback.value?(newCommandCenter)
+        }
+      }
+    }
+  }
+
+  /// Keys that are automatically published by MPNowPlayingSession on iOS 16+.
+  /// When automatic publishing is enabled, we skip setting these manually.
+  private static let autoPublishedKeys: Set<String> = [
+    MPNowPlayingInfoPropertyElapsedPlaybackTime,
+    MPMediaItemPropertyPlaybackDuration,
+    MPNowPlayingInfoPropertyPlaybackRate,
+  ]
+
+  /// Returns true if the key is auto-published and automatic publishing is enabled
+  private func shouldSkipKey(_ key: String) -> Bool {
+    isAutomaticPublishingEnabled && Self.autoPublishedKeys.contains(key)
+  }
+
+  /// Sets key-values and immediately updates the Now Playing Info Center.
+  /// When automatic publishing is enabled (iOS 16+), playback-related keys are skipped.
+  func set(keyValues: [NowPlayingInfoKeyValue]) {
+    // Extract and box key-value pairs before closure to safely cross concurrency boundary
+    let boxedPairs = UncheckedSendableBox(value: keyValues.map { ($0.key, $0.value) })
+    infoQueue.async(flags: .barrier) {
+      for (key, value) in boxedPairs.value {
+        if !self.shouldSkipKey(key) {
+          self._info[key] = value
+        }
+      }
+      self.performUpdate()
+    }
+  }
+
+  /// Sets key-values without updating the Now Playing Info Center.
+  /// Useful for batching multiple updates - call update() when ready to commit.
+  /// When automatic publishing is enabled (iOS 16+), playback-related keys are skipped.
+  func setWithoutUpdate(keyValues: [NowPlayingInfoKeyValue]) {
+    // Extract and box key-value pairs before closure to safely cross concurrency boundary
+    let boxedPairs = UncheckedSendableBox(value: keyValues.map { ($0.key, $0.value) })
+    infoQueue.async(flags: .barrier) {
+      for (key, value) in boxedPairs.value {
+        if !self.shouldSkipKey(key) {
+          self._info[key] = value
+        }
+      }
+    }
+  }
+
+  /// Sets a single key-value and immediately updates the Now Playing Info Center.
+  /// When automatic publishing is enabled (iOS 16+), playback-related keys are skipped.
+  func set(keyValue: NowPlayingInfoKeyValue) {
+    // Box key and value before closure to safely cross concurrency boundary
+    let key = keyValue.key
+    let boxedValue = UncheckedSendableBox(value: keyValue.value)
+    infoQueue.async(flags: .barrier) {
+      if !self.shouldSkipKey(key) {
+        self._info[key] = boxedValue.value
+        self.performUpdate()
+      }
+    }
+  }
+
+  /// Explicitly updates the Now Playing Info Center with the current info.
+  /// Thread-safe - can be called from any thread.
+  /// Use after calling setWithoutUpdate() to commit batched changes.
+  func update() {
+    infoQueue.async(flags: .barrier) {
+      self.performUpdate()
+    }
+  }
+
+  /// Internal update method - assumes already inside barrier block.
+  /// Use this from internal methods that are already synchronized to avoid nested dispatch.
+  ///
+  /// On iOS 16+ with automatic publishing:
+  /// - Sets metadata on `AVPlayerItem.nowPlayingInfo`
+  /// - Skips elapsed time and duration (system handles these)
+  ///
+  /// On iOS 15.x or without automatic publishing:
+  /// - Sets all info on `MPNowPlayingInfoCenter.default().nowPlayingInfo`
+  private func performUpdate() {
+    let keys = _info.keys.sorted().joined(separator: ", ")
+    let hasArtwork = _info[MPMediaItemPropertyArtwork] != nil
+    let playbackRate = _info[MPNowPlayingInfoPropertyPlaybackRate] as? NSNumber
+    logger.debug("performUpdate: setting nowPlayingInfo with \(self._info.count) keys (hasArtwork=\(hasArtwork), playbackRate=\(playbackRate?.doubleValue ?? -1), autoPublishing=\(self.isAutomaticPublishingEnabled)): \(keys)")
+
+    if #available(iOS 16.0, *), isAutomaticPublishingEnabled {
+      // iOS 16+ with automatic publishing: set metadata on player item
+      // If no current item yet, info is stored in _info and will be applied when reapplyToCurrentItem() is called
+      // AVPlayerItem.nowPlayingInfo is MainActor-isolated, so dispatch to main thread
+      let info = _info
+      let player = _linkedPlayer
+      DispatchQueue.main.async {
+        player?.currentItem?.nowPlayingInfo = info
+      }
+    } else {
+      // iOS 15.x or no automatic publishing: use MPNowPlayingInfoCenter
+      infoCenter.nowPlayingInfo = _info
+    }
+  }
+
+  /// Prepares an AVPlayerItem with stored metadata before it becomes current.
+  /// Call this before `replaceCurrentItem(with:)` so the item has metadata from the start.
+  /// Must be called from the main thread since AVPlayerItem.nowPlayingInfo is MainActor-isolated.
+  @MainActor
+  func prepareItem(_ item: AVPlayerItem) {
+    // Read state synchronously from the queue
+    let (shouldApply, info) = infoQueue.sync {
+      if #available(iOS 16.0, *) {
+        return (isAutomaticPublishingEnabled, _info)
+      }
+      return (false, [:] as [String: Any])
+    }
+    // Apply on main thread (we're already on main due to @MainActor)
+    if #available(iOS 16.0, *), shouldApply {
+      item.nowPlayingInfo = info
+    }
+  }
+
+  /// Clears all Now Playing info
+  func clear() {
+    infoQueue.async(flags: .barrier) {
+      self._info = [:]
+
+      // With automatic publishing, the session handles clearing when the player stops
+      // Without automatic publishing, we need to clear MPNowPlayingInfoCenter manually
+      if !self.isAutomaticPublishingEnabled {
+        self.infoCenter.nowPlayingInfo = nil
+      }
+    }
+  }
+
+  /// Sets the playback state (required for CarPlay Now Playing to show correct play/pause state)
+  func setPlaybackState(_ state: MPNowPlayingPlaybackState) {
+    infoQueue.async(flags: .barrier) {
+      self.logger.debug("setPlaybackState: \(state.rawValue)")
+      self.infoCenter.playbackState = state
+    }
+  }
+}

package/ios/NowPlayingInfo/NowPlayingInfoKeyValue.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+protocol NowPlayingInfoKeyValue {
+  var key: String { get }
+  var value: Any? { get }
+}

package/ios/NowPlayingInfo/NowPlayingInfoProperty.swift

@@ -0,0 +1,220 @@
+import Foundation
+@preconcurrency import MediaPlayer
+
+/**
+ Enum representing MPNowPlayingInfoProperties.
+ Docs for each property is taken from [Apple docs](https://developer.apple.com/documentation/mediaplayer/mpnowplayinginfocenter/additional_metadata_properties).
+ */
+enum NowPlayingInfoProperty: NowPlayingInfoKeyValue {
+  /**
+   The identifier of the collection the now playing item belongs to.
+   The identifier can be an album, artist, playlist, etc.
+   */
+  case collectionIdentifier(String?)
+
+  /**
+   The available language option groups for the now playing item.
+   Value is an array of MPNowPlayingInfoLanguageOptionGroup items. Only one language option in a given group can be played at a time.
+   */
+  case availableLanguageOptions([MPNowPlayingInfoLanguageOptionGroup]?)
+
+  /**
+   The URL pointing to the now playing item's underlying asset.
+   This constant is used by the system UI when video thumbnails or audio waveform visualizations are applicable.
+   */
+  case assetUrl(URL?)
+
+  /**
+   The total number of chapters in the now-playing item.
+   Value is an NSNumber object configured as an NSUInteger.
+   */
+  case chapterCount(UInt64?)
+
+  /**
+   The number corresponding to the chapter currently being played.
+   Value is an NSNumber object configured as an NSUInteger. Chapter numbering uses zero-based indexing. If you want the first chapter in the now-playing item to be displayed as “Chapter 1,” for example, set the chapter number to 0.
+   */
+  case chapterNumber(UInt64?)
+
+  /**
+   The currently active language options for the now playing item.
+   Value is an array of MPNowPlayingInfoLanguageOption items.
+   */
+  case currentLanguageOptions([MPNowPlayingInfoLanguageOption]?)
+
+  /**
+   The default playback rate for the now playing item.
+   Value is an NSNumber object configured as a double. Set this property if your app is playing a media item at a playback rate other than 1.0 as its default rate.
+   */
+  case defaultPlaybackRate(Double?)
+
+  /**
+   The elapsed time of the now playing item, in seconds.
+   Value is an NSNumber object configured as a double. Elapsed time is automatically calculated, by the system, from the previously provided elapsed time and the playback rate. Do not update this property frequently—it is not necessary
+   */
+  case elapsedPlaybackTime(Double?)
+
+  /**
+   The opaque identifier that uniquely identifies the now playing item, even through app relaunches.
+   This is only used to reference the item to the now playing app and can be in any format.
+   */
+  case externalContentIdentifier(Any?)
+
+  /**
+   The opaque identifier that uniquely identifies the profile the now playing item is played from, even through app relaunches.
+   This is only used to reference the profile to the now playing app and can be in any format.
+   */
+  case externalUserProfileIdentifier(Any?)
+
+  /**
+   Denotes whether the now playing item is a live stream.
+   Value is an NSNumber object configured as a boolean. A value of 1.0 indicates the now playing item is a live stream.
+   */
+  case isLiveStream(Bool?)
+
+  /**
+   The media type of the now playing item.
+   Value is an NSNumber object configured as a MPNowPlayingInfoMediaType.
+   */
+  case mediaType(MPNowPlayingInfoMediaType?)
+
+  /**
+   The current progress of the now playing item.
+   Value is an NSNumber object configured as a float. A value of 0.0 indicates the item has not been watched while a value of 1.0 indicates the item has been fully watched. This is a high-level indicator. Use MPNowPlayingInfoPropertyElapsedPlaybackTime for fine-detailed information on how much of the item has been watched.
+   */
+  case playbackProgress(Float?)
+
+  /**
+   The total number of items in the app’s playback queue.
+   Value is an NSNumber object configured as an NSUInteger.
+   */
+  case playbackQueueCount(UInt64?)
+
+  /**
+   The index of the now-playing item in the app’s playback queue.
+   Value is an NSNumber object configured as an NSUInteger. The playback queue uses zero-based indexing. If you want the first item in the queue to be displayed as “item 1 of 10,” for example, set the item’s index to 0.
+   */
+  case playbackQueueIndex(UInt64?)
+
+  /**
+   The playback rate of the now-playing item, with a value of 1.0 indicating the normal playback rate.
+   Value is an NSNumber object configured as a double. The default value is 1.0. A playback rate value of 2.0 means twice the normal playback rate; a piece of media played at this rate would take half as long to play to completion. A value of 0.5 means half the normal playback rate; a piece of media played at this rate would take twice as long to play to completion.
+   */
+  case playbackRate(Double?)
+
+  /**
+   The service provider associated with the now-playing item.
+   Value is a unique NSString that identifies the service provider for the now-playing item. If the now-playing item belongs to a channel or subscription service, this key can be used to coordinate various types of now-playing content from the service provider.
+   */
+  case serviceIdentifier(String?)
+
+  var key: String {
+    switch self {
+    case .collectionIdentifier:
+      MPNowPlayingInfoCollectionIdentifier
+
+    case .availableLanguageOptions:
+      MPNowPlayingInfoPropertyAvailableLanguageOptions
+
+    case .assetUrl:
+      MPNowPlayingInfoPropertyAssetURL
+
+    case .chapterCount:
+      MPNowPlayingInfoPropertyChapterCount
+
+    case .chapterNumber:
+      MPNowPlayingInfoPropertyChapterNumber
+
+    case .currentLanguageOptions:
+      MPNowPlayingInfoPropertyCurrentLanguageOptions
+
+    case .defaultPlaybackRate:
+      MPNowPlayingInfoPropertyDefaultPlaybackRate
+
+    case .elapsedPlaybackTime:
+      MPNowPlayingInfoPropertyElapsedPlaybackTime
+
+    case .externalContentIdentifier:
+      MPNowPlayingInfoPropertyExternalContentIdentifier
+
+    case .externalUserProfileIdentifier:
+      MPNowPlayingInfoPropertyExternalUserProfileIdentifier
+
+    case .isLiveStream:
+      MPNowPlayingInfoPropertyIsLiveStream
+
+    case .mediaType:
+      MPNowPlayingInfoPropertyMediaType
+
+    case .playbackProgress:
+      MPNowPlayingInfoPropertyPlaybackProgress
+
+    case .playbackQueueCount:
+      MPNowPlayingInfoPropertyPlaybackQueueCount
+
+    case .playbackQueueIndex:
+      MPNowPlayingInfoPropertyPlaybackQueueIndex
+
+    case .playbackRate:
+      MPNowPlayingInfoPropertyPlaybackRate
+
+    case .serviceIdentifier:
+      MPNowPlayingInfoPropertyServiceIdentifier
+    }
+  }
+
+  var value: Any? {
+    switch self {
+    case let .collectionIdentifier(identifier):
+      identifier
+
+    case let .availableLanguageOptions(options):
+      options
+
+    case let .assetUrl(url):
+      url
+
+    case let .chapterCount(count):
+      count != nil ? NSNumber(value: count!) : nil
+
+    case let .chapterNumber(number):
+      number != nil ? NSNumber(value: number!) : nil
+
+    case let .currentLanguageOptions(options):
+      options
+
+    case let .defaultPlaybackRate(rate):
+      rate != nil ? NSNumber(floatLiteral: rate!) : nil
+
+    case let .elapsedPlaybackTime(time):
+      time != nil ? NSNumber(floatLiteral: time!) : nil
+
+    case let .externalContentIdentifier(id):
+      id
+
+    case let .externalUserProfileIdentifier(id):
+      id
+
+    case let .isLiveStream(status):
+      status
+
+    case let .mediaType(type):
+      type != nil ? NSNumber(value: type!.rawValue) : nil
+
+    case let .playbackProgress(progress):
+      progress != nil ? NSNumber(value: progress!) : nil
+
+    case let .playbackQueueCount(count):
+      count != nil ? NSNumber(value: count!) : nil
+
+    case let .playbackQueueIndex(index):
+      index != nil ? NSNumber(value: index!) : nil
+
+    case let .playbackRate(rate):
+      rate != nil ? NSNumber(floatLiteral: rate!) : nil
+
+    case let .serviceIdentifier(id):
+      id != nil ? NSString(string: id!) : nil
+    }
+  }
+}

package/ios/Observer/PlayerItemNotificationObserver.swift

@@ -0,0 +1,83 @@
+import AVFoundation
+import Foundation
+
+/**
+ Observes player item notifications and invokes callbacks passed at initialization.
+ */
+class PlayerItemNotificationObserver {
+  private let notificationCenter: NotificationCenter = .default
+
+  private(set) weak var observingAVItem: AVPlayerItem?
+  private(set) var isObserving: Bool = false
+
+  private let onDidPlayToEndTime: @Sendable () -> Void
+  private let onFailedToPlayToEndTime: @Sendable (Error?) -> Void
+
+  init(
+    onDidPlayToEndTime: @escaping @Sendable () -> Void,
+    onFailedToPlayToEndTime: @escaping @Sendable (Error?) -> Void,
+  ) {
+    self.onDidPlayToEndTime = onDidPlayToEndTime
+    self.onFailedToPlayToEndTime = onFailedToPlayToEndTime
+  }
+
+  deinit {
+    stopObservingCurrentItem()
+  }
+
+  /**
+   Will start observing notifications from an AVPlayerItem.
+
+   - parameter avItem: The AVPlayerItem to observe.
+   - important: Cannot observe more than one item at a time.
+   */
+  func startObserving(item avItem: AVPlayerItem) {
+    stopObservingCurrentItem()
+    observingAVItem = avItem
+    isObserving = true
+    notificationCenter.addObserver(
+      self,
+      selector: #selector(avItemDidPlayToEndTime),
+      name: NSNotification.Name.AVPlayerItemDidPlayToEndTime,
+      object: avItem,
+    )
+    notificationCenter.addObserver(
+      self,
+      selector: #selector(avItemFailedToPlayToEndTime(_:)),
+      name: NSNotification.Name.AVPlayerItemFailedToPlayToEndTime,
+      object: avItem,
+    )
+  }
+
+  /**
+   Stop receiving notifications for the current AVPlayerItem.
+   */
+  func stopObservingCurrentItem() {
+    guard let observingAVItem, isObserving else {
+      return
+    }
+    notificationCenter.removeObserver(
+      self,
+      name: NSNotification.Name.AVPlayerItemDidPlayToEndTime,
+      object: observingAVItem,
+    )
+    notificationCenter.removeObserver(
+      self,
+      name: NSNotification.Name.AVPlayerItemFailedToPlayToEndTime,
+      object: observingAVItem,
+    )
+    self.observingAVItem = nil
+    isObserving = false
+  }
+
+  @objc private func avItemDidPlayToEndTime() {
+    onDidPlayToEndTime()
+  }
+
+  @objc private func avItemFailedToPlayToEndTime(_ notification: Notification) {
+    // Extract the error from the notification's userInfo
+    // AVPlayerItemFailedToPlayToEndTimeErrorKey contains the actual error
+    let error = notification.userInfo?[AVPlayerItemFailedToPlayToEndTimeErrorKey] as? Error
+    onFailedToPlayToEndTime(error)
+  }
+}