006-音视频

一、音频

　　音频播放分为音效播放和音乐播放两大类。前者主要是指的是一些短的音频播放，通常作为点缀音频。对于这一类音频不需要进行进度、循环等控制。后者是一些较长的音频，通常是主音频，对于这些音频的播放通常需要进行精确的控制。在iOS中播放两类音频分别使用AudioToolbox.framework和AVFoundation.framework来完成音效和音乐播放

1.音效(System Sound Service)

　1）说明

　　AudioToolbox.framework是一套基于C语言的框架，使用它来播放音效其本质是将段音频注册到系统声音服务(System Sound Service)

　　System Sound Service是一种简单、底层的声音播放服务，但是它本身也存在着一些限制：

　　　　a.音频播放时长不超过30秒

　　　　b.数据必须是PCM或者IMA4格式

　　　　c.音频文件必须打包成.caf、.aif、.wav中的一种(注意这是官方文档的说法，实际测试发现一些.mp3格式也可以播放)

　　　　d.只可以播放本地文件(boundle中的音效文件)

　2）使用System Sound Service播放音效的步骤如下：

　　a.调用AudioServicesCreateSystemSoundID(CFURLRef  inFileURL, SystemSoundID *outSystemSoundID)函数获得系统声音ID

　　b.如果需要监听播放完成操作，则使用AudioServicesAddSystemSoundCompletion(SystemSoundID inSystemSoundID,
CFRunLoopRef  inRunLoop, CFStringRef  inRunLoopMode, AudioServicesSystemSoundCompletionProc  inCompletionRoutine, void *inClientData)方法注册回调函数

　　c.调用AudioServicesPlaySystemSound(SystemSoundID inSystemSoundID)或者AudioServicesPlayAlertSound(SystemSoundID inSystemSoundID)方法播放音效(后者带有震动效果)

　3）程序实例

// SoundController.m文件
#import "SoundController.h"
#import <AudioToolbox/AudioToolbox.h> // 播放音效需要导入的框架

@interface SoundController ()

@end

@implementation SoundController

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    
    // 播放音效按钮
    UIButton *playBtn = [UIButton buttonWithType:UIButtonTypeSystem];
    playBtn.bounds = CGRectMake(0, 0, 150, 40);
    playBtn.center = CGPointMake(self.view.bounds.size.width / 2.0, self.view.bounds.size.height / 2.0);
    [playBtn setTitle:@"播放音效" forState:UIControlStateNormal];
    playBtn.tintColor = [UIColor whiteColor];
    playBtn.backgroundColor = [UIColor grayColor];
    playBtn.titleLabel.font = [UIFont boldSystemFontOfSize:20];
    [playBtn addTarget:self action:@selector(playBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:playBtn];
}

#pragma mark - 播放音效点击事件
- (void)playBtnClick:(UIButton *)playBtn
{
    [self playSoundEffectWithFileName:@"yinxiao.caf"];
}

#pragma mark - 播放音效文件
// 参数：fileName 文件名
- (void)playSoundEffectWithFileName:(NSString *)fileName
{
    // 获得音效文件路径(必须是本地文件)
    NSString *audioFile = [[NSBundle mainBundle] pathForResource:fileName ofType:nil];
    // 根据音效文件路径获得音效文件URL
    NSURL *fileURL = [NSURL fileURLWithPath:audioFile];
    
    // 获得系统声音ID
    SystemSoundID soundID = 0;
    
    // 此函数会将音效文件加入到系统音频服务中并返回一个长整形ID
    // 参数1：音频文件URL
    // 参数2：声音ID
    AudioServicesCreateSystemSoundID((__bridge CFURLRef _Nonnull)(fileURL), &soundID);
    
    // 如果需要在播放完成之后执行某些操作，可以调用下面方法注册一个播放完成的回调函数
    AudioServicesAddSystemSoundCompletion(soundID, NULL, NULL, soundCompleteCallBack, NULL);
    
    // 播放音效文件
    AudioServicesPlaySystemSound(soundID); // 不带振动效果
    AudioServicesPlayAlertSound(soundID); // 带有振动效果
}

#pragma mark - 播放完成回调函数
// 参数1：soundID 系统声音ID
// 参数2：clientData 回调时传递的数据
void soundCompleteCallBack(SystemSoundID soundID,void * clientData){
    NSLog(@"播放完成...");
}

@end

2.音乐(AVAudioPlayer)

　1）说明

　　如果播放较大的音频文件或者要对音频文件有精准的控制，则System Sound Service可能就很难满足实际需求了，通常这种情况会选择使用AVFoundation.framework中的AVAudioPlayer来实现。AVAudioPlayer可以看成一个播放器，它支持多种音频格式，而且能够进行进度、音量、播放速度等控制。另外与System Sound Service一样，AVFoundation.framework中的AVAudioPlayer也只能是播放本地音乐(boundle里面的音乐文件)

　2）常见属性和方法

属性	说明
@property(readonly, getter=isPlaying) BOOL playing	是否正在播放，只读
@property(readonly) NSUInteger numberOfChannels	音频声道数，只读
@property(readonly) NSTimeInterval duration	音频时长
@property(readonly) NSURL *url	音频文件路径，只读
@property(readonly) NSData *data	音频数据，只读
@property float pan	立体声平衡(-1.0：左声道，0.0：左右声道平衡，1.0：右声道)
@property float volume	音量大小(范围0 - 1.0)
@property BOOL enableRate	是否允许改变播放速率
@property float rate	播放速率(0.5 - 2.0，1.0：正常播放，如要修改播放速率则必须设置enableRate为YES)
@property NSTimeInterval currentTime	当前播放时长
@property(readonly) NSTimeInterval deviceCurrentTime	输出设备播放音频的时间，注意如果播放中被暂停此时间也会继续累加
@property NSInteger numberOfLoops	循环播放次数(0：不循环，小于0：无限循环，大于0：表示循环次数)
@property(readonly) NSDictionary *settings	音频播放设置信息，只读
@property(getter=isMeteringEnabled) BOOL meteringEnabled	是否启用音频测量，默认为NO，一旦启用音频测量可以通过updateMeters方法更新测量值
@property(nonatomic, copy) NSArray *channelAssignments	获得或设置播放声道

 

对象方法	说明
- (instancetype)initWithContentsOfURL:(NSURL *)url error:(NSError **)outError	使用文件URL初始化播放器，注意这个URL不能是HTTP URL，AVAudioPlayer不支持加载网络媒体流，只能播放本地文件
- (instancetype)initWithData:(NSData *)data error:(NSError **)outError	使用NSData初始化播放器，注意使用此方法时必须文件格式和文件后缀一致，否则出错，所以相比此方法更推荐使用上述方法或- (instancetype)initWithData:(NSData *)data fileTypeHint:(NSString *)utiString error:(NSError **)outError方法进行初始化
- (BOOL)prepareToPlay;	加载音频文件到缓冲区，注意即使在播放之前音频文件没有加载到缓冲区程序也会隐式调用此方法。
- (BOOL)play;	播放音频文件
- (BOOL)playAtTime:(NSTimeInterval)time	在指定的时间开始播放音频
- (void)pause;	暂停播放
- (void)stop;	停止播放
- (void)updateMeters	更新音频测量值，注意如果要更新音频测量值必须设置meteringEnabled为YES，通过音频测量值可以即时获得音频分贝等信息
- (float)peakPowerForChannel:(NSUInteger)channelNumber;	获得指定声道的分贝峰值，注意如果要获得分贝峰值必须在此之前调用updateMeters方法
- (float)averagePowerForChannel:(NSUInteger)channelNumber	获得指定声道的分贝平均值，注意如果要获得分贝平均值必须在此之前调用updateMeters方法

 

代理方法	说明
- (void)audioPlayerDidFinishPlaying:(AVAudioPlayer *)player successfully:(BOOL)flag	音频播放完成
- (void)audioPlayerDecodeErrorDidOccur:(AVAudioPlayer *)player error:(NSError *)error	音频解码发生错误

　3）AVAudioPlayer的使用步骤

　　a.初始化AVAudioPlayer对象，此时通常指定本地文件路径

　　b.设置播放器属性，例如重复次数、音量大小等

　　c.调用play方法播放

　4）代码示例

　　当然由于AVAudioPlayer一次只能播放一个音频文件，所有上一曲、下一曲其实可以通过创建多个播放器对象来完成，这里暂不实现。播放进度的实现主要依靠一个定时器实时计算当前播放时长和音频总时长的比例

// MusicController.m文件
#import "MusicController.h"
#import <AVFoundation/AVFoundation.h>  // 需要导入的框架

@interface MusicController ()<AVAudioPlayerDelegate>

#pragma mark - 音乐播放器
@property (nonatomic, strong) AVAudioPlayer *audioPlayer;
#pragma mark - 播放进度
@property (nonatomic, strong) UIProgressView *progressView;
#pragma mark - 播放/暂停
@property (nonatomic, strong) UIButton *playOrPauseBtn;
#pragma mark - 定时器
@property (nonatomic, strong) NSTimer *timer;

@end

@implementation MusicController

#pragma mark - 懒加载
// 1.audioPlayer
- (AVAudioPlayer *)audioPlayer
{
    if (!_audioPlayer) {
        // 本地音乐文件
        NSString *urlStr=[[NSBundle mainBundle]pathForResource:@"演员.mp3" ofType:nil];
        NSURL *url = [NSURL fileURLWithPath:urlStr];
        NSError *error = nil;
        // 初始化播放器
        // 注意：这里的URL只能是文件路径，也就是只能是本地音乐文件；不支持HTTP URL，也就是网络歌曲
        _audioPlayer = [[AVAudioPlayer alloc] initWithContentsOfURL:url error:&error];
        // 设置播放器属性
        _audioPlayer.numberOfLoops = 0; // 设置为0不循环
        _audioPlayer.delegate = self;
        [_audioPlayer prepareToPlay]; // 加载音频文件到缓存
        if (error) {
            NSLog(@"初始化播放器过程发生错误,错误信息:%@", error.localizedDescription);
            return nil;
        }
    }
    return _audioPlayer;
}
// 2.timer
- (NSTimer *)timer
{
    if (!_timer) {
        _timer = [NSTimer scheduledTimerWithTimeInterval:0.5 target:self selector:@selector(updateProgress) userInfo:nil repeats:YES];
        // 加入到运行循环
        [[NSRunLoop currentRunLoop] addTimer:_timer forMode:NSRunLoopCommonModes];
    }
    return _timer;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
   
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    // playOrPauseBtn
    _playOrPauseBtn = [UIButton buttonWithType:UIButtonTypeSystem];
    _playOrPauseBtn.frame = CGRectMake(100, 100, self.view.bounds.size.width - 100 * 2, 60);
    [_playOrPauseBtn setTitle:@"PLAY" forState:UIControlStateNormal];
    [_playOrPauseBtn setTitle:@"PAUSE" forState:UIControlStateSelected];
    _playOrPauseBtn.tintColor = [UIColor redColor];
    [_playOrPauseBtn addTarget:self action:@selector(playOrPauseBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_playOrPauseBtn];
    
    // progress
    _progressView = [[UIProgressView alloc] initWithFrame:CGRectMake(30, CGRectGetMaxY(_playOrPauseBtn.frame) + 10, self.view.bounds.size.width - 30 * 2, 5)];
    _progressView.progress = 0;
    [self.view addSubview:_progressView];
}

#pragma mark - 播放/暂停点击事件
- (void)playOrPauseBtnClick:(UIButton *)sender
{
    sender.selected = !sender.selected;
    
    if (sender.isSelected) {
        // 播放
        [self.audioPlayer play];
        // 恢复定时器
        self.timer.fireDate=[NSDate distantPast];
    
    } else {
        [self.audioPlayer pause];
        // 暂停定时器
        // 注意不能调用invalidate方法，此方法会取消，之后无法恢复
        self.timer.fireDate = [NSDate distantFuture];
    }
}

#pragma mark - 定时器事件
- (void)updateProgress
{
    float progressValue = self.audioPlayer.currentTime / self.audioPlayer.duration;
    // 进度设置
    [self.progressView setProgress:progressValue animated:YES];
}

#pragma mark - 代理方法<AVAudioPlayerDelegate>
// 播放完毕调用
- (void)audioPlayerDidFinishPlaying:(AVAudioPlayer *)player successfully:(BOOL)flag
{
    NSLog(@"音乐播放完成...");
}

@end

3.音频会话(AVAudioPlayer & AVAudioSession)

如果需要使播放器即使退出到后台也是可以播放的，即支持后台播放功能，我们还需要做以下几件事情：

　1）设置后台运行模式：在plist列表中添加字段“Required background modes”，并且设置item 0 = App plays audio or streams audio/video using AirPlay（其实可以直接通过Xcode在Project Targets-Capabilities-Background Modes中设置）

　　这一步的目的是不让应用程序在后台被挂起，而是处于运行状态

　2）设置AVAudioSession的类型为AVAudioSessionCategoryPlayback并且调用setActive::方法启动会话

    AVAudioSession *audioSession=[AVAudioSession sharedInstance];
    [audioSession setCategory:AVAudioSessionCategoryPlayback error:nil];
    [audioSession setActive:YES error:nil];

　　a.在iOS中每一个应用都有一个音频会话，这个会话就通过AVAudioSession来表示。

　　b.AVAudioSession属于AVFoundation框架，并且是单例模式设计，通过sharedInstance进行访问。

　　c.在使用Apple设备时大家会发现有些应用只要打开其他音频播放就会终止，而有些应用却可以和其他应用同时播放，在多种音频环境中如何去控制播放的方式就是通过音频回话来完成的。

　　音频会话的几种会话模式：

　注意：在设置完音频会话类型之后需要调用setActive::方法将会话激活才能起作用。如果设备上已经存在一个正在播放的音频会话，打开我们的应用之后设置了后台播放的会话类型，此时原本正在播放的音频会因我们应用的音频播放而停止，此时，如果希望我们的应用程序在音频播放结束之后，能够继续播放原来的音频，那么我们应该在我们自己的 应用中调用setActive::方法关闭会话。

3）如果需要让应用退出后台支持耳机控制，可以添加远程控制事件(这一步不是后台播放所必须)

代码实例(支持后台播放、支持拔出耳机暂停音乐)

// MusicPlayerController.m文件
#import "MusicPlayerController.h"
#import <AVFoundation/AVFoundation.h>  // 需要导入的框架

@interface MusicPlayerController ()<AVAudioPlayerDelegate>

#pragma mark - 音乐播放器
@property (nonatomic, strong) AVAudioPlayer *audioPlayer;
#pragma mark - 播放进度
@property (nonatomic, strong) UIProgressView *progressView;
#pragma mark - 播放/暂停
@property (nonatomic, strong) UIButton *playOrPauseBtn;
#pragma mark - 定时器
@property (nonatomic, strong) NSTimer *timer;

@end

@implementation MusicPlayerController

#pragma mark - 懒加载
// 1.audioPlayer
- (AVAudioPlayer *)audioPlayer
{
    if (!_audioPlayer) {
        // 本地音乐文件
        NSString *urlStr=[[NSBundle mainBundle]pathForResource:@"演员.mp3" ofType:nil];
        NSURL *url = [NSURL fileURLWithPath:urlStr];
        NSError *error = nil;
        // 初始化播放器
        // 注意：这里的URL只能是文件路径，也就是只能是本地音乐文件；不支持HTTP URL，也就是网络歌曲
        _audioPlayer = [[AVAudioPlayer alloc] initWithContentsOfURL:url error:&error];
        // 设置播放器属性
        _audioPlayer.numberOfLoops = 0; // 设置为0不循环
        _audioPlayer.delegate = self;
        [_audioPlayer prepareToPlay]; // 加载音频文件到缓存
        if (error) {
            NSLog(@"初始化播放器过程发生错误,错误信息:%@", error.localizedDescription);
            return nil;
        }
        
        // 设置后台播放模式
        AVAudioSession *audioSession = [AVAudioSession sharedInstance];
        [audioSession setCategory:AVAudioSessionCategoryPlayback error:nil];
        [audioSession setActive:YES error:nil];
        // 添加通知，拔出耳机后暂停播放
        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(routeChange:) name:AVAudioSessionRouteChangeNotification object:nil];
    }
    return _audioPlayer;
}
// 2.timer
- (NSTimer *)timer
{
    if (!_timer) {
        _timer = [NSTimer scheduledTimerWithTimeInterval:0.5 target:self selector:@selector(updateProgress) userInfo:nil repeats:YES];
        // 加入到运行循环
        [[NSRunLoop currentRunLoop] addTimer:_timer forMode:NSRunLoopCommonModes];
    }
    return _timer;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 显示当前视图控制器时，注册远程事件
- (void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear:animated];
    // 开启远程控制
    [[UIApplication sharedApplication] beginReceivingRemoteControlEvents];
    // 作为第一响应者
    // [self becomeFirstResponder];
}

