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

package/ios/CarPlay/CarPlayNowPlayingManager.swift

@@ -16,8 +16,8 @@ final class CarPlayNowPlayingManager {
 
   private let interfaceController: CPInterfaceController
   var listItemFactory: (Track, ((CPSelectableListItem, @escaping () -> Void) -> Void)?) -> CPListItem
-  /// Pushes a browse destination (wired to the controller's navigateToUrl).
-  var navigateToUrl: ((_ url: String, _ title: String) -> Void)?
+  /// Pushes a browse destination (wired to the controller's navigateToPath).
+  var navigateToPath: ((_ path: String, _ title: String) -> Void)?
 
   private weak var audioBrowser: HybridAudioBrowser?
   private var nowPlayingObserver: NowPlayingObserver?
@@ -46,11 +46,11 @@ final class CarPlayNowPlayingManager {
   private var builtRow: BuiltButtonRow?
 
   /// Browse path the album line navigates to for the active track —
-  /// `track.albumUrl`, or the pre-resolved `resolveAlbumUrl` result. Resolved
+  /// `track.albumPath`, or the pre-resolved `resolveAlbumPath` result. Resolved
   /// at track-change time (not at tap) so the album line only surfaces when a
   /// destination actually exists.
   private var albumArtistDestination: String?
-  /// Drops a stale async `resolveAlbumUrl` result when the track changed while
+  /// Drops a stale async `resolveAlbumPath` result when the track changed while
   /// the resolver was in flight (latest-update-wins).
   private var albumArtistGeneration: UInt = 0
   /// The just-tapped track whose load is still in flight. CarPlay reads
@@ -214,7 +214,7 @@ final class CarPlayNowPlayingManager {
 
   /// Re-resolves the album line's destination for the active track and
   /// enables the (tappable) album/artist button only when one exists:
-  /// `track.albumUrl`, or the app's `resolveAlbumUrl` result.
+  /// `track.albumPath`, or the app's `resolveAlbumPath` result.
   /// Marks `track` as the just-tapped (still loading) track and derives the
   /// album line's destination from it. Must run before the Now Playing
   /// template is pushed — CarPlay reads `isAlbumArtistButtonEnabled` at display
@@ -242,12 +242,12 @@ final class CarPlayNowPlayingManager {
       setAlbumArtistDestination(nil)
       return
     }
-    logger.info("AlbumArtist: track=\(track.title) albumUrl=\(track.albumUrl ?? "nil") resolver=\(self.config.resolveAlbumUrl != nil)")
-    if let albumUrl = track.albumUrl {
-      setAlbumArtistDestination(albumUrl)
+    logger.info("AlbumArtist: track=\(track.title) albumPath=\(track.albumPath ?? "nil") resolver=\(self.config.resolveAlbumPath != nil)")
+    if let albumPath = track.albumPath {
+      setAlbumArtistDestination(albumPath)
       return
     }
-    guard let resolver = config.resolveAlbumUrl else {
+    guard let resolver = config.resolveAlbumPath else {
       setAlbumArtistDestination(nil)
       return
     }
@@ -256,7 +256,7 @@ final class CarPlayNowPlayingManager {
       do {
         path = try await resolver(track).await()
       } catch {
-        self?.logger.error("resolveAlbumUrl failed: \(error.localizedDescription)")
+        self?.logger.error("resolveAlbumPath failed: \(error.localizedDescription)")
         path = nil
       }
       guard let self, self.albumArtistGeneration == generation else { return }
@@ -295,7 +295,10 @@ final class CarPlayNowPlayingManager {
   /// Returns the appropriate image for the favorite button based on state
   private func favoriteButtonImage(isFavorited: Bool) -> UIImage {
     let symbolName = isFavorited ? "heart.fill" : "heart"
-    guard let image = UIImage(systemName: symbolName)?.resized(to: CPNowPlayingButtonMaximumImageSize) else {
+    guard let image = UIImage(systemName: symbolName)?.resized(
+      to: CPNowPlayingButtonMaximumImageSize,
+      scale: interfaceController.carTraitCollection.displayScale,
+    ) else {
       return UIImage()
     }
     return image
@@ -360,7 +363,7 @@ final class CarPlayNowPlayingManager {
     // the pushed destination (artist may be unset, or the live song).
     let title = track?.album ?? track?.artist ?? track?.title ?? ""
     logger.info("Album/Artist button tapped, navigating to \(destination)")
-    navigateToUrl?(destination, title)
+    navigateToPath?(destination, title)
   }
 
   private func updateNowPlayingUpNextButton() {

package/ios/CarPlay/RNABMediaAddHandler.swift

@@ -22,8 +22,8 @@ class RNABMediaAddHandler: NSObject, INAddMediaIntentHandling {
   private static let logger = Logger(subsystem: "com.audiobrowser", category: "MediaAddHandler")
 
   func handle(
-    intent: INAddMediaIntent,
-    completion: @escaping @Sendable (INAddMediaIntentResponse) -> Void
+    intent _: INAddMediaIntent,
+    completion: @escaping @Sendable (INAddMediaIntentResponse) -> Void,
   ) {
     Self.logger.info("Add media — favorite current track")
 
@@ -57,7 +57,7 @@ class RNABMediaAddHandler: NSObject, INAddMediaIntentHandling {
   @objc(resolveMediaItemsForAddMedia:withCompletion:)
   func resolveMediaItems(
     for intent: INAddMediaIntent,
-    with completion: @escaping ([INAddMediaMediaItemResolutionResult]) -> Void
+    with completion: @escaping ([INAddMediaMediaItemResolutionResult]) -> Void,
   ) {
     let name = intent.mediaSearch?.mediaName ?? ""
     let item = INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)
@@ -66,10 +66,10 @@ class RNABMediaAddHandler: NSObject, INAddMediaIntentHandling {
 
   @objc(resolveMediaDestinationForAddMedia:withCompletion:)
   func resolveMediaDestination(
-    for intent: INAddMediaIntent,
-    with completion: @escaping (INAddMediaMediaDestinationResolutionResult) -> Void
+    for _: INAddMediaIntent,
+    with completion: @escaping (INAddMediaMediaDestinationResolutionResult) -> Void,
   ) {
     // One flat favorites collection — always the user's library, no playlists.
-      completion(.success(with: INMediaDestination.library))
+    completion(.success(with: INMediaDestination.library))
   }
 }

package/ios/CarPlay/RNABMediaAffinityHandler.swift

@@ -21,7 +21,7 @@ class RNABMediaAffinityHandler: NSObject, INUpdateMediaAffinityIntentHandling {
 
   func handle(
     intent: INUpdateMediaAffinityIntent,
-    completion: @escaping @Sendable (INUpdateMediaAffinityIntentResponse) -> Void
+    completion: @escaping @Sendable (INUpdateMediaAffinityIntentResponse) -> Void,
   ) {
     let affinity = intent.affinityType
     Self.logger.info("Update media affinity — type=\(affinity.rawValue)")
@@ -60,7 +60,7 @@ class RNABMediaAffinityHandler: NSObject, INUpdateMediaAffinityIntentHandling {
   @objc(resolveMediaItemsForUpdateMediaAffinity:withCompletion:)
   func resolveMediaItems(
     for intent: INUpdateMediaAffinityIntent,
-    with completion: @escaping ([INUpdateMediaAffinityMediaItemResolutionResult]) -> Void
+    with completion: @escaping ([INUpdateMediaAffinityMediaItemResolutionResult]) -> Void,
   ) {
     let name = intent.mediaSearch?.mediaName ?? ""
     let item = INMediaItem(identifier: name, title: name, type: .unknown, artwork: nil)

package/ios/CarPlay/RNABMediaIntentHandler.swift

@@ -21,7 +21,7 @@ class RNABMediaIntentHandler: NSObject, INPlayMediaIntentHandling {
       mediaTypeMode: Self.mediaTypeMode(s?.mediaType ?? .unknown),
       reference: Self.reference(s?.reference ?? .unknown),
       hasMediaType: (s?.mediaType ?? .unknown) != .unknown,
-      appName: Self.hostAppName()
+      appName: Self.hostAppName(),
     )
     Self.logger.info("Play media intent — query=\(criteria.query) matchesApp=\(criteria.matchesAppName) resume=\(criteria.isResume)")
 
@@ -37,18 +37,18 @@ class RNABMediaIntentHandler: NSObject, INPlayMediaIntentHandling {
   /// `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
+    case .station, .radioStation, .algorithmicRadioStation, .musicStation: "station"
+    case .podcastShow, .podcastEpisode, .podcastPlaylist, .podcastStation: "podcast"
+    case .audioBook: "audiobook"
+    case .news: "news"
+    case .music: "music"
+    case .song: "song"
+    case .playlist: "playlist"
+    case .musicVideo: "music-video"
+    case .movie: "movie"
+    case .tvShow: "tv-show"
+    case .tvShowEpisode: "tv-show-episode"
+    default: nil // album/artist/genre/unknown
     }
   }
 
@@ -56,9 +56,9 @@ class RNABMediaIntentHandler: NSObject, INPlayMediaIntentHandling {
   /// 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
+    case .currentlyPlaying: .currentlyPlaying
+    case .my: .my
+    default: .unknown
     }
   }
 

package/ios/Extension/Capability+RemoteCommand.swift

@@ -54,7 +54,7 @@ extension PlayerCapabilities {
     // 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.
+    // favorite row indicators via setFavoriteEnabled. See issues #67 / #71.
 
     // Mode controls
     if shuffleMode != false {

package/ios/Extension/PlayerCapabilities+Favorite.swift

@@ -1,20 +1,6 @@
 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 }
+  var favoriteEnabled: Bool { favorite ?? false }
 }

package/ios/Extension/ResolvedTrack+Copying.swift

@@ -10,9 +10,11 @@ extension ResolvedTrack {
   /// - `.some(nil)` → set field to nil
   /// - `.some(value)` → set field to value
   ///
-  /// `url` and `title` use single-optional since they are non-optional on ResolvedTrack.
+  /// `path` and `title` use single-optional since they are non-optional on ResolvedTrack.
   func copying(
-    url: String? = nil,
+    path: String? = nil,
+    style: SectionStyle?? = nil,
+    sections: [Section]?? = nil,
     children: [Track]?? = nil,
     carPlaySiriListButton: CarPlaySiriListButtonPosition?? = nil,
     id: String?? = nil,
@@ -20,24 +22,23 @@ extension ResolvedTrack {
     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,
+    albumPath: String?? = nil,
     album: String?? = nil,
     description: String?? = nil,
     genre: String?? = nil,
     duration: Double?? = nil,
-    style: TrackStyle?? = nil,
-    childrenStyle: TrackStyle?? = nil,
+    disabled: Bool?? = nil,
     favorited: Bool?? = nil,
-    groupTitle: String?? = nil,
     live: Bool?? = nil,
-    imageRow: [ImageRowItem]?? = nil,
+    icyCharset: String?? = nil,
   ) -> ResolvedTrack {
     ResolvedTrack(
-      url: url ?? self.url,
+      path: path ?? self.path,
+      style: style ?? self.style,
+      sections: sections ?? self.sections,
       children: children ?? self.children,
       carPlaySiriListButton: carPlaySiriListButton ?? self.carPlaySiriListButton,
       id: id ?? self.id,
@@ -45,21 +46,18 @@ extension ResolvedTrack {
       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,
+      albumPath: albumPath ?? self.albumPath,
       album: album ?? self.album,
       description: description ?? self.description,
       genre: genre ?? self.genre,
       duration: duration ?? self.duration,
-      style: style ?? self.style,
-      childrenStyle: childrenStyle ?? self.childrenStyle,
+      disabled: disabled ?? self.disabled,
       favorited: favorited ?? self.favorited,
-      groupTitle: groupTitle ?? self.groupTitle,
       live: live ?? self.live,
-      imageRow: imageRow ?? self.imageRow,
+      icyCharset: icyCharset ?? self.icyCharset,
     )
   }
 }

package/ios/Extension/Section+Copying.swift

@@ -0,0 +1,29 @@
+#if canImport(NitroModules)
+  import NitroModules
+#endif
+
+extension Section {
+  /// Returns a copy of this Section with only the specified fields changed.
+  ///
+  /// Same double-optional (`T??`) convention as the other copying helpers;
+  /// `children` is single-optional since it is non-optional on Section.
+  func copying(
+    title: String?? = nil,
+    style: SectionStyle?? = nil,
+    path: String?? = nil,
+    children: [Track]? = nil,
+  ) -> Section {
+    Section(
+      title: title ?? self.title,
+      style: style ?? self.style,
+      path: path ?? self.path,
+      children: children ?? self.children,
+    )
+  }
+
+  /// One untitled section — the canonical wrap of a flat track list
+  /// (`children` authoring sugar, search results — ADR 0010).
+  static func untitled(_ children: [Track]) -> Section {
+    Section(title: nil, style: nil, path: nil, children: children)
+  }
+}

package/ios/Extension/String+IcyCharset.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+extension String {
+  /// Re-decodes an ICY `StreamTitle` that AVFoundation decoded as Latin-1 with the
+  /// charset the track declares. AVFoundation keeps no raw bytes, so the tell is the
+  /// shape: every scalar at or below U+00FF with at least one at or above U+0080. A
+  /// title already decoded to another script contains higher scalars and is returned
+  /// as is, as is pure ASCII, an unknown charset, or bytes the charset cannot decode.
+  func redecodingIcyTitle(charset: String) -> String {
+    var high = false
+    for scalar in unicodeScalars {
+      if scalar.value > 0xFF { return self }
+      if scalar.value >= 0x80 { high = true }
+    }
+    guard high, let data = data(using: .isoLatin1) else { return self }
+    let cfEncoding = CFStringConvertIANACharSetNameToEncoding(charset as CFString)
+    guard cfEncoding != kCFStringEncodingInvalidId else { return self }
+    let encoding = String.Encoding(rawValue: CFStringConvertEncodingToNSStringEncoding(cfEncoding))
+    return String(data: data, encoding: encoding) ?? self
+  }
+}

package/ios/Extension/TimedMetadata+AVFoundation.swift

@@ -6,11 +6,13 @@ import AVFoundation
 
 extension TimedMetadata {
   /// Creates TimedMetadata from AVMetadataItem array, detecting the metadata format.
-  static func from(items: [AVMetadataItem]) -> TimedMetadata? {
+  /// `icyCharset` is the track's declared charset for ICY titles AVFoundation
+  /// decoded as Latin-1; it never touches ID3 or common metadata.
+  static func from(items: [AVMetadataItem], icyCharset: String? = nil) -> TimedMetadata? {
     // Check for ICY metadata (Shoutcast/Icecast streams)
     let icyItems = items.filter { $0.keySpace == .icy }
     if !icyItems.isEmpty {
-      return fromIcy(items: icyItems)
+      return fromIcy(items: icyItems, icyCharset: icyCharset)
     }
 
     // Check for ID3 metadata (MP3)
@@ -24,7 +26,7 @@ extension TimedMetadata {
   }
 
   /// Creates TimedMetadata from ICY (Shoutcast/Icecast) metadata.
-  static func fromIcy(items: [AVMetadataItem]) -> TimedMetadata? {
+  static func fromIcy(items: [AVMetadataItem], icyCharset: String? = nil) -> TimedMetadata? {
     var title: String?
 
     for item in items {
@@ -35,7 +37,7 @@ extension TimedMetadata {
 
     guard let title else { return nil }
     return TimedMetadata(
-      title: title,
+      title: icyCharset.map { title.redecodingIcyTitle(charset: $0) } ?? title,
       artist: nil,
       album: nil,
       date: nil,

package/ios/Extension/Track+Copying.swift

@@ -11,49 +11,45 @@ extension Track {
   /// `title` uses single-optional (`String?`) since it is non-optional on Track.
   func copying(
     id: String?? = nil,
-    url: String?? = nil,
+    path: String?? = nil,
     src: 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,
+    albumPath: String?? = nil,
     album: String?? = nil,
     description: String?? = nil,
     genre: String?? = nil,
     duration: Double?? = nil,
     style: TrackStyle?? = nil,
-    childrenStyle: TrackStyle?? = nil,
+    disabled: Bool?? = nil,
     favorited: Bool?? = nil,
-    groupTitle: String?? = nil,
     live: Bool?? = nil,
-    imageRow: [ImageRowItem]?? = nil,
+    icyCharset: String?? = nil,
   ) -> Track {
     Track(
       id: id ?? self.id,
-      url: url ?? self.url,
+      path: path ?? self.path,
       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,
+      albumPath: albumPath ?? self.albumPath,
       album: album ?? self.album,
       description: description ?? self.description,
       genre: genre ?? self.genre,
       duration: duration ?? self.duration,
       style: style ?? self.style,
-      childrenStyle: childrenStyle ?? self.childrenStyle,
+      disabled: disabled ?? self.disabled,
       favorited: favorited ?? self.favorited,
-      groupTitle: groupTitle ?? self.groupTitle,
       live: live ?? self.live,
-      imageRow: imageRow ?? self.imageRow,
+      icyCharset: icyCharset ?? self.icyCharset,
     )
   }
 }

package/ios/Extension/Track+Identity.swift

@@ -0,0 +1,18 @@
+#if canImport(NitroModules)
+  import NitroModules
+#endif
+
+/// A track's identity: the opaque `id` when present (non-blank), else the
+/// playable `src`. Two tracks refer to the same item iff their identities are
+/// equal. Browsable-only tracks (neither `id` nor `src`) have no identity —
+/// they are addressed by `path` instead.
+///
+/// This is THE comparison rule for favorites matching, section scoping,
+/// skip-in-place, the car now-playing row indicator, and the contextual
+/// `__trackId` — see ADR 0008. Mirrors `trackIdentity` on the TS side.
+extension Track {
+  var identity: String? {
+    if let id, !id.isEmpty { return id }
+    return src
+  }
+}

package/ios/Extension/UIApplication+ActiveScene.swift

@@ -0,0 +1,27 @@
+import UIKit
+
+extension UIApplication {
+  /// The scene showing the app's own UI: the foreground-active one, else any
+  /// connected window scene. Nil when the app has no UI scene at all (running
+  /// headless for CarPlay), which callers must handle rather than assume.
+  ///
+  /// Replaces the deprecated `UIScreen.main` / `keyWindow` idioms — and exists
+  /// once because the walk was previously written out at each use, so the two
+  /// copies had already drifted apart.
+  var activeWindowScene: UIWindowScene? {
+    let scenes = connectedScenes.compactMap { $0 as? UIWindowScene }
+    return scenes.first { $0.activationState == .foregroundActive } ?? scenes.first
+  }
+}
+
+/// The scale to rasterise at for the app's own screen.
+///
+/// `UITraitCollection.current` rather than the deprecated `UIScreen.main.scale`
+/// (also unavailable on visionOS, which the podspec targets): on the main actor
+/// it already reflects the environment being rendered for. CarPlay surfaces do
+/// NOT use this — they rasterise at `carTraitCollection.displayScale`, the car
+/// screen's own scale.
+@MainActor
+var appDisplayScale: CGFloat {
+  UITraitCollection.current.displayScale
+}

package/ios/Http/HttpClient.swift

@@ -92,8 +92,14 @@ final class HttpClient: @unchecked Sendable {
     httpRequest.headers?.forEach { name, value in
       urlRequest.setValue(value, forHTTPHeaderField: name)
     }
-    // Set User-Agent (userAgent parameter takes precedence over headers)
-    urlRequest.setValue(httpRequest.userAgent, forHTTPHeaderField: "User-Agent")
+    // An explicit `User-Agent` in `headers` wins, matching the two sibling paths
+    // (MediaLoader.buildAssetOptions and the artwork path in
+    // BrowserManager+URLResolution). `userAgent` carries a non-nil default, so
+    // overwriting unconditionally would replace a consumer's header with
+    // "react-native-audio-browser" whenever they set only the header.
+    if httpRequest.headers?["User-Agent"] == nil {
+      urlRequest.setValue(httpRequest.userAgent, forHTTPHeaderField: "User-Agent")
+    }
 
     // Add body for non-GET requests
     switch httpRequest.method.uppercased() {