前言

• 本文主要介绍基于AVPlayer实现边下边播边存处理，核心其实就是基于AVPlayer的AVAssetResourceLoaderDelegate然后对FILE文件实现边下边播方案，

AVPlayer的基本知识

单纯使用AVPlayer类是无法显示视频的，要将视频层添加至AVPlayerLayer中，这样才能将视频显示出来，简单总结播放视频就是这三者的使用，AVPlayer、AVPlayerLayer、AVPlayerItem

• AVPlayer：负责控制播放器的播放，暂停，播放速度等
• AVPlayerLayer：负责管理资源对象，提供播放数据源
• AVPlayerItem：负责显示视频，如果没有添加该类，只有声音没有画面

简单理解，你可以把这三者理解为我们常用的MVC，AVPlayer就对应C，AVPlayerLayer对应V，AVPlayerItem对应M

关于这些的介绍使用，我就不介绍了，网上资料一大堆。本文主要介绍边下边播边存方案

AVPlayer详解系列（一）参数设置

边下边播方案

再介绍之前，我们再来了解AVPlayer的一个类AVAsset，该类主要用于获取多媒体信息，再接着往下了解，AVURLAsset该类是AVAsset的子类，主要可以根据URL路径创建包含媒体信息的AVURLAsset对象，AVURLAsset通过委托AVAssetResourceLoader去加载所需文件，同时可以进行数据的缓存和读取操作，这样就实现边下边播边存的功能。

大致流程图，

流程图

初始化AVURLAsset

// 判断是否含有视频轨道
NS_INLINE BOOL kPlayerHaveTracks(NSURL *videoURL, void(^assetblock)(AVURLAsset *), NSDictionary *requestHeader){
    if (videoURL == nil) return NO;
    AVURLAsset *asset = [AVURLAsset URLAssetWithURL:videoURL options:requestHeader];
    if (assetblock) assetblock(asset);
    NSArray *tracks = [asset tracksWithMediaType:AVMediaTypeVideo];
    return [tracks count] > 0;
}

这里我们就得到AVURLAsset，接下来就是设置委托引出主人公AVAssetResourceLoaderDelegate，这个就是我们实现边下边播的中间桥梁

NSURL * URL = weakself.connection.kj_createSchemeURL(tempURL);
weakself.asset = [AVURLAsset URLAssetWithURL:URL options:weakself.requestHeader];
[weakself.asset.resourceLoader setDelegate:weakself.connection queue:dispatch_get_main_queue()];

AVAssetResourceLoaderDelegate实现

下面先来介绍AVAssetResourceLoaderDelegate的委托方法，

/*  连接视频播放和视频断点下载的桥梁
 *  必须返回Yes，如果返回NO，则resourceLoader将会加载出现故障的数据
 *  这里会出现很多个loadingRequest请求,需要为每一次请求作出处理
 *  该接口会被调用多次，请求不同片段的视频数据，应当保存这些请求，在请求的数据全部响应完毕才销毁该请求
 *  @param resourceLoader 资源管理器
 *  @param loadingRequest 每一小块数据的请求
 */
- (BOOL)resourceLoader:(AVAssetResourceLoader*)resourceLoader shouldWaitForLoadingOfRequestedResource:(AVAssetResourceLoadingRequest*)loadingRequest{
    // TODO:在这里面开始我们的网络下载请求，也就是得到AVAssetResourceLoadingRequest对象
}

这里在提一下，由于会调用很多次，得到很多个分片信息，所以我选择用一个字典来将这些分片信息存储起来，然后逐一下载使用

NSString *key = kGetRequestKey(loadingRequest.request.URL);
if (key == nil) return NO;
KJResourceLoaderManager *manager = self.loaderMap[key];
if (manager == nil){
    NSURL *resourceURL = loadingRequest.request.URL;
    NSString *string = [resourceURL.absoluteString stringByReplacingOccurrencesOfString:kCustomVideoScheme withString:@""];
    NSURL *videoURL = [NSURL URLWithString:string];
    manager = [[KJResourceLoaderManager alloc] initWithVideoURL:videoURL];
    manager.delegate = self;
    self.loaderMap[key] = manager;
}
[manager kj_addRequest:loadingRequest];

