Freelf Blog

2024

2025-01-24

博客好久没更新了，好像自从来了快手就没更新过。今天虽然已经在阳历上算 2025 了，但是今天除夕，在传统上节日上，还没有步入 2025。所以趁今天赶紧更新一篇生活记录。

学习

今年依然没有在工作外学习任何新的知识。只是趁着年底学了一下 vim 和形码，聊胜于无。发现来快手 4 年，貌似没有什么进步，果然来大厂后懈怠了。希望明年能多学习一些新的知识吧，毕竟互联网行业本身就是需要一个持续学习的行业。

发现每年给自己列目标，都是列很多，然后到年底完不成会比较焦虑。所以今年还是少列一些，毕竟排除工作外，自己所剩的精力已经不是很多。今年主要学习一下前端的知识，毕竟客户端已经到了一片蓝海区。学习前端，后续找一些远程工作，应该还是比较容易。到了这个年龄，现在想的永远是退路。另外 C++还是要学，毕竟现在工作主要写的就是 C++，去年说学，也没有学完。CS61C 还是继续提上日程吧，计算机基础还是要打牢。

列着列着，好像又不少了，就此打住，总结为以下三点吧～

技术：前端、C++、CS61C
英语：单词累计，培养用英语习惯，欧路记录生词背诵
算法：争取每日一题

工作

在工作上比较符合预期，前半年基本在搞一些稳定性问题。后半年自己一个人做了一个大的重构，为后续 SDK 的迭代打了一些基础。最后的绩效也比较符合预期，所以今年在工作上还算比较满意，希望明年可以再接再厉吧。

旅游

在 23 年 318 进藏后，无时无刻不在想着去阿里看看，所以今年趁着国庆假期去了一趟阿里，走了一趟阿里环线。阿里的景色真的是无可挑剔，雪山圣湖目不暇接，对于我这种自驾爱好者简直就是天堂。由于大多游客都是从拉萨去定日看珠峰，很少再往西走了。所以过了定日，车就很少，开起车来会很舒服，和高速差不多。不过由于假期的原因，租车和住宿都比较贵，加上阿里的物价也很贵，所以走下来还是花了不少钱。明年还是在非节假日请假年出行吧。阿里游记该写一下啦~

旅行就像充电，每次旅行，都会暂时忘记在城市里的一些烦恼。整个人会比较放松，焦虑也会变的少一些。明年还是争取多在北京周边摩旅吧，毕竟摩托车在北方，只能骑那么几个月，珍惜机会。

健身

今年不出意外的又没有把健身提到日程，导致自己又胖了 10 斤。但是身体情况还算好，没有怎么生病，只是在国庆前感冒了一次。差点阿里之行就泡汤了。今年特地批了一个健身预算，准备去学习打一下羽毛球。跑步真的对我来讲有点枯燥，每天跑步会消耗我大量的意志力，明年再试试吧，可能方法不太对。

去年一整年，周末都在家躺平，导致每次周末过的比工作日还累。今年必须改善一下，周末多出去走走，不能总在家待着。总在家，整个人就比较颓，越颓越不想出去。所以今年需要打破一下这个循环，我还年轻，哈哈。

投资

今年的大部分资金还是在 A 股，虽然经历了一波大涨，但是目前还是亏损状态。不过今年已经逐步在构建自己的投资体系，希望明年可以用上。港股已经回本，得益于美团的增长，希望明年能继续带来惊喜。

经过几年的胡乱操作，终于意识到组合的重要性。希望明年能构建起自己的投资组合，减少瞎操作带来的精力浪费，把精力放到工作上，提高自己的工作收入。

其他

结婚已经两年多了，妻子年龄也不小了，到了要娃的时候了，明年也需要提上日程了。自己本身也想有个娃，想跟娃一起玩耍了。明年事情真多呀，多多努力吧。

新疆游，一次不完美的旅途

2021-12-22

本来今年没打算去新疆，打算去走川藏线的，但是看了看川藏线好像时间不太足。所以最后决定去新疆走一波。原本计划是去一下北疆的喀纳斯，然后去走赛里木湖+独库的，但是中间因为伊犁疫情的原因没有去走赛里木湖和独库，最后走了一个北疆环线，喀纳斯+可可托海+鄯善库木塔格沙漠。

行程

此次行程一共9天，行程如下：

9月30日：石家庄-乌鲁木齐-乌尔禾，晚上住在乌尔禾 景点：世界魔鬼城

10月1日：乌尔禾-禾木，住禾木 景点：禾木村

10月2日：禾木-喀纳斯，住贾登峪 景点：喀纳斯

10月3日：喀纳斯-布尔津，住布尔津

10月4日：布尔津-吐鲁番，住吐鲁番

10月5日：吐鲁番-乌鲁木齐，住乌鲁木齐 景点：库木塔格沙漠

10月6日：乌鲁木齐-可可托海，住可可托海镇 景点：可可托海

10月7日：可可托海-乌鲁木齐，住乌鲁木齐 景点：国际大巴扎

10月8日：乌鲁木齐-北京

花费

旅途

石家庄飞乌鲁木齐需要4个小时，国庆前后机票都太贵了，也着实被民航坑了一把，我们是提前两个星期买的票，当时北京飞乌鲁木齐机票是3000一张，太贵了。就买了石家庄出发的，两张3000。出发前一天因为有同事要一起去，两张同样的机票1500就能买到，被坑了。不过也涨了经验，机票要么早买，要么就出发前一周内再买。我们特意买了早上的机票，12点就到乌鲁木齐了。

为了节约时间，我们取完车简单吃了个午饭就直接出发去了乌尔禾。乌鲁木齐到乌尔禾的路上风景基本上都是平原，风景一般。天快黑的时候到了魔鬼城。

魔鬼城我感觉一般，本来有的一些苍凉感已经被商业化抹掉了。本人还是比较喜欢自然风光，有山有水的地方。而且乌尔禾吃的也一般，烤串非常一般，吃完后我回酒店又买了个泡面吃。

在乌尔禾住了一晚后，第二天启程去喀纳斯。喀纳斯景区其实很大，主要包括3个部分，一个是禾木，一个是喀纳斯景区，另外一个是白哈巴。为了看禾木的晨雾，我们第二天出发直接去了禾木，午饭是在布尔津县城解决的。这次没有大众点评，而是在街边随便找了一家拌面店，意外的好吃。吃完午饭就出发去禾木。这一天路途比较长，400多公里，而且后面基本上山路。两个人开车比较好一些。乌尔禾到禾木的风景还是不错的，尤其是布尔津到禾木这一段。禾木景区入口到里面的禾木村落还需要搭乘摆渡车，大约40分钟车程。等我们到了酒店天也快黑了。先去酒店办理入住，然后去村落游玩了一圈。村落有环公交车。我们住在了禾木山庄，这应该是禾木最好的酒店了，当然价格也是十分美丽。禾木商业化也比较严重了，分为老村和新村，感觉都变成民宿和饭馆了。

第二天早上起床去看晨雾，然后发现没有雾，十月的早上那边已经很冷了，感觉有零下了，幸亏酒店提供了棉大衣。匆匆拍了几张照片就回去吃早饭了，准备出发到喀纳斯了。

在酒店吃完早饭，10点多钟，我们就出发去喀纳斯了，因为导航走错了100多公里路，路上还遇到了风雪，到喀纳斯已经下午4点了，其实禾木离喀纳斯很近，不需要下山，而是在半路有个分叉口。一边去禾木，一边就是喀纳斯，我们导航给导到白哈巴了，直到路过一个公安检查站问我们要边防证才反应过来。本来计划下午去喀纳斯买个二进票先去喀纳斯湖玩一下的。喀纳斯住宿有两种选择，一个是住在景区里面，景区里面就是民宿，条件较差。另外就是住在贾登峪，贾登峪商业化比较严重了，但是饭也是一言难进，中午吃了一下，晚饭还是泡面解决了。由于导航错浪费时间，当天就没有进去喀纳斯。我们选择第二天再去。喀纳斯主要游玩的就三个地方，一个是三湾(月亮湾，神仙湾，卧龙湾)，一个是喀纳斯湖，还有一个是观鱼台。观鱼台可以俯瞰整个喀纳斯湖，个人看观鱼台是必须去的，在湖边可以感受湖的宽广，观鱼台是一个俯瞰的角度，景色不一样。

按照时间安排，三湾是早上游玩的，因为有晨雾会很好。但是观鱼台一天放票时间有限，所以我们选择先去观鱼台。因为前两天下雪了，我们去的时候观鱼台还在清理积雪，还没开放，所以我们就先去喀纳斯湖转了一圈。

在湖边逛了逛听说观鱼台放票了，我们就去买观鱼台的票了。爬上观鱼台要走1000多个台阶，但是上面的风景绝对值得爬。从观鱼台看喀纳斯湖是这样的。

除了喀纳斯湖，其他的景色也不错，比如下面这些：

总之观鱼台值得上。来两个航拍视频(素材来自白嫖，自己拍的比较垃圾)：

从观鱼台下来就已经3点多了，我们准备回布尔津了，回去的路上匆匆打卡了三湾。

神仙湾：

月亮湾：

卧龙湾：

喀纳斯绝对是值得花时间游玩的，可以早上花两天慢慢玩，听说早上神仙湾晨雾很美，我们是下午去的，就没看到了，只是匆匆打卡了。三湾是有步行栈道的。可以从神仙湾步行到卧龙湾，然后再回景区入口。这个等后面再来时再玩吧。

从喀纳斯出来，我们就回布尔津了，按照既定行程，我们在布尔津住一晚，然后去赛里木湖，走独库公路的，但是因为伊犁爆发了疫情，赛里木湖关门了，独库公路也封路了。我们只能中断计划，把后面的酒店都退了。同行的同事害怕新疆因为疫情封城想直接回北京了，所以我们在布尔津住了一晚。第二天就直接回乌鲁木齐送同事回北京。因为假期刚开始三天，想着新疆很大，而且疫情区在南疆，我们就临时改变路线去了吐鲁番看沙漠了。

第二天我们从布尔津直接开车路过乌鲁木齐把同事送到机场，就直接到了吐鲁番。开了一路夜车，中间路上就我们一辆车还是挺害怕的。在吐鲁番住了一晚，我们第二天就去了鄯善的库木塔格沙漠。可以选择坐景区的车游览沙漠，也可以自驾，我们直接选择了自驾。因为第一次见沙漠，所以还是挺震撼的。我们做了沙漠飞车，还是蛮刺激的。沙漠飞车就是把你拉到沙漠上面，然后在上面玩。坐沙漠飞车的地方可以租滑沙板，但是上去之后根本没法滑。所以记住一定不要在这里租滑沙板，有专门的滑沙区。去那里滑，因为时间有限，我们就没有滑了。

沙漠玩了一天，本来计划直接回北京的，但是想着好不容易来了，决定再去北疆的可可托海玩一圈，把北疆的景区都玩一下。所以从鄯善回到乌鲁木齐后，在乌鲁木齐住了一晚，第二天就启程去可可托海了。从乌鲁木齐到可可托海段要路过一段没有加油站的地区，所以一定要在加油站加满油。路上的风景也很美，一望无际的草地，偶尔有几只牛马在风雪里面奔跑。总之在这种景色下就感觉自己很渺小。我们是吃过午饭才从乌鲁木齐出发的，傍晚的时候到了富蕴县。

可可托海是富蕴县下面的一个镇，我们在富蕴吃了个晚饭，然后就前往可可托海了。路程有40公里，都是山路。而且我们去的时候已经晚上了，基本上没车。你只会看到前面的路，左右两侧一片漆黑，还是挺害怕的。这一天行程也基本在路上了。第二天就去了可可托海。说实话去过喀纳斯，再去可可托海，感觉可可托海景色就一般了。可可托海主要有几个地方，一个是可可托海景区，另外还有一个三号矿坑，这里面为我国工业提供了稀有金属。还帮我们国家还了苏联的债务。

因为时间原因，三号矿坑就没有去了。回去的路上路过一个水库风景不错，后面查了一下是海子口水库。

从可可托海回富蕴的时候是下午，路上风景很不错，一大片草原，上面有牧民在放牛羊。路上路过可可苏里湿地。

去富蕴吃了个午饭，然后就回乌鲁木齐啦。

在乌鲁木齐住了一晚，第二天逛了逛国际大巴扎，买了点特产，晚上就回北京了。一定要注意，买冰箱贴一定要还价，我们在大巴扎里面买的30块，走了两步出来，10块钱一个。。。

旅途依然有遗憾，没有走独库和赛里木湖，这个就放给明年吧。因为这次行程主要集中在北疆，整个行程下来就是喀纳斯一定值得花时间玩，其他的魔鬼城和可可托海可以选择。如果走环线的话，建议乌鲁木齐-可可托海-喀纳斯-乌鲁木齐。这样整个北疆都可以玩完。我们这次因为疫情走了很多重复的路程。下次再去主要就是赛里木湖和独库啦。北疆建议秋天去，树叶变黄了，景色会很美。记得带冬天的衣服，因为北疆10月就会下雪啦。打工人的旅程永远这么短暂，好希望有一个很长的假期，环游一下中国，见识一下祖国的大好河山。哎，还是先搬砖赚钱吧，没钱哪里来的假期。。。。

Aspects源码分析

2020-12-09

最近有个需求用到了Aspects这个库，用的过程中发现了一些问题，为了解决问题，花了几天时间精读了一遍Aspects的源码。读的过程中发现这个库如果发散着去读，可以了解Objective-C这个语言的方方面面。这篇文章就不发散了，本篇集中记录Aspects如何去进行Hook方法的。后面可能会写一些Aspects发散的文章。本篇分析采用从入口方法开始，然后用到哪个方法会分析哪个方法。

Aspects入口方法

Aspects为NSObject写了一个分类，添加了两个方法，一个是类方法，一个是实例方法，方法名都一样，具体方法如下：

+ (id<AspectToken>)aspect_hookSelector:(SEL)selector
                           withOptions:(AspectOptions)options
                            usingBlock:(id)block
                                 error:(NSError **)error;
- (id<AspectToken>)aspect_hookSelector:(SEL)selector
                           withOptions:(AspectOptions)options
                            usingBlock:(id)block
                                 error:(NSError **)error;

这两个方法都直接调用了aspect_add方法，这个方法才是hook的真正入口，这个方法的实现如下：

