背景

VoIP应用中，需要在通话端进行视频播放，同时该视频又不进入到VoIP声音中，避免产生回音现象。

参考

• AudioUnit官方文档
• AudioTapProcessor官方Demo

解法

iOS provides three I/O (input/output) units. The vast majority of audio-unit applications use the Remote I/O unit, which connects to input and output audio hardware and provides low-latency access to individual incoming and outgoing audio sample values. For VoIP apps, the Voice-Processing I/O unit extends the Remote I/O unit by adding acoustic echo cancelation and other features. To send audio back to your application rather than to output audio hardware, use the Generic Output unit.

通过Subtype为kAudioUnitSubType_VoiceProcessingIO和kAudioUnitSubType_RemoteIO的AudioUnit来输出音频，可以使用上苹果自带的回音消除能力

基本思路

• 如果AVPlayer使用AudioUnit，直接Hook改变subType完成。
• 从AVPlayer解码过程中取到实时音频数据，直接转推到另一个AudioUnit播放出来，这种方案要是能通，Seek等可以默认实现对齐。
• 保底方案，从AVPlayer取出PCM文件，做内存或者文件缓存，单独再播一份，需要手动对齐媒体时间。
• 保底方案，使用AVPlayer播视频，同时直接再解码一份，光播音频的，需要手动对齐媒体时间。

尝试一

首先是看到官网中的架构图，第一反应肯定是AVPlayer的音频播放也是基于AudioUnit，那就好办了

直接Hook一下AudioUnit的几个核心函数，然后替换一下Unit初始化的subType。都是C函数，这里要使用到fishhook。要是hook

+(void)load{
    int success = rebind_symbols((struct rebinding[1]){{"AudioOutputUnitStart", fg_AudioOutputUnitStart, (void *)&origin_AudioOutputUnitStart}}, 1);
    DebugLog(@"%@",@(success));
}

分别尝试了

• AUGraphAddNode
• AudioOutputUnitStart
• AudioComponentInstanceNew
• AudioUnitSetProperty
  发现AVPlayer均没有实现，于是这个方案失败告终。

尝试二

参考了苹果的AudioTapProcessorDEMO，发现可以使用AudioMix方案来取到实时的音频数据，那转推一份就好了。
首先从AVPlayer的KVO中监听状态，获得音轨。

- (void)observeValueForKeyPath:(NSString *)keyPath ofObject:(id)object change:(NSDictionary *)change context:(void *)context {
    if (object == self.player.currentItem) {
        if ([keyPath isEqualToString:@"status"]) {
            if (self.player.currentItem.status == AVPlayerItemStatusReadyToPlay) {
                //分离音频
                for (AVPlayerItemTrack* track in self.player.currentItem.tracks) {
                    if([track.assetTrack.mediaType isEqualToString:AVMediaTypeAudio]){
                        [self beginRecordingAudioFromTrack:track.assetTrack];
                    }
                }
            }
        }
    }
}

根据音轨生成AudioMix，赋值给PlayerItem

    AVMutableAudioMix *audioMix = [AVMutableAudioMix audioMix];
    if (audioMix)
    {
        AVMutableAudioMixInputParameters *audioMixInputParameters = [AVMutableAudioMixInputParameters audioMixInputParametersWithTrack:self.audioAssetTrack];
        if (audioMixInputParameters)
        {
            MTAudioProcessingTapCallbacks callbacks;
            
            callbacks.version = kMTAudioProcessingTapCallbacksVersion_0;
            callbacks.clientInfo = (__bridge void *)self,
            callbacks.init = tap_InitCallback;
            callbacks.finalize = tap_FinalizeCallback;
            callbacks.prepare = tap_PrepareCallback;
            callbacks.unprepare = tap_UnprepareCallback;
            callbacks.process = tap_ProcessCallback;
            
            MTAudioProcessingTapRef audioProcessingTap;
            if (noErr == MTAudioProcessingTapCreate(kCFAllocatorDefault, &callbacks, kMTAudioProcessingTapCreationFlag_PostEffects, &audioProcessingTap))
            {
                audioMixInputParameters.audioTapProcessor = audioProcessingTap;
                
                CFRelease(audioProcessingTap);
                
                audioMix.inputParameters = @[audioMixInputParameters];
                //赋值
                self.player.currentItem.audioMix = audioMix;
            }
        }
    }

在Prepare回调中获取音频格式信息，同时新建我们的outPutUnit

static void tap_PrepareCallback(MTAudioProcessingTapRef tap, CMItemCount maxFrames, const AudioStreamBasicDescription *processingFormat)
{
    AVAudioTapProcessorContext *context = (AVAudioTapProcessorContext *)MTAudioProcessingTapGetStorage(tap);
    OSStatus status = noErr;
    AudioComponentDescription outputUnitDescription;
    outputUnitDescription.componentType = kAudioUnitType_Output;
    outputUnitDescription.componentSubType = kAudioUnitSubType_VoiceProcessingIO;
    outputUnitDescription.componentManufacturer = kAudioUnitManufacturer_Apple;
    outputUnitDescription.componentFlags = 0;
    outputUnitDescription.componentFlagsMask = 0;
    AudioComponent audioComponent = AudioComponentFindNext(NULL, &outputUnitDescription);
    if(audioComponent){
        if (noErr == AudioComponentInstanceNew(audioComponent, &context->outputUnit)){
            UInt32 maxFPS = (UInt32)maxFrames;
        
            //设置input和output
            status = AudioUnitSetProperty(context->outputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Input,  0, processingFormat, sizeof(AudioStreamBasicDescription));
            UInt32 flag = 1;
            status = AudioUnitSetProperty(context->outputUnit, kAudioOutputUnitProperty_EnableIO, kAudioUnitScope_Output,  0, &flag, sizeof(flag));
            AudioUnitSetProperty(context->outputUnit, kAudioUnitProperty_StreamFormat, kAudioUnitScope_Output, 0, processingFormat, sizeof(AudioStreamBasicDescription));
            //设置maxFrame
            status = AudioUnitSetProperty(context->outputUnit, kAudioUnitProperty_MaximumFramesPerSlice, kAudioUnitScope_Global, 0,&maxFPS, sizeof(maxFPS));
            //设置renderLoop
            AURenderCallbackStruct callbackStruct;
            callbackStruct.inputProcRefCon = (void *)tap;
            callbackStruct.inputProc = RenderCallback;
            status = AudioUnitSetProperty(context->outputUnit, kAudioUnitProperty_SetRenderCallback, kAudioUnitScope_Input, 0, &callbackStruct, sizeof(AURenderCallbackStruct));
            
            AudioUnitInitialize(context->outputUnit);
            //启动Unit
            AudioOutputUnitStart(context->outputUnit);
        }
    }
}

在process回调中获取并转存音频数据，尝试在这里直接把数据转发给outputUnit，会发现process的InputFrame(4096)和outputUnit的InputFrame(1024)不一致。
这说明process回调的以后，并没有直接开始播放音频，这部分音频数据会缓存在内存中，等到要播的时候再取出来。参考苹果的思路，我们也转存到内存中，然后把原始音频静音，直接抹除掉所有数据。

static void tap_ProcessCallback(MTAudioProcessingTapRef tap, CMItemCount numberFrames, MTAudioProcessingTapFlags flags, AudioBufferList *bufferListInOut, CMItemCount *numberFramesOut, MTAudioProcessingTapFlags *flagsOut)
{
    //不播放 手动增加frameout 转存data
    AVAudioTapProcessorContext *context = (AVAudioTapProcessorContext *)MTAudioProcessingTapGetStorage(tap);
    MYAudioTapProcessor *self = ((__bridge MYAudioTapProcessor *)context->self);
    OSStatus error = MTAudioProcessingTapGetSourceAudio(tap, numberFrames, bufferListInOut, flagsOut, NULL, numberFramesOut);
    if(error == noErr && bufferListInOut->mBuffers[0].mDataByteSize > 0){
        @synchronized (self) {
            
            self.currentTotalFrame += numberFrames;
            NSData* bufferData = [[NSData alloc] initWithBytes:bufferListInOut->mBuffers[0].mData length:bufferListInOut->mBuffers[0].mDataByteSize];
            //使用NSData可以实现内存区域的copy，类似memcpy。
            [self.totalBufferData appendData:bufferData];
        }
    }
    //清除原始音频数据 使之静音
    for (uint32_t i = 0; i < bufferListInOut->mNumberBuffers; ++i) {
         memset(bufferListInOut->mBuffers[i].mData, 0, bufferListInOut->mBuffers[i].mDataByteSize);
     }
     *numberFramesOut = 0;
}

最后在我们的回调中计算1024需要的bufferData，从总的buffer中取出

static OSStatus RenderCallback(void *userData, AudioUnitRenderActionFlags *ioActionFlags, const AudioTimeStamp *inTimeStamp, UInt32 inBusNumber, UInt32 inNumberFrames, AudioBufferList *ioData)
{
    AVAudioTapProcessorContext *context = (AVAudioTapProcessorContext *)MTAudioProcessingTapGetStorage(userData);
    MYAudioTapProcessor *self = ((__bridge MYAudioTapProcessor *)context->self);
    @synchronized (self) {
        if(self.currentPlayedFrame < self.currentTotalFrame){
            //是均匀的4
            uint64_t perFrameLength = self.totalBufferData.length / self.currentTotalFrame;
            NSData* playData = [self.totalBufferData subdataWithRange:NSMakeRange(perFrameLength*self.currentPlayedFrame, perFrameLength*inNumberFrames)];
            memcpy(ioData->mBuffers[0].mData, playData.bytes, playData.length);
            ioData->mBuffers[0].mDataByteSize = perFrameLength*inNumberFrames;
            ioData->mBuffers[0].mNumberChannels = 1;
            self.currentPlayedFrame += inNumberFrames;
            return noErr;
        }else{
            return -1;
        }
    }
}

其中的userData是我们在初始化的时候传入的对象。

注意点

• AudioUnit相关的操作必须在Audio线程中操作，可以在Tap的回调中操作，否则会导致线程死锁。
• AudioUnit开启必须释放。

AudioOutputUnitStop(self.outputUnit);
AudioUnitUninitialize(self.outputUnit);
AudioComponentInstanceDispose(self.outputUnit);

涉及到的LLDB命令

• br: 设置断点
• memory read: 读取内存原始值
• po: 打印变量，也可以执行函数并且获得返回值
• bt: 打印当前调用栈
• thread step over/in/out: 单步跳过/进入/跳出
• register: 寄存器操作
• next/ni/n/step/si: 同上

参考链接

• SQLCipher
• WCDB
• C函数形参列表与汇编寄存器的对应关系

0x00 准备工作

查看WCDB所用的SQLite的加密方式，直接在WCDB的README里写了:

Encryption Support: WCDB supports database encryption via SQLCipher.

于是查看SQLCipher的API，看到用的是sqlite3_key()和sqlite3_key_v2()这2个函数，在源码里搜索，找到调用，一共有两处，在WCTDatabase+Database.mm文件里

- (void)setCipherKey:(NSData *)cipherKey
{
    _database->setCipher(cipherKey.bytes, (int) cipherKey.length);
}

- (void)setCipherKey:(NSData *)cipherKey andCipherPageSize:(int)cipherPageSize
{
    _database->setCipher(cipherKey.bytes, (int) cipherKey.length, cipherPageSize);
}

然后是下面的C寄存器的含义对照表。其中函数参数也可以不用寄存器表示，可以直接$arg1/$arg2/$arg3来表示 。

0x01获取保存目录

开始用LLDB动态调试，首先Hook微信进程

$ ps aux | grep WeChat

// 25132   6.7  1.0  7341704 170876   ??  S    Fri04PM   8:36.19 /Applications/WeChat.app/Contents/MacOS/WeChat  进程id是25132

$ lldb -p 25132 //开始hook进程

(lldb) process attach --pid 25132
Process 25132 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = signal SIGSTOP
    frame #0: 0x00007fff6162722a libsystem_kernel.dylib`mach_msg_trap + 10
libsystem_kernel.dylib`mach_msg_trap:
->  0x7fff6162722a <+10>: retq
    0x7fff6162722b <+11>: nop

libsystem_kernel.dylib`mach_msg_overwrite_trap:
    0x7fff6162722c <+0>:  movq   %rcx, %r10
    0x7fff6162722f <+3>:  movl   $0x1000020, %eax          ; imm = 0x1000020
Target 0: (WeChat) stopped.

Executable module set to "/Applications/WeChat.app/Contents/MacOS/WeChat".
Architecture set to: x86_64h-apple-macosx.
(lldb)

