react-native-audio-browser 0.1.1 → 0.2.0-next.2

package/ios/CarPlay/RNABCarPlaySceneDelegate.m

@@ -34,6 +34,7 @@ API_AVAILABLE(ios(14.0))
     }
 
     // Create and start the CarPlay controller
+    [RNABCarPlayController setConnected:YES];
     self.carPlayController = [[RNABCarPlayController alloc] initWithInterfaceController:interfaceController];
     [self.carPlayController start];
 }
@@ -44,6 +45,7 @@ API_AVAILABLE(ios(14.0))
 
     [self.carPlayController stop];
     self.carPlayController = nil;
+    [RNABCarPlayController setConnected:NO];
 }
 
 - (void)templateApplicationScene:(CPTemplateApplicationScene *)templateApplicationScene

package/ios/CarPlay/RNABMediaAddHandler.swift

@@ -0,0 +1,75 @@
+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
+      // "Add" targets the current track; if nothing is playing there's nothing
+      // to add, so the assistant reports failure rather than a silent no-op.
+      guard let browser = HybridAudioBrowser.shared,
+            browser.getPlayer()?.currentTrack != nil
+      else {
+        completion(INAddMediaIntentResponse(code: .failure, userActivity: nil))
+        return
+      }
+
+      // Add = favorite the currently-playing track (same path as the CarPlay
+      // favorite button / affinity "like"): flips the now-playing heart and
+      // fires `onFavoriteChanged` so the consumer persists it — no extra handler.
+      do {
+        try browser.setActiveTrackFavorited(favorited: true)
+        completion(INAddMediaIntentResponse(code: .success, userActivity: nil))
+      } catch {
+        completion(INAddMediaIntentResponse(code: .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 intent: 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

@@ -0,0 +1,69 @@
+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
+      // Affinity targets the current track; if nothing is playing there's nothing
+      // to like, so the assistant reports failure rather than a silent no-op.
+      guard let browser = HybridAudioBrowser.shared,
+            browser.getPlayer()?.currentTrack != nil
+      else {
+        completion(INUpdateMediaAffinityIntentResponse(code: .failure, userActivity: nil))
+        return
+      }
+
+      // Map affinity onto the library-managed favorite state (same path as the
+      // CarPlay favorite button): flips the now-playing heart and fires
+      // `onFavoriteChanged` so the consumer persists it — no extra handler.
+      switch affinity {
+      case .like:
+        try? browser.setActiveTrackFavorited(favorited: true)
+      case .dislike:
+        try? browser.setActiveTrackFavorited(favorited: false)
+      default:
+        completion(INUpdateMediaAffinityIntentResponse(code: .failure, userActivity: nil))
+        return
+      }
+      completion(INUpdateMediaAffinityIntentResponse(code: .success, 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/CarPlay/RNABMediaIntentHandler.swift

@@ -2,59 +2,69 @@ import Foundation
 import Intents
 import os.log
 
-/// Handles INPlayMediaIntent for Siri voice search (e.g. from CarPlay).
-///
-/// The class is internal (not public) to avoid exposing Intents types in the
-/// generated AudioBrowser-Swift.h header, but is registered with the ObjC
-/// runtime via `@objc(RNABMediaIntentHandler)` for NSClassFromString lookup.
-///
-/// Host apps call the static method from `application(_:handle:completionHandler:)`:
-/// ```swift
-/// @objc private protocol RNABMediaIntentHandling {
-///   static func handleMediaIntent(_ intent: INIntent, completionHandler: @escaping (INIntentResponse) -> Void)
-/// }
-///
-/// func application(_ application: UIApplication, handle intent: INIntent, completionHandler: @escaping (INIntentResponse) -> Void) {
-///   (NSClassFromString("RNABMediaIntentHandler") as? RNABMediaIntentHandling.Type)?
-///     .handleMediaIntent(intent, completionHandler: completionHandler)
-/// }
-/// ```
+/// 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 {
   private static let logger = Logger(subsystem: "com.audiobrowser", category: "MediaIntentHandler")
 
-  // MARK: - Static Entry Point
-
-  /// Convenience entry point for host apps. Handles the full INPlayMediaIntent flow:
-  /// type checking, search, queue, and playback.
-  @objc static func handleMediaIntent(_ intent: INIntent, completionHandler: @escaping @Sendable (INIntentResponse) -> Void) {
-    guard let playIntent = intent as? INPlayMediaIntent else {
-      completionHandler(INPlayMediaIntentResponse(code: .failure, userActivity: nil))
-      return
-    }
-    let handler = RNABMediaIntentHandler()
-    handler.handle(intent: playIntent) { response in
-      completionHandler(response)
-    }
-  }
-
   // MARK: - INPlayMediaIntentHandling
 
   func handle(intent: INPlayMediaIntent, completion: @escaping @Sendable (INPlayMediaIntentResponse) -> Void) {
-    let searchTerm = intent.mediaSearch?.mediaName ?? ""
-    Self.logger.info("Handling play media intent with search term: \(searchTerm)")
+    let s = intent.mediaSearch
+    let criteria = MediaIntentCriteria.from(
+      mediaName: s?.mediaName,
+      genreNames: s?.genreNames ?? [],
+      artistName: s?.artistName,
+      albumName: s?.albumName,
+      mediaTypeMode: Self.mediaTypeMode(s?.mediaType ?? .unknown),
+      reference: Self.reference(s?.reference ?? .unknown),
+      hasMediaType: (s?.mediaType ?? .unknown) != .unknown,
+      appName: Self.hostAppName()
+    )
+    Self.logger.info("Play media intent — query=\(criteria.query) matchesApp=\(criteria.matchesAppName) resume=\(criteria.isResume)")
 
-    guard let browser = HybridAudioBrowser.shared else {
-      Self.logger.error("HybridAudioBrowser.shared is nil — app may not be initialized yet")
-      completion(INPlayMediaIntentResponse(code: .failureRequiringAppLaunch, userActivity: nil))
-      return
+    // Static + gate-waiting, so it works even before the shared instance exists
+    // (background intent launch, RN not booted yet).
+    HybridAudioBrowser.handlePlayMediaIntent(criteria: criteria) { success in
+      completion(INPlayMediaIntentResponse(code: success ? .success : .failure, userActivity: nil))
     }
+  }
 
-    browser.handlePlayMediaIntent(searchTerm: searchTerm) { success in
-      completion(INPlayMediaIntentResponse(
-        code: success ? .success : .failure,
-        userActivity: nil,
-      ))
+  /// Collapse `INMediaItemType` to a `SearchMode` string (the container
+  /// vertical), or nil for filter-only / unclassified types. `genre`/`artist`/
+  /// `album` are filters, not verticals — they yield no mode.
+  private static func mediaTypeMode(_ type: INMediaItemType) -> String? {
+    switch type {
+    case .station, .radioStation, .algorithmicRadioStation, .musicStation: return "station"
+    case .podcastShow, .podcastEpisode, .podcastPlaylist, .podcastStation:  return "podcast"
+    case .audioBook:       return "audiobook"
+    case .news:            return "news"
+    case .music:           return "music"
+    case .song:            return "song"
+    case .playlist:        return "playlist"
+    case .musicVideo:      return "music-video"
+    case .movie:           return "movie"
+    case .tvShow:          return "tv-show"
+    case .tvShowEpisode:   return "tv-show-episode"
+    default:               return nil   // album/artist/genre/unknown
     }
   }
+
+  /// Map the SiriKit reference to the pure criteria enum. `.currentlyPlaying`
+  /// routes to native resume; `.my` to the consumer; everything else is unknown.
+  private static func reference(_ ref: INMediaReference) -> MediaIntentCriteria.Reference {
+    switch ref {
+    case .currentlyPlaying: return .currentlyPlaying
+    case .my:               return .my
+    default:                return .unknown
+    }
+  }
+
+  /// Host app's display name, used to recognise "Play «app»" as a resume.
+  private static func hostAppName() -> String? {
+    let info = Bundle.main.infoDictionary
+    return (info?["CFBundleDisplayName"] as? String) ?? (info?["CFBundleName"] as? String)
+  }
 }

package/ios/Extension/Capability+RemoteCommand.swift

@@ -48,15 +48,13 @@ extension PlayerCapabilities {
       ))
     }
 
-    // TODO: Investigate where localizedTitle/localizedShortTitle are displayed
-    // (possibly only for accessibility/VoiceOver). See TODO.md for details.
-    if favorite != false {
-      commands.append(.like(
-        isActive: false,
-        localizedTitle: "Favorite",
-        localizedShortTitle: "Favorite",
-      ))
-    }
+    // 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
+    // favorites-match row indicators via setFavoriteMatch. See issues #67 / #71.
 
     // Mode controls
     if shuffleMode != false {

package/ios/Extension/ChapterMetadata+AVFoundation.swift

@@ -1,7 +1,7 @@
 import AVFoundation
 
 #if canImport(NitroModules)
-import NitroModules
+  import NitroModules
 #endif
 
 extension ChapterMetadata {

package/ios/Extension/NavigationError+Conversion.swift

@@ -43,7 +43,14 @@ extension NavigationError {
       "Error"
     case .unknownError:
       "Error"
+    case .emptyContent:
+      // Not a failure — a container that resolved with no children. Neutral copy;
+      // the message (carried on the NavigationError) is typically empty. See ADR 0001.
+      "Nothing here"
+    case .timeout:
+      "Couldn't load"
     }
-    return FormattedNavigationError(title: title, message: message)
+    // Omit an empty message so it renders as title-only (e.g. the empty-content case).
+    return FormattedNavigationError(title: title, message: message.isEmpty ? nil : message)
   }
 }

package/ios/Extension/PlayerCapabilities+Favorite.swift

@@ -0,0 +1,20 @@
+import Foundation
+
+extension PlayerCapabilities {
+  /// Resolved favorite match mode, or `nil` when favoriting is disabled.
+  ///
+  /// `false`/unset → `nil`; `true` → `.exact`; `{ match }` → that match.
+  var favoriteMatch: FavoritesMatchMode? {
+    switch favorite {
+    case .none:
+      nil
+    case let .some(.first(enabled)):
+      enabled ? .exact : nil
+    case let .some(.second(config)):
+      config.match
+    }
+  }
+
+  /// Whether the favorite/like control is enabled.
+  var favoriteEnabled: Bool { favoriteMatch != nil }
+}

package/ios/Extension/RequestConfig+Copying.swift

@@ -0,0 +1,31 @@
+import NitroModules
+
+extension RequestConfig {
+  /// Returns a copy of this RequestConfig with only the specified fields changed.
+  ///
+  /// `RequestConfig` is a C++-backed Nitro struct whose fields are get-only, so
+  /// "mutation" means rebuilding via the initializer. Uses double-optional
+  /// (`T??`) so callers can distinguish omitted (keep), `.some(nil)` (clear),
+  /// and `.some(value)` (set).
+  func copying(
+    method: HttpMethod?? = nil,
+    path: String?? = nil,
+    baseUrl: String?? = nil,
+    headers: [String: String]?? = nil,
+    query: [String: String]?? = nil,
+    body: String?? = nil,
+    contentType: String?? = nil,
+    userAgent: String?? = nil,
+  ) -> RequestConfig {
+    RequestConfig(
+      method: method ?? self.method,
+      path: path ?? self.path,
+      baseUrl: baseUrl ?? self.baseUrl,
+      headers: headers ?? self.headers,
+      query: query ?? self.query,
+      body: body ?? self.body,
+      contentType: contentType ?? self.contentType,
+      userAgent: userAgent ?? self.userAgent,
+    )
+  }
+}

package/ios/Extension/ResolvedTrack+Copying.swift

@@ -1,5 +1,5 @@
 #if canImport(NitroModules)
-import NitroModules
+  import NitroModules
 #endif
 
 extension ResolvedTrack {
@@ -15,13 +15,16 @@ extension ResolvedTrack {
     url: String? = nil,
     children: [Track]?? = nil,
     carPlaySiriListButton: CarPlaySiriListButtonPosition?? = nil,
+    id: String?? = nil,
     src: String?? = nil,
-    artwork: String?? = nil,
+    artwork: Variant_String_ArtworkVariants?? = nil,
     artworkSource: ImageSource?? = nil,
+    request: TrackRequest?? = nil,
     artworkCarPlayTinted: Bool?? = nil,
     title: String? = nil,
     subtitle: String?? = nil,
     artist: String?? = nil,
+    albumUrl: String?? = nil,
     album: String?? = nil,
     description: String?? = nil,
     genre: String?? = nil,
@@ -31,19 +34,22 @@ extension ResolvedTrack {
     favorited: Bool?? = nil,
     groupTitle: String?? = nil,
     live: Bool?? = nil,
-    imageRow: [ImageRowItem]?? = nil
+    imageRow: [ImageRowItem]?? = nil,
   ) -> ResolvedTrack {
     ResolvedTrack(
       url: url ?? self.url,
       children: children ?? self.children,
       carPlaySiriListButton: carPlaySiriListButton ?? self.carPlaySiriListButton,
+      id: id ?? self.id,
       src: src ?? self.src,
       artwork: artwork ?? self.artwork,
       artworkSource: artworkSource ?? self.artworkSource,
+      request: request ?? self.request,
       artworkCarPlayTinted: artworkCarPlayTinted ?? self.artworkCarPlayTinted,
       title: title ?? self.title,
       subtitle: subtitle ?? self.subtitle,
       artist: artist ?? self.artist,
+      albumUrl: albumUrl ?? self.albumUrl,
       album: album ?? self.album,
       description: description ?? self.description,
       genre: genre ?? self.genre,
@@ -53,7 +59,7 @@ extension ResolvedTrack {
       favorited: favorited ?? self.favorited,
       groupTitle: groupTitle ?? self.groupTitle,
       live: live ?? self.live,
-      imageRow: imageRow ?? self.imageRow
+      imageRow: imageRow ?? self.imageRow,
     )
   }
 }

package/ios/Extension/TimedMetadata+AVFoundation.swift

@@ -1,7 +1,7 @@
 import AVFoundation
 
 #if canImport(NitroModules)
-import NitroModules
+  import NitroModules
 #endif
 
 extension TimedMetadata {

package/ios/Extension/Track+AVPlayer.swift

@@ -23,11 +23,11 @@ extension Track {
   /// Builds an `ImageSource` from the track's artwork fields, skipping SF Symbol strings.
   var artworkImageSource: ImageSource? {
     if let source = artworkSource {
-      return source
-    } else if let artwork, !SFSymbolRenderer.isSFSymbol(artwork) {
-      return ImageSource(uri: artwork, method: nil, headers: nil, body: nil)
+      source
+    } else if let artwork = artwork?.url, !SFSymbolRenderer.isSFSymbol(artwork) {
+      ImageSource(uri: artwork, method: nil, headers: nil, body: nil)
     } else {
-      return nil
+      nil
     }
   }
 }

package/ios/Extension/Track+Copying.swift

@@ -10,14 +10,17 @@ extension Track {
   ///
   /// `title` uses single-optional (`String?`) since it is non-optional on Track.
   func copying(
+    id: String?? = nil,
     url: String?? = nil,
     src: String?? = nil,
-    artwork: String?? = nil,
+    artwork: Variant_String_ArtworkVariants?? = nil,
     artworkSource: ImageSource?? = nil,
+    request: TrackRequest?? = nil,
     artworkCarPlayTinted: Bool?? = nil,
     title: String? = nil,
     subtitle: String?? = nil,
     artist: String?? = nil,
+    albumUrl: String?? = nil,
     album: String?? = nil,
     description: String?? = nil,
     genre: String?? = nil,
@@ -27,17 +30,20 @@ extension Track {
     favorited: Bool?? = nil,
     groupTitle: String?? = nil,
     live: Bool?? = nil,
-    imageRow: [ImageRowItem]?? = nil
+    imageRow: [ImageRowItem]?? = nil,
   ) -> Track {
     Track(
+      id: id ?? self.id,
       url: url ?? self.url,
       src: src ?? self.src,
       artwork: artwork ?? self.artwork,
       artworkSource: artworkSource ?? self.artworkSource,
+      request: request ?? self.request,
       artworkCarPlayTinted: artworkCarPlayTinted ?? self.artworkCarPlayTinted,
       title: title ?? self.title,
       subtitle: subtitle ?? self.subtitle,
       artist: artist ?? self.artist,
+      albumUrl: albumUrl ?? self.albumUrl,
       album: album ?? self.album,
       description: description ?? self.description,
       genre: genre ?? self.genre,
@@ -47,7 +53,7 @@ extension Track {
       favorited: favorited ?? self.favorited,
       groupTitle: groupTitle ?? self.groupTitle,
       live: live ?? self.live,
-      imageRow: imageRow ?? self.imageRow
+      imageRow: imageRow ?? self.imageRow,
     )
   }
 }

package/ios/Extension/TrackMetadata+AVFoundation.swift

@@ -1,7 +1,7 @@
 import AVFoundation
 
 #if canImport(NitroModules)
-import NitroModules
+  import NitroModules
 #endif
 
 extension TrackMetadata {

package/ios/Extension/Variant+Artwork.swift

@@ -0,0 +1,49 @@
+import Foundation
+
+/// Reading the `artwork` union, which is either one URL or a URL per appearance.
+///
+/// Nitro surfaces it as `.first(String)` / `.second(ArtworkVariants)`. Call
+/// sites want one of two things — the URL to display, or both URLs so a
+/// `UIImageAsset` can adapt without re-fetching — so those are the only
+/// accessors here, and nothing below the boundary repeats the unwrap.
+///
+/// Deliberately Foundation-only: this is part of the SPM testable target, which
+/// also builds for macOS, so it cannot reach for `UIUserInterfaceStyle` to name
+/// an appearance. Picking between the two URLs is CarPlay's job anyway — it
+/// registers both and lets UIKit choose.
+extension Variant_String_ArtworkVariants {
+  /// Both URLs, when the track ships a pair; `nil` for a single URL, which
+  /// needs no per-appearance handling.
+  var variants: ArtworkVariants? {
+    switch self {
+    case .first: nil
+    case let .second(variants): variants
+    }
+  }
+
+  /// The URL to use where appearance is unknown or does not apply — now-playing
+  /// metadata, JS-facing values, the artwork transform pipeline.
+  ///
+  /// Resolves a pair to its dark URL. CarPlay dark is the common case, Android
+  /// Auto is dark-only, and it is what a single-URL track would have shipped
+  /// anyway — so a caller that cannot express appearance gets the same image it
+  /// got before pairs existed.
+  var url: String {
+    switch self {
+    case let .first(url): url
+    case let .second(variants): variants.dark
+    }
+  }
+}
+
+extension Variant_String_ArtworkVariants: Equatable {
+  /// Needed by `TabBarEntries.same`, and by the synthesised `Track: Equatable`
+  /// in the test stubs; the generated enum declares no conformance itself.
+  public static func == (lhs: Self, rhs: Self) -> Bool {
+    switch (lhs, rhs) {
+    case let (.first(l), .first(r)): l == r
+    case let (.second(l), .second(r)): l.light == r.light && l.dark == r.dark
+    default: false
+    }
+  }
+}