Pod update注意

1、先执行pod repo update 公司内部库specs
2、再执行pod update --no-repo-update这样就不会update github_specs，速度快

JSONSerialization

涉及到JSON Object<->NSData数据转换的地方，注意对NSError的处理和JSON Object合法性的校验，如：

BOOL validate = [NSJSONSerialization isValidJSONObject:parament];
            if (!validate) {
                // 对不是合法的JSON对象错误进行处理
                return;
            }
            NSError *error = nil;
            NSData *jsonData = [NSJSONSerialization dataWithJSONObject:parament options:NSJSONWritingPrettyPrinted error:&error];
            if (error) {
                // 对数据转换错误进行处理
                return;
            }

合法JSON对象满足：
1、Top level object is an NSArray or NSDictionary
2、All objects are NSString, NSNumber, NSArray, NSDictionary, or NSNull
3、All dictionary keys are NSStrings
4、NSNumbers are not NaN or infinity

补充一些代码规范、开发约定

写if else语句时可以else不换行紧跟if的}括号，但写if else if时，为了保持条件{}的可读性，务必请换行书写:

// if else
    BOOL flag = YES;
    if (flag) {
        
    } else {
        
    }

// if else if
    BOOL flag = YES;
    BOOL elseIfFlag = (1+1-1+2 == 5);
    if (flag) {
        
    }
// 这里换行书写
    else if(elseIfFlag) {
        
    }

对于@property声明的属性，如果初始化设置复杂，请采用懒加载getters方式，对于简单初始化的，应在.m文件中提供统一的-initData初始化数据的方法。

/// 懒加载方式-内部配置
@property(nonatomic, strong)UIView *redView;
/// 统一初始化
@property(nonatomic, strong)NSMutableArray *dataSourceArray;

/// 统一数据初始化
- (void)initData{
    _dataSourceArray = [NSMutableArray new];
}

/// 懒加载
- (UIView *)redView{
    if (!_redView) {
        _redView = [UIView new];
        _redView.backgroundColor = UIColor.redColor;
    }
    return _redView;
}

对于NSDictionary、NSArray等的初始化，为提高可读性起见，建议采用语法糖的初始化方式：

_dataSourceArray = [@[@"1", @"2"] mutableCopy];
_parameters = [@{@"action": @"add", @"id": @"22"} mutableCopy];

// X: 不推荐这样做
_dataSourceArray = [NSMutableArray new];
[_dataSourceArray addObject:@"1"];
[_dataSourceArray addObject:@"2"];

_parameters = [NSMutableDictionary new];
[_parameters setValue:@"add" forKey:@"action"];
[_parameters setValue:@"22" forKey:@"id"];

对于Category中的对外公有方法，务必采用categoryName_funcName的命名方式，以区别于主类里没有前缀的方法：

// TALPlayer+LogReport.h

/// 加载播放器
- (void)logReport_loadPlayer;
/// 开始播放
- (void)logReport_startPlay;

对于Category里的私有同名方法，可采用下划线方式如_mainClassFuncName以区别.
对于主类里的私有属性，在多个Category访问时，可采用属性中间件的方式，拆出一个独立的MainClass+InternalProperty来提供一些getters方法：

// TALPlayer+InternalProperty.h

- (TALPlayerLogModel *)internalProperty_logModel;
- (TALPlayerStaticsModel *)internalProperty_staticsModel;


// TALPlayer+InternalProperty.m

- (TALPlayerLogModel *)internalProperty_logModel{
    // 这里为方便以后调试断点用，建议拆开2行写
    id value = [self valueForKey:@"logModel"];
    return value;
}

对于需要跟服务器交互的网络请求参数字符串，务必独立出对应Category的DataInfoKeys扩展文件，方便查询、注释、全局引用、修改和拼写纠错：

// TALPlayer+LogReportDataInfoKeys.h

/// action
extern NSString *const LogReportDataInfoActionKey;
/// 心跳
extern NSString *const LogReportDataInfoActionHeartBeatKey;
/// 严重卡顿
extern NSString *const LogReportDataInfoActionSeriousBufferKey;


// TALPlayer+LogReportDataInfoKeys.m

// action
NSString *const LogReportDataInfoActionKey = @"action";
/// 心跳
NSString *const LogReportDataInfoActionHeartBeatKey = @"heartbeat";
/// 严重卡顿
NSString *const LogReportDataInfoActionSeriousBufferKey = @"seriousbuffer";


// 使用
#import "TALPlayerLogReportDataInfoKeys.h"

NSMutableDictionary *info = [NSMutableDictionary new];
info[LogReportDataInfoActionKey] = LogReportDataInfoActionHeartBeatKey;
// info[XXXKey] = value;

对于.h及.m文件中默认#pragma mark的规范，推荐如下:

// XXX.h

#pragma mark - Protocol

#pragma mark - Properties

#pragma mark - Methods

// XXX.m

#pragma mark - Consts

#pragma mark - UI Components

#pragma mark - Data Properties

#pragma mark - Initial Methods

#pragma mark - Lifecycle Methods

#pragma mark - Override Methods

#pragma mark - Public Methods

#pragma mark - Private Methods

#pragma mark - XXXDelegate

#pragma mark - Getters

#pragma mark - Setters

如上相关#pragma字符在Xcode中的自动配置，有机会我会单独分享给大家。
Xcode FileTemplate路径：Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/Library/Xcode/Templates/File Templates/Source/Cocoa Touch Class.xctemplate/

对于OC文件中注释规范说明：

//MARK: mark here(类似于#pragma mark，只不过没有横线)

//TODO: todo here

//FIXME: fix me later

//???: What is this shit

//!!!: DO NOT TOUCH MY CODE

说明：
对于单行注释，尽量用//代替/**/格式，，务必请在//后加一个空格，再进行内容补充，如：// 这是单行注释而不要写成//这是单行注释
对于SDK内部私有方法，如果无参数，则采用/// 这是无参数方法注释格式；
对于SDK需要向外暴露的接口方法注释，请务必按照AppleDoc编写，写明@param、@return等：

/**
 * 这是一个demo方法
 * @param param1 第一个参数
 * @param param2 第二个参数
 * @return BOOL值
 */
 - (BOOL)thisIsADemoFuncWithParam1: (NSString *)param1
                            param2: (NSInteger)param2{
    return NO;
}

1、对于@property申明的SDK公开属性，务必写成/* 这是SDK公开属性注释 */，方便调用时Xcode提示；

2、对于SDK内部使用的属性，最好写成/// 这是属性注释而不是/**/；

3、另外，务必让对于>=2个参数的方法，各个参数折行对齐，务必保持.h和.m方法参数格式一致；

4、对于方法名的统一性说明：

  4.1 如果方法是功能性的，处理某些事件、计算、数据处理等的私有方法，则可定义方法名为handleXXX:，如-handleRedBtnClick:、-handleResponsedData:、-handlePlayerEvent:等；

  4.2 对于一些需要暴露的公有方法，则命名最好按照n的功能命名，如对于一个TALPlayer它可以play、stop、resume等；

  4.3 对于可以switch两种状态切换的状态方法，最好命名为toggleXXX:(BOOL)on，如- (void)toggleMute:(BOOL)on；

5、对于一些状态描述性的属性，可以用needs、is、should、has+adj/vb组合形式，如needsAutoDisplay、shouldAutoRotateOrientation、isFinished、hasData或hasNoData等；

对于一些NS_ENUM枚举定义，务必遵循统一前缀方式:

typedef enum : NSUInteger {
    TALPlayerEventA = 0,
    TALPlayerEventB,
    TALPlayerEventC,
} TALPlayerEvent;
// 或者
typedef NS_ENUM(NSUInteger, MyEnum) {
    MyEnumValueA,
    MyEnumValueB,
    MyEnumValueC,
};

6、对于一些全局宏的定义，务必SDK前缀全大写_NAME_组合如TALPLAYER_GLOBAL_MACRO_NAME，对于const类型的常量，务必加上k前缀，命名为kConstValue；

7、对于一些typedef的Block，命名最好指明Block的类别+用途，如TALPlayerLogReportHandler，如果有功能性区分的话，则可以定义为TALPlayerLogReportCompletionHandler、TALPlayerLogReportSuccessHandler、TALPlayerLogReportFailureHandler注意是名词组合形式；

8、调用Block时，一定要对block对象进行nil值判断，防止崩溃handler ? handler() : nil;

9、所有对于NSString校验的地方，都应该校验其length > 0，而不是!str；

10、所有对于NSURL校验的地方，都应该校验其[URL.scheme.lowercaseString isEqualToString: @"https"]方式，而不是!URL；

链接：https://www.jianshu.com/p/deb117eca9ea

• 上一篇文章我们讲到了load方法，今天我们来看看initialize

新建项目，新建类（和上一篇文章所建的类相同，方便大家理解，具体的类相关关系可以看上一篇文章我的介绍）类结构图如下

将原来的load方法换成initialize

先告诉大家initialize方法调用的时间，以便大家带着答案去理解initialize：在类第一次接收到消息的时候调用，它区别于load(运行时加载类的时候调用)，下面我们来深入理解initialize

• 1. 相信大家在想什么叫第一次接收消息了，我们回到main（）

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

    }

    return 0;

}

2020-12-04 14:59:17.417072+0800 TCCateogry[1616:79391] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

        [TCPerson alloc];

    }

    return 0;

}

2020-12-04 15:11:12.246442+0800 TCCateogry[1659:85317] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCStudent alloc];

      

    }

    return 0;

}

2020-12-04 15:14:58.705423+0800 TCCateogry[1705:87507] TCPerson (TCtest2) +initialize

2020-12-04 15:14:58.705750+0800 TCCateogry[1705:87507] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];

        [TCPerson alloc];

        [TCStudent alloc];

        [TCStudent alloc];

    }

    return 0;

}

020-12-04 15:23:27.168243+0800 TCCateogry[1731:91248] TCPerson (TCtest2) +initialize

2020-12-04 15:23:27.168601+0800 TCCateogry[1731:91248] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

#import "TCStudent.h"



@implementation TCStudent

//+ (void)initialize{

//    NSLog(@"TCStudent +initialize");

//}

@end

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson alloc];   

        [TCStudent alloc];

    }

    return 0;

}

2020-12-04 15:37:09.055459+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

2020-12-04 15:37:09.055775+0800 TCCateogry[1822:98237] TCPerson (TCtest2) +initialize

Program ended with exit code: 0

#import "TCStudent.h"



@implementation TCStudent

+ (void)initialize{

    NSLog(@"TCStudent +initialize");

}

@end

#import "TCStudent+TCStudentTest1.h"



@implementation TCStudent (TCStudentTest1)

+ (void)initialize{

    NSLog(@"TCStudent (TCStudentTest1) +initialize");

}

@end#import "TCStudent+TCStudentTest2.h"



@implementation TCStudent (TCStudentTest2)

+ (void)initialize{

    NSLog(@"TCStudent (TCStudentTest2) +initialize");

}

@end

2020-12-04 15:41:21.863260+0800 TCCateogry[1868:100750] TCPerson (TCtest2) +initialize

2020-12-04 15:41:21.863568+0800 TCCateogry[1868:100750] TCStudent (TCStudentTest2) +initialize

Program ended with exit code: 0

首先先看几个面试问题

• Cateogry里面有load方法么? load方法什么时候调用？load方法有继承么？

1. 新建一个项目，并添加TCPerson类，并给TCPerson添加两个分类

2.新建一个TCStudent类继承自TCPerson，并且给TCStudent也添加两个分类

#import "TCPerson.h"



@implementation TCPerson

+ (void)load{

    

}

@end

#import "TCPerson+TCtest1.h"



@implementation TCPerson (TCtest1)

+ (void)load{

    

}

@end

#import "TCPerson+TCTest2.h"



@implementation TCPerson (TCTest2)

+ (void)load{

    

}

@end

#import <Foundation/Foundation.h>



int main(int argc, const char * argv[]) {

    @autoreleasepool {

        

    }

    return 0;

}

@implementation TCPerson

+ (void)load{

    NSLog(@"TCPerson +load");

}

@end





@implementation TCPerson (TCtest1)

+ (void)load{

    NSLog(@"TCPerson (TCtest1) +load");

}

@end

@implementation TCPerson (TCTest2)

+ (void)load{

    NSLog(@"TCPerson (TCtest2) +load");

}

@end

从输出结果我们可以看出，三个load方法都被调用

问题：分类重写方法，真的是覆盖原有类的方法么？如果不是，到底分类的方法是怎么调用的？

• 首先我们在TCPerson申明一个方法+ (void)test并且在它的两个分类都重写+ (void)test

#import <Foundation/Foundation.h>



NS_ASSUME_NONNULL_BEGIN



@interface TCPerson : NSObject

+ (void)test;

@end



NS_ASSUME_NONNULL_END

#import "TCPerson.h"



@implementation TCPerson

+ (void)load{

    NSLog(@"TCPerson +load");

}

+ (void)test{

    NSLog(@"TCPerson +test");

}

@end

分类重写test

#import "TCPerson+TCtest1.h"



@implementation TCPerson (TCtest1)

+ (void)load{

    NSLog(@"TCPerson (TCtest1) +load");

}

+ (void)test{

    NSLog(@"TCPerson (TCtest1) +test1");

}

@end

#import "TCPerson+TCTest2.h"



@implementation TCPerson (TCTest2)

+ (void)load{

    NSLog(@"TCPerson (TCtest2) +load");

}

+ (void)test{

    NSLog(@"TCPerson (TCtest2) +test2");

}

@end

在main里面我们调用test

#import <Foundation/Foundation.h>

#import "TCPerson.h"

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson test];

    }

    return 0;

}

从输出结果中我们可以看到，只有分类2中的test被调用，为什么只调用分类2中的test了？

因为编译顺序是分类2在后，1在前，这个时候我们改变编译顺序（拖动文件就行了）

细心的老铁会看到，为什么load方法一直都在调用，这是为什么了？它和test方法到底有什么不同了？真的是我们理解中的load不覆盖，test覆盖了，所以才出现这种情况么？

我们打印TCPerson的类方法

void printMethodNamesOfClass(Class cls)

{

    unsigned int count;

    // 获得方法数组

    Method *methodList = class_copyMethodList(cls, &count);

    

    // 存储方法名

    NSMutableString *methodNames = [NSMutableString string];

    

    // 遍历所有的方法

    for (int i = 0; i < count; i++) {

        // 获得方法

        Method method = methodList[I];

        // 获得方法名

        NSString *methodName = NSStringFromSelector(method_getName(method));

        // 拼接方法名

        [methodNames appendString:methodName];

        [methodNames appendString:@", "];

    }

    

    // 释放

    free(methodList);

    

    // 打印方法名

    NSLog(@"%@ %@", cls, methodNames);

}

int main(int argc, const char * argv[]) {

    @autoreleasepool {

        [TCPerson test];

        printMethodNamesOfClass(object_getClass([TCPerson class]));

    }

    return 0;

}

可以看到，TCPerson的所有类方法名，并不是覆盖，三个load，三个test，方法都在

load源码分析：查看objc底层源码我们可以看到：

void call_load_methods(void)

{

    static bool loading = NO;

    bool more_categories;



    loadMethodLock.assertLocked();



    // Re-entrant calls do nothing; the outermost call will finish the job.

    if (loading) return;

    loading = YES;



    void *pool = objc_autoreleasePoolPush();



    do {

        // 1. Repeatedly call class +loads until there aren't any more

        while (loadable_classes_used > 0) {

            call_class_loads();

        }



        // 2. Call category +loads ONCE

        more_categories = call_category_loads();



        // 3. Run more +loads if there are classes OR more untried categories

    } while (loadable_classes_used > 0  ||  more_categories);



    objc_autoreleasePoolPop(pool);



    loading = NO;

}

load方法它是先调用 while (loadable_classes_used > 0) {call_class_loads(); }类的load，再调用more_categories = call_category_loads()分类的load，和编译顺序无关，都会调用
我们查看call_class_loads()方法

static void call_class_loads(void)

{

    int I;

    

    // Detach current loadable list.

    struct loadable_class *classes = loadable_classes;

    int used = loadable_classes_used;

    loadable_classes = nil;

    loadable_classes_allocated = 0;

    loadable_classes_used = 0;

    

    // Call all +loads for the detached list.

    for (i = 0; i < used; i++) {

        Class cls = classes[i].cls;

        load_method_t load_method = (load_method_t)classes[i].method;

        if (!cls) continue; 



        if (PrintLoading) {

            _objc_inform("LOAD: +[%s load]\n", cls->nameForLogging());

        }

        (*load_method)(cls, SEL_load);

    }

    

    // Destroy the detached list.

    if (classes) free(classes);

}

其通过的是load_method_t函数指针直接调用
函数指针直接调用

typedef void(*load_method_t)(id, SEL);

其分类load方法调用也是一样

static bool call_category_loads(void)