进入LLDB命令行模式
打断点获取微信的数据库目录，看WCDB的初始化接口，[WCTDatabase [alloc] initWithPath:path];我们要获取path

(lldb) br set -n '[WCTDatabase initWithPath:]'
//输出
Breakpoint 1: where = WCDB`-[WCTDatabase(Database) initWithPath:], address = 0x0000000110b38676
(lldb) br list //查看断点
Current breakpoints:
1: names = {'[WCTDatabase initWithPath:]', '[WCTDatabase initWithPath:]'}, locations = 1, resolved = 1, hit count = 0
  1.1: where = WCDB`-[WCTDatabase(Database) initWithPath:], address = 0x0000000110b38676, resolved, hit count = 0

点击微信的备份文件，恢复聊天记录至手机或者管理备份文件来触发断点。

Process 25132 stopped
* thread #1, queue = 'com.apple.main-thread', stop reason = breakpoint 1.1
    frame #0: 0x0000000110b38676 WCDB`-[WCTDatabase(Database) initWithPath:]
WCDB`-[WCTDatabase(Database) initWithPath:]:
->  0x110b38676 <+0>: pushq  %rbp
    0x110b38677 <+1>: movq   %rsp, %rbp
    0x110b3867a <+4>: pushq  %r15
    0x110b3867c <+6>: pushq  %r14
Target 0: (WeChat) stopped.
(lldb) po $arg3 //或者po $rdx 打印第三个参数
/Users/xxxx/Library/Containers/com.tencent.xinWeChat/Data/Library/Application Support/com.tencent.xinWeChat/2.0b4.0.9/Backup/91f05ea8dc79f929613c0beb267b789a/75563957-B5FD-4CC5-90F4-0F36D91DD190/Backup.db

获取到备份的数据库位置，直接在finder中打开，发现一共有三个文件

• Backup.db
• BAK_0_MEDIA
• BAK_0_TEXT

为什么是第三个参数呢？
OC的对象方法调用，实际调用的是底层的objc_msgSend($arg1,$arg2,...),其中$arg1为调用者本身，$arg2为方法名，后面的参数表示传递的实际参数，因此是从$arg3开始的，可以打印整个寄存器和$arg1,$arg2出来看看

(lldb) register read
General Purpose Registers:
       rax = 0x00006000027b98e0
       rbx = 0x00007fff5fd16680  libobjc.A.dylib`objc_msgSend
       rcx = 0x0000000000000000
       rdx = 0x00006000012e63a0
       rdi = 0x00006000027b98e0
       rsi = 0x00007fff337c64f7  "initWithPath:"
       rbp = 0x00007ffee1a3f060
       rsp = 0x00007ffee1a3efb8
        r8 = 0x0000cc851f0d98e0
        r9 = 0x00000000000007fb
       r10 = 0x0000000110c78ee8  (void *)0x001d800110c78ec1
       r11 = 0x00007fcb9badab70
       r12 = 0x00006000037ca9c0
       r13 = 0x0000000000000000
       r14 = 0x00006000027b9a40
       r15 = 0x00006000037ca9c0
       rip = 0x0000000110b38676  WCDB`-[WCTDatabase(Database) initWithPath:]
    rflags = 0x0000000000000246
        cs = 0x000000000000002b
        fs = 0x0000000000000000
        gs = 0x0000000000000000
(lldb) po $arg1 //po $rdi
<WCTDatabase: 0x6000027b98e0>
(lldb) po $arg2 //po $rsi 
140734057178359 //字符串打印出被转成数字了，可以用memory read打印
(lldb) memory read $rsi
0x7fff337c64f7: 69 6e 69 74 57 69 74 68 50 61 74 68 3a 00 73 65  initWithPath:.se
0x7fff337c6507: 74 46 69 6c 65 6e 61 6d 65 3a 00 69 6d 61 67 65  tFilename:.image

因此实际的函数参数会从第三个$arg3开始。

用sqlitebrowser打开这个db文件，发现是SQLCipher加密，要输入密码。

0x02 获取sqlite3_key

继续加断点，如果加在sqlite3_key上，会发现拿不到PageSize，查看源码看调用链，pageSize是在void Database::setCipher(const void *key, int keySize, int pageSize)的时候接收的，断点打在setCipher上

(lldb) br set -n setCipher
(lldb) c //继续执行

触发到sqlite3_key的断点，
获取key和pageSize

(lldb) memory read $arg2
0x600003f8fa90: 64 64 30 36 33 35 65 63 65 62 35 37 39 35 32 66  dd0635eceb57952f
0x600003f8faa0: 31 62 35 65 63 31 65 64 33 37 38 30 36 65 31 30  1b5ec1ed37806e10

(lldb) po $arg3
32

(lldb) po $arg4
4096

key是dd0635eceb57952f1b5ec1ed37806e10,取32位，也就是整个字符串，页长度是4096.

打开数据库。
分析一下表，发现文本内容存在BAK_0_TEXT,媒体内容存在BAK_0_MEDIA，以偏移量记录某条消息，简单查看一下这2个文件，都是写二进制数据，看来还用了某种加密方式。

0x03 Todo

• 静态分析WeChat.app，获取打开两个加密文件的方法。

0x04 Update

有网友反馈key错误，跟了下发现是sqlitebrowser更新了，支持了最新的SQLCipher4算法，但是微信依旧使用的WCDB1.0.3，还是SQLCipher3，操作的时候先选择SQLCipher3，之后再选择custom，把pageSize改成响应大小即可。

html2canvas官方的配置介绍

ViewPort布局方案

页面采用ViewPort方案，解决iOS上的1px的边框问题，采用这个方案，在iOS上渲染出来的Dom会自动乘以devicePixelRatio，因此iOS上的Canvas相当于被直接放大了，没有出现模糊的情况。

var viewport = document.querySelector("meta[name=viewport]");
var deviceRatio = window.devicePixelRatio || 1;
var scale = 1.0/deviceRatio;
viewport.setAttribute('content', 'width=device-width,initial-scale='+scale + ', maximum-scale='+scale+', minimum-scale='+ scale +', user-scalable=no');

发现#id锚点异常，是因为CSS的属性text-size-adjust在作怪，导致，关掉即可。

-webkit-text-size-adjust: 100%;

安卓也想采用ViewPort方案，发现会引入更多的问题，首先是text-size-adjust导致的布局异常问题，可以通过关闭所有设备上的text-size-adjust解决

 -ms-text-size-adjust: 100%;
 -webkit-text-size-adjust: 100%;
 text-size-adjust: 100%;

但是依旧会发现在某些设备上有布局问题，还有因为这个text-size-adjust导致的闪动问题，以及滑动卡顿问题(devicePixelRatio太大了导致原始dom的尺寸太大渲染不流畅)。找了一圈后发现手淘的使用Flexible实现手淘H5页面的终端适配在安卓上的这个值始终认为是0，看来是不好走通了。

其中initial-dpr会把dpr强制设置为给定的值。如果手动设置了dpr之后，不管设备是多少的dpr，都会强制认为其dpr是你设置的值。在此不建议手动强制设置dpr，因为在Flexible中，只对iOS设备进行dpr的判断，对于Android系列，始终认为其dpr为1。

到这里iOS不用任何配置直接使用Html2Canvas就可以画出清晰的图了。
安卓还需要另外适配。

图片模糊问题

html2canvas一开始用的最新版本，发现dom在屏幕之外的部分始终无法绘制，调了半天最后换了个版本(往下降了一个版本)直接就好了。目前项目中使用的是1.0.0-alpha.12。

"html2canvas": "^1.0.0-alpha.12"

1. 设置html2canvas的选项

const html2canvasOpts = {
  backgroundColor: null,
  useCORS: $fn.isDev(),
  allowTaint: $fn.isDev(),
  scale: window.devicePixelRatio || 1,
  ignoreElements: (element) => {
    if(element.className.indexOf('no-share-element') > -1){
      return true;
    }
    return false;
  },
  copyStyles: true,
  removeContainer: true
}

主要是scale，需要引入devicePixelRatio，即可保证canvas清晰。

2. 不要使用background-image:url()属性，实验发现用这个属性渲染出来的图片都很糊，用img标签就好了。

其他问题

跨域问题

由于涉及到外源图片，目前是通过后台写了一个接口做图片下载后pipe()来解决的，在开发环境的时候直接打开跨域和允许污染Canvas的属性

useCORS: $fn.isDev(), //允许跨域
allowTaint: $fn.isDev(), //允许污染画布

这样在开发环境只能看到Canvas却无法调用canvas.toDataURL("image/png");函数。

正式环境将所有的图片替换成接口调用，使之同源

if(!isDev()){
    coverUrl = '/api/fetchImage?src='+encodeURIComponent(coverUrl);
}

接口层代码，express侧

//使用http或者https或者request库直接请求，然后直接
response.pipe(res)

注意需要白名单和各种过滤规则，否则就是典型的ssrf了。

AutoLayout和手动计算高度

毫无疑问，使用AutoLayout会明显的比手动计算高度慢，那么我为什么要用AutoLayout呢，因为实在太方便了，而且视图太复杂，产品改的太频繁，手动计算实在工作量太大，维护起来超级麻烦。
而且新的技术出来了，不用不是亏了吗。

方案

1.缓存高度

既然手动计算高度更快，那就在Reuse的时候用AutoLayout帮我们算过后的高度就行了，缓存一个高度字典(或者数组)，在算完渲染出来的时候取高度，在取高度的时候做个判断就行。

//保存高度
- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath{
    [_cellHeightsDic setObject:@(cell.height) forKey:indexPath];
}
//设置高度
-(CGFloat)tableView:(UITableView *)tableView estimatedHeightForRowAtIndexPath:(NSIndexPath *)indexPath{
    NSNumber *height = [_cellHeightsDic objectForKey:indexPath];
    if (height) return height.doubleValue;
    return 400;
}
-(CGFloat)tableView:(UITableView *)tableView heightForRowAtIndexPath:(NSIndexPath *)indexPath{
    NSNumber *height = [_cellHeightsDic objectForKey:indexPath];
    if (height) return height.doubleValue;
    return UITableViewAutomaticDimension;
}

2.图片和内容懒渲染

看不见的东西就不要让他渲染出来，这一步的优化是基于cellForRowAtIndexPath函数比willDisplayCell会先调用，如果在构造cell的时候就把所有内容填充上去，是一种浪费。因此可以把很重的内容，比如图片放到willDisplayCell的时候再加载。

- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath{
    [_cellHeightsDic setObject:@(cell.height) forKey:indexPath];
    [cell willDisplay];
}
-(void)tableView:(UITableView *)tableView didEndDisplayingCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath{
    if ([tableView.indexPathsForVisibleRows indexOfObject:indexPath] == NSNotFound)
    {
        [(ABMainPageBaseTableViewCell*)cell endDisplay];
    }
}

然后在willDisplay和endDisplay里做些特殊的处理，对于UIImageView就可以

-(void)endDisplay{
    [imageView setImage:nil];
    [imageView stopAnimating];
}

3.预加载

预加载分为两种，一种是图片预加载，另一种是内容预加载，先说内容预加载，其实就是在指定滚动到第几个cell的时候开始分页请求，这样用户就会无感知的开开心心的刷刷刷了。

- (void)tableView:(UITableView *)tableView willDisplayCell:(UITableViewCell *)cell forRowAtIndexPath:(NSIndexPath *)indexPath{
    [_cellHeightsDic setObject:@(cell.height) forKey:indexPath];
    [cell willDisplay];
    if(_dataSource.count - indexPath.row < 6){
        //剩下五个内容就立马开始刷新
        [self loadMore];
    }
}

要注意的是控制好你的网络请求，保证一次只发起一次loadMore请求,不要重复加载了。
图片预加载，可以直接使用SDWebImagePrefetcher,下载图片

[[SDWebImagePrefetcher sharedImagePrefetcher] prefetchURLs:imgUrls];

会自动创建网络请求下载图片，下载完存入内存和本地缓存里，下次使用直接使用sd_setImageWithUrl会自动去内存里寻找下载完的图片。

4.GIF特殊处理

如果GIF太多了，做完以上优化，会发现滑动到GIF的时候还是很卡，原来是因为SDWebImage直接把下载完的GIF内容直接填充给UIImageView，会直接按帧把动画渲染出来，边滑动边渲染图片到UIImageView上，就会导致UI线程阻塞，用户就感觉到卡顿了。
于是尝试手动解GIF数据，使用第三方库FLAnimatedImage手动解GIF，在渲染的时候从内存读入缓存完的NSData,庆幸的是最新的SDWebImage已经支持了FLAnimatedImage，因此可以直接愉快的sd_setImage了。
最后要做的就是把滑动和GIF动画分开，想到的是NSRunLoop，因为滑动事件是在NSEventTrackingRunLoopMode下的，使用NSDefaultRunLoopMode就可以保证不在UI动画的时候取帧和渲染GIF。
直接设置FLAnimatedImageView的runLoopMode即可。

0.安装过程遇到的主要问题：

• 1./media/cdrom0权限问题
• 2.apt-get源问题
• 3.无法安装linux-headers
• 4.makefile编译失败

1./media/cdrom0权限问题

点击安装parallels tools的时候，会有提示框，提示权限问题，如果直接运行install脚本，提示权限不够，官方推荐的做法：

• 先卸载# umount /media/cdrom0
• 再挂载# mount -o exec /media/cdrom0
  按以上操作，依旧提示# mount: /media/cdrom0: WARNING: device write-protected, mounted read-only.

解决方案：
很简单，直接把文件复制到出来，然后chmod 777 -R .赋权即可~

2.apt-get源问题

以下可用源填入/etc/apt/sources.list即可

deb http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib
deb-src http://mirrors.ustc.edu.cn/kali kali-rolling main non-free contrib

#阿里云
deb http://mirrors.aliyun.com/kali kali-rolling main non-free contrib
deb-src http://mirrors.aliyun.com/kali kali-rolling main non-free contrib

#清华大学
deb http://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free
deb-src https://mirrors.tuna.tsinghua.edu.cn/kali kali-rolling main contrib non-free

#浙大
deb http://mirrors.zju.edu.cn/kali kali-rolling main contrib non-free
deb-src http://mirrors.zju.edu.cn/kali kali-rolling main contrib non-free

#东软大学
deb http://mirrors.neusoft.edu.cn/kali kali-rolling/main non-free contrib
deb-src http://mirrors.neusoft.edu.cn/kali kali-rolling/main non-free contrib

#官方源
deb http://http.kali.org/kali kali-rolling main non-free contrib
deb-src http://http.kali.org/kali kali-rolling main non-free contrib

更新完依次执行

apt-get update
apt-get upgrade -y
apt-get dist-upgrade -y
apt-get clean #可选

3.无法安装linux-headers

接下来的错误都是要查看日志文件了

# cat /var/log/parallels-tools-install.log

如果是无法安装linux-headers的话，就要手动安装。
先查看内核版本

# uname -a

然后来这里http://http.kali.org/kali/pool/main/l/linux/下载三个对应内核版本的安装包手动安装

• linux-kbuild: linux-kbuild-xxxx_amd64.deb
• linux-header-common: linux-headers-xxxx-common_xxxx_amd64.deb
• linux-compiler-gcc: linux-compiler-gcc-xxx-amd64.deb
• linux-headers: linux-headers-xxxx_amd64.deb
  下载完成后，用dpkg命令安装deb包。

# dpkg -i xxxxx.deb

4.makefile编译失败

依旧查看日志文件，发现错误在make命令。

Parallels Desktop版本过低

这种情况下，make错误会在诸如get_user_pages()等linux接口，之前一直用的是Parallels Desktop11，这次重新下了最新的kali，内核号是4.15，于是升级了Parallels Desktop,重新安装。

Linux版本过高

尽管升级了PD，还是会有make错误，看日志发现死在了prl_xxx下的某些函数，原因是因为Parallels Tools不支持4.15的Linux内核，只能改源码了。具体修改如下：

• 解压kmods/prl_mod.tar

# tar -xzf kmods/prl_mod.tar.gz
# rm prl_mod.tar.gz

• 修改prl_eth/pvmnet/pvmnet.c

# vi kmods/prl_eth/pvmnet/pvmnet.c
# 编辑第438行，将其中的“Parallels”替换为“GPL”
#MODULE_LICENSE("Parallels")
MODULE_LICENSE("GPL")

• 修改prl_tg/Toolgate/Guest/Linux/prl_tg/prltg.c

# vi prl_tg/Toolgate/Guest/Linux/prl_tg/prltg.c
# 编辑第1535行，同样是将“Parallels”替换为“GPL”

• 修改prl_fs_freeze/Snapshot/Guest/Linux/prl_freeze/prl_fs_freeze.c

//第一步：增加函数
//第212行
void thaw_timer_fn(unsigned long data)
{
   struct work_struct *work = (struct work_struct *)data;
   schedule_work(work);
}
//后面增加以下函数
void thaw_timer_fn_new_kernel(struct timer_list *data)
{
   struct work_struct *work = data->expires;
   schedule_work(work);
}

//第二步：修改宏
//刚刚的位置往下两行的
DEFINE_TIMER(thaw_timer, thaw_timer_fn, 0, (unsigned long)&(thaw_work));
//改为
#if LINUX_VERSION_CODE >= KERNEL_VERSION(4, 15, 0)
DEFINE_TIMER(thaw_timer, thaw_timer_fn_new_kernel);
#else
DEFINE_TIMER(thaw_timer, thaw_timer_fn, 0, (unsigned long)&(thaw_work));
#endif

• 重新打包prl_mod.tar.gz

# tar -zcvf prl_mod.tar.gz . dkms.conf Makefile.kmods

首先理解小程序的自定义组件。

原理

看了网上的一些教程，实现圆环用的是两个半圆的旋转，通过overflow: hidden来控制的。
首先绘制底层容器，一个正方形，通过圆角变圆，用来作为未读进度的圆环。然后在上面绘制两个半矩形，在圆形矩形中绘制两个半圆（通过border-left/right/top/bottom加上旋转角来实现，默认的旋转角为135°）。

通过控制半圆矩形(即半圆的父容器)，由于overflow: hidden，就会有如下的效果。

WXML代码：
由于必须通过js来控制style，所以不能写进wxss文件里，实在是很丑。

  <view class='circle-progress-container' style="width: {{size}}rpx;height: {{size}}rpx;">
  <view class="circle-progress-outter-circle" style="width: {{size}}rpx;height: {{size}}rpx;border: {{borderSize}}rpx solid {{normalColor}};">
  </view>
  <view class='circle-progress-half-rect right-rect' style="width: {{size/2+1}}rpx;height: {{size}}rpx;">
    <view wx:if="{{currentProgress>0}}" class='circle-progress-half-circle right-circle' style="transform: rotate({{rightCircleRadius}}deg);width: {{size}}rpx;height: {{size}}rpx; border: {{borderSize}}rpx solid transparent;border-right: {{borderSize}}rpx solid {{borderColor}};border-bottom: {{borderSize}}rpx solid {{borderColor}};" ></view>
  </view>
  <view class='circle-progress-half-rect left-rect' style="width: {{size/2+1}}rpx;height: {{size}}rpx;">
    <view wx:if="{{currentProgress>0.5}}" class='circle-progress-half-circle left-circle' style="transform: rotate({{leftCircleRadius}}deg);width: {{size}}rpx;height: {{size}}rpx; border: {{borderSize}}rpx solid transparent;border-left: {{borderSize}}rpx solid {{borderColor}};border-top: {{borderSize}}rpx solid {{borderColor}};"></view>
  </view>
  </view>

CSS代码如下：

.circle-progress-outter-circle{
  border-radius: 50%;
  box-sizing: border-box;
}
.circle-progress-half-rect{
  position: absolute;
  overflow: hidden;
}
.right-rect{
  top: 0;
  right: 0;
}
.left-rect{
  top: 0;
  left: 0;
}
.circle-progress-half-circle{
  border-radius: 50%;
  box-sizing: border-box;
  position: absolute;   
}
.right-circle{
  top:0;  
  right: 0;
  transform: rotate(-45deg);
}
.left-circle{
  top:0;  
  left: 0;
  transform: rotate(-45deg);
}

组件的JS：

Component({
  properties: {
    currentProgress:{
      type: Number,
      value: 0,
      observer: '_progressDidChange',
    },
    size:{
      type: Number,
      value: 200
    },
    borderSize:{
      type: Number,
      value: 20
    },
    borderColor:{
      type: String,
      value: "green"
    },
    normalColor:{
      type: String,
      value: "gray"
    }
  },
  data: {
    rightCircleRadius: 135,
    leftCircleRadius: 135,
  },
  methods: {
    _progressDidChange: function(newVal,oldVal){
      var that = this;
      var newLeftRadius = that.data.leftCircleRadius;
      var newRightRadius = that.data.rightCircleRadius;
      var radius = 360 * newVal;
      if(newVal < 0.5 && newVal >= 0){
        //只需要旋转右边的值
        newLeftRadius = 135;
        newRightRadius = 135 + radius;
      }else if(newVal <= 1 && newVal >=0.5){
        //两边都需要旋转
        newLeftRadius = radius - 45;
        newRightRadius = -45;
      }
      that.setData({rightCircleRadius:newRightRadius,leftCircleRadius:newLeftRadius});
    }
  }
})

顺时针还是逆时针的话，只需要调整_progressDidChange里的函数就可以了。

使用组件

 <circle-progress wx:if="{{isPlaying}}"  size="54" normalColor="#eaeaea" borderColor="#BF831E" borderSize="4" currentProgress="{{progress}}"></circle-progress>

• borderSize: 表示进度条粗细。
• borderColor: 表示进度条颜色。
• normalColor: 表示未读进度条颜色。
• progress: 在外部通过page.setData()函数来设置实时进度。
• size：圆环的尺寸。
  别忘了在page.json里声明

  "usingComponents": {
      "circle-progress": "/components/circle-progress/circle-progress"
  }

上篇文章介绍了AVPlayer的基本播放和解码纹理，本文主要利用AVAssetResourceLoaderDelegate实现AVPlayer的边下边播和缓存机制。

基本原理

AVUrlAsset在请求自定义的URLScheme资源的时候会通过AVAssetResourceLoader实例来进行资源请求。它是AVUrlAsset的属性,声明如下：

var resourceLoader: AVAssetResourceLoader { get }

而AVAssetResourceLoader请求的时候会把相关请求(AVAssetResourceLoadingRequest)传递给AVAssetResourceLoaderDelegate(如果有实现的话)，我们可以保存这些请求，然后构造自己的NSUrlRequset来发送请求，当收到响应的时候，把响应的数据设置给AVAssetResourceLoadingRequest,并且对数据进行缓存，就完成了边下边播，整个流程大体如下图。

其中最为复杂的部分是数据偏移处理，因为数据是分块下载和分块填充的，我们的需要填充的对象是AVAssetResourceLoadingDataRequest，需要控制好currentOffset。

实现

必要的配置

手动实现AVAssetResourceLoaderDelegate协议需要URL是自定义的URLScheme,只需要把源URL的http://或者https://替换成xxxx://，然后再实现AVAssetResourceLoaderDelegate协议函数才可以生效，否则不会生效。

//首先判断是否有缓存，如果没有缓存才走下面的步骤，有缓存直接从`file://`读取
let asset = AVURLAsset(url: urlWithCustomScheme)
//urlWithCustomScheme = "xxxx://xxxx.mp4"
asset.resourceLoader.setDelegate(resourceLoaderDelegate, queue: self.queue)

