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

package/ios/CarPlay/RNABCarPlaySceneDelegate.h

@@ -0,0 +1,15 @@
+#import <Foundation/Foundation.h>
+#import <CarPlay/CarPlay.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+/// CarPlay scene delegate for Audio Browser.
+///
+/// This is implemented in Objective-C to avoid C++ interop issues
+/// with the generated Swift-to-Obj-C header when using Nitro modules.
+API_AVAILABLE(ios(14.0))
+@interface RNABCarPlaySceneDelegate : UIResponder <CPTemplateApplicationSceneDelegate>
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/CarPlay/RNABCarPlaySceneDelegate.m

@@ -0,0 +1,59 @@
+#import "RNABCarPlaySceneDelegate.h"
+#import <os/log.h>
+#import <UIKit/UIKit.h>
+
+// Import the generated Swift header to access RNABCarPlayController
+#if __has_include(<AudioBrowser/AudioBrowser-Swift.h>)
+#import <AudioBrowser/AudioBrowser-Swift.h>
+#elif __has_include("AudioBrowser-Swift.h")
+#import "AudioBrowser-Swift.h"
+#endif
+
+// Protocol for optional app delegate method to start React Native in headless mode
+@protocol RNABHeadlessAppDelegate <NSObject>
+@optional
+- (void)startReactNativeHeadless;
+@end
+
+@interface RNABCarPlaySceneDelegate ()
+@property (nonatomic, strong, nullable) RNABCarPlayController *carPlayController;
+@end
+
+API_AVAILABLE(ios(14.0))
+@implementation RNABCarPlaySceneDelegate
+
+- (void)templateApplicationScene:(CPTemplateApplicationScene *)templateApplicationScene
+      didConnectInterfaceController:(CPInterfaceController *)interfaceController {
+    os_log_info(OS_LOG_DEFAULT, "[CarPlay] Connected");
+
+    // Ensure React Native is started (for standalone CarPlay mode)
+    // The app delegate should implement startReactNativeHeadless
+    id<RNABHeadlessAppDelegate> appDelegate = (id<RNABHeadlessAppDelegate>)[UIApplication sharedApplication].delegate;
+    if ([appDelegate respondsToSelector:@selector(startReactNativeHeadless)]) {
+        [appDelegate startReactNativeHeadless];
+    }
+
+    // Create and start the CarPlay controller
+    self.carPlayController = [[RNABCarPlayController alloc] initWithInterfaceController:interfaceController];
+    [self.carPlayController start];
+}
+
+- (void)templateApplicationScene:(CPTemplateApplicationScene *)templateApplicationScene
+   didDisconnectInterfaceController:(CPInterfaceController *)interfaceController {
+    os_log_info(OS_LOG_DEFAULT, "[CarPlay] Disconnected");
+
+    [self.carPlayController stop];
+    self.carPlayController = nil;
+}
+
+- (void)templateApplicationScene:(CPTemplateApplicationScene *)templateApplicationScene
+             didSelectNavigationAlert:(CPNavigationAlert *)navigationAlert {
+    // Not used for audio apps
+}
+
+- (void)templateApplicationScene:(CPTemplateApplicationScene *)templateApplicationScene
+                  didSelectManeuver:(CPManeuver *)maneuver {
+    // Not used for audio apps
+}
+
+@end

package/ios/CarPlay/Track+CarPlay.swift

@@ -0,0 +1,49 @@
+import CarPlay
+import Foundation
+import NitroModules
+
+// MARK: - Track CarPlay Extensions
+
+extension Track {
+  /// Returns the best artwork URL for CarPlay display.
+  var carPlayArtworkUrl: URL? {
+    if let artworkSource {
+      let uri = artworkSource.uri
+      return URL(string: uri)
+    }
+    if let artwork {
+      return URL(string: artwork)
+    }
+    return nil
+  }
+
+  /// Returns whether this track is playable (has a media source).
+  var isPlayable: Bool {
+    src != nil
+  }
+
+  /// Returns whether this track is browsable (has a navigation URL).
+  var isBrowsable: Bool {
+    url != nil && src == nil
+  }
+
+  /// Returns the display subtitle for CarPlay.
+  /// Uses subtitle if available, falls back to artist.
+  var carPlaySubtitle: String? {
+    subtitle ?? artist
+  }
+}
+
+// MARK: - ResolvedTrack CarPlay Extensions
+
+extension ResolvedTrack {
+  /// Returns playable children only (tracks with src).
+  var playableChildren: [Track] {
+    children?.filter { $0.src != nil } ?? []
+  }
+
+  /// Returns browsable children only (tracks with url but no src).
+  var browsableChildren: [Track] {
+    children?.filter { $0.url != nil && $0.src == nil } ?? []
+  }
+}

