@rntp/player 5.0.0-beta.3 → 5.0.0-beta.5

package/ios/player/CacheProxyServer.swift

@@ -0,0 +1,429 @@
+//
+// Copyright (c) Double Symmetry GmbH
+// Commercial use requires a license. See https://rntp.dev/pricing
+//
+
+import Foundation
+import Network
+
+/// An HTTP proxy server running on localhost that sits between AVPlayer and
+/// the network. It serves fully-cached audio from disk and streams in-progress
+/// downloads using chunked Transfer-Encoding.
+final class CacheProxyServer {
+
+  private let coordinator: DownloadCoordinator
+  private let cache: AudioCache
+  private let listener: NWListener
+  private let serverQueue = DispatchQueue(label: "trackplayer.proxy-server")
+  private var connections: [NWConnection] = []
+
+  /// The TCP port the server is listening on. Available after `start()`.
+  var port: UInt16 {
+    listener.port?.rawValue ?? 0
+  }
+
+  init(coordinator: DownloadCoordinator, cache: AudioCache) throws {
+    self.coordinator = coordinator
+    self.cache = cache
+    self.listener = try NWListener(using: .tcp, on: .any)
+  }
+
+  // MARK: - Lifecycle
+
+  func start() {
+    let ready = DispatchSemaphore(value: 0)
+    listener.stateUpdateHandler = { state in
+      if case .ready = state { ready.signal() }
+    }
+    listener.newConnectionHandler = { [weak self] connection in
+      self?.acceptConnection(connection)
+    }
+    listener.start(queue: serverQueue)
+    ready.wait()
+  }
+
+  func stop() {
+    for conn in connections { conn.cancel() }
+    connections.removeAll()
+    listener.cancel()
+  }
+
+  // MARK: - URL Building
+
+  /// Build a proxy URL that encodes the upstream URL and optional headers
+  /// as query parameters.
+  ///
+  /// Format: `http://localhost:<port>/<cacheKey>?url=<encoded>&header_Key=Value`
+  func proxyURL(for url: URL, headers: [String: String]?) -> URL {
+    let key = cache.cacheKey(for: url)
+    let ext = url.pathExtension
+    var components = URLComponents()
+    components.scheme = "http"
+    components.host = "localhost"
+    components.port = Int(port)
+    components.path = ext.isEmpty ? "/\(key)" : "/\(key).\(ext)"
+
+    var queryItems = [URLQueryItem(name: "url", value: url.absoluteString)]
+    if let headers = headers {
+      for (k, v) in headers.sorted(by: { $0.key < $1.key }) {
+        queryItems.append(URLQueryItem(name: "header_\(k)", value: v))
+      }
+    }
+    components.queryItems = queryItems
+
+    return components.url!
+  }
+
+  // MARK: - Connection Handling
+
+  private func acceptConnection(_ connection: NWConnection) {
+    connections.append(connection)
+
+    connection.stateUpdateHandler = { [weak self] state in
+      switch state {
+      case .cancelled, .failed:
+        self?.connections.removeAll { $0 === connection }
+      default:
+        break
+      }
+    }
+
+    connection.start(queue: serverQueue)
+
+    connection.receive(minimumIncompleteLength: 1, maximumLength: 16384) { [weak self] data, _, _, error in
+      guard let self = self, let data = data, error == nil else {
+        connection.cancel()
+        return
+      }
+      self.handleRawRequest(data, on: connection)
+    }
+  }
+
+  // MARK: - HTTP Request Parsing
+
+  private struct ParsedRequest {
+    let cacheKey: String
+    let upstreamURL: URL
+    let headers: [String: String]
+    /// Byte range from a `Range: bytes=N-` or `Range: bytes=N-M` header.
+    let rangeStart: Int64?
+    let rangeEnd: Int64?
+  }
+
+  private func parseRequest(_ data: Data) -> ParsedRequest? {
+    guard let requestString = String(data: data, encoding: .utf8) else { return nil }
+
+    // Parse the request line: GET /path?query HTTP/1.1
+    let lines = requestString.components(separatedBy: "\r\n")
+    guard let requestLine = lines.first else { return nil }
+    let parts = requestLine.split(separator: " ")
+    guard parts.count >= 2 else { return nil }
+
+    let rawPath = String(parts[1])
+    guard let components = URLComponents(string: rawPath) else { return nil }
+
+    // Cache key is the path component (strip leading / and file extension)
+    var cacheKey = String(components.path.dropFirst())
+    if let dotIdx = cacheKey.lastIndex(of: ".") {
+      cacheKey = String(cacheKey[cacheKey.startIndex..<dotIdx])
+    }
+    guard !cacheKey.isEmpty else { return nil }
+
+    // Extract query parameters
+    let queryItems = components.queryItems ?? []
+
+    guard let urlParam = queryItems.first(where: { $0.name == "url" })?.value,
+          let upstreamURL = URL(string: urlParam) else { return nil }
+
+    var headers: [String: String] = [:]
+    for item in queryItems where item.name.hasPrefix("header_") {
+      let headerKey = String(item.name.dropFirst("header_".count))
+      headers[headerKey] = item.value ?? ""
+    }
+
+    // Parse Range header from AVPlayer's request (e.g. "Range: bytes=N-" or "Range: bytes=N-M")
+    var rangeStart: Int64?
+    var rangeEnd: Int64?
+    for line in lines.dropFirst() {
+      let lower = line.lowercased()
+      guard lower.hasPrefix("range:") else { continue }
+      let value = line.dropFirst("range:".count).trimmingCharacters(in: .whitespaces)
+      guard value.hasPrefix("bytes=") else { break }
+      let byteRange = value.dropFirst("bytes=".count)
+      let parts = byteRange.components(separatedBy: "-")
+      if let startStr = parts.first, let start = Int64(startStr) {
+        rangeStart = start
+      }
+      if parts.count > 1, let endStr = parts.last, !endStr.isEmpty, let end = Int64(endStr) {
+        rangeEnd = end
+      }
+      break
+    }
+
+    return ParsedRequest(cacheKey: cacheKey, upstreamURL: upstreamURL, headers: headers, rangeStart: rangeStart, rangeEnd: rangeEnd)
+  }
+
+  // MARK: - Request Routing
+
+  private func handleRawRequest(_ data: Data, on connection: NWConnection) {
+    guard let request = parseRequest(data) else {
+      sendError(status: 400, message: "Bad Request", on: connection)
+      return
+    }
+
+    if cache.isFullyCached(key: request.cacheKey) {
+      serveFromCache(request: request, on: connection)
+    } else {
+      serveThroughCoordinator(request: request, on: connection)
+    }
+  }
+
+  // MARK: - Cache Hit (full)
+
+  private func serveFromCache(request: ParsedRequest, on connection: NWConnection) {
+    let key = request.cacheKey
+    guard let info = cache.contentInfo(for: key) else {
+      sendError(status: 500, message: "Cache read error", on: connection)
+      return
+    }
+
+    let totalLength = info.contentLength
+    let startByte = request.rangeStart ?? 0
+    let endByte = request.rangeEnd ?? (totalLength - 1)
+    let sliceLength = endByte - startByte + 1
+
+    var header: String
+    if request.rangeStart != nil {
+      header = "HTTP/1.1 206 Partial Content\r\n"
+      header += "Content-Type: \(info.contentType)\r\n"
+      header += "Content-Range: bytes \(startByte)-\(endByte)/\(totalLength)\r\n"
+      header += "Content-Length: \(sliceLength)\r\n"
+      header += "Accept-Ranges: bytes\r\n"
+      header += "Connection: close\r\n"
+      header += "\r\n"
+    } else {
+      header = "HTTP/1.1 200 OK\r\n"
+      header += "Content-Type: \(info.contentType)\r\n"
+      header += "Content-Length: \(totalLength)\r\n"
+      header += "Accept-Ranges: bytes\r\n"
+      header += "Connection: close\r\n"
+      header += "\r\n"
+    }
+
+    connection.send(content: Data(header.utf8), completion: .contentProcessed { _ in })
+
+    let chunkSize = 64 * 1024
+    var offset: Int64 = startByte
+    let serveEnd = endByte + 1
+
+    func sendNextChunk() {
+      guard offset < serveEnd else {
+        connection.cancel()
+        return
+      }
+      let length = min(chunkSize, Int(serveEnd - offset))
+      guard let chunk = self.cache.readData(for: key, offset: offset, length: length) else {
+        connection.cancel()
+        return
+      }
+      offset += Int64(chunk.count)
+      let isComplete = offset >= serveEnd
+      connection.send(content: chunk, completion: .contentProcessed { error in
+        if error != nil || isComplete {
+          connection.cancel()
+        } else {
+          sendNextChunk()
+        }
+      })
+    }
+
+    sendNextChunk()
+  }
+
+  // MARK: - Cache Miss / Partial — Stream via Coordinator
+
+  private func serveThroughCoordinator(request: ParsedRequest, on connection: NWConnection) {
+    let key = request.cacheKey
+    let headers = request.headers.isEmpty ? nil : request.headers
+    let rangeStart = request.rangeStart ?? 0
+
+    // Track how many cache bytes we've sent to this client (absolute offset)
+    var bytesSent: Int64 = rangeStart
+    // Whether we're using chunked transfer encoding (no Content-Length known)
+    var isChunked = false
+    // Whether we've sent the HTTP response header yet
+    var headerSent = false
+    // Set when a send fails (client disconnected), prevents further writes.
+    var connectionClosed = false
+    // Download state — set from coordinator completion on serverQueue.
+    var downloadFinished = false
+    var downloadResult: Result<Void, Error> = .success(())
+
+    // Try to send the HTTP response header once content info is available.
+    func trySendResponseHeader() {
+      guard !headerSent else { return }
+      guard let contentInfo = self.cache.contentInfo(for: key) else { return }
+      headerSent = true
+
+      let contentLength = contentInfo.contentLength
+      var header: String
+      if contentLength > 0 {
+        isChunked = false
+        if request.rangeStart != nil {
+          let endByte = request.rangeEnd ?? (contentLength - 1)
+          let responseLength = endByte - rangeStart + 1
+          header = "HTTP/1.1 206 Partial Content\r\n"
+          header += "Content-Type: \(contentInfo.contentType)\r\n"
+          header += "Content-Range: bytes \(rangeStart)-\(endByte)/\(contentLength)\r\n"
+          header += "Content-Length: \(responseLength)\r\n"
+          header += "Accept-Ranges: bytes\r\n"
+          header += "Connection: close\r\n"
+          header += "\r\n"
+        } else {
+          header = "HTTP/1.1 200 OK\r\n"
+          header += "Content-Type: \(contentInfo.contentType)\r\n"
+          header += "Content-Length: \(contentLength)\r\n"
+          header += "Accept-Ranges: bytes\r\n"
+          header += "Connection: close\r\n"
+          header += "\r\n"
+        }
+      } else {
+        isChunked = true
+        header = "HTTP/1.1 200 OK\r\n"
+        header += "Content-Type: \(contentInfo.contentType)\r\n"
+        header += "Transfer-Encoding: chunked\r\n"
+        header += "Connection: close\r\n"
+        header += "\r\n"
+      }
+
+      connection.send(content: Data(header.utf8), completion: .contentProcessed { error in
+        if error != nil { connectionClosed = true }
+      })
+    }
+
+    // Send ONE chunk, then schedule the next via completion callback.
+    // This ensures only one write is in flight at a time, preventing
+    // broken pipe spam when the client disconnects.
+    func sendNextChunk() {
+      guard !connectionClosed else { return }
+
+      // If the download failed before we sent headers, send an error response.
+      if downloadFinished, case .failure = downloadResult, !headerSent {
+        self.sendError(status: 502, message: "Bad Gateway", on: connection)
+        return
+      }
+
+      trySendResponseHeader()
+      guard headerSent else {
+        // Content info not ready yet — retry shortly.
+        self.serverQueue.asyncAfter(deadline: .now() + .milliseconds(5)) {
+          sendNextChunk()
+        }
+        return
+      }
+
+      let available = self.cache.cachedBytes(for: key)
+      if bytesSent < available {
+        let chunkSize = min(Int(available - bytesSent), 64 * 1024)
+        guard let chunk = self.cache.readData(for: key, offset: bytesSent, length: chunkSize) else {
+          // Read failed — close.
+          connection.cancel()
+          return
+        }
+
+        let dataToSend: Data
+        if isChunked {
+          var chunked = Data(String(chunk.count, radix: 16).utf8)
+          chunked.append(Data("\r\n".utf8))
+          chunked.append(chunk)
+          chunked.append(Data("\r\n".utf8))
+          dataToSend = chunked
+        } else {
+          dataToSend = chunk
+        }
+
+        bytesSent += Int64(chunk.count)
+        connection.send(content: dataToSend, completion: .contentProcessed { [weak self] error in
+          guard self != nil else { return }
+          if error != nil {
+            connectionClosed = true
+            connection.cancel()
+            return
+          }
+          // Send next chunk on the server queue.
+          self?.serverQueue.async { sendNextChunk() }
+        })
+        return
+      }
+
+      // No more cached data available right now.
+      if downloadFinished {
+        // Verify all bytes were sent (cache flush race).
+        if !isChunked, let info = self.cache.contentInfo(for: key),
+           info.contentLength > 0, bytesSent < info.contentLength {
+          // Retry after a brief delay.
+          self.serverQueue.asyncAfter(deadline: .now() + .milliseconds(10)) {
+            sendNextChunk()
+          }
+          return
+        }
+
+        // All done — close the connection.
+        switch downloadResult {
+        case .success:
+          if isChunked {
+            connection.send(content: Data("0\r\n\r\n".utf8), completion: .contentProcessed { _ in
+              connection.cancel()
+            })
+          } else {
+            connection.send(content: Data(), completion: .contentProcessed { _ in
+              connection.cancel()
+            })
+          }
+        case .failure:
+          if !headerSent {
+            self.sendError(status: 502, message: "Bad Gateway", on: connection)
+          } else {
+            connection.cancel()
+          }
+        }
+        return
+      }
+
+      // Download still in progress — wait for more data.
+      self.serverQueue.asyncAfter(deadline: .now() + .milliseconds(5)) {
+        sendNextChunk()
+      }
+    }
+
+    // Start the send chain.
+    sendNextChunk()
+
+    // Kick off the download — the coordinator stores contentInfo as soon
+    // as the upstream response headers arrive.
+    coordinator.download(url: request.upstreamURL, headers: headers, cacheKey: key) { [weak self] result in
+      self?.serverQueue.async {
+        downloadResult = result
+        downloadFinished = true
+      }
+    }
+  }
+
+  // MARK: - Error Response
+
+  private func sendError(status: Int, message: String, on connection: NWConnection) {
+    let body = message
+    var header = "HTTP/1.1 \(status) \(message)\r\n"
+    header += "Content-Type: text/plain\r\n"
+    header += "Content-Length: \(body.utf8.count)\r\n"
+    header += "Connection: close\r\n"
+    header += "\r\n"
+
+    var response = Data(header.utf8)
+    response.append(Data(body.utf8))
+
+    connection.send(content: response, completion: .contentProcessed { _ in
+      connection.cancel()
+    })
+  }
+}