{

    int i, shift;

    bool new_categories_added = NO;

    

    // Detach current loadable list.

    struct loadable_category *cats = loadable_categories;

    int used = loadable_categories_used;

    int allocated = loadable_categories_allocated;

    loadable_categories = nil;

    loadable_categories_allocated = 0;

    loadable_categories_used = 0;



    // Call all +loads for the detached list.

    for (i = 0; i < used; i++) {

        Category cat = cats[i].cat;

        load_method_t load_method = (load_method_t)cats[i].method;

        Class cls;

        if (!cat) continue;



        cls = _category_getClass(cat);

        if (cls  &&  cls->isLoadable()) {

            if (PrintLoading) {

                _objc_inform("LOAD: +[%s(%s) load]\n", 

                             cls->nameForLogging(), 

                             _category_getName(cat));

            }

            (*load_method)(cls, SEL_load);

            cats[i].cat = nil;

        }

    }

为什么test不一样了

因为test是因为消息机制调用的，objc_msgSend([TCPerson class], @selector(test));消息机制就牵扯到了isa方法查找，test在元类方法里面顺序查找的

load只在加载类的时候调用一次，且先调用类的load，再调用分类的

#import "TCStudent.h"



@implementation TCStudent



@end

最近一直在看React的一些东西，其实很早前就想开始重拾前端，但是一直提不起兴趣再去看JavaScript，对CSS这种布局方式也不是很来感，说白了，就是懒吧😂。去年年底开始在公司app里开始尝试接入Weex，所以不得不把JavaScript再重新撸了一遍，顺带着把ES6的一些新特性也了解了一下，更好的函数调用方式，Class的引入，Promise的运用等等，其实最吸引我的还是在用了Weex之后，感受到了Component带来的UI复用，高效开发的快感。Weex是运用Vue.js来调用，渲染native控件，来达到one code, run everywhere。不管是Vue.js，还是React，最终都是朝着W3C WebComponent的标准走了（今年会发布的Vue 3.0在组件上的语法基本上跟React一样了）。这篇就来讲讲我对React Component的理解，还有怎么把这个标准也能在native上面做运用

demo源码

iOS UI开发的痛点

对iOS开发来说，最常用的UI组件就是UICollectionView了，就是所谓的一个列表页，现在的app大部分页面都是由一个列表来呈现内容的。对iOS开发者来说，我们可以封装每个UICollectionViewCell，从而可以在每个页面的UICollectionView中能够复用，但是痛点是，这个复用仅仅是UI上的复用，在每写一个新的页面（UIViewController）的时候，还是需要新建一个UICollectionView，然后再把UICollectionView的DataSource和Delegate方法再实现一遍，把这些Cell再在这些方法里重新生成一遍，才能让列表展现出来。比方说我们首页列表底部有猜你喜欢的cell，个人中心页面底部也有猜你喜欢的cell，这两个页面，都需要在自己拥有的UICollectionView中注册这个猜你喜欢的cell，返回这个猜你喜欢cell的高度，设置这个cell的model并刷新数据，如果有Header或者Footer的话，还得重新设置这些Header跟Footer。所以新写一个列表页面，对iOS开发者来说，还是很麻烦。

使用Weex或者RN开发原生列表页

使用Weex开发列表页的时候，我们组内的小伙伴都觉得很爽，很高效，基本上几行代码就能绘制出一个列表页，举个RN和weex的例子

// React
render() {
    const cells = this.state.items.map((item, index) => {
        if (item.cellType === 'largeCell') {
            return <LargeCell cellData={item.entity}></LargeCell>
        } else if (item.cellType === 'mediumCell') {
            return <MediumCell cellData={item.entity}></MediumCell>
        } else if (item.cellType === 'smallCell') {
            return <SmallCell cellData={item.entity}></SmallCell>
        }
    });

    return(
        <Waterfall>
            { cells }
        </Waterfall>
    );
}

// Vue
<template>
    <waterfall>
        <cell v-for="(item, index) in itemsArray" :key="index">
            <div class="cell" v-if="item.cellType === 'largeCell'">
                <LargeCell :cellData="item.entity"></LargeCell>
            </div>
            <div class="cell" v-if="item.cellType === 'mediumCell'">
                <MediumCell :cellData="item.entity"></MediumCell>
            </div>
            <div class="cell" v-if="item.cellType === 'smallCell'">
                <SmallCell :cellData="item.entity"></SmallCell>
            </div>
        </cell>
    </waterfall>
</template>

const

waterfall对应的就是iOS中的UICollectionView，waterfall这个组件中有cell的子组件，这些cell的子组件可以是我们自己定义的不同类型样式的cell组件。LargeCell，MediumCell，SmallCell对应的就是原生中的我们自定义的UICollectionViewCell。这些Cell子组在任何waterfall组件下面都可以使用，在一个waterfall组件下面，我们只需要把我们把在这个列表中需要展示的cell放进来，通过props把数据传到cell组件中即可。这种方式对iOS开发者来说，真的是太舒服了。在觉得开发很爽的同时，我也在思考，既然这种Component的方式用起来很爽，那么能不能也运用到原生开发中呢？毕竟我们大部分的业务需求还是基于原生来开发的。

React的核心思想

1、先来解释下React中的React Element和React Component
1.1、React Elements

const element = <div id='login-button>Login</div>

这段JSX表达式返回的就是一个React Element，React element描述了用户将在屏幕上看到的那个UI，跟DOM elements不一样的是，React elements是一个单纯的对象，仅仅是对将要呈现到屏幕上的UI的一个描述，并不是真正渲染好的UI，创建一个React element开销是极其小的，渲染的事情是由背后的React DOM来处理的。上面的那段代码相当于：

const element = React.createElement(
  'div',
  {id: 'login-button'},
  'Login'
)

返回的React element对象相当于 =>

{
  type: 'div',
  props: {
      children: 'Login',
      id: 'login-button'
  }
}

1.2 React Components

React中最核心的一个思想就是Component了，官方的解释是Component允许我们将UI拆分为独立可复用的代码片段，组件中可以包含多个其他组件，这样将组件一个个单独抽离出来，并最终再组合到一起，大大提高了代码的可读性（Readability）、可维护性（Maintainability）、可复用性（Reusability）和可测试性（Testability）。这也是 React 里用 Component 抽象所有 UI 的意义所在。

class Button extends React.Component {
  render() {
    const element = <div id='login-button>{ this.props.title }</div>
    return (
      <div>
        { element }
      </div>
    )
}

这段代码中Button就是一个React Component，这个component接受一个叫props的参数，返回描述UI的React element。

2、可以看出React Component接受props是一个对象，也就是所谓的一种数据结构，返回React Element也是一种对象，所谓的另外一种数据结构，所以我认为的React Component其实就是一个function，这个function的主要功能就是将一种数据结构（描述原始数据）转换成另外一种数据结构（描述UI）。React element仅仅是一个描述UI的对象，可以认为是一个中间状态，我们可以用最小的开销来创建或者销毁element对象。

3、React的核心思想总结下来就是这样的一个流程
1、原始数据到UI数据的转化 props -> React Component -> React Element
2、React Element的作用是将Component的创建跟描述状态分离，Component内部主要负责这个Component的构建，React Element主要用来做描述这个Component的状态
3、多个Component返回的多个Elements，这个流程是进行UI组合
4、React Element并不是一个渲染结果，React DOM的作用是将UI的状态（即Element）和UI的渲染分离，React DOM负责element的渲染
5、最后一个流程就是UI渲染了
上述这几个流程基本上代表了React的核心概念

怎么在iOS中运用React Component概念

说了这么多，其实iOS中缺少的就是这个Component概念，iOS原生的流程是原始数据到UI布局，再到UI绘制。复用的只是UI绘制结果的那个view（e.g. UICollectionViewCell）

在使用UICollectionView的时候，我们的数据都是通过DataSource方法返回给UICollectionView，UICollectionView拿到这些数据之后，就直接去绘制UICollectionViewCell了。所以每个列表页都得重新建一个UICollectionView，再引入自定义的UICollectionViewCell来绘制列表，所有的DataSource跟Delegate方法都得走一遍。所以我在想，我们可以按照React的那种方式来绘制列表么？将一个个UI控件抽象成一个个组件，再将这些组件组合到一起，绘制出最后的页面，React或者Weex的绘制列表其实就是waterfall这个列表component里面按照列表顺序插入自定义的cell component（组合）。那么我们其实可以在iOS中也可以有这个waterfall的component，这个component支持一个insertChildComponent:的方法，这个方法里就是插入自定义的CellComponent到waterfall这个组件中，并通过传入props来创建这个component。所以我就先定义了一个组件的基类BaseComponent

@protocol ComponentProtocol <NSObject>

/**
 *  绘制组件
 *
 *  @param view 展示该组件的view
 */
- (void)drawComponentInView:(UIView *)view withProps:(id)props;

/**
 *  组件的尺寸
 *
 *  @param props 该component的数据model
 *  @return 该组件的size
 */
+ (CGSize)componentSize:(id)props;

@end

@interface BaseComponent : NSObject <ComponentProtocol>

- (instancetype)initWithProps:(id)props;

@property (nonatomic, strong, readonly) id props;

所有的Component的创建都是通过传入props参数，来返回一个组件实例，每个Component还遵守一个ComponentProtocol的协议，协议里两个方法：

1、- (void)drawComponentInView:(UIView *)view withProps:(id)props; 每个component通过这个方法来进行native控件的绘制，参数中view是将会展示该组件的view，比方说WaterfallComponent中的该方法view为UIViewController的view，因为UIViewController的view会用来展示WaterfallComponent这个组件，'props'是该组件创建时传入的参数，这个参数用来告诉组件应该怎样绘制UI
2、+ (CGSize)componentSize:(id)props; 来描述组件的尺寸。

有了这个Component概念之后，我们原生的绘制流程就变成

1、创建Component，传入参数props
2、Component内部执行创建代码，保存props
3、当页面需要绘制的时候（React中的render命令），component内部会执行- (void)drawComponentInView:(UIView *)view withProps:(id)props;方法来描述并绘制UI

原生代码中想实现React element，其实不是一件简单的事情，因为原生没有类似JSX这种语言来生成一套只用来描述UI，并不绘制UI的中间状态的对象（可以做，比方说自己定义一套语法来描述UI），所以目前我的做法是在component内部，等到绘制命令来了之后，通过在- (void)drawComponentInView:(UIView *)view withProps:(id)props方法中，调用原生自定义的UIKit控件，通过props来绘制该UIKit

所以将通过封装component的方式，我们之前UIKit代表的UI组件转换成组件，把这些组件一个个单独抽离出来，再通过搭积木的方式，将各种组件一个个组合到一起，怎么绘制交给component内部去描述，而不是交给每个页面对应的UIViewController

Demo

Demo中，我会创建一个WaterfallComponent组件，还有多个CellComponent来绘制列表页，每个不一样列表页面(UIViewController)都可以创建一个WaterfallComponent组件，然后将不一样的CellComponent按照顺序插入到WaterfallComponent组件中，即可完成绘制列表，不需要每个页面再去处理UICollectionView的DataSource，Delegate方法。

WaterfallComponent内部会有一个UICollectionView，WaterfallComponent的insertChildComponent方法中，会创建一个dataController来管理数据源，并用来跟UICollectionView的DataSource方法进行交互从而绘制出列表页，最终UIViewController中绘制列表的方法如下：

self.waterfallComponent = [[WaterfallComponent alloc] initWithProps:nil];
    
for (NSDictionary *props in datas) {
    if ([props[@"type"] isEqualToString:@"1"]) {
        FirstCellComponent *cellComponent = [[FirstCellComponent alloc] initWithProps:props];
        [self.waterfallComponent insertChildComponent:cellComponent];
    } else if ([props[@"type"] isEqualToString:@"2"]) {
        SecondCellComponent *cellComponent = [[SecondCellComponent alloc] initWithProps:props];
        [self.waterfallComponent insertChildComponent:cellComponent];
    }
}
[self.waterfallComponent drawComponentInView:self.view withProps:nil];

这样，每个我们自定义的Cell就可以以CellComponent的形式，被按照随意顺序插入到WaterfallComponent，从而做到了真正意义上的复用，Demo已上传到GitHub上，有兴趣的可以看

总结

React的核心思想是将组件一个个单独抽离出来，并最终再组合到一起，大大提高了代码的可读性、可维护性、可复用性和可测试性。这也是 React 里用 Component 抽象所有 UI 的意义所在。
原生开发中，使用Component的概念，用Component去抽象UIKit控件，也能达到同样的效果，这样也能统一每个开发使用UICollectionView时候的规范，也能统一对所有列表页的数据源做一些统一处理，比方说根据一个逻辑，统一在所有列表页，插入一个广告cell，这个逻辑完全可以在WaterfallComponent里统一处理。

思考

目前我们只用到了Component这个概念，其实React中，React Element的概念也是非常核心的，React Element隔离了UI描述跟UI绘制的逻辑，通过JSX来描述UI，并不去生成，绘制UI，这样我们能够以最小的代价来生成或者销毁React Elements，然后在交付给系统绘制elements里描述的UI，那么如果原生里也有这一套模板语言，那么我们就能真正做到在Component里，传入props，返回一个element描述UI，然后再交给系统去绘制，这样还能省去cell的创建，只创建CellComponent即可。其实我们可以通过定义一套语义去描述UI布局，然后通过解析这套语义，通过Core Text去做绘制，这一套还是值得我再去思考的。

链接：https://www.jianshu.com/p/bc4b13a0d312

HackingSwift: What’s new in Swift 5.0
Result<T> 还是 Result<T, E: Error>

背景

在异步获取数据的场景中，常见的回调的数据结构是这样的：表示获取成功的数据，表示获取失败的 error。因为数据可能获取成功，也可能失败。因此回调中的数据和错误都是 optional 类型。
比如 CloudKit 中保存数据的一个函数就是这样：

func save(_ record: CKRecord, completionHandler: @escaping (CKRecord?, Error?) -> Void)

这种形式的缺点是没有体现出两种结果的互斥关系：如果数据成功获取到了，那么 error 一定为空。如果 error 有值，数据一定是获取失败了。

Swift 中枚举的能力相比 OC 有着很大的进步，每个枚举值除了可以是常规的基础类型，还可以是一个关联的类型。有了这样的特性后用枚举来优化返回结果的数据结构显得水到渠成：

enum Result<Success, Failure> where Failure : Error {

    /// A success, storing a `Success` value.
    case success(Success)

    /// A failure, storing a `Failure` value.
    case failure(Failure)
}

基本用法

定义异步返回结果是 Int 类型的函数：

func fetchData(_ completionHandler: @escaping (Result<Int, Error>) -> Void) {
    DispatchQueue.global().async {
        let isSuccess = true
        if isSuccess {
            let resultValue = 6
            return completionHandler(.success(resultValue))
        } else {
            let error = NSError(domain: "custom error", code: -1, userInfo: nil)
            return completionHandler(.failure(error))
        }
    }
}

返回值的类型通过泛型进行约束，Result 第一个泛型类型表示返回值的类型，第二个类型表示错误的类型。对 Result 赋值和常规的枚举一样：

let valueResult: Result<Int, CustomError> = Result.success(4)

// 因为 swift 中会进行类型推断，编译器在确认返回的是 `Result` 类型后，可以省略枚举类型的声明
let errorResult = .failure(CustomError.inputNotValid)

取出 Result 值和获取普通的关联类型枚举是一样的：

fetchData { (result) in
    switch result {
    case .success(let value):
        print(value)
    case .failure(let error)
        print(error.localizedDescription)
    }
}

如果你只想要获取其中一项的值，也可以直接用 if case 拆包：

fetchDate { (result) in
    if case .success(let value) = result {
        print(value)
    }
}

可以判等

Enum 是一个值类型，是一个值就应该可以判断是否相等。如果 Result 的成功和失败的类型都是 Equatable，那么 Result就可以判等，源码如下：

extension Result : Equatable where Success : Equatable, Failure : Equatable { }

类似的，如果是成功和失败的类型都是 Hashable，那么 Result 也是 Hashable：

extension Result : Hashable where Success : Hashable, Failure : Hashable { }

如果实现了 Hashable ，可以用来当做字典的 key。

辅助的 API

map、mapError
与 Dictionary 类似，Swift 为 Result 提供了几个 map value 和 error 的方法。

let intResult: Result<Int, Error> = Result.success(4)
let stringResult = x.map { (value) -> Result<String, Error> in
    return  .success("map")
}

let originError = NSError(domain: "origin error", code: -1, userInfo: nil)
let errorResult: Result<Int, Error> = .failure(originError)
let newErrorResult = errorResult.mapError { (error) -> Error in
    let newError = NSError(domain: "new error", code: -2, userInfo: nil)
    return newError
}

flatMap、flatMapError
map 返回的是具体的结果和错误， flatMap 闭包中返回的是 Result 类型。如果 Result 中包含的是数据，效果和 map 一致，替换数据；如果 Result 中包含的是错误，那么不替换结果。

let intResult: Result<Int, Error> = Result.success(4)

// 替换成功
let flatMapResult = intResult.flatMap { (value) -> Result<String, Error> in
    return  .success("flatMap")
}

// 没有执行替换操作，flatMapIntResult 值还是 intResult
let flatMapIntResult = intResult.flatMap { (value) -> Result<String, Error> in
    return  .failure(NSError(domain: "origin error", code: -1, userInfo: nil))
}

get
很多时候只关心 Result 的值，Swift 提供了 get() 函数来便捷的直接获取值，需要注意的是这个函数被标记为 throws，使用时语句前需要加上 try：

let intResult: Result<Int, Error> = Result.success(4)

let value = try? intResult.get()

可抛出异常的闭包初始化器

很多时候获取返回值的闭包中可能会发生异常代表获取失败的错误，基于这个场景 Swift 提供了一个可抛出异常的闭包初始化器：

enum CustomError: Error, Equatable {
    case inputNotValid
}

let fetchInt = { () -> Int in
    if true {
        return 4
    } else {
        throw CustomError.inputNotValid
    }
}

let result: Result<Int, Error> = Result { try fetchInt() }

需要提醒是通过这种方式声明的 Result 的 error 类型只能是 Error，不能指定特定的 Error。

转自：https://www.jianshu.com/p/a3712edc9367

1.方法调用的几种Hook机制

iOS系统中一共有：C函数、Block、OC类方法三种形式的方法调用。Hook一个方法调用的目的一般是为了监控拦截或者统计一些系统的行为。Hook的机制有很多种，通常良好的Hook方法都是以AOP的形式来实现的。

当我们想Hook一个OC类的某些具体的方法时可以通过Method Swizzling技术来实现、当我们想Hook动态库中导出的某个C函数时可以通过修改导入函数地址表中的信息来实现(可以使用开源库fishhook来完成)、当我们想Hook所有OC类的方法时则可以通过替换objc_msgSend系列函数来实现。。。

那么对于Block方法呢而言呢？

2.Block的内部实现原理和实现机制简介

这里假定你对Block内部实现原理和运行机制有所了解，如果不了解则请参考文章《深入解构iOS的block闭包实现原理》或者自行通过搜索引擎搜索。

源程序中定义的每个Block在编译时都会转化为一个和OC类对象布局相似的对象，每个Block也存在着isa这个数据成员，根据isa指向的不同，Block分为__NSStackBlock、__NSMallocBlock、__NSGlobalBlock 三种类型。也就是说从某种程度上Block对象也是一种OC对象。下面的类图描述了Block类的层次结构。

Block类以及其派生类在CoreFoundation.framework中被定义和实现，并且没有对外公开。

每个Block对象在内存中的布局，也就是Block对象的存储结构被定义如下(代码出自苹果开源出来的库实现libclosure中的文件Block_private.h)：

//需要注意的是下面两个只是模板，具体的每个Block定义时总是按这个模板来定义的。

//Block描述，每个Block一个描述并定义在全局数据段
struct Block_descriptor_1 {
    uintptr_t reserved;   //记住这个变量和结构体，它很重要！！
    uintptr_t size;
};

//Block对象的内存布局
struct Block_layout {
    void *isa;
    volatile int32_t flags; // contains ref count
    int32_t reserved;
    uintptr_t invoke;   //Block对象的实现函数
    struct Block_descriptor_1 *descriptor;
    // imported variables，这里是每个block对象的特定数据成员区域
};

这里要关注一下struct Block_descriptor_1中的reserved这个数据成员，虽然系统没有用到它，但是下面就会用到它而且很重要！

在了解了Block对象的类型以及Block对象的内存布局后，再来考察一下一个Block从定义到调用是如何实现的。就以下面的源代码为例：

int main(int argc, char *argv[])
{
   //定义
    int a = 10;
    void (^testblock)(void) = ^(){
        NSLog(@"Hello world!%d", a);
    };
    
    //执行
    testblock();

    return 0;
}

在将OC代码翻译为C语言代码后每个Block的定义和调用将变成如下的伪代码：

//testblock的描述信息
struct Block_descriptor_1_fortestblock {
    uintptr_t reserved; 
    uintptr_t size;
};

//testblock的布局存储结构体
struct Block_layout_fortestblock {
    void *isa;
    volatile int32_t flags; // contains ref count
    int32_t reserved;
    uintptr_t invoke;   //Block对象的实现函数
    struct Block_descriptor_1_fortestblock *descriptor;
    int m_a;  //外部的传递进来的数据。
};

//testblock函数的实现。
void main_invoke_fortestblock(struct Block_layout_fortestblock *cself)
{
      NSLog(@"Hello world!%d", cself->m_a);
}

//testblock对象描述的实例，存储在全局内存区
struct Block_descriptor_1_fortestblock  _testblockdesc = {0, sizeof(struct Block_layout_fortestblock)};

int main(int argc, char *argv[])
{
   //定义部分
    int a = 10;
    struct Block_layout_fortestblock testblock = {
            .isa = __NSConcreteStackBlock,
            .flags =0,
            .reserved = 0,
            .invoke = main_invoke_fortestblock,
            .descriptor = & _testblockdesc,
            .m_a = a
    };

   //调用部分
   testblock.invoke();
   
    return 0;
}

可以看出Block对象的生成和调用都是在编译期间就已经固定在代码中了，它不像其他OC对象调用方法时需要通过runtime来执行间接调用。并且线上程序中所有关于Block的符号信息都会被strip掉。所以上述的所介绍的几种Hook方法都无法Hook住一个Block对象的函数调用。

如果想要Hook住系统的所有Block调用，需要解决如下几个问题：
a. 如何在运行时将所有的Block的invoke函数替换为一个统一的Hook函数。
b. 这个统一的Hook函数如何调用原始Block的invoke函数。
c. 如何构建这个统一的Hook函数。

3.实现Block对象Hook的方法和原理

一个OC类对象的实例通过引用计数来管理对象的生命周期。在MRC时代当对象进行赋值和拷贝时需要通过调用retain方法来实现引用计数的增加，而在ARC时代对象进行赋值和拷贝时就不再需要显示调用retain方法了，而是系统内部在编译时会自动插入相应的代码来实现引用计数的添加和减少。不管如何只要是对OC对象执行赋值拷贝操作，最终内部都会调用retain方法。

Block对象也是一种OC对象！！

每当一个Block对象在需要进行赋值或者拷贝操作时，也会激发对retain方法的调用。因为Block对象赋值操作一般是发生在Block方法执行之前，因此我们可以通过Method Swizzling的机制来Hook 类的retain方法，然后在重写的retain方法内部将Block对象的invoke数据成员替换为一个统一的Hook函数！

通过考察__NSStackBlock、__NSMallocBlock、__NSGlobalBlock 三个类的实现发现这三个类都重载了NSObject的retain方法，这样在执行Method Swizzling时就不需要对NSObject的retain方法执行替换，而只要对上述三个类的retain执行替换即可。

你可以说出为什么这三个派生类都会对retain方法进行重载吗？答案可以从这三种Block的类型定义以及所表示的意义中去寻找。

Block技术不仅可以用在OC语言中，LLVM对C语言进行的扩展也能使用Block，比如gcd库中大量的使用了Block。在C语言中如果对一个Block进行赋值或者拷贝系统需要通过C库函数：

//函数声明在Block.h头文件汇总
// Create a heap based copy of a Block or simply add a reference to an existing one.
// This must be paired with Block_release to recover memory, even when running
// under Objective-C Garbage Collection.
BLOCK_EXPORT void *_Block_copy(const void *aBlock)
    __OSX_AVAILABLE_STARTING(__MAC_10_6, __IPHONE_3_2);

来实现，这个函数定义在libsystem_blocks.dylib库中，并且库实现已经开源：libclosure。因此可以借助fishhook库来对__Block_copy这个函数进行替换处理，然后在替换的函数函数中将一个Block的原始的invoke函数替换为统一的Hook函数。

另外一个C语言函数objc_retainBlock，也是实现了对Block进行赋值时的引用计数增加，这个函数内部就是简单的调用__Block_copy方法。因此我们也可以添加对objc_retainBlock的替换处理。

解决了第一个问题后，接下来再解决第二个问题。还记得上面提到过的struct Block_descriptor_1中的reserved这个数据成员吗? 当我们通过上述的方法对所有Block对象的invoke成员替换为一个统一的Hook函数前，可以将Block对象的原始invoke函数保存到这个保留字段中去。然后就可以在统一的Hook函数内部读取这个保留字段中的保存的原始invoke函数来执行真实的方法调用了。

因为一个Block对象函数的第一个参数其实是一个隐藏的参数，这个隐藏的参数就是Block对象本身，因此很容易就可以从隐藏的参数中来获取到对应的保留字段。

下面的代码将展示通过方法交换来实现Hook处理的伪代码

struct Block_descriptor {
    void *reserved;
    uintptr_t size;
};

struct Block_layout {
    void *isa;
    int32_t flags; // contains ref count
    int32_t reserved;
    void  *invoke;
    struct Block_descriptor *descriptor;
};

//统一的Hook函数,这里以伪代码的形式提供
void blockhook(void *obj, ...)
{
   struct Block_layout *layout = (struct Block_layout*) obj;
   //调用原始的invoke函数
   layout->descriptor->reserved(...);
}
//模拟器下如果返回类型是结构体并且大于16字节那么第一个参数是返回值保存的内存地址，block对象变为第二个参数
void blockhook_stret(void *pret, void *obj, ...)
{
   struct Block_layout *layout = (struct Block_layout*) obj;
   //调用原始的invoke函数
   layout->descriptor->reserved(...);
}

//执行Block对象的方法替换处理
void replaceBlockInvokeFunction(const void *blockObj)
{
   struct Block_layout *layout = (struct Block_layout*)blockObj;
   if (layout != NULL && layout->descriptor != NULL){
         int32_t BLOCK_USE_STRET = (1 << 29);  //如果模拟器下返回的类型是一个大于16字节的结构体，那么block的第一个参数为返回的指针，而不是block对象。
         void *hookfunc = ((layout->flags & BLOCK_USE_STRET) == BLOCK_USE_STRET) ? blockhook_stret : blockhook;
         if (layout->invoke != hookfunc){
                layout->descriptor->reserved = layout->invoke;
                layout->invoke = hookfunc;
            }
    }
}

void *(*__NSStackBlock_retain_old)(void *obj, SEL cmd) = NULL;
void *__NSStackBlock_retain_new(void *obj, SEL cmd)
{
    replaceBlockInvokeFunction(obj);
    return __NSStackBlock_retain_old(obj, cmd);
}

void *(*__NSMallocBlock_retain_old)(void *obj, SEL cmd) = NULL;
void *__NSMallocBlock_retain_new(void *obj, SEL cmd)
{
    replaceBlockInvokeFunction(obj);
    return __NSMallocBlock_retain_old(obj, cmd);
}

void *(*__NSGlobalBlock_retain_old)(void *obj, SEL cmd) = NULL;
void *__NSGlobalBlock_retain_new(void *obj, SEL cmd)
{
    replaceBlockInvokeFunction(obj);
    return __NSGlobalBlock_retain_old(obj, cmd);
}

int main(int argc, char *argv[])
{
      //因为类名和方法名都不能直接使用，所以这里都以字符串的形式来转换获取。
    __NSStackBlock_retain_old = (void *(*)(void*,SEL))class_replaceMethod(NSClassFromString(@"__NSStackBlock"), sel_registerName("retain"), (IMP)__NSStackBlock_retain_new, nil);
    __NSMallocBlock_retain_old = (void *(*)(void*,SEL))class_replaceMethod(NSClassFromString(@"__NSMallocBlock"), sel_registerName("retain"), (IMP)__NSMallocBlock_retain_new, nil);
    __NSGlobalBlock_retain_old = (void *(*)(void*,SEL))class_replaceMethod(NSClassFromString(@"__NSGlobalBlock"), sel_registerName("retain"), (IMP)__NSGlobalBlock_retain_new, nil);

    return 0;
 }

解决了第二个问题后，就需要解决第三个问题。上面的统一Hook函数blockhook和block_stret只是伪代码实现，因为任何一个Block中的函数的参数类型和个数是不一样的，而且统一Hook函数也需要在适当的时候调用原始的默认Block函数实现，并且不能破坏参数信息。为了解决这些问题就使得这个统一的Hook函数不能用高级语言来实现，而只能用汇编语言来实现。下面就是在arm64位体系下的实现代码：

.text
.align 5
.private_extern _blockhook   
_blockhook:
   //为了不破坏原有参数，这里将所有参数压入栈中
  stp q6, q7, [sp, #-0x20]!
  stp q4, q5, [sp, #-0x20]!
  stp q2, q3, [sp, #-0x20]!
  stp q0, q1, [sp, #-0x20]!
  stp x6, x7, [sp, #-0x10]!
  stp x4, x5, [sp, #-0x10]!
  stp x2, x3, [sp, #-0x10]!
  stp x0, x1, [sp, #-0x10]!
  stp x8, x30, [sp, #-0x10]!
  
  //这里可以添加任意逻辑来进行hook处理。

  //这里将所有参数还原
  ldp x8, x30, [sp], #0x10
  ldp x0, x1, [sp], #0x10
  ldp x2, x3, [sp], #0x10
  ldp x4, x5, [sp], #0x10
  ldp x6, x7, [sp], #0x10
  ldp q0, q1, [sp], #0x20
  ldp q2, q3, [sp], #0x20
  ldp q4, q5, [sp], #0x20
  ldp q6, q7, [sp], #0x20

  ldr x16, [x0, #0x18]   //将block对象的descriptor数据成员取出
  ldr x16, [x16]         //获取descriptor中的reserved成员
  br x16                 //执行reserved中保存的原始函数指针。
LExit_blockhook:

对于x86_64/arm32位系统来说，如果block函数的返回是一个结构体并且长度超过16字节(arm32是8字节)。那么block对象里面的flags属性就会设置为BLOCK_USE_STRET。而x86_64/arm32位系统对于这种返回类型的函数就会将返回值存放到第一个参数所指向的内存中，同时会把原本的block对象变化为第二个参数，因此需要对这种情况进行特殊处理。

关于在运行时Hook所有Block方法调用的技术实现原理就介绍到这里了。当然一个完整的系统可能需要其他一些能力：

1、如果你只想Hook可执行程序中定义的Block，那么请参考我的文章：深入iOS系统底层之映像操作API介绍 中的内容来实现Hook函数的过滤处理。
2、如果你不想借助Block_descriptor中的reserved来保存原始的invoke函数，那么可以参考我的文章：Thunk程序的实现原理以及在iOS中的应用(二)中介绍的技术来实现统一Hook函数以及完成对原始invoke函数的调用技术。

具体完整的代码可以访问我的github中的项目:YSBlockHook。这个项目以AOP的形式实现了真机arm64位模式下对可执行程序中所有定义的Block进行Hook的方法，Hook所做的事情就是在所有Block调用前，打印出这个Block的符号信息。

链接：https://www.jianshu.com/p/0a3d00485c7f

AsyncDisplayKit 已移动并重命名：Texture

性能提升

AsyncDisplayKit 的基本单位是node. ASDisplayNode 是对 的抽象UIView，而后者又是对 的抽象CALayer。与只能在主线程上使用的视图不同，节点是线程安全的：您可以在后台线程上并行实例化和配置它们的整个层次结构。

为了保持其用户界面流畅和响应迅速，您的应用程序应以每秒 60 帧的速度呈现——这是 iOS 的黄金标准。这意味着主线程有六十分之一秒来推动每一帧。执行所有布局和绘图代码需要 16 毫秒！并且由于系统开销，您的代码在导致丢帧之前的运行时间通常不到 10 毫秒。

AsyncDisplayKit 允许您将图像解码、文本大小调整和渲染、布局和其他昂贵的 UI 操作移出主线程，以保持主线程可用于响应用户交互。

随着框架的发展，添加了许多功能，通过消除现代 iOS 应用程序中常见的样板样式结构，可以为开发人员节省大量时间。如果您曾经处理过单元格重用错误，尝试为页面或滚动样式界面高效地预加载数据，或者甚至只是试图防止您的应用丢失太多帧，您都可以从集成 ASDK 中受益。

详细的api介绍:

https://texturegroup.org/appledocs.html

常见问题及demo下载:

https://github.com/facebookarchive/AsyncDisplayKit

源码下载:

前言

在面向对象程序设计过程中，有时会面临要创建大量相同或相似对象实例的问题。创建那么多的对象将会耗费很多的系统资源，它是系统性能提高的一个瓶颈。

例如，围棋和五子棋中的黑白棋子，图像中的坐标点或颜色，局域网中的路由器、交换机和集线器，教室里的桌子和凳子等。这些对象有很多相似的地方，如果能把它们相同的部分提取出来共享，则能节省大量的系统资源，这就是享元模式的产生背景。

定义

运用共享技术来有效地支持大量细粒度对象的复用。它通过共享已经存在的对象来大幅度减少需要创建的对象数量、避免大量相似类的开销，从而提高系统资源的利用率。

优点

相同对象只要保存一份，这降低了系统中对象的数量，从而降低了系统中细粒度对象给内存带来的压力。

缺点

为了使对象可以共享，需要将一些不能共享的状态外部化，这将增加程序的复杂性。
读取享元模式的外部状态会使得运行时间稍微变长。

享元模式的结构与实现

享元模式的定义提出了两个要求，细粒度和共享对象。因为要求细粒度，所以不可避免地会使对象数量多且性质相近，此时我们就将这些对象的信息分为两个部分：内部状态和外部状态。
内部状态指对象共享出来的信息，存储在享元信息内部，并且不回随环境的改变而改变；
外部状态指对象得以依赖的一个标记，随环境的改变而改变，不可共享。

比如，连接池中的连接对象，保存在连接对象中的用户名、密码、连接URL等信息，在创建对象的时候就设置好了，不会随环境的改变而改变，这些为内部状态。而当每个连接要被回收利用时，我们需要将它标记为可用状态，这些为外部状态。

享元模式的本质是缓存共享对象，降低内存消耗。

结构

抽象享元角色（Flyweight）：是所有的具体享元类的基类，为具体享元规范需要实现的公共接口，非享元的外部状态以参数的形式通过方法传入。
具体享元（Concrete Flyweight）角色：实现抽象享元角色中所规定的接口。
非享元（Unsharable Flyweight)角色：是不可以共享的外部状态，它以参数的形式注入具体享元的相关方法中。
享元工厂（Flyweight Factory）角色：负责创建和管理享元角色。当客户对象请求一个享元对象时，享元工厂检査系统中是否存在符合要求的享元对象，如果存在则提供给客户；如果不存在的话，则创建一个新的享元对象。

享元模式的实现

应用实例的话，其实上面的模板就已经是一个很好的例子了，类似于String常量池，没有的对象创建后存在池中，若池中存在该对象则直接从池中取出。

　　为了更好的理解享元模式，这里再举一个实例，比如接了我一个小型的外包项目，是做一个产品展示网站，后来他的朋友们也希望做这样的网站，但要求都有些不同，我们当然不能直接复制粘贴再来一份，有任希望是新闻发布形式的，有人希望是博客形式的等等，而且因为经费原因不能每个网站租用一个空间。

　　其实这里他们需要的网站结构相似度很高，而且都不是高访问量网站，如果分成多个虚拟空间来处理，相当于一个相同网站的实例对象很多，这是造成服务器的大量资源浪费。如果整合到一个网站中，共享其相关的代码和数据，那么对于硬盘、内存、CPU、数据库空间等服务器资源都可以达成共享，减少服务器资源；而对于代码，由于是一份实例，维护和扩展都更加容易。

　　那么此时就可以用到享元模式了。UML图如下：
　　
网站抽象类
　

 public abstract class WebSite {



     public abstract void use();



 }

具体网站类

public class ConcreteWebSite extends WebSite {



    private String name = "";



    public ConcreteWebSite(String name) {

        this.name = name;

    }



    @Override

    public void use() {

        System.out.println("网站分类：" + name);

    }



}

网络工厂类
　　这里使用HashMap来作为池，通过put和get方法实现加入池与从池中取的操作。

public class WebSiteFactory {



    private HashMap<String, ConcreteWebSite> pool = new HashMap<>();



    //获得网站分类

    public WebSite getWebSiteCategory(String key) {

        if(!pool.containsKey(key)) {

            pool.put(key, new ConcreteWebSite(key));

        }



        return (WebSite)pool.get(key);

    }



    //获得网站分类总数

    public int getWebSiteCount() {

        return pool.size();

    }



}

Client客户端
　　这里测试用例给了两种网站，原先我们需要做三个产品展示和三个博客的网站，也即需要六个网站类的实例，但其实它们本质上都是一样的代码，可以利用用户ID号的不同，来区分不同的用户，具体数据和模板可以不同，但代码核心和数据库却是共享的。

public class Client {



    public static void main(String[] args) {

        WebSiteFactory factory = new WebSiteFactory();



        WebSite fx = factory.getWebSiteCategory("产品展示");

        fx.use();



        WebSite fy = factory.getWebSiteCategory("产品展示");

        fy.use();



        WebSite fz = factory.getWebSiteCategory("产品展示");

        fz.use();



        WebSite fa = factory.getWebSiteCategory("博客");

        fa.use();



        WebSite fb = factory.getWebSiteCategory("博客");

        fb.use();



        WebSite fc = factory.getWebSiteCategory("博客");

        fc.use();



        System.out.println("网站分类总数为：" + factory.getWebSiteCount());

    }



}

源码中的享元模式

享元模式很重要，因为它能帮你在一个复杂的系统中大量的节省内存空间。在JAVA语言中，String类型就是使用了享元模式。String对象是final类型，对象一旦创建就不可改变。在JAVA中字符串常量都是存在常量池中的，JAVA会确保一个字符串常量在常量池中只有一个拷贝。String a=”abc”，其中”abc”就是一个字符串常量。

熟悉java的应该知道下面这个例子：

Stringa="hello";

Stringb="hello";

if(a==b)

　System.out.println("OK");

else

　System.out.println("Error");

输出结果是：OK。可以看出if条件比较的是两a和b的地址，也可以说是内存空间 核心总结，可以共享的对象，也就是说返回的同一类型的对象其实是同一实例，当客户端要求生成一个对象时，工厂会检测是否存在此对象的实例，如果存在那么直接返回此对象实例，如果不存在就创建一个并保存起来，这点有些单例模式的意思。通常工厂类会有一个集合类型的成员变量来用以保存对象，如hashtable,vector等。在java中，数据库连接池，线程池等即是用享元模式的应用。

首先String不属于8种基本数据类型，String是一个对象。
因为对象的默认值是null，所以String的默认值也是null；但它又是一种特殊的对象，有其它对象没有的一些特性。
new String()和new String(“”)都是申明一个新的空字符串，是空串不是null；
String str=”kvill”；
String str=new String (“kvill”);的区别：
在这里，我们不谈堆，也不谈栈，只先简单引入常量池这个简单的概念。
常量池(constant pool)指的是在编译期被确定，并被保存在已编译的.class文件中的一些数据。它包括了关于类、方法、接口等中的常量，也包括字符串常量。
看例1：

String s0=”kvill”; 



String s1=”kvill”; 



String s2=”kv” + “ill”; 



System.out.println( s0==s1 ); 



System.out.println( s0==s2 );

结果为：

true 



true

首先，我们要知结果为道Java会确保一个字符串常量只有一个拷贝。
因为例子中的s0和s1中的”kvill”都是字符串常量，它们在编译期就被确定了，所以s0==s1为true；而”kv”和”ill”也都是字符串常量，当一个字符串由多个字符串常量连接而成时，它自己肯定也是字符串常量，所以s2也同样在编译期就被解析为一个字符串常量，所以s2也是常量池中”kvill”的一个引用。

所以我们得出s0==s1==s2;

用new String() 创建的字符串不是常量，不能在编译期就确定，所以new String() 创建的字符串不放入常量池中，它们有自己的地址空间。

看例2：

String s0=”kvill”; 



String s1=new String(”kvill”); 



String s2=”kv” + new String(“ill”); 



System.out.println( s0==s1 ); 



System.out.println( s0==s2 ); 



System.out.println( s1==s2 );

结果为：

false 



false 



false

例2中s0还是常量池中”kvill”的应用，s1因为无法在编译期确定，所以是运行时创建的新对象”kvill”的引用，s2因为有后半部分new String(“ill”)所以也无法在编译期确定，所以也是一个新创建对象”kvill”的应用;明白了这些也就知道为何得出此结果了。

String.intern()：

再补充介绍一点：存在于.class文件中的常量池，在运行期被JVM装载，并且可以扩充。String的intern()方法就是扩充常量池的一个方法；当一个String实例str调用intern()方法时，Java查找常量池中是否有相同Unicode的字符串常量，如果有，则返回其的引用，如果没有，则在常量池中增加一个Unicode等于str的字符串并返回它的引用；看例3就清楚了

例3：

String s0= “kvill”; 



String s1=new String(”kvill”); 



String s2=new String(“kvill”); 



System.out.println( s0==s1 ); 



System.out.println( “**********” ); 



s1.intern(); 



s2=s2.intern(); //把常量池中“kvill”的引用赋给s2 



System.out.println( s0==s1); 



System.out.println( s0==s1.intern() ); 



System.out.println( s0==s2 );

结果为：

false 



********** 



false //虽然执行了s1.intern(),但它的返回值没有赋给s1 



true //说明s1.intern()返回的是常量池中”kvill”的引用 



true

最后我再破除一个错误的理解：

有人说，“使用String.intern()方法则可以将一个String类的保存到一个全局String表中，如果具有相同值的Unicode字符串已经在这个表中，那么该方法返回表中已有字符串的地址，如果在表中没有相同值的字符串，则将自己的地址注册到表中“如果我把他说的这个全局的String表理解为常量池的话，他的最后一句话，“如果在表中没有相同值的字符串，则将自己的地址注册到表中”是错的：

看例4：

String s1=new String("kvill"); 



String s2=s1.intern(); 



System.out.println( s1==s1.intern() ); 



System.out.println( s1+" "+s2 ); 



System.out.println( s2==s1.intern() );

结果：

false 



kvill kvill 



true

在这个类中我们没有声名一个”kvill”常量，所以常量池中一开始是没有”kvill”的，当我们调用s1.intern()后就在常量池中新添加了一个”kvill”常量，原来的不在常量池中的”kvill”仍然存在，也就不是“将自己的地址注册到常量池中”了。

s1==s1.intern()为false说明原来的“kvill”仍然存在；

s2现在为常量池中“kvill”的地址，所以有s2==s1.intern()为true。

关于equals()和==:

这个对于String简单来说就是比较两字符串的Unicode序列是否相当，如果相等返回true;而==是比较两字符串的地址是否相同，也就是是否是同一个字符串的引用。

关于String是不可变的

这一说又要说很多，大家只要知道String的实例一旦生成就不会再改变了，比如说：String str=”kv”+”ill”+” “+”ans”;

就是有4个字符串常量，首先”kv”和”ill”生成了”kvill”存在内存中，然后”kvill”又和” “ 生成 ”kvill “存在内存中，最后又和生成了”kvill ans”;并把这个字符串的地址赋给了str,就是因为String的“不可变”产生了很多临时变量，这也就是为什么建议用StringBuffer的原因了，因为StringBuffer是可改变的。

okhttp3 kotlin ConnectionPool 源码分析

ConnectionPool的说明：
管理http和http/2的链接，以便减少网络请求延迟。同一个address将共享同一个connection。该类实现了复用连接的目标。

class RealConnectionPool(

  /** 每个address的最大空闲连接数 */

  private val maxIdleConnections: Int,

  keepAliveDuration: Long,

  timeUnit: TimeUnit

) {

    /**

     * Background threads are used to cleanup expired connections. There will be at most a single

     * thread running per connection pool. The thread pool executor permits the pool itself to be

     * garbage collected.

     */

     //这是一个用于清楚过期链接的线程池，每个线程池最多只能运行一个线程，并且这个线程池允许被垃圾回收

    private val executor = ThreadPoolExecutor(

        0, // corePoolSize.

        Int.MAX_VALUE, // maximumPoolSize.

        60L, TimeUnit.SECONDS, // keepAliveTime.

        SynchronousQueue(),

        threadFactory("OkHttp ConnectionPool", true)

    )

    //双向队列

  private val connections = ArrayDeque<RealConnection>()

  //路由的数据库

  val routeDatabase = RouteDatabase()

  //清理任务正在执行的标志

  var cleanupRunning: Boolean = false

1. 主要就是connections，可见ConnectionPool内部以队列方式存储连接；
2. routDatabase是一个黑名单，用来记录不可用的route，但是看代码貌似ConnectionPool并没有使用它。所以此处不做分析。
3. 剩下的就是和清理有关了，所以executor是清理任务的线程池，cleanupRunning是清理任务的标志，cleanupRunnable是清理任务。

class ConnectionPool(

  maxIdleConnections: Int,

  keepAliveDuration: Long,

  timeUnit: TimeUnit

) {

  //创建一个适用于单个应用程序的新连接池。

 //该连接池的参数将在未来的okhttp中发生改变

 //目前最多可容乃5个空闲的连接，存活期是5分钟

  constructor() : this(5, 5, TimeUnit.MINUTES)

}



init {

    //保持活着的时间，否则清理将旋转循环

    require(keepAliveDuration > 0L) { "keepAliveDuration <= 0: $keepAliveDuration" }

  }

通过这个构造器我们知道了这个连接池最多维持5个连接，且每个链接最多活5分钟。并且包含一个线程池包含一个清理任务。
所以maxIdleConnections和keepAliveDurationNs则是清理中淘汰连接的的指标，这里需要说明的是maxIdleConnections是值每个地址上最大的空闲连接数。所以OkHttp只是限制与同一个远程服务器的空闲连接数量，对整体的空闲连接并没有限制。

这时候说下ConnectionPool的实例化的过程，一个OkHttpClient只包含一个ConnectionPool，其实例化也是在OkHttpClient的过程。这里说一下ConnectionPool各个方法的调用并没有直接对外暴露，而是通过OkHttpClient的Internal接口统一对外暴露。

然后我们来看下他的transmitterAcquirePooledConnection(获取连接)和put方法

fun transmitterAcquirePooledConnection(

    address: Address,

    transmitter: Transmitter,

    routes: List<Route>?,

    requireMultiplexed: Boolean

  ): Boolean {

   //断言，判断线程是不是被自己锁住了

    assert(Thread.holdsLock(this))

 // 遍历已有连接集合

    for (connection in connections) {

      if (requireMultiplexed && !connection.isMultiplexed) continue

          //如果connection和需求中的"地址"和"路由"匹配

      if (!connection.isEligible(address, routes)) continue

      //复用这个连接

      transmitter.acquireConnectionNoEvents(connection)



      return true

    }

    return false

  }

put方法更为简单，就是异步触发清理任务，然后将连接添加到队列中

  fun put(connection: RealConnection) {

    assert(Thread.holdsLock(this))

    if (!cleanupRunning) {

      cleanupRunning = true

      executor.execute(cleanupRunnable)

    }

    connections.add(connection)

  }

private val cleanupRunnable = object : Runnable {

    override fun run() {

      while (true) {

        val waitNanos = cleanup(System.nanoTime())

        if (waitNanos == -1L) return

        try {

          this@RealConnectionPool.lockAndWaitNanos(waitNanos)

        } catch (ie: InterruptedException) {

          // Will cause the thread to exit unless other connections are created!

          evictAll()

        }

      }

    }

  }

这个逻辑也很简单，就是调用cleanup方法执行清理，并等待一段时间，持续清理，其中cleanup方法返回的值来来决定而等待的时间长度。那我们继续来看下cleanup函数：

fun cleanup(now: Long): Long {

    var inUseConnectionCount = 0

    var idleConnectionCount = 0

    var longestIdleConnection: RealConnection? = null

    var longestIdleDurationNs = Long.MIN_VALUE



    // Find either a connection to evict, or the time that the next eviction is due.

    synchronized(this) {

      for (connection in connections) {

        // If the connection is in use, keep searching.

        if (pruneAndGetAllocationCount(connection, now) > 0) {

          inUseConnectionCount++

          continue

        }

//统计空闲连接数量

        idleConnectionCount++



        // If the connection is ready to be evicted, we're done.

        val idleDurationNs = now - connection.idleAtNanos

        if (idleDurationNs > longestIdleDurationNs) {

        //找出空闲时间最长的连接以及对应的空闲时间

          longestIdleDurationNs = idleDurationNs

          longestIdleConnection = connection

        }

      }



      when {

        longestIdleDurationNs >= this.keepAliveDurationNs

            || idleConnectionCount > this.maxIdleConnections -> {

          // We've found a connection to evict. Remove it from the list, then close it below

          // (outside of the synchronized block).

          //在符合清理条件下，清理空闲时间最长的连接

          connections.remove(longestIdleConnection)

        }

        idleConnectionCount > 0 -> {

          // A connection will be ready to evict soon.

           //不符合清理条件，则返回下次需要执行清理的等待时间，也就是此连接即将到期的时间

          return keepAliveDurationNs - longestIdleDurationNs

        }

        inUseConnectionCount > 0 -> {

          // All connections are in use. It'll be at least the keep alive duration 'til we run

          // again.

          //没有空闲的连接，则隔keepAliveDuration(分钟)之后再次执行

          return keepAliveDurationNs

        }

        else -> {

          // No connections, idle or in use.

          cleanupRunning = false

          return -1

        }

      }

    }

//关闭socket资源

    longestIdleConnection!!.socket().closeQuietly()



    // Cleanup again immediately.

    //这里是在清理一个空闲时间最长的连接以后会执行到这里，需要立即再次执行清理

    return 0

  }

这里的首先统计空闲连接数量，然后通过for循环查找最长空闲时间的连接以及对应空闲时长，然后判断是否超出最大空闲连接数(maxIdleConnections)或者或者超过最大空闲时间(keepAliveDurationNs)，满足其一则清除最长空闲时长的连接。如果不满足清理条件，则返回一个对应等待时间。
这个对应等待的时间又分二种情况：

1. 有连接则等待下次需要清理的时间去清理:keepAliveDurationNs-longestIdleDurationNs;
2. 没有空闲的连接，则等下一个周期去清理：keepAliveDurationNs
   如果清理完毕返回-1。

综上所述，我们来梳理一下清理任务，清理任务就是异步执行的，遵循两个指标，最大空闲连接数量和最大空闲时长，满足其一则清理空闲时长最大的那个连接，然后循环执行，要么等待一段时间，要么继续清理下一个连接，知道清理所有连接，清理任务才结束，下一次put的时候，如果已经停止的清理任务则会被再次触发

private fun pruneAndGetAllocationCount(connection: RealConnection, now: Long): Int {

    val references = connection.transmitters

    var i = 0

    //遍历弱引用列表

    while (i < references.size) {

      val reference = references[i]

//若StreamAllocation被使用则接着循环

      if (reference.get() != null) {

        i++

        continue

      }



      // We've discovered a leaked transmitter. This is an application bug.

      val transmitterRef = reference as TransmitterReference

      val message = "A connection to ${connection.route().address.url} was leaked. " +

          "Did you forget to close a response body?"

      Platform.get().logCloseableLeak(message, transmitterRef.callStackTrace)

//若StreamAllocation未被使用则移除引用，这边注释为泄露

      references.removeAt(i)

      connection.noNewExchanges = true

//如果列表为空则说明此连接没有被引用了，则返回0，表示此连接是空闲连接

      // If this was the last allocation, the connection is eligible for immediate eviction.

      if (references.isEmpty()) {

        connection.idleAtNanos = now - keepAliveDurationNs

        return 0

      }

    }



    return references.size

  }

pruneAndGetAllocationCount主要是用来标记泄露连接的。内部通过遍历传入进来的RealConnection的StreamAllocation列表，如果StreamAllocation被使用则接着遍历下一个StreamAllocation。如果StreamAllocation未被使用则从列表中移除，如果列表中为空则说明此连接连接没有引用了，返回0，表示此连接是空闲连接，否则就返回非0表示此连接是活跃连接。
接下来让我看下ConnectionPool的connectionBecameIdle()方法，就是当有连接空闲时，唤起cleanup线程清洗连接池

fun connectionBecameIdle(connection: RealConnection): Boolean {

    assert(Thread.holdsLock(this))

    //该连接已经不可用

    return if (connection.noNewExchanges || maxIdleConnections == 0) {

      connections.remove(connection)

      true

    } else {

      // Awake the cleanup thread: we may have exceeded the idle connection limit.

      //欢迎clean 线程

      this.notifyAll()

      false

    }

  }

connectionBecameIdle标示一个连接处于空闲状态，即没有流任务，那么久需要调用该方法，由ConnectionPool来决定是否需要清理该连接。
再来看下evictAll()方法

fun evictAll() {

    val evictedConnections = mutableListOf<RealConnection>()

    synchronized(this) {

      val i = connections.iterator()

      while (i.hasNext()) {

        val connection = i.next()

        if (connection.transmitters.isEmpty()) {

          connection.noNewExchanges = true

          evictedConnections.add(connection)

          i.remove()

        }

      }

    }



    for (connection in evictedConnections) {

      connection.socket().closeQuietly()

    }

  }

该方法是删除所有空闲的连接，比较简单，不说了

Integer中的享元模式

那么我们来看看Integer中的享元模式具体是怎么样的吧。
通过如下代码了解一下integer的比较

public static void main(String[] args)

    {

        Integer integer1 = 9;

        Integer integer2 = 9;

        System.out.println(integer1==integer2);



        Integer integer3 = 129;

        Integer integer4 = 129;

        System.out.println(integer3==integer4);

    }

输出：

true

false

在通过等号赋值的时候，实际上是通过调用valueOf方法的返回一个对象。然后我们观察一下这个方法的源码。

public final class Integer extends Number implements Comparable<Integer> {

    public static Integer valueOf(int i) {

        if (i >= IntegerCache.low && i <= IntegerCache.high)

            return IntegerCache.cache[i + (-IntegerCache.low)];

        return new Integer(i);

    }

    private final int value;

    public Integer(int value) {

        this.value = value;

    }

}

上面是我简化了的Integer类。平常在使用Integer类的时候。你是否思考过用valueOf还是用new创建Integer对象。看完源码就会发现在valueOf这个方法中它会先判断传进去的值是否在IntegerCache中，如果不在就创建新的对象，在就直接返回缓存池里的对象。这个valueOf方法就用到享元模式。它将-128到127的Integer对象先在缓存池里创建好，等我们需要的时候直接返回即可。所以在-128到127中的数值我们用valueOf创建会比new更快。因此我们在使用Integer对象的时候，也一定要记住使用equals()，而不是单纯的使用”==”，否则有可能出现不相等的情况。

桥接模式的定义与特点

桥接（Bridge）模式的定义如下：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。

通过上面的讲解，我们能很好的感觉到桥接模式遵循了里氏替换原则和依赖倒置原则，最终实现了开闭原则，对修改关闭，对扩展开放。这里将桥接模式的优缺点总结如下。

优点

• 抽象与实现分离，扩展能力强
• 符合开闭原则
• 符合合成复用原则
• 其实现细节对客户透明

缺点

由于聚合关系建立在抽象层，要求开发者针对抽象化进行设计与编程，能正确地识别出系统中两个独立变化的维度，这增加了系统的理解与设计难度。

桥接模式的结构与实现

可以将抽象化部分与实现化部分分开，取消二者的继承关系，改用组合关系。

模式的结构

抽象化角色：定义抽象类，并包含一个对实现化对象的引用。
扩展抽象化角色：是抽象化角色的子类，实现父类中的业务方法，并通过组合关系调用实现化角色中的业务方法。
实现化角色：定义实现化角色的接口，供扩展抽象化角色调用。
具体实现化角色：给出实现化角色接口的具体实现。

桥接模式的应用场景

当一个类内部具备两种或多种变化维度时，使用桥接模式可以解耦这些变化的维度，使高层代码架构稳定。

桥接模式通常适用于以下场景。

1. 当一个类存在两个独立变化的维度，且这两个维度都需要进行扩展时。
2. 当一个系统不希望使用继承或因为多层次继承导致系统类的个数急剧增加时。
3. 当一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性时。

桥接模式的一个常见使用场景就是替换继承。我们知道，继承拥有很多优点，比如，抽象、封装、多态等，父类封装共性，子类实现特性。继承可以很好的实现代码复用（封装）的功能，但这也是继承的一大缺点。

示例代码：

//抽象类：建筑

public abstract class Building {

    protected Paint paint;

    public Building(Paint paint) {

        this.paint = paint;

    }

    public abstract void decorate();

}

//接口：油漆

public interface Paint {

    void decorateImpl();

}

//教学楼

public class TeachingBuilding extends Building {

    public TeachingBuilding(Paint paint) {

        super(paint);

    }



    @Override

    public void decorate() {

        System.out.print("普通的教学楼");

        paint.decorateImpl();

    }

}

//实验楼

public class LaboratoryBuilding extends Building {

    public LaboratoryBuilding(Paint paint) {

        super(paint);

    }



    @Override

    public void decorate() {

        System.out.print("普通的实验楼");

        paint.decorateImpl();

    }

}

public class RedPaint implements Paint {

    @Override

    public void decorateImpl() {

        System.out.println("被红色油漆装饰过。");

    }

}

public class GreenPaint  implements Paint {

    @Override

    public void decorateImpl() {

        System.out.println("被绿色油漆装饰过。");

    }

}

public class BulePaint implements Paint {

    @Override

    public void decorateImpl() {

        System.out.println("被蓝色油漆装饰过。");

    }

}

public class BridgePatternDemo {

    public static void main(String[] args) {

        //普通的教学楼被红色油漆装饰。

        Building redTeachingBuilding=new TeachingBuilding(new RedPaint());

        redTeachingBuilding.decorate();

        //普通的教学楼被绿色油漆装饰。

        Building greenTeachingBuilding1=new TeachingBuilding(new GreenPaint());

        greenTeachingBuilding1.decorate();

        //普通的实验楼被红色油漆装饰。

        Building redLaboratoryBuilding=new LaboratoryBuilding(new RedPaint());

        redLaboratoryBuilding.decorate();

        //普通的实验楼被绿色油漆装饰。

        Building greenLaboratoryBuilding=new LaboratoryBuilding(new GreenPaint());

        greenLaboratoryBuilding.decorate();

        //普通的实验楼被蓝色油漆装饰。

        Building blueLaboratoryBuilding=new LaboratoryBuilding(new BulePaint());

        blueLaboratoryBuilding.decorate();

    }

}

运行结果：

普通的教学楼被红色油漆装饰过。

普通的教学楼被绿色油漆装饰过。

普通的实验楼被红色油漆装饰过。

普通的实验楼被绿色油漆装饰过。

普通的实验楼被蓝色油漆装饰过。

桥接模式与装饰模式对比：

两个模式都是为了解决子类过多问题, 但他们的诱因不同:

1. 桥接模式对象自身有 沿着多个维度变化的趋势 , 本身不稳定;
2. 装饰者模式对象自身非常稳定, 只是为了增加新功能/增强原功能。

前言

无论做啥，要想好设计，就得多扩展，少修改

开闭原则

此原则是由”Bertrand Meyer”提出的。原文是：”Software entities should be open for extension,but closed for modification”。就是说模块应对扩展开放，而对修改关闭。模块应尽量在不修改原(是”原”，指原来的代码)代码的情况下进行扩展

开闭原则的含义

当应用的需求改变时，在不修改软件实体的源代码或者二进制代码的前提下，可以扩展模块的功能，使其满足新的需求。

开闭原则的作用

1. 对软件测试的影响
   软件遵守开闭原则的话，软件测试时只需要对扩展的代码进行测试就可以了，因为原有的测试代码仍然能够正常运行。
2. 可以提高代码的可复用性
   粒度越小，被复用的可能性就越大；在面向对象的程序设计中，根据原子和抽象编程可以提高代码的可复用性。
3. 可以提高软件的可维护性
   遵守开闭原则的软件，其稳定性高和延续性强，从而易于扩展和维护。

里氏替换原则

里氏替换原则主要阐述了有关继承的一些原则，也就是什么时候应该使用继承，什么时候不应该使用继承，以及其中蕴含的原理。里氏替换原是继承复用的基础，它反映了基类与子类之间的关系，是对开闭原则的补充，是对实现抽象化的具体步骤的规范。

里氏替换原则的作用

它克服了继承中重写父类造成的可复用性变差的缺点。
它是动作正确性的保证。即类的扩展不会给已有的系统引入新的错误，降低了代码出错的可能性。
加强程序的健壮性，同时变更时可以做到非常好的兼容性，提高程序的维护性、可扩展性，降低需求变更时引入的风险。

里氏替换原则的实现方法

里氏替换原则通俗来讲就是：子类可以扩展父类的功能，但不能改变父类原有的功能。也就是说：子类继承父类时，除添加新的方法完成新增功能外，尽量不要重写父类的方法。

依赖倒置原则

要面向接口编程，不要面向实现编程。

依赖倒置原则是实现开闭原则的重要途径之一，它降低了客户与实现模块之间的耦合。

由于在软件设计中，细节具有多变性，而抽象层则相对稳定，因此以抽象为基础搭建起来的架构要比以细节为基础搭建起来的架构要稳定得多。这里的抽象指的是接口或者抽象类，而细节是指具体的实现类。

使用接口或者抽象类的目的是制定好规范和契约，而不去涉及任何具体的操作，把展现细节的任务交给它们的实现类去完成。

依赖、倒置原则的作用

• 依赖倒置原则的主要作用如下。
• 依赖倒置原则可以降低类间的耦合性。
• 依赖倒置原则可以提高系统的稳定性。
• 依赖倒置原则可以减少并行开发引起的风险。
• 依赖倒置原则可以提高代码的可读性和可维护性。

单一职责原则

单一职责原则规定一个类应该有且仅有一个引起它变化的原因，否则类应该被拆分

单一职责原则的优点

单一职责原则的核心就是控制类的粒度大小、将对象解耦、提高其内聚性。如果遵循单一职责原则将有以下优点。

• 降低类的复杂度。一个类只负责一项职责，其逻辑肯定要比负责多项职责简单得多。
• 提高类的可读性。复杂性降低，自然其可读性会提高。
• 提高系统的可维护性。可读性提高，那自然更容易维护了。
• 变更引起的风险降低。变更是必然的，如果单一职责原则遵守得好，当修改一个功能时，可以显著降低对其他功能的影响。

接口隔离原则

尽量将臃肿庞大的接口拆分成更小的和更具体的接口，让接口中只包含客户感兴趣的方法。
一个类对另一个类的依赖应该建立在最小的接口上

要为各个类建立它们需要的专用接口，而不要试图去建立一个很庞大的接口供所有依赖它的类去调用。

接口隔离原则和单一职责都是为了提高类的内聚性、降低它们之间的耦合性，体现了封装的思想，但两者是不同的：

• 单一职责原则注重的是职责，而接口隔离原则注重的是对接口依赖的隔离。
• 单一职责原则主要是约束类，它针对的是程序中的实现和细节；接口隔离原则主要约束接口，主要针对抽象和程序整体框架的构建。

  接口隔离原则的优点

  接口隔离原则是为了约束接口、降低类对接口的依赖性，遵循接口隔离原则有以下 5 个优点。

1. 将臃肿庞大的接口分解为多个粒度小的接口，可以预防外来变更的扩散，提高系统的灵活性和可维护性。
2. 接口隔离提高了系统的内聚性，减少了对外交互，降低了系统的耦合性。
3. 如果接口的粒度大小定义合理，能够保证系统的稳定性；但是，如果定义过小，则会造成接口数量过多，使设计复杂化；如果定义太大，灵活性降低，无法提供定制服务，给整体项目带来无法预料的风险。
4. 使用多个专门的接口还能够体现对象的层次，因为可以通过接口的继承，实现对总接口的定义。
5. 能减少项目工程中的代码冗余。过大的大接口里面通常放置许多不用的方法，当实现这个接口的时候，被迫设计冗余的代码。

迪米特法则

如果两个软件实体无须直接通信，那么就不应当发生直接的相互调用，可以通过第三方转发该调用。其目的是降低类之间的耦合度，提高模块的相对独立性。

迪米特法则中的“朋友”是指：当前对象本身、当前对象的成员对象、当前对象所创建的对象、当前对象的方法参数等，这些对象同当前对象存在关联、聚合或组合关系，可以直接访问这些对象的方法。
迪米特法则的优点
迪米特法则要求限制软件实体之间通信的宽度和深度，正确使用迪米特法则将有以下两个优点。

• 降低了类之间的耦合度，提高了模块的相对独立性。
• 由于亲合度降低，从而提高了类的可复用率和系统的扩展性。

但是，过度使用迪米特法则会使系统产生大量的中介类，从而增加系统的复杂性，使模块之间的通信效率降低。所以，在釆用迪米特法则时需要反复权衡，确保高内聚和低耦合的同时，保证系统的结构清晰。

合成复用原则

要尽量先使用组合或者聚合等关联关系来实现，其次才考虑使用继承关系来实现。

如果要使用继承关系，则必须严格遵循里氏替换原则。合成复用原则同里氏替换原则相辅相成的，两者都是开闭原则的具体实现规范。

合成复用原则的重要性

通常类的复用分为继承复用和合成复用两种，继承复用虽然有简单和易实现的优点，但它也存在以下缺点。

1. 继承复用破坏了类的封装性。因为继承会将父类的实现细节暴露给子类，父类对子类是透明的，所以这种复用又称为“白箱”复用。
2. 子类与父类的耦合度高。父类的实现的任何改变都会导致子类的实现发生变化，这不利于类的扩展与维护。
3. 它限制了复用的灵活性。从父类继承而来的实现是静态的，在编译时已经定义，所以在运行时不可能发生变化。

采用组合或聚合复用时，可以将已有对象纳入新对象中，使之成为新对象的一部分，新对象可以调用已有对象的功能，它有以下优点。

1. 它维持了类的封装性。因为成分对象的内部细节是新对象看不见的，所以这种复用又称为“黑箱”复用。
2. 新旧类之间的耦合度低。这种复用所需的依赖较少，新对象存取成分对象的唯一方法是通过成分对象的接口。
3. 复用的灵活性高。这种复用可以在运行时动态进行，新对象可以动态地引用与成分对象类型相同的对象。

写在前面：

本文旨在帮助社区各位小伙伴选择合适的渠道尽早升级HarmonyOS系统，深夜撸稿，还望三连支持一哈!!

目前正在进行的升级活动：消费者公测、消费者内测、HarmonyOS体验官(线下)

必要说明：

所有消费者公测渠道最终都会跳转到花粉俱乐部;

初期申请量巨大，花粉俱乐部很容易就挂掉，心急的小伙伴可尝试线下渠道或者多次尝试或者深夜(两点以后)申请;

申请前务必将“花粉俱乐部”、“我的华为”、“会员中心”升级到最新版本，尤其是“花粉俱乐部”。

消费者公测

包含机型：

Mate X2

Mate40、Mate40E、Mate 40 Pro、Mate 40 Pro+、Mate 40 RS 保时捷设计

P40 5G、P40 4G、P40 Pro、P40 Pro+

Mate 30 4G、Mate 30 Pro 4G、Mate 30 5G、Mate 30 Pro 5G、Mate 30 RS保时捷设计、Mate 30E Pro 5G

MatePad Pro、MatePad Pro 5G

我的华为/花粉俱乐部：请先更新到最新版本，如果卸载了，请在华为应用商店下载安装。

方法：

1.打开“我的华为”，点击“升级尝鲜” / 打开“花粉俱乐部”，点击“公测尝鲜”。

△我的华为

△花粉俱乐部

2.页面加载完成后，点击“公测尝鲜”下的“立即尝鲜”按钮。(花粉俱乐部进入的请忽略此步骤，直接进入下步)

3.接下来在列表中找到当前手机型号对应的公测活动，点击“报名公测”。由于不同手机对应的系统版本不一样，请务必仔细核实你的机器型号。

4.此处会跳转到“花粉论坛”的一篇帖子，划到这篇帖子的末尾，点击“参加公测活动”。接下来系统会引导用户签订《华为公测协议》和《华为公测与隐私声明》，等待10秒点击通过。

5.通过两个协议后，系统会引导你下载协议文件。这个过程会验证你的机型是否符合要求，且下载的文件也是将来升级为正式版的必要文件，如果找到(反正我是没找到)请勿删除!!

6.下载并提示安装完描述文件后，就可以去检测系统更新，下载并更新HarmonyOS了。(P40系列当前版本116)

消费者内测

包含机型：

Mate XS、Mate 20、Mate 20 Pro、Mate 20 RS(保时捷)、Mate 20 X(4G)

nova 8、nova 8 Pro、nova 8 SE、nova 7 5G、nova 7 Pro 5G、nova 7 SE 5G、nova 7 SE 5G活力版、nova 7 SE 5G乐活版、nova 6、nova 6 5G、nova 6 SE

华为畅享20 Plus 5G、华为畅享Z 5G、华为畅享20 Pro5G

华为麦芒9 5G

MatePad 10.8、MatePad 5G 10.4、MatePad 10.4

内测时间：6月2日~6月9日上午10:00

渠道一

会员中心：请先更新到最新版本，如果卸载了，请在华为应用商店下载安装。

方法：

1.打开会员中心，首页上找到“体验先锋”，点击进入。

2.点击顶部的HarmonyOS 2升级尝鲜。

3.进入页面点击报名。如果机型不符合，会弹出提示框。

4.接下来根据流程提示，填写信息，等待审核，坐等更新就好了。

渠道二

花粉俱乐部：请先更新到最新版本，如果卸载了，请在华为应用商店下载安装。

方法：

1.进入首页点击内测报名

2.跳转后，点击立即报名

3.接下来根据流程提示，填写信息，等待审核，坐等更新就好了。

HarmonyOS体验官(线下)

包含机型：

我的华为：请先更新到最新版本，如果卸载了，请在华为应用商店下载安装。

方法：

在APP首页点击“HarmonyOS体验官”海报，经过简单的互动问答即可参加。期间需要提交信息、预约门店时间和信息，最终会生成一张包含数字的海报，用户需要保存此海报才可参与活动。

活动仅在部分门店进行，具体店面和城市请在活动页面查询。到店会提供礼品，并可在线下由店面工作人员协助完成升级。

重要的补充说明

1.消费者公测仅审核设备型号是否合规，避免出现系统和硬件不适配的情况。

2.消费者内测仍然会存在审核机制，但仅审核设备型号是否合规，避免出现系统和硬件不适配的情况。

3.最终稳定的系统版本号预计为：HarmonyOS 2.0.0.116(以实际推送版本号为准!)

4.老荣耀系列机型不在本次消费者公测列表中。

详细介绍一下ZFPlayer 3.0的用法，如果你有什么问题或者建议可联系我。在3.0之前版本使用ZFPlayer，是不是在烦恼播放器SDK自定义、控制层自定义等问题。作者公司多个项目分别使用不同播放器SDK以及每个项目控制层都不一样，但是为了统一管理、统一调用，我特意写了这个播放器壳子。播放器SDK只要遵守ZFPlayerMediaPlayback协议，控制层只要遵守ZFPlayerMediaControl协议，可以实现自定义播放器和控制层。

目前支持的功能如下：

1、普通模式的播放，类似于腾讯视频、爱奇艺等APP；
2、列表普通模式的播放，包括手动点击播放、滑动到屏幕中间自动播放，wifi网络智能播放等等；
3、列表的亮暗模式播放，类似于微博、UC浏览器视频列表等APP；
4、列表视频滑出屏幕后停止播放、滑出屏幕后小窗播放；
5、优雅的全屏，支持横屏和竖屏全屏模式；

播放器的主要类为ZFPlayerController，具体API请看下边这张图吧，后边我也会详细介绍。在之前版本收到好多开发朋友的Issues建议也好bug也好，ZFPlayer也是致力于解决这些问题和满足各位的建议。

ZFPlayerController（播放器的主要类）

初始化方式：

/// 普通播放的初始化
+ (instancetype)playerWithPlayerManager:(id<ZFPlayerMediaPlayback>)playerManager containerView:(UIView *)containerView;

/// 普通播放的初始化
- (instancetype)initWithPlayerManager:(id<ZFPlayerMediaPlayback>)playerManager containerView:(UIView *)containerView;

/// UITableView、UICollectionView播放的初始化
+ (instancetype)playerWithScrollView:(UIScrollView *)scrollView playerManager:(id<ZFPlayerMediaPlayback>)playerManager containerViewTag:(NSInteger)containerViewTag;

/// UITableView、UICollectionView播放的初始化
- (instancetype)initWithScrollView:(UIScrollView *)scrollView playerManager:(id<ZFPlayerMediaPlayback>)playerManager containerViewTag:(NSInteger)containerViewTag;

/// UIScrollView播放的初始化
+ (instancetype)playerWithScrollView:(UIScrollView *)scrollView playerManager:(id<ZFPlayerMediaPlayback>)playerManager containerView:(UIView *)containerView;

/// UIScrollView播放的初始化
- (instancetype)initWithScrollView:(UIScrollView *)scrollView playerManager:(id<ZFPlayerMediaPlayback>)playerManager containerView:(UIView *)containerView;

属性

/// 初始化时传递的容器视图，用来显示播放器view，和播放器view同等大小
@property (nonatomic, strong) UIView *containerView;

/// 初始化时传递的播放器manager，必须遵守`ZFPlayerMediaPlayback`协议
@property (nonatomic, strong) id<ZFPlayerMediaPlayback> currentPlayerManager;

/// 此属性是设置显示的控制层，自定义UIView遵守`ZFPlayerMediaControl`协议，实现相关协议就可以满足自定义控制层的目的。
@property (nonatomic, strong) UIView<ZFPlayerMediaControl> *controlView;

/// 通知的管理类
@property (nonatomic, strong, readonly) ZFPlayerNotification *notification;

/// 容器的类型（cell和普通View）
@property (nonatomic, assign, readonly) ZFPlayerContainerType containerType;

/// 播放器小窗的容器View
@property (nonatomic, strong, readonly) ZFFloatView *smallFloatView;

/// 播放器小窗是否正在显示
@property (nonatomic, assign, readonly) BOOL isSmallFloatViewShow;

ZFPlayerController (ZFPlayerTimeControl)

/// 0...1.0,调节系统的声音，要是调节播放器声音可以使用播放器管理类设置
@property (nonatomic) float volume;

/// 系统静音，要是调节播放器静音可以使用播放器管理类设置
@property (nonatomic, getter=isMuted) BOOL muted;

// 0...1.0, 系统屏幕亮度
@property (nonatomic) float brightness;

/// 移动网络下自动播放, default is NO.
@property (nonatomic, getter=isWWANAutoPlay) BOOL WWANAutoPlay;

/// 当前播放的下标，只适用于设置了`assetURLs`
@property (nonatomic) NSInteger currentPlayIndex;

/// 在 `assetURLs`中是否是最后一个
@property (nonatomic, readonly) BOOL isLastAssetURL;

/// 在 `assetURLs`中是否是第一个
@property (nonatomic, readonly) BOOL isFirstAssetURL;

/// 当退到后台后是否暂停播放，前提是支持后台播放器模式，default is YES.
@property (nonatomic) BOOL pauseWhenAppResignActive;

/// 当播放器在玩播放时，它会被一些事件暂停，而不是用户点击暂停。
/// 例如，应用程序进入后台或者push到另一个视图控制器
@property (nonatomic, getter=isPauseByEvent) BOOL pauseByEvent;

/// 当前播放器控制器消失，而不是dealloc
@property (nonatomic, getter=isViewControllerDisappear) BOOL viewControllerDisappear;

/// 自定义AVAudioSession, default is NO.
@property (nonatomic, assign) BOOL customAudioSession;

/// 当播放器Prepare时候调用
@property (nonatomic, copy, nullable) void(^playerPrepareToPlay)(id<ZFPlayerMediaPlayback> asset, NSURL *assetURL);

///当播放器准备开始播放时候调用
@property (nonatomic, copy, nullable) void(^playerReadyToPlay)(id<ZFPlayerMediaPlayback> asset, NSURL *assetURL);

/// 当播放进度改变时候调用.
@property (nonatomic, copy, nullable) void(^playerPlayTimeChanged)(id<ZFPlayerMediaPlayback> asset, NSTimeInterval currentTime, NSTimeInterval duration);

/// 当缓冲进度改变时候调用
@property (nonatomic, copy, nullable) void(^playerBufferTimeChanged)(id<ZFPlayerMediaPlayback> asset, NSTimeInterval bufferTime);

/// 当播放状态改变时候调用
@property (nonatomic, copy, nullable) void(^playerPlayStateChanged)(id<ZFPlayerMediaPlayback> asset, ZFPlayerPlaybackState playState);

/// 当加载状态改变时候调用.
@property (nonatomic, copy, nullable) void(^playerLoadStateChanged)(id<ZFPlayerMediaPlayback> asset, ZFPlayerLoadState loadState);

/// 当播放失败时候调用.
@property (nonatomic, copy, nullable) void(^playerPlayFailed)(id<ZFPlayerMediaPlayback> asset, id error);

/// 当播放状态完成时候调用.
@property (nonatomic, copy, nullable) void(^playerDidToEnd)(id<ZFPlayerMediaPlayback> asset);

// 当播放器view的尺寸改变时候调用.
@property (nonatomic, copy, nullable) void(^presentationSizeChanged)(id<ZFPlayerMediaPlayback> asset, CGSize size);

/// 播放下一个，只适用于设置了`assetURLs`
- (void)playTheNext;

/// 播放上一个，只适用于设置了`assetURLs`
- (void)playThePrevious;

/// 播放某一个，只适用于设置了`assetURLs`
- (void)playTheIndex:(NSInteger)index;

/// 停止播放，并且把播放器view和相关通知移除
- (void)stop;

/// 切换当前的PlayerManager，适用场景：播放某一个视频时候使用特定的播放器管理类
- (void)replaceCurrentPlayerManager:(id<ZFPlayerMediaPlayback>)manager;

/**
 添加播放器view到cell上
 */
- (void)addPlayerViewToCell;

/**
 添加播放器view到容器view上.
 */
- (void)addPlayerViewToContainerView:(UIView *)containerView;

/**
 添加播放器到主window上.
 */
- (void)addPlayerViewToKeyWindow;

/**
 停止当前在view上的播放并移除播放器view.
 */
- (void)stopCurrentPlayingView;

/**
 停止当前在cell上的播放并移除播放器view.
 */
- (void)stopCurrentPlayingCell;

ZFPlayerController (ZFPlayerOrientationRotation)

/// 屏幕旋转管理类
@property (nonatomic, readonly) ZFOrientationObserver *orientationObserver;

///是否支持自动屏幕旋转。
/// iOS8.1~iOS8.3的值为YES，其他iOS版本的值为NO。
///这个属性用于UIViewController ' shouldAutorotate '方法的返回值。
@property (nonatomic, readonly) BOOL shouldAutorotate;

///是否允许视频方向旋转。
///默认值是YES。
@property (nonatomic) BOOL allowOrentitaionRotation;

/// 是否是全屏状态，当ZFFullScreenMode == ZFFullScreenModeLandscape，当currentOrientation是LandscapeLeft或者LandscapeRight，这个值是YES
/// 当ZFFullScreenMode == ZFFullScreenModePortrait，当视频全屏后，这个值是YES
@property (nonatomic, readonly) BOOL isFullScreen;

/// 锁定当前的屏幕方向，目的是禁止设备自动旋转
@property (nonatomic, getter=isLockedScreen) BOOL lockedScreen;

/// 隐藏系统的状态栏
@property (nonatomic, getter=isStatusBarHidden) BOOL statusBarHidden;

/// 使用设备方向旋转屏幕, default NO.
@property (nonatomic, assign) BOOL forceDeviceOrientation;

/// 播放器view当前方向
@property (nonatomic, readonly) UIInterfaceOrientation currentOrientation;

/// 当即将全屏时候会调用
@property (nonatomic, copy, nullable) void(^orientationWillChange)(ZFPlayerController *player, BOOL isFullScreen);

/// 当已经全屏时候会调用
@property (nonatomic, copy, nullable) void(^orientationDidChanged)(ZFPlayerController *player, BOOL isFullScreen);

/// 添加设备方向的监听
- (void)addDeviceOrientationObserver;

/// 移除设备方向的监听
- (void)removeDeviceOrientationObserver;

/// 当 ZFFullScreenMode == ZFFullScreenModeLandscape使用此API设置全屏切换
- (void)enterLandscapeFullScreen:(UIInterfaceOrientation)orientation animated:(BOOL)animated;

/// 当 ZFFullScreenMode == ZFFullScreenModePortrait使用此API设置全屏切换
- (void)enterPortraitFullScreen:(BOOL)fullScreen animated:(BOOL)animated;

/// 内部根据ZFFullScreenMode的值来设置全屏切换
- (void)enterFullScreen:(BOOL)fullScreen animated:(BOOL)animated;

ZFPlayerController (ZFPlayerViewGesture)

/// 手势的管理类
@property (nonatomic, readonly) ZFPlayerGestureControl *gestureControl;

/// 禁用哪些手势，默认支持单击、双击、滑动、缩放手势
@property (nonatomic, assign) ZFPlayerDisableGestureTypes disableGestureTypes;

///不支持的平移手势移动方向
@property (nonatomic) ZFPlayerDisablePanMovingDirection disablePanMovingDirection;

ZFPlayerController (ZFPlayerScrollView)

/// 初始化时候设置的scrollView
@property (nonatomic, readonly, nullable) UIScrollView *scrollView;

/// 只适用于列表播放时候是否自动播放,default is YES.
@property (nonatomic) BOOL shouldAutoPlay;

/// 移动网络自动播放，只有当“shouldAutoPlay”为YES时才支持，默认为NO
@property (nonatomic, getter=isWWANAutoPlay) BOOL WWANAutoPlay;

/// 当前播放的indexPath 
@property (nonatomic, nullable) NSIndexPath *playingIndexPath;

/// 初始化时候设置的containerViewTag，根据此tag在cell上找到播放器view显示的位置
@property (nonatomic) NSInteger containerViewTag;

/// 滑出屏幕后是否停止播放，如果设置为NO，滑出屏幕后则会小窗播放，defalut is YES.
@property (nonatomic) BOOL stopWhileNotVisible;

/**
当前播放器滚动滑出屏幕的百分比。
当`stopWhileNotVisible`为YES时使用的属性，停止当前正在播放的播放器。
当`stopWhileNotVisible`为NO时使用的属性，当前正在播放的播放器添加到小容器视图。
范围是0.0~1.0,defalut是0.5。
0.0是player将会消失。
1.0是player消失了。
*/
@property (nonatomic) CGFloat playerDisapperaPercent;

/**
当前播放器滚动到屏幕百分比来播放视频。
范围是0.0~1.0,defalut是0.0。
0.0是玩家将会出现。
1.0是播放器确实出现了。
 */
@property (nonatomic) CGFloat playerApperaPercent;

/// 如果列表播放时候有多个区，使用此API
@property (nonatomic, copy, nullable) NSArray <NSArray <NSURL *>*>*sectionAssetURLs;

/**
播放url的indexPath，而' assetURLs '或' sectionAssetURLs '不为空。

@param indexPath播放url的indexPath。
 */
- (void)playTheIndexPath:(NSIndexPath *)indexPath;

/**
播放url的indexPath，而' assetURLs '或' sectionAssetURLs '不为空。

@param indexPath播放url的indexPath
@param scrollToTop使用动画将当前单元格滚动到顶部。
*/
- (void)playTheIndexPath:(NSIndexPath *)indexPath scrollToTop:(BOOL)scrollToTop;

/**
播放url的indexPath，而' assetURLs '或' sectionAssetURLs '不为空。

@param indexPath播放url的indexPath
@param assetURL播放器URL。
@param scrollToTop使用动画将当前单元格滚动到顶部。
 */
- (void)playTheIndexPath:(NSIndexPath *)indexPath assetURL:(NSURL *)assetURL scrollToTop:(BOOL)scrollToTop;

/**
播放url的indexPath，而' assetURLs '或' sectionAssetURLs '不为空。

@param indexPath播放url的indexPath
@param scrollToTop使用动画将当前单元格滚动到顶部。
@param completionHandler滚动完成回调。
 */
- (void)playTheIndexPath:(NSIndexPath *)indexPath scrollToTop:(BOOL)scrollToTop completionHandler:(void (^ __nullable)(void))completionHandler;

ZFPlayerMediaPlayback—播放器SDK遵守的协议

1、枚举类型：

///  播放状态：未知、播放中、暂停、失败、停止
typedef NS_ENUM(NSUInteger, ZFPlayerPlaybackState) {
    ZFPlayerPlayStateUnknown = 0, 
    ZFPlayerPlayStatePlaying,
    ZFPlayerPlayStatePaused,
    ZFPlayerPlayStatePlayFailed,
    ZFPlayerPlayStatePlayStopped
};

///  加载状态：未知、就绪、可以播放、自动播放、播放暂停
typedef NS_OPTIONS(NSUInteger, ZFPlayerLoadState) {
    ZFPlayerLoadStateUnknown        = 0,
    ZFPlayerLoadStatePrepare        = 1 << 0,
    ZFPlayerLoadStatePlayable       = 1 << 1,
    ZFPlayerLoadStatePlaythroughOK  = 1 << 2, 
    ZFPlayerLoadStateStalled        = 1 << 3,
};

///  播放画面拉伸模式：无拉伸、等比例拉伸不裁剪、部分内容裁剪按比例填充、非等比例填满
typedef NS_ENUM(NSInteger, ZFPlayerScalingMode) {
     ZFPlayerScalingModeNone,         
     ZFPlayerScalingModeAspectFit,  
     ZFPlayerScalingModeAspectFill,     
     ZFPlayerScalingModeFill     
};

2、协议属性：

///  播放器视图继承于ZFPlayerView，处理一些手势冲突
@property (nonatomic) ZFPlayerView *view;

///  0...1.0，播放器音量，不影响设备的音量大小
@property (nonatomic) float volume;

///  播放器是否静音，不影响设备静音
@property (nonatomic, getter=isMuted) BOOL muted;

///  0.5...2，播放速率，正常速率为 1
@property (nonatomic) float rate;

///  当前播放时间
@property (nonatomic, readonly) NSTimeInterval currentTime;

///  播放总时间
@property (nonatomic, readonly) NSTimeInterval totalTime;

///  缓冲时间
@property (nonatomic, readonly) NSTimeInterval bufferTime;

///  视频播放定位时间
@property (nonatomic) NSTimeInterval seekTime;

///  视频是否正在播放中
@property (nonatomic, readonly) BOOL isPlaying;

///  视频播放视图的填充模式，默认不做任何拉伸
@property (nonatomic) ZFPlayerScalingMode scalingMode;

///  检查视频播放是否准备就绪，返回YES，调用play方法直接播放视频；返回NO，调用play方法内部自动调用prepareToPlay方法进行视频播放准备工作
@property (nonatomic, readonly) BOOL isPreparedToPlay;

///  媒体播放资源URL
@property (nonatomic) NSURL *assetURL;

///  视频的尺寸
@property (nonatomic, readonly) CGSize presentationSize;

///  视频播放状态
@property (nonatomic, readonly) ZFPlayerPlaybackState playState;

///  视频的加载状态
@property (nonatomic, readonly) ZFPlayerLoadState loadState;

///------------------------------------
///如果没有指定controlView，可以调用以下块。
///如果你指定了controlView，下面的代码块不能在外部调用，只能用于“ZFPlayerController”调用。
///------------------------------------

///  准备播放
@property (nonatomic, copy, nullable) void(^playerPrepareToPlay)(id<ZFPlayerMediaPlayback> asset, NSURL *assetURL);

/// 开始播放了
@property (nonatomic, copy, nullable) void(^playerReadyToPlay)(id<ZFPlayerMediaPlayback> asset, NSURL *assetURL);

///  播放进度改变
@property (nonatomic, copy, nullable) void(^playerPlayTimeChanged)(id<ZFPlayerMediaPlayback> asset, NSTimeInterval currentTime, NSTimeInterval duration);

///  视频缓冲进度改变
@property (nonatomic, copy, nullable) void(^playerBufferTimeChanged)(id<ZFPlayerMediaPlayback> asset, NSTimeInterval bufferTime);

///  视频播放状态改变
@property (nonatomic, copy, nullable) void(^playerPlayStatChanged)(id<ZFPlayerMediaPlayback> asset, ZFPlayerPlaybackState playState);

///  视频加载状态改变
@property (nonatomic, copy, nullable) void(^playerLoadStatChanged)(id<ZFPlayerMediaPlayback> asset, ZFPlayerLoadState loadState);

///  视频播放已经结束
@property (nonatomic, copy, nullable) void(^playerDidToEnd)(id<ZFPlayerMediaPlayback> asset);

// 视频的尺寸改变了
@property (nonatomic, copy, nullable) void(^presentationSizeChanged)(id<ZFPlayerMediaPlayback> asset, CGSize size);

///------------------------------------
/// end
///------------------------------------

3、协议方法：

///  视频播放准备，中断除non-mixible之外的任何音频会话
- (void)prepareToPlay;

///  重新进行视频播放准备
- (void)reloadPlayer;

///  视频播放
- (void)play;

///  视频暂停
- (void)pause;

///  视频重新播放
- (void)replay;

///  视频播放停止
- (void)stop;

///  视频播放当前时间的画面截图
- (UIImage *)thumbnailImageAtCurrentTime;

///  替换当前媒体资源地址
- (void)replaceCurrentAssetURL:(NSURL *)assetURL;

///  调节播放进度
- (void)seekToTime:(NSTimeInterval)time completionHandler:(void (^ __nullable)(BOOL finished))completionHandler;

ZFPlayerMediaControl—控制层遵守的协议

1、视频状态相关

///  视频播放准备就绪
- (void)videoPlayer:(ZFPlayerController *)videoPlayer prepareToPlay:(NSURL *)assetURL;

///  视频播放状态改变
- (void)videoPlayer:(ZFPlayerController *)videoPlayer playStateChanged:(ZFPlayerPlaybackState)state;

///  视频加载状态改变
- (void)videoPlayer:(ZFPlayerController *)videoPlayer loadStateChanged:(ZFPlayerLoadState)state;

2、播放进度

///  视频播放时间进度
- (void)videoPlayer:(ZFPlayerController *)videoPlayer
        currentTime:(NSTimeInterval)currentTime
          totalTime:(NSTimeInterval)totalTime;

///  视频缓冲进度
- (void)videoPlayer:(ZFPlayerController *)videoPlayer
         bufferTime:(NSTimeInterval)bufferTime;

///  视频定位播放时间
- (void)videoPlayer:(ZFPlayerController *)videoPlayer
       draggingTime:(NSTimeInterval)seekTime
          totalTime:(NSTimeInterval)totalTime;

///  视频播放结束
- (void)videoPlayerPlayEnd:(ZFPlayerController *)videoPlayer;

3、锁屏

/// 设置播放器锁屏时的协议方法
- (void)lockedVideoPlayer:(ZFPlayerController *)videoPlayer lockedScreen:(BOOL)locked;

4、屏幕旋转

///  播放器全屏模式即将改变
- (void)videoPlayer:(ZFPlayerController *)videoPlayer orientationWillChange:(ZFOrientationObserver *)observer;

///  播放器全屏模式已经改变
- (void)videoPlayer:(ZFPlayerController *)videoPlayer orientationDidChanged:(ZFOrientationObserver *)observer;

///  当前网络状态发生变化
- (void)videoPlayer:(ZFPlayerController *)videoPlayer reachabilityChanged:(ZFReachabilityStatus)status;

5、手势方法

///  相关手势设置
- (BOOL)gestureTriggerCondition:(ZFPlayerGestureControl *)gestureControl
                    gestureType:(ZFPlayerGestureType)gestureType
              gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
                          touch:(UITouch *)touch;

///  单击
- (void)gestureSingleTapped:(ZFPlayerGestureControl *)gestureControl;

///  双击
- (void)gestureDoubleTapped:(ZFPlayerGestureControl *)gestureControl;

///  开始拖拽
- (void)gestureBeganPan:(ZFPlayerGestureControl *)gestureControl
           panDirection:(ZFPanDirection)direction
            panLocation:(ZFPanLocation)location;

///  拖拽中
- (void)gestureChangedPan:(ZFPlayerGestureControl *)gestureControl
             panDirection:(ZFPanDirection)direction
              panLocation:(ZFPanLocation)location
             withVelocity:(CGPoint)velocity;

///  拖拽结束
- (void)gestureEndedPan:(ZFPlayerGestureControl *)gestureControl
           panDirection:(ZFPanDirection)direction
            panLocation:(ZFPanLocation)location;

///  捏合手势变化
- (void)gesturePinched:(ZFPlayerGestureControl *)gestureControl
        scale:(float)scale;

6、scrollView上的播放器视图方法

/**
scrollView中的播放器视图将要出现的回调
 */
- (void)playerWillAppearInScrollView:(ZFPlayerController *)videoPlayer;

/**
scrollView中的播放器视图已经出现的回调
 */
- (void)playerDidAppearInScrollView:(ZFPlayerController *)videoPlayer;

/**
scrollView中的播放器视图即将消失的回调
 */
- (void)playerWillDisappearInScrollView:(ZFPlayerController *)videoPlayer;

/**
scrollView中的播放器视图已经消失的回调
 */
- (void)playerDidDisappearInScrollView:(ZFPlayerController *)videoPlayer;

/**
scrollView中的播放器视图正在显示的回调
 */
- (void)playerAppearingInScrollView:(ZFPlayerController *)videoPlayer playerApperaPercent:(CGFloat)playerApperaPercent;

/**
scrollView中的播放器视图正在消失的回调
 */
- (void)playerDisappearingInScrollView:(ZFPlayerController *)videoPlayer playerDisapperaPercent:(CGFloat)playerDisapperaPercent;

/**
小窗视图显示隐藏的回调
 */
- (void)videoPlayer:(ZFPlayerController *)videoPlayer floatViewShow:(BOOL)show;

代码传送门：https://github.com/renzifeng/ZFPlayer

转自：https://www.jianshu.com/p/90e55deb4d51

wxlibrary aar文件使用说明

一、项目介绍

1. APP 使用示例项目，libs下含有以编译最新的aar资源。
2. wxlibrary arr资源项目，需要引入的资源包项目。
3. aar文件生成，在工具栏直接Gradle - (项目名) - wxlibrary - Tasks - build - assemble，直到编译完成
4. aar文件位置，打开项目所在文件夹，找到 wxlibrary\build\outputs\aar 下。

二、工程引入工具包

下载项目，可以在APP项目的libs文件下找到*.aar文件（已编译为最新版），选择其中一个引入自己的工程

引入微信工具包及微信SDK

dependencies {

   //引入wxlibrary.aar资源

   implementation files('libs/wxlibrary-release.aar')

   //引入wxlibrary.aar的依赖资源，以下2个

   implementation 'com.tencent.mm.opensdk:wechat-sdk-android-without-mta:6.6.5'

   //eventbus，引入后你的项目将支持EventBus，EventBus是一种用于Android的事件发布-订阅总线，替代广播的传值方式，使用方法可以度娘查询。

   implementation 'org.greenrobot:eventbus:3.1.1'

   ...

}

三、工具包初始准备工作

• 工程继承WxApplication 或者 application 的 onCreate 下使用，获取 APPkey 和AppSecret需要使用mete-data方式获取。 isCheckSignature() 与 isNowRegister() 默认即可

    WxApiUtil.getInstance().init(getApplicationContext(), true, true);

• APPkey和AppSecret，需要使用mete-data方式进行赋值

方式一，manifest下覆盖mete-data资源

 

       ...>



        

        

            android:name="WX_LIBRARY_WX_APP_KEY"

            android:value="123456s"

            tools:replace="android:value"/>

        

        

            android:name="WX_LIBRARY_WX_APP_SECRET"

            android:value="567890a"

            tools:replace="android:value"/>

        



        

 

方式二，manifest下不覆盖mete-data资源，在gradle(app)下赋值

android {

    ...

    defaultConfig {

        ...



        //todo 微信appKey和appSecret赋值的方法二，2个参数都需要赋值，secret不需要时赋值为空字符串即可

        manifestPlaceholders = [

                WX_LIBRARY_WX_APP_KEY: '',

                WX_LIBRARY_WX_APP_SECRET: ''

        ]

    }

    ...

}

四、登录、分享和支付的使用，链式写法一句搞定

1. 登录使用



 // 注意以下注册回调事件不注册则不会触发

        WxLoginUtil.newInstance()

                .setSucceed((code) -> {

                    // 登录过程回调成功   code为微信返回的code

                    // 如果需要在app获取openID，则在此处使用code向微信服务器请求获取openID。

                    // 使用WxApiGlobal.getInstance().getAppKey()和WxApiGlobal.getInstance().getAppSecret()获取微信的必要参数，使用前请确保已填写正确参数

                    return;

                })

                .setNoInstalled((() -> {

                    // 微信客户端未安装

                    return;

                }))

                .setUserCancel(() -> {

                    // 用户取消

                    return;

                })

                .setFail((errorCode, errStr) -> {

                    // 其他类型错误， errorCode为微信返回的错误码

                    return;

                })

                //发起登录请求

                .logIn();

2. 分享使用，注意由于微信分享变更，分享时只要唤起微信客户端，无论是否真正分享，都会返回成功



  // 注意以下注册回调事件不注册则不会触发

        WxShareUtil.newInstance()

                .setSucceed(() -> {

                    // 分享过程回调成功

                })

                .setNoInstalled((() -> {

                    // 微信客户端未安装

                }))

                .setUserCancel(() -> {

                    // 用户取消，由于微信调整，用户取消状态不会触发

                })

                .setFail((errorCode, errStr) -> {

                    // 其他类型错误， errorCode为微信返回的错误码

                })

                //发起分享请求

                .shareTextMessage("内容", "标题", "描述", ShareType.WXSceneTimeline);

3. 支付使用



        // req.appId = json.getString("appid");

        // req.partnerId = json.getString("partnerid");

        // req.prepayId = json.getString("prepayid");

        // req.nonceStr = json.getString("noncestr");

        // req.timeStamp = json.getString("timestamp");

        // req.packageValue = json.getString("package");

        // req.sign = json.getString("sign");

        // 此json文本需要包含以上所需字段，或者使用实体方式，不列举

        // 注意以下注册回调事件不注册则不会触发

        WxPayUtil.newInstance()

                .setSucceed(() -> {

                    // sdk支付成功，向微信服务器查询下具体结果吧

                })

                .setNoInstalled((() -> {

                    // 微信客户端未安装

                }))

                .setUserCancel(() -> {

                    // 用户取消

                })

                .setFail((errorCode, errStr) -> {

                    // 其他类型错误， errorCode为微信返回的错误码

                })

                //发起分享请求

                .payWeChat("json文本");

五、测试说明

由于微信需要在后台配置签名信息，而测试时不能修改一次打包一次进行测试，所以配置项目的签名信息即可在debug模式下使用正式版签名信息。

android {

    signingConfigs {

        release {

            storeFile file('key文件位置，可写相对位置。默认是相对于app的文件夹下')

            storePassword 'key文件密码'

            keyAlias = '打包别名'

            keyPassword '别名密码'

        }

    }

    ...

    buildTypes {

        debug {

            signingConfig signingConfigs.release

        }

        release {

            minifyEnabled false

            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'

            signingConfig signingConfigs.release

        }

    }



}

代码下载:mjsoftking-wxlibraryapp-master.zip

ecorderManager

因为在项目中经常需要使用音视频录制，所以写了一个公共库RecorderManager，欢迎大家使用。

最新0.4.0-beta.3版本: 1.升级依赖 2.移除EasyPermissions和废弃方法，使用新API registerForActivityResult，请采用Java1.8以上版本 3.重构框架，优化代码 4.库调用做部分调整，详见下方文档说明 5.欢迎大家测试反馈完善功能

0.3.2版本:1.移除strings.xml中app_name 2.升级kotlin

0.3.1版本更新：详情见文档 1.新增最小录制时间设置RecordVideoOption.setMinDuration(//最小录制时长（秒数，最小是1，会自动调整不大于最大录制时长）) 2.优化代码

0.3-beta.2版本更新： 1.重构项目代码，kotlin改写部分功能 2.移除rxjava库，减少依赖 3.升级最新SDK 4.新增闪光灯功能，增加计时前提示文本设置 5.增加国际化支持，英文和中文 6.修复已知问题，优化代码 7.对外用户调用API改动较少，主要为内部调整，见下方文档，欢迎大家测试反馈完善功能

0.2.29版本更新： 1.新增圆形进度按钮配置功能 2.新增指定前后置摄像头功能 3.优化代码，调整启动视频录制配置项

0.2.28版本更新： 1.优化视频录制结果获取方式 2.优化代码

0.2.27版本更新： 1.视频录制界面RecordVideoRequestOption新增RecorderOption和hideFlipCameraButton配置 2.优化代码

0.2.26版本更新： 1.项目迁移至AndroidX， 引入Kotlin

0.2.25版本更新： 1.优化权限自动申请，可自动调起视频录制界面 2.规范图片资源命名

一.效果展示

仿微信界面视频录制

2.音频录制界面比较简单，就不放图了

二.引用

1.Add it in your root build.gradle at the end of repositories

allprojects {

		repositories {

			...

			maven { url 'https://jitpack.io' }

		}

	}

2.Add the dependency

dependencies {

	        implementation 'com.github.MingYueChunQiu:RecorderManager:0.3.2'

	}

三.使用

1.音频录制

采用默认配置录制

mRecorderManager.recordAudio(mFilePath);

自定义配置参数录制

mRecorderManager.recordAudio(new RecorderOption.Builder()

                    .setAudioSource(MediaRecorder.AudioSource.MIC)

                    .setOutputFormat(MediaRecorder.OutputFormat.MPEG_4)

                    .setAudioEncoder(MediaRecorder.AudioEncoder.AAC)

                    .setAudioSamplingRate(44100)

                    .setBitRate(96000)

                    .setFilePath(path)

                    .build());

2.视频录制

(1).可以直接使用RecordVideoActivity，实现了仿微信风格的录制界面

从0.2.18开始改为类似

RecorderManagerFactory.getRecordVideoRequest().startRecordVideo(MainActivity.this, 0);

从0.4.0-beta版本开始，因为采用registerForActivityResult，所以直接传入结果回调

      RecorderManagerProvider.getRecordVideoRequester().startRecordVideo(MainActivity.this, new RMRecordVideoResultCallback() {

            @Override

            public void onResponseRecordVideoResult(@NonNull RecordVideoResultInfo info) {

                Log.e("MainActivity", "onActivityResult: " + info.getDuration() + " " + info.getFilePath());

                Toast.makeText(MainActivity.this, info.getDuration() + " " + info.getFilePath(), Toast.LENGTH_SHORT).show();

            }



            @Override

            public void onFailure(@NonNull RecorderManagerException e) {

                Log.e("MainActivity", "onActivityResult: " + e.getErrorCode() + " " + e.getMessage());

            }

        });

从0.4.0-beta版本开始：RecorderManagerFactory重命名为RecorderManagerProvider RecorderManagerFactory中可以拿到IRecordVideoPageRequester，在IRecordVideoPageRequester接口中

/**

     * 以默认配置打开录制视频界面

     *

     * @param activity    Activity

     * @param requestCode 请求码

     */

    void startRecordVideo(@NonNull FragmentActivity activity, int requestCode);



    /**

     * 以默认配置打开录制视频界面

     *

     * @param fragment    Fragment

     * @param requestCode 请求码

     */

    void startRecordVideo(@NonNull Fragment fragment, int requestCode);



    /**

     * 打开录制视频界面

     *

     * @param activity    Activity

     * @param requestCode 请求码

     * @param option      视频录制请求配置信息类

     */

    void startRecordVideo(@NonNull FragmentActivity activity, int requestCode, @Nullable RecordVideoRequestOption option);



    /**

     * 打开录制视频界面

     *

     * @param fragment    Fragment

     * @param requestCode 请求码

     * @param option      视频录制请求配置信息类

     */

    void startRecordVideo(@NonNull Fragment fragment, int requestCode, @Nullable RecordVideoRequestOption option);

从0.4.0-beta版本开始：

public interface IRecordVideoPageRequester extends IRMRequester {



    /**

     * 以默认配置打开录制视频界面

     *

     * @param activity Activity

     * @param callback 视频录制结果回调

     */

    void startRecordVideo(@NonNull FragmentActivity activity, @NonNull RMRecordVideoResultCallback callback);



    /**

     * 以默认配置打开录制视频界面

     *

     * @param fragment Fragment

     * @param callback 视频录制结果回调

     */

    void startRecordVideo(@NonNull Fragment fragment, @NonNull RMRecordVideoResultCallback callback);



    /**

     * 打开录制视频界面

     *

     * @param activity Activity

     * @param option   视频录制请求配置信息类

     * @param callback 视频录制结果回调

     */

    void startRecordVideo(@NonNull FragmentActivity activity, @Nullable RecordVideoRequestOption option, @NonNull RMRecordVideoResultCallback callback);



    /**

     * 打开录制视频界面

     *

     * @param fragment Fragment

     * @param option   视频录制请求配置信息类

     * @param callback 视频录制结果回调

     */

    void startRecordVideo(@NonNull Fragment fragment, @Nullable RecordVideoRequestOption option, @NonNull RMRecordVideoResultCallback callback);

}

RecordVideoRequestOption可配置最大时长（秒）和文件保存路径

public class RecordVideoRequestOption implements Parcelable {



        private String filePath;//文件保存路径

        private int maxDuration;//最大录制时间（秒数）

        private RecordVideoOption recordVideoOption;//录制视频配置信息类（里面配置的filePath和maxDuration会覆盖外面的）

}

RecordVideoActivity里已经配置好了默认参数，可以直接使用，然后在onActivityResult里拿到视频路径的返回值 返回值为RecordVideoResultInfo

@Override

    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {

        super.onActivityResult(requestCode, resultCode, data);

        if (resultCode == Activity.RESULT_OK && requestCode == 0) {

        RecordVideoResultInfo info = data.getParcelableExtra(EXTRA_RECORD_VIDEO_RESULT_INFO);

	  

	//从0.2.28版本开始可以使用下面这种方式，更安全更灵活，兼容性强

	RecordVideoResultInfo info = RecorderManagerFactory.getRecordVideoResult(data);

	//从0.3版本开始

	RecordVideoResultInfo info = RecorderManagerFactory.getRecordVideoResultParser().parseRecordVideoResult(data);

	

	if (info != null) {

                Log.e("MainActivity", "onActivityResult: " + " "

                        + info.getDuration() + " " + info.getFilePath());

            }

        }

    }

从0.4.0-beta.1版本开始： 由于采用Android新API registerForActivityResult，所以startActivityForResult等相关方法皆已废弃，相关回调将直接通过RMRecordVideoResultCallback传递

interface RMRecordVideoResultCallback {



    fun onResponseRecordVideoResult(info: RecordVideoResultInfo)



    fun onFailure(e: RecorderManagerException)

}

    

    通过下列IRecordVideoPageRequester相关方法，调用时同时传入响应结果回调

    void startRecordVideo(@NonNull FragmentActivity activity, @NonNull RMRecordVideoResultCallback callback);

(2).如果想要界面一些控件的样式，可以继承RecordVideoActivity，里面提供了几个protected方法，可以拿到界面的一些控件

/**

     * 获取计时控件

     *

     * @return 返回计时AppCompatTextView

     */

    protected AppCompatTextView getTimingView() {

        return mRecordVideoFg == null ? null : mRecordVideoFg.getTimingView();

    }



    /**

     * 获取圆形进度按钮

     *

     * @return 返回进度CircleProgressButton

     */

    protected CircleProgressButton getCircleProgressButton() {

        return mRecordVideoFg == null ? null : mRecordVideoFg.getCircleProgressButton();

    }



	/**

     * 获取翻转摄像头控件

     *

     * @return 返回翻转摄像头AppCompatImageView

     */

    public AppCompatImageView getFlipCameraView() {

        return mRecordVideoFg == null ? null : mRecordVideoFg.getFlipCameraView();

    }



    /**

     * 获取播放控件

     *

     * @return 返回播放AppCompatImageView

     */

    protected AppCompatImageView getPlayView() {

        return mRecordVideoFg == null ? null : mRecordVideoFg.getPlayView();

    }



    /**

     * 获取取消控件

     *

     * @return 返回取消AppCompatImageView

     */

    protected AppCompatImageView getCancelView() {

        return mRecordVideoFg == null ? null : mRecordVideoFg.getCancelView();

    }



    /**

     * 获取确认控件

     *

     * @return 返回确认AppCompatImageView

     */

    protected AppCompatImageView getConfirmView() {

        return mRecordVideoFg == null ? null : mRecordVideoFg.getConfirmView();

    }



    /**

     * 获取返回控件

     *

     * @return 返回返回AppCompatImageView

     */

    protected AppCompatImageView getBackView() {

        return mRecordVideoFg == null ? null : mRecordVideoFg.getBackView();

    }

想要替换图标资源的话，提供下列名称图片

rm_record_video_flip_camera.png

rm_record_video_cancel.png

rm_record_video_confirm.png

rm_record_video_play.png

rm_record_video_pull_down.png

rm_record_video_flashlight_turn_off.png

rm_record_video_flashlight_turn_on.png

(3).同时提供了对应的RecordVideoFragment，实现与RecordVideoActivity同样的功能，实际RecordVideoActivity就是包裹了一个RecordVideoFragment

1.创建RecordVideoFragment

/**

     * 获取录制视频Fragment实例（使用默认配置项）

     *

     * @param filePath 存储文件路径

     * @return 返回RecordVideoFragment

     */

    public static RecordVideoFragment newInstance(@Nullable String filePath) {

        return newInstance(filePath, 30);

    }



    /**

     * 获取录制视频Fragment实例（使用默认配置项）

     *

     * @param filePath    存储文件路径

     * @param maxDuration 最大时长（秒数）

     * @return 返回RecordVideoFragment

     */

    public static RecordVideoFragment newInstance(@Nullable String filePath, int maxDuration) {

        return newInstance(new RecordVideoOption.Builder()

                .setRecorderOption(new RecorderOption.Builder().buildDefaultVideoBean(filePath))

                .setMaxDuration(maxDuration)

                .build());

    }



    /**

     * 获取录制视频Fragment实例

     *

     * @param option 录制配置信息对象

     * @return 返回RecordVideoFragment

     */

    public static RecordVideoFragment newInstance(@Nullable RecordVideoOption option) {

        RecordVideoFragment fragment = new RecordVideoFragment();

        Bundle args = new Bundle();

        args.putParcelable(BUNDLE_EXTRA_RECORD_VIDEO_OPTION, option == null ? new RecordVideoOption() : option);

        fragment.setArguments(args);

        return fragment;

    }

2.然后添加RecordVideoFragment到自己想要的地方就可以了 3.可以设置OnRecordVideoListener，拿到各个事件的回调

public class RecordVideoOption：



	private RecorderOption recorderOption;//录制配置信息

        private RecordVideoButtonOption recordVideoButtonOption;//录制视频按钮配置信息类

	private int minDuration;//最小录制时长（秒数，最小是1，会自动调整不大于最大录制时长），可以和timingHint配合使用

        private int maxDuration;//最大录制时间（秒数）

        private RecorderManagerConstants.CameraType cameraType;//摄像头类型

        private boolean hideFlipCameraButton;//隐藏返回翻转摄像头按钮

        private boolean hideFlashlightButton;//隐藏闪光灯按钮

        private String timingHint;//录制按钮上方提示语句（默认：0:%s）,会在计时前显示

        private String errorToastMsg;//录制发生错误Toast（默认：录制时间小于1秒，请重试）

原OnRecordVideoListener现已改为RMOnRecordVideoListener，并从RecordVideoOption中移除，主要用于用户自己activity或fragment实现此接口，用于承载RecordVideoFragment，获取相关步骤回调

interface RMOnRecordVideoListener {



    /**

     * 当完成一次录制时回调

     *

     * @param filePath      视频文件路径

     * @param videoDuration 视频时长（毫秒）

     */

    fun onCompleteRecordVideo(filePath: String?, videoDuration: Int)



    /**

     * 当点击确认录制结果按钮时回调

     *

     * @param filePath      视频文件路径

     * @param videoDuration 视频时长（毫秒）

     */

    fun onClickConfirm(filePath: String?, videoDuration: Int)



    /**

     * 当点击取消按钮时回调

     *

     * @param filePath      视频文件路径

     * @param videoDuration 视频时长（毫秒）

     */

    fun onClickCancel(filePath: String?, videoDuration: Int)



    /**

     * 当点击返回按钮时回调

     */

    fun onClickBack()

}

4.RecordVideoButtonOption是圆形进度按钮配置类

	private @ColorInt

        int idleCircleColor;//空闲状态内部圆形颜色

        private @ColorInt

        int pressedCircleColor;//按下状态内部圆形颜色

        private @ColorInt

        int releasedCircleColor;//释放状态内部圆形颜色

        private @ColorInt

        int idleRingColor;//空闲状态外部圆环颜色

        private @ColorInt

        int pressedRingColor;//按下状态外部圆环颜色

        private @ColorInt

        int releasedRingColor;//释放状态外部圆环颜色

        private int idleRingWidth;//空闲状态外部圆环宽度

        private int pressedRingWidth;//按下状态外部圆环宽度

        private int releasedRingWidth;//释放状态外部圆环宽度

        private int idleInnerPadding;//空闲状态外部圆环与内部圆形之间边距

        private int pressedInnerPadding;//按下状态外部圆环与内部圆形之间边距

        private int releasedInnerPadding;//释放状态外部圆环与内部圆形之间边距

        private boolean idleRingVisible;//空闲状态下外部圆环是否可见

        private boolean pressedRingVisible;//按下状态下外部圆环是否可见

        private boolean releasedRingVisible;//释放状态下外部圆环是否可见

5.RecorderOption是具体的录制参数配置类

	private int audioSource;//音频源

        private int videoSource;//视频源

        private int outputFormat;//输出格式

        private int audioEncoder;//音频编码格式

        private int videoEncoder;//视频编码格式

        private int audioSamplingRate;//音频采样频率（一般44100）

        private int bitRate;//视频编码比特率

        private int frameRate;//视频帧率

        private int videoWidth, videoHeight;//视频宽高

        private int maxDuration;//最大时长

        private long maxFileSize;//文件最大大小

        private String filePath;//文件存储路径

        private int orientationHint;//视频录制角度方向

(4).如果想自定义自己的界面，可以直接使用RecorderManagerable类

1.通过RecorderManagerFactory获取IRecorderManager 从0.4.0-beta版本开始：RecorderManagerFactory重命名为RecorderManagerProvider

public class RecorderManagerFactory {



    private RecorderManagerFactory() {

    }



    /**

     * 创建录制管理类实例（使用默认录制类）

     *

     * @return 返回录制管理类实例

     */

    @NonNull

    public static IRecorderManager newInstance() {

        return newInstance(new RecorderHelper());

    }



    /**

     * 创建录制管理类实例（使用默认录制类）

     *

     * @param intercept 录制管理器拦截器

     * @return 返回录制管理类实例

     */

    @NonNull

    public static IRecorderManager newInstance(@NonNull IRecorderManagerInterceptor intercept) {

        return newInstance(new RecorderHelper(), intercept);

    }



    /**

     * 创建录制管理类实例

     *

     * @param helper 实际录制类

     * @return 返回录制管理类实例

     */

    @NonNull

    public static IRecorderManager newInstance(@NonNull IRecorderHelper helper) {

        return newInstance(helper, null);

    }



    /**

     * 创建录制管理类实例

     *

     * @param helper    实际录制类

     * @param intercept 录制管理器拦截器

     * @return 返回录制管理类实例

     */

    @NonNull

    public static IRecorderManager newInstance(@NonNull IRecorderHelper helper, @Nullable IRecorderManagerInterceptor intercept) {

        return new RecorderManager(helper, intercept);

    }



    @NonNull

    public static IRecordVideoRequest getRecordVideoRequest() {

        return new RecordVideoPageRequest();

    }



    //0.3之后版本通过解析器来进行处理数据

    @NonNull

    public static IRecordVideoResultParser getRecordVideoResultParser() {

        return new RecordVideoResultParser();

    }

}

它们返回的都是IRecorderManager 接口类型，RecorderManager 是默认的实现类，RecorderManager 内持有一个真正进行操作的RecorderHelper。

public interface IRecorderManager extends IRecorderHelper {



    /**

     * 设置录制对象

     *

     * @param helper 录制对象实例

     */

    void setRecorderHelper(@NonNull IRecorderHelper helper);



    /**

     * 获取录制对象

     *

     * @return 返回录制对象实例

     */

    @NonNull

    IRecorderHelper getRecorderHelper();



    /**

     * 初始化相机对象

     *

     * @param holder Surface持有者

     * @return 返回初始化好的相机对象

     */

    @Nullable

    Camera initCamera(@NonNull SurfaceHolder holder);



    /**

     * 初始化相机对象

     *

     * @param cameraType 指定的摄像头类型

     * @param holder     Surface持有者

     * @return 返回初始化好的相机对象

     */

    @Nullable

    Camera initCamera(@NonNull RecorderManagerConstants.CameraType cameraType, @NonNull SurfaceHolder holder);



    /**

     * 打开或关闭闪光灯

     *

     * @param turnOn true表示打开，false关闭

     */

    boolean switchFlashlight(boolean turnOn);



    /**

     * 翻转摄像头

     *

     * @param holder Surface持有者

     * @return 返回翻转并初始化好的相机对象

     */

    @Nullable

    Camera flipCamera(@NonNull SurfaceHolder holder);



    /**

     * 翻转到指定类型摄像头

     *

     * @param cameraType 摄像头类型

     * @param holder     Surface持有者

     * @return 返回翻转并初始化好的相机对象

     */

    @Nullable

    Camera flipCamera(@NonNull RecorderManagerConstants.CameraType cameraType, @NonNull SurfaceHolder holder);



    /**

     * 获取当前摄像头类型

     *

     * @return 返回摄像头类型

     */

    @NonNull

    RecorderManagerConstants.CameraType getCameraType();



    /**

     * 释放相机资源

     */

    void releaseCamera();



}

RecorderManagerIntercept实现IRecorderManagerInterceptor接口，用户可以直接继承RecorderManagerIntercept，它里面所有方法都是空实现，可以自己改写需要的方法

public interface or extends ICameraInterceptor {}

public interface IRecorderHelper {



    /**

     * 录制音频

     *

     * @param path 文件存储路径

     * @return 返回是否成功开启录制，成功返回true，否则返回false

     */

    boolean recordAudio(@NonNull String path);



    /**

     * 录制音频

     *

     * @param option 存储录制信息的对象

     * @return 返回是否成功开启录制，成功返回true，否则返回false

     */

    boolean recordAudio(@NonNull RecorderOption option);



    /**

     * 录制视频

     *

     * @param camera  相机

     * @param surface 表面视图

     * @param path    文件存储路径

     * @return 返回是否成功开启录制，成功返回true，否则返回false

     */

    boolean recordVideo(@Nullable Camera camera, @Nullable Surface surface, @Nullable String path);



    /**

     * 录制视频

     *

     * @param camera  相机

     * @param surface 表面视图

     * @param option  存储录制信息的对象

     * @return 返回是否成功开启视频录制，成功返回true，否则返回false

     */

    boolean recordVideo(@Nullable Camera camera, @Nullable Surface surface, @Nullable RecorderOption option);



    /**

     * 释放资源

     */

    void release();



    /**

     * 获取录制器

     *

     * @return 返回实例对象

     */

    @NonNull

    MediaRecorder getMediaRecorder();



    /**

     * 获取配置信息对象

     *

     * @return 返回实例对象

     */

    @Nullable

    RecorderOption getRecorderOption();

}

		if (mCamera == null) {

            mCamera = mManager.initCamera(mCameraType, svVideoRef.get().getHolder());

            mCameraType = mManager.getCameraType();

        }

isRecording = mManager.recordVideo(mCamera, svVideoRef.get().getHolder().getSurface(), mOption.getRecorderOption());

	    mManager.release();

            mManager = null;

            mCamera = null;

MXVideo

介绍

基于饺子播放器、kotlin编写的 Android 开源播放器, 开箱即用，欢迎提 issue 和 pull request 最新版本：

功能特性

• 任意播放器内核（包含开源IJK、谷歌Exo、阿里云等等）
• 单例播放，只能同时播放一个节目
• 0代码集成全屏功能
• 可以调节音量、屏幕亮度
• 可以注册播放状态监听回调
• 播放器高度可以根据视频高度自动调节
• 播放器支持设置宽高比，设置宽高比后，高度固定。
• 自动保存与恢复播放进度（可关闭）
• 支持循环播放、全屏时竖屏模式、可关闭快进快退功能、可关闭全屏功能、可关闭非WiFi环境下流量提醒

1、通过 dependence 引入MXVideo

    dependencies {

	        implementation 'com.gitee.zhangmengxiong:MXVideo:x.x.x'

    }

2、页面集成

        

            android:id="@+id/mxVideoStd"

            android:layout_width="match_parent"

            android:layout_height="wrap_content" />

3、开始播放

// 设置播放占位图
Glide.with(this).load("http://www.xxx.com/xxx.png").into(mxVideoStd.getPosterImageView())

// 默认从上一次进度播放
mxVideoStd.setSource(MXPlaySource(Uri.parse("https://aaa.bbb.com/xxx.mp4"), "标题1"))
mxVideoStd.startPlay()

// 从头开始播放
mxVideoStd.setSource(MXPlaySource(Uri.parse("https://aaa.bbb.com/xxx.mp4"), "标题1"), seekTo = 0)
mxVideoStd.startPlay()

// 从第10秒开始播放
mxVideoStd.setSource(MXPlaySource(Uri.parse("https://aaa.bbb.com/xxx.mp4"), "标题1"), seekTo = 10)
mxVideoStd.startPlay()

MXPlaySource 可选参数说明：

参数	说明	默认值
title	标题	""
headerMap	网络请求头部	null
changeOrientationWhenFullScreen	全屏时是否需要变更Activity方向，如果 = null，会自动根据视频宽高来判断	null
isLooping	是否循环播放	false
enableSaveProgress	是否存储、读取播放进度	true
isLiveSource	是否直播源，当时直播时，不显示进度，无法快进快退暂停	false

4、监听播放进度

mxVideoStd.addOnVideoListener(object : MXVideoListener() {

            // 播放状态变更

            override fun onStateChange(state: MXState) {

            }



            // 播放时间变更

            override fun onPlayTicket(position: Int, duration: Int) {

            }

        })

5、全屏返回 + 释放资源

这里MXVideo默认持有当前播放的MXVideoStd，可以使用静态方法操作退出全屏、释放资源等功能。

也可以直接使用viewId：mxVideoStd.isFullScreen()，mxVideoStd.isFullScreen()，mxVideoStd.release() 等方法。

    override fun onBackPressed() {

        if (MXVideo.isFullScreen()) {

            MXVideo.gotoNormalScreen()

            return

        }

        super.onBackPressed()

    }



    override fun onDestroy() {

        MXVideo.releaseAll()

        super.onDestroy()

    }

功能相关

• 切换播放器内核

// 默认MediaPlayer播放器，库默认内置

com.mx.video.player.MXSystemPlayer



// 谷歌的Exo播放器

com.mx.mxvideo_demo.player.MXExoPlayer



// IJK播放器

com.mx.mxvideo_demo.player.MXIJKPlayer



// 设置播放源是可以设置内核，默认 = MXSystemPlayer

mxVideoStd.setSource(MXPlaySource(Uri.parse("xxx"), "xxx"), player = MXSystemPlayer::class.java)

• 视频渲染旋转角度

// 默认旋转角度 = MXOrientation.DEGREE_0

mxVideoStd.setOrientation(MXOrientation.DEGREE_90)

• 视频填充规则

// 强制填充宽高 MXScale.FILL_PARENT

// 根据视频大小，自适应宽高 MXScale.CENTER_CROP



// 默认填充规则 = MXScale.CENTER_CROP

mxVideoStd.setScaleType(MXScale.CENTER_CROP)

• MXVideoStd 控件宽高约束

在页面xml中添加，layout_width一般设置match_parent，高度wrap_content

    

        android:id="@+id/mxVideoStd"

        android:layout_width="match_parent"

        android:layout_height="wrap_content" />

可以设置任意宽高比，如果设置宽高比，则控件高度需要设置android:layout_height="wrap_content"，否则不生效。

当取消约束、MXVideo高度自适应、填充规则=MXScale.CENTER_CROP时，控件高度会自动根据视频宽高自动填充高度

// MXVideoStd控件设置宽高比= 16：9

mxVideoStd.setDimensionRatio(16.0 / 9.0)



// MXVideoStd控件设置宽高比= 4：3

mxVideoStd.setDimensionRatio(4.0 / 3.0)



// 取消约束

mxVideoStd.setDimensionRatio(0.0)

• 进度跳转

// 进度单位：秒  可以在启动播放后、错误或播完之前调用

mxVideoStd.seekTo(55)

• 设置不能快进快退

// 播放前设置 默认=true

mxVideoStd.getConfig().canSeekByUser = false

• 设置不能全屏

// 播放前设置 默认=true

mxVideoStd.getConfig().canFullScreen = false

• 设置不显示控件右上角时间

// 播放前设置 默认=true

mxVideoStd.getConfig().canShowSystemTime = false

• 设置不显示控件右上角电量图

// 播放前设置 默认=true

mxVideoStd.getConfig().canShowBatteryImg = false

• 设置关闭WiFi环境播放前提醒

// 播放前设置 默认=true

mxVideoStd.getConfig().showTipIfNotWifi = false

• 设置播放完成后自动退出全屏

// 播放前设置 默认=true

mxVideoStd.getConfig().gotoNormalScreenWhenComplete = true

• 设置播放错误后自动退出全屏

// 播放前设置 默认=true

mxVideoStd.getConfig().gotoNormalScreenWhenError = true

• 设置屏幕方向根据重力感应自动进入全屏、小屏模式

// 播放前设置 默认=false

mxVideoStd.getConfig().autoRotateBySensor = true

代码下载:zhangmengxiong-MXVideo-master.zip

由于最近微信大佬发飙，罚了红包外挂5000万大洋，这就让人很慌了，别说罚我5000万，5000块我都吃不消。所以笔者决定以后不用微信做例子了。换成优酷了😈。

本文会对优酷的设置页面增加一个开启/关闭屏蔽广告的Cell(仅UI)。效果可见下文配图。

在之前的几篇文章里已经介绍了APP重签名，代码注入，Hook原理，可以发现，将工程建好，脚本写好，我们就可以以代价非常小的方式对一个第三方的APP进行分析。
那么是否一种工具，可以将重签名，代码注入，Hook源代码，class-dump，Cydia Substrate，甚至是恢复符号表这些功能，集成在一个工程里面，让真正的逆向小白也能享受逆向的乐趣呢？
答案是肯定的，Monkey就是这样的一个非越狱插件开发集成神器！

老规矩，片头先上福利：点击下载demo。
这篇文章会用到的工具有：

1、MonkeyDev
2、博主自己砸壳的优酷ipa包 提取码: xtua
3、砸壳后的SimpleAppDemo.ipa 提取码: afnc

一、Monkey

什么是Monkey？
原有iOSOpenDev的升级，非越狱插件开发集成神器！

可以使用Xcode开发CaptainHook Tweak、Logos Tweak 和 Command-line Tool，在越狱机器开发插件，这是原来iOSOpenDev功能的迁移和改进。

1、只需拖入一个砸壳应用，自动集成class-dump、restore-symbol、* Reveal、Cycript和注入的动态库并重签名安装到非越狱机器。
2、支持调试自己编写的动态库和第三方App
3、支持通过CocoaPods第三方应用集成SDK以及非越狱插件，简单来说就是通过CocoaPods搭建了一个非越狱插件商店。

环境要求

使用工具前确保如下几点:

1、安装最新的theos

sudo git clone --recursive https://github.com/theos/theos.git /opt/theos

2、安装ldid(如安装theos过程安装了ldid，跳过)

brew install ldid

安装

你可以通过以下命令选择指定的Xcode进行安装:

sudo xcode-select -s /Applications/Xcode-beta.app

默认安装的Xcode为:

xcode-select -p

执行安装命令:

sudo /bin/sh -c "$(curl -fsSL https://raw.githubusercontent.com/AloneMonkey/MonkeyDev/master/bin/md-install)"

卸载

sudo /bin/sh -c "$(curl -fsSL https://raw.githubusercontent.com/AloneMonkey/MonkeyDev/master/bin/md-uninstall)"

更新
如果没有发布特殊说明，使用如下命令更新即可:

sudo /bin/sh -c "$(curl -fsSL https://raw.githubusercontent.com/AloneMonkey/MonkeyDev/master/bin/md-update)"

安装/更新之后重启下Xcode再新建项目。如果看到如下选项，即代表安装成功，如果没有，重复上面步骤再来一遍。

二、Logos

Logos是Thoes开发的一套组件，可非常方便用于的Hook OC代码。

接下来我们就介绍下Logos的简单用法，最后运用Monkey和Logos给优酷增加一点UI。

1、创建一个简单的工程
创建工程SimpleAppDemo，里面只有一个按钮，点击按钮弹出一个Alert。 点击下载：SimpleAppDemo
按钮对应的方法为：

- (IBAction)tapAction:(id)sender {
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"来啦" message:@"老弟😁😁😁" delegate:nil cancelButtonTitle:@"我知道了" otherButtonTitles:nil, nil];
    [alert show];
}

2、砸壳
对SimpleAppDemo参数的ipa文件进行砸壳，砸壳过程就不在这详细描述了，这里有笔者已经砸壳好的ipa：SimpleAppDemo.ipa 提取码: afnc

3、新建一个Monkey工程
取名LogosDemo，将下面下载好的SimpleAppDemo.ipa，放到工程对应的目录下：

配好证书（随意一个能在手机上运行的证书即可），Run。运行成功~

4、玩转Logos
在上一步建好的Monkey工程中，可以发现在目录有一个Logos目录：

默认有两个文件LogosDemoDylib.xm和LogosDemoDylib.mm。
其中Logos语句就是写在LogosDemoDylib.xm中的，LogosDemoDylib.mm是根据LogosDemoDylib.xm中的内容自动生成的。
接下来，咱们根据几个需求来介绍Logos的一些常用的用法。

1、更改点击按钮的弹框内容（hook）
由于需要更改弹窗，所以首先导入UIKit框架。

#import <UIKit/UIKit.h>

由于咱们手上有源码，所以可以直接跳过动态分析的这一步，直接就知道按钮所处的页面是叫做ViewController，按钮的响应方法是：

- (IBAction)tapAction:(id)sender

利用hook命令：

#import <UIKit/UIKit.h>

// hook + 类名
%hook ViewController
// IBAction == void
- (void)tapAction:(id)sender {
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"来什么来" message:@"😡😡😡" delegate:nil cancelButtonTitle:@"我知道了" otherButtonTitles:nil, nil];
    [alert show];
}

%end

运行项目，发现按钮已经被成功hook了。

2、调用原方法（orig）

#import <UIKit/UIKit.h>

%hook ViewController

- (void)tapAction:(id)sender {
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"来什么来" message:@"😡😡😡" delegate:nil cancelButtonTitle:@"我知道了" otherButtonTitles:nil, nil];
    [alert show];
    // 调用原方法
    %orig;
}

%end

3、新增一个方法，并且调用（new）

由于在Monkey工程里面是编译不到源码的，所以无论是新增的方法，还是调用原工程中的方法，都是无法通过编译的，所以都需要使用interface申明每一个方法。

#import <UIKit/UIKit.h>

// 这里只是为了申明
@interface ViewController

- (void)newFunC;

@end

%hook ViewController

// 新增方法关键字new
%new
- (void)newFunC{
    NSLog(@"newFunC");
}

// IBAction == void
- (void)tapAction:(id)sender {
    UIAlertView *alert = [[UIAlertView alloc] initWithTitle:@"来什么来" message:@"😡😡😡" delegate:nil cancelButtonTitle:@"我知道了" otherButtonTitles:nil, nil];
    [alert show];
    [self newFunC];
    // 调用原方法关键字orig
    %orig;
}

%end

文中所有的Demo都在这可以下载到:Dmoe

Logos除了以上hook,end,orig,new这几种关键字，还有：
%subclass：增加一个类
%log：打印，类似NSLog
%group： 给代码分组，可以用于在不同环境加载不同的代码，比如iOS8加载group1,iOS9加载group2，如果部分中，默认所有代码在名为「_ungrouped」的隐藏分组中。
...

所有的Logos语法都可以在官方文档中查询得到。

5、给优酷加UI

首先在这里下载笔者自己砸壳后优酷ipa包(arm64架构的)：优酷(砸壳).ipa 提取码: xtua

Step 1、新建工程YouKu

同样的新建一个Monkey工程，取名YouKu，将下载好的ipa包放入工程对应的TargetApp目录下。Run。同样是重签名成功。

在上面的Demo中，我们是对我们直接的工程进行HOOK，由于我们手上有源码，所以我们越过了最难的一个步骤：动态分析。
而我们现在要对优酷进行Hook，但我们手上是没有优酷的源码的，所以此时此刻就需要对其进行动态分析了。
下面我将结合Xcode和class dump对优酷的设置页面简单的进行分析。

Step 2、class dump

class-dump is a command-line utility for examining the Objective-C segment of Mach-O files. It generates declarations for the classes, categories and protocols. This is the same information provided by using 'otool -ov', but presented as normal Objective-C declarations.
简单说就是一个可以导出一个MachO文件的所有头文件信息（包括Extension）

在文首有提到Monkey除了重签名，还集成了class dump的功能,所以我们需要做的就仅仅是开启这个功能：

Run！成功之后可以发现在工程目录下多了一个文件夹Youkui4Phone_Headers，其中就是优酷的所有的头文件了。

Step 3、分析优酷设置页面

工程Run成功后，点击进入设置页面（不用登录），如下图：

我们现在要做的就是在这个页面的TableView的最后一行加上Cell，里面有个Switch，用于打开/关闭屏蔽广告功能(只是UI，这篇文章不牵扯到屏蔽广告的具体实现，如果你需要，点个小心心，持续关注我哦😀😀😀)。

利用伟大的Xcode我们可以非常清晰的看到，设置页面的DataSource和Delegate都是在SettingViewController中，

咱们就找到Hook的类名：SettingViewController
需要Hook的方法自然就是TableView的那些DataSource和Delegate了。

这里需要额外提到的一点是，在文章开始的时候就说了Monkey已经将Cydia Substrate集成进去了，所以我们可以直接使用Cydia Substrate的相关功能了。

在这里我们需要拿到这个页面TableView的对应的变量，我们就需要使用到Cydia Substrate的功能了。打开上文中获取到优酷的所有的头文件，所有SettingViewController，发现其只有一个TableView变量:_tabview。
那么毫无疑问，就是他了！
而获取它的方法是：

MSHookIvar <UITableView *>(self,"_tabview")

一个reloadData的简单使用:

[MSHookIvar <UITableView *>(self,"_tabview") reloadData];

其他的UI代码在这里就不一一解释了，全部代码如下，当然在Demo中也是有的，其中包括了数据的简单持久化功能：

#import <UIKit/UIKit.h>
#define FYDefaults  [NSUserDefaults standardUserDefaults]
#define FYSwitchUserDefaultsKey @"FYSwitchUserDefaultsKey"

@interface SettingViewController
- (long long)numberOfSectionsInTableView:(id)arg1;
@end

%hook SettingViewController

%new
-(void)switchChangeAction:(UISwitch *)switchView{
    [FYDefaults setBool:switchView.isOn forKey:FYSwitchUserDefaultsKey];
    [FYDefaults synchronize];
    [MSHookIvar <UITableView *>(self,"_tabview") reloadData];
}

//多少组
- (long long)numberOfSectionsInTableView:(id)arg1{
    UITableView * tableView = MSHookIvar <UITableView *>(self,"_tabview");
    NSLog(@"fy_numberOfSectionsInTableView:");
    // 额外增加一个
    return %orig+1;
}

//每组多少行
- (long long)tableView:(UITableView *)tableView numberOfRowsInSection:(long long)section{
    NSLog(@"fy_numberOfRowsInSection:");
    //定位设置界面,并且是最后一个
    if(section == [self numberOfSectionsInTableView:tableView]-1){
        return 1;
    }
    else{
        return %orig;
    }
}

//返回高度
- (double)tableView:
(UITableView *)tableView heightForRowAtIndexPath:(id)indexPath{
    NSLog(@"fy_heightForRowAtIndexPath:");
    //定位设置界面,并且是最后一个
    if([indexPath section] ==[self numberOfSectionsInTableView:tableView]-1){
        return 44;
    }
    else{
        return %orig;
    }
}


//每一个Cell
- (id)tableView:(UITableView *)tableView cellForRowAtIndexPath:(id)indexPath{
    NSLog(@"fy_cellForRowAtIndexPath:");
    //定位设置界面,并且是最后一组
    if([indexPath section] == [self numberOfSectionsInTableView:tableView]-1){
        UITableViewCell * cell = nil;
        if([indexPath row] == 0){
            static NSString *swCell = @"SwCellIdentifier";
            cell = [tableView dequeueReusableCellWithIdentifier:swCell];
            if(!cell){
                cell = [[UITableViewCell alloc] initWithStyle:(UITableViewCellStyleDefault) reuseIdentifier:nil];
            }
            cell.textLabel.text = @"免广告";
            // 免广告开关
            UISwitch *switchView = [[UISwitch alloc] init];
            switchView.on = [FYDefaults boolForKey:FYSwitchUserDefaultsKey];
            [switchView addTarget:self action:@selector(switchChangeAction:) forControlEvents:(UIControlEventValueChanged)];
            cell.accessoryView = switchView;
            cell.imageView.image = [UIImage imageNamed:([FYDefaults boolForKey:FYSwitchUserDefaultsKey] == 1) ? @"unlocked" : @"locked"];
        }
        cell.backgroundColor = [UIColor whiteColor];
        return cell;
        
    }else{
        return %orig;
    }
}

%end

最后的效果

6、为什么Monkey这么牛逼

查看重新编译后的app文件，可以发现其中的Framework多了很多东西：

从这可以得知，原来Monkey其实也是通过将诸多的动态库（包括自己的工程）注入的形式，实现了这些功能。

三、总结

在这片文章中主要介绍了Monkey的一些用法已经Logos的基本语法。而在上一篇其实留了一个小尾巴，就是Cycript，笔者将要在下一篇文章中重点讲解Cycript的安装，基础用法和高级用法。之所以放在下一篇，是因为Cycript配合Monkey将会有事半功倍的效果。

链接：https://www.jianshu.com/p/da6cb32a1416

TYAttributedLabel

1、TYAttributedLabel 简单，强大的属性文本控件(无需了解CoreText)
2、支持富文本，图文混排显示，支持行间距，字间距，自适应高度，指定行数
3、支持添加高度自定义文本属性
4、支持添加属性文本，自定义链接，新增高亮效果显示（文字和背景）
5、支持添加UIImage和UIView控件

demo演示

重点类简介

TYAttributedLabel

创建label（可接受文本及富文本）
设置字体间距
设置行间距
设置字体大小
设置view的位置和宽，会自动计算高度
设置链接文本，并用代理（TYAttributedLabelDelegate）方法完成点击后需完成的任务

TYImageStorage

可创建一个append在TYAttributedLabel后的图片控件，可自定义图片大小，及对齐样式

TYTextStorage

文本文件，可设置文本大小及字体颜色

TYTextContainer

属性文本生成器（使用 RegexKitLite）
具体代码及使用细节请看作者的demo（作者是华人），讲的很详细，这里就不再赘述

链接：TYAttributedLabel

链接：https://www.jianshu.com/p/5d81bf7e79c8

某天闲着无聊想练一下手速，去上拉一个小程序项目中一个有1万多条商品数据的列表。在数据加载到1000多条后，是列表居然出现了白屏。看了一下控制台：

‘Dom limit exceeded’，dom数超出了限制， 不知道微信是出于什么考虑，要限制页面的dom数量。

一.小程序页面限制多少个wxml节点？

写了个小dome做了个测试。 listData的数据结构为：

listData:[
   {
    isDisplay:true,
    itemList:[{
          qus:'下面哪位是刘发财女朋友?',
          answerA:'刘亦菲',
          answerB:'迪丽热巴',
          answerC:'斋藤飞鸟',
          answerD:'花泽香菜',
       }
      .......//20条数据
     ]
   }]

页面渲染效果：

     
         {{item.qus}}
         
              A. {{item.answerA}}
              B. {{item.answerB}}
              C. {{item.answerC}}
              D. {{item.answerD}}
         
           

2.dome2，删除了不必要的dom嵌套

     
         {{item.qus}}
         
              A. {{item.answerA}}
              B. {{item.answerB}}
              C. {{item.answerC}}
              D. {{item.answerD}}
         
           

通过大致计算，一个小程序页面大概可以渲染2万个wxml节点 而小程序官方的性能测评得分条件为少于1000个wxml节点官方链接

二.列表页面优化

newList=[{...},{...}];
   this.setData({
     listData:[...this.data.listData,...newList]
   })

let index=0;
  this.setData({
     [`listData[${index}].isDisplay`]:false,
  })

for(let index=0;index<10;index++){
     this.setData({
        [`listData[${index}].isDisplay`]:false,
     })
  }

let changeData={};
  for(let index=0;index<10;index++){
      changeData[[`listData[${index}].isDisplay`]]=false;
  }
  this.setData(changeData);

这样我们就把数组listData中下标从0到9的元素的isDisplay属性改成了false。

• setDate往数组末尾添加数据

如果只添加一条数据

let newData={...};
  this.setData({
    [`listData[${this.data.listData.length}]`]:newData
  })

如果是添加多条数据

let newData=[{...},{...},{...},{...},{...},{...}];
  let changeData={};
  let index=this.data.listData.length
    newData.forEach((item) => {
        changeData['listData[' + (index++) + ']'] = item //赋值，索引递增
    }) 
  this.setData(changeData)

三.使用自定义组件

可以把列表的一行或者多行封装到自定义组件里，在列表页使用一个组件，只算一个节点，这样你的列表能渲染的数据可以成倍数的增加。组件内的节点数也是有限制的，但是你可以一层层嵌套组件实现列表的无限加载，如果你不怕麻烦的话

四.使用虚拟列表

经过上面的一系列操作后，列表的性能会得到很大的提升，但是如果数据量实在太大，wxml节点数也会超出限制，导致页面发生错误。我们的处理方法是使用虚拟列表，页面只渲染当前可视区域以及可视区域上下若干条数据的节点，通过isDisplay控制节点的渲染。

• 可视区域上方：above
• 可视区域：screen
• 可视区域下方：below

listData:[
   {
    isDisplay:true,
    itemList:[{
          qus:'下面哪位是刘发财女朋友?',
          answerA:'刘亦菲',
          answerB:'迪丽热巴',
          answerC:'斋藤飞鸟',
          answerD:'花泽香菜',
       }
      .......//二维数组中的条数根据项目实际情况
     ]
   }]

data{
       itemHeight:4520,//列表第一层dom高度，单位为rpx
       itemPxHeight:'',//转化为px高度,因为小程序获取的滚动条高度单位为px
       aboveShowIndex:0,//已渲染数据的第一条的Index
       belowShowNum:0,//显示区域下方隐藏的条数
       oldSrollTop:0,//记录上一次滚动的滚动条高度，判断滚动方向
       prepareNum:5,//可视区域上下方要渲染的数量
       throttleTime:200，//滚动事件节流的时间，单位ms
   }

3.wxml的dom结构

     
   
    
        
           {{item.qus}}
           
                A. {{item.answerA}}
                B. {{item.answerB}}
                C. {{item.answerC}}
                D. {{item.answerD}}
           
           
    
    
     

4.获取列表第一层dom的px高度

let query = wx.createSelectorQuery();
  query.select('.content').boundingClientRect(rect=>{
    let clientWidth = rect.width;
    let ratio = 750 / clientWidth;
    this.setData({
      itemPxHeight:Math.floor(this.data.itemHeight/ratio),
     })
   }).exec();

5.页面滚动时间节流

function throttle(fn){
  let valid = true
  return function() {
     if(!valid){
         return false 
     }
     // 工作时间，执行函数并且在间隔期内把状态位设为无效
      valid = false
      setTimeout(() => {
          fn.call(this,arguments);
          valid = true;
      }, this.data.throttleTime)
  }
}

6.页面滚动事件处理

onPageScroll:throttle(function(e){
    let scrollTop=e[0].scrollTop;//滚动条高度
    let itemNum=Math.floor(scrollTop/this.data.itemPxHeight);//计算出可视区域的数据Index
    let clearindex=itemNum-this.data.prepareNum+1;//滑动后需要渲染数据第一条的index
    let oldSrollTop=this.data.oldSrollTop;//滚动前的scrotop,用于判断滚动的方向
    let aboveShowIndex=this.data.aboveShowIndex；//获取已渲染数据第一条的index
    let listDataLen=this.data.listData.length;
    let changeData={}
  //向下滚动
    if(scrollTop-oldSrollTop>0){
        if(clearindex>0){
         //滚动后需要变更的条数
          for(let i=aboveShowIndex;i                changeData[[`listData[${i}].isDisplay`]]=false;
                let belowShowIndex=i+2*this.data.prepareNum;
                if(i+2*this.data.prepareNum                  changeData[[`listData[${belowShowIndex}].isDisplay`]]=true;
                 }
          }   
        }    
    }else{//向上滚动
        if(clearindex>=0){
         let changeData={}
         for(let i=aboveShowIndex-1;i>=clearindex;i--){
           let belowShowIndex=i+2*this.data.prepareNum
           if(i+2*this.data.prepareNum<=listDataLen-1){
            changeData[[`listData[${belowShowIndex}].isDisplay`]]=false;
           }
           changeData[[`listData[${i}].isDisplay`]]=true;
         }  
        }else{
          if(aboveShowIndex>0){
            for(let i=0;i              this.setData({
                [`listData[${i}].isDisplay`]:true,
              })
            }
          }
        }      
    }
    clearindex=clearindex>0?clearindex:0
    if(clearindex>=0&&!(clearindex>0&&clearindex==this.data.aboveShowIndex)){
      changeData.aboveShowIndex=clearindex;
      let belowShowNum=this.data.listData.length-(2*this.data.prepareNum+clearindex)
      belowShowNum=belowShowNum>0?belowShowNum:0
      if(belowShowNum>=0){
        changeData.belowShowNum=belowShowNum
      }
      this.setData(changeData)
    }
    this.setData({
      oldSrollTop:scrollTop
    })
  }),

经过上面的处理后，页面的wxml节点数量相对稳定，可能因为可视区域数据的index计算误差，页面渲染的数据有小幅度的浮动，但是已经完全不会超过小程序页面的节点数量的限制。理论上100万条数据的列表也不会有问题，只要你有耐心和精力一直划列表加载这么多数据。

Moya最新版本11.0.2

由于前段时间写了这篇文章，最新Moya已更新最新版本，故此也更新了下用法，本人已使用，故特意奉上最新的使用demo供参考。
Moya11.0.2Demo

Moya简介

Moya 是你的 app 中缺失的网络层。不用再去想在哪儿（或者如何）安放网络请求，Moya 替你管理。

Moya有几个比较好的特性:

1、编译时检查正确的API端点访问.

2、使你定义不同端点枚举值对应相应的用途更加明晰.

3、提高测试地位从而使单元测试更加容易.

Swift我们用Alamofire来做网络库.而Moya在Alamofire的基础上又封装了一层,如下流程图说明Moya的简单工作流程图:

** Moya**的官方下载地址点我强大的Moya,有具体的使用方法在demo里面有说明。

本文主要介绍一下Moya的用法

1、设置请求头部信息
2、设置超时时间
3、自定义插件
4、自签名证书
注意：以下所出现的NetAPIManager跟官网上demo的** GitHub**是一样类型的文件，都是这个enum实现一个协议TargetType，点进去可以看到TargetType定义了我们发送一个网络请求所需要的东西，什么baseURL，parameter，method等一些计算性属性，我们要做的就是去实现这些东西，当然有带默认值的我们可以不去实现，但是设置头部信息跟超时时间就要修改这些系统默认设置了。

为了看得更加清楚，贴上NetAPIManager文件的内容

//
//  NetAPIManager.swift
//  NN110
//
//  Created by 陈亦海 on 2017/5/12.
//  Copyright © 2017年 陈亦海. All rights reserved.
//

import Foundation
import Moya


enum NetAPIManager {
    case Show
    case upload(bodyData: Data)
    case download
    case request(isTouch: Bool, body: Dictionary<String, Any>? ,isShow: Bool)
}


extension NetAPIManager: TargetType {
    var baseURL: URL {//服务器地址
        
        switch self {
        case .request( _, _, _):
            return URL(string: "https://www.pmphmall.com")!
        default:
            return URL(string: "https://httpbin.org")!
        }
        
        
    }
    
    var path: String {//具体某个方法的路径
        switch self {
        case .Show:
            return ""
        case .upload(_):
            return ""
        case .request(_, _, _):
            return "/app/json.do"
        case .download:
            return ""
        }
    }
    
    var method: Moya.Method {//请求的方法 get或者post之类的
        switch self {
        case .Show:
            return .get
        case .request(_, _, _):
            return .post
        default:
            return .post
        }
    }
    
    var parameters: [String: Any]? {//请求的get post给服务器的参数
        switch self {
        case .Show:
            return nil
        case .request(_, _, _):
            return ["msg":"H4sIAAAAAAAAA11SSZJFIQi7EqPAEgTvf6TP62W7sMoSQhKSWDrs6ZUKVWogLwYV7RjHFBZJlNlzloN6LVqID4a+puxqRdUKVNLwE1TRcZIC/fjF2rPotuXmb84r1gMXbiASZIZbhQdKEewJlz41znDkujCHuQU3dU7G4/PmVRnwArMLXukBv0J23XVahNO3VX35wlgce6TLUzzgPQJFuHngAczl6VhaNXpmRLxJBlMml6gdLWiXxTdO7I+iEyC7XuTirCQXOk4dotgArgkH/InxVjfNTnE/uY46++hyAiLFuFL4cv1Z8WH5DgB2GnvFXMh5gm53Tr13vqqrEYtcdXfkNsMwKB+9sAQ77grNJmquFWOhfXA/DELlMB0KKFtHOc/ronj1ml+Z7qas82L3VWiCVQ+HEitjTVzoFw8RisFN/jJxBY4awvq427McXqnyrfCsl7oeEU6wYgW9yJtj1lOkx0ELL5Fw4z071NaVzRA9ebxWXkFyothgbB445cpRmTC+//F73r1kOyQ3lTpec12XNDR00nnq5/YmJItW3+w1z27lSOLqgVctrxG4xdL9WVPdkH1tkiZ/pUKBGhADAAA="]
        default:
            return nil
        
        }
    }
    
    var sampleData: Data { //编码转义
       return "{}".data(using: String.Encoding.utf8)!
    }
    
    var task: Task { //一个请求任务事件
        
        switch self {

        
        case let .upload(data):
        return .upload(.multipart([MultipartFormData(provider: .data(data), name: "file", fileName: "gif.gif", mimeType: "image/gif")]))
            
        default:
            return .request

       }

     }
    
    var parameterEncoding: ParameterEncoding {//编码的格式
        switch self {
        case .request(_, _, _):
            return URLEncoding.default
        default:
            return URLEncoding.default
        }
        
    }
    //以下两个参数是我自己写，用来控制网络加载的时候是否允许操作，跟是否要显示加载提示，这两个参数在自定义插件的时候会用到
    var touch: Bool { //是否可以操作
        
        switch self {
        case .request(let isTouch, _, _):
            return isTouch
        default:
            return false
        }
        
    }
    
    var show: Bool { //是否显示转圈提示
        
        switch self {
        case .request( _, _,let isShow):
            return isShow
        default:
            return false
        }
        
    }
    
    
}

如何设置Moya请求头部信息

头部信息的设置在开发过程中很重要，如服务器生成的token，用户唯一标识等
我们直接上代码，不说那么多理论的东西，哈哈

// MARK: - 设置请求头部信息
let myEndpointClosure = { (target: NetAPIManager) -> Endpoint<NetAPIManager> in
    
    
    let url = target.baseURL.appendingPathComponent(target.path).absoluteString
    let endpoint = Endpoint<NetAPIManager>(
        url: url,
        sampleResponseClosure: { .networkResponse(200, target.sampleData) },
        method: target.method,
        parameters: target.parameters,
        parameterEncoding: target.parameterEncoding
    )

    //在这里设置你的HTTP头部信息
    return endpoint.adding(newHTTPHeaderFields: [
        "Content-Type" : "application/x-www-form-urlencoded",
        "ECP-COOKIE" : ""
        ])
    
}

如何设置请求超时时间

// MARK: - 设置请求超时时间
let requestClosure = { (endpoint: Endpoint<NetAPIManager>, done: @escaping MoyaProvider<NetAPIManager>.RequestResultClosure) in
    
    guard var request = endpoint.urlRequest else { return }
    
    request.timeoutInterval = 30    //设置请求超时时间
    done(.success(request))
}

自定义插件

自定义插件必须PluginType协议的两个方法willSend与didReceive

//
//  MyNetworkActivityPlugin.swift
//  NN110
//
//  Created by 陈亦海 on 2017/5/10.
//  Copyright © 2017年 CocoaPods. All rights reserved.
//

import Foundation
import Result
import Moya


/// Network activity change notification type.
public enum MyNetworkActivityChangeType {
    case began, ended
}

/// Notify a request's network activity changes (request begins or ends).
public final class MyNetworkActivityPlugin: PluginType {
    
    
    
    public typealias MyNetworkActivityClosure = (_ change: MyNetworkActivityChangeType, _ target: TargetType) -> Void
    let myNetworkActivityClosure: MyNetworkActivityClosure
    
    public init(newNetworkActivityClosure: @escaping MyNetworkActivityClosure) {
        self.myNetworkActivityClosure = newNetworkActivityClosure
    }
    
    // MARK: Plugin
    
    /// Called by the provider as soon as the request is about to start
    public func willSend(_ request: RequestType, target: TargetType) {
        myNetworkActivityClosure(.began,target)
    }
    
    /// Called by the provider as soon as a response arrives, even if the request is cancelled.
    public func didReceive(_ result: Result<Moya.Response, MoyaError>, target: TargetType) {
        myNetworkActivityClosure(.ended,target)
    }
}

使用自定义插件方法

// MARK: - 自定义的网络提示请求插件
let myNetworkPlugin = MyNetworkActivityPlugin { (state,target) in
    if state == .began {
        //        SwiftSpinner.show("Connecting...")
        
        let api = target as! NetAPIManager
        if api.show {
            print("我可以在这里写加载提示")
        }
        
        if !api.touch {
            print("我可以在这里写禁止用户操作，等待请求结束")
        }

        print("我开始请求\(api.touch)")
        
        UIApplication.shared.isNetworkActivityIndicatorVisible = true
    } else {
        //        SwiftSpinner.show("request finish...")
        //        SwiftSpinner.hide()
        print("我结束请求")
        UIApplication.shared.isNetworkActivityIndicatorVisible = false
        
    }
}

自签名证书

在16年的WWDC中，Apple已表示将从2017年1月1日起，所有新提交的App必须强制性应用HTTPS协议来进行网络请求。默认情况下非HTTPS的网络访问是禁止的并且不能再通过简单粗暴的向Info.plist中添加NSAllowsArbitraryLoads
设置绕过ATS(App Transport Security)的限制（否则须在应用审核时进行说明并很可能会被拒）。所以还未进行相应配置的公司需要尽快将升级为HTTPS的事项提上进程了。本文将简述HTTPS及配置数字证书的原理并以配置实例和出现的问题进行说明，希望能对你提供帮助。(比心~)

HTTPS：
简单来说，HTTPS就是HTTP协议上再加一层加密处理的SSL协议,即HTTP安全版。相比HTTP，HTTPS可以保证内容在传输过程中不会被第三方查看、及时发现被第三方篡改的传输内容、防止身份冒充，从而更有效的保证网络数据的安全。
HTTPS客户端与服务器交互过程：
1、 客户端第一次请求时，服务器会返回一个包含公钥的数字证书给客户端；
2、 客户端生成对称加密密钥并用其得到的公钥对其加密后返回给服务器；
3、 服务器使用自己私钥对收到的加密数据解密，得到对称加密密钥并保存；
4、 然后双方通过对称加密的数据进行传输。

数字证书：
在HTTPS客户端与服务器第一次交互时，服务端返回给客户端的数字证书是让客户端验证这个数字证书是不是服务端的，证书所有者是不是该服务器，确保数据由正确的服务端发来，没有被第三方篡改。数字证书可以保证数字证书里的公钥确实是这个证书的所有者(Subject)的，或者证书可以用来确认对方身份。证书由公钥、证书主题(Subject)、数字签名(digital signature)等内容组成。其中数字签名就是证书的防伪标签，目前使用最广泛的SHA-RSA加密。
证书一般分为两种：

1、一种是向权威认证机构购买的证书，服务端使用该种证书时，因为苹果系统内置了其受信任的签名根证书，所以客户端不需额外的配置。为了证书安全，在证书发布机构公布证书时，证书的指纹算法都会加密后再和证书放到一起公布以防止他人伪造数字证书。而证书机构使用自己的私钥对其指纹算法加密，可以用内置在操作系统里的机构签名根证书来解密，以此保证证书的安全。
2、另一种是自己制作的证书，即自签名证书。好处是不需要花钱购2买，但使用这种证书是不会受信任的，所以需要我们在代码中将该证书配置为信任证书.

自签名证书具体实现:

我们在使用自签名证书来实现HTTPS请求时，因为不像机构颁发的证书一样其签名根证书在系统中已经内置了，所以我们需要在App中内置自己服务器的签名根证书来验证数字证书。首先将服务端生成的.cer格式的根证书添加到项目中，注意在添加证书要一定要记得勾选要添加的targets。这里有个地方要注意：苹果的ATS要求服务端必须支持TLS 1.2或以上版本；必须使用支持前向保密的密码；证书必须使用SHA-256或者更好的签名hash算法来签名，如果证书无效，则会导致连接失败。由于我在生成的根证书时签名hash算法低于其要求，在配置完请求时一直报NSURLErrorServerCertificateUntrusted = -1202错误，希望大家可以注意到这一点。

那么如何在Moya中使用自签名的证书来实现HTTPS网络请求呢，请期待下回我专门分享......需要自定义一个Manager管理

综合使用的方法如下

定义一个公用的Moya请求服务对象

let MyAPIProvider = MoyaProvider<NetAPIManager>(endpointClosure: myEndpointClosure,requestClosure: requestClosure, plugins: [NetworkLoggerPlugin(verbose: true, responseDataFormatter: JSONResponseDataFormatter),myNetworkPlugin])

// MARK: -创建一个Moya请求
func sendRequest(_ postDict: Dictionary<String, Any>? = nil,
                 success:@escaping (Dictionary<String, Any>)->(),
                 failure:@escaping (MoyaError)->()) -> Cancellable? {
    
   let request = MyAPIProvider.request(.Show) { result in    
        switch result {
        case let .success(moyaResponse):
            
            
            do {
                let any = try moyaResponse.mapJSON()
                let data =  moyaResponse.data
                let statusCode =  moyaResponse.statusCode
                MyLog("\(data) --- \(statusCode) ----- \(any)")
                
                success(["":""])
                

            } catch {
                
            }
            
           
            
        case let .failure(error):
            
            print(error)
            failure(error)
        }
    }
    
    return request
}

取消所有的Moya请求

// MARK: -取消所有请求
func cancelAllRequest() {
//    MyAPIProvider.manager.session.invalidateAndCancel()  //取消所有请求
    MyAPIProvider.manager.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
        dataTasks.forEach { $0.cancel() }
        uploadTasks.forEach { $0.cancel() }
        downloadTasks.forEach { $0.cancel() }
    }
    
    //let sessionManager = Alamofire.SessionManager.default
    //sessionManager.session.getTasksWithCompletionHandler { dataTasks, uploadTasks, downloadTasks in
    //    dataTasks.forEach { $0.cancel() }
    //    uploadTasks.forEach { $0.cancel() }
    //    downloadTasks.forEach { $0.cancel() }
    //}

}

转自：https://www.jianshu.com/p/38fbc22a1e2b

##WelikeAndroid 是什么? WelikeAndroid 是一款引入即用的便捷开发框架,致力于为程序员打造最佳的编程体验,
使用WelikeAndroid, 你会觉得写代码是一件很轻松的事情.

##Welike带来了哪些特征？

WelikeAndroid目前包含五个大模块:

• 异常安全隔离模块(实验阶段):当任何线程抛出任何异常,我们的异常隔离机制都会让UI线程继续运行下去.
• Http模块: 一行代码完成POST、GET请求和Download,支持上传, 高度优化Disk的缓存加载机制,
  自由设置缓存大小、缓存时间(也支持永久缓存和不缓存).
• Bitmap模块: 一行代码完成异步显示图片,无需考虑OOM问题,支持加载前对图片做自定义处理.
• Database模块: 支持NotNull,Table,ID,Ignore等注解,Bean无需Getter和Setter,一键式部署数据库.
• ui操纵模块: 我们为Activity基类做了完善的封装,继承基类可以让代码更加优雅.
• 另:请不要认为功能相似,框架就不是原创,源码摆在眼前,何不看一看?

使用WelikeAndroid需要以下权限：

<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />

<uses-permission android:name="android.permission.INTERNET" />

##下文将教你如何圆润的使用WelikeAndroid:
###通过WelikeContext在任意处取得上下文:

• WelikeContext.getApplication(); 就可以取得当前App的上下文
• WelikeToast.toast("你好!"); 简单一步弹出Toast.
  

##WelikeGuard(异常安全隔离机制用法):

• 第一步,开启异常隔离机制:

WelikeGuard.enableGuard();

• 第二步,注册一个全局异常监听器:

WelikeGuard.registerUnCaughtHandler(new Thread.UncaughtExceptionHandler() {

@Override

public void uncaughtException(Thread thread, Throwable ex) {



 WelikeGuard.newThreadToast("出现异常了: " + ex.getMessage() );



}

});

• 你也可以自定义异常:

/**

*

* 自定义的异常,当异常被抛出后,会自动回调onCatchThrowable函数.

*/

@Catch(process = "onCatchThrowable")

public class CustomException extends IllegalAccessError {



   public static void onCatchThrowable(Thread t){

    WeLog.e(t.getName() + "  抛出了一个异常...");

   }

}

• 另外,继承自UncaughtThrowable的异常我们不会对其进行拦截.

使用Welike做屏幕适配:

Welike的ViewPorter类提供了屏幕适配的Fluent-API,我们可以通过一组流畅的API轻松做好屏幕适配.

        ViewPorter.from(button).ofScreen().divWidth(2).commit();//宽度变为屏幕的二分之一

        ViewPorter.from(button).of(viewGroup).divHeight(2).commit();//高度变为viewGroup的二分之一

        ViewPorter.from(button).div(2).commit();//宽度和高度变为屏幕的四分之一

        ViewPorter.from(button).of(this).fillWidth().fillHeight().commit();//宽度和高度铺满Activity

        ViewPorter.from(button).sameAs(imageView).commit();//button的宽度和高度和imageView一样

WelikeHttp入门:

首先来看看框架的调试信息,是不是一目了然.  

• 第一步,取得WelikeHttp默认实例.

WelikeHttp welikeHttp = WelikeHttp.getDefault();

• 第二步,发送一个Get请求.

HttpParams params = new HttpParams();

params.putParams("app","qr.get",

                 "data","Test");//一次性放入两对 参数 和 值



//发送Get请求

HttpRequest request = welikeHttp.get("http://api.k780.com:88", params, new HttpResultCallback() {

    @Override

    public void onSuccess(String content) {

    super.onSuccess(content);

    WelikeToast.toast("返回的JSON为:" + content);

    }



    @Override

    public void onFailure(HttpResponse response) {

    super.onFailure(response);

    WelikeToast.toast("JSON请求发送失败.");

    }



    @Override

    public void onCancel(HttpRequest request) {

    super.onCancel(request);

    WelikeToast.toast("请求被取消.");

    }

});



    //取消请求,会回调onCancel()

    request.cancel();

当然,我们为满足需求提供了多种扩展的Callback,目前我们提供以下Callback供您选择:

• HttpCallback(响应为byte[]数组)
• FileUploadCallback(仅在上传文件时使用)
• HttpBitmapCallback(建议使用Bitmap模块)
• HttpResultCallback(响应为String)
• DownloadCallback(仅在download时使用)

如需自定义Http模块的配置(如缓存时间),请查看HttpConfig.

WelikeBitmap入门:

• 第一步,取得默认的WelikeBitmap实例:

//取得默认的WelikeBitmap实例

WelikeBitmap welikeBitmap = WelikeBitmap.getDefault();

• 第二步,异步加载一张图片:

BitmapRequest request = welikeBitmap.loadBitmap(imageView,

"http://img0.imgtn.bdimg.com/it/u=937075122,1381619862&fm=21&gp=0.jpg",

android.R.drawable.btn_star,//加载中显示的图片

android.R.drawable.ic_delete,//加载失败时显示的图片

new BitmapCallback() {



    @Override

    public Bitmap onProcessBitmap(byte[] data) {

    //如果需要在加载时处理图片,可以在这里处理,

    //如果不需要处理,就返回null或者不复写这个方法.

    return null;

    }



    @Override

    public void onPreStart(String url) {

    super.onPreStart(url);

    //加载前回调

    WeLog.d("===========> onPreStart()");

    }



    @Override

    public void onCancel(String url) {

    super.onCancel(url);

    //请求取消时回调

    WeLog.d("===========> onCancel()");

    }



    @Override

    public void onLoadSuccess(String url, Bitmap bitmap) {

    super.onLoadSuccess(url, bitmap);

    //图片加载成功后回调

    WeLog.d("===========> onLoadSuccess()");

    }



    @Override

    public void onRequestHttp(HttpRequest request) {

    super.onRequestHttp(request);

    //图片需要请求http时回调

    WeLog.d("===========> onRequestHttp()");

    }



    @Override

    public void onLoadFailed(HttpResponse response, String url) {

    super.onLoadFailed(response, url);

    //请求失败时回调

    WeLog.d("===========> onLoadFailed()");

    }

});