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

package/ios/CarPlay/IntentHandlers.swift

@@ -0,0 +1,96 @@
+import Foundation
+import Intents
+import os.log
+
+/// The library's Siri handlers, vended to the host app through `RNABAudioBrowser.handlerForIntent:`.
+@objc(RNABIntentHandlers)
+public final class IntentHandlers: NSObject {
+  /// A handler for `INPlayMediaIntent`, `INUpdateMediaAffinityIntent` and `INAddMediaIntent`;
+  /// nil for any other intent.
+  @objc(handlerForIntent:)
+  public static func handler(for intent: INIntent) -> Any? {
+    switch intent {
+    case is INPlayMediaIntent: MediaIntentHandler()
+    case is INUpdateMediaAffinityIntent, is INAddMediaIntent: FavoriteIntentHandler()
+    default: nil
+    }
+  }
+}
+
+/// "Add this to my favorites" and "I like / don't like this": sets the favorite state of the
+/// playing track, through the same path as the CarPlay favorite button. A named item that is
+/// not playing is out of scope.
+final class FavoriteIntentHandler: NSObject, INAddMediaIntentHandling, INUpdateMediaAffinityIntentHandling {
+  private static let logger = Logger(subsystem: "com.audiobrowser", category: "FavoriteIntentHandler")
+
+  func handle(intent _: INAddMediaIntent, completion: @escaping @Sendable (INAddMediaIntentResponse) -> Void) {
+    Self.logger.info("Add media — favorite current track")
+    Task { @MainActor in
+      let applied = Self.favoriteCurrentTrack(true)
+      completion(INAddMediaIntentResponse(code: applied ? .success : .failure, userActivity: nil))
+    }
+  }
+
+  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: Self.favoriteCurrentTrack(true)
+      case .dislike: Self.favoriteCurrentTrack(false)
+      default: false
+      }
+      completion(INUpdateMediaAffinityIntentResponse(code: applied ? .success : .failure, userActivity: nil))
+    }
+  }
+
+  // Siri fails an intent whose handler has no resolution method. They are optional @objc
+  // requirements, so each is pinned to the selector SiriKit calls. The handlers act on the
+  // playing track, so the spoken item passes through.
+
+  @objc(resolveMediaItemsForAddMedia:withCompletion:)
+  func resolveMediaItems(
+    for intent: INAddMediaIntent,
+    with completion: @escaping ([INAddMediaMediaItemResolutionResult]) -> Void,
+  ) {
+    completion([.success(with: Self.spokenItem(intent.mediaSearch))])
+  }
+
+  /// One flat favorites collection: always the user's library.
+  @objc(resolveMediaDestinationForAddMedia:withCompletion:)
+  func resolveMediaDestination(
+    for _: INAddMediaIntent,
+    with completion: @escaping (INAddMediaMediaDestinationResolutionResult) -> Void,
+  ) {
+    completion(.success(with: INMediaDestination.library))
+  }
+
+  @objc(resolveMediaItemsForUpdateMediaAffinity:withCompletion:)
+  func resolveMediaItems(
+    for intent: INUpdateMediaAffinityIntent,
+    with completion: @escaping ([INUpdateMediaAffinityMediaItemResolutionResult]) -> Void,
+  ) {
+    completion([.success(with: Self.spokenItem(intent.mediaSearch))])
+  }
+
+  private static func spokenItem(_ search: INMediaSearch?) -> INMediaItem {
+    let name = search?.mediaName ?? ""
+    return INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)
+  }
+
+  /// False when nothing is playing, the playing track has no identity to favorite, or the
+  /// change throws.
+  @MainActor
+  private static func favoriteCurrentTrack(_ favorited: Bool) -> Bool {
+    guard let browser = HybridAudioBrowser.shared else { return false }
+    do {
+      return try browser.favoriteActiveTrack(favorited)
+    } catch {
+      logger.error("favoriteCurrentTrack(\(favorited)) failed: \(error.localizedDescription)")
+      return false
+    }
+  }
+}

package/ios/CarPlay/MediaIntentCriteria.swift

@@ -3,7 +3,7 @@ import Foundation
 /// Normalized "what did the user ask to play", derived from a media intent.
 /// Deliberately free of `Intents` types so the core (`HybridAudioBrowser`)
 /// never imports the Intents framework — the mapping lives in the
