ZFPlayer 源码解读

源码下载地址：https://github.com/renzifeng/ZFPlayer

之前自己实现过一个模仿百思不得姐的demo https://github.com/agelessman/FFmpegAndKxmovieDemo

由于有朋友推荐，看了下ZFPlayer，觉得功能和封装都写的很好，就把源码看了一遍，现在看源码已经养成了一个习惯，就是把自己在源码中不太熟悉的地方记录下来，还有就是尽量捕捉作者的思路。

打开demo，先看主控制器

主要的方法有两个：

// 哪些页面支持自动转屏

- (BOOL)shouldAutorotate

// viewcontroller支持哪些转屏方向

- (UIInterfaceOrientationMask)supportedInterfaceOrientations

这两个方法也没什么好说的，只是在我们写app的时候，一般都是默认开启app支持旋转的，然后用代码实现支持哪些界面能够旋转。

这里作者使用了这样的代码

// 调用ZFPlayerSingleton单例记录播放状态是否锁定屏幕方向

        return !ZFPlayerShared.isLockScreen;

不看后边的代码，应该能够推断出整个播放器采用的是单例模式的设计，有且只有一个，这样就避免了反复创建的消耗。但不是说创建了就一直存在，完全可以在需要销毁的时候进行销毁。

接下来看这四个文件

不难看出，ZFSessionModel应该就是与下载的文件相关信息的一个模型，在这个模型中我们能够得到跟下载的文件相关的我们需要的所有信息

支持NSCoding 协议，说明这个类会被归档和解档，也就是说对本类或进行本地存储操作

从编码的属性看，并没有编码所有的属性，只编码了必要的信息。

我们用一张图表来看本类的所有信息

接下来我们说说下载管理器的问题

其实编程跟我们日常生活中的生活规律特别的像，比如，我需要一个下载管理器来管理我整个工程的下载任务，如果我的下载任务很重，很多，那么我就应该多弄几个管理器，各管各自的业务，最后向一个总的管理boss负责。这种思想很重要，我们完全可以在写代码之前想象出一个大概的职责列表，每一项职责都是一个属性或者方法。

这样的想法很奇妙，不如我们就按照现在的思路，想象一下，现实生活中，作为一个数据仓库的管理员都需要干什么呢？

大家可以对比一下这个日常生活中的做事习惯跟变成是不是很像

再和

文件对比下，看看是不是差不多，可能我们在写接口文件的时候并不能一开始写的很周到，但是在实现功能的过程中，会慢慢的想到需要添加哪些东西，除非很必要，应该暴露的东西越少越好。

由于作者的注释非常的详细，对所有的方法就不一一解释了，有点基础的都能看懂，

这个是更加安全的单例写法，不要只写最下边的那个方法。

在下载管理者的实现中通过

NSURLSessionDataDelegate

处理了下载过程和下载完成后的逻辑，这个就不解释了，所有的下载代码都差不多是这样的，需要指出的是断点下载的实现,是下边的代码，在配置下载器的时候传入一个范围就可以了

好了现在重点来看看播放器的部分。

这个demo作者是没有加入边播边下载功能的，但是加了加载进度的缓存显示效果，这个效果主要是通过监听

loadedTimeRanges 实现的，

由于代码比较长，也都是一些业务逻辑上的问题，再次就一个个的进行说明了，作者也注释的清晰，

通过这个方法可以直接用在tableview类型的播放器中，这个还是比较方便的，看来作者也是想让别人用起来方便。

该demo提供的逻辑和功能还是很完善的，因为前段时间也自学了AVFoundation方面的知识，所以对这个还是很感兴趣的。

AVFoundation 提供了一系列很强大的功能

有兴趣的朋友可以下载这些demo看看，使用swift写的 http://code.cocoachina.com/u/373290

在这里也正好总结一些我对写一个类似这样播放器的看法。

作者是把整个功能使用UIView来实现的，而且额外提供了一些功能，可以让用户处理点击事件或者设置点击后的行为。

如果是我，我会把整个功能封装成一个NSObject（在一本书上学到的），把所有的功能封装进这个对象中去，就像这样

很简单，之暴露出来一个初始化方法，和一个实际播放的view

使用起来大概是这么使用

