iOS solution to realize video caching while playing

import AVFoundation

class VideoPlayerManager {
    private var player: AVPlayer?
    private var cacheURL: URL!
    private var outputStream: OutputStream?
    private var inputStream: InputStream?
    
    func startPlayback(url: URL) {
        // Create cache file path        cacheURL = ("cachedVideo.mp4")
        
        // Initialize the output stream (for writing to cache)        outputStream = OutputStream(toFileAtPath: , append: true)
        outputStream?.open()
        
        // Initialize the input stream (for reading cache)        inputStream = InputStream(url: cacheURL)!
        inputStream?.open()
        
        // Create AVPlayer and bind playback source        let asset = AVURLAsset(url: url)
        let playerItem = AVPlayerItem(asset: asset)
        player = AVPlayer(playerItem: playerItem)
        
        // Custom resource loader        let resourceLoaderDelegate = ResourceLoaderDelegate(outputStream: outputStream, inputStream: inputStream)
        (resourceLoaderDelegate, queue: .main)
        
        // Start playing        player?.play()
        
        // Start the download task        startDownloadTask(url: url)
    }
    
    private func startDownloadTask(url: URL) {
        var request = URLRequest(url: url)
         = "GET"
        
        // Set Range request header (breakpoint continuous transmission)        if let fileData = try? Data(contentsOf: cacheURL),  > 0 {
            let range = "bytes=\()-"
            (range, forHTTPHeaderField: "Range")
        }
        
        let task = (with: request) { [weak self] data, response, error in
            guard let self = self else { return }
            if let data = data {
                // Write the downloaded data to the cache file                (data: data)
            }
        }
        ()
    }
    
    private func writeDataToFile(data: Data) {
        if let outputStream = outputStream {
            let buffer = [UInt8](data)
            (buffer, maxLength: )
            ()
        }
    }
}

class ResourceLoaderDelegate: NSObject, AVAssetResourceLoaderDelegate {
    private let outputStream: OutputStream?
    private let inputStream: InputStream?
    private var cachedData: Data = Data()
    
    init(outputStream: OutputStream?, inputStream: InputStream?) {
         = outputStream
         = inputStream
    }
    
    func resourceLoader(_ resourceLoader: AVAssetResourceLoader,
                        shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
        //Read cached data in real time and return it to the player        ().async {
            var buffer = [UInt8](repeating: 0, count: 1024)
            while ?.hasBytesAvailable == true {
                let bytesRead = ?.read(&buffer, maxLength: ) ?? 0
                if bytesRead > 0 {
                    let data = Data(bytes: buffer, count: bytesRead)
                    (with: data)
                }
            }
        }
        return true
    }
    
    func resourceLoader(_ resourceLoader: AVAssetResourceLoader,
                        didCancel loadingRequest: AVAssetResourceLoadingRequest) {
        // Process the cancel request        ()
    }
}

import KTVHTTPCache

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

func preloadVideos(urls: [URL]) {
    let queue = OperationQueue()
     = 3
    
    for url in urls {
         {
            let proxyURLString = (withOriginalURLString: )
            let proxyURL = URL(string: proxyURLString)!
            let request = URLRequest(url: proxyURL)
            let task = (with: request) { _, _, _ in }
            ()
        }
    }
}