static id aspect_add(id self, SEL selector, AspectOptions options, id block, NSError **error) {
    NSCParameterAssert(self);
    NSCParameterAssert(selector);
    NSCParameterAssert(block);

    __block AspectIdentifier *identifier = nil;
    // 1. 加锁，保证线程安全
    aspect_performLocked(^{
    // 2. 判断是否可以hook
        if (aspect_isSelectorAllowedAndTrack(self, selector, options, error)) {
        // 3.1 获取aspect容器
            AspectsContainer *aspectContainer = aspect_getContainerForObject(self, selector);
            //3.2 生成aspect标识，每个标识对应一个aspect
            identifier = [AspectIdentifier identifierWithSelector:selector object:self options:options block:block error:error];
            if (identifier) {
            //3.3 将aspect添加到容器里面
                [aspectContainer addAspect:identifier withOptions:options];
                // 4.进行hook
                aspect_prepareClassAndHookSelector(self, selector, error);
            }
        }
    });
    return identifier;
}

通过这个入口方法可以了解到添加一个hook的具体过程，具体过程如下：

先加锁保证线程安全(这里如果发散的话，其实可以了解一下iOS中的各种锁)。
判断是否可以添加hook
如果可以hook的话，创建对应的aspect标识，如果标识创建成功，添加到容器，进行下一流程。
进行hook

用一张图来表示整个流程的话就如下图所示：

aspect_performLocked

aspect_performLocked这个方法很简单，就是一个加锁的方法，代码如下：

static void aspect_performLocked(dispatch_block_t block) {
    static OSSpinLock aspect_lock = OS_SPINLOCK_INIT;
    OSSpinLockLock(&aspect_lock);
    block();
    OSSpinLockUnlock(&aspect_lock);
}

这里使用了OSSpinLock，这是个自旋锁，关于锁的知识，这里不展开讲，后面可能会专门写文章去研究锁。这个方法主要保证我们添加aspect时的线程安全。

aspect_isSelectorAllowedAndTrack

aspect_isSelectorAllowedAndTrack这个方法是检查是否可以添加aspect。代码比较长，这里逐步进行分析。

static NSSet *disallowedSelectorList;
static dispatch_once_t pred;
dispatch_once(&pred, ^{
    disallowedSelectorList = [NSSet setWithObjects:@"retain", @"release", @"autorelease", @"forwardInvocation:", nil];
});

// Check against the blacklist.
NSString *selectorName = NSStringFromSelector(selector);
if ([disallowedSelectorList containsObject:selectorName]) {
    NSString *errorDescription = [NSString stringWithFormat:@"Selector %@ is blacklisted.", selectorName];
    AspectError(AspectErrorSelectorBlacklisted, errorDescription);
    return NO;
}

这里创建了一个不允许hook的方法集合，如果要hook的方法在集合中，直接返回NO，不允许hook。

// Additional checks.
AspectOptions position = options&AspectPositionFilter;
// dealloc 只允许option为before时hook
if ([selectorName isEqualToString:@"dealloc"] && position != AspectPositionBefore) {
    NSString *errorDesc = @"AspectPositionBefore is the only valid position when hooking dealloc.";
    AspectError(AspectErrorSelectorDeallocPosition, errorDesc);
    return NO;
}

这里对hook dealloc方法做了判断，dealloc方法只允许在option为AspectPositionBefore时才允许hook。

if (![self respondsToSelector:selector] && ![self.class instancesRespondToSelector:selector]) { // 查看类中是否有hook的方法
    NSString *errorDesc = [NSString stringWithFormat:@"Unable to find selector -[%@ %@].", NSStringFromClass(self.class), selectorName];
    AspectError(AspectErrorDoesNotRespondToSelector, errorDesc);
    return NO;
}

如果当前类没有响应要hook的方法，直接返回NO不允许hook。

接下来有个判断，class_isMetaClass(object_getClass(self))，object_getClass是获取当前类的isa指针指向的对象。如果当前类的isa是元类就会进行下面一系列检查。Objective-C中只有类对象的isa指向元类。所以如果调用hook方法的是一个实例对象，这里直接返回YES。如果是类对象这里要进行判断。加这个判断的主要是为了保证在类继承体系上只允许对一个方法进行一次hook。下面来看一下是如何保证的：

Class klass = [self class];
NSMutableDictionary *swizzledClassesDict = aspect_getSwizzledClassesDict();
Class currentClass = [self class];

这里声明了3个变量，其中klass和currentClass都代表当前类。swizzledClassesDict是一个可变的字典。获取可变字典通过一个函数获取的，代码如下：

static NSMutableDictionary *aspect_getSwizzledClassesDict() {
    static NSMutableDictionary *swizzledClassesDict;
    static dispatch_once_t pred;
    dispatch_once(&pred, ^{
        swizzledClassesDict = [NSMutableDictionary new];
    });
    return swizzledClassesDict;
}

接下来看下面的代码用到了一个类AspectTracker，先来看一下AspectTracker的实现，AspectTracker的实现很简单，对应的方法在下面代码中已经标明注释

// AspectTracker interface
@interface AspectTracker : NSObject
- (id)initWithTrackedClass:(Class)trackedClass;
// 当前tracker的类
@property (nonatomic, strong) Class trackedClass;
// 当前tracker对应的类名
@property (nonatomic, readonly) NSString *trackedClassName;
// 当前类hook的方法名
@property (nonatomic, strong) NSMutableSet *selectorNames;
// 记录tracker类子类的tracker，key是selectorName，value是set
@property (nonatomic, strong) NSMutableDictionary *selectorNamesToSubclassTrackers;
// 添加对应selectorName方法的子类tracker
- (void)addSubclassTracker:(AspectTracker *)subclassTracker hookingSelectorName:(NSString *)selectorName;
// 移除对应selectorName方法的子类tracker
- (void)removeSubclassTracker:(AspectTracker *)subclassTracker hookingSelectorName:(NSString *)selectorName;
// 判断子类是否hook了当前方法
- (BOOL)subclassHasHookedSelectorName:(NSString *)selectorName;
// 获取当前类对应selectorName的子类tracker
- (NSSet *)subclassTrackersHookingSelectorName:(NSString *)selectorName;
@end

// AspectTracker implementation
@implementation AspectTracker

- (id)initWithTrackedClass:(Class)trackedClass {
    if (self = [super init]) {
        _trackedClass = trackedClass;
        _selectorNames = [NSMutableSet new];
        _selectorNamesToSubclassTrackers = [NSMutableDictionary new];
    }
    return self;
}

- (BOOL)subclassHasHookedSelectorName:(NSString *)selectorName {
    return self.selectorNamesToSubclassTrackers[selectorName] != nil;
}

- (void)addSubclassTracker:(AspectTracker *)subclassTracker hookingSelectorName:(NSString *)selectorName {
    NSMutableSet *trackerSet = self.selectorNamesToSubclassTrackers[selectorName];
    if (!trackerSet) {
        trackerSet = [NSMutableSet new];
        self.selectorNamesToSubclassTrackers[selectorName] = trackerSet;
    }
    [trackerSet addObject:subclassTracker];
}
- (void)removeSubclassTracker:(AspectTracker *)subclassTracker hookingSelectorName:(NSString *)selectorName {
    NSMutableSet *trackerSet = self.selectorNamesToSubclassTrackers[selectorName];
    [trackerSet removeObject:subclassTracker];
    if (trackerSet.count == 0) {
        [self.selectorNamesToSubclassTrackers removeObjectForKey:selectorName];
    }
}
- (NSSet *)subclassTrackersHookingSelectorName:(NSString *)selectorName {
    NSMutableSet *hookingSubclassTrackers = [NSMutableSet new];
    for (AspectTracker *tracker in self.selectorNamesToSubclassTrackers[selectorName]) {
        if ([tracker.selectorNames containsObject:selectorName]) {
            [hookingSubclassTrackers addObject:tracker];
        }
        [hookingSubclassTrackers unionSet:[tracker subclassTrackersHookingSelectorName:selectorName]];
    }
    return hookingSubclassTrackers;
}
- (NSString *)trackedClassName {
    return NSStringFromClass(self.trackedClass);
}

- (NSString *)description {
    return [NSString stringWithFormat:@"<%@: %@, trackedClass: %@, selectorNames:%@, subclass selector names: %@>", self.class, self, NSStringFromClass(self.trackedClass), self.selectorNames, self.selectorNamesToSubclassTrackers.allKeys];
}

@end

接下来看一下如何使用AspectTracker的：

AspectTracker *tracker = swizzledClassesDict[currentClass];
// 先检查子类是否Hook
if ([tracker subclassHasHookedSelectorName:selectorName]) {
    NSSet *subclassTracker = [tracker subclassTrackersHookingSelectorName:selectorName];
    NSSet *subclassNames = [subclassTracker valueForKey:@"trackedClassName"];
    NSString *errorDescription = [NSString stringWithFormat:@"Error: %@ already hooked subclasses: %@. A method can only be hooked once per class hierarchy.", selectorName, subclassNames];
    AspectError(AspectErrorSelectorAlreadyHookedInClassHierarchy, errorDescription);
    return NO;
}

先获取当前类的tracker，然后检查当前类的子类是否已经对要进行hook的方法进行了hook，如果已经进行了hook，抛出错误。返回NO不允许进行hook。如果子类没有进行hook，继续执行以下代码：

// 检查父类是否hook
do {
    tracker = swizzledClassesDict[currentClass];
    if ([tracker.selectorNames containsObject:selectorName]) {
        if (klass == currentClass) {
            // Already modified and topmost!
            return YES;
        }
         NSString *errorDescription = [NSString stringWithFormat:@"Error: %@ already hooked in %@. A method can only be hooked once per class hierarchy.", selectorName, NSStringFromClass(currentClass)];
         AspectError(AspectErrorSelectorAlreadyHookedInClassHierarchy, errorDescription);
         return NO;
     }
} while ((currentClass = class_getSuperclass(currentClass))); //遍历所有的父类，直到为nil

这个方法是从自己开始往父类进行遍历，看看是否进行hook，如果当前类已经hook，返回YES，允许添加hook，如果是父类已经Hook，抛出错误，返回NO，不允许hook。

如果代码可以走到下面说明当前类的继承体系上没有类对要进行hook的selector进行过hook，最后肯定返回YES，只是在返回YES前需要进行把给当前类添加tracker，并且在父类继承体系上面打标记，标记这个方法已经有类hook过了，当用继承体系其他类进行hook时，在前面两步就可以拦住。

// 添加Hook的tracker，当前类和父类继承体系里面的都会添加。hook一个方法只会有一次这里。只有再次hook不同方法时才会再次走这里。
// Add the selector as being modified.
currentClass = klass;
AspectTracker *subclassTracker = nil;
do {
    tracker = swizzledClassesDict[currentClass];
    if (!tracker) {
        tracker = [[AspectTracker alloc] initWithTrackedClass:currentClass];
        swizzledClassesDict[(id<NSCopying>)currentClass] = tracker;
    }
    if (subclassTracker) {
        [tracker addSubclassTracker:subclassTracker hookingSelectorName:selectorName];
    } else {
        [tracker.selectorNames addObject:selectorName];
    }
    // All superclasses get marked as having a subclass that is modified.
    subclassTracker = tracker;
} while ((currentClass = class_getSuperclass(currentClass)));

总结

aspect_isSelectorAllowedAndTrack这个方法用来判断是否可以为当前类的某个方法添加aspect，主要会进行以下几步验证：

黑名单验证
dealloc不允许在option为非AspectPositionBefore的情况下hook
当前类没有响应该方法
继承体系上面不允许多个类进行hook

进行Hook

如果允许hook，下面进行hook流程。

AspectsContainer

前面代码3.1是先获取aspectContainer，代码比较简单，这里就不进行解释了

AspectsContainer *aspectContainer = aspect_getContainerForObject(self, selector);
// aspect_getContainerForObject
static AspectsContainer *aspect_getContainerForObject(NSObject *self, SEL selector) {
    NSCParameterAssert(self);
    SEL aliasSelector = aspect_aliasForSelector(selector);
    AspectsContainer *aspectContainer = objc_getAssociatedObject(self, aliasSelector);
    if (!aspectContainer) {
        aspectContainer = [AspectsContainer new];
        objc_setAssociatedObject(self, aliasSelector, aspectContainer, OBJC_ASSOCIATION_RETAIN);
    }
    return aspectContainer;
}
// aspect_aliasForSelector
static SEL aspect_aliasForSelector(SEL selector) {
    NSCParameterAssert(selector);
	return NSSelectorFromString([AspectsMessagePrefix stringByAppendingFormat:@"_%@", NSStringFromSelector(selector)]);
}

// AspectsMessagePrefix
static NSString *const AspectsMessagePrefix = @"aspects_";

AspectIdentifier

AspectIdentifier表示一个aspect，每添加一个aspect，就会生成一个AspectIdentifier放到AspectsContainer中。接下来看一下AspectIdentifier的定义：

// Tracks a single aspect.
@interface AspectIdentifier : NSObject<AspectToken>
// 初始化方法
+ (instancetype)identifierWithSelector:(SEL)selector object:(id)object options:(AspectOptions)options block:(id)block error:(NSError **)error;
// invoke aspect
- (BOOL)invokeWithInfo:(id<AspectInfo>)info;
// hook的方法
@property (nonatomic, assign) SEL selector;
// 要执行的block
@property (nonatomic, strong) id block;
// block的方法签名
@property (nonatomic, strong) NSMethodSignature *blockSignature;
// hook的对象
@property (nonatomic, weak) id object;
// hook的option
@property (nonatomic, assign) AspectOptions options;
@end

从AspectIdentifier的定义可以看出来，它和添加一个aspect的参数几乎是一一对应的，每添加一个aspect，都会生成一个对应的AspectIdentifier保存起来，等执行到对应的方法时，取出对应的aspect调用一下。接下来看一下AspectIdentifier的实现，先看初始化方法：

+ (instancetype)identifierWithSelector:(SEL)selector object:(id)object options:(AspectOptions)options block:(id)block error:(NSError **)error {
    NSCParameterAssert(block);
    NSCParameterAssert(selector);
    // 获取block的方法签名
    NSMethodSignature *blockSignature = aspect_blockMethodSignature(block, error); // TODO: check signature compatibility, etc.
    // 校验block方法签名是否和原方法签名是否兼容
    if (!aspect_isCompatibleBlockSignature(blockSignature, object, selector, error)) {
        return nil;
    }

    AspectIdentifier *identifier = nil;
    if (blockSignature) {
        identifier = [AspectIdentifier new];
        identifier.selector = selector;
        identifier.block = block;
        identifier.blockSignature = blockSignature;
        identifier.options = options;
        identifier.object = object; // weak
    }
    return identifier;
}

这里有两个地方需要重点讲一下，一个是获取block的方法签名，另外一个是校验block签名是否和原方法签名是否兼容。这两个地方看明白会有利于了解Objective-C的本质。

aspect_blockMethodSignature

