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];                           // 1
        [self prepareToPlay];
    }
    return self;
}

- (void)prepareToPlay {
    NSArray *keys = @[
        @"tracks",
        @"duration",
        @"commonMetadata",
        @"availableMediaCharacteristicsWithMediaSelectionOptions"
    ];
    self.playerItem = [AVPlayerItem playerItemWithAsset:self.asset          // 2
                           automaticallyLoadedAssetKeys:keys];

    [self.playerItem addObserver:self                                       // 3
                      forKeyPath:STATUS_KEYPATH
                         options:0
                         context:&PlayerItemStatusContext];

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

    self.playerView = [[THPlayerView alloc] initWithPlayer:self.player];    // 5
    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(), ^{                        // 1
            
            [self.playerItem removeObserver:self forKeyPath:STATUS_KEYPATH];
            
            if (self.playerItem.status == AVPlayerItemStatusReadyToPlay) {
                
                // Set up time observers.                                   // 2
                [self addPlayerItemTimeObserver];
                [self addItemEndObserverForPlayerItem];
                
                CMTime duration = self.playerItem.duration;
                
                // Synchronize the time display                             // 3
                [self.transport setCurrentTime:CMTimeGetSeconds(kCMTimeZero)
                                      duration:CMTimeGetSeconds(duration)];
                
                // Set the video title.
                [self.transport setTitle:self.asset.title];                 // 4
                
                [self.player play];                                         // 5
                
                [self loadMediaOptions];
                [self generateThumbnails];
                
            } else {
                [UIAlertView showAlertWithTitle:@"Error"
                                        message:@"Failed to load video"];
            }
        });
    }
}

- (void)loadMediaOptions {
    NSString *mc = AVMediaCharacteristicLegible;                            // 1
    AVMediaSelectionGroup *group =
        [self.asset mediaSelectionGroupForMediaCharacteristic:mc];          // 2
    if (group) {
        NSMutableArray *subtitles = [NSMutableArray array];                 // 3
        for (AVMediaSelectionOption *option in group.options) {
            [subtitles addObject:option.displayName];
        }
        [self.transport setSubtitles:subtitles];                            // 4
    } else {
        [self.transport setSubtitles:nil];
    }
}

- (void)subtitleSelected:(NSString *)subtitle {
    NSString *mc = AVMediaCharacteristicLegible;
    AVMediaSelectionGroup *group =
        [self.asset mediaSelectionGroupForMediaCharacteristic:mc];          // 1
    BOOL selected = NO;
    for (AVMediaSelectionOption *option in group.options) {
        if ([option.displayName isEqualToString:subtitle]) {
            [self.playerItem selectMediaOption:option                       // 2
                         inMediaSelectionGroup:group];
            selected = YES;
        }
    }
    if (!selected) {
        [self.playerItem selectMediaOption:nil                              // 3
                     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;                             // 3
    void (^callback)(CMTime time) = ^(CMTime time) {
        NSTimeInterval currentTime = CMTimeGetSeconds(time);
        NSTimeInterval duration = CMTimeGetSeconds(weakSelf.playerItem.duration);
        [weakSelf.transport setCurrentTime:currentTime duration:duration];  // 4
    };
    
    // Add observer and store pointer for future use
    self.timeObserver =                                                     // 5
        [self.player addPeriodicTimeObserverForInterval:interval
                                                  queue:queue
                                             usingBlock:callback];
}

- (void)addItemEndObserverForPlayerItem {

    NSString *name = AVPlayerItemDidPlayToEndTimeNotification;

    NSOperationQueue *queue = [NSOperationQueue mainQueue];

    __weak THPlayerController *weakSelf = self;                             // 1
    void (^callback)(NSNotification *note) = ^(NSNotification *notification) {
        [weakSelf.player seekToTime:kCMTimeZero                             // 2
                  completionHandler:^(BOOL finished) {
            [weakSelf.transport playbackComplete];                          // 3
        }];
    };

    self.itemEndObserver =                                                  // 4
        [[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 {                                                 // 1
    self.lastPlaybackRate = self.player.rate;
    [self.player pause];
    [self.player removeTimeObserver:self.timeObserver];
}

- (void)scrubbedToTime:(NSTimeInterval)time {                               // 2
    [self.playerItem cancelPendingSeeks];
    [self.player seekToTime:CMTimeMakeWithSeconds(time, NSEC_PER_SEC) toleranceBefore:kCMTimeZero toleranceAfter:kCMTimeZero];
}

- (void)scrubbingDidEnd {                                                   // 3
    [self addPlayerItemTimeObserver];
    if (self.lastPlaybackRate > 0.0f) {
        [self.player play];
    }
}


#pragma mark - Thumbnail Generation

- (void)generateThumbnails {
    
    self.imageGenerator =                                                   // 1
        [AVAssetImageGenerator assetImageGeneratorWithAsset:self.asset];
    
    // Generate the @2x equivalent
    self.imageGenerator.maximumSize = CGSizeMake(200.0f, 0.0f);             // 2

    CMTime duration = self.asset.duration;

    NSMutableArray *times = [NSMutableArray array];                         // 3
    CMTimeValue increment = duration.value / 20;
    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;                            // 4
    __block NSMutableArray *images = [NSMutableArray array];

    AVAssetImageGeneratorCompletionHandler handler;                         // 5
    
    handler = ^(CMTime requestedTime,
                CGImageRef imageRef,
                CMTime actualTime,
                AVAssetImageGeneratorResult result,
                NSError *error) {

        if (result == AVAssetImageGeneratorSucceeded) {                     // 6
            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 == 0) {                                            // 7
            dispatch_async(dispatch_get_main_queue(), ^{
                NSString *name = THThumbnailsGeneratedNotification;
                NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
                [nc postNotificationName:name object:images];
            });
        }
    };

    [self.imageGenerator generateCGImagesAsynchronouslyForTimes:times       // 8
                                              completionHandler:handler];
    
    
}


#pragma mark - Housekeeping

- (UIView *)view {
    return self.playerView;
}

- (void)dealloc {
    if (self.itemEndObserver) {                                             // 5
        NSNotificationCenter *nc = [NSNotificationCenter defaultCenter];
        [nc removeObserver:self.itemEndObserver
                      name:AVPlayerItemDidPlayToEndTimeNotification
                    object:self.player.currentItem];
        self.itemEndObserver = nil;
    }
}

@end

本類只提供 AVFoundation中的關於視頻的一些播放暫停等等的控制功能，

界面需要另外一個view來展示，

控制單元也就是界面 跟 播放控制器 之間的通信同過一個協議來實現

這樣需要在控制界面添加功能 都是通過協議來通信的，即實現了功能，也保持了很好的獨立性。

這樣用戶完全可以自定義一套界面 ，依然能夠使用AVFoundation的功能。

好了 ，本片文章就到此為止了。由於個人能力有限，如有錯誤之處，請幫忙給與指出，不勝感謝啊 。