package/ios/Extension/Capability+RemoteCommand.swift

@@ -0,0 +1,76 @@
+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)
+    }
+
+    // Jump forward/backward
+    if jumpForward != false {
+      commands.append(.skipForward(
+        preferredIntervals: [(forwardJumpInterval ?? backwardJumpInterval) ?? 15],
+      ))
+    }
+    if jumpBackward != false {
+      commands.append(.skipBackward(
+        preferredIntervals: [(backwardJumpInterval ?? forwardJumpInterval) ?? 15],
+      ))
+    }
+
+    // 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",
+      ))
+    }
+
+    // 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
+  }
+}

package/ios/Extension/ChapterMetadata+AVFoundation.swift

@@ -0,0 +1,37 @@
+import AVFoundation
+import NitroModules
+
+extension ChapterMetadata {
+  /// Creates an array of ChapterMetadata from AVTimedMetadataGroup array.
+  static func from(groups: [AVTimedMetadataGroup]) -> [ChapterMetadata] {
+    groups.map { group in
+      let startTime = CMTimeGetSeconds(group.timeRange.start)
+      let endTime = CMTimeGetSeconds(group.timeRange.start) + CMTimeGetSeconds(group.timeRange.duration)
+
+      // Extract metadata from chapter items
+      // TODO: Artwork extraction missing. Requires converting binary data
+      // to a URL (base64 data URL or temp file).
+      // See also: Android implementation in MetadataAdapter.kt
+      var title: String?
+      var url: String?
+
+      for item in group.items {
+        if let commonKey = item.commonKey {
+          switch commonKey {
+          case .commonKeyTitle:
+            title = item.stringValue
+          default:
+            break
+          }
+        }
+      }
+
+      return ChapterMetadata(
+        startTime: startTime,
+        endTime: endTime,
+        title: title,
+        url: url
+      )
+    }
+  }
+}

package/ios/Extension/TimedMetadata+AVFoundation.swift