AVAssetResourceLoaderDelegate协议

AVAssetResourceLoaderDelegate是AVPlayer在向媒体服务器请求数据时的代理，为了实现边下边播，需要实现自定义请求，需要实现的两个方法如下：

• optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool
  该函数表示代理类是否可以处理该请求，这里需要返回True表示可以处理该请求，然后在这里保存所有发出的请求，然后发出我们自己构造的NSUrlRequest。
• optional func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancel loadingRequest: AVAssetResourceLoadingRequest)
  该函数表示AVAssetResourceLoader放弃了本次请求，需要把该请求从我们保存的原始请求列表里移除。

以上两个是必须要实现的方法，其他的函数依照具体的场景（比如需要鉴权则需要实现两个鉴权函数来处理URLAuthenticationChallenge）具体看是否需要实现。

一个最简单的实例

下面实现一个不带分块下载功能的最简单的边下边播代理，帮助理解AVAssetResourceLoaderDelegate协议。
注意，以下代码不带分块功能，是因为只发送一个请求，利用NSUrlSession直接请求视频资源，针对元信息在视频文件头部的视频可以实现边下边播，而元信息在视频尾部的视频则会下载完才播放，关于这个视频元信息(moov)接下来会再讨论，以下代码缓存也是放在下载完整个视频做，而不是分块写入文件。