#pragma mark - 当前视图消失时取消远程控制
- (void)viewWillDisappear:(BOOL)animated
{
    [super viewWillDisappear:animated];
    // 结束远程控制
    [[UIApplication sharedApplication] endReceivingRemoteControlEvents];
    // 失去第一响应
    // [self resignFirstResponder];
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    
    // playOrPauseBtn
    _playOrPauseBtn = [UIButton buttonWithType:UIButtonTypeSystem];
    _playOrPauseBtn.frame = CGRectMake(100, 100, self.view.bounds.size.width - 100 * 2, 60);
    [_playOrPauseBtn setTitle:@"PLAY" forState:UIControlStateNormal];
    [_playOrPauseBtn setTitle:@"PAUSE" forState:UIControlStateSelected];
    _playOrPauseBtn.tintColor = [UIColor redColor];
    [_playOrPauseBtn addTarget:self action:@selector(playOrPauseBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_playOrPauseBtn];
    
    // progress
    _progressView = [[UIProgressView alloc] initWithFrame:CGRectMake(30, CGRectGetMaxY(_playOrPauseBtn.frame) + 10, self.view.bounds.size.width - 30 * 2, 5)];
    _progressView.progress = 0;
    [self.view addSubview:_progressView];
}

#pragma mark - 播放/暂停点击事件
- (void)playOrPauseBtnClick:(UIButton *)sender
{
    sender.selected = !sender.selected;
    
    if (sender.isSelected) {
        // 播放
        [self play];
        
    } else {
        // 暂停
        [self pause];
    }
}

#pragma mark - 播放
- (void)play
{
    // 播放
    [self.audioPlayer play];
    // 恢复定时器
    self.timer.fireDate=[NSDate distantPast];
}

#pragma mark - 暂停
- (void)pause
{
    // 暂停
    [self.audioPlayer pause];
    // 暂停定时器
    // 注意不能调用invalidate方法，此方法会取消，之后无法恢复
    self.timer.fireDate = [NSDate distantFuture];
}

#pragma mark - 定时器事件
- (void)updateProgress
{
    float progressValue = self.audioPlayer.currentTime / self.audioPlayer.duration;
    // 进度设置
    [self.progressView setProgress:progressValue animated:YES];
}

#pragma mark - 代理方法<AVAudioPlayerDelegate>
// 播放完毕调用
- (void)audioPlayerDidFinishPlaying:(AVAudioPlayer *)player successfully:(BOOL)flag
{
    NSLog(@"音乐播放完成...");
    // 根据实际情况播放完成可以将会话关闭，其他音频应用继续播放
    [[AVAudioSession sharedInstance] setActive:NO error:nil];
}

#pragma mark - 通知事件
// 一旦输出改变则执行此方法
- (void)routeChange:(NSNotification *)notification
{
    NSDictionary *dict = notification.userInfo;
    int changeReason = [dict[AVAudioSessionRouteChangeReasonKey] intValue];
    // 等于AVAudioSessionRouteChangeReasonOldDeviceUnavailable表示旧输出不可用
    if (changeReason == AVAudioSessionRouteChangeReasonOldDeviceUnavailable) {
        AVAudioSessionRouteDescription *routeDescription = dict[AVAudioSessionRouteChangePreviousRouteKey];
        AVAudioSessionPortDescription *portDescription= [routeDescription.outputs firstObject];
        // 原设备为耳机则暂停
        if ([portDescription.portType isEqualToString:@"Headphones"]) {
            // 点击播放/暂停按键
            [self playOrPauseBtnClick:_playOrPauseBtn];
        }
    }
}

#pragma mark - 销毁方法
- (void)dealloc
{
    [[NSNotificationCenter defaultCenter] removeObserver:self name:AVAudioSessionRouteChangeNotification object:nil];
}

@end

4.播放音乐库中的音乐(MPMusicPlayerController)

　1）说明

　　MPMusicPlayerController是属于MediaPlayer.frameowork框架

　2）属性和方法

属性	说明
@property (nonatomic, readonly) MPMusicPlaybackState playbackState	播放器状态，枚举类型： MPMusicPlaybackStateStopped：停止播放 MPMusicPlaybackStatePlaying：正在播放 MPMusicPlaybackStatePaused：暂停播放 MPMusicPlaybackStateInterrupted：播放中断 MPMusicPlaybackStateSeekingForward：向前查找 MPMusicPlaybackStateSeekingBackward：向后查找
@property (nonatomic) MPMusicRepeatMode repeatMode	重复模式，枚举类型： MPMusicRepeatModeDefault：默认模式，使用用户的首选项（系统音乐程序设置） MPMusicRepeatModeNone：不重复 MPMusicRepeatModeOne：单曲循环 MPMusicRepeatModeAll：在当前列表内循环
@property (nonatomic) MPMusicShuffleMode shuffleMode	随机播放模式，枚举类型： MPMusicShuffleModeDefault：默认模式，使用用户首选项（系统音乐程序设置） MPMusicShuffleModeOff：不随机播放 MPMusicShuffleModeSongs：按歌曲随机播放 MPMusicShuffleModeAlbums：按专辑随机播放
@property (nonatomic, copy) MPMediaItem *nowPlayingItem	正在播放的音乐项
@property (nonatomic, readonly) NSUInteger indexOfNowPlayingItem	当前正在播放的音乐在播放队列中的索引
@property(nonatomic, readonly) BOOL isPreparedToPlay	是否准好播放准备
@property(nonatomic) NSTimeInterval currentPlaybackTime	当前已播放时间，单位：秒
@property(nonatomic) float currentPlaybackRate	当前播放速度，是一个播放速度倍率，0表示暂停播放，1代表正常速度

 

类方法	说明
+ (MPMusicPlayerController *)applicationMusicPlayer;	获取应用播放器，注意此类播放器无法在后台播放
+ (MPMusicPlayerController *)systemMusicPlayer	获取系统播放器，支持后台播放

 

对象方法	说明
- (void)setQueueWithQuery:(MPMediaQuery *)query	使用媒体队列设置播放源媒体队列
- (void)setQueueWithItemCollection:(MPMediaItemCollection *)itemCollection	使用媒体项集合设置播放源媒体队列
- (void)skipToNextItem	下一曲
- (void)skipToBeginning	从起始位置播放
- (void)skipToPreviousItem	上一曲
- (void)beginGeneratingPlaybackNotifications	开启播放通知，注意不同于其他播放器，MPMusicPlayerController要想获得通知必须首先开启，默认情况无法获得通知
- (void)endGeneratingPlaybackNotifications	关闭播放通知
- (void)prepareToPlay	做好播放准备（加载音频到缓冲区），在使用play方法播放时如果没有做好准备回自动调用该方法
- (void)play	开始播放
- (void)pause	暂停播放
- (void)stop	停止播放
- (void)beginSeekingForward	开始向前查找（快进）
- (void)beginSeekingBackward	开始向后查找（快退）
- (void)endSeeking	结束查找

  

通知	说明 （注意：要想获得MPMusicPlayerController通知必须首先调用beginGeneratingPlaybackNotifications开启通知）
MPMusicPlayerControllerPlaybackStateDidChangeNotification	播放状态改变
MPMusicPlayerControllerNowPlayingItemDidChangeNotification	当前播放音频改变
MPMusicPlayerControllerVolumeDidChangeNotification	声音大小改变
MPMediaPlaybackIsPreparedToPlayDidChangeNotification	准备好播放

 

　3）MPMusicPlayerController

　　a.MPMusicPlayerController有两种播放器：

　　　　applicationMusicPlayer：应用退出后，音乐播放会自动停止

　　　　systemMusicPlayer：应用停止后不会退出播放状态

　　b.MPMusicPlayerController加载音乐不同于AVAudioPlayer

　　　　AVAudioPlayer是通过一个文件路径来加载

　　　　MPMusicPlayerController是需要一个播放队列来加载

　　c.MPMusicPlayerController提供了两个方法来加载播放队列

　　　　- (void)setQueueWithQuery:(MPMediaQuery *)query;

　　　　- (void)setQueueWithItemCollection:(MPMediaItemCollection *)itemCollection;

　　　　正是因为MPMusicPlayerController的播放音频来源是一个队列，因此它支持上一曲、下一曲等操作

　　d.MPMusicPlayerController如何获取MPMediaQueue或者MPMediaItemCollection

　　　　MPMediaQueue对象有以下方法用来获取媒体队列:

　　　　+ (MPMediaQuery *)albumsQuery;

　　　　+ (MPMediaQuery *)artistsQuery;

　　　　+ (MPMediaQuery *)songsQuery;

　　　　+ (MPMediaQuery *)playlistsQuery;

　　　　+ (MPMediaQuery *)podcastsQuery;

　　　　+ (MPMediaQuery *)audiobooksQuery;

　　　　+ (MPMediaQuery *)compilationsQuery;

　　　　+ (MPMediaQuery *)composersQuery;

　　　　+ (MPMediaQuery *)genresQuery;

　　e.设置音乐来源

　　　　MPMediaQueue：- (void)setQueueWithQuery:(MPMediaQuery *)query;

　　　　MPMediaItemCollection：- (void)setQueueWithItemCollection:(MPMediaItemCollection *)itemCollection;

　　f.MPMediaPickerController

　　　　如果希望用户自己来选择将要播放的音乐，这个时候可以使用MPMediaPickerController

　　　　MPMediaPickerController是一个视图控制器，类似于UIImagePickerController

　　　　选择完播放来源后可以在其代理方法中获得MPMediaItemCollection对象

　　g.MPMediaItem(媒体文件对象)

　　　　无论通过哪一种方式获得MPMusicPlayerController的媒体源，我们都可以通过MPMediaItem对象获得媒体文件的信息

　　　　一个MPMediaItem对象对应着一个媒体文件，通过它可以访问媒体标题、专辑名称、专辑封面、音乐时长等等

　　　　无论是MPMediaQueue，还是MPMediaItemCollection都有一个items属性，这是一个装有MPMediaItem的数组，通过这个属性可以获得MPMediaItem对象

　4）代码实例

// MusicQueueController.m文件
#import "MusicQueueController.h"
#import <MediaPlayer/MediaPlayer.h> // 导入框架

@interface MusicQueueController ()<MPMediaPickerControllerDelegate>

// 媒体选择控制器
@property (nonatomic, strong) MPMediaPickerController *mediaPicker;
// 音乐播放器
@property (nonatomic, strong) MPMusicPlayerController *musicPlayer;

#pragma mark - 界面上的按钮
@property (nonatomic, strong) UIButton *selectBtn; // 选择音乐来源按钮
@property (nonatomic, strong) UIButton *playBtn; // 播放按钮
@property (nonatomic, strong) UIButton *pauseBtn; // 暂停按钮
@property (nonatomic, strong) UIButton *stopBtn; // 停止按钮
@property (nonatomic, strong) UIButton *nextBtn; // 下一曲按钮
@property (nonatomic, strong) UIButton *prevBtn; // 上一曲按钮

@end

@implementation MusicQueueController

#pragma mark - 懒加载
// 1.mediaPicker
- (MPMediaPickerController *)mediaPicker
{
    if (!_mediaPicker) {
        // 初始化媒体选择器
        // 这里设置媒体类型为音乐，其实这里也可以选择视频、广播等
        _mediaPicker = [[MPMediaPickerController alloc] initWithMediaTypes:MPMediaTypeMusic];
        // 允许多选
        _mediaPicker.allowsPickingMultipleItems = YES;
        // 显示icloud选项
        // _mediaPicker.showsCloudItems = YES;
        _mediaPicker.prompt = @"请选择要播放的音乐";
        // 设置选择器代理
        _mediaPicker.delegate = self;
    }
    return _mediaPicker;
}
// 2.musicPlayer
- (MPMusicPlayerController *)musicPlayer
{
    if (!_musicPlayer) {
        // systemMusicPlayer：应用停止后不会退出播放状态
        _musicPlayer = [MPMusicPlayerController systemMusicPlayer];
        // 开启通知(否则监控不到MPMusicPlayerController的通知)
        [_musicPlayer beginGeneratingPlaybackNotifications];
        // 添加通知
        [self addNotification];
        // 如果不使用MPMediaPickerController可以使用如下方法获得音乐库媒体队列
        // [_musicPlayer setQueueWithItemCollection:[self getLocalMediaItemCollection]];
    }
    return _musicPlayer;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    
    // 选择音乐来源按钮
    CGFloat selectBtnX = 40;
    CGFloat selectBtnY = 80;
    CGFloat selectBtnW = self.view.bounds.size.width - 40 * 2;
    CGFloat selectBtnH = 40;
    _selectBtn = [UIButton buttonWithType:UIButtonTypeCustom];
    _selectBtn.frame = CGRectMake(selectBtnX, selectBtnY, selectBtnW, selectBtnH);
    [_selectBtn setTitle:@"选择音乐来源" forState:UIControlStateNormal];
    _selectBtn.tintColor = [UIColor whiteColor];
    _selectBtn.backgroundColor = [UIColor blackColor];
    _selectBtn.titleLabel.font = [UIFont boldSystemFontOfSize:17];
    [_selectBtn addTarget:self action:@selector(selectBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_selectBtn];
    
    // 播放按钮
    CGFloat playBtnX = _selectBtn.frame.origin.x;
    CGFloat playBtnY = CGRectGetMaxY(_selectBtn.frame) + 10;
    CGFloat playBtnW = _selectBtn.bounds.size.width;
    CGFloat playBtnH = _selectBtn.bounds.size.height;
    _playBtn = [UIButton buttonWithType:UIButtonTypeCustom];
    _playBtn.frame = CGRectMake(playBtnX, playBtnY, playBtnW, playBtnH);
    [_playBtn setTitle:@"播放" forState:UIControlStateNormal];
    _playBtn.tintColor = [UIColor whiteColor];
    _playBtn.backgroundColor = [UIColor blackColor];
    _playBtn.titleLabel.font = [UIFont boldSystemFontOfSize:17];
    [_playBtn addTarget:self action:@selector(playBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_playBtn];
    
    // 暂停按钮
    CGFloat pauseBtnX = _selectBtn.frame.origin.x;
    CGFloat pauseBtnY = CGRectGetMaxY(_playBtn.frame) + 10;
    CGFloat pauseBtnW = _selectBtn.bounds.size.width;
    CGFloat pauseBtnH = _selectBtn.bounds.size.height;
    _pauseBtn = [UIButton buttonWithType:UIButtonTypeCustom];
    _pauseBtn.frame = CGRectMake(pauseBtnX, pauseBtnY, pauseBtnW, pauseBtnH);
    [_pauseBtn setTitle:@"暂停" forState:UIControlStateNormal];
    _pauseBtn.tintColor = [UIColor whiteColor];
    _pauseBtn.backgroundColor = [UIColor blackColor];
    _pauseBtn.titleLabel.font = [UIFont boldSystemFontOfSize:17];
    [_pauseBtn addTarget:self action:@selector(pauseBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_pauseBtn];
    
    // 停止按钮
    CGFloat stopBtnX = _selectBtn.frame.origin.x;
    CGFloat stopBtnY = CGRectGetMaxY(_pauseBtn.frame) + 10;
    CGFloat stopBtnW = _selectBtn.bounds.size.width;
    CGFloat stopBtnH = _selectBtn.bounds.size.height;
    _stopBtn = [UIButton buttonWithType:UIButtonTypeCustom];
    _stopBtn.frame = CGRectMake(stopBtnX, stopBtnY, stopBtnW, stopBtnH);
    [_stopBtn setTitle:@"停止" forState:UIControlStateNormal];
    _stopBtn.tintColor = [UIColor whiteColor];
    _stopBtn.backgroundColor = [UIColor blackColor];
    _stopBtn.titleLabel.font = [UIFont boldSystemFontOfSize:17];
    [_stopBtn addTarget:self action:@selector(stopBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_stopBtn];
    
    // 下一曲按钮
    CGFloat nextBtnX = _selectBtn.frame.origin.x;
    CGFloat nextBtnY = CGRectGetMaxY(_stopBtn.frame) + 10;
    CGFloat nextBtnW = _selectBtn.bounds.size.width;
    CGFloat nextBtnH = _selectBtn.bounds.size.height;
    _nextBtn = [UIButton buttonWithType:UIButtonTypeCustom];
    _nextBtn.frame = CGRectMake(nextBtnX, nextBtnY, nextBtnW, nextBtnH);
    [_nextBtn setTitle:@"下一曲" forState:UIControlStateNormal];
    _nextBtn.tintColor = [UIColor whiteColor];
    _nextBtn.backgroundColor = [UIColor blackColor];
    _nextBtn.titleLabel.font = [UIFont boldSystemFontOfSize:17];
    [_nextBtn addTarget:self action:@selector(nextBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_nextBtn];
    
    // 上一曲按钮
    CGFloat prevBtnX = _selectBtn.frame.origin.x;
    CGFloat prevBtnY = CGRectGetMaxY(_nextBtn.frame) + 10;
    CGFloat prevBtnW = _selectBtn.bounds.size.width;
    CGFloat prevBtnH = _selectBtn.bounds.size.height;
    _prevBtn = [UIButton buttonWithType:UIButtonTypeCustom];
    _prevBtn.frame = CGRectMake(prevBtnX, prevBtnY, prevBtnW, prevBtnH);
    [_prevBtn setTitle:@"上一曲" forState:UIControlStateNormal];
    _prevBtn.tintColor = [UIColor whiteColor];
    _prevBtn.backgroundColor = [UIColor blackColor];
    _prevBtn.titleLabel.font = [UIFont boldSystemFontOfSize:17];
    [_prevBtn addTarget:self action:@selector(prevBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_prevBtn];
    
    // 按钮交互设置
    _selectBtn.enabled = YES;
    _playBtn.enabled = NO;
    _pauseBtn.enabled = NO;
    _stopBtn.enabled = NO;
    _nextBtn.enabled = NO;
    _prevBtn.enabled = NO;
}

#pragma mark - 点击事件
// 1.选择音乐来源
- (void)selectBtnClick:(UIButton *)sender
{
    [self presentViewController:self.mediaPicker animated:YES completion:nil];
}
// 2.播放
- (void)playBtnClick:(UIButton *)sender
{
    [self.musicPlayer play];
}
// 3.暂停
- (void)pauseBtnClick:(UIButton *)sender
{
    [self.musicPlayer pause];
}
// 4.停止
- (void)stopBtnClick:(UIButton *)sender
{
    [self.musicPlayer stop];
}
// 5.下一曲
- (void)nextBtnClick:(UIButton *)sender
{
    [self.musicPlayer skipToNextItem];
}
// 6.上一曲
- (void)prevBtnClick:(UIButton *)sender
{
    [self.musicPlayer skipToPreviousItem];
}

#pragma mark - 直接通过MPMediaQueue获得媒体队列或媒体集合
// 1.取得媒体队列
- (MPMediaQuery *)getLocalMediaQuery
{
    MPMediaQuery *mediaQueue = [MPMediaQuery songsQuery];
    for (MPMediaItem *item in mediaQueue.items) {
        NSLog(@"标题：%@,%@", item.title, item.albumTitle);
    }
    return mediaQueue;
}
// 2.取得媒体集合
- (MPMediaItemCollection *)getLocalMediaItemCollection
{
    MPMediaQuery *mediaQueue = [MPMediaQuery songsQuery];
    NSMutableArray *array = [NSMutableArray array];
    for (MPMediaItem *item in mediaQueue.items) {
        [array addObject:item];
        NSLog(@"标题：%@,%@",item.title,item.albumTitle);
    }
    MPMediaItemCollection *mediaItemCollection = [[MPMediaItemCollection alloc]initWithItems:[array copy]];
    return mediaItemCollection;
}

#pragma mark - 代理方法<MPMediaPickerController>
// 1.选择完成
-(void)mediaPicker:(MPMediaPickerController *)mediaPicker didPickMediaItems:(MPMediaItemCollection *)mediaItemCollection
{
    // 按钮交互设置
    _selectBtn.enabled = YES;
    _playBtn.enabled = YES;
    _pauseBtn.enabled = NO;
    _stopBtn.enabled = NO;
    _nextBtn.enabled = YES;
    _prevBtn.enabled = YES;
    
    // 第一个播放音乐
    MPMediaItem *mediaItem=[mediaItemCollection.items firstObject];
    // 注意很多音乐信息(标题、专辑、表演者、封面、时长等)都可以通过MPMediaItem的valueForKey:方法得到，但是从iOS7开始都有对应的属性可以直接访问
    // NSString *title = [mediaItem valueForKey:MPMediaItemPropertyAlbumTitle];
    // NSString *artist = [mediaItem valueForKey:MPMediaItemPropertyAlbumArtist];
    // MPMediaItemArtwork *artwork = [mediaItem valueForKey:MPMediaItemPropertyArtwork];
    //UIImage *image = [artwork imageWithSize:CGSizeMake(100, 100)]; // 专辑图片
    NSLog(@"标题：%@,表演者：%@,专辑：%@", mediaItem.title, mediaItem.artist, mediaItem.albumTitle);
    [self.musicPlayer setQueueWithItemCollection:mediaItemCollection];
    [self dismissViewControllerAnimated:YES completion:nil];
}
// 2.取消选择
-(void)mediaPickerDidCancel:(MPMediaPickerController *)mediaPicker
{
    // 按钮交互设置
    _selectBtn.enabled = YES;
    _playBtn.enabled = NO;
    _pauseBtn.enabled = NO;
    _stopBtn.enabled = NO;
    _nextBtn.enabled = NO;
    _prevBtn.enabled = NO;
    [self dismissViewControllerAnimated:YES completion:nil];
}

#pragma mark - 通知
// 1.添加通知
- (void)addNotification
{
    NSNotificationCenter *notificationCenter = [NSNotificationCenter defaultCenter];
    [notificationCenter addObserver:self selector:@selector(playbackStateChange:) name:MPMusicPlayerControllerPlaybackStateDidChangeNotification object:self.musicPlayer];
}
// 2.播放状态改变通知
- (void)playbackStateChange:(NSNotification *)notification
{
    switch (self.musicPlayer.playbackState) {
        case MPMusicPlaybackStatePlaying:
            NSLog(@"正在播放...");
            // 按钮交互设置
            _selectBtn.enabled = NO;
            _playBtn.enabled = NO;
            _pauseBtn.enabled = YES;
            _stopBtn.enabled = YES;
            _nextBtn.enabled = YES;
            _prevBtn.enabled = YES;
            break;
        case MPMusicPlaybackStatePaused:
            NSLog(@"播放暂停.");
            // 按钮交互设置
            _selectBtn.enabled = YES;
            _playBtn.enabled = YES;
            _pauseBtn.enabled = NO;
            _stopBtn.enabled = NO;
            _nextBtn.enabled = YES;
            _prevBtn.enabled = YES;
            break;
        case MPMusicPlaybackStateStopped:
            NSLog(@"播放停止.");
            // 按钮交互设置
            _selectBtn.enabled = YES;
            _playBtn.enabled = YES;
            _pauseBtn.enabled = NO;
            _stopBtn.enabled = NO;
            _nextBtn.enabled = YES;
            _prevBtn.enabled = YES;
            break;
        default:
            break;
    }
}

#pragma mark - 销毁方法
- (void)dealloc
{
    // 结束通知
    [self.musicPlayer endGeneratingPlaybackNotifications];
}

@end

5.录音(AVAudioRecorder)

　1）说明

　　a.AVAudioRecorder属于AVFoundation框架

　　b.AVAudioRecorder是专门处理录音操作的，它同样支持多种音频格式

　　c.AVAudioRecorder跟AVAudioPlayer创建有所不同,创建录音机时除了指定的路径外，还须指定录音设置信息(文件格式、采样率、通道数、每个采样点的位数等)

　2）属性和方法

属性	说明
@property(readonly, getter=isRecording) BOOL recording;	是否正在录音，只读
@property(readonly) NSURL *url	录音文件地址，只读
@property(readonly) NSDictionary *settings	录音文件设置，只读
@property(readonly) NSTimeInterval currentTime	录音时长，只读，注意仅仅在录音状态可用
@property(readonly) NSTimeInterval deviceCurrentTime	输入设置的时间长度，只读，注意此属性一直可访问
@property(getter=isMeteringEnabled) BOOL meteringEnabled	是否启用录音测量，如果启用录音测量可以获得录音分贝等数据信息
@property(nonatomic, copy) NSArray *channelAssignments	当前录音的通道

  

对象方法	说明
- (instancetype)initWithURL:(NSURL *)url settings:(NSDictionary *)settings error:(NSError **)outError	录音机对象初始化方法，注意其中的url必须是本地文件url，settings是录音格式、编码等设置
- (BOOL)prepareToRecord	准备录音，主要用于创建缓冲区，如果不手动调用，在调用record录音时也会自动调用
- (BOOL)record	开始录音
- (BOOL)recordAtTime:(NSTimeInterval)time	在指定的时间开始录音，一般用于录音暂停再恢复录音
- (BOOL)recordForDuration:(NSTimeInterval) duration	按指定的时长开始录音
- (BOOL)recordAtTime:(NSTimeInterval)time forDuration:(NSTimeInterval) duration	在指定的时间开始录音，并指定录音时长
- (void)pause	暂停录音
- (void)stop	停止录音
- (BOOL)deleteRecording	删除录音，注意要删除录音此时录音机必须处于停止状态
- (void)updateMeters	更新测量数据，注意只有meteringEnabled为YES此方法才可用
- (float)peakPowerForChannel:(NSUInteger)channelNumber	指定通道的测量峰值，注意只有调用完updateMeters才有值
- (float)averagePowerForChannel:(NSUInteger)channelNumber	指定通道的测量平均值，注意只有调用完updateMeters才有值

 

代理方法	说明
- (void)audioRecorderDidFinishRecording:(AVAudioRecorder *)recorder successfully:(BOOL)flag	完成录音
- (void)audioRecorderEncodeErrorDidOccur:(AVAudioRecorder *)recorder error:(NSError *)error	录音编码发生错误

 　3）代码实例(实现录音功能、录音结束自动播放、监听录音的声波变化)

 

// RecorderController.m文件
#import "RecorderController.h"
#import <AVFoundation/AVFoundation.h>

#define kRecordAudioFile @"myRecord.caf"

@interface RecorderController ()<AVAudioRecorderDelegate>

@property (nonatomic,strong) AVAudioRecorder *audioRecorder; // 音频录音机
@property (nonatomic,strong) AVAudioPlayer *audioPlayer; // 音频播放器，用于播放录音文件
@property (nonatomic,strong) NSTimer *timer; // 录音声波监控（注意这里暂时不对播放进行监控）

@property (nonatomic, strong) UIButton *recordBtn; // 开始录音
@property (nonatomic, strong) UIButton *pauseBtn; // 暂停录音
@property (nonatomic, strong) UIButton *resumeBtn; // 恢复录音
@property (nonatomic, strong) UIButton *stopBtn; // 停止录音
@property (nonatomic, strong) UIProgressView *audioPowerProgressView; // 音频波动

@end

@implementation RecorderController

#pragma mark - 懒加载
// 1.audioRecorder
- (AVAudioRecorder *)audioRecorder
{
    if (!_audioRecorder) {
        // 创建录音文件保存路径
        NSURL *url = [self getSavePath];
        // 创建录音格式设置
        NSDictionary *setting = [self getAudioSetting];
        // 创建录音机
        NSError *error = nil;
        _audioRecorder = [[AVAudioRecorder alloc]initWithURL:url settings:setting error:&error];
        _audioRecorder.delegate = self;
        _audioRecorder.meteringEnabled = YES; // 如果要监控声波则必须设置为YES
        if (error) {
            NSLog(@"创建录音机对象时发生错误，错误信息：%@", error.localizedDescription);
            return nil;
        }
    }
    return _audioRecorder;
}
// 2.audioPlayer
- (AVAudioPlayer *)audioPlayer
{
    if (!_audioPlayer) {
        // 取得录音文件保存路径
        NSURL *url = [self getSavePath];
        NSError *error = nil;
        // 创建播放器
        _audioPlayer = [[AVAudioPlayer alloc]initWithContentsOfURL:url error:&error];
        _audioPlayer.numberOfLoops = 0;
        [_audioPlayer prepareToPlay]; // 播放缓存
        if (error) {
            NSLog(@"创建播放器过程中发生错误，错误信息：%@",error.localizedDescription);
            return nil;
        }
    }
    return _audioPlayer;
}
// 3.timer
- (NSTimer *)timer
{
    if (!_timer) {
        _timer=[NSTimer scheduledTimerWithTimeInterval:0.1f target:self selector:@selector(audioPowerChange) userInfo:nil repeats:YES];
    }
    return _timer;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
    [self setAudioSession]; // 设置音频会话
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor colorWithRed:50 / 255.0 green:88 / 255.0 blue:111 / 255.0 alpha:1];
    
    // recordBtn
    CGFloat recordBtnX = 10;
    CGFloat recordBtnY = self.view.frame.size.height / 2.0 + 50;
    CGFloat recordBtnW = (self.view.bounds.size.width - 5 * recordBtnX) / 4;
    CGFloat recordBtnH = 35;
    _recordBtn = [UIButton buttonWithType:UIButtonTypeSystem];
    _recordBtn.frame = CGRectMake(recordBtnX, recordBtnY, recordBtnW, recordBtnH);
    [_recordBtn setTitle:@"开始录音" forState:UIControlStateNormal];
    _recordBtn.titleLabel.font = [UIFont systemFontOfSize:13];
    _recordBtn.backgroundColor = [UIColor whiteColor];
    _recordBtn.tintColor = [UIColor greenColor];
    _recordBtn.layer.borderWidth = 3;
    _recordBtn.layer.borderColor = [UIColor greenColor].CGColor;
    [_recordBtn addTarget:self action:@selector(recordBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_recordBtn];
    
    // pauseBtn
    CGFloat pauseBtnX = CGRectGetMaxX(_recordBtn.frame) + recordBtnX;
    CGFloat pauseBtnY = _recordBtn.frame.origin.y;
    CGFloat pauseBtnW = _recordBtn.bounds.size.width;
    CGFloat pauseBtnH = _recordBtn.bounds.size.height;
    _pauseBtn = [UIButton buttonWithType:UIButtonTypeSystem];
    _pauseBtn.frame = CGRectMake(pauseBtnX, pauseBtnY, pauseBtnW, pauseBtnH);
    [_pauseBtn setTitle:@"暂停录音" forState:UIControlStateNormal];
    _pauseBtn.titleLabel.font = [UIFont systemFontOfSize:13];
    _pauseBtn.backgroundColor = [UIColor whiteColor];
    _pauseBtn.tintColor = [UIColor greenColor];
    _pauseBtn.layer.borderWidth = 3;
    _pauseBtn.layer.borderColor = [UIColor greenColor].CGColor;
    [_pauseBtn addTarget:self action:@selector(pauseBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_pauseBtn];
    
    // resumeBtn
    CGFloat resumeBtnX = CGRectGetMaxX(_pauseBtn.frame) + recordBtnX;
    CGFloat resumeBtnY = _recordBtn.frame.origin.y;
    CGFloat resumeBtnW = _recordBtn.bounds.size.width;
    CGFloat resumeBtnH = _recordBtn.bounds.size.height;
    _resumeBtn = [UIButton buttonWithType:UIButtonTypeSystem];
    _resumeBtn.frame = CGRectMake(resumeBtnX, resumeBtnY, resumeBtnW, resumeBtnH);
    [_resumeBtn setTitle:@"恢复录音" forState:UIControlStateNormal];
    _resumeBtn.titleLabel.font = [UIFont systemFontOfSize:13];
    _resumeBtn.backgroundColor = [UIColor whiteColor];
    _resumeBtn.tintColor = [UIColor greenColor];
    _resumeBtn.layer.borderWidth = 3;
    _resumeBtn.layer.borderColor = [UIColor greenColor].CGColor;
    [_resumeBtn addTarget:self action:@selector(resumeBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_resumeBtn];
    
    // stopBtn
    CGFloat stopBtnX = CGRectGetMaxX(_resumeBtn.frame) + recordBtnX;
    CGFloat stopBtnY = _recordBtn.frame.origin.y;
    CGFloat stopBtnW = _recordBtn.bounds.size.width;
    CGFloat stopBtnH = _recordBtn.bounds.size.height;
    _stopBtn = [UIButton buttonWithType:UIButtonTypeSystem];
    _stopBtn.frame = CGRectMake(stopBtnX, stopBtnY, stopBtnW, stopBtnH);
    [_stopBtn setTitle:@"停止录音" forState:UIControlStateNormal];
    _stopBtn.titleLabel.font = [UIFont systemFontOfSize:13];
    _stopBtn.backgroundColor = [UIColor whiteColor];
    _stopBtn.tintColor = [UIColor greenColor];
    _stopBtn.layer.borderWidth = 3;
    _stopBtn.layer.borderColor = [UIColor greenColor].CGColor;
    [_stopBtn addTarget:self action:@selector(stopBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:_stopBtn];
    
    // audioPowerProgressView
    CGFloat audioPowerProgressViewX = recordBtnX;
    CGFloat audioPowerProgressViewY = self.view.frame.size.height / 2.0;
    CGFloat audioPowerProgressViewW = self.view.bounds.size.width - audioPowerProgressViewX * 2;
    CGFloat audioPowerProgressViewH = 20;
    _audioPowerProgressView = [[UIProgressView alloc] initWithProgressViewStyle:UIProgressViewStyleBar];
    _audioPowerProgressView.frame = CGRectMake(audioPowerProgressViewX, audioPowerProgressViewY, audioPowerProgressViewW, audioPowerProgressViewH);
    _audioPowerProgressView.progress = 0;
    _audioPowerProgressView.progressTintColor = [UIColor redColor];
    _audioPowerProgressView.trackTintColor = [UIColor grayColor];
    [self.view addSubview:_audioPowerProgressView];
}

#pragma mark - 设置音频会话
- (void)setAudioSession
{
    AVAudioSession *audioSession = [AVAudioSession sharedInstance];
    // 设置为播放和录音状态，以便在录制完之后播放录音
    [audioSession setCategory:AVAudioSessionCategoryPlayAndRecord error:nil];
    [audioSession setActive:YES error:nil];
}

#pragma mark - 取得录音文件保存路径
- (NSURL *)getSavePath
{
    NSString *urlStr = [NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES) lastObject];
    urlStr = [urlStr stringByAppendingPathComponent:kRecordAudioFile];
    NSLog(@"录音文件保存路径：%@", urlStr);
    NSURL *url = [NSURL fileURLWithPath:urlStr];
    return url;
}

#pragma mark - 取得录音文件设置
// 返回的是参数字典
- (NSDictionary *)getAudioSetting
{
    NSMutableDictionary *dicM = [NSMutableDictionary dictionary];
    // 设置录音格式
    [dicM setObject:@(kAudioFormatLinearPCM) forKey:AVFormatIDKey];
    // 设置录音采样率，8000是电话采样率，对于一般录音已经够了
    [dicM setObject:@(8000) forKey:AVSampleRateKey];
    // 设置通道,这里采用单声道
    [dicM setObject:@(1) forKey:AVNumberOfChannelsKey];
    // 每个采样点位数,分为8、16、24、32
    [dicM setObject:@(8) forKey:AVLinearPCMBitDepthKey];
    // 是否使用浮点数采样
    [dicM setObject:@(YES) forKey:AVLinearPCMIsFloatKey];
    return dicM;
}

#pragma mark - 更新设置录音声波状态
- (void)audioPowerChange
{
    // 更新测量值
    [self.audioRecorder updateMeters];
    // 取得第一个通道的音频，注意音频强度范围时-160到0
    float power = [self.audioRecorder averagePowerForChannel:0];
    CGFloat progress = (1.0 / 160.0) * (power + 160.0);
    // 设置audioPowerProgressView的值
    _audioPowerProgressView.progress = progress;
}

#pragma mark - 点击事件
// 1.开始录音
- (void)recordBtnClick:(UIButton *)sender
{
    if (![self.audioRecorder isRecording]) {
        // 首次使用应用时如果调用recordBtnClick:方法会询问用户是否允许使用麦克风
        [self.audioRecorder record];
        self.timer.fireDate = [NSDate distantPast];
    }
}
// 2.暂停录音
- (void)pauseBtnClick:(UIButton *)sender
{
    if ([self.audioRecorder isRecording]) {
        [self.audioRecorder pause];
        self.timer.fireDate = [NSDate distantFuture];
    }
}
// 3.恢复录音
- (void)resumeBtnClick:(UIButton *)sender
{
    [self recordBtnClick:sender];
}
// 4.停止录音
- (void)stopBtnClick:(UIButton *)sender
{
    [self.audioRecorder stop];
    self.timer.fireDate = [NSDate distantFuture];
    _audioPowerProgressView.progress = 0.0;
}

#pragma mark - 代理方法<AVAudioRecorderDelegate>
// 参数1：recorder 录音机对象
// 参数2：flag 是否成功
- (void)audioRecorderDidFinishRecording:(AVAudioRecorder *)recorder successfully:(BOOL)flag
{
    if (![self.audioPlayer isPlaying]) {
        [self.audioPlayer play];
    }
    NSLog(@"录音完成!");
}

@end

 

二、视频

1.MPMoviePlayerController(通常作嵌入视频播放)

　1）简介

　　a.属于框架MediaPlayer.framework

　　b.支持本地视频和网络视频播放

　　c.MPMoviePlayerController自身实现了MPMediaPlayback协议，因此具有一般的播放器控制功能，例如：播放、停止、暂停等等

　　d.MPMoviePlayerController自身并不是一个完成的视图控制器，如果要在UI中展示视频，需要将该类中的属性View添加到界面中

　2）常用属性和方法 

属性	说明
@property (nonatomic, copy) NSURL *contentURL	播放媒体URL(可以是本地路径，也可以是网络路径)
@property (nonatomic, readonly) UIView *view	播放器视图(如果要显示视频，必须将此视图添加到控制器视图中)
@property (nonatomic, readonly) UIView *backgroundView	播放器背景视图
@property (nonatomic, readonly) MPMoviePlaybackState playbackState	媒体播放状态，枚举类型： MPMoviePlaybackStateStopped：停止播放 MPMoviePlaybackStatePlaying：正在播放 MPMoviePlaybackStatePaused：暂停 MPMoviePlaybackStateInterrupted：中断 MPMoviePlaybackStateSeekingForward：向前定位 MPMoviePlaybackStateSeekingBackward：向后定位
@property (nonatomic, readonly) MPMovieLoadState loadState	网络媒体加载状态，枚举类型： MPMovieLoadStateUnknown：位置类型 MPMovieLoadStatePlayable： MPMovieLoadStatePlaythroughOK：这种状态如果shouldAutoPlay为YES将自动播放 MPMovieLoadStateStalled：停滞状态
@property (nonatomic) MPMovieControlStyle controlStyle	控制面板风格，枚举类型： MPMovieControlStyleNone：无控制面板  MPMovieControlStyleEmbedded：嵌入视频风格  MPMovieControlStyleFullscreen：全屏  MPMovieControlStyleDefault：默认风格
@property (nonatomic) MPMovieRepeatMode repeatMode	重复播放模式，枚举类型: MPMovieRepeatModeNone:不重复，默认值 MPMovieRepeatModeOne:重复播放
@property (nonatomic) BOOL shouldAutoplay	当网络媒体缓存到一定数据时是否自动播放，默认为YES
@property (nonatomic, getter=isFullscreen) BOOL fullscreen	是否全屏展示(默认为NO，注意如果要通过此属性设置全屏必须在视图显示完成后设置，否则无效)
@property (nonatomic) MPMovieScalingMode scalingMode	视频缩放填充模式，枚举类型： MPMovieScalingModeNone：不进行任何缩放 MPMovieScalingModeAspectFit：固定缩放比例并且尽量全部展示视频，不会裁切视频 MPMovieScalingModeAspectFill：固定缩放比例并填充满整个视图展示，可能会裁切视频 MPMovieScalingModeFill：不固定缩放比例压缩填充整个视图，视频不会被裁切但是比例失衡
@property (nonatomic, readonly) BOOL readyForDisplay	是否有相关媒体被播放
@property (nonatomic, readonly) MPMovieMediaTypeMask movieMediaTypes	媒体类别，枚举类型： MPMovieMediaTypeMaskNone：未知类型 MPMovieMediaTypeMaskVideo：视频 MPMovieMediaTypeMaskAudio：音频
@property (nonatomic) MPMovieSourceType movieSourceType	媒体源，枚举类型： MPMovieSourceTypeUnknown：未知来源 MPMovieSourceTypeFile：本地文件 MPMovieSourceTypeStreaming：流媒体（直播或点播）
@property (nonatomic, readonly) NSTimeInterval duration	媒体时长，如果未知则返回0
@property (nonatomic, readonly) NSTimeInterval playableDuration	媒体可播放时长，主要用于表示网络媒体已下载视频时长
@property (nonatomic, readonly) CGSize naturalSize	视频实际尺寸，如果未知则返回CGSizeZero
@property (nonatomic) NSTimeInterval initialPlaybackTime	起始播放时间
@property (nonatomic) NSTimeInterval endPlaybackTime	终止播放时间
@property (nonatomic) BOOL allowsAirPlay	是否允许无线播放，默认为YES
@property (nonatomic, readonly, getter=isAirPlayVideoActive) BOOL airPlayVideoActive	当前媒体是否正在通过AirPlay播放
@property(nonatomic, readonly) BOOL isPreparedToPlay	是否准备好播放
@property(nonatomic) NSTimeInterval currentPlaybackTime	当前播放时间，单位：秒
@property(nonatomic) float currentPlaybackRate	当前播放速度，如果暂停则为0，正常速度为1.0，非0数据表示倍率

 

对象方法	说明
- (instancetype)initWithContentURL:(NSURL *)url	使用指定的URL初始化媒体播放控制器对象
- (void)setFullscreen:(BOOL)fullscreen animated:(BOOL)animated	设置视频全屏，注意如果要通过此方法设置全屏则必须在其视图显示之后设置，否则无效
- (void)requestThumbnailImagesAtTimes:(NSArray *)playbackTimes timeOption:(MPMovieTimeOption)option	获取在指定播放时间的视频缩略图，第一个参数是获取缩略图的时间点数组；第二个参数代表时间点精度，枚举类型： MPMovieTimeOptionNearestKeyFrame：时间点附近 MPMovieTimeOptionExact：准确时间
- (void)cancelAllThumbnailImageRequests	取消所有缩略图获取请求
- (void)prepareToPlay	准备播放，加载视频数据到缓存，当调用play方法时如果没有准备好会自动调用此方法
- (void)play	开始播放
- (void)pause	暂停播放
- (void)stop	停止播放
- (void)beginSeekingForward	向前定位
- (void)beginSeekingBackward	向后定位
- (void)endSeeking	停止快进/快退

 

通知	说明
MPMoviePlayerScalingModeDidChangeNotification	视频缩放填充模式发生改变
MPMoviePlayerPlaybackDidFinishNotification	媒体播放完成或用户手动退出，具体完成原因可以通过通知userInfo中的key为MPMoviePlayerPlaybackDidFinishReasonUserInfoKey的对象获取
MPMoviePlayerPlaybackStateDidChangeNotification	播放状态改变，可配合playbakcState属性获取具体状态
MPMoviePlayerLoadStateDidChangeNotification	媒体网络加载状态改变
MPMoviePlayerNowPlayingMovieDidChangeNotification	当前播放的媒体内容发生改变
MPMoviePlayerWillEnterFullscreenNotification	将要进入全屏
MPMoviePlayerDidEnterFullscreenNotification	进入全屏后
MPMoviePlayerWillExitFullscreenNotification	将要退出全屏
MPMoviePlayerDidExitFullscreenNotification	退出全屏后
MPMoviePlayerIsAirPlayVideoActiveDidChangeNotification	当媒体开始通过AirPlay播放或者结束AirPlay播放
MPMoviePlayerReadyForDisplayDidChangeNotification	视频显示状态改变
MPMovieMediaTypesAvailableNotification	确定了媒体可用类型后
MPMovieSourceTypeAvailableNotification	确定了媒体来源后
MPMovieDurationAvailableNotification	确定了媒体播放时长后
MPMovieNaturalSizeAvailableNotification	确定了媒体的实际尺寸后
MPMoviePlayerThumbnailImageRequestDidFinishNotification	缩略图请求完成之后
MPMediaPlaybackIsPreparedToPlayDidChangeNotification	做好播放准备后

注：MPMoviePlayerController的状态信息并不是通过代理来和外界交互的，而是通过通知中心。

　3）代码示例

　　注：本例实现获取缩略图(视频第一帧画面)，点击缩略图播放视频

// VideoPlayerController.m文件
#import "VideoPlayerController.h"
#import <MediaPlayer/MediaPlayer.h>  // 导入框架
#import <AVFoundation/AVFoundation.h> // 使用AVURLAsset获取视频第一帧需要导入的框架

@interface VideoPlayerController ()

@property (nonatomic, strong) MPMoviePlayerController *moviePlayer; // 视频播放控制器
@property (nonatomic, strong) UIImageView *imageView; // 显示第一帧视频的图片
@property (nonatomic, assign) BOOL isThumbnailRequestFinished;  // 第一帧请求是否成功

@end

@implementation VideoPlayerController

#pragma mark - 懒加载
// 1.moviePlayer
- (MPMoviePlayerController *)moviePlayer
{
    if (!_moviePlayer) {
        // 获取视频URL
        NSURL *url = [self getNetworkUrl];
        // 根据URL初始化视频播放控制器
        _moviePlayer = [[MPMoviePlayerController alloc] initWithContentURL:url];
        _moviePlayer.view.frame = CGRectMake(0, 64, self.view.bounds.size.width, 200);
        // 将视频播放控制器的View添加到控制器的View上
        [self.view addSubview:_moviePlayer.view];
    }
    return _moviePlayer;
}
// 2.imageView
- (UIImageView *)imageView
{
    if (!_imageView) {
        CGFloat imageViewX = 0;
        CGFloat imageViewY = 10;
        CGFloat imageViewW = self.moviePlayer.view.bounds.size.width;
        CGFloat imageViewH = self.moviePlayer.view.bounds.size.height - imageViewY * 2;
        _imageView = [[UIImageView alloc] initWithFrame:CGRectMake(imageViewX, imageViewY, imageViewW, imageViewH)];
        _imageView.userInteractionEnabled = YES;
        // 添加点击手势
        UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(tapClick:)];
        [_imageView addGestureRecognizer:tap];
        [self.moviePlayer.view addSubview:_imageView];
    }
    return _imageView;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor blueColor];
    
    // [self thumbnailImageRequest];  // 请求第一帧视频画面
    [self thumbnailImageRequest:0.1]; // 请求第一帧视频画面
    [self addNotification]; // 注册通知
}

#pragma mark - 注册通知
- (void)addNotification
{
    // 监听播放状态发生改变的通知
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(moviePlayerPlaybackStateDidChange:) name:MPMoviePlayerPlaybackStateDidChangeNotification object:nil];
    // 监听播放完成的通知
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(moviePlayerPlaybackStateDidFinish:) name:MPMoviePlayerPlaybackDidFinishNotification object:nil];
    // 监听缩略图请求成功的通知
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(moviePlayerThumbnailRequestFinished:) name:MPMoviePlayerThumbnailImageRequestDidFinishNotification object:self.moviePlayer];
}

#pragma mark - 手势点击事件
// 点击第一帧视频播放
- (void)tapClick:(UITapGestureRecognizer *)tap
{
    // 判断缩略图是否请求成功
    if (!_isThumbnailRequestFinished) {
        return;
    }
    
    self.imageView.hidden = YES;
    [self.moviePlayer play];  // 播放
}

#pragma mark - 取得视频URL
- (NSURL *)getNetworkUrl
{
    NSString *urlStr = @"http://192.168.1.177:8080/HKGI/upload/001.mp4";
    urlStr = [urlStr stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
    NSURL *url = [NSURL URLWithString:urlStr];
    return url;
}

#pragma mark - 请求第一帧视频
// 1.第一种方法(使用MPMoviePlayerController生成缩略图)
// 方法1与方法2的区别：方法1在获取缩略图的时候会播放缩略图的那一帧，而方法2不会
- (void)thumbnailImageRequest
{
    // 获取0.1s缩略图
    [self.moviePlayer requestThumbnailImagesAtTimes:@[@0.1] timeOption:MPMovieTimeOptionNearestKeyFrame];
}
// 2.第二种方法(使用AVFoundation生成缩略图)
- (void)thumbnailImageRequest:(CGFloat )timeBySecond
{
    // 创建URL
    NSURL *url = [self getNetworkUrl];
    // 根据URL创建AVURLAsset
    AVURLAsset *urlAsset = [AVURLAsset assetWithURL:url];
    // 根据AVURLAsset创建
    AVAssetImageGenerator *imageGenerator = [AVAssetImageGenerator assetImageGeneratorWithAsset:urlAsset];
    
    // 截图
    // requestTime:缩略图创建时间
    // actualTime:缩略图实际生成的时间
    NSError *error = nil;
    // CMTime：电影时间信息的结构体(参数一：视频第几秒，参数二：每秒有多少帧)
    // 如果要动态的某一秒的第几帧可以使用CMTimeMake方法
    CMTime time = CMTimeMakeWithSeconds(timeBySecond, 10);
    // CMTime time = CMTimeMake(timeBySecond, 10);
    
    CMTime actualTime;
    CGImageRef cgImage = [imageGenerator copyCGImageAtTime:time actualTime:&actualTime error:&error];
    if (error) {
        NSLog(@"截取视频缩略图时发生错误，错误信息：%@",error.localizedDescription);
        return;
    }
    
    CMTimeShow(actualTime);
    // 转化为UIImage
    UIImage *image = [UIImage imageWithCGImage:cgImage];
    self.imageView.image = image;
    _isThumbnailRequestFinished = YES;
    
    // 保存到相册
    // UIImageWriteToSavedPhotosAlbum(image, nil, nil, nil);
    // CGImageRelease(cgImage);
}

#pragma mark - 通知事件
// 1.播放状态发生改变
- (void)moviePlayerPlaybackStateDidChange:(NSNotification *)notification
{
    switch (self.moviePlayer.playbackState) {
        case MPMoviePlaybackStatePlaying:
            NSLog(@"正在播放");
            break;
        case MPMoviePlaybackStatePaused:
            NSLog(@"暂停播放");
            break;
        case MPMoviePlaybackStateStopped:
            NSLog(@"停止播放");
            break;
        default:
            NSLog(@"播放状态：%d", self.moviePlayer.playbackState);
            break;
    }
}
// 2.播放完成
- (void)moviePlayerPlaybackStateDidFinish:(NSNotification *)notification
{
    NSLog(@"播放完成：%d", self.moviePlayer.playbackState);
    self.imageView.hidden = NO;
}
// 3.缩略图请求成功(该方法每次截图成功都会调用一次)(对于第一种方法获取的缩略图，会以通知形式返回)
- (void)moviePlayerThumbnailRequestFinished:(NSNotification *)notification
{
    NSLog(@"视频截图完成");
    UIImage *image = notification.userInfo[MPMoviePlayerThumbnailImageKey];
    self.imageView.image = image;
    _isThumbnailRequestFinished = YES;
    
    // 保存图片到相册(首次调用会请求用户获得访问相册权限)
    // UIImageWriteToSavedPhotosAlbum(image, nil, nil, nil);
}

#pragma mark - 销毁通知
- (void)dealloc
{
    // 移除所有通知监控
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

@end

2.MPMoviePlayerViewController(单独跳转控制器播放)

　1）说明

　　如果MPMoviePlayerController不作为嵌入视频播放(例如腾讯新闻中嵌入一个视频)，通常在播放时都是占满一个屏幕的，特别是在iPhone上。因此自iOS3.2以后，苹果自己封装了一个继承自UIViewController的控制器MPMoviePlayerViewController，专门用来全屏播放视频，这个控制器里面有一个属性moviePlayer和一个带有URL的初始化方法。同时它的内部也实现了一些作为模态视图展示所特有的功能。例如：默认是全屏模式展示，弹出后自动播放；作为模态窗口展示时，如果点击“Done”按钮会自动退出模态窗口等

　2）代码示例

　　注：本例实现获取缩略图(视频第一帧画面)，点击缩略图模态跳转播放视频控制器全屏开始播放 

// VideoController.m文件
#import "VideoController.h"
#import <MediaPlayer/MediaPlayer.h> // 导入框架
#import <AVFoundation/AVFoundation.h> // 使用AVURLAsset获取视频第一帧需要导入的框架

@interface VideoController ()

// 播放器视图控制器
@property (nonatomic, strong) MPMoviePlayerViewController *moviePlayerViewController;
// 显示第一帧视频的图片
@property (nonatomic, strong) UIImageView *imageView;
// 第一帧请求是否成功
@property (nonatomic, assign) BOOL isThumbnailRequestFinished;

@end

@implementation VideoController

#pragma mark - 懒加载
// 1.moviePlayerViewController
- (MPMoviePlayerViewController *)moviePlayerViewController
{
    if (!_moviePlayerViewController) {
        // 获取视频URL
        NSURL *url = [self getNetworkUrl];
        // 根据URL初始化视频播放控制器
        _moviePlayerViewController = [[MPMoviePlayerViewController alloc] initWithContentURL:url];
        // 注册通知
        [self addNotification];
    }
    return _moviePlayerViewController;
}
// 2.imageView
- (UIImageView *)imageView
{
    if (!_imageView) {
        CGFloat imageViewX = 20;
        CGFloat imageViewY = 80;
        CGFloat imageViewW = self.view.bounds.size.width - imageViewX * 2;
        CGFloat imageViewH = 200;
        _imageView = [[UIImageView alloc] initWithFrame:CGRectMake(imageViewX, imageViewY, imageViewW, imageViewH)];
        _imageView.userInteractionEnabled = YES;
        // 添加点击手势
        UITapGestureRecognizer *tap = [[UITapGestureRecognizer alloc] initWithTarget:self action:@selector(tapClick:)];
        [_imageView addGestureRecognizer:tap];
        [self.view addSubview:_imageView];
    }
    return _imageView;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    [self thumbnailImageRequest:0.1]; // 请求第一帧视频画面
}

#pragma mark - 注册通知
- (void)addNotification
{
    // 监听播放状态发生改变的通知
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(moviePlayerPlaybackStateDidChange:) name:MPMoviePlayerPlaybackStateDidChangeNotification object:nil];
    // 监听播放完成的通知
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(moviePlayerPlaybackStateDidFinish:) name:MPMoviePlayerPlaybackDidFinishNotification object:nil];
}

#pragma mark - 手势点击事件
// 点击第一帧视频播放
- (void)tapClick:(UITapGestureRecognizer *)tap
{
    // 判断缩略图是否请求成功
    if (!_isThumbnailRequestFinished) {
        return;
    }
    
    self.moviePlayerViewController = nil;
    [self presentMoviePlayerViewControllerAnimated:self.moviePlayerViewController];
}

#pragma mark - 请求第一帧视频画面
// 使用AVFoundation生成缩略图
- (void)thumbnailImageRequest:(CGFloat )timeBySecond
{
    // 创建URL
    NSURL *url = [self getNetworkUrl];
    // 根据URL创建AVURLAsset
    AVURLAsset *urlAsset = [AVURLAsset assetWithURL:url];
    // 根据AVURLAsset创建
    AVAssetImageGenerator *imageGenerator = [AVAssetImageGenerator assetImageGeneratorWithAsset:urlAsset];
    
    // 截图
    // requestTime:缩略图创建时间
    // actualTime:缩略图实际生成的时间
    NSError *error = nil;
    // CMTime：电影时间信息的结构体(参数一：视频第几秒，参数二：每秒有多少帧)
    // 如果要动态的某一秒的第几帧可以使用CMTimeMake方法
    CMTime time = CMTimeMakeWithSeconds(timeBySecond, 10);
    // CMTime time = CMTimeMake(timeBySecond, 10);
    
    CMTime actualTime;
    CGImageRef cgImage = [imageGenerator copyCGImageAtTime:time actualTime:&actualTime error:&error];
    if (error) {
        NSLog(@"截取视频缩略图时发生错误，错误信息：%@",error.localizedDescription);
        return;
    }
    
    CMTimeShow(actualTime);
    // 转化为UIImage
    UIImage *image = [UIImage imageWithCGImage:cgImage];
    self.imageView.image = image;
    _isThumbnailRequestFinished =  YES;
}

#pragma mark - 获取本地视频URL
- (NSURL *)getFileUrl
{
    NSString *urlStr = [[NSBundle mainBundle] pathForResource:@"1" ofType:@"mp4"];
    NSURL *url = [NSURL fileURLWithPath:urlStr];
    return url;
}

#pragma mark - 获取网络视频URL
- (NSURL *)getNetworkUrl
{
    NSString *urlStr = @"http://192.168.1.177:8080/HKGI/upload/001.mp4";
    urlStr = [urlStr stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
    NSURL *url = [NSURL URLWithString:urlStr];
    return url;
}

#pragma mark - 通知事件
// 1.播放状态发生改变
- (void)moviePlayerPlaybackStateDidChange:(NSNotification *)notification
{
    switch (self.moviePlayerViewController.moviePlayer.playbackState) {
        case MPMoviePlaybackStatePlaying:
            NSLog(@"正在播放");
            break;
        case MPMoviePlaybackStatePaused:
            NSLog(@"暂停播放");
            break;
        case MPMoviePlaybackStateStopped:
            NSLog(@"停止播放");
            break;
        default:
            NSLog(@"播放状态：%ld", self.moviePlayerViewController.moviePlayer.playbackState);
            break;
    }
}
// 2.播放完成
- (void)moviePlayerPlaybackStateDidFinish:(NSNotification *)notification
{
    NSLog(@"播放完成：%ld", self.moviePlayerViewController.moviePlayer.playbackState);
}

#pragma mark - 销毁通知
- (void)dealloc
{
    // 移除所有通知监控
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

@end

 注：这里需要强调一下，由于MPMoviePlayerViewController的初始化方法做了大量工作（例如设置URL、自动播放、添加点击Done完成的监控等），所以当再次点击播放弹出新的模态窗口的时如果不销毁之前的MPMoviePlayerViewController，那么新的对象就无法完成初始化，这样也就不能再次进行播放。定位到我们代码示例中就是在每次模态跳转播放控制器之前必须将它设置为nil，重新加载初始化一下(self.moviePlayerViewController = nil)

3.AVPlayer(通常用于自定义一个播放器)

　1）说明

　　a.MPMoviePlayerController足够强大，只需要写几行代码就能够完成一个播放器的功能；但是由于它的高度封装，使得我们自定义播放器变得相当复杂或是不可能完成。其实在这个时候，我们通常会使用AVFoundation框架的AVPlayer进行自定义播放器。因为它更加接近底层，灵活性也较强。

　　b.AVPlayer本身并不能显示视频，而且也不像MPMoviePlayerController有一个View属性。如果AVPlayer要显示，必须创建一个播放器层AVPlayerLayer用于展示。播放器层继承自CALayer。有了这个AVPlayerLayer，我们需要将它添加到控制器的layer中

　　c.AVPlayer的常用类：

　　　　AVAsset：主要用于获取多媒体信息，是一个抽象类，不能直接使用。

　　　　AVURLAsset：AVAsset的子类，可以根据一个URL路径创建一个包含媒体信息的AVURLAsset对象。

　　　　AVPlayerItem：一个媒体资源管理对象，管理视频的一些基本信息和状态(一个AVPlayerItem对应着一个视频资源)

　2）代码示例

// CustomAVPlayerController.m文件
#import "CustomAVPlayerController.h"
#import <AVFoundation/AVFoundation.h> // 需要导入的框架

@interface CustomAVPlayerController ()

// 播放器对象
@property (nonatomic, strong) AVPlayer *player;
// 播放器容器
@property (nonatomic, strong) UIView *containerView;
// 播放暂停按钮
@property (nonatomic, strong) UIButton *playOrPauseBtn;
// 播放进度
@property (nonatomic, strong) UIProgressView *progressView;
// 保存当前正在播放剧集的按钮
@property (nonatomic, strong) UIButton *currentBtn;

@end

@implementation CustomAVPlayerController

#pragma mark - 懒加载
// player
- (AVPlayer *)player
{
    if (!_player) {
        // 获取第1个视频文件(AVPlayerItem对象)
        AVPlayerItem *playerItem = [self getPlayerItemWithIndex:0];
        // 根据AVPlayerItem对象初始化播放器对象
        _player = [AVPlayer playerWithPlayerItem:playerItem];
        
        // 给播放器添加进度更新(定时器)
        [self addProgressObserver];
        // 给AVPlayerItem(视频文件对象)添加监控(KVO)
        [self addObserverToPlayerItem:playerItem];
    }
    return _player;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
    [self.player play]; // 播放
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    
    // containerView
    CGFloat containerViewX = 0;
    CGFloat containerViewY = 64;
    CGFloat containerViewW = self.view.bounds.size.width;
    CGFloat containerViewH = 250;
    _containerView = [[UIView alloc] initWithFrame:CGRectMake(containerViewX, containerViewY, containerViewW, containerViewH)];
    [self.view addSubview:_containerView];
    
    // 根据AVPlayer创建播放器层
    AVPlayerLayer *playerLayer = [AVPlayerLayer playerLayerWithPlayer:self.player];
    playerLayer.frame = _containerView.bounds;
    // 视频填充模式
    playerLayer.videoGravity = AVLayerVideoGravityResizeAspect;
    [_containerView.layer addSublayer:playerLayer];
    
    // playOrPauseBtn
    CGFloat playOrPauseBtnX = 20;
    CGFloat playOrPauseBtnY = CGRectGetMaxY(_containerView.frame);
    CGFloat playOrPauseBtnW = 40;
    CGFloat playOrPauseBtnH = 40;
    _playOrPauseBtn = [UIButton buttonWithType:UIButtonTypeCustom];
    _playOrPauseBtn.frame = CGRectMake(playOrPauseBtnX, playOrPauseBtnY, playOrPauseBtnW, playOrPauseBtnH);
    [_playOrPauseBtn setImage:[UIImage imageNamed:@"play"] forState:UIControlStateNormal];
    [_playOrPauseBtn setImage:[UIImage imageNamed:@"pause"] forState:UIControlStateSelected];
    [_playOrPauseBtn addTarget:self action:@selector(playOrPauseBtnClick:) forControlEvents:UIControlEventTouchUpInside];
    _playOrPauseBtn.selected = YES;
    [self.view addSubview:_playOrPauseBtn];
    
    // progressView
    CGFloat progressViewX = CGRectGetMaxX(_playOrPauseBtn.frame);
    CGFloat progressViewY = _playOrPauseBtn.frame.origin.y + _playOrPauseBtn.bounds.size.height / 2.0;
    CGFloat progressViewW = _containerView.bounds.size.width - progressViewX - _playOrPauseBtn.frame.origin.x;
    CGFloat progressViewH = 2;
    _progressView = [[UIProgressView alloc] initWithFrame:CGRectMake(progressViewX, progressViewY, progressViewW, progressViewH)];
    [self.view addSubview:_progressView];
    
    // bottomView
    CGFloat bottomViewX = _playOrPauseBtn.frame.origin.x;
    CGFloat bottomViewY = CGRectGetMaxY(_playOrPauseBtn.frame) + 10;
    CGFloat bottomViewW = _containerView.bounds.size.width - bottomViewX * 2;
    CGFloat bottomViewH = 70;
    UIView *bottomView = [[UIView alloc] initWithFrame:CGRectMake(bottomViewX, bottomViewY, bottomViewW, bottomViewH)];
    [self.view addSubview:bottomView];
    
    // textLabel
    CGFloat textLabelX = 0;
    CGFloat textLabelY = 0;
    CGFloat textLabelW = bottomView.bounds.size.width;
    CGFloat textLabelH = 30;
    UILabel *textLabel = [[UILabel alloc] initWithFrame:CGRectMake(textLabelX, textLabelY, textLabelW, textLabelH)];
    textLabel.text = @"播放列表";
    textLabel.font = [UIFont boldSystemFontOfSize:17];
    textLabel.textColor = [UIColor blueColor];
    [bottomView addSubview:textLabel];
    
    // 循环创建btn
    NSArray *movieNames = @[@"001", @"002", @"003", @"004"];
    for (int i = 0; i < movieNames.count; i++) {
        CGFloat btnW = 55;
        CGFloat btnH = 35;
        CGFloat btnX = textLabel.frame.origin.x + (btnW + 5) * i;
        CGFloat btnY = CGRectGetMaxY(textLabel.frame);
        UIButton *btn = [UIButton buttonWithType:UIButtonTypeSystem];
        btn.frame = CGRectMake(btnX, btnY, btnW, btnH);
        [btn setTitle:movieNames[i] forState:UIControlStateNormal];
        btn.titleLabel.font = [UIFont boldSystemFontOfSize:13];
        btn.tintColor = [UIColor blueColor];
        btn.backgroundColor = [UIColor grayColor];
        btn.tag = 100 + i;
        [btn addTarget:self action:@selector(btnClick:) forControlEvents:UIControlEventTouchUpInside];
        [bottomView addSubview:btn];
        if (i == 0) {
            _currentBtn = btn;
            _currentBtn.backgroundColor = [UIColor redColor];
        }
    }
}

#pragma mark - 点击事件
// 1.播放暂停按钮
- (void)playOrPauseBtnClick:(UIButton *)sender
{
    // 说明暂停
    if(self.player.rate == 0){
        sender.selected = YES;
        [self.player play]; // 播放
    
    // 正在播放
    }else if(self.player.rate == 1){
        sender.selected = NO;
        [self.player pause]; // 暂停
    }
}
// 2.播放列表剧集按钮
- (void)btnClick:(UIButton *)sender
{
    // 进度归0
    _progressView.progress = 0;
    // 切换背景
    _currentBtn.backgroundColor = [UIColor grayColor];
    _currentBtn = sender;
    _currentBtn.backgroundColor = [UIColor redColor];
    // 移除播放完毕通知
    [self removeNotification];
    // 移除当前正在播放的视频文件的属性监听(KVO)
    [self removeObserverFromPlayerItem:self.player.currentItem];
    // 获得切换后的视频文件对象(AVPlayerItem对象)
    AVPlayerItem *playerItem = [self getPlayerItemWithIndex:(int)(sender.tag - 100)];
    // 给AVPlayerItem(视频文件对象)添加监控(KVO)
    [self addObserverToPlayerItem:playerItem];
    // 切换视频
    [self.player replaceCurrentItemWithPlayerItem:playerItem];
    // 注册通知
    [self addNotification];
}

#pragma mark - 根据索引取得AVPlayerItem对象
// 一个AVPlayerItem对象对应一个视频文件
- (AVPlayerItem *)getPlayerItemWithIndex:(int)index
{
    NSArray *movieNames = @[@"001", @"002", @"003", @"004"];
    NSString *urlStr = [NSString stringWithFormat:@"http://192.168.1.177:8080/HKGI/upload/%@.mp4", movieNames[index]];
    urlStr = [urlStr stringByAddingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
    NSURL *url = [NSURL URLWithString:urlStr];
    // 根据视频URL创建视频文件对象(AVPlayerItem对象)
    AVPlayerItem *playerItem = [AVPlayerItem playerItemWithURL:url];
    return playerItem;
}

#pragma mark - 监控
// 1.给播放器添加进度更新(定时器)
- (void)addProgressObserver
{
    AVPlayerItem *playerItem = self.player.currentItem;
    // 这里设置每秒更新一次进度值
    __weak CustomAVPlayerController *weakSelf = self;
    [self.player addPeriodicTimeObserverForInterval:CMTimeMake(1.0, 1.0) queue:dispatch_get_main_queue() usingBlock:^(CMTime time) {
        float currentTime = CMTimeGetSeconds(time);
        float totalTime = CMTimeGetSeconds(playerItem.duration);
        // 判断当前播放时间是否为0
        if (currentTime) {
            [weakSelf.progressView setProgress:(currentTime / totalTime) animated:YES];
        }
    }];
}
// 2.给AVPlayerItem(视频文件对象)添加监控(KVO)
- (void)addObserverToPlayerItem:(AVPlayerItem *)playerItem
{
    // 监控状态属性，注意AVPlayer也有一个status属性，通过监控它的status也可以获得播放状态
    [playerItem addObserver:self forKeyPath:@"status" options:NSKeyValueObservingOptionNew context:nil];
    // 监控网络加载情况属性
    [playerItem addObserver:self forKeyPath:@"loadedTimeRanges" options:NSKeyValueObservingOptionNew context:nil];
}
// 添加播放器通知(通知中心)
- (void)addNotification
{
    // 给AVPlayerItem添加播放完成通知
    [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(playbackFinished:) name:AVPlayerItemDidPlayToEndTimeNotification object:self.player.currentItem];
}

#pragma mark - 通过KVO监控播放器状态
// 参数1：keyPath 监控属性
// 参数2：object  监视器
// 参数3：change  状态改变
// 参数4：context 上下文
- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context
{
    AVPlayerItem *playerItem = object;
    if ([keyPath isEqualToString:@"status"]) {
        AVPlayerStatus status= [change[@"new"] intValue];
        if(status == AVPlayerStatusReadyToPlay) {
            NSLog(@"正在播放...，视频总长度:%.2f", CMTimeGetSeconds(playerItem.duration));
        }
        
    } else if([keyPath isEqualToString:@"loadedTimeRanges"]) {
        NSArray *array = playerItem.loadedTimeRanges;
        CMTimeRange timeRange = [array[0] CMTimeRangeValue]; // 本次缓冲时间范围
        float startSeconds = CMTimeGetSeconds(timeRange.start);
        float durationSeconds = CMTimeGetSeconds(timeRange.duration);
        NSTimeInterval totalBuffer = startSeconds + durationSeconds; // 缓冲总长度
        NSLog(@"共缓冲：%.2f", totalBuffer);
    }
}

#pragma mark - 播放完成通知
- (void)playbackFinished:(NSNotification *)notification
{
    NSLog(@"视频播放完成.");
}

#pragma mark - 移除KVO监听的属性
- (void)removeObserverFromPlayerItem:(AVPlayerItem *)playerItem
{
    // KVO监听播放状态属性status
    [playerItem removeObserver:self forKeyPath:@"status"];
    // KVO监听加载进度属性loadedTimeRanges
    [playerItem removeObserver:self forKeyPath:@"loadedTimeRanges"];
}

#pragma mark - 移除通知
- (void)removeNotification
{
    [[NSNotificationCenter defaultCenter] removeObserver:self];
}

#pragma mark - 销毁方法
- (void)dealloc
{
    // 移除KVO监听的属性
    [self removeObserverFromPlayerItem:self.player.currentItem];
    // 移除通知
    [self removeNotification];
}

@end

 

三、摄像头

1.UIImageViewPickerController(可用于选取相册相片、拍照和视频录制)

 　1）说明

　　UIImageViewPickerController继承自UINavigationController，主要可用于选取相册相片、拍照和视频录制

　2）属性和方法

属性	说明
@property (nonatomic) UIImagePickerControllerSourceType sourceType	拾取源类型，sourceType是枚举类型： UIImagePickerControllerSourceTypePhotoLibrary：照片库(默认值) UIImagePickerControllerSourceTypeCamera：摄像头 UIImagePickerControllerSourceTypeSavedPhotosAlbum：相簿
@property (nonatomic, copy) NSArray  *mediaTypes	媒体类型(拍照时可以不用设置；但是当要录像的时候必须设置) 默认情况下此数组包含： kUTTypeImage：图片 kUTTypeVideo：视频不带声音 kUTTypeMovie：视频带有声音
@property (nonatomic) NSTimeInterval  videoMaximumDuration	视频最大录制时长(默认为10s)
@property (nonatomic) UIImagePickerControllerQualityType  videoQuality	视频质量，枚举类型： UIImagePickerControllerQualityTypeHigh：高清质量 UIImagePickerControllerQualityTypeMedium：中等质量，适合WiFi传输 UIImagePickerControllerQualityTypeLow：低质量，适合蜂窝网传输 UIImagePickerControllerQualityType640x480：640*480 UIImagePickerControllerQualityTypeIFrame1280x720：1280*720 UIImagePickerControllerQualityTypeIFrame960x540：960*540
@property (nonatomic) BOOL  showsCameraControls	是否显示摄像头控制面板(默认为YES)
@property (nonatomic, retain) UIView  *cameraOverlayView	摄像头上覆盖的视图，可用通过这个视频来自定义拍照或录像界面
@property (nonatomic) CGAffineTransform  cameraViewTransform	摄像头形变
@property (nonatomic) UIImagePickerControllerCameraCaptureMode cameraCaptureMode	摄像头捕获模式，捕获模式是枚举类型： UIImagePickerControllerCameraCaptureModePhoto：拍照模式 UIImagePickerControllerCameraCaptureModeVideo：视频录制模式
@property (nonatomic) UIImagePickerControllerCameraDevice cameraDevice	摄像头设备，cameraDevice是枚举类型： UIImagePickerControllerCameraDeviceRear：前置摄像头 UIImagePickerControllerCameraDeviceFront：后置摄像头
@property (nonatomic) UIImagePickerControllerCameraFlashMode cameraFlashMode	闪光灯模式，枚举类型： UIImagePickerControllerCameraFlashModeOff：关闭闪光灯 UIImagePickerControllerCameraFlashModeAuto：闪光灯自动 UIImagePickerControllerCameraFlashModeOn：打开闪光灯

 

类方法	说明
+ (BOOL)isSourceTypeAvailable:(UIImagePickerControllerSourceType)sourceType	指定的源类型是否可用，sourceType是枚举类型： UIImagePickerControllerSourceTypePhotoLibrary：照片库 UIImagePickerControllerSourceTypeCamera：摄像头 UIImagePickerControllerSourceTypeSavedPhotosAlbum：相簿
+ (NSArray *)availableMediaTypesForSourceType:(UIImagePickerControllerSourceType)sourceType	指定的源设备上可用的媒体类型，一般就是图片和视频
+ (BOOL)isCameraDeviceAvailable:(UIImagePickerControllerCameraDevice)cameraDevice	指定的摄像头是否可用，cameraDevice是枚举类型： UIImagePickerControllerCameraDeviceRear：前置摄像头 UIImagePickerControllerCameraDeviceFront：后置摄像头
+ (BOOL)isFlashAvailableForCameraDevice:(UIImagePickerControllerCameraDevice)cameraDevice	指定摄像头的闪光灯是否可用
+ (NSArray *)availableCaptureModesForCameraDevice:(UIImagePickerControllerCameraDevice)cameraDevice	获得指定摄像头上的可用捕获模式，捕获模式是枚举类型： UIImagePickerControllerCameraCaptureModePhoto：拍照模式 UIImagePickerControllerCameraCaptureModeVideo：视频录制模式

 

对象方法	说明
- (void)takePicture	编程方式拍照
- (BOOL)startVideoCapture	编程方式录制视频
- (void)stopVideoCapture	编程方式停止录制视频

 

代理方法	说明
- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary *)info	媒体拾取完成
- (void)imagePickerControllerDidCancel:(UIImagePickerController *)picker	取消拾取

 

扩展方法（主要用于保存照片、视频到相簿）	说明
UIImageWriteToSavedPhotosAlbum(UIImage *image, id completionTarget, SEL completionSelector, void *contextInfo)	保存照片到相簿
UIVideoAtPathIsCompatibleWithSavedPhotosAlbum(NSString *videoPath)	能否将视频保存到相簿
void UISaveVideoAtPathToSavedPhotosAlbum(NSString *videoPath, id completionTarget, SEL completionSelector, void *contextInfo)	保存视频到相簿

 　3）如果使用UIImagePickerController拍照或是录制视频，使用步骤如下

　　a.创建UIImagePickerController对象

　　b.指定拾取源：选择照片时指定拾取源是照片或是相簿，拍照和录制指定拾取源为摄像头类型

　　c.拍照和录制视频，需要指定摄像头：前置摄像头或者后置摄像头

　　d.设置媒体类型mediaType，注意如果是录像必须设置；如果是拍照，次步骤可省略，因为mediaType默认包含kUTTypeImage(注意媒体类型定义在MobileCoreServices.framework中)

　　e.指定捕捉模式、拍照或者录制视频(视频录制时必须先设置媒体类型再设置捕捉模式)

　　f.展示UIImagePickerController(通常以模态窗口形式打开)

　　g.拍照和录制视频结束后在代理方法中展示/保存照片或视频

　4）代码实例

// ImagePickerController.m文件
#import "ImagePickerController.h"
#import <MobileCoreServices/MobileCoreServices.h>
#import <AVFoundation/AVFoundation.h>

@interface ImagePickerController ()<UIImagePickerControllerDelegate, UINavigationControllerDelegate>

@property (nonatomic, assign) int isVideo; // 是否录制视频(1：录制视频 0：拍照)
@property (nonatomic, strong) UIImagePickerController *imagePicker;
@property (nonatomic, strong) UIImageView *photoImageView; // 照片展示视图
@property (nonatomic, strong) AVPlayer *player; // 播放器(用于录制完视频后播放视频)

@end

@implementation ImagePickerController

#pragma mark - 懒加载
// imagePicker
- (UIImagePickerController *)imagePicker
{
    if (!_imagePicker) {
        _imagePicker = [[UIImagePickerController alloc] init];
        // 设置UIImagePickerController的拾取源(这里是摄像头)
        _imagePicker.sourceType = UIImagePickerControllerSourceTypeCamera;
        // 设置使用哪一个摄像头(这里设置的是后置摄像头)
        _imagePicker.cameraDevice = UIImagePickerControllerCameraDeviceRear;
        // 判断当前用户设置是视频录制，还是拍照(1：视频录制 0：拍照)
        if (_isVideo) {
            // 视频录制必须设置媒体类型数组(当前设置为视频且带有声音)
            _imagePicker.mediaTypes = @[(NSString *)kUTTypeMovie];
            // 设置视频质量
            _imagePicker.videoQuality = UIImagePickerControllerQualityTypeIFrame1280x720;
            // 设置摄像头模式(当前设置为录制视频模式)
            _imagePicker.cameraCaptureMode = UIImagePickerControllerCameraCaptureModeVideo;
        
        } else {
            // 设置摄像头模式(当前设置为拍照模式)
            _imagePicker.cameraCaptureMode = UIImagePickerControllerCameraCaptureModePhoto;
        }
        // 允许编辑
        _imagePicker.allowsEditing = YES;
        // 设置代理
        _imagePicker.delegate = self;
    }
    return _imagePicker;
}

- (void)viewDidLoad
{
    [super viewDidLoad];
    
    [self initUI]; // 界面
}

#pragma mark - 界面
- (void)initUI
{
    self.view.backgroundColor = [UIColor whiteColor];
    
    // photoImageView
    CGFloat photoImageViewX = 0;
    CGFloat photoImageViewY = 64;
    CGFloat photoImageViewW = self.view.bounds.size.width;
    CGFloat photoImageViewH = 250;
    _photoImageView = [[UIImageView alloc] initWithFrame:CGRectMake(photoImageViewX, photoImageViewY, photoImageViewW, photoImageViewH)];
    _photoImageView.userInteractionEnabled = YES;
    [self.view addSubview:_photoImageView];
    
    // btn
    CGFloat btnW = 100;
    CGFloat btnH = 30;
    CGFloat btnX = (self.view.bounds.size.width - btnW) / 2.0;
    CGFloat btnY = CGRectGetMaxY(_photoImageView.frame) + 20;
    UIButton *btn = [UIButton buttonWithType:UIButtonTypeSystem];
    btn.frame = CGRectMake(btnX, btnY, btnW, btnH);
    [btn setTitle:@"调取摄像头" forState:UIControlStateNormal];
    btn.tintColor = [UIColor blueColor];
    btn.backgroundColor = [UIColor grayColor];
    btn.titleLabel.font = [UIFont boldSystemFontOfSize:15];
    [btn addTarget:self action:@selector(btnClick:) forControlEvents:UIControlEventTouchUpInside];
    [self.view addSubview:btn];
   
    // 当前程序为录制视频
    _isVideo = YES;
}

#pragma mark - 点击事件
// 点击调取摄像头
- (void)btnClick:(UIButton *)btn
{
    if ([[[UIDevice currentDevice] systemVersion] floatValue] >= 8.0) {
        self.modalPresentationStyle = UIModalPresentationOverCurrentContext;
    }
    [self presentViewController:self.imagePicker animated:YES completion:nil];
}

#pragma mark - 代理方法<UIImagePickerControllerDelegate, UINavigationControllerDelegate>
// 1.完成
- (void)imagePickerController:(UIImagePickerController *)picker didFinishPickingMediaWithInfo:(NSDictionary<NSString *,id> *)info
{
    // 获取媒体类型
    NSString *mediaType = info[UIImagePickerControllerMediaType];
    if ([mediaType isEqualToString:(NSString *)kUTTypeImage]) {
        UIImage *image = nil;
        // 如果允许编辑，则获得编辑后的图片，否则获取原始图片
        if (self.imagePicker.allowsEditing) {
            // 获得编辑后的图片
            image = info[UIImagePickerControllerEditedImage];
        } else {
            // 获取原始图片
            image = info[UIImagePickerControllerOriginalImage];
        }
        
        if (image) {
            // 显示照片
            self.photoImageView.image = image;
            // 保存照片到相册
            UIImageWriteToSavedPhotosAlbum(image, nil, nil, nil);
        }
    
    } else if ([mediaType isEqualToString:(NSString *)kUTTypeMovie]) {
        // 获取录制视频路径
        NSURL *url = info[UIImagePickerControllerMediaURL];
        NSString *urlStr = url.path;
        if (UIVideoAtPathIsCompatibleWithSavedPhotosAlbum(urlStr)) {
            // 保存视频到相簿，注意也可以使用ALAssetsLibrary来保存
            UISaveVideoAtPathToSavedPhotosAlbum(urlStr, self, @selector(video:didFinishSavingWithError:contextInfo:), nil);
        }
    }
    [self dismissViewControllerAnimated:YES completion:nil];
}
// 2.取消
- (void)imagePickerControllerDidCancel:(UIImagePickerController *)picker
{
    NSLog(@"取消");
}

#pragma mark - 视频保存后的回调
- (void)video:(NSString *)videoPath didFinishSavingWithError:(NSError *)error contextInfo:(void *)contextInfo
{
    if (error) {
        NSLog(@"保存视频过程中发生错误，错误信息:%@",error.localizedDescription);
        
    } else {
        NSLog(@"视频保存成功.");
        // 录制完之后自动播放
        NSURL *url = [NSURL fileURLWithPath:videoPath];
        _player = [AVPlayer playerWithURL:url];
        AVPlayerLayer *playerLayer = [AVPlayerLayer playerLayerWithPlayer:_player];
        playerLayer.frame = self.photoImageView.bounds;
        [self.photoImageView.layer addSublayer:playerLayer];
        [_player play];
    }
}

@end

2.AVFoundation的拍照和视频录制(可自定义)

　1）说明

　　UIImagePickerController的功能很强大，但是它与MPMoviePlayerController类似，由于它的高度封装性，要进行某些自定义工作就比较复杂了。那么如果需要自定义，我们可以使用AVFoundation来实现。AVFoundation框架中提供了很多现成的播放器和录音机，但是事实上它还是提供了一些更底层的内容供开发者使用。因为AVFoundation框架中抽了很多底层输入、输出设备打交道的类，依靠这些类开发人员面对的不再是封装好的音频播放器(AVAudioPlayer)、录音机(AVAudioRecorder)、视频(包括音频)播放器(AVPlayer)，而是输入设备(例如：麦克风、摄像头)、输出设备(图片、视频)等。

　2）AVFoundation拍照和视频录制的相关类：

　　a.AVCaptureSession：媒体(音、视频)捕获会话，负责把捕获的音视频数据输出到输出设备中。一个AVCaptureSession可以有多个输入输出

　　b.AVCaptureDevice：输入设备，包括麦克风、摄像头，通过该对象可以设置物理设备的一些属性（例如相机聚焦、白平衡等）。

　　c.AVCaptureDeviceInput：设备输入数据管理对象，可以根据AVCaptureDevice创建对应的AVCaptureDeviceInput对象，该对象将会被添加到AVCaptureSession

　　d.AVCaptureOutput：输出数据管理对象，用于接收各类输出数据，通常使用对应的子类AVCaptureAudioDataOutput、AVCaptureStillImageOutput、AVCaptureVideoDataOutput、AVCaptureFileOutput，该对象将会被添加到AVCaptureSession中管理。注意：前面几个对象的输出数据都是NSData类型，而AVCaptureFileOutput代表数据以文件形式输出，类似的，AVCcaptureFileOutput也不会直接创建使用，通常会使用其子类：AVCaptureAudioFileOutput、AVCaptureMovieFileOutput。当把一个输入或者输出添加到AVCaptureSession之后，AVCaptureSession就会在所有相符的输入、输出设备之间建立连接(AVCaptionConnection)

　　e.AVCaptureVideoPreviewLayer：相机拍摄预览图层，是CALayer的子类，使用该对象可以实时查看拍照或视频录制效果，创建该对象需要指定对应的AVCaptureSession对象。

　3）使用AVFoundation拍照和录制视频的一般步骤

　　a.创建AVCaptureSession对象

　　b.使用AVCaptureDevice的静态方法获得需要使用的设备，例如：拍照和录像就需要获得摄像头设备，录音就要获得麦克风设备

　　c.利用输入设备AVCaptureDevice初始化AVCaptureDeviceInput对象

　　d.初始化输出数据管理对象，如果要拍照就初始化AVCaptureStillImageOutput对象；如果拍摄视频就初始化AVCaptureMovieFileOutput对象

　　e.将数据输入对象AVCaptureDeviceInput、数据输出对象AVCaptureOutput添加到媒体会话管理对象AVCaptureSession中

　　f.创建视频预览图层AVCaptureVideoPreviewLayer并指定媒体会话，添加图层到显示容器中，调用AVCaptureSession的startRunning方法开始捕获

　　g.将捕获的音频或视频数据输出到指定问件

　4）代码示例(这里就不做详细写啦，关联博客：http://www.cnblogs.com/kenshincui/p/4186022.html#uiImagePickerController)

 

四、总结