react-native-audio-browser 0.0.1 → 0.1.0-next.2

package/ios/Extension/Track+Copying.swift

@@ -0,0 +1,53 @@
+import NitroModules
+
+extension Track {
+  /// Returns a copy of this Track with only the specified fields changed.
+  ///
+  /// Uses double-optional (`T??`) so callers can distinguish between:
+  /// - Omitted argument → keep existing value
+  /// - `.some(nil)` → set field to nil
+  /// - `.some(value)` → set field to value
+  ///
+  /// `title` uses single-optional (`String?`) since it is non-optional on Track.
+  func copying(
+    url: String?? = nil,
+    src: String?? = nil,
+    artwork: String?? = nil,
+    artworkSource: ImageSource?? = nil,
+    artworkCarPlayTinted: Bool?? = nil,
+    title: String? = nil,
+    subtitle: String?? = nil,
+    artist: String?? = nil,
+    album: String?? = nil,
+    description: String?? = nil,
+    genre: String?? = nil,
+    duration: Double?? = nil,
+    style: TrackStyle?? = nil,
+    childrenStyle: TrackStyle?? = nil,
+    favorited: Bool?? = nil,
+    groupTitle: String?? = nil,
+    live: Bool?? = nil,
+    imageRow: [ImageRowItem]?? = nil
+  ) -> Track {
+    Track(
+      url: url ?? self.url,
+      src: src ?? self.src,
+      artwork: artwork ?? self.artwork,
+      artworkSource: artworkSource ?? self.artworkSource,
+      artworkCarPlayTinted: artworkCarPlayTinted ?? self.artworkCarPlayTinted,
+      title: title ?? self.title,
+      subtitle: subtitle ?? self.subtitle,
+      artist: artist ?? self.artist,
+      album: album ?? self.album,
+      description: description ?? self.description,
+      genre: genre ?? self.genre,
+      duration: duration ?? self.duration,
+      style: style ?? self.style,
+      childrenStyle: childrenStyle ?? self.childrenStyle,
+      favorited: favorited ?? self.favorited,
+      groupTitle: groupTitle ?? self.groupTitle,
+      live: live ?? self.live,
+      imageRow: imageRow ?? self.imageRow
+    )
+  }
+}

package/ios/Extension/TrackMetadata+AVFoundation.swift

@@ -0,0 +1,131 @@
+import AVFoundation
+
+#if canImport(NitroModules)
+import NitroModules
+#endif
+
+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?
+    let artworkUri: String? = nil
+    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,
+    )
+  }
+}

package/ios/Http/HttpClient.swift