package/ios/player/DownloadCoordinator.swift

@@ -0,0 +1,242 @@
+//
+// Copyright (c) Double Symmetry GmbH
+// Commercial use requires a license. See https://rntp.dev/pricing
+//
+
+import Foundation
+
+/// Token returned by download() to allow cancellation of a specific subscriber.
+struct DownloadToken: Equatable {
+  fileprivate let id: UUID = UUID()
+  fileprivate let cacheKey: String
+}
+
+/// Coordinates downloads for audio URLs. Deduplicates concurrent requests
+/// for the same cache key so that preload → play transitions share a single
+/// upstream connection.
+final class DownloadCoordinator: NSObject {
+
+  private let cache: AudioCache
+  private let sessionQueue = DispatchQueue(label: "trackplayer.downloads")
+  private lazy var session: URLSession = {
+    let config = URLSessionConfiguration.default
+    let opQueue = OperationQueue()
+    opQueue.underlyingQueue = sessionQueue
+    opQueue.maxConcurrentOperationCount = 4
+    return URLSession(configuration: config, delegate: self, delegateQueue: opQueue)
+  }()
+
+  /// State for a single in-progress download.
+  private class ActiveDownload {
+    let url: URL
+    let cacheKey: String
+    var task: URLSessionDataTask?
+    var contentInfo: AudioCache.ContentInfo?
+    var maxBytes: Int64?
+    var subscribers: [(token: DownloadToken, completion: (Result<Void, Error>) -> Void)] = []
+
+    init(url: URL, cacheKey: String) {
+      self.url = url
+      self.cacheKey = cacheKey
+    }
+  }
+
+  /// Map of cache key → active download.
+  private var downloads: [String: ActiveDownload] = [:]
+  /// Map of URLSessionTask identifier → cache key (for delegate routing).
+  private var taskKeyMap: [Int: String] = [:]
+
+  /// Called when any download completes successfully.
+  /// Parameters: cache key, whether the full file was downloaded (false when stopped by maxBytes).
+  var onDownloadComplete: ((_ key: String, _ isFull: Bool) -> Void)?
+
+  var activeDownloadCount: Int {
+    sessionQueue.sync { downloads.count }
+  }
+
+  init(cache: AudioCache) {
+    self.cache = cache
+  }
+
+  // MARK: - Public
+
+  /// Start or attach to a download for the given URL.
+  /// Returns a token that can be used to cancel this subscriber.
+  /// - Parameter cacheKey: Explicit cache key. If nil, computed from the URL.
+  ///   Pass this when the URL has gone through encoding/decoding that might
+  ///   change its string representation (e.g. proxy query parameters).
+  @discardableResult
+  func download(
+    url: URL,
+    headers: [String: String]?,
+    cacheKey: String? = nil,
+    maxBytes: Int64? = nil,
+    completion: @escaping (Result<Void, Error>) -> Void = { _ in }
+  ) -> DownloadToken {
+    let key = cacheKey ?? cache.cacheKey(for: url)
+    let token = DownloadToken(cacheKey: key)
+
+    sessionQueue.async { [self] in
+      if cache.isFullyCached(key: key) {
+        DispatchQueue.global().async { completion(.success(())) }
+        return
+      }
+
+      if let existing = downloads[key] {
+        existing.subscribers.append((token, completion))
+        return
+      }
+
+      let dl = ActiveDownload(url: url, cacheKey: key)
+      dl.maxBytes = maxBytes
+      dl.subscribers.append((token, completion))
+
+      var request = URLRequest(url: url)
+      headers?.forEach { request.setValue($0.value, forHTTPHeaderField: $0.key) }
+
+      let cachedBytes = cache.cachedBytes(for: key)
+      if cachedBytes > 0 {
+        request.setValue("bytes=\(cachedBytes)-", forHTTPHeaderField: "Range")
+      }
+
+      let task = session.dataTask(with: request)
+      dl.task = task
+      downloads[key] = dl
+      taskKeyMap[task.taskIdentifier] = key
+
+      task.resume()
+    }
+
+    return token
+  }
+
+  /// Cancel a specific subscriber. If no subscribers remain, the download is cancelled.
+  func cancelDownload(token: DownloadToken) {
+    sessionQueue.async { [self] in
+      guard let dl = downloads[token.cacheKey] else { return }
+      dl.subscribers.removeAll { $0.token == token }
+      if dl.subscribers.isEmpty {
+        dl.task?.cancel()
+        if let taskId = dl.task?.taskIdentifier {
+          taskKeyMap.removeValue(forKey: taskId)
+        }
+        downloads.removeValue(forKey: token.cacheKey)
+      }
+    }
+  }
+
+  /// Cancel all active downloads.
+  func cancelAll() {
+    sessionQueue.async { [self] in
+      for (_, dl) in downloads {
+        dl.task?.cancel()
+      }
+      downloads.removeAll()
+      taskKeyMap.removeAll()
+    }
+  }
+
+  // MARK: - Private
+
+  private func activeDownload(for task: URLSessionTask) -> ActiveDownload? {
+    guard let key = taskKeyMap[task.taskIdentifier] else { return nil }
+    return downloads[key]
+  }
+
+  private func notifySubscribers(for key: String, result: Result<Void, Error>, isFull: Bool = true) {
+    guard let dl = downloads.removeValue(forKey: key) else { return }
+    if let taskId = dl.task?.taskIdentifier {
+      taskKeyMap.removeValue(forKey: taskId)
+    }
+    for sub in dl.subscribers {
+      DispatchQueue.global().async { sub.completion(result) }
+    }
+    if case .success = result {
+      onDownloadComplete?(key, isFull)
+    }
+  }
+}
+
+// MARK: - URLSessionDataDelegate
+
+extension DownloadCoordinator: URLSessionDataDelegate {
+
+  func urlSession(
+    _ session: URLSession,
+    dataTask: URLSessionDataTask,
+    didReceive response: URLResponse,
+    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
+  ) {
+    guard let dl = activeDownload(for: dataTask),
+          let http = response as? HTTPURLResponse else {
+      completionHandler(.allow)
+      return
+    }
+
+    if cache.contentInfo(for: dl.cacheKey) == nil {
+      let mime = http.mimeType ?? "audio/mpeg"
+      var totalLength: Int64 = -1
+
+      if http.statusCode == 206,
+         let rangeHeader = http.value(forHTTPHeaderField: "Content-Range"),
+         let slashIdx = rangeHeader.lastIndex(of: "/") {
+        totalLength = Int64(rangeHeader[rangeHeader.index(after: slashIdx)...]) ?? -1
+      } else {
+        totalLength = response.expectedContentLength
+      }
+
+      let byteRange = http.statusCode == 206
+      let info = AudioCache.ContentInfo(
+        contentType: mime,
+        contentLength: totalLength,
+        isByteRangeAccessSupported: byteRange
+      )
+      cache.storeContentInfo(info, for: dl.cacheKey, url: dl.url)
+      downloads[dl.cacheKey]?.contentInfo = info
+    }
+
+    completionHandler(.allow)
+  }
+
+  func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
+    guard let dl = activeDownload(for: dataTask) else { return }
+    cache.appendData(data, for: dl.cacheKey)
+
+    // Stop download if byte limit reached.
+    if let maxBytes = dl.maxBytes, cache.cachedBytes(for: dl.cacheKey) >= maxBytes {
+      cache.touchAccessDate(for: dl.cacheKey)
+      cache.evictIfNeeded()
+      dataTask.cancel()
+      notifySubscribers(for: dl.cacheKey, result: .success(()), isFull: false)
+    }
+  }
+
+  func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
+    guard let key = taskKeyMap[task.taskIdentifier] else { return }
+
+    if let error = error as? URLError, error.code == .cancelled { return }
+
+    if let error = error {
+      notifySubscribers(for: key, result: .failure(error))
+      return
+    }
+
+    // Finalize content length if the server didn't provide it.
+    if let info = cache.contentInfo(for: key), info.contentLength <= 0 {
+      let actualLength = cache.cachedBytes(for: key)
+      if actualLength > 0 {
+        let updated = AudioCache.ContentInfo(
+          contentType: info.contentType,
+          contentLength: actualLength,
+          isByteRangeAccessSupported: info.isByteRangeAccessSupported
+        )
+        cache.storeContentInfo(updated, for: key, url: downloads[key]?.url ?? URL(fileURLWithPath: "/"))
+      }
+    }
+
+    cache.touchAccessDate(for: key)
+    cache.evictIfNeeded()
+
+    notifySubscribers(for: key, result: .success(()))
+  }
+}