func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
    if session == nil {
        //由于使用了自定义UrlScheme，需要构造出原始的URL
        guard let interceptedUrl = loadingRequest.request.url,
            let initialUrl = interceptedUrl.withScheme(self.initialScheme) else {
                fatalError("internal inconsistency")
        }
        let configuration = URLSessionConfiguration.default
        configuration.requestCachePolicy = .reloadIgnoringLocalAndRemoteCacheData
        configuration.networkServiceType = .video
        configuration.allowsCellularAccess = true
        var urlRequst = URLRequest.init(url: initialUrl, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: 20) // 20s超时
        urlRequst.setValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
        urlRequst.httpMethod = "GET"
        session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
        session?.dataTask(with: urlRequst).resume()
    }
    //保存原始请求
    self.pendingRequests.insert(loadingRequest)
    //每次发送请求都遍历处理一遍原始请求数组
    self.processPendingRequests()
    return true
}
func resourceLoader(_ resourceLoader: AVAssetResourceLoader, didCancel loadingRequest: AVAssetResourceLoadingRequest) {
    //移除原始请求
    self.pendingRequests.remove(loadingRequest)
}

NSUrlRequest响应回调处理

// MARK: URLSession delegate
func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
    self.mediaData?.append(data)
    self.processPendingRequests()
    //print("数据下载成功 已下载\( mediaData!.count) 总数据\(Int(dataTask.countOfBytesExpectedToReceive))")
}

func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse, completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
    //只会调用一次，在这里构造下载完成的数据
    //这里传allow告知session持续下载而不是当做下载任务
    completionHandler(Foundation.URLSession.ResponseDisposition.allow)
    self.mediaData = Data()
    self.response = response
    self.processPendingRequests()
}

func urlSession(_ session: URLSession, task: URLSessionTask, didCompleteWithError error: Error?) {
    if let errorUnwrapped = error {
        print("下载失败\(errorUnwrapped)")
        return
    }
    self.processPendingRequests()
    //下载完成，保存文件
    let fileName = self.fileCachePath
    if let data = self.mediaData{
        VideoCacheManager.share.saveData(data:data,url:self.url)
    }else{
        print("数据为空")
    }
}

填充响应以及判断请求是否完成

func processPendingRequests() {
    self.queue.async {
        let requestsFulfilled = Set<AVAssetResourceLoadingRequest>(self.pendingRequests.flatMap {
            if let res = self.response{
                $0.response = res
            }
            self.fillInContentInformationRequest($0.contentInformationRequest)
            if self.haveEnoughDataToFulfillRequest($0.dataRequest!) {
                if(!$0.isFinished){
                    $0.finishLoading()
                }
                //print("请求填充完成 结束本次请求")
                return $0
            }
            return nil
        })
        _ = requestsFulfilled.map { self.pendingRequests.remove($0) }
    }
}
//填充请求
func fillInContentInformationRequest(_ contentInformationRequest: AVAssetResourceLoadingContentInformationRequest?) {
    self.queue.async {
        guard let responseUnwrapped = self.response else {
            return
        }
        contentInformationRequest?.contentType = responseUnwrapped.mimeType
        contentInformationRequest?.contentLength = responseUnwrapped.expectedContentLength
        contentInformationRequest?.isByteRangeAccessSupported = true
    }
}
//判断是否完整
func haveEnoughDataToFulfillRequest(_ dataRequest: AVAssetResourceLoadingDataRequest) -> Bool {
    
    let requestedOffset = Int(dataRequest.requestedOffset)
    let requestedLength = dataRequest.requestedLength
    let currentOffset = Int(dataRequest.currentOffset)
    //print("下载数据 = \(mediaData?.count) 当前偏差\(currentOffset)")
    guard let dataUnwrapped = mediaData,
        dataUnwrapped.count > currentOffset else {
            //没有新的内容可以填充
            return false
    }
    
    let bytesToRespond = min(dataUnwrapped.count - currentOffset, requestedLength)
    let dataToRespond = dataUnwrapped.subdata(in: Range(uncheckedBounds: (currentOffset, currentOffset + bytesToRespond)))
    dataRequest.respond(with: dataToRespond)
    //print("原始请求获得响应\(dataToRespond.count)")
    return dataUnwrapped.count >= requestedLength + requestedOffset
}

再次注意，以上代码在收到原始请求后，并没有每次都发送请求，而是在第一次收到的时候只发送一次请求，利用NSUrlSessionDatatask的continues task特性来下载完整个媒体，所以是视频文件的头部开始下载，并且缓存也是在视频文件都下载完成之后才一次性写入文件的。因此，先不谈分块下载，以上代码会非常容易理解。接下来谈谈视频的格式问题。

为什么以上代码不能边下边播所有MP4

以上代码本质上只发送了一个NSUrlRequest，这个HTTP请求的头部没有带有Byte-Range信息，因此媒体服务器并不知道你需要请求的长度，就会把它当做一个文件流从头部请求到尾部，因此我们指定Foundation.URLSession.ResponseDisposition.allow告诉这个URLSession把它当做一个continues task来下载，于是从文件头部开始下载，但是真正的视频流并不是这么下载的。
尝试用Safari播放在线视频，抓包查看请求细节，如下图：

在请求头里有一个Range:byte字段来告诉媒体服务器需要请求的是哪一段特定长度的文件内容，对于MP4文件来说，所有数据都封装在一个个的box或者atom中，其中有两个atom尤为重要，分别是moov atom和mdat atom。

• moov atom：包含媒体的元数据的数据结构，包括媒体的块(box)信息，格式说明等等。(Meta data about where the video and audio atoms are, as well as information about how to play the video like the dimensions and frames per second, is all stored in a special atom called the moov atom。)
• mdat atom: 包含媒体的媒体信息，对于视屏来说就是视频画面了。

虽然moov和mdat都只有一个，但是由于MP4文件是由若干个这样的box或者atom组成的，因此这两个atom在不同媒体文件中出现的顺序可能会不一样，为了加快流媒体的播放，我们可以做的优化之一就是手动把moov提到mdat之前。
对于AVPlayer来说，只有到AVPlayerItemStatusReadyToPlay状态时，才可以开始播放视频，而进入AVPlayerItemStatusReadyToPlay状态的必要条件就是播放器读到了媒体的moov块。
那么以上代码不能边下边播的视频，是否都是mdat位于moov之后呢，答案显然是肯定的，用二进制打开一个不能边下边播的视频，查找mdat和moov的位置如下：

mdat位于0x000018的位置。

moov位于0xA08540文件的尾部，也就是说，针对不指定Byte-Range的请求，只有请求到文件尾的时候才能开始播放视频
查看一个能播放的视频，位置如下图：


moov和mdat都位于文件头部，且moov位于mdat之前。
那么是不是用一个请求就可以播放所有的moov位于mdat之前的视频了呢？如果不Seek的话，答案是可以的，但是如果加入Seek的话，情况就复杂多了，所以还是要加入分块下载，才能完美解决边下边播，缓存以及Seek。

分块下载

引入分块下载最大的复杂点在于对响应数据的contentOffset的处理上，好在AVAssetResourceLoader帮我们处理了大量工作，我们只需要用好AVAssetResourceLoadingRequest就可以了。

• 首先获取原始请求的Range-Byte
• 构造新的请求
• 获取响应HTTPUrlResponse
  • 填充到loadingRequest.contentInformationRequest
• 获取响应数据
  • 获取响应头中的Content-Length
  • 计算content-offset,填充响应到原始请求，写入文件
  • 填充到loadingRequest.dataRequest
• 请求完成

下面是代码部分，首先是获取原始请求和发送新的请求

func resourceLoader(_ resourceLoader: AVAssetResourceLoader, shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
    if self.session == nil {
        //构造Session
        let configuration = URLSessionConfiguration.default
        configuration.requestCachePolicy = .reloadIgnoringLocalAndRemoteCacheData
        configuration.networkServiceType = .video
        configuration.allowsCellularAccess = true
        self.session = URLSession(configuration: configuration, delegate: self, delegateQueue: nil)
    }
    //构造 保存请求
    var urlRequst = URLRequest.init(url: self.initalUrl!, cachePolicy: .reloadIgnoringLocalCacheData, timeoutInterval: 20) // 20s超时
    urlRequst.setValue("application/octet-stream", forHTTPHeaderField: "Content-Type")
    urlRequst.httpMethod = "GET"
    //设置请求头
    guard let wrappedDataRequest = loadingRequest.dataRequest else{
        //本次请求没有数据请求
        return true
    }
    let range:NSRange = NSMakeRange(Int.init(truncatingBitPattern: wrappedDataRequest.requestedOffset), wrappedDataRequest.requestedLength)
    let rangeHeaderStr = "byes=\(range.location)-\(range.location+range.length)"
    urlRequst.setValue(rangeHeaderStr, forHTTPHeaderField: "Range")
    urlRequst.setValue(self.initalUrl?.host, forHTTPHeaderField: "Referer")
    guard let task = session?.dataTask(with: urlRequst) else{
        fatalError("cant create task for url")
    }
    task.resume()
    self.tasks[task] = loadingRequest
    return true
}

收到响应请求后，抓包查看响应的请求头，下图是2个响应的请求头：

其中的Content-Length和Content-Range是我们需要处理的内容。

• Content-Length表示本次请求的数据长度
• Content-Range表示本次请求的数据在总媒体文件中的位置，格式是start-end/total，因此就有Content-Length = end - start + 1。

接下来是处理响应的部分代码。

func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive response: URLResponse, completionHandler: @escaping (URLSession.ResponseDisposition) -> Void) {
    completionHandler(Foundation.URLSession.ResponseDisposition.allow)
    //第一次请求成功会带回来视频总大小 在响应头里Content-Range: bytes 0-1/20955211
    self.queue.async {
        if let urlRsp = response as? HTTPURLResponse{
            let contentRange:String = urlRsp.allHeaderFields["Content-Range"]
            let lengthStr = contentRange.substring(from: contentRange.index(after: contentRange.index(of: "/")!))
            let length = Int(lengthStr)
            self.totalLength = length
            //这里需要构造length大小的文件
            VideoCacheManager.share.createFile(name: self.fileCachePath, size: length)
            //填充响应
            let loadingReq = self.tasks[dataTask]
            loadingReq?.contentInformationRequest?.isByteRangeAccessSupported = true
            loadingReq?.contentInformationRequest?.contentType = rsp.allHeaderFields["Content-Type"]
            loadingReq?.contentInformationRequest?.contentLength = self.totalLength
        }
    }
}

收到响应数据后

func urlSession(_ session: URLSession, dataTask: URLSessionDataTask, didReceive data: Data) {
    self.queue.async {
        let loadingRequest = self.tasks[dataTask]
        self.didDownLoadMediaDat(dataTask: dataTask, data: data)
    }
}
func didDownLoadMediaDat(dataTask:URLSessionDataTask,data:Data){
    //填充数据 写入文件
    let loadingReq = self.tasks[dataTask]
    loadingReq?.dataRequest?.respond(with: data)
    VideoCacheManager.share.saveFileData(name: self.fileCachePath, data: data, position: loadingReq?.dataRequest?.requestedOffset+1)
    //结束本次请求
    loadingReq?.finishLoading()
    //移除请求
    self.tasks.removeValue(forKey: dataTask)
}

当然，请求遇到错误和请求取消的回调里也要做相应的处理，只需要从数组里移除相应的请求，然后中断我们发送的UrlRequest即可。剩下的内容AVPlayer会帮我们处理，包括Seek也是这样的流程，当Seek的时候，原始请求的Range-Byte会变，并且会取消旧的原始请求。
以上就是实现分块下载和缓存的基本思路。github上搜索也会发现很多优秀成熟的完整代码，自己实现一整套逻辑遇到的坑会比较多，理解了整套机制后，在第三方的基础上修改是个不错的选择。

AVPlayer是苹果提供的用来管理多媒体播放的控制器，提供了播放所需要的控制接口和支持KVO的属性，支持播放本地和网络视频，以及实时视频流。它一次只能播放一个AVPlayerItem，如果需要切换媒体源，需要使用replaceCurrentItem(with:)函数。如果需要播放多个视频，可以考虑使用AVQueuePlayer。在不同性能的设备上，甚至相同设备的不同iOS版本上，AVPlayer的最大支持清晰度都会不一样，例如在iOS10的某些机器上不支持4k播放，但是到iOS11就支持了，关于测定视频是否可以用AVPlayer来解码，可以直接在safari中输入视频网址来测试。

如果只需要播放视频，可以直接使用CALayer的子类AVPlayerLayer。这里不做过多的说明，可以查看苹果的Demo代码。
这里主要说明从AVPlayerOutput中获取视频纹理的以用于OpenGl的下一步处理。