@@ -0,0 +1,237 @@
+import Foundation
+import os.log
+
+/// URLSession-based HTTP client for API requests.
+final class HttpClient: @unchecked Sendable {
+  static let defaultUserAgent = "react-native-audio-browser"
+  static let defaultContentType = "application/json"
+  private static let timeoutSeconds: TimeInterval = 30
+
+  private let session: URLSession
+  private let logger = Logger(subsystem: "com.audiobrowser", category: "HttpClient")
+
+  /// HTTP request configuration (matches Kotlin HttpClient.HttpRequest).
+  struct HttpRequest {
+    let url: String
+    let method: String
+    let headers: [String: String]?
+    let body: String?
+    let contentType: String
+    let userAgent: String
+
+    init(
+      url: String,
+      method: String = "GET",
+      headers: [String: String]? = nil,
+      body: String? = nil,
+      contentType: String = HttpClient.defaultContentType,
+      userAgent: String = HttpClient.defaultUserAgent,
+    ) {
+      self.url = url
+      self.method = method
+      self.headers = headers
+      self.body = body
+      self.contentType = contentType
+      self.userAgent = userAgent
+    }
+  }
+
+  /// HTTP response data (matches Kotlin HttpClient.HttpResponse).
+  struct HttpResponse {
+    let code: Int
+    let body: String
+    let headers: [String: String]
+
+    var isSuccessful: Bool {
+      (200 ..< 300).contains(code)
+    }
+  }
+
+  /// HTTP exception (matches Kotlin HttpClient.HttpException).
+  final class HttpException: Error, Sendable {
+    let code: Int
+    let responseBody: String
+
+    init(code: Int, responseBody: String) {
+      self.code = code
+      self.responseBody = responseBody
+    }
+
+    var localizedDescription: String {
+      // Try to extract error message from JSON response: { "error": "message" }
+      if let data = responseBody.data(using: .utf8),
+         let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+         let errorMessage = json["error"] as? String
+      {
+        return errorMessage
+      }
+      // Fall back to localized HTTP status description
+      return HTTPURLResponse.localizedString(forStatusCode: code)
+    }
+  }
+
+  /// Creates a new HTTP client.
+  init(session: URLSession = .shared) {
+    self.session = session
+  }
+
+  /// Executes an HTTP request (matches Kotlin request() signature).
+  func request(_ httpRequest: HttpRequest) async -> Result<HttpResponse, Error> {
+    guard let url = URL(string: httpRequest.url) else {
+      return .failure(NSError(
+        domain: "HttpClient",
+        code: -1,
+        userInfo: [NSLocalizedDescriptionKey: "Invalid URL: \(httpRequest.url)"],
+      ))
+    }
+
+    var urlRequest = URLRequest(url: url)
+    urlRequest.timeoutInterval = Self.timeoutSeconds
+
+    // Add headers
+    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")
+
+    // Add body for non-GET requests
+    switch httpRequest.method.uppercased() {
+    case "GET":
+      urlRequest.httpMethod = "GET"
+    case "POST", "PUT", "PATCH":
+      urlRequest.httpMethod = httpRequest.method.uppercased()
+      urlRequest.setValue(httpRequest.contentType, forHTTPHeaderField: "Content-Type")
+      if let body = httpRequest.body {
+        urlRequest.httpBody = body.data(using: .utf8)
+      }
+    case "DELETE":
+      urlRequest.httpMethod = "DELETE"
+      if let body = httpRequest.body {
+        urlRequest.setValue(httpRequest.contentType, forHTTPHeaderField: "Content-Type")
+        urlRequest.httpBody = body.data(using: .utf8)
+      }
+    default:
+      return .failure(NSError(
+        domain: "HttpClient",
+        code: -1,
+        userInfo: [NSLocalizedDescriptionKey: "Unsupported HTTP method: \(httpRequest.method)"],
+      ))
+    }
+
+    // Log request
+    logRequest(httpRequest)
+
+    do {
+      let (data, response) = try await session.data(for: urlRequest)
+
+      guard let httpResponse = response as? HTTPURLResponse else {
+        return .failure(NSError(
+          domain: "HttpClient",
+          code: -1,
+          userInfo: [NSLocalizedDescriptionKey: "Invalid response type"],
+        ))
+      }
+
+      let responseBody = String(data: data, encoding: .utf8) ?? ""
+
+      // Extract response headers
+      var headers: [String: String] = [:]
+      for (key, value) in httpResponse.allHeaderFields {
+        if let keyString = key as? String, let valueString = value as? String {
+          headers[keyString] = valueString
+        }
+      }
+
+      let httpResp = HttpResponse(
+        code: httpResponse.statusCode,
+        body: responseBody,
+        headers: headers,
+      )
+
+      // Log response
+      logResponse(httpResp, url: httpRequest.url)
+
+      return .success(httpResp)
+    } catch {
+      logError(error, url: httpRequest.url)
+      return .failure(error)
+    }
+  }
+
+  /// Executes an HTTP request and decodes the JSON response (matches Kotlin requestJson()).
+  func requestJson<T: Decodable>(
+    _ httpRequest: HttpRequest,
+    as type: T.Type,
+  ) async throws -> T {
+    let result = await request(httpRequest)
+
+    switch result {
+    case let .success(response):
+      if !response.isSuccessful {
+        throw HttpException(code: response.code, responseBody: response.body)
+      }
+      guard let data = response.body.data(using: .utf8) else {
+        throw NSError(
+          domain: "HttpClient",
+          code: -1,
+          userInfo: [NSLocalizedDescriptionKey: "Failed to convert response body to data"],
+        )
+      }
+      let decoder = JSONDecoder()
+      do {
+        return try decoder.decode(type, from: data)
+      } catch let DecodingError.keyNotFound(key, context) {
+        throw NSError(
+          domain: "HttpClient",
+          code: -1,
+          userInfo: [NSLocalizedDescriptionKey: "Missing required key '\(key.stringValue)' at path: \(context.codingPath.map(\.stringValue).joined(separator: "."))"],
+        )
+      } catch let DecodingError.typeMismatch(type, context) {
+        throw NSError(
+          domain: "HttpClient",
+          code: -1,
+          userInfo: [NSLocalizedDescriptionKey: "Type mismatch for \(type) at path: \(context.codingPath.map(\.stringValue).joined(separator: "."))"],
+        )
+      } catch let DecodingError.valueNotFound(type, context) {
+        throw NSError(
+          domain: "HttpClient",
+          code: -1,
+          userInfo: [NSLocalizedDescriptionKey: "Value not found for \(type) at path: \(context.codingPath.map(\.stringValue).joined(separator: "."))"],
+        )
+      }
+    case let .failure(error):
+      throw error
+    }
+  }
+}
+
+// MARK: - Logging
+
+extension HttpClient {
+  private func logRequest(_ request: HttpRequest) {
+    logger.debug("→ \(request.method) \(request.url)")
+    if let headers = request.headers, !headers.isEmpty {
+      for (key, value) in headers {
+        logger.debug("  \(key): \(value)")
+      }
+    }
+    if let body = request.body {
+      let truncated = body.prefix(500)
+      logger.debug("  Body: \(truncated)\(body.count > 500 ? "..." : "")")
+    }
+  }
+
+  private func logResponse(_ response: HttpResponse, url: String) {
+    let emoji = response.isSuccessful ? "✓" : "✗"
+    logger.debug("← \(emoji) \(response.code) \(url)")
+    if !response.body.isEmpty {
+      let truncated = response.body.prefix(500)
+      logger.debug("  Body: \(truncated)\(response.body.count > 500 ? "..." : "")")
+    }
+  }
+
+  private func logError(_ error: Error, url: String) {
+    logger.error("✗ Error for \(url): \(error.localizedDescription)")
+  }
+}