/*  当视频播放器要取消请求时，相应的，也应该停止下载这部分数据。
 *  通常在拖拽视频进度时调这方法
 *  @param resourceLoader 资源管理器
 *  @param loadingRequest 每一小块数据的请求
 */
- (void)resourceLoader:(AVAssetResourceLoader*)resourceLoader didCancelLoadingRequest:(AVAssetResourceLoadingRequest*)loadingRequest{
    // TODO:停止下载请求
}

下面我们来一步一步讲解得到AVAssetResourceLoadingRequest之后，怎么去开启一个请求

第一步：获取请求长度，文件类型等信息

这里开启一个小分片去获取视频数据信息，然后配置正确的信息

/* 对请求加上长度，文件类型等信息，必须设置正确否则会报播放器Failed */
NS_INLINE void kSetDownloadConfiguration(KJDownloader *downloader, AVAssetResourceLoadingRequest *loadingRequest){
    AVAssetResourceLoadingContentInformationRequest *request = loadingRequest.contentInformationRequest;
    if (downloader.fileHandleManager.cacheInfo.contentType) {
        request.contentType = downloader.fileHandleManager.cacheInfo.contentType;
    }else{
        CFStringRef type = UTTypeCreatePreferredIdentifierForTag(kUTTagClassMIMEType, (__bridge CFStringRef)(@"video/mp4"), NULL);
        request.contentType = CFBridgingRelease(type);
    }
    request.byteRangeAccessSupported = YES;
    request.contentLength = downloader.fileHandleManager.cacheInfo.contentLength;
}

第二步：将下载的NSData传给播放器

总结其实就下面这一句代码，

[request.dataRequest respondWithData:data];

第三步：请求完成

取消并移除请求

if (error.code == KJPlayerCustomCodeCachedComplete) {
    [weakself kj_cancelLoading];
}else if (error){
    [request finishLoadingWithError:error];
}else{
    [request finishLoading];
    [weakself.requests removeObject:request];
}

到此抛开下载器部分处理不说，简单的边下边播就已经实现，下面我们就来说说下载器部分

下载器

下载器我这边采用的是NSURLSession，然后实现NSURLSessionDelegate委托协议
主要就是这三个方法

- (void)URLSession:(NSURLSession*)session
          dataTask:(NSURLSessionDataTask*)dataTask
didReceiveResponse:(NSURLResponse*)response
 completionHandler:(void (^)(NSURLSessionResponseDisposition disposition))completionHandler{

}
- (void)URLSession:(NSURLSession*)session dataTask:(NSURLSessionDataTask*)dataTask didReceiveData:(NSData*)data{

}
- (void)URLSession:(NSURLSession*)session task:(NSURLSessionDataTask*)task didCompleteWithError:(nullable NSError*)error{

}

这里关于下载就不做多余赘述，接着说说分片下载处理

NSUInteger fromOffset = fragment.range.location;
NSUInteger endOffset  = fragment.range.location + fragment.range.length - 1;
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:self.videoURL];
request.cachePolicy = NSURLRequestReloadIgnoringLocalAndRemoteCacheData;
NSString *range = [NSString stringWithFormat:@"bytes=%lu-%lu", fromOffset, endOffset];
[request setValue:range forHTTPHeaderField:@"Range"];
self.startOffset = fragment.range.location;
self.task = [self.session dataTaskWithRequest:request];
[self.task resume];

到此分片下载我们也就实现完成，

文件管理

文件管理这边，我们声明两个NSFileHandle，一个用来写入分片资源，一个用来读取已下载分片资源

写入已下载分片文件

[self.writeHandle seekToFileOffset:range.location];
[self.writeHandle writeData:data];
[self.cacheInfo kj_continueCacheFragmentRange:range];

读取已下载分片缓存数据

/* 读取已下载分片缓存数据 */
- (NSData*)kj_readCachedDataWithRange:(NSRange)range{
    @synchronized(self.readHandle) {
        [self.readHandle seekToFileOffset:range.location];
        return [self.readHandle readDataOfLength:range.length];
    }
}

这里还值得一提的就是，我们有可能数据并没有下载完成就就取消等等，这时候就选择了归档的方式来存储下载文件，然后下次进入优先读取归档信息，接着继续下载缓存这样子

