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

package/src/interfaces/BrowseTree.ts

@@ -3,17 +3,52 @@
  * Commercial use requires a license. See https://rntp.dev/pricing
  */
 
-import type { MediaItem } from './MediaItem';
+import type { MediaUrl } from './MediaItem';
 
 /**
- * A category in the media browse tree shown in Android Auto / media browsers.
- * Each category appears as a top-level tab/section; its items are playable leaves.
+ * An item in the browse tree — either a playable track or a browsable container.
+ *
+ * - `url` present → playable track (leaf node)
+ * - `children` present (no `url`) → browsable container (tapping drills down)
+ * - `url` takes precedence if both are present
+ *
+ * Maximum nesting depth: 4 levels (matching CarPlay's navigation stack limit).
+ */
+export interface BrowseItem {
+  /** Unique identifier for this item. */
+  mediaId: string;
+  /** Display title. */
+  title: string;
+  /** Artist or subtitle. */
+  artist?: string;
+  /** Artwork image URL. */
+  artworkUrl?: MediaUrl;
+
+  // Playable fields
+  /** Audio source URL. If present, this item is playable. */
+  url?: MediaUrl;
+  /** Duration hint in seconds. */
+  duration?: number;
+  /** Whether this is a live stream. */
+  isLive?: boolean;
+  /** MIME type hint for format detection. */
+  mimeType?: string;
+
+  // Browsable fields
+  /** Child items. If present (and no `url`), this item is browsable. */
+  children?: BrowseItem[];
+}
+
+/**
+ * A top-level category in the browse tree.
+ * On Android Auto, each category is a browsable folder.
+ * On CarPlay, each category is a tab (max 4; overflow creates a "More" tab).
  */
 export interface BrowseCategory {
   /** Unique identifier for this category. */
   mediaId: string;
   /** Display title for the category (e.g. "Albums", "Podcasts"). */
   title: string;
-  /** Playable media items within this category. */
-  items: MediaItem[];
+  /** Items within this category — can be playable tracks or browsable containers. */
+  items: BrowseItem[];
 }

package/src/interfaces/MediaItem.ts

@@ -34,7 +34,10 @@ export interface MediaItem {
    */
   duration?: number;
   /**
-   * Whether this is a live stream (affects seek behavior).
+   * Whether this is a live stream.
+   *
+   * When `true`, caching and preloading are disabled and the stream is
+   * played directly.
    */
   isLive?: boolean;
   /**

package/src/interfaces/PlayerConfig.ts

@@ -9,17 +9,36 @@ import type {
   PerCommandHandling,
 } from './PlayerCommand';
 
+export interface PreloadConfig {
+  /**
+   * Auto-preload next N tracks in queue after current track is fully cached.
+   * @default 0 (disabled)
+   */
+  window?: number;
+}
+
+export interface PreloadOptions {
+  /**
+   * Target duration in seconds. If omitted, preloads the entire file.
+   */
+  duration?: number;
+}
+
 export interface CacheConfig {
   /**
    * Maximum disk cache size in bytes.
    * When the cache exceeds this size, least-recently-used items are evicted.
-   * @default 104857600 (100 MB)
+   * @default 524288000 (500 MB)
    */
   maxSizeBytes?: number;
+  /**
+   * Preloading configuration. Requires cache to be enabled.
+   */
+  preloading?: PreloadConfig;
 }
 
-export const DEFAULT_CACHE_CONFIG: Required<CacheConfig> = {
-  maxSizeBytes: 100 * 1024 * 1024,
+export const DEFAULT_CACHE_CONFIG: Required<Omit<CacheConfig, 'preloading'>> = {
+  maxSizeBytes: 500 * 1024 * 1024,
 };
 
 /**

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()
-    }
-  }
-}