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

package/ios/player/AVPlayerEngine.swift

@@ -23,8 +23,14 @@ class AVPlayerEngine: PlayerEngine {
 
   // Caching
   private let cache: AudioCache?
-  private var currentResourceLoader: CachingResourceLoader?
-  private let resourceLoaderQueue = DispatchQueue(label: "trackplayer.resourceloader")
+  private let proxyServer: CacheProxyServer?
+  private let _downloadCoordinator: DownloadCoordinator?
+
+  /// Exposed so AudioPlayer can pass it to the Preloader.
+  var downloadCoordinator: DownloadCoordinator? { _downloadCoordinator }
+
+  /// Cache key for the currently loaded URL, used for cachedPosition.
+  private(set) var currentCacheKey: String?
 
   // MARK: - Callbacks
 
@@ -59,14 +65,20 @@ class AVPlayerEngine: PlayerEngine {
   }
 
   var cachedPosition: Double {
-    guard let cache = cache, let loader = currentResourceLoader else { return 0 }
-    let bytes = cache.cachedBytes(for: loader.cacheKey)
-    guard bytes > 0,
-          let info = cache.contentInfo(for: loader.cacheKey),
-          info.contentLength > 0 else { return 0 }
-    let dur = duration
-    guard dur > 0 else { return 0 }
-    return (Double(bytes) / Double(info.contentLength)) * dur
+    guard let cache = cache, let key = currentCacheKey else { return 0 }
+    let bytes = cache.cachedBytes(for: key)
+    guard bytes > 0 else { return 0 }
+
+    if let info = cache.contentInfo(for: key), info.contentLength > 0 {
+      let dur = duration
+      guard dur > 0 else { return 0 }
+      return (Double(bytes) / Double(info.contentLength)) * dur
+    }
+
+    // Content length unknown (download in progress, no response yet).
+    // Fall back to bufferedPosition — since AVPlayer streams through
+    // the proxy, what's buffered approximates what's cached.
+    return bufferedPosition
   }
 
   var defaultRate: Float {
@@ -99,6 +111,17 @@ class AVPlayerEngine: PlayerEngine {
   init(handleAudioBecomingNoisy: Bool = true, cache: AudioCache? = nil) {
     self.handleAudioBecomingNoisy = handleAudioBecomingNoisy
     self.cache = cache
+
+    if let cache = cache {
+      let coordinator = DownloadCoordinator(cache: cache)
+      self._downloadCoordinator = coordinator
+      self.proxyServer = try? CacheProxyServer(coordinator: coordinator, cache: cache)
+      self.proxyServer?.start()
+    } else {
+      self._downloadCoordinator = nil
+      self.proxyServer = nil
+    }
+
     avPlayer.allowsExternalPlayback = true
     avPlayer.usesExternalPlaybackWhileExternalScreenIsActive = true
     observeTimeControlStatus()
@@ -111,7 +134,7 @@ class AVPlayerEngine: PlayerEngine {
   }
 
   deinit {
-    currentResourceLoader?.invalidate()
+    proxyServer?.stop()
     timeControlObservation?.invalidate()
     removeItemObservers()
     if let observer = interruptionObserver {
@@ -133,20 +156,18 @@ class AVPlayerEngine: PlayerEngine {
   }
 
   func load(url: URL, headers: [String: String]? = nil, isLive: Bool = false) {
-    currentResourceLoader?.invalidate()
-    currentResourceLoader = nil
-
     let asset: AVURLAsset
 
-    if !isLive, let cache = cache, url.scheme?.hasPrefix("http") == true,
-       let cacheURL = CachingResourceLoader.cacheURL(from: url) {
-      let loader = CachingResourceLoader(url: url, headers: headers, cache: cache, queue: resourceLoaderQueue)
-      currentResourceLoader = loader
-      asset = AVURLAsset(url: cacheURL)
-      asset.resourceLoader.setDelegate(loader, queue: resourceLoaderQueue)
+    if !isLive, let proxy = proxyServer, let cache = cache,
+       url.scheme?.hasPrefix("http") == true {
+      let proxyURL = proxy.proxyURL(for: url, headers: headers)
+      currentCacheKey = cache.cacheKey(for: url)
+      asset = AVURLAsset(url: proxyURL)
     } else if let headers = headers, !headers.isEmpty {
+      currentCacheKey = nil
       asset = AVURLAsset(url: url, options: ["AVURLAssetHTTPHeaderFieldsKey": headers])
     } else {
+      currentCacheKey = nil
       asset = AVURLAsset(url: url)
     }
 
@@ -162,8 +183,7 @@ class AVPlayerEngine: PlayerEngine {
   }
 
   func reset() {
-    currentResourceLoader?.invalidate()
-    currentResourceLoader = nil
+    currentCacheKey = nil
     removeItemObservers()
     avPlayer.replaceCurrentItem(with: nil)
   }
@@ -260,14 +280,15 @@ class AVPlayerEngine: PlayerEngine {
   private func observeItem(_ item: AVPlayerItem) {
     itemStatusObservation = item.observe(\.status, options: [.initial, .new]) { [weak self] item, _ in
       DispatchQueue.main.async {
+        guard let self = self else { return }
         switch item.status {
         case .readyToPlay:
-          self?.emitAssetMetadata(from: item)
+          self.emitAssetMetadata(from: item)
         case .failed:
           let nsError = item.error as NSError?
           let code = Self.classifyError(nsError)
           let message = nsError?.localizedDescription ?? "Unknown playback error"
-          self?.onItemFailed?(code, message)
+          self.onItemFailed?(code, message)
         default:
           break
         }
@@ -341,15 +362,8 @@ class AVPlayerEngine: PlayerEngine {
   // MARK: - Asset Metadata
 
   /// Extracts static metadata (ID3, etc.) from the asset when the item becomes ready.
-  /// When caching is active the playback asset uses a custom URL scheme, so we use
-  /// the original HTTP URL for metadata extraction instead.
   private func emitAssetMetadata(from item: AVPlayerItem) {
-    let asset: AVURLAsset
-    if let loader = currentResourceLoader {
-      asset = AVURLAsset(url: loader.originalURL)
-    } else {
-      asset = item.asset as! AVURLAsset
-    }
+    let asset = item.asset as! AVURLAsset
     asset.loadValuesAsynchronously(forKeys: ["commonMetadata"]) { [weak self] in
       var error: NSError?
       let status = asset.statusOfValue(forKey: "commonMetadata", error: &error)

package/ios/player/AudioCache.swift

@@ -117,6 +117,40 @@ final class AudioCache: @unchecked Sendable {
     }
   }
 
+  // MARK: - Debug
+
+  /// Dumps the full cache state to the console for debugging.
+  func dumpState(currentKey: String? = nil) {
+    queue.sync {
+      let fm = FileManager.default
+      guard let contents = try? fm.contentsOfDirectory(at: root, includingPropertiesForKeys: nil) else {
+        print("[AudioCache] empty or unreadable")
+        return
+      }
+
+      let metaFiles = contents.filter { $0.pathExtension == "meta" }
+      let totalSize = metaFiles.reduce(Int64(0)) { total, metaURL in
+        let key = metaURL.deletingPathExtension().lastPathComponent
+        return total + dataFileSize(for: key)
+      }
+
+      print("[AudioCache] \(metaFiles.count) items, \(totalSize / 1024 / 1024)MB / \(maxSize / 1024 / 1024)MB max")
+
+      for metaURL in metaFiles {
+        let key = metaURL.deletingPathExtension().lastPathComponent
+        let m = meta(for: key)
+        let size = dataFileSize(for: key)
+        let cl = m?.contentInfo?.contentLength ?? -1
+        let ct = m?.contentInfo?.contentType ?? "?"
+        let url = m?.url ?? "?"
+        let pct = cl > 0 ? Int(Double(size) / Double(cl) * 100) : -1
+        let isCurrent = (key == currentKey) ? " ← CURRENT" : ""
+        let urlShort = url.count > 60 ? "…" + url.suffix(55) : url
+        print("  [\(key.prefix(8))…] \(size / 1024)KB / \(cl > 0 ? "\(cl / 1024)KB" : "??") (\(pct)%) \(ct) \(urlShort)\(isCurrent)")
+      }
+    }
+  }
+
   // MARK: - Internal File Helpers
 
   private func dataFileURL(for key: String) -> URL {

package/ios/player/AudioPlayer.swift

@@ -22,11 +22,13 @@ class AudioPlayer {
 
   private let engine: PlayerEngine
   private let queue = QueueManager()
-  private var preloader: Preloader?
+  private(set) var preloader: Preloader?
   #if canImport(UIKit)
   private let artworkCache = NSCache<NSString, UIImage>()
   #endif
 
+  var preloadWindow: Int = 0
+
   private static let previousThreshold: Double = 3.0
   private var lastEmittedMetadata: StreamMetadata?
   private var pendingItemMetadata: StreamMetadata?
@@ -77,20 +79,33 @@ class AudioPlayer {
 
   // MARK: - Init
 
-  init(engine: PlayerEngine, cache: AudioCache? = nil) {
+  init(engine: PlayerEngine, cache: AudioCache? = nil, coordinator: DownloadCoordinator? = nil) {
     self.engine = engine
-    if let cache = cache {
-      self.preloader = Preloader(cache: cache)
+    if let cache = cache, let coordinator = coordinator {
+      self.preloader = Preloader(cache: cache, coordinator: coordinator)
+    }
+    coordinator?.onDownloadComplete = { [weak self] key, isFull in
+      guard let self = self, isFull else { return }
+      if let engine = self.engine as? AVPlayerEngine,
+         engine.currentCacheKey == key {
+        DispatchQueue.main.async {
+          self.onCurrentTrackCached()
+        }
+      }
     }
     setupEngineCallbacks()
   }
 
+  #if os(iOS)
   convenience init(handleAudioBecomingNoisy: Bool = true, cache: AudioCache? = nil) {
+    let engine = AVPlayerEngine(handleAudioBecomingNoisy: handleAudioBecomingNoisy, cache: cache)
     self.init(
-      engine: AVPlayerEngine(handleAudioBecomingNoisy: handleAudioBecomingNoisy, cache: cache),
-      cache: cache
+      engine: engine,
+      cache: cache,
+      coordinator: engine.downloadCoordinator
     )
   }
+  #endif
 
   private func setupEngineCallbacks() {
     engine.onPlaybackStateChange = { [weak self] status in
@@ -268,7 +283,7 @@ class AudioPlayer {
   // MARK: - Destroy
 
   func destroy() {
-    preloader?.cancel()
+    preloader?.cancelAll()
     clear()
     onStateChange = nil
     onCurrentItemChanged = nil
@@ -313,23 +328,23 @@ class AudioPlayer {
     state = .loading
     updateNowPlayingMetadata(for: item)
     onCurrentItemChanged?(item, queue.currentIndex)
-    if !item.isLive { preloadNextItem() }
   }
 
-  private func preloadNextItem() {
-    guard let preloader = preloader else { return }
-    let nextIndex = queue.currentIndex + 1
-    guard nextIndex < queue.items.count else {
-      preloader.cancel()
-      return
-    }
-    let nextItem = queue.items[nextIndex]
-    guard nextItem.sourceType == .stream,
-          let url = URL(string: nextItem.sourceUrl) else {
-      preloader.cancel()
-      return
+  /// Called when the current track's download completes (fully cached).
+  private func onCurrentTrackCached() {
+    guard preloadWindow > 0, let preloader = preloader else { return }
+    preloader.cancelAll()
+
+    let startIndex = queue.currentIndex + 1
+    let endIndex = min(startIndex + preloadWindow, queue.items.count)
+    guard startIndex < endIndex else { return }
+
+    for i in startIndex..<endIndex {
+      let item = queue.items[i]
+      guard !item.isLive, item.sourceType == .stream,
+            let url = URL(string: item.sourceUrl) else { continue }
+      preloader.preload(url: url, headers: item.headers)
     }
-    preloader.preload(url: url, headers: nextItem.headers)
   }
 
   // MARK: - State Handling