归档解档处理

这里采用runtime结合kvc的方式获取处理Ivar，快捷简便

#pragma mark - NSCopying
- (id)copyWithZone:(nullable NSZone *)zone {
    KJFileHandleInfo *info = [[[self class] allocWithZone:zone] init];
    unsigned int count = 0;
    Ivar *ivars = class_copyIvarList([self class], &count);
    for (int i = 0; i<count; i++){
        const char *name = ivar_getName(ivars[i]);
        NSString *key = [NSString stringWithUTF8String:name];
        id value = [self valueForKey:key];
        if ([value respondsToSelector:@selector(copyWithZone:)]) {
            [info setValue:[value copy] forKey:key];
        }else{
            [info setValue:value forKey:key];
        }
    }
    free(ivars);
    return info;
}
/* 归档 */
- (void)encodeWithCoder:(NSCoder*)aCoder{
    unsigned int count = 0;
    Ivar *ivars = class_copyIvarList([self class], &count);
    for (int i = 0; i<count; i++){
        const char *name = ivar_getName(ivars[i]);
        NSString *key = [NSString stringWithUTF8String:name];
        id value = [self valueForKey:key];
        [aCoder encodeObject:value forKey:key];
    }
    free(ivars);
}
/* 解档 */
- (instancetype)initWithCoder:(NSCoder*)aDecoder{
    if (self = [super init]) {
        unsigned int count = 0;
        Ivar *ivars = class_copyIvarList([self class], &count);
        for (int i = 0; i<count; i++){
            const char *name = ivar_getName(ivars[i]);
            NSString *key = [NSString stringWithUTF8String:name];
            id value = [aDecoder decodeObjectForKey:key];
            [self setValue:value forKey:key];
        }
        free(ivars);
    }
    return self;
}

到此，其实我们的边下边播边存就基本上完成

存入信息到Database

为了更方便更好的管理存储数据，我还定义了一个数据库，然后我们将下载的信息存储至数据库当中，

//存储到本地数据库
- (BOOL)kj_saveDatabaseVideoIntact:(BOOL)videoIntact{
    PLAYER_WEAKSELF;
    NSError *__error;
    [DBPlayerDataInfo kj_insertData:self.cacheInfo.fileName Data:^(DBPlayerData * data){
        data.dbid = weakself.cacheInfo.fileName;
        data.videoUrl = weakself.cacheInfo.videoURL.absoluteString;
        data.videoFormat = weakself.cacheInfo.fileFormat;
        data.sandboxPath = [weakself.cacheInfo.fileName stringByAppendingPathExtension:weakself.cacheInfo.fileFormat];
        data.saveTime = NSDate.date.timeIntervalSince1970;
        data.videoIntact = videoIntact;
        data.videoContentLength = weakself.cacheInfo.contentLength;
    } error:&__error];
    if (__error) {
        return YES;
    }else if (videoIntact) {
        kGCD_player_main(^{
            weakself.playError = [DBPlayerDataInfo kj_errorSummarizing:KJPlayerCustomCodeSaveDatabase];
        });
    }
    return NO;
}

缓存管理器

提供了文件的增删改查等，资源文件管理等等

#pragma mark - NSFileManager
/* 删除指定文件 */
+ (BOOL)kj_removeFilePath:(NSString*)path;
/* 创建文件夹 */
+ (BOOL)kj_createFilePath:(NSString*)path;
/* 目录下有用的文件路径，排除临时文件 */
+ (NSArray*)kj_videoFilePaths;
/* 目录下的全部文件名，包含临时文件 */
+ (NSArray*)kj_videoAllFileNames;
/* 删除指定完整路径数据 */
+ (void)kj_removeAimPath:(NSString*)path,...;
/* 判断文件是否存在，存在拼接完整路径 */
+ (BOOL)kj_haveFileSandboxPath:(NSString * _Nonnull __strong * _Nonnull)path;
/* 清除视频缓存文件和数据库数据 */
+ (BOOL)kj_crearVideoCachedAndDatabase:(DBPlayerData*)data;

