avfoundation - 是什么导致 AVAssetCache 报告完全下载的资产无法离线播放？

Question

我正在开发一个 iOS 应用程序，它通过 HLS 播放 FairPlay 加密的音频，并支持下载和流式传输。而且在飞行模式下我无法播放下载的内容。AVURLAsset如果我在下载完成时从本地 URL创建一个，asset.assetCache.isPlayableOffline返回NO，当我尝试以飞行模式播放时，它仍然会尝试请求 .m3u8 播放列表文件之一。

我的主播放列表如下所示：

#EXTM3U
# Created with Bento4 mp4-hls.py version 1.1.0r623

#EXT-X-VERSION:5
#EXT-X-SESSION-KEY:METHOD=SAMPLE-AES,URI="skd://url/to/key?KID=foobar",KEYFORMAT="com.apple.streamingkeydelivery",KEYFORMATVERSIONS="1"


# Media Playlists
#EXT-X-STREAM-INF:AVERAGE-BANDWIDTH=133781,BANDWIDTH=134685,CODECS="mp4a.40.2" media-1/stream.m3u8
#EXT-X-STREAM-INF:AVERAGE-BANDWIDTH=67526,BANDWIDTH=67854,CODECS="mp4a.40.2" media-2/stream.m3u8

流播放列表如下所示：

#EXTM3U
#EXT-X-VERSION:5
#EXT-X-PLAYLIST-TYPE:VOD
#EXT-X-TARGETDURATION:30
#EXT-X-MEDIA-SEQUENCE:0
#EXT-X-KEY:METHOD=SAMPLE-AES,URI="skd://url/to/key?KID=foobar",KEYFORMAT="com.apple.streamingkeydelivery",KEYFORMATVERSIONS="1"
#EXTINF:30.000181,
#EXT-X-BYTERANGE:470290@0
media.aac
# more segments...
#EXT-X-ENDLIST

下载资产：

AVURLAsset *asset = [AVURLAsset assetWithURL:myM3u8Url];
[asset.resourceLoader setDelegate:[FairPlayKeyManager instance] queue:[FairPlayKeyManager queue]];
asset.resourceLoader.preloadsEligibleContentKeys = YES;
AVAssetDownloadTask *task = [self.session assetDownloadTaskWithURLAsset:asset assetTitle:@"Track" assetArtworkData:imgData options:nil];
[task resume];

在代表的URLSession:assetDownloadTask:didFinishDownloadingToURL:：

self.downloadedPath = location.relativePath;

在代表的URLSession:task:didCompleteWithError:：

if (!error)
{
  NSString *strUrl = [NSHomeDirectory() stringByAppendingPathComponent:self.downloadedPath];
  NSURL *url = [NSURL fileURLWithPath:strUrl];
  AVURLAsset *localAsset = [AVURLAsset assetWithURL:url];
  if (!localAsset.assetCache.playableOffline)
    NSLog(@"Oh no!"); //not playable offline
}

除了资产缓存报告无法离线播放外，下载不会出错。但是，如果您切换到飞行模式并尝试播放下载的资产，它会正确地向资源加载器委托请求一个密钥（我使用的是持久密钥，因此离线工作正常），然后尝试发出请求media-1/stream.m3u8.

有什么我没有在这里处理的问题吗？播放列表文件应该以某种方式有所不同吗？我缺少的任务或资产是否有一些财产？

Answer 1

事实证明，这是因为我从中下载音频的 URL（例如，https://mywebsite.com/path/to/master.m3u8重定向到 CDN url https://my.cdn/other/path/to/master.m3u8(AVAssetDownloadTask它需要来自网络的更多文件。我已将其归档为雷达 43285278。我通过手动HEAD向同一 URL 发出请求来解决此问题，然后给出AVAssetDownloadTask生成的重定向 URL。

Answer 2

我认为您在检查之前几乎没有什么要检查的asset.assetCache.isPlayableOffline。

1. 您的 KSM 是否配置为支持 fairplay 离线播放？
   • 访问Apple 的 FairPlay 流媒体网站
   • 下载 fairplay 示例 SDK (FairPlay Streaming Server SDK (4.2.0))
   • 打开HLSCatalogWithFPS - AVAssetResourceLoader或HLSDatalogWithFPS - AVContentKeySession
   • 使您的 KSM 适应示例项目以检查 FPS 离线播放是否正常
2. 检查您的密钥请求过程
   • 由于您没有提供任何与密钥请求过程相关的代码，我不知道您是否正确请求并收到了 ckc 数据
   • 完成下载并不意味着您已获得 ckc 或持久密钥。调试以检查您是否从 KSM 获得正确的 ckc 数据。（如果您的 KSM 未将内容配置为可离线播放，则在使用持久密钥选项请求 ckc 时您可能会遇到错误）

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.")
        }
    }