@rntp/player 5.0.0-beta.4 → 5.0.0-beta.6

package/ios/player/CachingResourceLoader.swift

@@ -1,273 +0,0 @@
-//
-// Copyright (c) Double Symmetry GmbH
-// Commercial use requires a license. See https://rntp.dev/pricing
-//
-
-import AVFoundation
-import UniformTypeIdentifiers
-
-final class CachingResourceLoader: NSObject, AVAssetResourceLoaderDelegate, URLSessionDataDelegate {
-
-  private let cache: AudioCache
-  let originalURL: URL
-  private let headers: [String: String]?
-  let cacheKey: String
-
-  private var pendingRequests: [AVAssetResourceLoadingRequest] = []
-  private var session: URLSession!
-  private var activeTask: URLSessionDataTask?
-
-  /// Byte offset of the next data chunk the active download will deliver.
-  private var downloadCursor: Int64 = 0
-  /// True when the download started at the cache boundary, so incoming data
-  /// can be appended sequentially.
-  private var downloadIsCacheable: Bool = false
-
-  // MARK: - Init
-
-  init(url: URL, headers: [String: String]?, cache: AudioCache, queue: DispatchQueue) {
-    self.cache = cache
-    self.originalURL = url
-    self.headers = headers
-    self.cacheKey = cache.cacheKey(for: url)
-    super.init()
-
-    let opQueue = OperationQueue()
-    opQueue.underlyingQueue = queue
-    opQueue.maxConcurrentOperationCount = 1
-    self.session = URLSession(configuration: .default, delegate: self, delegateQueue: opQueue)
-  }
-
-  func invalidate() {
-    activeTask?.cancel()
-    activeTask = nil
-    session.invalidateAndCancel()
-    for request in pendingRequests where !request.isFinished && !request.isCancelled {
-      request.finishLoading(with: URLError(.cancelled))
-    }
-    pendingRequests.removeAll()
-  }
-
-  // MARK: - URL Scheme Helpers
-
-  static func cacheURL(from original: URL) -> URL? {
-    guard var components = URLComponents(url: original, resolvingAgainstBaseURL: false) else { return nil }
-    guard let scheme = components.scheme else { return nil }
-    components.scheme = "trackplayer-\(scheme)"
-    return components.url
-  }
-
-  static func originalURL(from cacheURL: URL) -> URL? {
-    guard var components = URLComponents(url: cacheURL, resolvingAgainstBaseURL: false) else { return nil }
-    guard let scheme = components.scheme, scheme.hasPrefix("trackplayer-") else { return nil }
-    components.scheme = String(scheme.dropFirst("trackplayer-".count))
-    return components.url
-  }
-
-  // MARK: - AVAssetResourceLoaderDelegate
-
-  func resourceLoader(
-    _ resourceLoader: AVAssetResourceLoader,
-    shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest
-  ) -> Bool {
-    pendingRequests.append(loadingRequest)
-    processRequests()
-    return true
-  }
-
-  func resourceLoader(
-    _ resourceLoader: AVAssetResourceLoader,
-    didCancel loadingRequest: AVAssetResourceLoadingRequest
-  ) {
-    pendingRequests.removeAll { $0 === loadingRequest }
-    if pendingRequests.isEmpty {
-      activeTask?.cancel()
-      activeTask = nil
-    }
-  }
-
-  // MARK: - Request Processing
-
-  private func processRequests() {
-    var completed: [AVAssetResourceLoadingRequest] = []
-
-    for request in pendingRequests {
-      guard !request.isFinished && !request.isCancelled else {
-        completed.append(request)
-        continue
-      }
-
-      let infoReady = fillContentInfo(request)
-      let dataReady = fillData(request)
-
-      if infoReady && dataReady {
-        request.finishLoading()
-        completed.append(request)
-      }
-    }
-
-    pendingRequests.removeAll { req in completed.contains { $0 === req } }
-
-    if !pendingRequests.isEmpty {
-      ensureDownload()
-    }
-  }
-
-  private func fillContentInfo(_ request: AVAssetResourceLoadingRequest) -> Bool {
-    guard let infoRequest = request.contentInformationRequest else { return true }
-    guard let info = cache.contentInfo(for: cacheKey) else { return false }
-
-    if let utType = UTType(mimeType: info.contentType) {
-      infoRequest.contentType = utType.identifier
-    }
-    infoRequest.contentLength = info.contentLength
-    infoRequest.isByteRangeAccessSupported = info.isByteRangeAccessSupported
-    return true
-  }
-
-  private func fillData(_ request: AVAssetResourceLoadingRequest) -> Bool {
-    guard let dataRequest = request.dataRequest else { return true }
-
-    let currentOffset = dataRequest.currentOffset
-    let requestedEnd = requestEnd(for: dataRequest)
-    let cachedBytes = cache.cachedBytes(for: cacheKey)
-
-    if currentOffset < cachedBytes {
-      let readable = min(requestedEnd, cachedBytes)
-      let length = Int(readable - currentOffset)
-      if length > 0, let data = cache.readData(for: cacheKey, offset: currentOffset, length: length) {
-        dataRequest.respond(with: data)
-      }
-    }
-
-    return dataRequest.currentOffset >= requestedEnd
-  }
-
-  private func requestEnd(for dataRequest: AVAssetResourceLoadingDataRequest) -> Int64 {
-    if dataRequest.requestsAllDataToEndOfResource {
-      return cache.contentInfo(for: cacheKey)?.contentLength ?? Int64.max
-    }
-    return dataRequest.requestedOffset + Int64(dataRequest.requestedLength)
-  }
-
-  // MARK: - Download
-
-  private func ensureDownload() {
-    guard activeTask == nil else { return }
-
-    guard let dataRequest = pendingRequests.first(where: { $0.dataRequest != nil })?.dataRequest else { return }
-
-    let neededOffset = dataRequest.currentOffset
-    let cachedBytes = cache.cachedBytes(for: cacheKey)
-
-    guard neededOffset >= cachedBytes else { return }
-
-    downloadCursor = neededOffset
-    downloadIsCacheable = (neededOffset == cachedBytes)
-
-    var request = URLRequest(url: originalURL)
-    headers?.forEach { request.setValue($0.value, forHTTPHeaderField: $0.key) }
-    request.setValue("bytes=\(neededOffset)-", forHTTPHeaderField: "Range")
-
-    activeTask = session.dataTask(with: request)
-    activeTask?.resume()
-  }
-
-  // MARK: - URLSessionDataDelegate
-
-  func urlSession(
-    _ session: URLSession,
-    dataTask: URLSessionDataTask,
-    didReceive response: URLResponse,
-    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
-  ) {
-    if cache.contentInfo(for: cacheKey) == nil, let http = response as? HTTPURLResponse {
-      let mime = http.mimeType ?? "audio/mpeg"
-      var totalLength: Int64 = -1
-
-      if http.statusCode == 206, let rangeHeader = http.value(forHTTPHeaderField: "Content-Range") {
-        if 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: cacheKey, url: originalURL)
-    }
-
-    completionHandler(.allow)
-    processRequests()
-  }
-
-  func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
-    if downloadIsCacheable {
-      cache.appendData(data, for: cacheKey)
-    }
-    downloadCursor += Int64(data.count)
-
-    // Respond to pending data requests that fall within the just-downloaded range
-    var completed: [AVAssetResourceLoadingRequest] = []
-    for request in pendingRequests {
-      guard !request.isFinished && !request.isCancelled else {
-        completed.append(request)
-        continue
-      }
-      let infoReady = fillContentInfo(request)
-      let dataReady: Bool
-
-      if downloadIsCacheable {
-        dataReady = fillData(request)
-      } else if let dataReq = request.dataRequest {
-        let chunkStart = downloadCursor - Int64(data.count)
-        let reqOffset = dataReq.currentOffset
-        if reqOffset >= chunkStart && reqOffset < downloadCursor {
-          let skip = Int(reqOffset - chunkStart)
-          let subdata = data.subdata(in: skip..<data.count)
-          dataReq.respond(with: subdata)
-        }
-        dataReady = dataReq.currentOffset >= requestEnd(for: dataReq)
-      } else {
-        dataReady = true
-      }
-
-      if infoReady && dataReady {
-        request.finishLoading()
-        completed.append(request)
-      }
-    }
-
-    pendingRequests.removeAll { req in completed.contains { $0 === req } }
-  }
-
-  func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
-    activeTask = nil
-
-    if let error = error as? URLError, error.code == .cancelled { return }
-
-    if let error = error {
-      for request in pendingRequests where !request.isFinished && !request.isCancelled {
-        request.finishLoading(with: error)
-      }
-      pendingRequests.removeAll()
-      return
-    }
-
-    if downloadIsCacheable {
-      cache.touchAccessDate(for: cacheKey)
-      cache.evictIfNeeded()
-    }
-
-    processRequests()
-
-    if !pendingRequests.isEmpty {
-      ensureDownload()
-    }
-  }
-}