Что заставляет AVAssetCache сообщать о невозможности воспроизведения в автономном режиме для полностью загруженного актива?

Как оказалось, это произошло из-за того, что URL-адрес, с которого я загружал аудио (например, https://mywebsite.com/path/to/master.m3u8, перенаправлялся на URL-адрес CDN (https://my.cdn/other/path/to/master.m3u8). Что-то шло не так в бухгалтерии AVAssetDownloadTask, поэтому, когда я пытался воспроизвести загруженные файлы в автономном режиме , он подумал, что ему нужно больше файлов из сети. Я зарегистрировал это как радар 43285278. Я решил эту проблему, вручную выполнив HEAD запрос к тому же URL-адресу, а затем передав AVAssetDownloadTask результирующий URL-адрес перенаправления.

Я думаю, вам нужно проверить несколько вещей, прежде чем проверять asset.assetCache.isPlayableOffline.

1. Does your KSM configured to support fairplay offline play?
   • visit Apple's FairPlay Streaming Website
   • загрузить образец SDK Fairplay (SDK FairPlay Streaming Server (4.2.0))
   • откройте HLSCatalogWithFPS – AVAssetResourceLoader или HLSCatalogWithFPS – AVContentKeySession.
   • адаптируйте свой KSM к образцу проекта, чтобы проверить, хорошо ли работает автономная игра FPS.
2. Check your key requesting process
   • since you didn't provide any of code related to key requesting process, I have no idea if you properly requested & received ckc data
   • завершение загрузки не означает, что вы приобрели ckc или постоянный ключ. Отладьте, чтобы проверить, получаете ли вы правильные данные ckc из KSM. (Возможно, вы получите сообщение об ошибке при запросе ckc с параметром постоянного ключа, если ваш KSM не настроил контент для воспроизведения в автономном режиме)

func handlePersistableContentKeyRequest(keyRequest: AVPersistableContentKeyRequest) {

        /*
         The key ID is the URI from the EXT-X-KEY tag in the playlist (e.g. "skd://key65") and the
         asset ID in this case is "key65".
         */
        guard let contentKeyIdentifierString = keyRequest.identifier as? String,
            let contentKeyIdentifierURL = URL(string: contentKeyIdentifierString),
            let assetIDString = contentKeyIdentifierURL.host,
            let assetIDData = assetIDString.data(using: .utf8)
            else {
                print("Failed to retrieve the assetID from the keyRequest!")
                return
        }

        do {

            let completionHandler = { [weak self] (spcData: Data?, error: Error?) in
                guard let strongSelf = self else { return }
                if let error = error {
                    keyRequest.processContentKeyResponseError(error)

                    strongSelf.pendingPersistableContentKeyIdentifiers.remove(assetIDString)
                    return
                }

                guard let spcData = spcData else { return }

                do {
                    // Send SPC to Key Server and obtain CKC
                    let ckcData = try strongSelf.requestContentKeyFromKeySecurityModule(spcData: spcData, assetID: assetIDString)

                    let persistentKey = try keyRequest.persistableContentKey(fromKeyVendorResponse: ckcData, options: nil)

                    try strongSelf.writePersistableContentKey(contentKey: persistentKey, withContentKeyIdentifier: assetIDString)

                    /*
                     AVContentKeyResponse is used to represent the data returned from the key server when requesting a key for
                     decrypting content.
                     */
                    let keyResponse = AVContentKeyResponse(fairPlayStreamingKeyResponseData: persistentKey)

                    /*
                     Provide the content key response to make protected content available for processing.
                     */
                    keyRequest.processContentKeyResponse(keyResponse)

                    let assetName = strongSelf.contentKeyToStreamNameMap.removeValue(forKey: assetIDString)!

                    if !strongSelf.contentKeyToStreamNameMap.values.contains(assetName) {
                        NotificationCenter.default.post(name: .DidSaveAllPersistableContentKey,
                                                        object: nil,
                                                        userInfo: ["name": assetName])
                    }

                    strongSelf.pendingPersistableContentKeyIdentifiers.remove(assetIDString)
                } catch {
                    keyRequest.processContentKeyResponseError(error)

                    strongSelf.pendingPersistableContentKeyIdentifiers.remove(assetIDString)
                }
            }

            // Check to see if we can satisfy this key request using a saved persistent key file.
            if persistableContentKeyExistsOnDisk(withContentKeyIdentifier: assetIDString) {

                let urlToPersistableKey = urlForPersistableContentKey(withContentKeyIdentifier: assetIDString)

                guard let contentKey = FileManager.default.contents(atPath: urlToPersistableKey.path) else {
                    // Error Handling.

                    pendingPersistableContentKeyIdentifiers.remove(assetIDString)

                    /*
                     Key requests should never be left dangling.
                     Attempt to create a new persistable key.
                     */
                    let applicationCertificate = try requestApplicationCertificate()
                    keyRequest.makeStreamingContentKeyRequestData(forApp: applicationCertificate,
                                                                  contentIdentifier: assetIDData,
                                                                  options: [AVContentKeyRequestProtocolVersionsKey: [1]],
                                                                  completionHandler: completionHandler)

                    return
                }

                /*
                 Create an AVContentKeyResponse from the persistent key data to use for requesting a key for
                 decrypting content.
                 */
                let keyResponse = AVContentKeyResponse(fairPlayStreamingKeyResponseData: contentKey)

                // Provide the content key response to make protected content available for processing.
                keyRequest.processContentKeyResponse(keyResponse)

                return
            }

            let applicationCertificate = try requestApplicationCertificate()

            keyRequest.makeStreamingContentKeyRequestData(forApp: applicationCertificate,
                                                          contentIdentifier: assetIDData,
                                                          options: [AVContentKeyRequestProtocolVersionsKey: [1]],
                                                          completionHandler: completionHandler)
        } catch {
            print("Failure responding to an AVPersistableContentKeyRequest when attemping to determine if key is already available for use on disk.")
        }
    }