@@ -0,0 +1,126 @@
+import AVFoundation
+import NitroModules
+
+extension TimedMetadata {
+  /// Creates TimedMetadata from AVMetadataItem array, detecting the metadata format.
+  static func from(items: [AVMetadataItem]) -> TimedMetadata? {
+    // Check for ICY metadata (Shoutcast/Icecast streams)
+    let icyItems = items.filter { $0.keySpace == .icy }
+    if !icyItems.isEmpty {
+      return fromIcy(items: icyItems)
+    }
+
+    // Check for ID3 metadata (MP3)
+    let id3Items = items.filter { $0.keySpace == .id3 }
+    if !id3Items.isEmpty {
+      return fromId3(items: id3Items)
+    }
+
+    // Fall back to common metadata identifiers (covers QuickTime, iTunes, etc.)
+    return fromCommon(items: items)
+  }
+
+  /// Creates TimedMetadata from ICY (Shoutcast/Icecast) metadata.
+  static func fromIcy(items: [AVMetadataItem]) -> TimedMetadata? {
+    var title: String?
+
+    for item in items {
+      if let key = item.key as? String, key == "StreamTitle" {
+        title = item.stringValue
+      }
+    }
+
+    guard let title else { return nil }
+    return TimedMetadata(
+      title: title,
+      artist: nil,
+      album: nil,
+      date: nil,
+      genre: nil
+    )
+  }
+
+  /// Creates TimedMetadata from ID3 metadata (MP3).
+  static func fromId3(items: [AVMetadataItem]) -> TimedMetadata? {
+    var title: String?
+    var artist: String?
+    var album: String?
+    var date: String?
+    var genre: String?
+
+    for item in items {
+      switch item.identifier {
+      case .id3MetadataTitleDescription:
+        title = item.stringValue
+      case .id3MetadataLeadPerformer, .id3MetadataOriginalArtist:
+        artist = item.stringValue
+      case .id3MetadataAlbumTitle, .id3MetadataOriginalAlbumTitle:
+        album = item.stringValue
+      case .id3MetadataRecordingTime:
+        date = item.stringValue  // TDRC takes precedence (ID3v2.4, more precise)
+      case .id3MetadataYear:
+        date = date ?? item.stringValue  // TYER only if TDRC not found (ID3v2.3)
+      case .id3MetadataContentType:
+        genre = item.stringValue
+      default:
+        break
+      }
+    }
+
+    guard title != nil || artist != nil || album != nil || date != nil || genre != nil else { return nil }
+    return TimedMetadata(
+      title: title,
+      artist: artist,
+      album: album,
+      date: date,
+      genre: genre
+    )
+  }
+
+  /// Creates TimedMetadata from common metadata identifiers.
+  static func fromCommon(items: [AVMetadataItem]) -> TimedMetadata? {
+    var title: String?
+    var artist: String?
+    var album: String?
+    var date: String?
+    var genre: String?
+
+    for item in items {
+      switch item.identifier {
+      case .commonIdentifierTitle:
+        title = item.stringValue
+      case .commonIdentifierArtist:
+        artist = item.stringValue
+      case .commonIdentifierAlbumName:
+        album = item.stringValue
+      case .commonIdentifierCreationDate:
+        date = item.stringValue
+      default:
+        // Check by commonKey for broader compatibility
+        if let commonKey = item.commonKey {
+          switch commonKey {
+          case .commonKeyTitle:
+            title = title ?? item.stringValue
+          case .commonKeyArtist:
+            artist = artist ?? item.stringValue
+          case .commonKeyAlbumName:
+            album = album ?? item.stringValue
+          case .commonKeyCreationDate:
+            date = date ?? item.stringValue
+          default:
+            break
+          }
+        }
+      }
+    }
+
+    guard title != nil || artist != nil || album != nil || date != nil || genre != nil else { return nil }
+    return TimedMetadata(
+      title: title,
+      artist: artist,
+      album: album,
+      date: date,
+      genre: genre
+    )
+  }
+}

package/ios/Extension/Track+AVPlayer.swift

@@ -0,0 +1,68 @@
+import AVFoundation
+import Foundation
+import Kingfisher
+import NitroModules
+import UIKit
+
+/// 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
+  }
+
+  /// Loads artwork from the artwork URL (local file or remote URL)
+  /// Uses Kingfisher for caching and efficient image loading
+  func loadArtwork() async -> UIImage? {
+    // Try artworkSource first (has more detailed config), then fall back to artwork string
+    let artworkUrlString: String?
+    let artworkHeaders: [String: String]?
+
+    if let source = artworkSource {
+      artworkUrlString = source.uri
+      artworkHeaders = source.headers
+    } else {
+      artworkUrlString = artwork
+      artworkHeaders = nil
+    }
+
+    guard let urlString = artworkUrlString, let url = URL(string: urlString) else {
+      return nil
+    }
+
+    if url.isFileURL {
+      return UIImage(contentsOfFile: url.path)
+    }
+
+    // Build Kingfisher options with headers if provided
+    var options: KingfisherOptionsInfo = []
+    if let headers = artworkHeaders, !headers.isEmpty {
+      let modifier = AnyModifier { request in
+        var mutableRequest = request
+        for (key, value) in headers {
+          mutableRequest.setValue(value, forHTTPHeaderField: key)
+        }
+        return mutableRequest
+      }
+      options.append(.requestModifier(modifier))
+    }
+
+    do {
+      let result = try await KingfisherManager.shared.retrieveImage(with: url, options: options)
+      return result.image
+    } catch {
+      return nil
+    }
+  }
+}

package/ios/Extension/TrackMetadata+AVFoundation.swift

