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

package/ios/Model/MediaURL.swift

@@ -0,0 +1,66 @@
+import Foundation
+
+struct MediaURL {
+  let value: URL
+  let isLocal: Bool
+  private let originalObject: Any
+
+  init?(object: Any?) {
+    guard let object else { return nil }
+    originalObject = object
+
+    // This is based on logic found in RCTConvert NSURLRequest
+    if let localObject = object as? [String: Any] {
+      var urlString = localObject["uri"] as? String ?? localObject["url"] as! String
+
+      if let bundleName = localObject["bundle"] as? String {
+        urlString = String(format: "%@.bundle/%@", bundleName, urlString)
+      }
+
+      isLocal = !urlString.lowercased().hasPrefix("http")
+      guard let converted = Self.convertToURL(urlString) else { return nil }
+      value = converted
+    } else {
+      let urlString = object as! String
+      isLocal = urlString.lowercased().hasPrefix("file://")
+      guard let converted = Self.convertToURL(urlString) else { return nil }
+      value = converted
+    }
+  }
+
+  /// Convert a string to URL, matching RCTConvert NSURL behavior
+  private static func convertToURL(_ string: String) -> URL? {
+    // Try as absolute URL first
+    if let url = URL(string: string), url.scheme != nil {
+      return url
+    }
+
+    // If it has a scheme but failed, try percent-encoding
+    if string.contains("://") {
+      var allowed = CharacterSet()
+      allowed.formUnion(.urlUserAllowed)
+      allowed.formUnion(.urlPasswordAllowed)
+      allowed.formUnion(.urlHostAllowed)
+      allowed.formUnion(.urlPathAllowed)
+      allowed.formUnion(.urlQueryAllowed)
+      allowed.formUnion(.urlFragmentAllowed)
+      if let encoded = string.addingPercentEncoding(withAllowedCharacters: allowed),
+         let url = URL(string: encoded) {
+        return url
+      }
+    }
+
+    // Assume it's a local path
+    var path = string.removingPercentEncoding ?? string
+
+    if path.hasPrefix("~") {
+      // Expand tilde for user directory
+      path = NSString(string: path).expandingTildeInPath
+    } else if !path.hasPrefix("/") {
+      // Not absolute - assume it's a bundle resource path
+      path = (Bundle.main.resourcePath ?? "") + "/" + path
+    }
+
+    return URL(fileURLWithPath: path)
+  }
+}

package/ios/Model/PlayerUpdateOptions.swift

