iOS实现视频边播放边缓存的解决方案

import AVFoundation

class VideoPlayerManager {
    private var player: AVPlayer?
    private var cacheURL: URL!
    private var outputStream: OutputStream?
    private var inputStream: InputStream?
    
    func startPlayback(url: URL) {
        // 创建缓存文件路径
        cacheURL = FileManager.default.temporaryDirectory.appendingPathComponent("cachedVideo.mp4")
        
        // 初始化输出流（用于写入缓存）
        outputStream = OutputStream(toFileAtPath: cacheURL.path, append: true)
        outputStream?.open()
        
        // 初始化输入流（用于读取缓存）
        inputStream = InputStream(url: cacheURL)!
        inputStream?.open()
        
        // 创建 AVPlayer 并绑定播放源
        let asset = AVURLAsset(url: url)
        let playerItem = AVPlayerItem(asset: asset)
        player = AVPlayer(playerItem: playerItem)
        
        // 自定义资源加载器
        let resourceLoaderDelegate = ResourceLoaderDelegate(outputStream: outputStream, inputStream: inputStream)
        asset.resourceLoader.setDelegate(resourceLoaderDelegate, queue: .main)
        
        // 开始播放
        player?.play()
        
        // 启动下载任务
        startDownloadTask(url: url)
    }
    
    private func startDownloadTask(url: URL) {
        var request = URLRequest(url: url)
        request.httpMethod = "GET"
        
        // 设置 Range 请求头（断点续传）
        if let fileData = try? Data(contentsOf: cacheURL), fileData.count > 0 {
            let range = "bytes=\(fileData.count)-"
            request.setValue(range, forHTTPHeaderField: "Range")
        }
        
        let task = URLSession.shared.dataTask(with: request) { [weak self] data, response, error in
            guard let self = self else { return }
            if let data = data {
                // 将下载的数据写入缓存文件
                self.writeDataToFile(data: data)
            }
        }
        task.resume()
    }
    
    private func writeDataToFile(data: Data) {
        if let outputStream = outputStream {
            let buffer = [UInt8](data)
            outputStream.write(buffer, maxLength: buffer.count)
            outputStream.flush()
        }
    }
}

class ResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate {
    private let outputStream: OutputStream?
    private let inputStream: InputStream?
    private var cachedData: Data = Data()
    
    init(outputStream: OutputStream?, inputStream: InputStream?) {
        self.outputStream = outputStream
        self.inputStream = inputStream
    }
    
    func resourceLoader(_ resourceLoader: AVAssetResourceLoader,
                        shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
        // 实时读取缓存数据并返回给播放器
        DispatchQueue.global().async {
            var buffer = [UInt8](repeating: 0, count: 1024)
            while self.inputStream?.hasBytesAvailable == true {
                let bytesRead = self.inputStream?.read(&buffer, maxLength: buffer.count) ?? 0
                if bytesRead > 0 {
                    let data = Data(bytes: buffer, count: bytesRead)
                    loadingRequest.dataRequest.respond(with: data)
                }
            }
        }
        return true
    }
    
    func resourceLoader(_ resourceLoader: AVAssetResourceLoader,
                        didCancel loadingRequest: AVAssetResourceLoadingRequest) {
        // 处理取消请求
        loadingRequest.dataRequest.finishLoading()
    }
}

import KTVHTTPCache

class VideoCacheManager {
    func initCache() {
        do {
            try KTVHTTPCache.proxyStart()
            let maxLength: Int64 = 300 * 1024 * 1024 // 300MB
            KTVHTTPCache.cacheSetMaxCacheLength(maxLength)
        } catch {
            print("Proxy Start Failure: $error)")
        }
    }
    
    func playVideo(url: URL) {
        let proxyURLString = KTVHTTPCache.proxyURLString(withOriginalURLString: url.absoluteString)
        let proxyURL = URL(string: proxyURLString)!
        let player = AVPlayer(url: proxyURL)
        player.play()
    }
}

func preloadVideos(urls: [URL]) {
    let queue = OperationQueue()
    queue.maxConcurrentOperationCount = 3
    
    for url in urls {
        queue.addOperation {
            let proxyURLString = KTVHTTPCache.proxyURLString(withOriginalURLString: url.absoluteString)
            let proxyURL = URL(string: proxyURLString)!
            let request = URLRequest(url: proxyURL)
            let task = URLSession.shared.dataTask(with: request) { _, _, _ in }
            task.resume()
        }
    }
}