static NSMethodSignature *aspect_blockMethodSignature(id block, NSError **error) {
    // 找到desc中的方法签名，生成签名
    AspectBlockRef layout = (__bridge void *)block;
	if (!(layout->flags & AspectBlockFlagsHasSignature)) {
        NSString *description = [NSString stringWithFormat:@"The block %@ doesn't contain a type signature.", block];
        AspectError(AspectErrorMissingBlockSignature, description);
        return nil;
    }
	void *desc = layout->descriptor;
	desc += 2 * sizeof(unsigned long int);
	if (layout->flags & AspectBlockFlagsHasCopyDisposeHelpers) {
		desc += 2 * sizeof(void *);
    }
	if (!desc) {
        NSString *description = [NSString stringWithFormat:@"The block %@ doesn't has a type signature.", block];
        AspectError(AspectErrorMissingBlockSignature, description);
        return nil;
    }
	const char *signature = (*(const char **)desc);
	return [NSMethodSignature signatureWithObjCTypes:signature];
}

这里先把传进来的block强制转换成AspectBlockRef类型，从这里可以看出，Objective-C中的block其实就是一个对象，接下来看一下AspectBlockRef的定义：

// Block internals.
typedef NS_OPTIONS(int, AspectBlockFlags) {
	AspectBlockFlagsHasCopyDisposeHelpers = (1 << 25),
	AspectBlockFlagsHasSignature          = (1 << 30)
};
typedef struct _AspectBlock {
	__unused Class isa;
	AspectBlockFlags flags;
	__unused int reserved;
	void (__unused *invoke)(struct _AspectBlock *block, ...);
	struct {
		unsigned long int reserved;
		unsigned long int size;
		// requires AspectBlockFlagsHasCopyDisposeHelpers
		void (*copy)(void *dst, const void *src);
		void (*dispose)(const void *);
		// requires AspectBlockFlagsHasSignature
		const char *signature;
		const char *layout;
	} *descriptor;
	// imported variables
} *AspectBlockRef;

有没有很眼熟，这不就是block的定义么，关于block，后面写一篇专门的文章来讲。这里可以记住，一个block类型在Objective-C中是这样存储的。把传进来的block强制转换成AspectBlockRef类型，是为了取到其中某个变量的值。

接下来看一下如何取出block的方法签名：

if (!(layout->flags & AspectBlockFlagsHasSignature)) {
    NSString *description = [NSString stringWithFormat:@"The block %@ doesn't contain a type signature.", block];
    AspectError(AspectErrorMissingBlockSignature, description);
    return nil;
}

先根据标志位判断当前block是否有签名，如果没有签名，直接报错。返回nil，这里返回nil会打断整个hook流程，也就是要求传进来的block必须是有签名的。如果是有签名的block，接下来就是取签名的过程：

void *desc = layout->descriptor;
desc += 2 * sizeof(unsigned long int);
if (layout->flags & AspectBlockFlagsHasCopyDisposeHelpers) {
    desc += 2 * sizeof(void *);
}
if (!desc) {
     NSString *description = [NSString stringWithFormat:@"The block %@ doesn't has a type signature.", block];
     AspectError(AspectErrorMissingBlockSignature, description);
     return nil;
}
const char *signature = (*(const char **)desc);
return [NSMethodSignature signatureWithObjCTypes:signature];

先取到block中的descriptor指针，descriptor指针向下偏移两个unsigned long int的位置就是copy函数的地址，接下来判断根据flag判断是否包含copy和dispose函数地址，如果包含的话，继续往下偏移两个void *的大小。这时指针肯定移动到了const char *signature的地址，如果desc不存在说明block没有类型签名，也会报错，终止hook。desc有值的话，说明有方法签名，最后返回方法签名。

可以通过调试看一下具体的方法签名，通过如下代码进行调试：

[UIViewController aspect_hookSelector:NSSelectorFromString(@"dealloc") withOptions:(AspectPositionBefore | AspectPositionInstead) usingBlock:^(id<AspectInfo> info){
     NSLog(@"TestOne hook");
} error:NULL];

得到的方法签名如下：

(const char *) signature = 0x000000010d6379e7 "v20@?0@\"<AspectInfo>\"8B16"

想要看懂这串编码需要了解一些Objective-C中type encodings的知识。在Objective-C中，编译器将每个方法的返回值和参数类型编码为一个字符串，并将这个字符串与方法的selector关联在一起。可以通过@encode指令来获取类型编码。在Objective-C Runtime Programming Guide中的Type Encodings中列举了Objective-C中所有的类型编码：需要注意的是Objective-C不支持long double类型，@encode(long double)会返回d，和double的类型编码一样。

了解了这些再来看前面block的签名字符串就能看懂了，"v20@?0@\"<AspectInfo>\"8B16"，v代表返回值类型是void，20代表整个函数的偏移，@?表示block类型，0代表偏移量，@\"<AspectInfo>\"表示第一个参数是遵守AspectInfo协议的对象，8代表偏移量，B表示第二个参数BOOL类型，16是偏移量。

接下来打印一下方法签名，可以看到type encoding和offset和上面的字符串是对应的(除了v的不对应，字符串中v后面的数字应该表示整个函数的偏移，不是相对偏移)。

<NSMethodSignature: 0x600000a902a0>
    number of arguments = 3
    frame size = 224
    is special struct return? NO
    return value: -------- -------- -------- --------
        type encoding (v) 'v'
        flags {}
        modifiers {}
        frame {offset = 0, offset adjust = 0, size = 0, size adjust = 0}
        memory {offset = 0, size = 0}
    argument 0: -------- -------- -------- --------
        type encoding (@) '@?'
        flags {isObject, isBlock}
        modifiers {}
        frame {offset = 0, offset adjust = 0, size = 8, size adjust = 0}
        memory {offset = 0, size = 8}
    argument 1: -------- -------- -------- --------
        type encoding (@) '@"<AspectInfo>"'
        flags {isObject}
        modifiers {}
        frame {offset = 8, offset adjust = 0, size = 8, size adjust = 0}
        memory {offset = 0, size = 8}
            conforms to protocol 'AspectInfo'
    argument 2: -------- -------- -------- --------
        type encoding (B) 'B'
        flags {}
        modifiers {}
        frame {offset = 16, offset adjust = 0, size = 8, size adjust = -7}
        memory {offset = 0, size = 1}

aspect_isCompatibleBlockSignature

aspect_isCompatibleBlockSignature这个函数是校验添加的aspect和原来的方法签名是否相同。如果不同，不允许添加aspect。下面来看一下实现：

static BOOL aspect_isCompatibleBlockSignature(NSMethodSignature *blockSignature, id object, SEL selector, NSError **error) {
    NSCParameterAssert(blockSignature);
    NSCParameterAssert(object);
    NSCParameterAssert(selector);

    BOOL signaturesMatch = YES;
    NSMethodSignature *methodSignature = [[object class] instanceMethodSignatureForSelector:selector];
    if (blockSignature.numberOfArguments > methodSignature.numberOfArguments) {
        signaturesMatch = NO;
    }else {
        if (blockSignature.numberOfArguments > 1) {
            const char *blockType = [blockSignature getArgumentTypeAtIndex:1];
            if (blockType[0] != '@') {
                signaturesMatch = NO;
            }
        }
        // Argument 0 is self/block, argument 1 is SEL or id<AspectInfo>. We start comparing at argument 2.
        // The block can have less arguments than the method, that's ok.
        if (signaturesMatch) {
            for (NSUInteger idx = 2; idx < blockSignature.numberOfArguments; idx++) {
                const char *methodType = [methodSignature getArgumentTypeAtIndex:idx];
                const char *blockType = [blockSignature getArgumentTypeAtIndex:idx];
                // Only compare parameter, not the optional type data.
                if (!methodType || !blockType || methodType[0] != blockType[0]) {
                    signaturesMatch = NO; break;
                }
            }
        }
    }

    if (!signaturesMatch) {
        NSString *description = [NSString stringWithFormat:@"Block signature %@ doesn't match %@.", blockSignature, methodSignature];
        AspectError(AspectErrorIncompatibleBlockSignature, description);
        return NO;
    }
    return YES;
}

该方法，先比较参数个数是否相等，如果不相等直接返回NO，终止hook。接下来再判断第二个参数是否是一个对象，如果不是，直接返回NO。接下来逐个比较参数，看参数类型是否一样，只有所有参数类型一样，才会返回YES，这里需要解释一下比较参数为什么从2开始比较。其实注释已经解释的很清楚了，Objective-C方法中有两个隐藏函数，第一个是self，第二个是_cmd，所以比较传入参数，需要从2开始比较。

接下来带代码就非常简单了，把传入的参数赋值给自己的属性。

aspect_prepareClassAndHookSelector

前面的AspectIdentifier如果可以初始化成功，就会进行hook。aspect_prepareClassAndHookSelector是hook的核心。接下来看一下这个方法的实现：

static void aspect_prepareClassAndHookSelector(NSObject *self, SEL selector, NSError **error) {
    NSCParameterAssert(selector);
    Class klass = aspect_hookClass(self, error); // hook forwardInvocation
    Method targetMethod = class_getInstanceMethod(klass, selector);
    IMP targetMethodIMP = method_getImplementation(targetMethod);
    if (!aspect_isMsgForwardIMP(targetMethodIMP)) { // hook 对应的方法
        // Make a method alias for the existing method implementation, it not already copied.
        const char *typeEncoding = method_getTypeEncoding(targetMethod);
        SEL aliasSelector = aspect_aliasForSelector(selector);
        if (![klass instancesRespondToSelector:aliasSelector]) {
            __unused BOOL addedAlias = class_addMethod(klass, aliasSelector, method_getImplementation(targetMethod), typeEncoding);
            NSCAssert(addedAlias, @"Original implementation for %@ is already copied to %@ on %@", NSStringFromSelector(selector), NSStringFromSelector(aliasSelector), klass);
        }

        // We use forwardInvocation to hook in.
        class_replaceMethod(klass, selector, aspect_getMsgForwardIMP(self, selector), typeEncoding);
        AspectLog(@"Aspects: Installed hook for -[%@ %@].", klass, NSStringFromSelector(selector));
    }
}

这个方法体现了Aspects这个库的hook思想，先来简单总结一下。

Aspects是先把类的forwardInvocation:方法进行hook。
如果想要对类的某个方法进行Hook，Aspects会把想要hook的方法实现指向_objc_msgForward，_objc_msgForward这个函数是一个汇编标记，标记这个方法需要走消息转发流程。关于这块不明白的可以去看一下Objective-C的消息转发流程。当调用已经hook过的方法时，就会走转发流程，因为Aspects已经hook了forwardInvocation:所以就会走Aspects自己的实现，然后Aspects在自己实现里面做一些实现。

aspect_hookClass

这个方法是用来hook类的forwardInvocation:方法，下面来看一下如何hook类的forwardInvocation:方法。

NSCParameterAssert(self);
Class statedClass = self.class;
Class baseClass = object_getClass(self);
NSString *className = NSStringFromClass(baseClass);

statedClass和baseClass是有区别的，对于实力对象而言，这两个意义一样。但是对于类对象而言，statedClass表示自己，baseClass表示元类。

// Already subclassed
// static NSString *const AspectsSubclassSuffix = @"_Aspects_";
if ([className hasSuffix:AspectsSubclassSuffix]) {
    return baseClass;
    // We swizzle a class object, not a single object.
}else if (class_isMetaClass(baseClass)) {
    return aspect_swizzleClassInPlace((Class)self);
    // Probably a KVO'ed class. Swizzle in place. Also swizzle meta classes in place.
    // baseClass不是元类的话，那么self就是对象，statedClass 和baseClass肯定相等，不相等的话是因为KVO产生了中间类，这种情况对KVO的中间类调用aspect_swizzleClassInPlace
}else if (statedClass != baseClass) {
    return aspect_swizzleClassInPlace(baseClass);
}

如果类名里面已经包含了AspectsSubclassSuffix这个字符串说明已经hook过了。直接返回baseClass。

如果baseClass是元类，说明self是类对象，直接进行hook。aspect_swizzleClassInPlace这个函数作用就是hook类的forwardInvocation:方法。

如果baseClass不是元类的话，那么self就是实例对象，statedClass和baseClass肯定是指向同一个地址。不想等的情况只能是KVO产生了中间类。这种情况直接对中间类就行Hook。中间类就是baseClass。

如果这几个判断条件都没有走，说明self是实例对象，并且没有被KVO过。那么走下面的方法：

// 拼接"_Aspects_"字符串
const char *subclassName = [className stringByAppendingString:AspectsSubclassSuffix].UTF8String;

Class subclass = objc_getClass(subclassName);

if (subclass == nil) {
    subclass = objc_allocateClassPair(baseClass, subclassName, 0);
    if (subclass == nil) {
        NSString *errrorDesc = [NSString stringWithFormat:@"objc_allocateClassPair failed to allocate class %s.", subclassName];
        AspectError(AspectErrorFailedToAllocateClassPair, errrorDesc);
        return nil;
    }
        
    // swizzle 子类的forwardInvocation
    aspect_swizzleForwardInvocation(subclass);
    // hook实例class方法
    aspect_hookedGetClass(subclass, statedClass);
    // hook类class方法
    aspect_hookedGetClass(object_getClass(subclass), statedClass);
    objc_registerClassPair(subclass);
}
// 这里偷偷换了一下，class方法返回statedClass，实际上object_getClass返回新创建的类
// 把当前对象的isa指向自己。
object_setClass(self, subclass);
return subclass;

到这里我们可以看到，如果对某个对象的方法进行hook，Aspects会创建一个对象的子类，在子类的基础上进行操作。这样的好处是不需要修改对象本身的类。当remove aspects的时候，如果发现当前对象的所有aspect都移除了，可以直接将isa指针指向回原来的类。

接下来看一下Aspects如何创建子类进行hook的。新建类的名字，会先加上AspectsSubclassSuffix后缀，标记成子类。然后调用objc_getClass方法，去查找是否已经创建过子类。能来到这里肯定是还没有创建，所以返回的肯定是nil。接下来就会调用objc_allocateClassPair方法创建子类。如果创建失败会报错。终止hook流程。创建成功的话，会走下面的流程。调用aspect_swizzleForwardInvocationhook新建子类的forwardInvocation:方法，调用aspect_hookedGetClasshook子类类的class方法，返回statedClass，statedClass就是原来实例的类对象。调用aspect_hookedGetClasshook元类的class方法，返回statedClass。接下来调用objc_registerClassPair方法注册新建的子类。最后把原来实例的isa指向新创建的子类。

aspect_swizzleForwardInvocation

前面aspect_hookClass方法中用到了aspect_swizzleForwardInvocation和aspect_swizzleClassInPlace方法。aspect_swizzleClassInPlace最后也是调用了aspect_swizzleForwardInvocation，只是多了一个加锁的过程。现在来看一下aspect_swizzleForwardInvocation方法实现：

