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

package/ios/TrackPlayer.swift

@@ -22,13 +22,7 @@ class TrackPlayer: RCTEventEmitter {
   private var progressSyncHttpUrl: String?
   private var progressSyncHttpHeaders: [String: String]?
 
-  private var sleepTimerType: String? // "time" or "mediaItem"
-  private var sleepTimerRemainingSeconds: Double = 0
-  private var sleepTimerFadeOutSeconds: Double = 0
-  private var sleepTimerTargetIndex: Int?
-  private var sleepTimer: Timer?
-  private var sleepTimerPreFadeVolume: Float?
-  private var sleepTimerPreviousIndex: Int?
+  private var sleepTimerController: SleepTimerController?
 
   // MARK: - Initializers
 
@@ -71,19 +65,29 @@ class TrackPlayer: RCTEventEmitter {
     try? AVAudioSession.sharedInstance().setCategory(.playback, mode: mode)
 
     var cache: AudioCache? = nil
+    var preloadWindow = 0
     if let cacheConfig = config["cache"] as? [String: Any] {
-      let maxSize = (cacheConfig["maxSizeBytes"] as? NSNumber)?.int64Value ?? (100 * 1024 * 1024)
+      let maxSize = (cacheConfig["maxSizeBytes"] as? NSNumber)?.int64Value ?? (500 * 1024 * 1024)
       cache = AudioCache(maxSizeBytes: maxSize)
+      if let preloadConfig = cacheConfig["preloading"] as? [String: Any] {
+        preloadWindow = (preloadConfig["window"] as? NSNumber)?.intValue ?? 0
+      }
     }
     audioCache = cache
 
     let handleNoisy = config["handleAudioBecomingNoisy"] as? Bool ?? true
     player = AudioPlayer(handleAudioBecomingNoisy: handleNoisy, cache: cache)
+    player.preloadWindow = preloadWindow
     bindPlayerCallbacks()
     BrowseTreeStore.shared.player = player
     lastEmittedStateString = nil
     lastIsPlaying = false
 
+    sleepTimerController = SleepTimerController(player: player)
+    sleepTimerController?.onTriggered = { [weak self] type in
+      self?.emitEvent(event: SleepTimerTriggeredEvent(sleepType: type))
+    }
+
     if let progressSync = config["progressSync"] as? [String: Any] {
       progressSyncIntervalSeconds = progressSync["intervalSeconds"] as? Double ?? 0
       if let http = progressSync["http"] as? [String: Any] {
@@ -152,6 +156,28 @@ class TrackPlayer: RCTEventEmitter {
     audioCache?.removeAll()
   }
 
+  @objc(preload:duration:)
+  func preload(item: [String: Any], duration: Double) {
+    guard let urlString = extractUrl(from: item),
+          let url = URL(string: urlString) else { return }
+
+    let headers = item["headers"] as? [String: String]
+    player.preloader?.preload(url: url, headers: headers)
+  }
+
+  @objc(cancelPreload:)
+  func cancelPreload(item: [String: Any]) {
+    guard let urlString = extractUrl(from: item),
+          let url = URL(string: urlString) else { return }
+    player.preloader?.cancel(url: url)
+  }
+
+  private func extractUrl(from item: [String: Any]) -> String? {
+    if let url = item["url"] as? String { return url }
+    if let urlObj = item["url"] as? [String: Any], let uri = urlObj["uri"] as? String { return uri }
+    return nil
+  }
+
   @objc(setPlaybackSpeed:)
   func setPlaybackSpeed(speed: Double) {
     player.rate = Float(speed)
@@ -233,8 +259,8 @@ class TrackPlayer: RCTEventEmitter {
   @objc(clear)
   func clear() {
     player.clear()
-    if sleepTimerType == "mediaItem" {
-      cancelSleepTimerInternal(restoreVolume: false)
+    if sleepTimerController?.sleepTimerType == "mediaItem" {
+      sleepTimerController?.cancelInternal(restoreVolume: false)
     }
     emitEvent(event: QueueChangedEvent())
   }
@@ -413,101 +439,24 @@ class TrackPlayer: RCTEventEmitter {
 
   // MARK: - Sleep Timer
 
-  private func cancelSleepTimerInternal(restoreVolume: Bool) {
-    sleepTimer?.invalidate()
-    sleepTimer = nil
-    if restoreVolume, let preFadeVolume = sleepTimerPreFadeVolume {
-      player.volume = preFadeVolume
-    }
-    sleepTimerPreFadeVolume = nil
-    sleepTimerType = nil
-    sleepTimerRemainingSeconds = 0
-    sleepTimerFadeOutSeconds = 0
-    sleepTimerTargetIndex = nil
-    sleepTimerPreviousIndex = nil
-  }
-
-  private func onSleepTimerTick() {
-    sleepTimerRemainingSeconds -= 1
-
-    // Handle fade-out (before zero-check so final tick sets volume to 0)
-    if sleepTimerFadeOutSeconds > 0 && sleepTimerRemainingSeconds < sleepTimerFadeOutSeconds {
-      if sleepTimerPreFadeVolume == nil {
-        sleepTimerPreFadeVolume = player.volume
-      }
-      let progress = max(0, sleepTimerRemainingSeconds) / sleepTimerFadeOutSeconds
-      player.volume = (sleepTimerPreFadeVolume ?? 1.0) * Float(progress)
-    }
-
-    if sleepTimerRemainingSeconds <= 0 {
-      sleepTimerRemainingSeconds = 0
-      player.pause()
-      emitEvent(event: SleepTimerTriggeredEvent(sleepType: "time"))
-      // Restore volume after pausing so next playback isn't muted
-      cancelSleepTimerInternal(restoreVolume: true)
-      return
-    }
-  }
-
-  private func startSleepCountdownTimer() {
-    sleepTimer?.invalidate()
-    let timer = Timer(timeInterval: 1.0, repeats: true) { [weak self] _ in
-      self?.onSleepTimerTick()
-    }
-    RunLoop.main.add(timer, forMode: .common)
-    sleepTimer = timer
-  }
-
-  private func pauseSleepCountdownTimer() {
-    sleepTimer?.invalidate()
-    sleepTimer = nil
-  }
-
   @objc(sleepAfterTime:fadeOutSeconds:)
   func sleepAfterTime(seconds: Double, fadeOutSeconds: Double) {
-    cancelSleepTimerInternal(restoreVolume: true)
-    sleepTimerType = "time"
-    sleepTimerRemainingSeconds = seconds
-    sleepTimerFadeOutSeconds = min(fadeOutSeconds, seconds)
-
-    if seconds <= 0 {
-      player.pause()
-      emitEvent(event: SleepTimerTriggeredEvent(sleepType: "time"))
-      cancelSleepTimerInternal(restoreVolume: true)
-      return
-    }
-
-    startSleepCountdownTimer()
+    sleepTimerController?.sleepAfterTime(seconds: seconds, fadeOutSeconds: fadeOutSeconds)
   }
 
   @objc(sleepAfterMediaItemAtIndex:)
   func sleepAfterMediaItemAtIndex(index: Double) {
-    cancelSleepTimerInternal(restoreVolume: true)
-    sleepTimerType = "mediaItem"
-    sleepTimerTargetIndex = Int(index)
-    sleepTimerPreviousIndex = player.currentIndex
+    sleepTimerController?.sleepAfterMediaItemAtIndex(index: Int(index))
   }
 
   @objc(getSleepTimer)
   func getSleepTimer() -> [String: Any]? {
-    guard let type = sleepTimerType else { return nil }
-    if type == "time" {
-      return [
-        "type": "time",
-        "remainingSeconds": sleepTimerRemainingSeconds,
-        "fadeOutSeconds": sleepTimerFadeOutSeconds
-      ]
-    } else {
-      return [
-        "type": "mediaItem",
-        "index": sleepTimerTargetIndex ?? 0
-      ]
-    }
+    return sleepTimerController?.getState()
   }
 
   @objc(cancelSleepTimer)
   func cancelSleepTimer() {
-    cancelSleepTimerInternal(restoreVolume: true)
+    sleepTimerController?.cancel()
   }
 
   // MARK: - Browse Tree
@@ -522,7 +471,8 @@ class TrackPlayer: RCTEventEmitter {
   @objc(destroy)
   func destroy() {
     BrowseTreeStore.shared.clear()
-    cancelSleepTimerInternal(restoreVolume: false)
+    sleepTimerController?.cancel()
+    sleepTimerController = nil
     stopProgressSyncTimer(fireFinalTick: false)
     let commandCenter = MPRemoteCommandCenter.shared()
     commandCenter.togglePlayPauseCommand.removeTarget(nil)
@@ -580,17 +530,12 @@ class TrackPlayer: RCTEventEmitter {
 
   func handleCurrentItemChanged(item: AudioItem?, index: Int) {
     // Sleep timer: check if the target item just finished
-    if sleepTimerType == "mediaItem", let targetIndex = sleepTimerTargetIndex {
-      if sleepTimerPreviousIndex == targetIndex && index != targetIndex {
-        emitEvent(event: SleepTimerTriggeredEvent(sleepType: "mediaItem"))
-        cancelSleepTimerInternal(restoreVolume: false)
-        // Defer pause to next run loop — calling during transition gets overridden
-        DispatchQueue.main.async { [weak self] in
-          self?.player.pause()
-        }
+    if sleepTimerController?.handleItemTransition(to: index) == true {
+      // Defer pause to next run loop — calling during transition gets overridden
+      DispatchQueue.main.async { [weak self] in
+        self?.player.pause()
       }
     }
-    sleepTimerPreviousIndex = index
     let mediaItem = item as? MediaItem
     let dict = mediaItem?.toDictionary()
     BrowseTreeStore.shared.updateNowPlaying(mediaId: mediaItem?.mediaId)

package/ios/TrackPlayerBridge.mm

@@ -29,6 +29,8 @@ RCT_EXTERN_METHOD(skipToPrevious);
 RCT_EXTERN_METHOD(skipToIndex:(double)index);
 RCT_EXTERN_METHOD(retry);
 RCT_EXTERN_METHOD(clearCache);
+RCT_EXTERN_METHOD(preload:(NSDictionary *)item duration:(double)duration);
+RCT_EXTERN_METHOD(cancelPreload:(NSDictionary *)item);
 RCT_EXTERN_METHOD(setPlaybackSpeed:(double)speed);
 RCT_EXTERN_METHOD(setVolume:(double)volume);
 

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