@@ -0,0 +1,116 @@
+import Foundation
+import NitroModules
+
+/**
+ * Update options for the TrackPlayer that can be changed at runtime.
+ * These options control player behavior and capabilities that can be modified during playback.
+ */
+class PlayerUpdateOptions {
+  // MARK: - Core Properties
+
+  /// Jump intervals
+  var forwardJumpInterval: Double = 15.0
+  var backwardJumpInterval: Double = 15.0
+  var progressUpdateEventInterval: Double?
+
+  /// Player capabilities - most enabled by default, only false values disable
+  /// Exceptions: jumpForward, jumpBackward default to false
+  var capabilities: PlayerCapabilities = .init(
+    play: nil, pause: nil, stop: nil, seekTo: nil,
+    skipToNext: nil, skipToPrevious: nil,
+    jumpForward: false, jumpBackward: false,
+    favorite: nil,
+    shuffleMode: nil, repeatMode: nil, playbackRate: nil,
+  )
+
+  /// Repeat mode
+  var repeatMode: RepeatMode = .off
+
+  /// Supported playback rates for the playback-rate capability
+  var playbackRates: [Double] = [0.5, 1.0, 1.5, 2.0]
+
+  // MARK: - Initialization
+
+  init() {}
+
+  // MARK: - Update from Nitro Options
+
+  /// Update options from NativeUpdateOptions
+  func update(from options: NativeUpdateOptions) {
+    // Update jump intervals
+    if let interval = options.forwardJumpInterval {
+      forwardJumpInterval = interval
+    }
+    if let interval = options.backwardJumpInterval {
+      backwardJumpInterval = interval
+    }
+    // progressUpdateEventInterval is a Variant_NullType_Double - extract the Double
+    if let interval = options.progressUpdateEventInterval {
+      switch interval {
+      case .first:
+        // null - disable progress updates
+        progressUpdateEventInterval = nil
+      case let .second(value):
+        progressUpdateEventInterval = value
+      }
+    }
+
+    // Update capabilities - merge incoming with existing, only explicitly set values override
+    if let caps = options.capabilities {
+      capabilities = mergeCapabilities(existing: capabilities, incoming: caps)
+    }
+
+    // Update playback rates
+    if let rates = options.iosPlaybackRates {
+      playbackRates = rates
+    }
+  }
+
+  /// Convert to Nitro Options struct (full options with all required fields)
+  func toOptions() -> Options {
+    // Convert Double? to Variant_NullType_Double?
+    let progressInterval: Variant_NullType_Double? = progressUpdateEventInterval.map { .second($0) }
+
+    return Options(
+      android: nil,
+      forwardJumpInterval: forwardJumpInterval,
+      backwardJumpInterval: backwardJumpInterval,
+      progressUpdateEventInterval: progressInterval,
+      capabilities: capabilities,
+      repeatMode: repeatMode,
+    )
+  }
+
+  /// Convert to Nitro UpdateOptions struct (partial options for getOptions())
+  func toUpdateOptions() -> UpdateOptions {
+    // Convert Double? to Variant_NullType_Double?
+    let progressInterval: Variant_NullType_Double? = progressUpdateEventInterval.map { .second($0) }
+
+    return UpdateOptions(
+      android: nil,
+      forwardJumpInterval: forwardJumpInterval,
+      backwardJumpInterval: backwardJumpInterval,
+      progressUpdateEventInterval: progressInterval,
+      capabilities: capabilities,
+      iosPlaybackRates: playbackRates,
+    )
+  }
+
+  /// Merge incoming capabilities with existing - only explicitly set values override
+  private func mergeCapabilities(existing: PlayerCapabilities, incoming: PlayerCapabilities) -> PlayerCapabilities {
+    PlayerCapabilities(
+      play: incoming.play ?? existing.play,
+      pause: incoming.pause ?? existing.pause,
+      stop: incoming.stop ?? existing.stop,
+      seekTo: incoming.seekTo ?? existing.seekTo,
+      skipToNext: incoming.skipToNext ?? existing.skipToNext,
+      skipToPrevious: incoming.skipToPrevious ?? existing.skipToPrevious,
+      jumpForward: incoming.jumpForward ?? existing.jumpForward,
+      jumpBackward: incoming.jumpBackward ?? existing.jumpBackward,
+      favorite: incoming.favorite ?? existing.favorite,
+      shuffleMode: incoming.shuffleMode ?? existing.shuffleMode,
+      repeatMode: incoming.repeatMode ?? existing.repeatMode,
+      playbackRate: incoming.playbackRate ?? existing.playbackRate,
+    )
+  }
+}

package/ios/Model/RemoteCommand.swift

@@ -0,0 +1,71 @@
+import Foundation
+
+public enum RemoteCommand: CustomStringConvertible, Equatable {
+  case play
+
+  case pause
+
+  case stop
+
+  case togglePlayPause
+
+  case next
+
+  case previous
+
+  case changePlaybackPosition
+
+  case skipForward(preferredIntervals: [NSNumber])
+
+  case skipBackward(preferredIntervals: [NSNumber])
+
+  case like(isActive: Bool, localizedTitle: String, localizedShortTitle: String)
+
+  case changeRepeatMode
+
+  case changeShuffleMode
+
+  case changePlaybackRate(supportedPlaybackRates: [NSNumber])
+
+  public var description: String {
+    switch self {
+    case .play: "play"
+    case .pause: "pause"
+    case .stop: "stop"
+    case .togglePlayPause: "togglePlayPause"
+    case .next: "nextTrack"
+    case .previous: "previousTrack"
+    case .changePlaybackPosition: "changePlaybackPosition"
+    case .skipForward: "skipForward"
+    case .skipBackward: "skipBackward"
+    case .like: "like"
+    case .changeRepeatMode: "changeRepeatMode"
+    case .changeShuffleMode: "changeShuffleMode"
+    case .changePlaybackRate: "changePlaybackRate"
+    }
+  }
+
+  var key: String { description }
+
+  /**
+   All values in an array for convenience.
+   Don't use for associated values.
+   */
+  static func all() -> [RemoteCommand] {
+    [
+      .play,
+      .pause,
+      .stop,
+      .togglePlayPause,
+      .next,
+      .previous,
+      .changePlaybackPosition,
+      .skipForward(preferredIntervals: []),
+      .skipBackward(preferredIntervals: []),
+      .like(isActive: false, localizedTitle: "", localizedShortTitle: ""),
+      .changeRepeatMode,
+      .changeShuffleMode,
+      .changePlaybackRate(supportedPlaybackRates: []),
+    ]
+  }
+}

package/ios/Model/SourceType.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+public enum SourceType {
+  case stream
+  case file
+}

package/ios/Model/TrackPlayerError.swift