static NSString *const AspectsForwardInvocationSelectorName = @"__aspects_forwardInvocation:";
// swizzling forwardInvocation
static void aspect_swizzleForwardInvocation(Class klass) {
    NSCParameterAssert(klass);
    // If there is no method, replace will act like class_addMethod.
    IMP originalImplementation = class_replaceMethod(klass, @selector(forwardInvocation:), (IMP)__ASPECTS_ARE_BEING_CALLED__, "v@:@");
    // 如果以前类里面已经实现了forwardInvocation，用另一个sel挂住原来的
    if (originalImplementation) {
        class_addMethod(klass, NSSelectorFromString(AspectsForwardInvocationSelectorName), originalImplementation, "v@:@");
    }
    AspectLog(@"Aspects: %@ is now aspect aware.", NSStringFromClass(klass));
}

直接调用class_replaceMethod方法，替换类的forwardInvocation:方法，替换的实现是__ASPECTS_ARE_BEING_CALLED__，这个实现后面分析。如果原来的类实现了forwardInvocation:，用AspectsForwardInvocationSelectorName这个selector指向原来的实现。

__ASPECTS_ARE_BEING_CALLED__

接下来看一下__ASPECTS_ARE_BEING_CALLED__的实现：

#define aspect_invoke(aspects, info) \
for (AspectIdentifier *aspect in aspects) {\
    [aspect invokeWithInfo:info];\
    if (aspect.options & AspectOptionAutomaticRemoval) { \
        aspectsToRemove = [aspectsToRemove?:@[] arrayByAddingObject:aspect]; \
    } \
}

// This is the swizzled forwardInvocation: method.
static void __ASPECTS_ARE_BEING_CALLED__(__unsafe_unretained NSObject *self, SEL selector, NSInvocation *invocation) {
    NSCParameterAssert(self);
    NSCParameterAssert(invocation);
    SEL originalSelector = invocation.selector;
    SEL aliasSelector = aspect_aliasForSelector(invocation.selector);
    invocation.selector = aliasSelector;
    AspectsContainer *objectContainer = objc_getAssociatedObject(self, aliasSelector);
    AspectsContainer *classContainer = aspect_getContainerForClass(object_getClass(self), aliasSelector);
    AspectInfo *info = [[AspectInfo alloc] initWithInstance:self invocation:invocation];
    NSArray *aspectsToRemove = nil;

    // Before hooks.
    aspect_invoke(classContainer.beforeAspects, info);
    aspect_invoke(objectContainer.beforeAspects, info);

    // Instead hooks.
    BOOL respondsToAlias = YES;
    if (objectContainer.insteadAspects.count || classContainer.insteadAspects.count) {
        aspect_invoke(classContainer.insteadAspects, info);
        aspect_invoke(objectContainer.insteadAspects, info);
    }else {
        Class klass = object_getClass(invocation.target);
        do {
            if ((respondsToAlias = [klass instancesRespondToSelector:aliasSelector])) {
                [invocation invoke];
                break;
            }
        }while (!respondsToAlias && (klass = class_getSuperclass(klass)));
    }

    // After hooks.
    aspect_invoke(classContainer.afterAspects, info);
    aspect_invoke(objectContainer.afterAspects, info);

    // If no hooks are installed, call original implementation (usually to throw an exception)
    if (!respondsToAlias) {
        invocation.selector = originalSelector;
        SEL originalForwardInvocationSEL = NSSelectorFromString(AspectsForwardInvocationSelectorName);
        if ([self respondsToSelector:originalForwardInvocationSEL]) {
            ((void( *)(id, SEL, NSInvocation *))objc_msgSend)(self, originalForwardInvocationSEL, invocation);
        }else {
            [self doesNotRecognizeSelector:invocation.selector];
        }
    }

    // Remove any hooks that are queued for deregistration.
    [aspectsToRemove makeObjectsPerformSelector:@selector(remove)];
}

前面把原来类forwardInvocation:的实现替换成__ASPECTS_ARE_BEING_CALLED__这个函数。所以当调用类hook方法时，会走到这个函数中。

SEL originalSelector = invocation.selector;
SEL aliasSelector = aspect_aliasForSelector(invocation.selector);
invocation.selector = aliasSelector;
AspectsContainer *objectContainer = objc_getAssociatedObject(self, aliasSelector);
AspectsContainer *classContainer = aspect_getContainerForClass(object_getClass(self), aliasSelector);
AspectInfo *info = [[AspectInfo alloc] initWithInstance:self invocation:invocation];

这几行代码做了以下几件事：

获取原始的selector
获取带有aspects_前缀的selector
替换selector
获取实例对象的aspectsContainer
获取类的aspectContainer
初始化AspectInfo，传入instance和invocation

接下来调用aspect_invoke宏定义，执行需要再before调用的aspect。宏定义里面做了两件事，一个是执行了[aspect invokeWithInfo:info]方法，一个是把需要remove的aspect添加到等待移除的数组。

接下来看一下[aspect invokeWithInfo:info]的实现：

- (BOOL)invokeWithInfo:(id<AspectInfo>)info {
    NSInvocation *blockInvocation = [NSInvocation invocationWithMethodSignature:self.blockSignature];
    NSInvocation *originalInvocation = info.originalInvocation;
    NSUInteger numberOfArguments = self.blockSignature.numberOfArguments;

    // paranoid: 偏执
    // Be extra paranoid. We already check that on hook registration.
    if (numberOfArguments > originalInvocation.methodSignature.numberOfArguments) {
        AspectLogError(@"Block has too many arguments. Not calling %@", info);
        return NO;
    }

    // 0: block
    // 1: 
    // The `self` of the block will be the AspectInfo. Optional.
    if (numberOfArguments > 1) {
        [blockInvocation setArgument:&info atIndex:1];
    }
    
    // 拷贝参数
	void *argBuf = NULL;
    for (NSUInteger idx = 2; idx < numberOfArguments; idx++) {
        const char *type = [originalInvocation.methodSignature getArgumentTypeAtIndex:idx];
		NSUInteger argSize;
		NSGetSizeAndAlignment(type, &argSize, NULL);
        
		if (!(argBuf = reallocf(argBuf, argSize))) {
            AspectLogError(@"Failed to allocate memory for block invocation.");
			return NO;
		}
        
		[originalInvocation getArgument:argBuf atIndex:idx];
		[blockInvocation setArgument:argBuf atIndex:idx];
    }
    
    [blockInvocation invokeWithTarget:self.block];
    
    if (argBuf != NULL) {
        free(argBuf);
    }
    return YES;
}

这个方法中主要做了4件事：

根据blockSignature初始化invocation
把info放到参数的第二个位置
把原来invocation中的参数拷贝到block的invocation中
调用添加的aspect