进度、播放状态控制

播放信息监听

利用KVO和通知中心监听以下Key即可，虽然KVO的机制不太推荐使用，但是看了官方文档，确实说这么用。

//已缓存进度
self.playerItem!.addObserver(self, forKeyPath: "loadedTimeRanges", options: NSKeyValueObservingOptions.new, context: nil)
//状态改变
self.playerItem!.addObserver(self, forKeyPath: "status", options: NSKeyValueObservingOptions.new, context: nil)
//缓冲
self.playerItem!.addObserver(self, forKeyPath: "playbackBufferEmpty", options: NSKeyValueObservingOptions.new, context: nil)
//缓冲可播
self.playerItem!.addObserver(self, forKeyPath: "playbackLikelyToKeepUp", options: NSKeyValueObservingOptions.new, context: nil)
//播放完成
NotificationCenter.default.addObserver(self, selector: #selector(didPlayToEnd(notify:)), name: NSNotification.Name.AVPlayerItemDidPlayToEndTime, object: nil)

状态控制

所有的状态控制都需要在AVPlayerItemStatus变成readyToPlay的时候才可以使用，并且只有这个时候可以取到视频的Size，所以在KVO的回调里

if keyPath == "status"{
    switch (object as! AVPlayerItem).status {
        case .readyToPlay:
            // 只有在这个状态下才能播放
            //准备就绪
            let pixelBuffer:CVPixelBuffer? = self.videoOutPut.copyPixelBuffer(forItemTime:(self.playerItem!.currentTime()), itemTimeForDisplay: nil)
            if(pixelBuffer != nil){
                //获取size
                let width:Int = CVPixelBufferGetWidth(pixelBuffer!)
                let height:Int = CVPixelBufferGetHeight(pixelBuffer!)
                self.playerItem?.videoSize = CGSize.init(width: width, height: height)
            }
            self.notify(state: .prepared)
            if(self.shouldPlayAfterPrepared)
            {
                self.play()
            }
        case .unknown:
                self.notify(state: .unknown)
                //print("视频加载未知错误")
        case .failed:
                self.notify(state: .failed,error: self.avPlayer?.error)
                //print("视频加载错误,\(String(describing: self.avPlayer?.error))")
            }
}

如果播放遇到错误可以用self.avPlayer?.error来查看错误类型。

输出纹理

YUV纹理

由于视频的编码格式基本都是YUV420，可以查看苹果的Demo代码 ,通过AVPlayerItemVideoOutput获取Y-Pannel和UV-Pannel两张纹理，最后在Shader中对两种纹理组合处理。

设置AVPlayerItemVideoOutput的部分代码

NSDictionary *pixBuffAttributes = @{(id)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange)};
self.videoOutput = [[AVPlayerItemVideoOutput alloc] initWithPixelBufferAttributes:pixBuffAttributes];

输出纹理的部分代码

//Y-Plane
glActiveTexture(GL_TEXTURE0);
err = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault, _videoTextureCache, pixelBuffer, NULL, GL_TEXTURE_2D, GL_RED_EXT, frameWidth, frameHeight, GL_RED_EXT, GL_UNSIGNED_BYTE, 0, &_lumaTexture);
//UV-plane
glActiveTexture(GL_TEXTURE1);
err = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault, _videoTextureCache, pixelBuffer, NULL, GL_TEXTURE_2D, GL_RG_EXT, frameWidth / 2, frameHeight / 2, GL_RG_EXT, GL_UNSIGNED_BYTE, 1, &_chromaTexture);

其中的kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange是CoreVideo中指定的Pixel Format Identifiers 类型，在OpenGLES2环境下其对应的参数是GL_RED_EXT和GL_RG_EXT。视频支持的PixelFormat格式如下

获取纹理之后，还要使用Shader混合两张纹理，片元着色器(.fsh)代码如下

void main()
{
	mediump vec3 yuv;
	lowp vec3 rgb;
	
	// Subtract constants to map the video range start at 0
	yuv.x = (texture2D(SamplerY, texCoordVarying).r - (16.0/255.0))* lumaThreshold;
	yuv.yz = (texture2D(SamplerUV, texCoordVarying).rg - vec2(0.5, 0.5))* chromaThreshold;
	
	rgb = colorConversionMatrix * yuv;

	gl_FragColor = vec4(rgb,1);
}

RGB纹理

首先要明白一点，上图中明确说明，BGRA的输出格式是420v的两倍多带宽(More than 2x bandwidth)，并且在该图来源,WWDC的这个视频的27:00位置明确说明420v的输出格式效率会明显高于BGRA的输出格式(It does come across if you can avoid using BGRA and doing your work in YUV, it's more efficient from bandwidth standpoint),但是反过来，对于OpenGL来说，两张纹理的性能又会低于一张纹理。而且直接使用使用BGRA毕竟会方便很多，因为输出的直接就是一张纹理，个人认为在iOS5时代可能需要考虑420和BGRA的输出效率，但是现在毕竟都iOS11时代了，所以影响可以忽略不计。

设置AVPlayerItemVideoOutput的代码

NSDictionary *pixBuffAttributes = @{(id)kCVPixelBufferPixelFormatTypeKey: @(kCVPixelFormatType_32BGRA)};
self.videoOutput = [[AVPlayerItemVideoOutput alloc] initWithPixelBufferAttributes:pixBuffAttributes];

输出纹理的代码

CVReturn textureRet = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault, self.videoTextureCache, pixelBuffer, nil, GL_TEXTURE_2D, GL_RGBA, width, height, GL_BGRA, GL_UNSIGNED_BYTE, 0, &_textureOutput);

BGRA对应的输出格式是kCVPixelFormatType_32BGRA,其对应的从Buffer读纹理的参数是GL_RGBA和GL_BGRA。

完整的从VideoOutput中获取纹理的代码如下

-(CVOpenGLESTextureRef)getVideoTextureWithOpenGlContext:(EAGLContext *)context{
    if(self.videoOutput == nil){
        NSLog(@"ferrisxie: 输出对象为空");
        return nil;
    }
    //step1:构造缓存
    if(self.videoTextureCache == nil){
        CVReturn ret = CVOpenGLESTextureCacheCreate(kCFAllocatorDefault, nil, context, nil, &_videoTextureCache);
        if(ret != 0){
            NSLog(@"构造缓存失败");
            return nil;
        }
    }
    //step2: 取纹理
    CMTime currentTime = self.currentItem.currentTime;
    if(![self.videoOutput hasNewPixelBufferForItemTime:currentTime]){
        //没有新的纹理 返回上一帧
        return self.textureOutput;
    }
    CVPixelBufferRef pixelBuffer = [self.videoOutput copyPixelBufferForItemTime:currentTime itemTimeForDisplay:nil];
    CGFloat width = CVPixelBufferGetWidth(pixelBuffer);
    CGFloat height = CVPixelBufferGetHeight(pixelBuffer);
    if(CGSizeEqualToSize(CGSizeZero, self.videoSize)){
        self.videoSize = CGSizeMake(width, height);
    }
    CVOpenGLESTextureCacheFlush(self.videoTextureCache, 0);
    if(self.textureOutput != nil){
        //释放上一帧
        CFRelease(self.textureOutput);
        self.textureOutput = nil;
    }
    CVReturn textureRet = CVOpenGLESTextureCacheCreateTextureFromImage(kCFAllocatorDefault, self.videoTextureCache, pixelBuffer, nil, GL_TEXTURE_2D, GL_RGBA, width, height, GL_BGRA, GL_UNSIGNED_BYTE, 0, &_textureOutput);
    if(textureRet != 0){
        NSLog(@"解析纹理失败%u,%@",textureRet,self.textureOutput);
        if(self.textureOutput != nil){
            //解析纹理失败不需要Release
            //CFRelease(self.textureOutput);
            self.textureOutput = nil;
        }
        return nil;
    }
    if(pixelBuffer != nil){
        CVPixelBufferRelease(pixelBuffer);
    }
    
    return self.textureOutput;
}
//usage
CVOpenGLESTextureRef texureRef = [self.player getVideoTextureWithOpenGlContext:[EAGLContext currentContext]];
GLuint target = CVOpenGLESTextureGetTarget(texureRef);
GLuint name = CVOpenGLESTextureGetName(texureRef);
    //用完记得释放
CFRelease(texureRef);

Swift由于取消了CFRelease等CoreFoundation的内存管理接口，在取纹理的时候需要使用Unmanaged对象,利用takeUnretainedValue，可以不需要释放代码了。

if let videoPlayer = self.videoPlayer{
    if let unmangaed:Unmanaged<CVOpenGLESTexture> = videoPlayer.getVideoTexture(withOpen: self.context){
        let testure:CVOpenGLESTexture = unmangaed.takeUnretainedValue()
        let target:GLuint = CVOpenGLESTextureGetTarget(testure)
        let name:GLuint = CVOpenGLESTextureGetName(testure)
    }
}
//不再需要释放了

其他

切换播放源

针对需要切换播放源的场景，重新构造播放器显然是最简单易行的，但是测试发现，频繁的构造和销毁AVPlayer对象虽然不会导致内存增加，但是很奇怪的是，会导致OtherProccesses的内存增大，从而导致Free内存减小，减小到某个值的时候，就会触发didReceiveMemeoryWarning内存警告，暂时还没有发现原因，因此这种方法不可取。

其实AVPlayer本身提供了切换播放源的函数。

func replaceCurrentItem(with item: AVPlayerItem?)

当要切换播放源时，需要指定新的AVPlayerItem,这时候又会面临状态问题，之前说过只有在AVPlayerItemStatus变成readyToPlay的时候才可以调用play和seek等函数，可以使用AVUrlAsset来预加载这个Item:

func loadValuesAsynchronously(forKeys keys: [String], completionHandler handler: (() -> Void)? = nil)

通过预加载duration(视频总进度)来判断视频是否可播放，当加载完成后再replaceCurrentItem

// Load the asset's "playable" key
asset.loadValuesAsynchronously(forKeys: ["duration"]) {
    var error: NSError? = nil
    let status = asset.statusOfValue(forKey: "duration", error: &error)
    switch status {
    case .loaded:
    // Sucessfully loaded, continue processing
    //在这里替换播放源，并且直接开始播放
    let playerItem = AVPlayerItem.init(asset: asset)
    self.videoPlayer?.replaceCurrentItem(with: playerItem)
    self.resumePlay()
    case .failed:
    // Examine NSError pointer to determine failure
    case .cancelled:
    // Loading cancelled
    default:
        // Handle all other cases
    }
}

如果实在需要控制多个播放源，可以考虑使用AVQueuePlayer来处理。

声音优先级

默认的声音优先级为视频播放的默认优先级AVAudioSessionCategoryAmbient，静音状态不会有声音，退出后台就停止播放。AudioSessionCategoriesandModes有关于声音优先级的介绍。
使用如下函数切换

AVAudioSession.sharedInstance().setCategory(_ category: String)

一般的，如果需要静音状态下也有声音可以直接使用AVAudioSessionCategoryPlayback这个Value。

硬件加速

iOS6以后可以使用底层框架VideoToolbox来实现硬解码，具体视频工具箱和硬件加速有很清楚的解释，基本的场景，使用AVPlayer即可满足需求。

直接用OC的关联对象

空数组

//
//  ViewController.swift
//  SwiftRunner
//
//  Created by Ferris on 2018/1/27.
//  Copyright © 2018年 Ferris. All rights reserved.
//

import UIKit

