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

package/ios/player/Preloader.swift

@@ -5,110 +5,41 @@
 
 import Foundation
 
-final class Preloader: NSObject, URLSessionDataDelegate {
-
+final class Preloader {
+  private let coordinator: DownloadCoordinator
   private let cache: AudioCache
-  private lazy var session: URLSession = {
-    let config = URLSessionConfiguration.default
-    config.networkServiceType = .background
-    let queue = OperationQueue()
-    queue.maxConcurrentOperationCount = 1
-    return URLSession(configuration: config, delegate: self, delegateQueue: queue)
-  }()
-
-  private var activeKey: String?
-  private var activeTask: URLSessionDataTask?
-  private var needsContentInfo: Bool = false
+  private var activeTokens: [String: DownloadToken] = [:]
 
-  init(cache: AudioCache) {
+  init(cache: AudioCache, coordinator: DownloadCoordinator) {
     self.cache = cache
+    self.coordinator = coordinator
   }
 
-  // MARK: - Public
-
-  /// Begin preloading the given URL. Cancels any in-flight preload.
-  func preload(url: URL, headers: [String: String]?) {
+  /// Preload a URL. If maxBytes is nil, downloads the entire file.
+  func preload(url: URL, headers: [String: String]?, maxBytes: Int64? = nil) {
     let key = cache.cacheKey(for: url)
-
     if cache.isFullyCached(key: key) { return }
-    if key == activeKey { return }
-
-    cancel()
-    activeKey = key
+    if activeTokens[key] != nil { return }
 
-    var request = URLRequest(url: url)
-    headers?.forEach { request.setValue($0.value, forHTTPHeaderField: $0.key) }
-
-    let cached = cache.cachedBytes(for: key)
-    if cached > 0 {
-      request.setValue("bytes=\(cached)-", forHTTPHeaderField: "Range")
-      needsContentInfo = false
-    } else {
-      needsContentInfo = (cache.contentInfo(for: key) == nil)
+    let token = coordinator.download(url: url, headers: headers, cacheKey: key, maxBytes: maxBytes) { [weak self] _ in
+      self?.activeTokens.removeValue(forKey: key)
     }
-
-    activeTask = session.dataTask(with: request)
-    activeTask?.resume()
+    activeTokens[key] = token
   }
 
-  func cancel() {
-    activeTask?.cancel()
-    activeTask = nil
-    activeKey = nil
-  }
-
-  // MARK: - URLSessionDataDelegate
-
-  func urlSession(
-    _ session: URLSession,
-    dataTask: URLSessionDataTask,
-    didReceive response: URLResponse,
-    completionHandler: @escaping (URLSession.ResponseDisposition) -> Void
-  ) {
-    guard let key = activeKey else {
-      completionHandler(.cancel)
-      return
-    }
-
-    if needsContentInfo, 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: key, url: dataTask.originalRequest?.url ?? URL(fileURLWithPath: "/"))
-      needsContentInfo = false
+  /// Cancel preload for a specific URL.
+  func cancel(url: URL) {
+    let key = cache.cacheKey(for: url)
+    if let token = activeTokens.removeValue(forKey: key) {
+      coordinator.cancelDownload(token: token)
     }
-
-    completionHandler(.allow)
-  }
-
-  func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
-    guard let key = activeKey else { return }
-    cache.appendData(data, for: key)
   }
 
-  func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
-    guard let key = activeKey else { return }
-
-    if error == nil {
-      cache.touchAccessDate(for: key)
-      cache.evictIfNeeded()
+  /// Cancel all active preloads.
+  func cancelAll() {
+    for token in activeTokens.values {
+      coordinator.cancelDownload(token: token)
     }
-
-    activeTask = nil
-    activeKey = nil
+    activeTokens.removeAll()
   }
 }

package/ios/player/SleepTimerController.swift

@@ -0,0 +1,147 @@
+//
+// Copyright (c) Double Symmetry GmbH
+// Commercial use requires a license. See https://rntp.dev/pricing
+//
+
+import Foundation
+
+/// Protocol for the minimal player interface the sleep timer needs.
+protocol SleepTimerPlayer: AnyObject {
+    var volume: Float { get set }
+    var currentIndex: Int { get }
+    func pause()
+}
+
+/// Makes AudioPlayer usable as a SleepTimerPlayer.
+extension AudioPlayer: SleepTimerPlayer {}
+
+class SleepTimerController {
+
+    /// Called when the sleep timer fires (pauses playback).
+    var onTriggered: ((_ type: String) -> Void)?
+
+    private weak var player: SleepTimerPlayer?
+
+    private(set) var sleepTimerType: String?
+    private(set) var sleepTimerRemainingSeconds: Double = 0
+    private(set) var sleepTimerFadeOutSeconds: Double = 0
+    private(set) var sleepTimerTargetIndex: Int?
+    private(set) var sleepTimerPreviousIndex: Int?
+    private var sleepTimer: Timer?
+    private var sleepTimerPreFadeVolume: Float?
+
+    init(player: SleepTimerPlayer) {
+        self.player = player
+    }
+
+    // MARK: - Public API
+
+    func sleepAfterTime(seconds: Double, fadeOutSeconds: Double) {
+        cancelInternal(restoreVolume: true)
+        sleepTimerType = "time"
+        sleepTimerRemainingSeconds = seconds
+        sleepTimerFadeOutSeconds = min(fadeOutSeconds, seconds)
+
+        if seconds <= 0 {
+            player?.pause()
+            onTriggered?("time")
+            cancelInternal(restoreVolume: true)
+            return
+        }
+
+        startCountdownTimer()
+    }
+
+    func sleepAfterMediaItemAtIndex(index: Int) {
+        cancelInternal(restoreVolume: true)
+        sleepTimerType = "mediaItem"
+        sleepTimerTargetIndex = index
+        sleepTimerPreviousIndex = player?.currentIndex
+    }
+
+    func cancel() {
+        cancelInternal(restoreVolume: true)
+    }
+
+    func getState() -> [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
+            ]
+        }
+    }
+
+    /// Call this when the current media item changes.
+    /// Returns true if the timer fired.
+    func handleItemTransition(to index: Int) -> Bool {
+        if sleepTimerType == "mediaItem", let targetIndex = sleepTimerTargetIndex {
+            if sleepTimerPreviousIndex == targetIndex && index != targetIndex {
+                onTriggered?("mediaItem")
+                cancelInternal(restoreVolume: false)
+                sleepTimerPreviousIndex = index
+                return true
+            }
+        }
+        sleepTimerPreviousIndex = index
+        return false
+    }
+
+    /// Call this manually in tests to simulate a tick. In production, the Timer calls this.
+    func tick() {
+        onSleepTimerTick()
+    }
+
+    // MARK: - Internal
+
+    func cancelInternal(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() {
+        guard sleepTimerType == "time" else { return }
+        sleepTimerRemainingSeconds -= 1
+
+        if sleepTimerFadeOutSeconds > 0 && sleepTimerRemainingSeconds < sleepTimerFadeOutSeconds {
+            if sleepTimerPreFadeVolume == nil {
+                sleepTimerPreFadeVolume = player?.volume ?? 1.0
+            }
+            let progress = max(0, sleepTimerRemainingSeconds) / sleepTimerFadeOutSeconds
+            player?.volume = (sleepTimerPreFadeVolume ?? 1.0) * Float(progress)
+        }
+
+        if sleepTimerRemainingSeconds <= 0 {
+            sleepTimerRemainingSeconds = 0
+            player?.pause()
+            onTriggered?("time")
+            cancelInternal(restoreVolume: true)
+            return
+        }
+    }
+
+    private func startCountdownTimer() {
+        sleepTimer?.invalidate()
+        let timer = Timer(timeInterval: 1.0, repeats: true) { [weak self] _ in
+            self?.onSleepTimerTick()
+        }
+        RunLoop.main.add(timer, forMode: .common)
+        sleepTimer = timer
+    }
+}

package/ios/tests/AVPlayerEngineIntegrationTests.swift

@@ -39,6 +39,82 @@ final class AVPlayerEngineIntegrationTests: XCTestCase {
     return url
   }
 
+  /// Creates ADTS AAC data — a streamable format that AVPlayer can play
+  /// without a Content-Length header.
+  private func createADTSAACData(duration: Double) -> Data? {
+    let sampleRate: Double = 44100
+    let frameCount = AVAudioFrameCount(sampleRate * duration)
+
+    let pcmFormat = AVAudioFormat(standardFormatWithSampleRate: sampleRate, channels: 1)!
+    let silentBuffer = AVAudioPCMBuffer(pcmFormat: pcmFormat, frameCapacity: frameCount)!
+    silentBuffer.frameLength = frameCount
+
+    guard let aacFormat = AVAudioFormat(
+      commonFormat: .pcmFormatFloat32,
+      sampleRate: sampleRate,
+      channels: 1,
+      interleaved: false
+    ) else { return nil }
+
+    var classDesc = AudioClassDescription(
+      mType: kAudioEncoderComponentType,
+      mSubType: kAudioFormatMPEG4AAC,
+      mManufacturer: kAppleSoftwareAudioCodecManufacturer
+    )
+    var outputASBD = AudioStreamBasicDescription(
+      mSampleRate: sampleRate,
+      mFormatID: kAudioFormatMPEG4AAC,
+      mFormatFlags: 0,
+      mBytesPerPacket: 0,
+      mFramesPerPacket: 1024,
+      mBytesPerFrame: 0,
+      mChannelsPerFrame: 1,
+      mBitsPerChannel: 0,
+      mReserved: 0
+    )
+    guard let aacOutputFormat = AVAudioFormat(streamDescription: &outputASBD) else { return nil }
+    guard let converter = AVAudioConverter(from: pcmFormat, to: aacOutputFormat) else { return nil }
+
+    var aacData = Data()
+    let outputBuffer = AVAudioCompressedBuffer(format: aacOutputFormat, packetCapacity: 1, maximumPacketSize: 768)
+
+    var inputConsumed = false
+    let inputBlock: AVAudioConverterInputBlock = { _, outStatus in
+      if inputConsumed {
+        outStatus.pointee = .endOfStream
+        return nil
+      }
+      inputConsumed = true
+      outStatus.pointee = .haveData
+      return silentBuffer
+    }
+
+    while true {
+      outputBuffer.packetCount = 0
+      outputBuffer.byteLength = 0
+      var error: NSError?
+      let status = converter.convert(to: outputBuffer, error: &error, withInputFrom: inputBlock)
+      if outputBuffer.byteLength > 0 {
+        // Wrap each AAC packet in an ADTS header
+        let packetSize = Int(outputBuffer.byteLength)
+        let frameLength = packetSize + 7
+        var adtsHeader = Data(count: 7)
+        adtsHeader[0] = 0xFF
+        adtsHeader[1] = 0xF1 // MPEG-4, Layer 0, no CRC
+        adtsHeader[2] = 0x50 // AAC-LC, 44100Hz, mono (upper bits)
+        adtsHeader[3] = UInt8(0x80) | UInt8((frameLength >> 11) & 0x03)
+        adtsHeader[4] = UInt8((frameLength >> 3) & 0xFF)
+        adtsHeader[5] = UInt8(((frameLength & 0x07) << 5) | 0x1F)
+        adtsHeader[6] = 0xFC
+        aacData.append(adtsHeader)
+        aacData.append(Data(bytes: outputBuffer.data, count: packetSize))
+      }
+      if status == .endOfStream || status == .error { break }
+    }
+
+    return aacData.isEmpty ? nil : aacData
+  }
+
   private func loadAndWaitForReady() {
     let ready = expectation(description: "item ready")
     ready.assertForOverFulfill = false
@@ -201,4 +277,158 @@ final class AVPlayerEngineIntegrationTests: XCTestCase {
 
     XCTAssertTrue(receivedStates.contains(.playing), "should have received .playing")
   }
+
+  // MARK: - Caching Without Content-Length
+
+  func testCachedPlaybackCompletesWithContentLength() throws {
+    let cache = AudioCache(maxSizeBytes: 10 * 1024 * 1024, directory: cacheDir)
+    let cachedEngine = AVPlayerEngine(cache: cache)
+    defer { cachedEngine.reset() }
+
+    // Use ADTS AAC — a streamable format that the HTTP proxy can serve
+    // progressively. WAV requires byte-range access which is not available
+    // until the full file is cached.
+    guard let audioData = createADTSAACData(duration: 1.0) else {
+      throw XCTSkip("Could not create ADTS AAC test data")
+    }
+    let server = try LocalAudioServer(
+      audioData: audioData,
+      options: .init(includeContentLength: true, contentType: "audio/aac")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let ready = expectation(description: "ready")
+    ready.assertForOverFulfill = false
+    cachedEngine.onItemReady = { ready.fulfill() }
+
+    let failed = expectation(description: "should not fail")
+    failed.isInverted = true
+    cachedEngine.onItemFailed = { _, _ in failed.fulfill() }
+
+    cachedEngine.load(url: server.url)
+    wait(for: [ready], timeout: 10.0)
+
+    let ended = expectation(description: "ended")
+    cachedEngine.onItemPlayedToEnd = { ended.fulfill() }
+    cachedEngine.play()
+    wait(for: [ended, failed], timeout: 10.0)
+  }
+
+  func testCachedPlaybackCompletesWithoutContentLength() throws {
+    // Use ADTS AAC — a streamable format that AVPlayer can handle without
+    // Content-Length (unlike WAV/M4A which require it).
+    guard let audioData = createADTSAACData(duration: 1.0) else {
+      throw XCTSkip("Could not create ADTS AAC test data")
+    }
+
+    let cache = AudioCache(maxSizeBytes: 10 * 1024 * 1024, directory: cacheDir)
+    let cachedEngine = AVPlayerEngine(cache: cache)
+    defer { cachedEngine.reset() }
+    let server = try LocalAudioServer(
+      audioData: audioData,
+      options: .init(includeContentLength: false, contentType: "audio/aac")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let ready = expectation(description: "ready")
+    ready.assertForOverFulfill = false
+    cachedEngine.onItemReady = { ready.fulfill() }
+
+    let failed = expectation(description: "should not fail")
+    failed.isInverted = true
+    cachedEngine.onItemFailed = { _, _ in failed.fulfill() }
+
+    cachedEngine.load(url: server.url)
+    wait(for: [ready], timeout: 10.0)
+
+    let ended = expectation(description: "ended")
+    cachedEngine.onItemPlayedToEnd = { ended.fulfill() }
+    cachedEngine.play()
+    wait(for: [ended, failed], timeout: 10.0)
+  }
+
+  // MARK: - Cache Hit Playback
+
+  func testPlaybackFromCacheHit() throws {
+    let cache = AudioCache(maxSizeBytes: 10 * 1024 * 1024, directory: cacheDir)
+    let cachedEngine = AVPlayerEngine(cache: cache)
+    defer { cachedEngine.reset() }
+
+    // Use ADTS AAC — streamable format
+    guard let audioData = createADTSAACData(duration: 1.0) else {
+      throw XCTSkip("Could not create ADTS AAC test data")
+    }
+    let server = try LocalAudioServer(
+      audioData: audioData,
+      options: .init(includeContentLength: true, contentType: "audio/aac")
+    )
+    server.start()
+
+    // First play — downloads and caches through the proxy.
+    let ready1 = expectation(description: "first play ready")
+    ready1.assertForOverFulfill = false
+    cachedEngine.onItemReady = { ready1.fulfill() }
+    cachedEngine.load(url: server.url)
+    wait(for: [ready1], timeout: 10.0)
+
+    let ended1 = expectation(description: "first play ended")
+    cachedEngine.onItemPlayedToEnd = { ended1.fulfill() }
+    cachedEngine.play()
+    wait(for: [ended1], timeout: 10.0)
+
+    // Stop the server — second play must come from cache.
+    server.stop()
+
+    let ready2 = expectation(description: "cache hit ready")
+    ready2.assertForOverFulfill = false
+    cachedEngine.onItemReady = { ready2.fulfill() }
+    cachedEngine.load(url: server.url)
+    wait(for: [ready2], timeout: 10.0)
+
+    let ended2 = expectation(description: "cache hit ended")
+    cachedEngine.onItemPlayedToEnd = { ended2.fulfill() }
+    cachedEngine.play()
+    wait(for: [ended2], timeout: 10.0)
+  }
+
+  // MARK: - Skip Mid-Download Preserves Partial Cache
+
+  func testSkipMidDownloadPreservesPartialCache() throws {
+    let cache = AudioCache(maxSizeBytes: 10 * 1024 * 1024, directory: cacheDir)
+    let cachedEngine = AVPlayerEngine(cache: cache)
+    defer { cachedEngine.reset() }
+
+    guard let aacData = createADTSAACData(duration: 5.0) else {
+      throw XCTSkip("Could not create AAC test data")
+    }
+    let server = try LocalAudioServer(
+      audioData: aacData,
+      options: .init(includeContentLength: true, contentType: "audio/aac")
+    )
+    server.start()
+    defer { server.stop() }
+
+    let ready = expectation(description: "ready")
+    ready.assertForOverFulfill = false
+    cachedEngine.onItemReady = { ready.fulfill() }
+    cachedEngine.load(url: server.url)
+    wait(for: [ready], timeout: 10.0)
+
+    // Reset (simulates skipping to next track).
+    cachedEngine.reset()
+
+    // Check that some data was cached (partial).
+    let key = cache.cacheKey(for: server.url)
+    let cachedBytes = cache.cachedBytes(for: key)
+    XCTAssertGreaterThan(cachedBytes, 0, "Some data should be cached after partial play")
+  }
+
+  // MARK: - Helpers
+
+  private lazy var cacheDir: URL = {
+    FileManager.default.temporaryDirectory
+      .appendingPathComponent("CacheTests-\(UUID().uuidString)", isDirectory: true)
+  }()
 }

package/ios/tests/AudioPlayerTests.swift

@@ -20,6 +20,12 @@ private struct MockItem: AudioItem {
     self.sourceUrl = "https://example.com/\(id).mp3"
     self.title = id
   }
+
+  #if canImport(UIKit)
+  func getArtwork(_ handler: @escaping (UIImage?) -> Void) {
+    handler(nil)
+  }
+  #endif
 }
 
 private func item(_ id: String) -> MockItem { MockItem(id) }