内部的实现是这样

 #import "THPlayerController.h"

 #import "THThumbnail.h"

 #import <AVFoundation/AVFoundation.h>

 #import "THTransport.h"

 #import "THPlayerView.h"

 #import "AVAsset+THAdditions.h"

 #import "UIAlertView+THAdditions.h"

 #import "THNotifications.h"

 // AVPlayerItem's status property

 #define STATUS_KEYPATH @"status"

 // Refresh interval for timed observations of AVPlayer

 #define REFRESH_INTERVAL 0.5f

 // Define this constant for the key-value observation context.

 static const NSString *PlayerItemStatusContext;

 @interface THPlayerController () <THTransportDelegate>

 @property (strong, nonatomic) AVAsset *asset;

 @property (strong, nonatomic) AVPlayerItem *playerItem;

 @property (strong, nonatomic) AVPlayer *player;

 @property (strong, nonatomic) THPlayerView *playerView;

 @property (weak, nonatomic) id <THTransport> transport;

 @property (strong, nonatomic) id timeObserver;

 @property (strong, nonatomic) id itemEndObserver;

 @property (assign, nonatomic) float lastPlaybackRate;

 @property (strong, nonatomic) AVAssetImageGenerator *imageGenerator;

 @end

 @implementation THPlayerController

 #pragma mark - Setup

 - (id)initWithURL:(NSURL *)assetURL {

     self = [super init];

     if (self) {

         _asset = [AVAsset assetWithURL:assetURL];                           //

         [self prepareToPlay];

     }

     return self;

 }

 - (void)prepareToPlay {

     NSArray *keys = @[

         @"tracks",

         @"duration",

         @"commonMetadata",

         @"availableMediaCharacteristicsWithMediaSelectionOptions"

     ];

     self.playerItem = [AVPlayerItem playerItemWithAsset:self.asset          //

                            automaticallyLoadedAssetKeys:keys];

     [self.playerItem addObserver:self                                       //

                       forKeyPath:STATUS_KEYPATH

                          options:

                          context:&PlayerItemStatusContext];

     self.player = [AVPlayer playerWithPlayerItem:self.playerItem];          //

     self.playerView = [[THPlayerView alloc] initWithPlayer:self.player];    //

     self.transport = self.playerView.transport;

     self.transport.delegate = self;

 }

 - (void)observeValueForKeyPath:(NSString *)keyPath

                       ofObject:(id)object

                         change:(NSDictionary *)change

                        context:(void *)context {

     if (context == &PlayerItemStatusContext) {

         dispatch_async(dispatch_get_main_queue(), ^{                        //

             [self.playerItem removeObserver:self forKeyPath:STATUS_KEYPATH];

             if (self.playerItem.status == AVPlayerItemStatusReadyToPlay) {

                 // Set up time observers.                                   //

                 [self addPlayerItemTimeObserver];

                 [self addItemEndObserverForPlayerItem];

                 CMTime duration = self.playerItem.duration;

                 // Synchronize the time display                             //

                 [self.transport setCurrentTime:CMTimeGetSeconds(kCMTimeZero)

                                       duration:CMTimeGetSeconds(duration)];

                 // Set the video title.

                 [self.transport setTitle:self.asset.title];                 //

                 [self.player play];                                         //

                 [self loadMediaOptions];

                 [self generateThumbnails];

             } else {

                 [UIAlertView showAlertWithTitle:@"Error"

                                         message:@"Failed to load video"];

             }

         });

     }

 }

 - (void)loadMediaOptions {

     NSString *mc = AVMediaCharacteristicLegible;                            //

     AVMediaSelectionGroup *group =

         [self.asset mediaSelectionGroupForMediaCharacteristic:mc];          //

     if (group) {

         NSMutableArray *subtitles = [NSMutableArray array];                 //

         for (AVMediaSelectionOption *option in group.options) {

             [subtitles addObject:option.displayName];

         }

         [self.transport setSubtitles:subtitles];                            //

     } else {

         [self.transport setSubtitles:nil];

     }

 }

 - (void)subtitleSelected:(NSString *)subtitle {

     NSString *mc = AVMediaCharacteristicLegible;

     AVMediaSelectionGroup *group =

         [self.asset mediaSelectionGroupForMediaCharacteristic:mc];          //

     BOOL selected = NO;

     for (AVMediaSelectionOption *option in group.options) {

         if ([option.displayName isEqualToString:subtitle]) {

             [self.playerItem selectMediaOption:option                       //

                          inMediaSelectionGroup:group];

             selected = YES;

         }

     }

     if (!selected) {

         [self.playerItem selectMediaOption:nil                              //

                      inMediaSelectionGroup:group];

     }

 }

 #pragma mark - Time Observers

 - (void)addPlayerItemTimeObserver {

     // Create 0.5 second refresh interval - REFRESH_INTERVAL == 0.5

     CMTime interval =

         CMTimeMakeWithSeconds(REFRESH_INTERVAL, NSEC_PER_SEC);              // 1

     // Main dispatch queue

     dispatch_queue_t queue = dispatch_get_main_queue();                     // 2

     // Create callback block for time observer

     __weak THPlayerController *weakSelf = self;                             //

     void (^callback)(CMTime time) = ^(CMTime time) {

         NSTimeInterval currentTime = CMTimeGetSeconds(time);

         NSTimeInterval duration = CMTimeGetSeconds(weakSelf.playerItem.duration);

         [weakSelf.transport setCurrentTime:currentTime duration:duration];  //

     };

     // Add observer and store pointer for future use

     self.timeObserver =                                                     //

         [self.player addPeriodicTimeObserverForInterval:interval

                                                   queue:queue

                                              usingBlock:callback];

 }

 - (void)addItemEndObserverForPlayerItem {

     NSString *name = AVPlayerItemDidPlayToEndTimeNotification;

     NSOperationQueue *queue = [NSOperationQueue mainQueue];

     __weak THPlayerController *weakSelf = self;                             //

     void (^callback)(NSNotification *note) = ^(NSNotification *notification) {

         [weakSelf.player seekToTime:kCMTimeZero                             //

                   completionHandler:^(BOOL finished) {

             [weakSelf.transport playbackComplete];                          //

         }];

     };

     self.itemEndObserver =                                                  //

         [[NSNotificationCenter defaultCenter] addObserverForName:name

                                                           object:self.playerItem

                                                            queue:queue

                                                       usingBlock:callback];

 }

 #pragma mark - THTransportDelegate Methods

 - (void)play {

     [self.player play];

 }

 - (void)pause {

     self.lastPlaybackRate = self.player.rate;

     [self.player pause];

 }

 - (void)stop {

     [self.player setRate:0.0f];

     [self.transport playbackComplete];

 }

 - (void)jumpedToTime:(NSTimeInterval)time {

     [self.player seekToTime:CMTimeMakeWithSeconds(time, NSEC_PER_SEC)];

 }

 - (void)scrubbingDidStart {                                                 //

     self.lastPlaybackRate = self.player.rate;

     [self.player pause];

     [self.player removeTimeObserver:self.timeObserver];

 }

 - (void)scrubbedToTime:(NSTimeInterval)time {                               //

     [self.playerItem cancelPendingSeeks];

     [self.player seekToTime:CMTimeMakeWithSeconds(time, NSEC_PER_SEC) toleranceBefore:kCMTimeZero toleranceAfter:kCMTimeZero];

 }

 - (void)scrubbingDidEnd {                                                   //

     [self addPlayerItemTimeObserver];

     if (self.lastPlaybackRate > 0.0f) {

         [self.player play];

     }

 }

 #pragma mark - Thumbnail Generation

 - (void)generateThumbnails {

     self.imageGenerator =                                                   //

         [AVAssetImageGenerator assetImageGeneratorWithAsset:self.asset];

     // Generate the @2x equivalent

     self.imageGenerator.maximumSize = CGSizeMake(200.0f, 0.0f);             //

     CMTime duration = self.asset.duration;

     NSMutableArray *times = [NSMutableArray array];                         //

     CMTimeValue increment = duration.value / ;

     CMTimeValue currentValue = 2.0 * duration.timescale;

     while (currentValue <= duration.value) {

         CMTime time = CMTimeMake(currentValue, duration.timescale);

         [times addObject:[NSValue valueWithCMTime:time]];

         currentValue += increment;

     }

     __block NSUInteger imageCount = times.count;                            //

     __block NSMutableArray *images = [NSMutableArray array];

     AVAssetImageGeneratorCompletionHandler handler;                         //

     handler = ^(CMTime requestedTime,

                 CGImageRef imageRef,

                 CMTime actualTime,

                 AVAssetImageGeneratorResult result,

                 NSError *error) {

         if (result == AVAssetImageGeneratorSucceeded) {                     //

             UIImage *image = [UIImage imageWithCGImage:imageRef];

             id thumbnail =

                 [THThumbnail thumbnailWithImage:image time:actualTime];

             [images addObject:thumbnail];

         } else {

             NSLog(@"Error: %@", [error localizedDescription]);

         }

         // If the decremented image count is at 0, we're all done.

         if (--imageCount == ) {                                            //

             dispatch_async(dispatch_get_main_queue(), ^{

                 NSString *name = THThumbnailsGeneratedNotification;

                 NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];

                 [nc postNotificationName:name object:images];

             });

         }

     };

     [self.imageGenerator generateCGImagesAsynchronouslyForTimes:times       //

                                               completionHandler:handler];

 }

 #pragma mark - Housekeeping

 - (UIView *)view {

     return self.playerView;

 }

 - (void)dealloc {

     if (self.itemEndObserver) {                                             //

         NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];

         [nc removeObserver:self.itemEndObserver

                       name:AVPlayerItemDidPlayToEndTimeNotification

                     object:self.player.currentItem];

         self.itemEndObserver = nil;

     }

 }

 @end

本类只提供 AVFoundation中的关于视频的一些播放暂停等等的控制功能，

界面需要另外一个view来展示，

控制单元也就是界面跟播放控制器之间的通信同过一个协议来实现

这样需要在控制界面添加功能都是通过协议来通信的，即实现了功能，也保持了很好的独立性。

这样用户完全可以自定义一套界面，依然能够使用AVFoundation的功能。

好了，本片文章就到此为止了。由于个人能力有限，如有错误之处，请帮忙给与指出，不胜感谢啊。

巴特西

ZFPlayer 源码解读

最新文章

热门文章