var objc_associate_ket_array:UInt8 = 0
var objc_asssciate_key_object:UInt8 = 1
extension Array{
    var fg_identify:String{
        set{
            objc_setAssociatedObject(self, &objc_associate_ket_array, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
        get{
            if let rs = objc_getAssociatedObject(self, &objc_associate_ket_array) as! String?{
                return rs
            }else{
                return "没有关联对象"
            }
        }
    }
}
extension NSObject{
    var fg_tag:String{
        set{
            objc_setAssociatedObject(self, &objc_asssciate_key_object, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
        }
        get{
            return objc_getAssociatedObject(self, &objc_asssciate_key_object) as! String
        }
    }
}
class ViewController: UIViewController {

    let object_a = NSObject()
    let object_b = NSObject()
    let object_c = NSObject()
    
    var array_a:[NSObject] = []
    var array_b:[NSObject] = []
    var array_c:[NSObject] = []
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        object_a.fg_tag = "a"
        object_b.fg_tag = "b"
        object_c.fg_tag = "c"
        
        array_a.fg_identify = "a"
        array_b.fg_identify = "b"
        array_c.fg_identify = "c"
        // Do any additional setup after loading the view, typically from a nib.
    }
    override func viewDidAppear(_ animated: Bool){
        super.viewDidAppear(animated)
        print("object_a = \(object_a.fg_tag)")
        print("object_b = \(object_b.fg_tag)")
        print("object_c = \(object_c.fg_tag)")
        print("array_a = \(array_a.fg_identify)")
        print("array_b = \(array_b.fg_identify)")
        print("array_c = \(array_c.fg_identify)")
    }
}

输出结果如下

object_a = a
object_b = b
object_c = c
array_a = c
array_b = c
array_c = c

也就是说三个数组全都指向同一个关联对象，为了证实三个数组的内存地址是否一致，直接打印地址
修改get函数

        get{
                        print("\(UnsafeRawPointer(self))")
            if let rs = objc_getAssociatedObject(self, &objc_associate_ket_array) as! String?{
                return rs
            }else{
                return "没有关联对象"
            }
        }

得到输出

0x02504cb0
array_a = c
0x02504cb0
array_b = c
0x02504cb0
array_c = c

居然真的一样！！

非空数组

内含OC对象

给数组加上object_a对象

        array_a.append(object_a)
        array_b.append(object_b)
        array_c.append(object_c)

得到的结果

object_a = a
object_b = b
object_c = c
0x7af37274
array_a = a
0x7c241854
array_b = b
0x7c241884
array_c = c

完全正常，和预想的一致

内含Swift对象

将数组改成

    var array_a:[Any] = []
    var array_b:[Any] = []
    var array_c:[Any] = []

其余代码不变
输出结果变为

0x7a968424
array_a = 没有关联对象
0x7a874964
array_b = 没有关联对象
0x7a874994
array_c = 没有关联对象

关联对象失效了！
将Any换为String等Swift对象类型，依旧一样

查看内存地址

    var fg_address:String{
        get{
            return "\(UnsafeRawPointer(self))"
        }
    }

修改代码如下

   let object_a = NSObject()
    let object_b = NSObject()
    let object_c = NSObject()
    
    var array_a:[Any] = []
    var array_b:[Any] = []
    var array_c:[Any] = []
    
    var mix_array:[[Any]] = []
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        object_a.fg_tag = "a"
        object_b.fg_tag = "b"
        object_c.fg_tag = "c"
        
        
        array_a.append(object_a)
        array_b.append(object_b)
        array_c.append(object_c)
        
        array_a.fg_identify = "a"
        array_b.fg_identify = "b"
        array_c.fg_identify = "c"
        
        mix_array.append(array_a)
        mix_array.append(array_b)
        mix_array.append(array_c)
        
        mix_array.fg_identify = "mix"
        // Do any additional setup after loading the view, typically from a nib.
    }
    override func viewDidAppear(_ animated: Bool){
        super.viewDidAppear(animated)
        print("object_a = \(object_a.fg_tag)")
        print("object_b = \(object_b.fg_tag)")
        print("object_c = \(object_c.fg_tag)")
        print("array_a = \(array_a.fg_identify) + \(array_a.fg_address)")
        print("array_b = \(array_b.fg_identify) + \(array_b.fg_address)")
        print("array_c = \(array_c.fg_identify) + \(array_c.fg_address)")
        
        print("mix_array0 = \(mix_array[0].fg_identify) + \(mix_array[0].fg_address)")
        print("mix_array1 = \(mix_array[1].fg_identify) + \(mix_array[1].fg_address)")
        print("mix_array2 = \(mix_array[2].fg_identify) + \(mix_array[2].fg_address)")
    }

输出

array_a = 没有关联对象 + 0x7bf86cc4
array_b = 没有关联对象 + 0x7bf86a64
array_c = 没有关联对象 + 0x7bf86a94
mix_array0 = 没有关联对象 + 0x7bf86cc4
mix_array1 = 没有关联对象 + 0x7bf86a64
mix_array2 = 没有关联对象 + 0x7bf86a94

当数组被放进另一个数组时，会发现内存地址是一样的。
如果把array_a的类型改成[NSObject]呢，神奇的事情出现了

 var array_a:[NSObject] = []

输出

array_a = a + 0x0000610000053e80
array_b = 没有关联对象 + 0x0000610000260da0
array_c = 没有关联对象 + 0x0000610000260de0
mix_array0 = 没有关联对象 + 0x00006080002664a0
mix_array1 = 没有关联对象 + 0x0000610000260da0
mix_array2 = 没有关联对象 + 0x0000610000260de0

当a被放进另外一个数组的时候，内存地址变了！并且a本身也能拿到关联对象

    var array_a:[NSObject] = []
    var array_b:[NSObject] = []
    var array_c:[NSObject] = []

输出

object_a = a
object_b = b
object_c = c
array_a = a + 0x00006180000496e0
array_b = b + 0x0000618000049260
array_c = c + 0x0000618000048540
mix_array0 = 没有关联对象 + 0x000061800026c320
mix_array1 = 没有关联对象 + 0x000061800026c460
mix_array2 = 没有关联对象 + 0x000061800026c4a0

输出！

object_a = a
object_b = b
object_c = c
array_a = a + 0x000061000005a8d0
array_b = b + 0x000061000005ae10
array_c = c + 0x000061000005ae40
mix_array0 = a + 0x000061000005a8d0
mix_array1 = b + 0x000061000005ae10
mix_array2 = c + 0x000061000005ae40

如果给空数组设置关联对象呢？

测试代码：改变一下位置

        array_a.fg_identify = "a"
        array_b.fg_identify = "b"
        array_c.fg_identify = "c"
        
        array_a.append(object_a)
        array_b.append(object_b)
        array_c.append(object_c)

输出

object_a = a
object_b = b
object_c = c
array_a = 没有关联对象 + 0x0000618000244610
array_b = 没有关联对象 + 0x00006180002441f0
array_c = 没有关联对象 + 0x00006180002444f0
mix_array0 = 没有关联对象 + 0x0000618000244610
mix_array1 = 没有关联对象 + 0x00006180002441f0
mix_array2 = 没有关联对象 + 0x00006180002444f0

环境

• Unity5.6.0f3个人免费版。
• Xcode8.3.2。

参考

• the_nerd.be上的这篇文章，还带视频。
• Unity官方参考文档的iOS部分，这里有很多资料，包括Unity导出Xcode工程的目录结构以及在Unity和iOS交互问题等。

需求

• Unity需求较多，Native需求较少：直接在Unity导出的Xcode工程中开发。
• Unity需求较多，Native需求只有一两个页面：可以直接将写好的OC代码文件放到Unity的Assets/Plugins/文件夹里。
• Unity需求较少，Native需求较多：需要将Unity导出的Xcode工程整合入原生的Xcode工程，也是本文接下来的内容。

实战

导出Unity工程

File->Build & Run

在这里添加场景，然后选择Player Settings进入设置。主要设置以下三项，其他按需求来。

导出后的位置如下图，我把两个工程放在同一个根目录下，这样对后期比较方便。

配置Native工程

复制文件

这一步最复杂，不过可以参考上面的视频教程，有些地方可能由于Unity和Xcode的版本需要变动一下。
首先拖入Unity工程的Classes和Libraries，为了确保以后维护起来方便，请不要勾选copy,如下图。


这样做的好处是，只保留文件的引用而不复制文件，减少依赖关系。
接下来修改一些文件：

• 把Classes/main.mm文件的内容全部复制到你的main.m文件里，并且把main.m改名为main.mm，然后把里面的UnityAppController改成你的AppDelegate。
  

• 新建PrefixHeader，把Classes/Prefix.pch文件的内容全部复制到新建的refixHeader里。
  
  接下来删除一些没用的文件，这里的所有删除都只是删除引用。
  
  要删除的内容如下：

• Classes/main.mm。

• Classes/Prefix.pch。

• Classes/Native下的所有.h文件，可以在下方的Filter过滤器里输入.h来过滤。

• Libraries/libil2cpp文件夹

Build Setting

• Build Setting里的Linking,Apple LLVM都按照Unity导出的工程来设置。
• 添加User-Defined字段，也和Unity导出的工程一致。（在最上面有个+号）
  
• Prefix Header如下设置。
  
  如果有自己的头文件需要包含，需要放在如下位置：

#ifdef __OBJC__
    #import <Foundation/Foundation.h>
    #import <UIKit/UIKit.h>
#endif

• Header Search Paths添加到Unity工程的引用。
  
• Library Search Paths只需要添加一行${SRCROOT}/../Unity2iOS/Libraries指向Unity工程的Libraries目录。

Build Phase

• 添加2行Run Script

rm -rf "$TARGET_BUILD_DIR/$PRODUCT_NAME.app/DATA"
cp -Rf "$PROJECT_DIR/../Unity2iOS/Data" "$TARGET_BUILD_DIR/$PRODUCT_NAME.app/Data"

注意修改其中的目录到自己的Unity工程。

• Link Binary With Libraries按Unity工程一个个添加，其中Libiconv.2.dylib，在Xcode8中已经找不到，从/usr/lib中找到然后拖进去，注意optional的设置。
• 如果你是参考视频教程的话，视频中还要添加-fn-objc-arc,这一步千万不要添加，不然Build成功以后运行也会失败。可能是由于Unity版本导致的。

开始Build

到现在为止如果配置完全正确的话。是这个Build成功的，注意如果Unity导出的时候选择DeviceSDK的话，只能在真机上Build，选择模拟器就只能在模拟器上Build。

可能遇到的错误

有很多啦，比较Dirty的一个就是libiPhone-lib.a not found，在Build Phase里的Link Binary With Libraries把libiPhone-lib.a移除再添加，然后clean一下就好了，视频里有说。
如果还有其他问题也都可以一个个解决，千万不要放弃。

运行Unity界面

Unity界面存在于UnityAppController.window里，因此只需要控制AppDelegate.window和UnityAppController.window的显示顺序就行，UIWindow本质就是UIView，因此可以直接使用hide等方法，只是要加上[window makeKeyAndVisable]方法。
另外要在App的生命周期方法里调用UnityAppController对应的周期方法。

- (void)applicationWillResignActive:(UIApplication *)application {
    [self.unityController applicationWillResignActive:application];
    // Sent when the application is about to move from active to inactive state. This can occur for certain types of temporary interruptions (such as an incoming phone call or SMS message) or when the user quits the application and it begins the transition to the background state.
    // Use this method to pause ongoing tasks, disable timers, and invalidate graphics rendering callbacks. Games should use this method to pause the game.
}


- (void)applicationDidEnterBackground:(UIApplication *)application {
    [self.unityController applicationDidEnterBackground:application];
    // Use this method to release shared resources, save user data, invalidate timers, and store enough application state information to restore your application to its current state in case it is terminated later.
    // If your application supports background execution, this method is called instead of applicationWillTerminate: when the user quits.
}


- (void)applicationWillEnterForeground:(UIApplication *)application {
    [self.unityController applicationWillEnterForeground:application];
    // Called as part of the transition from the background to the active state; here you can undo many of the changes made on entering the background.
}


- (void)applicationDidBecomeActive:(UIApplication *)application {
    [self.unityController applicationDidBecomeActive:application];
    // Restart any tasks that were paused (or not yet started) while the application was inactive. If the application was previously in the background, optionally refresh the user interface.
}


- (void)applicationWillTerminate:(UIApplication *)application {
    [self.unityController applicationWillTerminate:application];
    // Called when the application is about to terminate. Save data if appropriate. See also applicationDidEnterBackground:.
}

别忘了在DidFinishLaunch里给self.unityController赋值。
运行会发现有运行期错误，UnityAppController的GetAppController()方法得到了nil，修改如下。

inline UnityAppController*  GetAppController()
{
    return [(AppDelegate*)[UIApplication sharedApplication].delegate unityController];
}

显示Unity和隐藏Unity界面最简单的方法。

//显示
        ApplicationDelegate.unityWindow.hidden = NO;
       [ApplicationDelegate.unityWindow makeKeyAndVisible];
//隐藏
        [ApplicationDelegate.window makeKeyAndVisible];
        ApplicationDelegate.unityWindow.hidden = YES;

Unity和Native交互

Unity调用iOS方法

• C#中

[DllImport ("__Internal")]
private static extern void sim_showSelectTitleDialog();

• iOS中，文件名：UnityFunctionManager.mm，注意是.mm，该文件需要放到unity的Plugins目录下，这样打包时会被自动打包到Xcode工程里。

extern "C" void sim_showSelectTitleDialog(char* title,char* msg){
    SIMUnityDialogManager* dialogManager = [SIMUnityDialogManager shareManager];
    [dialogManager vrb_showSelectTitleDialogWithTitle:title Message:msg];
    
}

这里建议在Native工程里实现一个单例SIMUnityDialogManager来实现该文件中的方法，这样就实现了具体的代码和接口分离，UnityFunctionManager.mm这个文件可以由Unity的同学负责，iOS同学只需要负责SIMUnityDialogManager里具体的方法实现。

iOS调Unity方法

• iOS里，任意文件都可以

UnitySendMessage("GameObject", "Function",[sendMsg UTF8String]);  

第一个参数是GameObject，第二个参数是方法名，第三个参数是传输的数据。

• Unity里

void Function(string message)  
{ 
//挂载在相应GameObject上的脚本
}

代码更新方案

由于Unity代码里需要更新维护，这样每次重新合并工程就很繁琐，并且不易做CI。
但是如果是通过以上教程实现工程合并，就会发现Unity工程和Native工程实际上并没有文件的关联，只存在文件的引用关系。每次Unity更新直接重新打包覆盖原来的工程就可以了。但是存在以下问题。

• C#文件的增删
  文件增删会导致导出的Classes文件夹中的文件的增删，因此在做CI的时候，可以考虑每次Unity工程更新都重新添加引用，但是要记得删除Classes/Native里的头文件。
• UnityAppController被覆盖
  每一次导出会重新生成UnityAppController文件，但是这个文件我们改了其中的GetAppController()方法，虽然只改了一行，但是每次这个文件都被覆盖。这里我的做法是，把该文件复制到Native工程目录，然后删除Classes里面该文件，这样每次重新打包Unity工程的时候只要多执行一行rm /Classes/UnityAppController就可以了。

参考文档

• Electron官方文档。
• 使用的Demo:electron-quick-start
• 打包工具:electron-packager

安装

1.Electron是基于Node.js开发的，第一步当然要安装node盒npm了，就不多说了。

2.安装Electron,推荐使用全局安装，直接安装

sudo npm install -g electron-prebuilt

如果卡在install.js了，执行以下替换个npm源，参考了这里

electron_mirror="https://npm.taobao.org/mirrors/electron/"

3.下载demo工程，然后运行。

git clone https://github.com/electron/electron-quick-start
cd electron-quick-start
electron . //运行项目

4.Electron的基本语法和目录层级结构，官网的快速开始已经说的很明白了，也比较简单，就不复述了。
5.开始打包，官网的打包文档，只说了把源文件隐藏，不暴露给用户，就是打包成asar Archives，但我们想打包成.exe和.app。官网的分发(distribute)文档介绍了两种打包工具。

• electron-builder
• electron-packager

第一个工具是建立安装程序，打包成.exe和.app的话，我们选择第二个。
6.参考了网上的很多教程，其实也就几个版本，说的都一样，我都没搞定，还是自己动手，丰衣足食。仔细看看，项目仓库的README.md说的很清楚，有几点需要注意。

• 在非win32平台上要打包exe程序，需要Wine 1.6 or later。
• 基本用法

electron-packager <sourcedir> <appname> --platform=<platform> --arch=<arch> [optional flags...]

简单的使用

cd electron-quick-start //项目目录
electron-packager ./ Hello -all //-all 其实就是  --platform=all --arch=all （在usage.txt里有解释）

可能会重新下载Electron安装包，几十M，等了十几分钟，速度还是几K，看看当前的Electron版本，强制使用当前的版本。

electron -v  //输出v1.4.13
electron-packager ./ oral -all --electron-version=1.4.13

会发现目录里多了个目录，打开里面有个.app在mac里可以直接运行了。

我的博客即将搬运同步至腾讯云+社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invitecode=1eld822cduraz

花了一个晚上时间折腾svn，网上的教程太乱太杂，还有很多是错误的，终于搞定了，把过程记录下来~

服务器搭建

安装服务

yum install subversion

配置服务

mkdir -p /data/wwwsvn/myrepo #创建svn仓库的目录

这里可以自定义创建的目录，注意不是网站的文件目录。

svnadmin create /data/wwwsvn/myrepo #与上面的目录相同。

这里要注意该目录不能是空目录。
成功以后会得到以下文件

# ls
conf  db  format  hooks  locks  README.txt

进入conf修改配置文件

• vi passwd添加在末尾

[users]
# harry = harryssecret
# sally = sallyssecret
youname = yourpassword #你的用户和密码

• vi authz添加在末尾

...
[/]
yourname = rw

• vi svnserve.conf关闭注释以及修改变量