#pragma mark - Sandbox板块
/* 判断是否有缓存，返回缓存链接 */
@property(nonatomic,copy,class,readonly)void(^kJudgeHaveCacheURL)(void(^)(BOOL locality), NSURL * _Nonnull __strong * _Nonnull);
/* 创建视频缓存文件完整路径 */
+ (NSString*)kj_createVideoCachedPath:(NSURL*)url;
/* 追加视频临时缓存路径，用于播放器读取 */
+ (NSString*)kj_appendingVideoTempPath:(NSURL*)url;
/* 获取视频缓存大小 */
+ (int64_t)kj_videoCachedSize;
/* 清除全部视频缓存，暴露当前正在下载数据 */
+ (void)kj_clearAllVideoCache;
/* 清除指定视频缓存 */
+ (BOOL)kj_clearVideoCacheWithURL:(NSURL*)url;
/* 存入视频封面图 */
+ (void)kj_saveVideoCoverImage:(UIImage*)image VideoURL:(NSURL*)url;
/* 读取视频封面图 */
+ (UIImage*)kj_getVideoCoverImageWithURL:(NSURL*)url;
/* 清除视频封面图 */
+ (void)kj_clearVideoCoverImageWithURL:(NSURL*)url;
/* 清除全部封面缓存 */
+ (void)kj_clearAllVideoCoverImage;

关于seek处理

这里再说说，关于我们seek的时候的处理，大致分3种情况，

第一种：seek处视频已经下载好

I Like 这种是最中规中矩的只需要直接读取缓存播放即可

第二种：seek到视频未下载部分

这时就需要先取消正在下载的数据，然后从seek处开始重新下载数据，只需要下载器支持分片指定位置下载即可实现该需求

NSString *range = [NSString stringWithFormat:@"bytes=%lu-%lu", fromOffset, endOffset];
[request setValue:range forHTTPHeaderField:@"Range"];

第三种：seek来回多次数据就会包含已下载部分和未下载部分，断断续续

你咋这么烦呢？搞事情！！！
这时候就需要对这段分片做个标记，它到底属于已下载分片，还是未下载分片

1、如果为未下载分片数据，执行分片下载

if (fragment.type){// 远端碎片，即开始下载
    NSUInteger fromOffset = fragment.range.location;
    NSUInteger endOffset  = fragment.range.location + fragment.range.length - 1;
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:self.videoURL];
    request.cachePolicy = NSURLRequestReloadIgnoringLocalAndRemoteCacheData;
    NSString *range = [NSString stringWithFormat:@"bytes=%lu-%lu", fromOffset, endOffset];
    [request setValue:range forHTTPHeaderField:@"Range"];
    self.startOffset = fragment.range.location;
    self.task = [self.session dataTaskWithRequest:request];
    [self.task resume];
}

2、如果是已下载分片数据，则读取分片数据

NSData *data = [self.fileHandleManager kj_readCachedDataWithRange:fragment.range];

3、如果读取不成功，给一次机会再读，好好珍惜 - -!

self.once = YES;
data = [self.fileHandleManager kj_readCachedDataWithRange:fragment.range];

4、如果还是不成功，则将此分片标记为未下载分片，然后重新下载

if (data == nil) {
    fragment.type = 1;
    NSUInteger fromOffset = fragment.range.location;
    NSUInteger endOffset  = fragment.range.location + fragment.range.length - 1;
    NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:self.videoURL];
    request.cachePolicy = NSURLRequestReloadIgnoringLocalAndRemoteCacheData;
    NSString *range = [NSString stringWithFormat:@"bytes=%lu-%lu", fromOffset, endOffset];
    [request setValue:range forHTTPHeaderField:@"Range"];
    self.startOffset = fragment.range.location;
    self.task = [self.session dataTaskWithRequest:request];
    [self.task resume];
}

到此，关于边下边播边存，并且断点读取播放继续缓存处理也就介绍的差不多了，至于详细信息，我Dmeo里面写的也很详细，感兴趣的朋友可以去下载 Demo地址：KJPlayerDemo

文章关联

关于播放器其他相关文章

• 开发播放器框架之全屏处理
• 开发播放器框架之边下边播边存方案分享

后续该播放器壳子我会慢慢补充完善，老哥觉得好用还请帮我点个小星星传送门