-/// `Intents`-aware `RNABMediaIntentHandler`.
+/// `Intents`-aware `MediaIntentHandler`.
 public struct MediaIntentCriteria: Sendable {
   /// Media-reference axis (mirrors `INMediaReference`). `currentlyPlaying`
   /// routes to native resume and never reaches the consumer; `my` routes to
@@ -12,19 +12,16 @@ public struct MediaIntentCriteria: Sendable {
 
   let query: String
   let reference: Reference
-  let hasGenres: Bool
   let hasMediaType: Bool
-  /// True when `query` is effectively the host app's own name. Siri turns
-  /// "Play «app»" into a search for a word in the app name — e.g. "Play Radio
-  /// Garden" arrives as mediaName "Garden" (+ radio mediaType). That's an
-  /// app-open/resume, not a station search.
+  /// True when `query` is effectively the host app's own name. Siri turns "Play «App Name»"
+  /// into a search for a word of it ("Name", with a radio media type): an app-open or resume,
+  /// not a search.
   let matchesAppName: Bool
 
-  // Structured search payload, mirroring the shared `SearchParams`. Plain
-  // Sendable strings so this type stays in the unit-testable target; the Nitro
-  // `SearchParams` is assembled in the funnel.
-  /// The container-vertical `SearchMode` name, or nil. Comes ONLY from the
-  /// intent's media type — never derived from which filter field is set.
+  // Structured search payload, mirroring `SearchParams` in plain strings so this type stays in
+  // the SwiftPM target; the funnel builds the Nitro `SearchParams`.
+  /// The container-vertical `SearchMode` name, or nil. Comes only from the intent's media type,
+  /// never from which filter field is set.
   let searchMode: String?
   let genre: String?
   let artist: String?
@@ -32,30 +29,40 @@ public struct MediaIntentCriteria: Sendable {
   let title: String?
   let playlist: String?
 
+  /// Builds criteria from the raw fields of a media-search intent.
+  ///
+  /// `mediaTypeMode` is the `SearchMode` string for the intent's container vertical ("station",
+  /// "podcast", "song", …), or nil for a filter-only or unclassified type.
   init(
-    query: String,
+    mediaName: String?,
+    genreNames: [String],
+    artistName: String?,
+    albumName: String?,
+    mediaTypeMode: String?,
     reference: Reference,
-    hasGenres: Bool,
     hasMediaType: Bool,
-    matchesAppName: Bool,
-    searchMode: String? = nil,
-    genre: String? = nil,
-    artist: String? = nil,
-    album: String? = nil,
-    title: String? = nil,
-    playlist: String? = nil,
+    appName: String?,
   ) {
-    self.query = query
+    let name = (mediaName ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+    let trimmedNonEmpty: (String?) -> String? = {
+      let t = ($0 ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
+      return t.isEmpty ? nil : t
+    }
+
+    genre = genreNames.isEmpty ? nil : genreNames.joined(separator: " ")
+    artist = trimmedNonEmpty(artistName)
+    album = trimmedNonEmpty(albumName)
+    // song/playlist carry their spoken name into a dedicated field.
+    title = mediaTypeMode == "song" ? (name.isEmpty ? nil : name) : nil
+    playlist = mediaTypeMode == "playlist" ? (name.isEmpty ? nil : name) : nil
+
+    // Always populated, so search works before the API honours `mode`: the spoken name, else a
+    // structured value.
+    query = name.isEmpty ? (genre ?? artist ?? album ?? title ?? playlist ?? "") : name
     self.reference = reference
-    self.hasGenres = hasGenres
     self.hasMediaType = hasMediaType
-    self.matchesAppName = matchesAppName
-    self.searchMode = searchMode
-    self.genre = genre
-    self.artist = artist
-    self.album = album
-    self.title = title
-    self.playlist = playlist
+    matchesAppName = Self.queryMatchesAppName(query, appName: appName)
+    searchMode = mediaTypeMode
   }
 
   /// Resume vs search, by reference:
@@ -69,61 +76,12 @@ public struct MediaIntentCriteria: Sendable {
     case .unknown:
       let q = query.trimmingCharacters(in: .whitespacesAndNewlines)
       // "Play «app»": no search term and no other filter → resume.
-      if q.isEmpty { return !hasGenres && !hasMediaType }
+      if q.isEmpty { return genre == nil && !hasMediaType }
       // "Play «app-name»": resume — unless a real filter signals a search.
-      return matchesAppName && !hasGenres
+      return matchesAppName && genre == nil
     }
   }
 
-  /// Builds criteria from the raw fields of a media-search intent. Pure (no
-  /// `Intents`/`Bundle` dependency) so the whole Siri-phrase → search decision
-  /// is unit-testable.
-  ///
-  /// `mediaTypeMode` is the already-collapsed `SearchMode` string for the
-  /// intent's container vertical (e.g. "station"/"podcast"/"song"), or nil for
-  /// a filter-only / unclassified type. `reference` is the mapped axis.
-  static func from(
-    mediaName: String?,
-    genreNames: [String],
-    artistName: String?,
-    albumName: String?,
-    mediaTypeMode: String?,
-    reference: Reference,
-    hasMediaType: Bool,
-    appName: String?,
-  ) -> MediaIntentCriteria {
-    let name = (mediaName ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
-    let trimmedNonEmpty: (String?) -> String? = {
-      let t = ($0 ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
-      return t.isEmpty ? nil : t
-    }
-
-    let genre = genreNames.isEmpty ? nil : genreNames.joined(separator: " ")
-    let artist = trimmedNonEmpty(artistName)
-    let album = trimmedNonEmpty(albumName)
-    // song/playlist carry their spoken name into a dedicated field.
-    let title = mediaTypeMode == "song" ? (name.isEmpty ? nil : name) : nil
-    let playlist = mediaTypeMode == "playlist" ? (name.isEmpty ? nil : name) : nil
-
-    // `query` is always populated so search works even before the API honours
-    // `mode`: prefer the spoken name, else fall back to a structured value.
-    let query = name.isEmpty ? (genre ?? artist ?? album ?? title ?? playlist ?? "") : name
-
-    return MediaIntentCriteria(
-      query: query,
-      reference: reference,
-      hasGenres: !genreNames.isEmpty,
-      hasMediaType: hasMediaType,
-      matchesAppName: queryMatchesAppName(query, appName: appName),
-      searchMode: mediaTypeMode, // mode is the vertical, verbatim — no derivation
-      genre: genre,
-      artist: artist,
-      album: album,
-      title: title,
-      playlist: playlist,
-    )
-  }
-
   /// Whether `query` is effectively the host app's own name. Case- and
   /// diacritic-insensitive.
   ///

package/ios/CarPlay/{RNABMediaIntentHandler.swift → MediaIntentHandler.swift}

@@ -2,18 +2,15 @@ import Foundation
 import Intents
 import os.log
 
-/// In-app INPlayMediaIntent handler (Siri / CarPlay voice). Internal so Intents
-/// types stay out of the generated header; exposed to the ObjC runtime via
-/// `@objc(RNABMediaIntentHandler)` and vended from `RNABAudioBrowser.handlerForIntent(_:)`.
-@objc(RNABMediaIntentHandler)
-class RNABMediaIntentHandler: NSObject, INPlayMediaIntentHandling {
+/// Siri's play-media intent, from the phone or CarPlay voice: plays through `MediaIntentPlayback`.
+final class MediaIntentHandler: NSObject, INPlayMediaIntentHandling {
   private static let logger = Logger(subsystem: "com.audiobrowser", category: "MediaIntentHandler")
 
   // MARK: - INPlayMediaIntentHandling
 
   func handle(intent: INPlayMediaIntent, completion: @escaping @Sendable (INPlayMediaIntentResponse) -> Void) {
     let s = intent.mediaSearch
-    let criteria = MediaIntentCriteria.from(
+    let criteria = MediaIntentCriteria(
       mediaName: s?.mediaName,
       genreNames: s?.genreNames ?? [],
       artistName: s?.artistName,

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/CarPlay/NowPlayingButtonRules.swift

@@ -0,0 +1,35 @@
+/// What CarPlay's Now Playing custom buttons show and do.
+enum NowPlayingButtonRules {
+  /// `CPNowPlayingTemplate` takes at most five custom buttons and does not say what happens to
+  /// more.
+  static let maximumButtonCount = 5
+
+  /// The configured buttons, first occurrence of each kept, capped at `maximumButtonCount`:
+  /// the configuration comes from JS, where duplicates and excess are representable.
+  static func buttons<Button: Equatable>(_ configured: [Button]) -> [Button] {
+    var buttons: [Button] = []
+    for button in configured where !buttons.contains(button) {
+      buttons.append(button)
+    }
+    return Array(buttons.prefix(maximumButtonCount))
+  }
+
+  /// The repeat button cycles off → track → queue → off.
+  static func repeatMode(after mode: RepeatMode) -> RepeatMode {
+    switch mode {
+    case .off: .track
+    case .track: .queue
+    case .queue: .off
+    }
+  }
+
+  /// The rate after `current` in `rates`: the next one, wrapping, when `current` is one of them;
+  /// else the first rate above it, else the first. Nil when there are no rates.
+  static func rate(after current: Double, in rates: [Double]) -> Double? {
+    guard !rates.isEmpty else { return nil }
+    if let index = rates.firstIndex(where: { (current - $0).magnitude < 0.01 }) {
+      return rates[(index + 1) % rates.count]
+    }
+    return rates.first { $0 > current } ?? rates[0]
+  }
+}

package/ios/CarPlay/RNABAudioBrowser.m

@@ -1,23 +1,15 @@
 #import "RNABAudioBrowser.h"
 
+#if __has_include(<AudioBrowser/AudioBrowser-Swift.h>)
+#import <AudioBrowser/AudioBrowser-Swift.h>
+#elif __has_include("AudioBrowser-Swift.h")
+#import "AudioBrowser-Swift.h"
+#endif
+
 @implementation RNABAudioBrowser
 
 + (nullable id)handlerForIntent:(INIntent *)intent {
-    // The handlers are internal Swift classes exposed to the ObjC runtime via
-    // @objc(...); each conforms to the matching INIntentHandling protocol.
-    NSString *handlerClassName = nil;
-    if ([intent isKindOfClass:[INPlayMediaIntent class]]) {
-        handlerClassName = @"RNABMediaIntentHandler";
-    } else if ([intent isKindOfClass:[INUpdateMediaAffinityIntent class]]) {
-        handlerClassName = @"RNABMediaAffinityHandler";
-    } else if ([intent isKindOfClass:[INAddMediaIntent class]]) {
-        handlerClassName = @"RNABMediaAddHandler";
-    }
-    if (!handlerClassName) {
-        return nil;
-    }
-    Class cls = NSClassFromString(handlerClassName);
-    return cls ? [[cls alloc] init] : nil;
+    return [RNABIntentHandlers handlerForIntent:intent];
 }
 
 @end

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 {