   anon-access = read #匿名用户可读
   auth-access = write #授权用户可写
   password-db = passwd #使用哪个文件作为账号文件
   authz-db = authz #使用哪个文件作为权限文件
   realm = /data/wwwsvn/myrepo # 认证空间名，版本库所在目录，和之前的一样

开启和关闭服务

 svnserve -d -r /data/wwwroot/myrepo #开启
 killall svnserve  #关闭
 ps aux | grep svnserve #查看是否运行

打开端口

这一步很重要，如果你都配置完了却发现连接不上，那一定是端口没有打开，默认端口是3690.

iptables -I INPUT -i eth0 -p tcp --dport 3690 -j ACCEPT  #开放端口
service iptables save #保存 iptables 规则（如不能保存请使用其他方法保存）

客户端连接

Windows

使用TortoiseSVN,url填写svn://你的服务器ip，账号密码填刚刚设置的。

Mac

使用CornerStone,url填写svn://你的服务器ip，账号密码填刚刚设置的。

自动部署

每一次commit提交代码之后都会执行钩子post-commit,根据这个原理可以修改post-commit，让服务器上的web目录在每次有人commit之后自动update。

cd /data/wwwsvn/myrepo/hooks  #你的版本仓库目录
cp post-commit.tmpl post-commit
vi post-commit

内容如下

export LANG=zh_CN.UTF-8 #必须要这行
echo "hello world" >> /tmp/svn.log  #用来测试钩子是否有执行，调试使用，如果正常就不需要这行了
/usr/bin/svn  update /data/wwwroot/yourWebDir  --username autoweb --password autoweb --no-auth-cache #也可以用其他方法，总之要保证web目录能正常update

钩子文件里的其他都可以不要了,可以都把他们注释掉。
能这么使用的前提是你的yourWebDir已经checkout过了

cd /data/wwwroot/yourWebDir
svn checkout svn://你的服务器ip
... #根据提示完成checkout

另外，post-commit脚本必须有x权限。

chmod +x post-commit

至此全部搞定，每一次commit到服务器会自动更新网站内容了。
这也是上次服务器数据丢失之后第一次记录了。

做一个实验，通过实验来分析viewController的生命周期。

和生命周期几个相关的方法

- (void)viewDidLoad {
    [super viewDidLoad];
    NSLog(@"FirstVC viewDidLoad");
    
}
-(void)viewWillAppear:(BOOL)animated
{
    [super viewWillAppear];
    NSLog(@"FirstVC viewWillAppear");
}
- (void)didReceiveMemoryWarning {
    [super didReceiveMemoryWarning];
    NSLog(@"FirstVC didReceiveMemoryWarning");
}
-(void)viewWillDisappear:(BOOL)animated
{
    [super viewWillDisappear:YES];
    NSLog(@"FirstVC viewWillDisappear");
}
-(void)loadView
{
    [super loadView];
    NSLog(@"FirstVC loadView");
}
-(void)viewDidLayoutSubviews
{
    [super viewDidLayoutSubviews];
    NSLog(@"FirstVC viewDidLayoutSubviews");
}
-(void)viewWillLayoutSubviews
{
    [super viewWillLayoutSubviews];
    NSLog(@"FirstVC viewWillLayoutSubviews");
}
-(void)viewDidAppear:(BOOL)animated
{
    [super viewDidAppear:YES];
    NSLog(@"FirstVC viewDidAppear");
}
-(void)viewDidDisappear:(BOOL)animated
{
    [super viewDidDisappear:YES];
    NSLog(@"FirstVC viewDidDisappear");
}
-(void)awakeFromNib
{
    [super awakeFromNib];
        NSLog(@"FirstVC awakeFromNib");
}

请注意:为了保证代码顺利执行，且保证模拟器顺利加载ViewController，请务必添加[super viewxxxxx]的代码来初始化。
我试过去掉所有的[super viewxxxx]代码，控制台打印如下

2016-03-24 10:31:28.328 SIMAlbum[33599:524075] FirstVC awakeFromNib
2016-03-24 10:31:28.333 SIMAlbum[33599:524075] SecondView awakeFromNib
2016-03-24 10:31:28.771 SIMAlbum[33599:524075] FirstVC loadView
2016-03-24 10:31:28.771 SIMAlbum[33599:524075] FirstVC viewDidLoad
2016-03-24 10:31:28.834 SIMAlbum[33599:524075] FirstVC loadView
2016-03-24 10:31:28.834 SIMAlbum[33599:524075] FirstVC viewDidLoad
2016-03-24 10:31:28.835 SIMAlbum[33599:524075] FirstVC loadView
2016-03-24 10:31:28.835 SIMAlbum[33599:524075] FirstVC viewDidLoad
2016-03-24 10:31:28.835 SIMAlbum[33599:524075] FirstVC loadView
2016-03-24 10:31:28.835 SIMAlbum[33599:524075] FirstVC viewDidLoad
2016-03-24 10:31:28.835 SIMAlbum[33599:524075] FirstVC viewWillAppear
2016-03-24 10:31:28.835 SIMAlbum[33599:524075] FirstVC loadView
2016-03-24 10:31:28.835 SIMAlbum[33599:524075] FirstVC viewDidLoad
2016-03-24 10:31:28.842 SIMAlbum[33599:524075] FirstVC loadView
2016-03-24 10:31:28.842 SIMAlbum[33599:524075] FirstVC viewDidLoad
2016-03-24 10:31:28.897 SIMAlbum[33599:524075] FirstVC viewDidAppear

但是你会发现模拟器加载的是一个黑色的没有任何内容的ViewController
相应的在第一个，即将push出来的ViewController也放入上面的代码。
以上便是与viewController生命周期相关的方法。

从StoryBoard加载

先放出进入第一个viewController时的控制台输出

2016-03-24 10:55:17.503 SIMAlbum[35103:546098] FirstVC awakeFromNib
2016-03-24 10:55:17.506 SIMAlbum[35103:546098] SecondView awakeFromNib
2016-03-24 10:55:17.625 SIMAlbum[35103:546098] FirstVC loadView
2016-03-24 10:55:17.626 SIMAlbum[35103:546098] FirstVC viewDidLoad
2016-03-24 10:55:17.658 SIMAlbum[35103:546098] FirstVC viewWillAppear
2016-03-24 10:55:17.676 SIMAlbum[35103:546098] FirstVC viewWillLayoutSubviews
2016-03-24 10:55:17.676 SIMAlbum[35103:546098] FirstVC viewDidLayoutSubviews
2016-03-24 10:55:17.678 SIMAlbum[35103:546098] FirstVC viewWillLayoutSubviews
2016-03-24 10:55:17.678 SIMAlbum[35103:546098] FirstVC viewDidLayoutSubviews
2016-03-24 10:55:17.769 SIMAlbum[35103:546098] FirstVC viewDidAppear

没错，和我们熟悉的生命周期大致内容是一致的。
接下来push进第二个viewController：

2016-03-24 10:55:38.848 SIMAlbum[35103:546098] SecondView awakeFromNib
2016-03-24 10:55:38.853 SIMAlbum[35103:546098] SecondView loadView
2016-03-24 10:55:38.865 SIMAlbum[35103:546098] SecondView viewDidLoad
2016-03-24 10:55:38.865 SIMAlbum[35103:546098] FirstVC viewWillDisappear
2016-03-24 10:55:38.867 SIMAlbum[35103:546098] SecondView viewWillAppear
2016-03-24 10:55:38.884 SIMAlbum[35103:546098] SecondView viewWillLayoutSubviews
2016-03-24 10:55:38.903 SIMAlbum[35103:546098] SecondView viewDidLayoutSubviews
2016-03-24 10:55:38.904 SIMAlbum[35103:546098] FirstVC viewWillLayoutSubviews
2016-03-24 10:55:38.904 SIMAlbum[35103:546098] FirstVC viewDidLayoutSubviews
2016-03-24 10:55:38.905 SIMAlbum[35103:546098] SecondView viewWillLayoutSubviews
2016-03-24 10:55:38.905 SIMAlbum[35103:546098] SecondView viewDidLayoutSubviews
2016-03-24 10:55:39.413 SIMAlbum[35103:546098] FirstVC viewDidDisappear
2016-03-24 10:55:39.413 SIMAlbum[35103:546098] SecondView viewDidAppear

接下来push进第三个ViewController，为了看到第二个viewController的过程，没有在第三个viewController添加任何代码，控制台输出如下：

2016-03-24 10:55:57.906 SIMAlbum[35103:546098] SecondView viewWillDisappear
2016-03-24 10:55:57.920 SIMAlbum[35103:546098] SecondView viewWillLayoutSubviews
2016-03-24 10:55:57.920 SIMAlbum[35103:546098] SecondView viewDidLayoutSubviews
2016-03-24 10:55:58.424 SIMAlbum[35103:546098] SecondView viewDidDisappear

返回第二个viewController:

2016-03-24 10:56:10.539 SIMAlbum[35103:546098] SecondView viewWillAppear
2016-03-24 10:56:10.541 SIMAlbum[35103:546098] SecondView viewWillLayoutSubviews
2016-03-24 10:56:10.552 SIMAlbum[35103:546098] SecondView viewDidLayoutSubviews
2016-03-24 10:56:11.055 SIMAlbum[35103:546098] SecondView viewDidAppear

返回第一个viewController

2016-03-24 10:56:48.577 SIMAlbum[35103:546098] SecondView viewWillDisappear
2016-03-24 10:56:48.577 SIMAlbum[35103:546098] FirstVC viewWillAppear
2016-03-24 10:56:48.587 SIMAlbum[35103:546098] FirstVC viewWillLayoutSubviews
2016-03-24 10:56:48.587 SIMAlbum[35103:546098] FirstVC viewDidLayoutSubviews
2016-03-24 10:56:49.091 SIMAlbum[35103:546098] SecondView viewDidDisappear
2016-03-24 10:56:49.091 SIMAlbum[35103:546098] FirstVC viewDidAppear
2016-03-24 10:56:49.093 SIMAlbum[35103:546098] FirstVC viewWillLayoutSubviews
2016-03-24 10:56:49.093 SIMAlbum[35103:546098] FirstVC viewDidLayoutSubviews

代码加载viewController

依旧做了个实验，进入代码生成的viewController时控制台输出如下：

2016-03-24 11:09:49.361 SimDraw[36310:564381] FirstVC loadView
2016-03-24 11:09:49.370 SimDraw[36310:564381] FirstVC viewDidLoad
2016-03-24 11:09:49.381 SimDraw[36310:564381] FirstVC viewWillAppear
2016-03-24 11:09:49.393 SimDraw[36310:564381] FirstVC viewWillLayoutSubviews
2016-03-24 11:09:49.393 SimDraw[36310:564381] FirstVC viewDidLayoutSubviews
2016-03-24 11:09:49.395 SimDraw[36310:564381] FirstVC viewWillLayoutSubviews
2016-03-24 11:09:49.395 SimDraw[36310:564381] FirstVC viewDidLayoutSubviews
2016-03-24 11:09:49.929 SimDraw[36310:564381] FirstVC viewDidAppear

退出时

2016-03-24 11:10:20.636 SimDraw[36310:564381] FirstVC viewWillDisappear
2016-03-24 11:10:21.166 SimDraw[36310:564381] FirstVC viewDidDisappear

分析与总结

以上的结果简单粗暴，虽然和印象中的一样，但是还是有些许出入，我系统的做了个viewControll的图：

注意到其中的viewWillLayoutSubviews和viewDidLayoutSubviews，调用情况视具体的viewDidLoad和viewWillAppear等方法中的代码而定。

viewWillLayoutSubviews调用情况分析

• init初始化不会触发layoutSubviews
• addSubview会触发layoutSubviews
• 设置view的Frame会触发layoutSubviews，当然前提是frame的值设置前后发生了变化
• 滚动一个UIScrollView会触发layoutSubviews
• 旋转Screen会触发父UIView上的layoutSubviews事件
• 改变一个UIView大小的时候也会触发父UIView上的layoutSubviews事件

CGAffineTransform

A structure for holding an affine transformation matrix.

以上是它的定义，其实就是一个矩阵的结构体，经常用于动画，形状变换。
包含如下参数：

struct CGAffineTransform { CGFloat a; CGFloat b; CGFloat c; CGFloat d; CGFloat tx; CGFloat ty; }; typedef struct CGAffineTransform CGAffineTransform;  

下面直观的描述这个这个矩阵和坐标之间的关系。

一个实验

• 给一个UIImageView添加手势