@@ -0,0 +1,69 @@
+import Foundation
+import NitroModules
+
+public enum TrackPlayerError: Error {
+  public enum PlaybackError: Error, Equatable {
+    case failedToLoadKeyValue
+    case invalidSourceUrl(String)
+    case notConnectedToInternet
+    case playbackFailed
+    case trackWasUnplayable
+  }
+
+  public enum QueueError: Error {
+    case noCurrentItem
+    case invalidIndex(index: Int, message: String)
+    case empty
+  }
+}
+
+extension TrackPlayerError.PlaybackError: LocalizedError {
+  public var errorDescription: String? {
+    switch self {
+    case .failedToLoadKeyValue:
+      "Failed to load audio track"
+    case let .invalidSourceUrl(url):
+      "Invalid audio source URL: \(url)"
+    case .notConnectedToInternet:
+      "No internet connection"
+    case .playbackFailed:
+      "Playback failed"
+    case .trackWasUnplayable:
+      "Track is not playable"
+    }
+  }
+}
+
+extension TrackPlayerError.QueueError: LocalizedError {
+  public var errorDescription: String? {
+    switch self {
+    case .noCurrentItem:
+      "No current track"
+    case let .invalidIndex(index, message):
+      "Invalid track index \(index): \(message)"
+    case .empty:
+      "Queue is empty"
+    }
+  }
+}
+
+// MARK: - Nitro PlaybackError Conversion
+
+public extension TrackPlayerError.PlaybackError {
+  /// Converts to Nitro PlaybackError for JS callbacks
+  func toNitroError() -> PlaybackError {
+    let code = switch self {
+    case .failedToLoadKeyValue:
+      "failed_to_load"
+    case .invalidSourceUrl:
+      "invalid_source_url"
+    case .notConnectedToInternet:
+      "not_connected_to_internet"
+    case .playbackFailed:
+      "playback_failed"
+    case .trackWasUnplayable:
+      "track_unplayable"
+    }
+    return PlaybackError(code: code, message: errorDescription ?? "Unknown error")
+  }
+}

package/ios/NowPlayingInfo/MediaItemProperty.swift

@@ -0,0 +1,78 @@
+import Foundation
+@preconcurrency import MediaPlayer
+
+/**
+ Enum representing MPMediaItemProperties.
+ Docs for each property is taken from [Apple docs](https://developer.apple.com/documentation/mediaplayer/mpmediaitem/general_media_item_property_keys)
+ */
+enum MediaItemProperty: NowPlayingInfoKeyValue {
+  /**
+   The performing artist(s) for a media item—which may vary from the primary artist for the album that a media item belongs to.
+
+   For example, if the album artist is “Joseph Fable,” the artist for one of the songs in the album may be “Joseph Fable featuring Thomas Smithson”. Value is an NSString object.
+   */
+  case artist(String?)
+
+  /**
+   The title (or name) of the media item.
+
+   This property is unrelated to the MPMediaItemPropertyAlbumTitle property. Value is an NSString object.
+   */
+  case title(String?)
+
+  /**
+   The title of an album.
+
+   This property contains the album title, such as “Live On Mars”, as opposed to the title of an individual song on the album, such as “Crater Dance (radio edit)” (which you specify using the MPMediaItemPropertyTitle property). Value is an NSString object.
+   */
+  case albumTitle(String?)
+
+  /**
+   The playback duration of the media item.
+   Value is an NSNumber object representing a duration in seconds as an TimeInterval.
+   */
+  case duration(TimeInterval?)
+
+  /**
+   The artwork image for the media item.
+   */
+  case artwork(MPMediaItemArtwork?)
+
+  var key: String {
+    switch self {
+    case .artist:
+      MPMediaItemPropertyArtist
+
+    case .title:
+      MPMediaItemPropertyTitle
+
+    case .albumTitle:
+      MPMediaItemPropertyAlbumTitle
+
+    case .duration:
+      MPMediaItemPropertyPlaybackDuration
+
+    case .artwork:
+      MPMediaItemPropertyArtwork
+    }
+  }
+
+  var value: Any? {
+    switch self {
+    case let .artist(artist):
+      artist
+
+    case let .title(title):
+      title
+
+    case let .albumTitle(title):
+      title
+
+    case let .duration(duration):
+      duration != nil ? NSNumber(floatLiteral: duration!) : nil
+
+    case let .artwork(artwork):
+      artwork
+    }
+  }
+}

package/ios/NowPlayingInfo/NowPlayingInfoCenter.swift

@@ -0,0 +1,9 @@
+import Foundation
+import MediaPlayer
+
+protocol NowPlayingInfoCenter {
+  var nowPlayingInfo: [String: Any]? { get set }
+  var playbackState: MPNowPlayingPlaybackState { get set }
+}
+
+extension MPNowPlayingInfoCenter: NowPlayingInfoCenter {}