Preload and precache videos

1
private let preloadManager = PreloadManager.shared
2
private let precacheManager = PrecacheManager.shared
3
4
override func viewDidLoad() {
5
    super.viewDidLoad()
6
    playerViewController.addPlaylist(playlist)
7
8
    // Assign delegates to receive status callbacks
9
    preloadManager.delegate = self
10
    precacheManager.delegate = self
11
12
    // Start preloading and precaching after the playlist is ready
13
    preloadNextVideos()
14
    precacheUpcomingVideos()
15
}

1
private func preloadNextVideos() {
2
    let currentIndex = playerViewController.currentPlaylistIndex
3
    let currentId = currentIndex < playlist.count ? playlist[currentIndex].playbackId : ""
4
    let upcoming = playlist
5
        .enumerated()
6
        .filter { $0.offset > currentIndex }
7
        .prefix(2)
8
        .map { $0.element }
9
        .filter {
10
            // Skip if already loading, ready, or currently playing
11
            let status = preloadManager.preloadStatus(forVideo: $0.playbackId)
12
            switch status {
13
            case .idle: return $0.playbackId != currentId
14
            default:    return false
15
            }
16
        }
17
18
    let itemsToPreload: [(id: String, item: AVPlayerItem)] = upcoming.compactMap { playlistItem -> (id: String, item: AVPlayerItem)? in
19
        guard let url = buildPlaybackURL(for: playlistItem) else { return nil }
20
        let playerItem = AVPlayerItem(url: url)
21
        return (id: playlistItem.playbackId, item: playerItem)
22
    }
23
24
    guard !itemsToPreload.isEmpty else { return }
25
    preloadManager.preload(items: itemsToPreload)
26
}

1
private func precacheUpcomingVideos() {
2
    let currentIndex = playerViewController.currentPlaylistIndex
3
    let upcoming = playlist
4
        .enumerated()
5
        .filter { $0.offset >= currentIndex }
6
        .prefix(2)
7
        .map { $0.element }
8
9
    for item in upcoming {
10
        // Skip DRM-protected content. Encrypted segments cannot be cached.
11
        guard item.drmToken.isEmpty else { continue }
12
13
        let host = item.customDomain.isEmpty == false
14
            ? item.customDomain
15
            : "stream.fastpix.io"
16
        var urlString = "https://\(host)/\(item.playbackId).m3u8"
17
        if !item.token.isEmpty {
18
            urlString += "?token=\(item.token)"
19
        }
20
21
        guard let url = URL(string: urlString) else { continue }
22
        precacheManager.startPrecaching(url: url)
23
    }
24
}

1
let nextIndex = playerViewController.currentPlaylistIndex + 1
2
if nextIndex < playlist.count {
3
    let nextId = playlist[nextIndex].playbackId
4
    if preloadManager.consumePreloadedItem(for: nextId) != nil {
5
        print("Preloaded item consumed. AVFoundation cache warm for: \(nextId)")
6
    }
7
}
8
_ = playerViewController.next()

1
@objc private func playlistStateChanged(_ notification: Notification) {
2
    DispatchQueue.main.async {
3
        // ... your existing reset logic ...
4
        self.preloadNextVideos()
5
        self.precacheUpcomingVideos()
6
    }
7
}

1
deinit {
2
    preloadManager.clearAll()
3
    precacheManager.stopAllPrecaching()
4
}

1
extension VideoPlayerViewController: PreloadManagerDelegate {
2
    // Called when preloading begins for a video
3
    func videoPreloadDidStart(forId id: String) {
4
        print("Preload started for: \(id)")
5
    }
6
7
    // Called when the preloaded AVPlayerItem is buffered and ready
8
    func videoPreloadDidBecomeReady(forId id: String) {
9
        print("Preload ready. Instant playback available for: \(id)")
10
    }
11
12
    // Called when preloading fails
13
    func videoPreloadDidFail(forId id: String, error: Error?) {
14
        print("Preload failed for \(id): \(error?.localizedDescription ?? "unknown error")")
15
    }
16
17
    // Called when a preload task is cancelled
18
    func videoPreloadDidCancel(forId id: String) {
19
        print("Preload cancelled for: \(id)")
20
    }
21
22
    // Called when the SDK auto-advances and consumes the preloaded buffer
23
    func videoPreloadDidAutoAdvance(toId id: String) {
24
        print("Auto-advance consumed preloaded item: \(id)")
25
    }
26
}

1
extension VideoPlayerViewController: PrecacheManagerDelegate {
2
    // Called when a request is served from the local disk cache
3
    func videoCacheDidHit(url: URL) {
4
        print("Cache HIT. Served from disk: \(url.lastPathComponent)")
5
    }
6
7
    // Called when a request is not in the cache and is being downloaded
8
    func videoCacheDidMiss(url: URL) {
9
        print("Cache MISS. Downloading and caching: \(url.lastPathComponent)")
10
    }
11
}