所以只要调用aspect_invoke就能调用我们添加的aspect。对应的传入beforeAspects、insteadAspects、afterAspects就能实现before、instead、after`的hook。

// Instead hooks.
BOOL respondsToAlias = YES;
if (objectContainer.insteadAspects.count || classContainer.insteadAspects.count) {
    aspect_invoke(classContainer.insteadAspects, info);
    aspect_invoke(objectContainer.insteadAspects, info);
}else {
    Class klass = object_getClass(invocation.target);
    do {
        if ((respondsToAlias = [klass instancesRespondToSelector:aliasSelector])) {
            [invocation invoke];
            break;
        }
    }while (!respondsToAlias && (klass = class_getSuperclass(klass)));
}

如果存在instead的aspect，直接调用，不存在的话，调用原来实现。这里需要注意，原来的实现绑定在aliasSelector上面。

// After hooks.
aspect_invoke(classContainer.afterAspects, info);
aspect_invoke(objectContainer.afterAspects, info);

这两行代码是调用After Aspect，原理和前面一样。

// If no hooks are installed, call original implementation (usually to throw an exception)
if (!respondsToAlias) {
    invocation.selector = originalSelector;
    SEL originalForwardInvocationSEL = NSSelectorFromString(AspectsForwardInvocationSelectorName);
    if ([self respondsToSelector:originalForwardInvocationSEL]) {
    ((void( *)(id, SEL, NSInvocation *))objc_msgSend)(self, originalForwardInvocationSEL, invocation);
    }else {
        [self doesNotRecognizeSelector:invocation.selector];
    }
}

如果原来的实现没有正确执行，调用原来的forwardInvocation:方法。如果原来的类没有实现forwardInvocation:方法，就会报错崩溃了。

总结

aspect_hookClass到这里就讲完了，这个方法的目的就是hook对应类的forward Invocation:方法。在里面进行了各种判断，下面总结一下判断的情况：

如果已经hook过了直接返回
如果当前类是类对象，直接进行hook
如果是KVO的情况，hook KVO产生的子类对象
如果是对象，动态创建子类，hook子类的forwardInvocation:方法

给对应的方法添加Aspect

通过aspect_hookClass方法对forwardInvocation:进行hook之后，会返回hook完后的类。接下来只需要把需要添加aspect的selector指向forwardInvocation:即可。下面看一下Aspects如何做的：

Method targetMethod = class_getInstanceMethod(klass, selector);
IMP targetMethodIMP = method_getImplementation(targetMethod);

这两句代码是获取要hook的方法原来的实现。

if (!aspect_isMsgForwardIMP(targetMethodIMP)) { // swizzling method
    // Make a method alias for the existing method implementation, it not already copied.
    const char *typeEncoding = method_getTypeEncoding(targetMethod);
    SEL aliasSelector = aspect_aliasForSelector(selector);
    if (![klass instancesRespondToSelector:aliasSelector]) {
         __unused BOOL addedAlias = class_addMethod(klass, aliasSelector, method_getImplementation(targetMethod), typeEncoding);
         NSCAssert(addedAlias, @"Original implementation for %@ is already copied to %@ on %@", NSStringFromSelector(selector), NSStringFromSelector(aliasSelector), klass);
    }
    // We use forwardInvocation to hook in.
    class_replaceMethod(klass, selector, aspect_getMsgForwardIMP(self, selector), typeEncoding);
    AspectLog(@"Aspects: Installed hook for -[%@ %@].", klass, NSStringFromSelector(selector));
}

static BOOL aspect_isMsgForwardIMP(IMP impl) {
    return impl == _objc_msgForward
#if !defined(__arm64__)
    || impl == (IMP)_objc_msgForward_stret
#endif
    ;
}

aspect_isMsgForwardIMP这个函数用来判断原来的实现是否指向_objc_msgForward或者_objc_msgForward_stret。这两个IMP是消息转发的标记。这里是判断当前的IMP是否为消息转发。

如果不是消息转发，就获取当前原始的selector对应IMP的方法编码，如果当前类不能响应aspect_xxx这个方法，就给当前类添加aspect_xxxselector，实现为原来方法的实现。

然后调用class_replaceMethod把原来的selector指向_objc_msgForward或者_objc_msgForward_stret。这样，当原来的方法被调用时，会直接走消息转发，因为前面已经hook了forwardInvocation:，所以会走到自己的处理逻辑中。

到这里，就完成了一次完整的hook。

aspect_remove

aspect_remove是移除一个hook。接下来看一下如何移除：

static BOOL aspect_remove(AspectIdentifier *aspect, NSError **error) {
    NSCAssert([aspect isKindOfClass:AspectIdentifier.class], @"Must have correct type.");

    __block BOOL success = NO;
    aspect_performLocked(^{
        id self = aspect.object; // strongify
        if (self) {
            AspectsContainer *aspectContainer = aspect_getContainerForObject(self, aspect.selector);
            success = [aspectContainer removeAspect:aspect];

            aspect_cleanupHookedClassAndSelector(self, aspect.selector);
            // destroy token
            aspect.object = nil;
            aspect.block = nil;
            aspect.selector = NULL;
        }else {
            NSString *errrorDesc = [NSString stringWithFormat:@"Unable to deregister hook. Object already deallocated: %@", aspect];
            AspectError(AspectErrorRemoveObjectAlreadyDeallocated, errrorDesc);
        }
    });
    return success;
}

aspect_performLocked是保证线程安全。先把aspect从aspectContainer中移除。然后调用aspect_cleanupHookedClassAndSelector取消对当前方法的hook。接下来看一下aspect_cleanupHookedClassAndSelector的实现：

Class klass = object_getClass(self);
BOOL isMetaClass = class_isMetaClass(klass);
if (isMetaClass) {
    klass = (Class)self;
}

这几句代码的作用是取到类对象。

Method targetMethod = class_getInstanceMethod(klass, selector);
IMP targetMethodIMP = method_getImplementation(targetMethod);
if (aspect_isMsgForwardIMP(targetMethodIMP)) {
    // Restore the original method implementation.
    const char *typeEncoding = method_getTypeEncoding(targetMethod);
    SEL aliasSelector = aspect_aliasForSelector(selector);
    Method originalMethod = class_getInstanceMethod(klass, aliasSelector);
    IMP originalIMP = method_getImplementation(originalMethod);
    NSCAssert(originalMethod, @"Original implementation for %@ not found %@ on %@", NSStringFromSelector(selector), NSStringFromSelector(aliasSelector), klass);
    class_replaceMethod(klass, selector, originalIMP, typeEncoding);
     AspectLog(@"Aspects: Removed hook for -[%@ %@].", klass, NSStringFromSelector(selector));
}

这里检查当前的方法是否被标记成消息转发，如果标记成了消息转发，换回原来的方法实现。经过前面的代码，这些方法应该很容易看明白。这里有个问题需要注意，如果一个类的两个对象同时对类的某个方法进行hook，其中某个对象把方法还原后，另外一个对象的方法也还原了，这里是对整个类进行的操作。

aspect_deregisterTrackedSelector(self, selector);

static void aspect_deregisterTrackedSelector(id self, SEL selector) {
    if (!class_isMetaClass(object_getClass(self))) return;

    NSMutableDictionary *swizzledClassesDict = aspect_getSwizzledClassesDict();
    NSString *selectorName = NSStringFromSelector(selector);
    Class currentClass = [self class];
    AspectTracker *subclassTracker = nil;
    do {
        AspectTracker *tracker = swizzledClassesDict[currentClass];
        if (subclassTracker) {
            [tracker removeSubclassTracker:subclassTracker hookingSelectorName:selectorName];
        } else {
            [tracker.selectorNames removeObject:selectorName];
        }
        if (tracker.selectorNames.count == 0 && tracker.selectorNamesToSubclassTrackers) {
            [swizzledClassesDict removeObjectForKey:currentClass];
        }
        subclassTracker = tracker;
    }while ((currentClass = class_getSuperclass(currentClass)));
}

aspect_deregisterTrackedSelector方法的作用是取消对该方法的tracker。继承体系中的tracker也取消。如果当前类没有进行过hook了，把当前类从swizzledClassesDict中移除。

// Get the aspect container and check if there are any hooks remaining. Clean up if there are not.
AspectsContainer *container = aspect_getContainerForObject(self, selector);
if (!container.hasAspects) {
    // Destroy the container
    aspect_destroyContainerForObject(self, selector);

    // Figure out how the class was modified to undo the changes.
    NSString *className = NSStringFromClass(klass);
    if ([className hasSuffix:AspectsSubclassSuffix]) {
        Class originalClass = NSClassFromString([className stringByReplacingOccurrencesOfString:AspectsSubclassSuffix withString:@""]);
        NSCAssert(originalClass != nil, @"Original class must exist");
        object_setClass(self, originalClass);
        AspectLog(@"Aspects: %@ has been restored.", NSStringFromClass(originalClass));

        // We can only dispose the class pair if we can ensure that no instances exist using our subclass.
        // Since we don't globally track this, we can't ensure this - but there's also not much overhead in keeping it around.
        //objc_disposeClassPair(object.class);
    }else {
        // Class is most likely swizzled in place. Undo that.
        if (isMetaClass) {
            aspect_undoSwizzleClassInPlace((Class)self);
         }else if (self.class != klass) {
            aspect_undoSwizzleClassInPlace(klass);
         }
    }
}

如果container中已经没有aspect了，移除当前类的关联对象。如果当前类里面包含_Aspects_后缀，说明创建了子类，需要把当前类的isa指针指回原来的类。

aspect_undoSwizzleClassInPlace里面会调用aspect_undoSwizzleForwardInvocation，aspect_undoSwizzleClassInPlace里面只是进行了加锁，并且把当前class移除了swizzledClasses容器。接下来看一下aspect_undoSwizzleForwardInvocation实现：

static void aspect_undoSwizzleForwardInvocation(Class klass) {
    NSCParameterAssert(klass);
    Method originalMethod = class_getInstanceMethod(klass, NSSelectorFromString(AspectsForwardInvocationSelectorName));
    Method objectMethod = class_getInstanceMethod(NSObject.class, @selector(forwardInvocation:));
    // There is no class_removeMethod, so the best we can do is to retore the original implementation, or use a dummy.
    IMP originalImplementation = method_getImplementation(originalMethod ?: objectMethod);
    class_replaceMethod(klass, @selector(forwardInvocation:), originalImplementation, "v@:@");

    AspectLog(@"Aspects: %@ has been restored.", NSStringFromClass(klass));
}

这个方法的作用就是还原forwardInvocation:实现。

Aspects的坑

Aspects设计虽然很好，但是在项目里面用还是有一些坑的，比如我们在项目里面手动hook了一个方法，然后用Aspects也进行了hook，就有可能会崩溃(先用Aspects去hook，再手动hook就会崩溃)，比如下面代码：

@implementation UIViewController (TestOne)
+ (void)load {
    static dispatch_once_t onceToken;
    dispatch_once(&onceToken, ^{
        Class class = [self class];
        // When swizzling a class method, use the following:
        // Class class = object_getClass((id)self);
        SEL originalSelector = @selector(viewWillAppear:);
        SEL swizzledSelector = @selector(xxx_viewWillAppear:);
        Method originalMethod = class_getInstanceMethod(class, originalSelector);
        Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);
        BOOL didAddMethod = class_addMethod(class,
                                            originalSelector,
                                            method_getImplementation(swizzledMethod),
                                            method_getTypeEncoding(swizzledMethod));
        if (didAddMethod) {
            class_replaceMethod(class,
                                swizzledSelector,
                                method_getImplementation(originalMethod),
                                method_getTypeEncoding(originalMethod));
        } else {
            method_exchangeImplementations(originalMethod, swizzledMethod);
        }
    });
}
#pragma mark - Method Swizzling
- (void)xxx_viewWillAppear:(BOOL)animated {
    [self xxx_viewWillAppear:animated];
    NSLog(@"viewWillAppear: %@", self);
}
@end

先在一个分类中hookviewWillAppear:方法，然后在另一个分类中用Aspects也hookviewWillAppear:方法：

@implementation UIViewController (TestTwo)
+ (void)load {
    [UIViewController aspect_hookSelector:@selector(viewWillAppear:) withOptions:AspectPositionBefore usingBlock:^(id<AspectInfo> info , BOOL animated) {
        NSLog(@"viewWillAppear");
    } error:nil];
}
@end

运行就会崩溃。即便能保证项目里面不手动hook，也不能保证一些第三方sdk不会手动进行hook。如果想要保证能正常使用，就需要对Aspects库进行改造。这个不在本文讨论范围，暂时不发散了。解决办法可以在参考链接中找到。

参考链接

初识iOS中的动态库和静态库

2020-07-19

由于最近研究组件化后调试时二进制映射源码的功能，发现需要对开发中的动态库和静态库需要有一些了解。所以就有了这篇文章，由于只是了解，并没有深入到编译层面，所以本篇文章只是简单了解一些库的知识，并不深入。

静态库 vs 动态库

平常开发的时候会接触一些库的文件，比如.a、.tbd、.framework结尾的文件，甚至以前还有.dylib结尾的。由于以前一直没忙于工作，所以也没有细致的研究这些文件结尾的区别。只是傻傻的以为.a结尾的是静态库，.framework结尾的是动态库。现在看来以前是真的傻。现在来看一下静态库和动态库的区别。

静态库

如果我们的app依赖一个静态库，在链接阶段会把依赖静态库的部分合并到app的可执行文件中(app的可执行文件指的是app包内容里面同名的一个文件)。静态库的文件名后缀是.a或.framework。

动态库

编译app时并不会把动态库合并到app的可执行文件中，而是在程序启动的时候加载动态库到内存中。其中动态库分动态链接库和动态加载库两种。

动态链接库：在编译阶段需要指定app需要依赖哪些动态库。当运行可执行文件时，如果系统还没有加载过这些库时，就会随着运行可执行文件的加载一起加载这些动态库。如果有多个可执行文件依赖同一个动态库，不会重复加载。
动态加载库：编译阶段不需要指定app需要依赖哪些动态库。当运行过程中需要加载某个动态库时，就会用dlopen函数动态的把库加载到内存中使用。

所以这两个的区别就是动态链接库在app运行时就需要加载，动态加载库可以在任何时间进行加载。动态库的文件后缀是.tbd或.framework。

小总结

由于静态库在链接时需要链接到可执行文件中，所以会导致包体积变大。动态库因为不会添加到可执行文件中，所以相比静态库包体积会小一些。

相对于启动时间，静态库会比动态库好一些，因为如果使用很多动态库，app在冷启动时加载动态库会占用一些时间。

下面来说一下文件后缀的问题。.a就是静态库，.tbd是动态库，以前还有.dylib结尾的动态库。.framework既可以是动态库也可以是静态库，这取决于制作静态库时我们选择的Mach-O type。现在无论是静态库还是动态库都推荐使用.framework。接下来会展示如何制作自己的.framework类型的动态库和静态库。

如何制作使用动态库和动态库

制作.a静态库

创建工程的时候选择Static Library选项。然后随便起个名字就好。创建完工程应该是下面这样的：然后写一个测试代码：

// CreateStatic.h
#import <Foundation/Foundation.h>

@interface CreateStatic : NSObject
- (void)test;
@end

// CreateStatic.m
#import "CreateStatic.h"

@implementation CreateStatic
- (void)test {
	NSLog(@"test static .a");
}
@end

然后对工程文件做一些配置：设置Build Active Architecture Only为NO，当设置为YES时，只会针对当前架构进行编译，当设置为NO时，会对所有架构进行编译。接下来编译一下就可以在Product文件夹下生成一个.a的静态库。测试代码如下：

// CreateFrameworkStatic.h
#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface CreateFrameworkStatic : NSObject
- (void)test;
@end

NS_ASSUME_NONNULL_END

// CreateFrameworkStatic.m
#import "CreateFrameworkStatic.h"

@implementation CreateFrameworkStatic
- (void)test {
	NSLog(@"test create framework static library");
}
@end

通过设置是否为Debug状态和是否为真机，会生成4个.a文件。可以用lipo -info来查看.a文件信息。

接下来可以通过lipo -crate命令把这几个静态库合并成一个：可以看到合并后的.a文件既有真机又有模拟器的架构。

接下来创建一个工程，测试一下这个静态库：可以看到静态库可以用了。

制作Framework静态库

制作Framework静态库选择这个选项，创建工程。然后需要修改Build Setting选项，除了调整Build Active Architecture Only为NO，还需要调整Mach-O Type为Static Library。然后调整编译选项，会和原来创建.a静态库一样，生成四个Framework。这里偷个懒，只编译Debug+真机和Debug+模拟器选项。生成的文件目录如下：其中红色框框的这个文件就是二进制文件，同样可以使用lipo -info和lipo -create查看和合并库文件。

接下来测试一下Framework类型的静态库使用，当加到工程后，如果报framework not found的错误，需要调整Build Setting中Library Search Path选项：

制作Framework动态库

制作Framework动态库和Framework静态库一样，创建Framework类型的工程，然后Mach-O Type选择Dynamic Library。测试代码如下：

// CreateFrameworkDynamicLibrary.h
#import <Foundation/Foundation.h>

NS_ASSUME_NONNULL_BEGIN

@interface CreateFrameworkDynamicLibrary : NSObject
- (void)test;
@end

NS_ASSUME_NONNULL_END

// CreateFrameworkDynamicLibrary.m
#import "CreateFrameworkDynamicLibrary.h"

@implementation CreateFrameworkDynamicLibrary
- (void)test {
	NSLog(@"test framework dynamic library");
}
@end

这里也只编译Debug+真机和Debug+模拟器两种：其中上图红色框框就是动态库二进制文件，同样可以使用lipo -info和lipo -create查看和合并库文件。接下来测试一下动态库使用，同样直接拖到项目里面就可以：

记得在Frameworks, Libraries, and Embedded Content中选择Embed & Sign这个选项，否则会报dyld: Library not loaded的错误。

我们上面添加动态库的方式会在程序启动的时候加载，如果项目在编译阶段没有直接使用这个动态库，可以设置在运行时加载动态库。需要把Build Phases里面Link Binary With Libraries里面的动态库删除，只保留Embed Frameworks。

这样程序启动的时候就不会加载这个动态库，然后我们在页面里面添加一个按钮，点击按钮时加载动态库并执行动态库的方法：

- (IBAction)testDynamicLibrary:(id)sender {
	NSString *path = [NSString stringWithFormat:@"%@/%@", [NSBundle mainBundle].privateFrameworksPath, @"CreateFrameworkDynamicLibrary.framework"];
	[self loadDynamicLibraryWithPath:path];
	Class cl = NSClassFromString(@"CreateFrameworkDynamicLibrary");
	if (!cl) {
		NSLog(@"class not found");
	}
	[[cl new] performSelector:@selector(test)];
}
- (BOOL)loadDynamicLibraryWithPath:(NSString *)path {
	NSBundle *bundle = [NSBundle bundleWithPath:path];
	if (!bundle) {
		NSLog(@"%@ not found", path);
		return NO;
	}

	NSError *error;
	if (![bundle loadAndReturnError:&error]) {
		NSLog(@"Load %@ failed: %@", path, error);
		return NO;
	} else {
		NSLog(@"Load %@ success", path);
	}

	return YES;
}

这样也可以成功加载动态库，这样加载动态库更像是一个动态加载库。

总结

动态库和静态库其实都是一个编译产物，只是加载到app的方式不同。静态库在链接阶段参与的加载。而动态库是在app启动或app运行时加载。
至于文件后缀就很好理解了，静态库可以是.a文件也可以是.framework文件。动态库现在一般都是.framework，不过.framework不一定都是动态库。

参考

Ghost S1复刻 & Hackintosh

2020-06-03

由于年初疫情的原因，去年装的黑苹果终于可以用来干点正事了(关于去年的黑苹果配置可以看前一篇文章)，在家办公一直使用黑苹果来开发。疫情渐渐远去，慢慢开始复工，复工后又开始用19年13寸中配的MBP办公。没有对比就没有伤害，没用黑苹果之前也没感觉这台笔记本会这么慢，编译一次项目2分钟的时长实在忍不了。经过权衡决定组装一台黑苹果在公司用。

这次装电脑又两个需求，一个是在公司用，另外一个是老家没电脑，每次放假回家都很无聊，所以希望这台电脑可以放假带回家用。有了便携这个需求，所以主机肯定是ITX的机型了。组ITX主机需要先去选机箱，然后根据机箱找合适的配件。正好同事推荐了Ghost S1复刻这个机箱，A4机箱，很满意，就是价格略贵。最后还是咬咬牙买了下来。机箱确定了，其他配件就好说了，最后敲定配置如下：

配件	型号	入手渠道	价格	备注
主板	技嘉Z370N Wi-Fi	闲鱼	1000	Z390 ITX主板价格太高，缩预算选择Z370N，物超所值
CPU	i5 9600K	淘宝散片	1400	主板都缩了，CPU也从开始的9700K缩到了9600K，主频够高，就是核数少点
显卡	蓝宝石5500xt	淘宝官方旗舰店	1499	最便宜的7nm免驱卡，还可以低特效玩点游戏
内存	海盗船复仇者16G*2 3200Hz	闲鱼	800	和主板一起收的，挺便宜
SSD	西数SN750 500G + SN550 500G	淘宝	1060	一块装macOS，一块装Windows玩游戏
电源	海盗船SF600金牌	闲鱼	773	闲鱼买的全新的，价格还算可以
WI-FI & 蓝牙	BCM94360CS2	淘宝	180	免驱
散热器	利民AXP90	京东	299	幸亏买的AXP90没买AXP100，尺寸正好
机箱	Ghost S1 复刻 K总家的	闲鱼	788	全新的要等40天，闲鱼买的二手
定制电源线	YY定制	淘宝	180	线材长度正好，省了理线流程
总计	7971

组装

因为是第一次装ITX主机，所以和同事一起装的，过程还算顺利，照着教程撸了下来。中间大力出奇迹把显卡延长线的卡扣搞折了，不过不影响使用。整机图片如下：

系统安装

本来以为用OpenCore安装起来很简单，结果下了一个同型号主板的EFI安装，死活不显示进macOS恢复模式的引导。后来从QQ群重新找了一个Z370主板的EFI可以进恢复模式，然后就和安装白苹果的流程一样了。中间在下载镜像时自动重启了，不走安装流程。期间还怀疑EFI有问题，后来怀着试试的态度，又重新走了一遍，顺利安装上了。中间甚至还烧了一个Clover的盘，后来也没用上。OpenCore安装起来很简单，只要找一个可以引导的EFI就可以。相关教程可以看这个链接。

优化系统

系统安装上了，需要自己优化一下，毕竟是别人的EFI。需要自己填入自己生成的机型信息。本来以为用以前那台电脑的EFI就可以，因为以前的电脑也是技嘉的主板，只不过是Z390，都是300系列的。结果被现实啪啪打脸。折腾了一下午才搞好。主要是有个RTC相关的坑。新电脑的主板需要去改这个问题，旧的电脑没有这个问题。以后一定要照着教程好好撸一遍。相关教程可以看xjn大佬的博客。经过一下午的优化以下功能可以正常工作：

核显
独显
声卡
WIFI
蓝牙
主板网卡
Sidecar
电源节能5项
USB
睡眠唤醒
USBPower充电
原生NVRAM启动盘切换

使用体验

在公司使用了一天的感受是编译速度明显变快，因为本身是iOS开发，所以拿编译工程来举例。以前Clean重新编译平均需要360s，CPU温度高的话500s的时候也有，MBP会在温度高的时候自动降频，降到1GHz。不Clean工程，跑缓存，平均一次编译需要120-150s不等。

换上新主机后Clean重新编译需要120-150s，不Clean平均编译需要70-90s。编译时CPU可以一直满速跑，基本不会掉频。Emmm，极大高了生产力，再也不会有打字都卡的情况了，心情愉悦… EFI地址

等后面装好Windows再看看游戏效果怎么样。

WKWebView离线包开发小记

2020-05-18

随着项目里面Web页面内容越来越多，H5的加载速度变得越来越重要。在H5同学提出需求前就看过有关优化的文章。当时没有细致的去看，本来以为做起来轻车熟路，但是真做起来坑还是不少。下面记录一下整个优化过程。

优化思路

一个WebView加载的过程大约有以下几个步骤(内容来自于腾讯Bugly的文章):

初始化 WebView -> 请求页面 -> 下载数据 -> 解析HTML -> 请求 js/css 资源 -> dom 渲染 -> 解析 JS 执行 -> JS 请求数据 -> 解析渲染 -> 下载渲染图片

在dom渲染前，Web页面都是白屏，所以优化的思路就是优化dom渲染前的时间耗时。从上图可以看出优化主要集中优化以下两个阶段

WebView的初始化阶段，这个阶段可以采用类似UITableViewCell的复用池机制来解决。
初始化后到渲染前的阶段的优化，请求页面、下载数据、请求js/css资源这些阶段可以通过提前下载H5资源到本地，加载H5的时候加载本地资源来优化。

优化WebView初始化阶段

WebView的初始化也需要一段时间，美团已经测量过WebView加载需要的时间了，这里直接引用一下：优化WebView初始化耗时的方式是在app启动之后启动一个WebView的复用池，创建一些备用的WebView，至于创建几个要根据app的使用情况来定，主要代码如下：

- (instancetype)init
{
	self = [super init];
	if (self) {
		self.capacity = 3;
		self.reuseableWebViewSet = [NSMutableSet new];
		self.visiableWebViewSet = [NSMutableSet new];
		[self prepareWebView];
	}
	return self;
}
- (void)prepareWebView {
	dispatch_async(dispatch_get_main_queue(), ^{
		for (NSUInteger i = 0; i < self.capacity; i++) {
			WBWebView *webView = [[WBWebView alloc] initWithFrame:CGRectZero configuration:[self defaultConfiguration]];
			[self.reuseableWebViewSet addObject:webView];
		}
	});
}

// 获取WebView
- (WBWebView *)getReuseWebViewForHolder:(id)holder {
	if (!holder) {
		return nil;
	}
	[self tryCompactWekHolders];
	WBWebView *webView = nil;
	dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
	if (self.reuseableWebViewSet.count > 0) {
		webView = [self.reuseableWebViewSet anyObject];
		[self.reuseableWebViewSet removeObject:webView];
		[self.visiableWebViewSet addObject:webView];
		[webView willReuse];
	} else {
		webView = [[WBWebView alloc] initWithFrame:CGRectZero configuration:[self defaultConfiguration]];
		[self.visiableWebViewSet addObject:webView];
	}
	webView.holdObject = holder;
	dispatch_semaphore_signal(self.semaphore);
	return webView;
}
// 用完之后回收WebView
- (void)recycleReuseWebView:(WBWebView *)webView {
	if (!webView) {
		return;
	}
	dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
	if ([self.visiableWebViewSet containsObject:webView]) {
		[webView endReuse];
		[self.visiableWebViewSet removeObject:webView];
		[self.reuseableWebViewSet addObject:webView];
	}
	dispatch_semaphore_signal(self.semaphore);
}
// 清除WebView复用池
- (void)clearReuseWebViews {
	dispatch_semaphore_wait(self.semaphore, DISPATCH_TIME_FOREVER);
	[self.reuseableWebViewSet removeAllObjects];
	dispatch_semaphore_signal(self.semaphore);
}

WebView复用池写完后，发现了两个问题。其中一个是进入一个H5页面退出后，再次进入另一个H5页面调用webView的goBack方法会返回第一次进入的H5页面么。另外一个是如果WebView没有销毁，sessionStorage是不会清空的，如果两次进入的是同一个H5页面，而且H5用sessionStorage做一些业务逻辑的话，会有一些奇怪的bug。所以在一个WebView结束复用的时候，需要做一些操作来清除一些东西来保证进入复用池的WebView和一个新建的WebView一样，主要代码如下:

#define kWKWebViewReuseUrlString @"WBCustomScheme://reuse-webView"
- (void)willReuse {
	[self _clearBackForwardList];
}
- (void)endReuse {
	self.holdObject = nil;
	self.scrollView.delegate = nil;
	[self stopLoading];
	self.navigationDelegate = nil;
	self.UIDelegate = nil;
	[self clearWebSessionStorage];
	[self _clearBackForwardList];
	[self loadRequest:[NSURLRequest requestWithURL:[NSURL URLWithString:kWKWebViewReuseUrlString]]];
	[self.configuration.userContentController removeScriptMessageHandlerForName:@"WebInteractiveWithNative"];
	[self.configuration.userContentController removeAllUserScripts];
}

// 清空页面历史记录
- (void)_clearBackForwardList {
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
	SEL sel = NSSelectorFromString([NSString stringWithFormat:@"%@%@%@%@", @"_re", @"moveA", @"llIte", @"ms"]);
	if ([self.backForwardList respondsToSelector:sel]) {
		[self.backForwardList performSelector:sel];
	}
#pragma clang diagnostic pop
}

// 清空sessonStorage
- (void)clearWebSessionStorage {
	NSSet *websiteDataTypes = [NSSet setWithArray:@[
													WKWebsiteDataTypeSessionStorage
													]];

	NSDate *dateFrom = [NSDate dateWithTimeIntervalSince1970:0];
	[[WKWebsiteDataStore defaultDataStore] removeDataOfTypes:websiteDataTypes
											   modifiedSince:dateFrom
										   completionHandler:^{}];
}

- (BOOL)canGoBack {
	if ([self.backForwardList.backItem.URL.absoluteString caseInsensitiveCompare:kWKWebViewReuseUrlString] == NSOrderedSame ||
		[self.URL.absoluteString isEqualToString:kWKWebViewReuseUrlString]) {
		return NO;
	}
	
	return [super canGoBack];
}

- (BOOL)canGoForward {
	if ([self.backForwardList.forwardItem.URL.absoluteString caseInsensitiveCompare:kWKWebViewReuseUrlString] == NSOrderedSame ||
		[self.URL.absoluteString isEqualToString:kWKWebViewReuseUrlString]) {
		return NO;
	}
	
	return [super canGoForward];
}

继承WKWebView写了一个子类，通过在willReuse和endReuse调用_clearBackForwardList方法来清空历史记录可以解决前面说的第一个问题，为了使回收后的WebView在重新用的时候更像一个新建的WebView，在endReuse时加载了一个WBCustomScheme://reuse-webView这样的url，这个其实是加载了一个类似前端about:blank这样的的页面。后面说离线包的时候再说怎么通过加载这个url可以加载一个空页面。这里多说一句，_clearBackForwardList这个方法调用了WebKit的私有api，关于审核风险也咨询了用的一些人，详情见这个issue 在endReuse时，调用clearWebSessionStorage这个方法可以清空WebView的sessionStorage，解决前面提到的第二个问题。复用池的坑就这么多，下面来看一下离线包的实现。

离线包优化

前面提到了，请求页面、下载数据、请求js/css资源这些阶段可以通过加载本地资源实现，也就是离线包的方式。离线包的核心技术是拦截，市面上有多种拦截方案，个有优劣。这次优化使用的是WKWebView自定义scheme的拦截方式来实现的离线包。原理也很简单，WKWebView初始化时允许注册ShemeHandler，当WebView加载自定义的scheme的url时，SchemeHandler就可以拦截这个请求。拦截后可以检测所需要的资源是否在本地，在本地的话加载本地资源给WebView渲染。不在本地的话手动发一个请求去请求资源交给WebView渲染。关于post请求会被拦截的问题，可以让前端同学在js里面发post请求时不用相对路径，写死请求路径即可。SchemeHandler的代码如下:

// MARK: - WKURLSchemeHandler
- (void)webView:(WKWebView *)webView startURLSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask  API_AVAILABLE(ios(11.0))
{
	self.holdURLSchemeTasks[urlSchemeTask.description] = @(YES);
	NSDictionary *headers = urlSchemeTask.request.allHTTPHeaderFields;
	NSString *accept = headers[@"Accept"];
	if (!accept || !urlSchemeTask.request.URL.absoluteString) {
		return;
	}
	NSString *requestUrlString = urlSchemeTask.request.URL.absoluteString;
	if (accept.length > 0 && [accept containsString:@"text/html"]) { // HTML拦截
		WBLogDebug(@"WBWebViewCustomURLSchemeHandler-- html = %@", urlSchemeTask.request.URL.absoluteString);
		[self loadLocalFileWithURLSchemeTask:urlSchemeTask];
	} else if ([self isJSOrCSSFile:requestUrlString]) { // JS/CSS拦截
		[self loadLocalFileWithURLSchemeTask:urlSchemeTask];
	} else if (accept.length >= @"image".length && [accept rangeOfString:@"image"].location != NSNotFound) { // image
		[self loadLocalFileWithURLSchemeTask:urlSchemeTask];
	} else {
		[self loadLocalFileWithURLSchemeTask:urlSchemeTask];
	}
}
- (void)webView:(WKWebView *)webView stopURLSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask  API_AVAILABLE(ios(11.0))
{
	self.holdURLSchemeTasks[urlSchemeTask.description] = @(NO);
}

// MARK: - Private Method

// 判断当前资源是否在本地
- (void)loadLocalFileWithURLSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask {
	NSString *URLString = urlSchemeTask.request.URL.absoluteString;
	if ([URLString containsString:@"wbcustomscheme"]) {
		URLString = [URLString stringByReplacingOccurrencesOfString:@"wbcustomscheme" withString:@"https"];
	}
	URLString = [[URLString componentsSeparatedByString:@"?"] firstObject];
	EZTuple2 *tuple = [WBServiceWebViewOfflinePackage.service getLocalFileDataForURLString:URLString];
	NSData *data = tuple.first;
	if (data && data.length > 0) {
		WBLogDebug(@"离线包命中缓存");
		[self resendQuestForUrlSchemeTask:urlSchemeTask mimeType:tuple.second requestData:data];
	} else {
		[self requestRemoteForUrlSchemeTask:urlSchemeTask];
	}
}

// 把本地资源作为响应返回给UrlSchemeTask
- (void)resendQuestForUrlSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask mimeType:(NSString *)mimeType requestData:(NSData *)data {
	if (!urlSchemeTask.request.URL) {
		return;
	}
	BOOL isValid = [self.holdURLSchemeTasks[urlSchemeTask.description] boolValue];
	if (!isValid) {
		return;
	}
	NSURLResponse *resp = [[NSURLResponse alloc] initWithURL:urlSchemeTask.request.URL MIMEType:mimeType expectedContentLength:data.length textEncodingName:@"utf-8"];
	[urlSchemeTask didReceiveResponse:resp];
	[urlSchemeTask didReceiveData:data];
	[urlSchemeTask didFinish];
}

// 资源不在本地，请求远程资源
- (void)requestRemoteForUrlSchemeTask:(id<WKURLSchemeTask>)urlSchemeTask {
	NSString *urlString = [urlSchemeTask.request.URL.absoluteString stringByReplacingOccurrencesOfString:@"wbcustomscheme" withString:@"https"];
	[self.httpSessionManager GET:urlString parameters:nil headers:nil progress:nil success:^(NSURLSessionDataTask *_Nonnull task, id _Nullable responseObject) {
		// urlSchemeTask 提前结束，调用实例方法会崩溃
		BOOL isValid = [self.holdURLSchemeTasks[urlSchemeTask.description] boolValue];
		if (!isValid) {
			return;
		}
		if (task.response && responseObject) {
			[urlSchemeTask didReceiveResponse:task.response];
			[urlSchemeTask didReceiveData:responseObject];
			[urlSchemeTask didFinish];
		} else {
			return;
		}
	} failure:^(NSURLSessionDataTask *_Nullable task, NSError *_Nonnull error) {
		// urlSchemeTask 提前结束，调用实例方法会崩溃
		BOOL isValid = [self.holdURLSchemeTasks[urlSchemeTask.description] boolValue];
		if (!isValid) {
			return;
		}
		[urlSchemeTask didFailWithError:error];
	}];
}

WebView初始化时需要注册的代码如下:

if (@available(iOS 11.0, *)) {
		if (![config urlSchemeHandlerForURLScheme:@"WBCustomScheme"]) {
			[config setURLSchemeHandler:[WBWebViewCustomURLSchemeHandler new] forURLScheme:@"WBCustomScheme"];
		}
	}

WebView加载url时的代码如下:

if (@available(iOS 11.0, *)) {
// 这里主要是服务端开关，和当前这个url的资源是否在本地的判断。
		if ([WBServiceWebViewOfflinePackage.service shouldOpenOfflinePackageFeature] && [urlString hasPrefix:@"https"] && [WBServiceWebViewOfflinePackage.service doseOfflinePackageContainUrlString:urlString]) { 
			tmpUrlString = [tmpUrlString stringByReplacingOccurrencesOfString:@"https" withString:@"WBCustomScheme"];
		}
	}

这样，整套离线包的实现主要就是这些。离线包主要就一个坑，把https换成自定义的scheme后cookie就不生效了。解决cookie的问题是通过localStorage来解决的，加载WebView时设置localStorage，前端想要获取一些信息就通过localStorage来取。除了cookie这个坑，离线包其他的坑还没遇到。接下来看一下怎么通过加载WBCustomScheme://reuse-webView这个url时加载一个空的H5页面。其实很简单，因为加载这个页面时也是一个自定义的scheme，所以自定义的SchemeHandler可以拦截到请求，然后返回一个空的H5数据给WebView渲染就好了。具体代码如下:

if ([url.host isEqualToString:@"reuse-webView"]) {
		NSData *responseData = [[self _getWebViewReuseLoadString] dataUsingEncoding:NSUTF8StringEncoding];
		return EZTuple(responseData, @"text/html");
	}
	
	- (NSString *)_getWebViewReuseLoadString{
	return @"<html><head><meta name=\"viewport\" " @"content=\"initial-scale=1.0,width=device-width,user-scalable=no\"/><title></title></head><body></body></html>";
}

总结

本文主要讲述了在优化时的一些坑，看了一些文章，思路都差不多，但是这些坑都没有涉及到，所以总结一下。

参考链接

近期黑苹果折腾小记

2020-04-24

一直以来都想装一台黑苹果折腾一下，去年10月终于组装了一台。在近期也把电脑折腾完美了。配置如下：

主板	技嘉Z390m GAMING
CPU	i7 9700k
GPU	蓝宝石5700xt 超白金
主SSD(macOS)	三星 970 Pro M.2 500G
副SSD(Windows10)	Intel 660P M.2 1T
内存	芝奇幻光戟 16G * 2
电源	海韵FOCUS GX750 750w
水冷	酷冷至尊冰神B240
网卡蓝牙(黑苹果免驱)	BCM94360CS2
显示器	LG 27UL850
机箱	酷冷至尊睿Lite3.1红色

其中显卡最开始是蓝宝石Vega56，因为黑屏问题换成了5700xt。桌面整理如下，秀一下我4K的壁纸，哈哈

发现问题

去年10月装完之后发现电脑有静电或者开关音响会自动黑屏，然后就只能重启。因为静电的出现频率不高，把音响和主机插到两个不同的插线板上，开关音响就不会导致黑屏了。所以当时并没有在意，也就不了了之了(主要是不想折腾了，哈哈)。直到今年年初因为疫情的原因在家办公，加上春天天气干燥，电脑经常黑屏，搞得心情烦躁，终于下定决心来找一下问题。

确定黑屏原因

本着花钱节约时间的原则，约了京东的电脑上门维修服务，维修人员来了之后检测了一下告诉我是地线问题。我也不知道他是如何检测的，只拿着电表笔告诉我火线和底线之间应该有电压，但是测量出来我家里的没有。本着怀疑的态度，我自己买了一个电压表，回来检测了一下，家里的地线是正常的。于是联系京东售后重新检测，为了排除问题，维修人员把我电脑带到了维修站去检测，终于发现是显卡的问题，因为换一个其他显卡就不会出现这种问题。

解决显卡问题

因为最初装机时显卡是闲鱼买的二手的蓝宝石Vega56，所以当天立即联系卖家解决问题。卖家当时买了京东的延保服务，2年之内有问题可以直接换新。所以需要我把显卡寄给延保服务进行检测。在这里强烈谴责这个延保服务工作效率，检测问题就需要15个工作日。后面检测确实有问题，进行换新，因为Vega56没有现货了，所以自己补了差价，买了5700xt。收到货后放到电脑里面，把黑苹果引导配置重新折腾了一番，终于可以正常开机，并且没有了黑屏问题了。本以为到这里就算解决了显卡问题，哪知道前方还有坑在等我。第二天早上想测试一下5700xt的性能，毕竟A卡高端卡。下载了Geekbench开始跑分，跑OpenCL刚开始10秒中，电脑直接卡住不动，然后自己重启了。当时我心里想可能需要预热一下，又跑了一次，结果还是同样的情况。切到Windows系统，下载Windows版本的Geekbench重新跑(这里表扬一下Geekbench的开发者，支持了Windows，让我排除了系统问题)，还是一样卡死，只是Windows不会重启。在这之后还下载了国产跑分软件鲁大师跑了一下，鲁大师告诉我我的显卡很厉害，超过了99%的电脑，我呵呵了。虽然我平常不用OpenCL的软件(从一个群友那里得知Adobe全家桶好像都用了OpenCL算法)，但是也不允许电脑有这种缺陷额，于是联系京东换货。京东客服告诉我他们需要检测有问题才能换货。我去，当时心里就想又检测，上次检测15个工作日，不会又来15个工作日吧。好在客服告诉我2-3个工作日就可以检测完成。于是尽快的把显卡寄给了京东售后，这里要夸一下京东的售后处理速度，第二天就给我说可以换货了，然后给我寄了一个新的显卡。装到电脑上，跑分不会卡住重启，黑屏的问题也解决了。

优化5700xt在黑苹果下的跑分

虽然跑分没问题了，但是5700xt在macOS下跑分只有3w左右，Windows下面可以到6w5左右。远景也有一些优化的帖子，但是我感觉小白不容易看懂。自己照着帖子研究了一段时间，终于明白了其中的一些原理。因为5700xt这块显卡还没有苹果机器在用，只是在macOS10.15.1系统里面支持了Navi架构(5700xt是Navi10的架构)。所以想要正确驱动5700xt需要自己注册正确的RomId和EFIVersion进系统，只要正确注入了，跑分基本上可以到65000左右。注入的教程可以看xjn大佬的优化贴。我自己是用SSDT注入的，SSDT文件地址，这个SSDT的作用有3个：

Change HECI To IMEI
Change PEGP To GFX0
注入5700xt信息

如果要用SSDT需要自己修改以下的代码，把ATY,EFIVersionRomB和ATY,EFIVersionB替换成自己显卡的RomId，自己显卡的RomId可以通过Windows下的GPU-Z软件查看，剩下的几个不用修改。

用了这个SSDT还需要在config文件里面注入Change GFX0 To IGPU的补丁，也就是下图这样：这三个改名的其实是WhateverGreen的一部分，看xjn大佬的帖子，WhateverGreen其实干了以下几件事：

AMD框架等
HECI, IGPU, PEGP的重命名
核显驱动
AGDP黑屏补丁

AMD框架会影响独显的发挥，重命名的事我们自己做了，去掉核显驱动核显就可以拉满1.2GHz，AGDP黑屏补丁不能去掉。所以在我的EFI里面用了VegaGraphicsFixup这个kext，没用WhateverGreen。这个里面只保留了AGDP黑屏补丁。通过这样设置5700xt在黑苹果下的跑分就和Windows下面一样了。下面对比一下优化前和优化后独显的跑分：

下面是核显1.2GHz的满载：

到这里已经可以说独显跑分正常，核显可以拉满性能。如果是视频工作者的朋友可以接着往下看，独显的跑分虽然正常了，但是独显还是可以接着优化的。独显默认的超频很小，可以通过注入一些内容，让独显在渲染视频时可以发挥更大的性能。

5700xt超频优化

我的蓝宝石5700xt超白金，GPU最高频率是2100MHz，超频最高超到2150MHz，这也太少了。我们可以通过在config里面注入一些信息调整。调整超频需要用到一个excel表，表的内容大概如下：这里面是显卡的Bios信息，调整完这些信息可以在左下角获得一个Output值，把Output的值注入到config的DeviceProperties里面。其中1是显卡的Device Path，每个人的主板不一样，对应的地址也不一样，可以通过Hackintool获取找到PCIe下的显卡，然后复制设备地址出来，添加到DeviceProperties里面。 2是注入的Key，添加PP_PhmSoftPowerPlayTable这个key，value类型是data，然后把前面Excel表中的Output值填进去就可以了。下面来说一下如何调整这个表，首先需要获取Rom信息，这个需要两个工具，并且需要再Windows下操作。其中一个工具是GPU-Z，用来导出显卡Bios信息，另外一个是MorePowerTool，用来查看Rom信息。

通过GPU-Z导出显卡Bios信息：
通过MorePowerTool加载导出的信息：点击load加载导出的文件，然后对上面5个标签展示的页面分别截图保存，比如我的就是下面这样的：

这些信息对应上面Excel表中的信息，可以先把上面Excel表中的每个字段都按照当前显卡信息填一遍，然后再去调整超频。我自己调整的超频是在上面这些信息的基础上调整了表中的5个值：

Max Memory Clock：从1900调整到了2000，表中的Max Memory Clock对应的是上图的Memory Maximum Clock，而且表中对应值=上图中的值 * 2，我的显卡信息对应的是950，表中的就是1900，我调整到了2000。
Max GPU Clock (MHz)：从2150调整到了2300
Power Limit (%) Maximum：从50调整到了90
Power Limit GPU (W)：从220调整到了250
MaxVoltageSoc：从1050调整到了1250

其他的都是按照上图默认的填进去的，调整完可以从左下角的Output把值复制出来，填到config的PP_PhmSoftPowerPlayTable里面。我调整的这几个值是从xjn大佬调整的结果，因为到现在为止，苹果系统没有开5700xt的传感器接口，所以不能瞎填，还是在大佬们的调整结果上自己改一些东西。我是自己加了风扇控制，如果直接用这个帖子里面调整完的结果，显卡的风扇会一直转。我调整到显卡温度到65度才会开始转，这样静音效果比较好。如果用别人已经调好了值，自己想在这种结果上修改，可以看一下Excel表中最后的Output怎么来的：可以看到Output的值其实就是左面Output上面所有单元格的值拼起来，我们修改右侧的一些值，左侧的带颜色的单元格的值就会变化，最后Output的值也会变化，其中左侧单元格颜色对应的就是右面单元格每行相对应颜色的值，也是一个函数，下面随便来举一个例子：看上图中的FC，函数对应的是AD4，意思就是这个单元格的值就是AD列，第4行的值，右侧第4行的颜色和左侧FC单元格的颜色是一样的，再看AD4的值就是FC，再点到AD4上，看到对应的函数： AD4取的值是AC4的后两位，再去看AC4的值是怎么来的：可以看到AC4的值是AB4的16进制数，并且格式化成4位，2300的16进制可以算一下：可以看到2300的16进制是8fc，然后格式化成4位，高位加0，就是08FC，通过上面一系列可以得到，我们修改AB4单元格的值可以影响到左侧的Output值。所以拿到别人调整好的Output值，想在调整好的值上面修改一些东西可以这样对应一下去修改。

总结

如果没有这场疫情，可能自己永远都不会想着去解决黑屏的问题，还是用着那个有问题的显卡。所以以后应该直面一些问题，问题总会解决的。只是需要些时间嘛。

再说后面调整显卡，其实自己完全可以将就着用，直接把其他大佬调整的值抄过来。但是用抄过来的值显卡风扇会一直转，像我这么追求完美的人怎么会允许风扇一直转(不经意间又自夸了一下，哈哈)。只能自己去探索一下了，本来以为很难的事情，经过探索那个Excel表发现，其实大佬只是调整了超频的几个值，风扇的自动控制是关的，只要把风扇的自动控制打开就可以达到自己想要的效果了。所以有些东西看起来很难，但是稍微去研究一下就会发现其实还蛮简单的。

有的人说了，追求完美直接去买白苹果啊，折腾啥黑苹果。哎，没办法，我就想折腾一些自己没玩过的东西。黑果可以撸代码，还可以切Windows玩游戏，爽歪歪。白果显卡太垃圾，升级不合算，还是黑果香～

iOS 13 ScrollView截图问题记录

2019-09-24

最近有个需求，需要给TabelView截图。当时做的比较着急，从stackoverflow上面抄了如下一段代码，并且可以正常运行。代码如下：

UIImage* image = nil;
UIGraphicsBeginImageContext(_scrollView.contentSize);
{
	CGPoint savedContentOffset = _scrollView.contentOffset;
	CGRect savedFrame = _scrollView.frame;

	_scrollView.contentOffset = CGPointZero;
	_scrollView.frame = CGRectMake(0, 0, _scrollView.contentSize.width, _scrollView.contentSize.height);

	[_scrollView.layer renderInContext: UIGraphicsGetCurrentContext()];     
	image = UIGraphicsGetImageFromCurrentImageContext();

	_scrollView.contentOffset = savedContentOffset;
	_scrollView.frame = savedFrame;
}
UIGraphicsEndImageContext();

最近发版，QA同学在iOS13的手机上面测试，发现这个方法截图只能截到TableView高度的图，没有截到TableView全部的图。于是仔细看了一下截图的代码，发现原理是把TableView的frame改为和TableView的containerSize相同后，再去截图，但是在iOS13上面不好用。经过各种尝试，发现可以通过创建一个和TableView大小相同的临时view，然后把TableView添加到这个临时view，然后再对这个临时view进行截图，就可以再iOS13上面截到完整的图了。代码如下：

- (UIImage *)getTableViewImageWithTabelview:(UITableView *)tableview{
    UIImage* viewImage = nil;
    UITableView *scrollView = tableview;
    UIGraphicsBeginImageContextWithOptions(scrollView.contentSize, NO, 0.0);
    {
		// 保存原来的偏移量
        CGPoint savedContentOffset = scrollView.contentOffset;
        // CGPoint savedFrame = scrollView.frame;

		// 设置截图需要的偏移量和frame
        scrollView.contentOffset = CGPointZero;
        scrollView.frame = CGRectMake(0, 0, scrollView.contentSize.width, scrollView.contentSize.height);
        
		// 创建临时view，并且把要截图的view添加到临时view上面
        UIView *tempView = [[UIView alloc]initWithFrame:CGRectMake(0, 0, scrollView.contentSize.width, scrollView.contentSize.height)];
        [scrollView removeFromSuperview];
        [tempView addSubview:scrollView];
        
		// 对临时view进行截图
        [tempView.layer renderInContext:UIGraphicsGetCurrentContext()];
        viewImage = UIGraphicsGetImageFromCurrentImageContext();
        
		// 恢复截图view原来的状态
        [scrollView removeFromSuperview];
        [self addSubview:scrollView];
        scrollView.contentOffset = savedContentOffset;

		// 如果原来是frame布局，需要设置frame，如果是Auto layout需要再次进行Auto layout布局。
		// scrollView.frame = savedFrame;
        [scrollView mas_makeConstraints:^(MASConstraintMaker *make) 	{
            make.edges.equalTo(self);
        }];
    }
    UIGraphicsEndImageContext();
    
    return viewImage;
}

这里需要注意，如果原来TableView用的是Auto layout进行的布局，那么后面需要对TableView再次进行布局。不然的话，截图之后会发现TableView不见了。

Metal基础概念——利用GPU高效计算

2019-08-02

Metal是Apple提供的一个可以让我们开发者直接和GPU对话的API。Metal在图像处理，并行计算方面通过发挥GPU的特性，极大提升了性能。

由于本人最近在一个画板需求中使用了Metal，做项目的时候由于Deadline的原因，当时并没有有系统学习。现在项目上线，回头系统学习一下Metal，顺便入门一下图像处理。本文主要是介绍一些Metal的基础概念，通过一系列项目来了解Metal。

在GPU中进行计算

通过这个例子，我们会介绍一些在所有Metal应用中都会用到的一些概念：

编写可以在GPU中执行的函数
找到一个GPU
通过创建管道让第一步创建的函数可以在GPU上执行
创建GPU可以访问的内存保存数据
创建command buffer并且编码GPU指令来操作数据
提交command buffer到command queue来让GPU执行编码的指令

既然是想利用GPU进行一些操作，我们通过下图来看一下如何使用GPU进行操作：我们只需要组装command，然后提交到GPU就可以得到我们想要的结果。

编写在GPU中执行的函数

通过下面两个函数，我们来看一下在GPU中计算和在CPU中进行计算的区别，我们先来看一下在CPU中把两个数组中的数相加然后把结果写到第三个数组的计算过程：

void add_arrays(const float* inA,
                const float* inB,
                float* result,
                int length)
{
    for (int index = 0; index < length ; index++)
    {
        result[index] = inA[index] + inB[index];
    }
}

接下来我们看一下如何使用GPU实现相同的功能，在GPU中执行的函数我们统称为着色器函数(至于为什么叫着色器函数是有历史原因的，因为在GPU执行的函数大多是用来处理图像的像素的，所以叫做着色器函数)：

kernel void add_arrays(device const float* inA,
                       device const float* inB,
                       device float* result,
                       uint index [[thread_position_in_grid]])
{
    // the for-loop is replaced with a collection of threads, each of which
    // calls this function.
    result[index] = inA[index] + inB[index];
}

先不要管上面函数中kernel、[[thread_position_in_grid]]这些代码是什么意思(这些是Metal Shader Language的固定语法，不属于本文的讨论)，只看计算过程。通过对比，我们可以发现在GPU中，我们可以并行的对每个元素进行计算，而在CPU中，我们需要遍历数组进行计算。这就是GPU强大的运算能力。我们知道，CPU擅长进行逻辑控制，串行的运算，而GPU擅长大规模的并发计算，比如上面这种简单的运算。而图像处理本身就需要大量的简单运算，所以非常适合GPU，所以一般图像处理的任务都会交给GPU去做。

找到一个GPU对象

有了上面的函数，我们如何让这个函数在GPU中执行呢？首先，我们需要拿到一个GPU。在iOS中，我们可以通过Metal的MTLCreateSystemDefaultDevice()这个函数去拿到一个GPU的抽象对象MTLDevice。GPU对象的创建非常耗时，我们平常使用时最好使用一个单例去持有它，然后进行复用。

创建管道让函数在GPU中执行

通过上面简单的函数，我们获取到GPU的抽象对象。接下来需要配置一下我们前面写的运算函数，来让函数可以在GPU中进行执行。当我们编译Metal应用时，Xcode会把着色器函数编译到默认的Metal library中。我们可以使用MTLLibrary和MTLFunction分别获取Metal library和着色器函数的信息。我们可以通过MTLDevice创建MTLLibrary，然后通过MTLLibrary来获取着色器函数:

_mDevice = device;
        
NSError* error = nil;
// Load the shader files with a .metal file extension in the project

id<MTLLibrary> defaultLibrary = [_mDevice newDefaultLibrary];
if (defaultLibrary == nil)
{
	NSLog(@"Failed to find the default library.");
	return nil;
}

id<MTLFunction> addFunction = [defaultLibrary newFunctionWithName:@"add_arrays"];
if (addFunction == nil)
{
	NSLog(@"Failed to find the adder function.");
	return nil;
}

取到着色器函数，接下来我们创建管道来配置函数，因为这里我们想使用GPU进行运算，所以，我们创建一个计算类型的管道，除了计算类型的管道还有渲染类型的管道，也就是我们经常听说的渲染管道。由于这里我们只想计算一下，所以这里我们创建一个计算类型的管道MTLComputePipelineState:

_mAddFunctionPSO = [_mDevice newComputePipelineStateWithFunction: addFunction error:&error];

创建command queue

为了把任务提交到GPU，我们需要一个command queue，对应前面图中粉色的轨道。Metal使用命令队列来安排命令。

_mCommandQueue = [_mDevice newCommandQueue];

创建数据

因为这里我们要计算两个数组元素相加对应的和，所以这里我们需要三个数组，两个相加的数组和一个存放结果的数组。GPU可以拥有自己的内存，也可以和操作系统共享内存。Metal使用MTLResource来管理内存。一个Resource表示在执行command时GPU可以访问的内存。使用MTLDeveice为它所代表的GPU创建resource。

_mBufferA = [_mDevice newBufferWithLength:bufferSize options:MTLResourceStorageModeShared];
_mBufferB = [_mDevice newBufferWithLength:bufferSize options:MTLResourceStorageModeShared];
_mBufferResult = [_mDevice newBufferWithLength:bufferSize options:MTLResourceStorageModeShared];

在这个例子中的resource是一个MTLBuffer对象，它继承自MTLResource，MTLBuffer分配的时候没有进行预先格式化。我们可以在使用的时候指定这块内存的格式。我们在分配的时候指定了一个option，MTLResourceStorageModeShared，这个option表示GPU和CPU都可以访问这块内存。为了计算两个数组相加的结果，我们需要填充_mBufferA和_mBufferB：

- (void) generateRandomFloatData: (id<MTLBuffer>) buffer
{
    float* dataPtr = buffer.contents;
    
    for (unsigned long index = 0; index < arrayLength; index++)
    {
        dataPtr[index] = (float)rand()/(float)(RAND_MAX);
    }
}

创建command buffer

接下来我们通过command queue创建command buffer：

id<MTLCommandBuffer> commandBuffer = [_mCommandQueue commandBuffer];

创建command encoder

为了把command写到command buffer中，我们使用command encoder来编码具体类型的command。这个例子中，我们创建一个计算类型的command encoder，这个encoder编码计算过程。我们调用encoder的一些方法设置一些状态信息，比如设置管道和传入管道的参数。Encoder会把所有的状态改变和command参数写入到command buffer中。

id<MTLComputeCommandEncoder> computeEncoder = [commandBuffer computeCommandEncoder];
[computeEncoder setComputePipelineState:_mAddFunctionPSO];
[computeEncoder setBuffer:_mBufferA offset:0 atIndex:0];
[computeEncoder setBuffer:_mBufferB offset:0 atIndex:1];
[computeEncoder setBuffer:_mBufferResult offset:0 atIndex:2];

每一个计算command都会让GPU创建一组线程去执行计算，这里我们需要设置GPU分配的线程数，关于如何计算这个数字，不属于本文讨论范围，想要了解详细的计算可以看 Calculating Threadgroup and Grid Sizes 这篇文章。在这里我们先简单设置一下：

MTLSize gridSize = MTLSizeMake(arrayLength, 1, 1);
NSUInteger threadGroupSize = _mAddFunctionPSO.maxTotalThreadsPerThreadgroup;
if (threadGroupSize > arrayLength)
{
    threadGroupSize = arrayLength;
}
MTLSize threadgroupSize = MTLSizeMake(threadGroupSize, 1, 1);
[computeEncoder dispatchThreads:gridSize
          threadsPerThreadgroup:threadgroupSize];

描述完整个计算过程后，我们可以调用[computeEncoder endEncoding];这个方法关闭计算过程。

提交command buffer执行命令

我们可以通过调用[commandBuffer commit];这个方法，提交command buffer中的命令。我们提交后，Metal会异步的准备将要执行的命令，然后安排GPU执行命令。当GPU执行完command buffer中的所有命令后，Metal会标记这个command buffer执行完成。

我们的应用可以在GPU执行命令时做一些其他的工作，在这个例子中，我们不需要做其他工作，所以在这里我们等待GPU执行完整个command buffer：

[commandBuffer waitUntilCompleted];

Metal也支持通知的方式来通知应用，我们可以通过command buffer 的addCompletedHandler:方法添加一个handler，或者监听command buffer的status属性来在GPU执行命令时做其他工作

读取结果并验证正确定

当command buffer被执行后，GPU的计算结果存放在输出的buffer中。在一个真实的应用中，我们会从buffer中读取结果，并使用这个结果做一些事情，比如：在屏幕上显示结果或着把结果写入到文件中。在我们这个例子中，我们仅仅读取一下结果验证一下在GPU中计算是否和在CPU中计算的是否一致。

- (void) verifyResults
{
    float* a = _mBufferA.contents;
    float* b = _mBufferB.contents;
    float* result = _mBufferResult.contents;

    for (unsigned long index = 0; index < arrayLength; index++)
    {
        assert(result[index] == a[index] + b[index]);
    }
}

总结

通过这个例子，我们可以看到，通过编码命令的方式，可以让GPU执行一些任务。在这个例子中，我们仅仅让GPU执行了一些运算任务。让GPU执行一些其他的任务和计算任务大同小异，都是这些过程：

先要找到GPU对象
编写任务函数
通过编码任务把数据丢给GPU
提交任务。

我们可以利用GPU执行很多任务，但是一定要发挥GPU强大的运算能力。比如图像处理就是让GPU对每个像素执行一些算法，然后变换出一些滤镜效果。一定不要把CPU擅长的任务交给GPU去做，这就南辕北辙了。接下来我们将介绍一下GPU最重要的能力——渲染。

本文实例代码：代码

白驹过隙--2018总结

2019-02-05

2018 不知不觉就过去了，在 2018 年的尾巴公司决定实行 OKR，所以本文从工作、生活、学习、投资方面总结一下 2018，并制定一下 2019 的 OKR。

工作

工作方面 2018 还是比较满意的，在 10 月份因为公司原因自己换了一份工作，新公司的技术氛围、福利和环境都比上一家公司好很多。希望自己可以在未来的日子里可以在新公司发光发热。

生活

生活方面其实没有多少讲的，就是今年花费巨资去植了发。不得不说，钱花的很值。形象提高了，自信也提高了不少！哈哈，以后在这方面的钱绝对不省。

学习

去年制定了好多目标，看好多书。然而今年实现的却很少，因为从今年 5 月份就在筹划换一份工作，所以平时闲暇时间大部分用在复习 iOS 基础知识上。通过复习，发现自己还是平常看的太多，实践的太少。一些知识只是在看的当时感觉自己懂了，并没有去验证为什么。就拿 runtime 源码来举例，看了无数篇 blog，但是自己并没有去具体的调研到底为什么，所以以前在面试时总是感觉有些东西说不上来。今年在计划换工作时就花了一大部分时间去研究 iOS 底层知识，关于 runtime 写了两篇 blog。在这里强烈推荐 Dravness 的 blog，跟着一步一步调试下来会发现对一些知识会有更深刻的认识，在面试时回答会更加切中要点。还有一些知识点的整理，并没有在文章方面体现，主要在一些笔记中。

当然，花时间去准备面试也是没有白费。在面试找工作过程中相比较值钱会更顺利一些。在对知识有了更深刻的理解之后，在面试过程中很容易就可以 get 到面试官的一些问题点，然后重点回答。当然也有一些不足，就是自己只准备了 iOS 相关的基础，其他的，比如数据结构和算法、操作系统、编译原理方面的的知识还是比较薄弱，这也是进不了一些大厂的原因。今年对网络方面的知识也有了一个初步的了解，准备在 19 年可以有一些深入的理解。总结来说，今年的进步还是不是很大，主要是对 iOS 基础知识和网络有了一定的了解，计算机基础方面的知识的还是没有什么进展。这也是 19 年 OKR 的重点。

投资

从 17 年 10 月份开始在且慢跟投长赢计划开启了自己的投资之路，年初的时候看到腾讯跌倒 419 块，感觉很便宜了，就想进去投机，然后很自然的被套了。后来又关注了电子货币，又想投机电子货币，就在腾讯发布了第一季度财报涨了一些时把腾讯卖了，入了电子货币的坑。重仓了 EOS，然后在高点时没有套现离场，到现在被深套。

2018 年自己的投资之路现在看起来还是挺动荡的，虽然赔了很多钱，但是自己一点也不后悔。因为经历了之后，心态会不一样。刚开始投长赢计划时自己每天都会看收益，甚至每天会去看几次。感觉都会影响工作，但是经历了腾讯和电子货币之后，感觉心态都不一样了。可能是被搞得破罐子破摔了[捂脸]。但是说真心话，经历过之后的心态真的不一样。虽然自己在电子货币上的钱亏了 90%，但是自己真的不后悔。今年学到了，以后绝对不会去投机。不懂的地方绝对不碰。

2019 的 OKR

以前一直在盲目的立 flag，感觉有好多东西需要去学习。年底看了有关 OKR 的东西之后，感觉这个东西不仅可以在工作方面使用，还是用来管理自己的成长。

想了一下自己的价值观，自己想成为一个终身成长的人，所以 OKR 对自己非常适用。

所以在这里制定一下自己 2019 年的 OKR。

学习方面

学习计算机基础知识：Key Result 为：

数据结构和算法方面：每星期学习三篇《数据结构和算法之美》专栏内容，并根据内容拓展学习算法方面的书籍，比如《大话数据结构》，《数据结构与算法分析》，《算法》等。
设计模式方面：读 Raywenderlich 的设计模式书籍，每周一章，配合《研磨设计模式》和《设计模式》等书籍争取把设计模式搞明白。
操作方面，读《程序员的自我修养》，《深入理解计算机系统》。
编译原理方面：《SICP》
网络方面：《图解 HTTP》，《图解 TCP/IP》，《计算机网络》，《TCP/IP 详解》。

2018 年其实知识付费了很多东西，希望今年抽时间把一些付费课程看完，比如方糖全栈课，还有一些极客时间的专栏争取看完。其实上面的书不要求看完，但是数据结构、设计模式、操作系统、网络相关的知识需要有一定的了解。把 2018 年的付费课程能看完并且配合一些书籍，这些知识都会有一定的了解。其中的顺序可以根据自己的心情去决定，可能会先去看设计模式和数据结构，其他的可能会往后放放，也可能会根据工作需要有变动，这里不列具体计划。同时希望自己可以在 2019 年坚持一年的 ARTS。

投资方面

投资方面虽然 2018 亏了很多，但是自己还没有割肉。电子货币已经很失望了，要么归零要么暴富。反正 2019 绝对不会考虑投资电子货币了。会继续跟投长赢计划，然后把自己欠的钱还完。等有闲钱会去考虑买一些保险和股票之类的东西。经历了 2018 年，自己在投资方面的心态好了很多。以后会多去践行价值投资理念。嗯嗯，关于这方面有时间会去找一些书籍来看。但是今年估计没有时间了，学习计算机基础的优先级会最高。

生活方面

在生活方面其实没有很多的要求，主要是健身相关的，希望 2019 年自己的身体可以棒棒的，已经报了一个健身工作室了，希望自己到夏天可以把肚子弄下去～如果有时间可以报一个英语学习的课程，学习英语。其实自己这辈子的目标就是写一手好的代码，说一口流利的英语，在这之后可以财务自由就可以啦～哈哈，想的有点多，2019 加油～