@@ -0,0 +1,128 @@
+import AVFoundation
+import NitroModules
+
+extension TrackMetadata {
+  /// Creates TrackMetadata from AVMetadataItem array using common identifiers.
+  static func from(items: [AVMetadataItem]) -> TrackMetadata {
+    var title: String?
+    var artist: String?
+    var albumTitle: String?
+    var subtitle: String?
+    var description: String?
+    var artworkUri: String?
+    var trackNumber: String?
+    var composer: String?
+    var conductor: String?
+    var genre: String?
+    var creationDate: String?
+    var creationYear: String?
+
+    for item in items {
+      // Try common identifiers first
+      switch item.identifier {
+      case .commonIdentifierTitle:
+        title = item.stringValue
+      case .commonIdentifierArtist:
+        artist = item.stringValue
+      case .commonIdentifierAlbumName:
+        albumTitle = item.stringValue
+      case .commonIdentifierDescription:
+        description = item.stringValue
+      case .commonIdentifierCreationDate:
+        creationDate = item.stringValue
+      default:
+        break
+      }
+
+      // Also check commonKey for broader compatibility
+      if let commonKey = item.commonKey {
+        switch commonKey {
+        case .commonKeyTitle:
+          title = title ?? item.stringValue
+        case .commonKeyArtist:
+          artist = artist ?? item.stringValue
+        case .commonKeyAlbumName:
+          albumTitle = albumTitle ?? item.stringValue
+        case .commonKeySubject:
+          subtitle = subtitle ?? item.stringValue
+        case .commonKeyDescription:
+          description = description ?? item.stringValue
+        case .commonKeyCreationDate:
+          creationDate = creationDate ?? item.stringValue
+        case .commonKeyAuthor:
+          composer = composer ?? item.stringValue
+        default:
+          break
+        }
+      }
+
+      // Check ID3-specific identifiers for additional fields
+      if item.keySpace == .id3, let key = item.key as? String {
+        switch key {
+        case "TIT3": // Subtitle
+          subtitle = subtitle ?? item.stringValue
+        case "TRCK": // Track number
+          trackNumber = trackNumber ?? item.stringValue
+        case "TCOM": // Composer
+          composer = composer ?? item.stringValue
+        case "TPE3": // Conductor
+          conductor = conductor ?? item.stringValue
+        case "TCON": // Content type (genre)
+          genre = genre ?? item.stringValue
+        case "TDRC": // Recording time (ID3v2.4)
+          creationDate = creationDate ?? item.stringValue
+        case "TYER": // Year (ID3v2.3)
+          creationYear = creationYear ?? item.stringValue
+        default:
+          break
+        }
+      }
+
+      // Check iTunes-specific identifiers
+      switch item.identifier {
+      case .iTunesMetadataSongName:
+        title = title ?? item.stringValue
+      case .iTunesMetadataArtist:
+        artist = artist ?? item.stringValue
+      case .iTunesMetadataAlbum:
+        albumTitle = albumTitle ?? item.stringValue
+      case .iTunesMetadataComposer:
+        composer = composer ?? item.stringValue
+      case .iTunesMetadataDescription:
+        description = description ?? item.stringValue
+      case .iTunesMetadataUserGenre:
+        genre = genre ?? item.stringValue
+      case .iTunesMetadataTrackNumber:
+        trackNumber = trackNumber ?? item.stringValue
+      case .iTunesMetadataReleaseDate:
+        creationDate = creationDate ?? item.stringValue
+      default:
+        break
+      }
+    }
+
+    // Extract year from creationDate if creationYear not set
+    if creationYear == nil, let date = creationDate, date.count >= 4 {
+      creationYear = String(date.prefix(4))
+    }
+
+    return TrackMetadata(
+      title: title,
+      artist: artist,
+      albumTitle: albumTitle,
+      subtitle: subtitle,
+      description: description,
+      artworkUri: artworkUri,
+      trackNumber: trackNumber,
+      composer: composer,
+      conductor: conductor,
+      genre: genre,
+      compilation: nil,
+      station: nil,
+      mediaType: nil,
+      creationDate: creationDate,
+      creationYear: creationYear,
+      url: nil
+    )
+  }
+}