    //zoom手势
    UIPinchGestureRecognizer* zoomer = [[UIPinchGestureRecognizer alloc] initWithTarget:self action:@selector(editImageWithZoom:)];
    
    UIRotationGestureRecognizer* rotation = [[UIRotationGestureRecognizer alloc] initWithTarget:self action:@selector(editImageWithRotation:)];
    [imageView addGestureRecognizer:zoomer];
    
    [imageView addGestureRecognizer:rotation];
  

• 手势实现方法

//缩放
-(void)editImageWithZoom:(UIPinchGestureRecognizer*)sender
{
    CGAffineTransform transform= CGAffineTransformScale(originTransform, sender.scale, sender.scale);
    imageView.transform=transform;
}
//旋转
-(void)editImageWithRotation:(UIRotationGestureRecognizer*)sender
{
    CGAffineTransform transfrom = CGAffineTransformRotate(originTransform, sender.rotation);
    imageView.transform=transfrom;
}

其中的两个方法CGAffineTransformScale和CGAffineTransformRotate是生成旋转和缩放的矩阵，当然也可以直接使用通用方法

CGAffineTransform CGAffineTransformMake ( CGFloat a, CGFloat b, CGFloat c, CGFloat d, CGFloat tx, CGFloat ty );

生成对应的矩阵。

• 继续变换

不修改任何代码，继续缩放和旋转。会发现每次都重新归位后旋转。
原来是CGAffineTransformIdentity这个常量搞的鬼。
每一次的rotate和scale都是在这个常量的基础上变换的。

这个是它的定义。
解决这个问题只要在手势代码中加入

    if(sender.state==UIGestureRecognizerStateEnded || sender.state==UIGestureRecognizerStateCancelled)
    {
        //结束手势
        originTransform=imageView.transform;
    }

其中的originTransform可以定义为成员变量，初始化代码。

originTransform = CGAffineTransformIdentity;

• 坐标变换之后出现的问题

  意识到CGAffineTransform所做的变换其实是对坐标系做的变换。因此变换完以后使用平移操作会发现坐标系变换以后产生的影响。解决方案：

• 取父view的坐标系，更改imageView.center，因为不论是scale还是rotation，center的点是不变的。

获取变换后的参数

变换以后需要取得变换以后的scale和rotation。
打变量观察。

(lldb) po transistion
 (a = 0.69003591274966281, b = -1.6204680103221447, c = 1.6204680103221447, d = 0.69003591274966281, tx = 0, ty = 0)  

其中scale是(双指缩放sx=sy)：

rotation是：

联合作用在单位对角矩阵上：可以得到最终的transfrom:

可以解得：
好吧根本解不出来。另寻他路。

打算用成员变量接受每一次旋转和缩放后的参数。
打出每一次旋转和缩放操作的scale和rotation。发现每一次都是重新从1和0开始计算。
于是简单了，在每一次手势结束的时候加上原来的参数。

-(void)editImageWithRotation:(UIRotationGestureRecognizer*)sender
{

    CGAffineTransform transfrom = CGAffineTransformRotate(originTransform, sender.rotation);
    imageView.transform=transfrom;
   // NSLog(@"%lf",sender.rotation);
    if(sender.state==UIGestureRecognizerStateEnded || sender.state==UIGestureRecognizerStateCancelled)
    {
        //结束手势
        radians = radians+sender.rotation;
        originTransform=imageView.transform;
    }
}

scale类似方法获得。
输出最后imageView的frame和最开始的frame。

frame = (247.357 307.2; 273.285 409.6)  //最初的
frame = (142.016 271.144; 483.968 481.711)  //变换后的
r = 0.79710480433663233  //旋转参数

在swift的牛逼的playground下调试

let r = 0.79710480433663233
let w = 273.285
let h = 409.6
let nw = h*cos(r)+w*sin(r)
let nh = h*sin(r)+w*cos(r)

发现rect旋转后的rect其实是这样：

所以要获取用户变换以后的图片，可以这么来。

    UIImage* editedImge = [image imageByScalingToSize:CGSizeMake(originRect.size.width*scale, originRect.size.height*scale)];
    editedImge = [editedImge imageRotatedByRadians:rotation];
    
    //获取最终点的坐标
    [editedImge drawInRect:rect];

大功告成。

实现选择

网上大部分的教程，都是基于修改section的hearderView来实现的，但是看QQ的好友列表，style是grouped，显然不是使用section的header来处理。使用section的hearderView来实现的，十分简单，网上也有很多源码和教程，只要刷新一下dataSource然后调用就可以了。不在本次讨论的范围之内。

- (void)reloadSections:(NSIndexSet *)sections

这次我直接使用grouped的cell来做父cell，点击后展开相应的子cell，还有动画特效。(目测QQ好友列表没有使用动画特效，可能是因为好友列表过于大，内存占用问题或者是用户体验问题。)

封装测试数据

使用FMDB(或者CoreData)从objc中国获取主issue作为父级cell，文章作为subCell，具体获取使用python和BeautifulSoup，不在本次的讨论范围之内，需要的可以查看相应的资料或者留言我，也可以在文末的项目源码里获取python代码。

具体实现分析

TableView一些相关方法介绍

delegate里和点击有关的方法如下。

- (NSIndexPath *)tableView:(UITableView *)tableView willSelectRowAtIndexPath:(NSIndexPath *)indexPath
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
- (NSIndexPath *)tableView:(UITableView *)tableView willDeselectRowAtIndexPath:(NSIndexPath *)indexPath
- (void)tableView:(UITableView *)tableView didDeselectRowAtIndexPath:(NSIndexPath *)indexPath

当有点击事件发生时，运行顺序为。

• willSelect
• willDeselect
• didDeselect
• didSelect

插入删除cell的方法为

- (void)insertRowsAtIndexPaths:(NSArray *)indexPaths withRowAnimation:(UITableViewRowAnimation)animation
- (void)deleteRowsAtIndexPaths:(NSArray *)indexPaths withRowAnimation:(UITableViewRowAnimation)animation

记得把他们放在

[table beginUpdates];
//input insert/delete code here
[table endUpdates];

逻辑分析

在didSelect的时候执行插入代码。

        [tableView beginUpdates];
        [tableView insertRowsAtIndexPaths:indexArray withRowAnimation:UITableViewRowAnimationTop];
        [tableView endUpdates];

        [tableView beginUpdates];
        [tableView deleteRowsAtIndexPaths:indexArray withRowAnimation:UITableViewRowAnimationRight];
        [tableView endUpdates];

其中的indexArray需要动态计算。类似这样。

        NSMutableArray* indexArray = [NSMutableArray array];
        for (int i=1; i<=masterModel.subIuuses.count; i++) {
            NSIndexPath* path = [NSIndexPath indexPathForRow:i+indexPath.row inSection:indexPath.section];
           [indexArray addObject:path];
        }

可以实现这样的效果。

问题分析

看起来没有什么问题。
但是当点击的是展开的cell下方的cell时，indexPath就会出现问题。像下面这样。

我要点击的是2x，但是实际上点击的却是4x，问题出在哪里？看这个图片就会发现问题，原来还是那几个方法的执行顺序问题。
在执行的时候，先执行didDeselect里面的代码，导致插入的cell被删除，indexPath变化，然后再didSelect，当然选中的不是我们想要选中的那个cell了。

解决方案

如下图。

只要willSelect的时候return一个新的indexPath即可，这个indexPath通过计算得出。下面是我的willSelect里的实现代码。

-(NSIndexPath *)tableView:(UITableView *)tableView willSelectRowAtIndexPath:(NSIndexPath *)indexPath
{
    UITableViewCell* cell = [tableView cellForRowAtIndexPath:indexPath];
    if (cell && [cell isMemberOfClass:[SIMMasterTableViewCell class]]) {
        //点击masterCell
        if (_isShowIssues) {
            //展开状态
            if(indexPath.row>_lastSelectMatserIndexPath.row)
                return [NSIndexPath indexPathForRow:indexPath.row-_lastModelIssuesCount inSection:indexPath.section];
            else
                return indexPath;
        }
        return  indexPath;
    }
    else if(cell)
    {
        _isSelectSubCell = YES;
        return indexPath;
        //点击到uitableviewcell
    }
    return  indexPath;
}

最后放上一张效果图。

项目源码:https://github.com/XFerris/SIMObjc