简述
在上篇文章：JOBridge之一任意方法的Swizzle（链接地址https://www.jianshu.com/p/905e06eeda7b），介绍了Swizzle任意方法（暂不包含有变长参数中的匿名参数，例如stringWithFormat:的第二个以上的参数，对于这种情况的处理较为麻烦，以后再处理）的详细方案，其做法是定义一个无参数无返回值的C桩函数，将被替换方法替换到该桩函数，在桩函数内部暂存参数，调用解析函数根据方法签名解析出所有参数放入数组，然后进入JOCallJsFunction调用对应的JS方法。本篇博客继续讲根据JS调用class注册方法，如何注册一个类以及其属性和方法；以及向JS上下文开放所有的原生方法，并完成参数转换、调用和返回值转换等。此篇完成后JOBridge基本就可以使用了，利用其可以重新一个原生的页面，实现动态更新代码，甚至于实时更新代码（不过这种方式有一定风险），下一篇讲如何比较简单的开放c函数调用入口和其他一些零散的东西和优化点。废话不多说，直接进入正题。
注册类
Native通过js上下文向js开放注册接口，js通过该接口注册类。
jsContext[@"interface"] = ^(JSValue *className, JSValue *properties, JSValue *classMethods, JSValue *metaClassMethods) {
[JOClass classWithName:className properties:properties classMethods:classMethods metaClassMethods:metaClassMethods];
};
注册时传入类名字，继承的父类，实现的协议，属性列表，类方法，元类方法等参数，然后调用JOClass的方法来注册，该方法会依次调用parseClass，parseMethods，parseProperties，addDealloc来完成类的注册，整个过程不难，简单说明即可。
parseClass传入的参className是包含类名，父类名和协议的字符串，解析出名字后调用OC的运行时方法创建类和添加协议。
- (void)parseClass:(NSString *)className {
NSString *aClassName = JOTools.trim([self getClassName:className]);
NSString *superClassName = JOTools.trim([self getSuperClassName:className]);
NSArray *protocolsName = [self getProtocolName:className];
self.class = objc_getClass(aClassName.UTF8String);
if (!self.class) {
self.isNewClass = YES;
self.superClass = objc_getClass(superClassName.UTF8String);
if (!self.superClass) {
self.class = NULL;
return;
}
self.class = objc_allocateClassPair(self.superClass, aClassName.UTF8String, 2);
}
if (!self.protocols) self.protocols = [NSMutableArray array];
for (NSString *obj in protocolsName) {
Protocol *pro = objc_getProtocol(JOTools.trim(obj).UTF8String);
class_addProtocol(self.class, pro);
[self.protocols addObject:pro];
}
}
注册属性和成员变量，
将js对象转成字典，枚举字典，调用JOAddPropertyAttribute具体添加属性和成员变量，完成后调用objc_registerClassPair注册类，此后类模板固定不能再添加成员变量，但属性和方法不受限制。
- (void)parseProperties:(JSValue *)jsValue {
NSDictionary *propertyList = [jsValue toDictionary];
for (NSString *obj in propertyList.allKeys) {//这里全部使用关联对象也可以，这不过先实现了class_addProperty
JOAddPropertyAttribute(self.class, obj, propertyList[obj], self.isNewClass);
}
if (self.isNewClass) objc_registerClassPair(self.class);
}
JOAddPropertyAttribute方法如下:
//目前只支持OC类型，基础类型暂时不支持，基础类型由NSNumber代替，而NSNumber和js中的Number等价
void JOAddPropertyAttribute(Class class, NSString *name, NSArray *att, BOOL isNewClass) {
if (!isNewClass) goto JOAssociatedTag;//使用关联对象只需要添加方法，关联对象目前只支持retain
objc_property_attribute_t nonatomic = {"N", ""};
objc_property_attribute_t ownership = {"&", ""};
objc_property_attribute_t type = {"T", @encode(id)};
if ([att.lastObject isEqualToString:@"weak"]) {
ownership = (objc_property_attribute_t){"W",""};
} else if ([att.lastObject isEqualToString:@"copy"]) {
ownership = (objc_property_attribute_t){"C",""};
}
// else if ([att.lastObject isEqualToString:@"assign"]) {
// type = (objc_property_attribute_t){"T", [[NSString stringWithFormat:@"@\"%@\"",att.firstObject] UTF8String]};
// }
objc_property_attribute_t attribute[] = { ownership, nonatomic, type};
BOOL success = class_addProperty(class, [name UTF8String], attribute, 3);
if (success) {
//这里似乎要手动调用class_addIvar才能将变量描述进去，仅用class_addProperty似乎不奏效。
class_addIvar(class, [[NSString stringWithFormat:@"_%@",name] UTF8String], sizeof(id), log2(sizeof(id)), @encode(id));
JOAssociatedTag:
class_addMethod(class, NSSelectorFromString(name), (IMP)JOGetter, "@@:");
NSString *head = [[name substringToIndex:1] uppercaseString];
NSString *set = [NSString stringWithFormat:@"set%@%@:", head, [name substringFromIndex:1]];
class_addMethod(class, NSSelectorFromString(set), (IMP)JOSetter, "v@:@");
}
}
这里为了简单，暂时仅支持OC类型的属性添加。如果不是JS动态创建类，则只能使用关联对象，直接goto到JOAssociatedTag，仅添加getter和setter方法，这里要小心的是编译器会添加release操作，goto别跳过去了，这会导致内存泄露。
如果是新创建的类，则可以添加成员变量。创建三个objc_property_attribute_t属性，调用class_addProperty添加属性，如果成功则调用class_addIvar添加成员变量，比较重要的是内存大小的计算log2(sizeof(id))，其头文件有说明，对齐大小将以1左移align，所以只可能是1,2,4,8...，任何指针类型都传log2(sizeof(pointer_type))也就是8。
接下来通过动态方法添加的方式添加一组getter和setter，默认实现为JOGetter和JOSetter。
id JOGetter(id obj, SEL sel) {
NSString *key = [NSString stringWithFormat:@"_%@",NSStringFromSelector(sel)];
Ivar ivar = class_getInstanceVariable([obj class], [key UTF8String]);
if (ivar) {
return object_getIvar(obj, ivar);
} else {
return objc_getAssociatedObject(obj, JOAssociatedKey(key));
}
}
/* object_setIvar不会retain对象，而object_setIvarWithStrongDefault在iOS10之后才有效，
所以需要手动调用retain，并在父对象dealloc的时候调用release
*/
void JOSetter(id obj, SEL sel, id newValue) {
NSString *selStr = [NSStringFromSelector(sel) substringFromIndex:3];
NSString *head = [[selStr substringToIndex:1] lowercaseString];
NSString *tail = [selStr substringFromIndex:1];
tail = [tail substringToIndex:tail.length - 1];
NSString *key = [NSString stringWithFormat:@"_%@%@", head, tail];
Ivar ivar = class_getInstanceVariable([obj class], [key UTF8String]);
if (ivar) {
id value = object_getIvar(obj, ivar);
JOTools.release(value);
object_setIvar(obj, ivar, newValue);
JOTools.retain(newValue);
} else {
objc_setAssociatedObject(obj, JOAssociatedKey(key), newValue, OBJC_ASSOCIATION_RETAIN_NONATOMIC);
}
}
JOGetter先通过class_getInstanceVariable在类中查找实例描述Ivar，如果找到了则表示其为成员变量，调用对象的object_getIvar方法获取成员变量值，否则就调用关联对象方法获取关联对象。
JOSetter套路类似，先获取描述，如果有描述则先调用object_setIvar存储数据，需要注意的是其不会retain对象，而会retain对象的方法object_setIvarWithStrongDefault在iOS10才可用，所以这里需要手动调用JOTools.retain()。如果是关联对象就简单了，直接调用相关方法就好。需要注意的是这里的Key必须是唯一变量地址，这里将key放入全局字典，。
JOTools.retain实现如下，就是汇编调用_objc_retain（当然也可以用别的实现方案），注意参数和堆栈，需要注意的是这里其实是有一个参数的存在x0中，但在该retain函数中我并不使用，所以不用在栈上存储，也就不用手动修改栈大小（不过stp， ldp命令会导致sp增减），直接调用_objc_retain就可以了，不过retain这个桩函数会默认插入汇编指令ret，因此这里需要将x29, x30入栈，如果不想入栈优化性能，可以把retain定义为宏函数，直接调用_objc_retain。release同理。
OS_ALWAYS_INLINE void retain() {
asm volatile("stp x29, x30, [sp, #-0x10]!");
asm volatile("mov x29, sp");
asm volatile("bl _objc_retain");
asm volatile("mov sp, x29");
asm volatile("ldp x29, x30, [sp], #0x10");
}
OS_ALWAYS_INLINE void release() {
asm volatile("stp x29, x30, [sp, #-0x10]!");
asm volatile("mov x29, sp");
asm volatile("bl _objc_release");
asm volatile("mov sp, x29");
asm volatile("ldp x29, x30, [sp], #0x10");
}
注册方法
接下来解析JS方法，根据方法列表创建对应的Method。
- (void)parseMethods:(JSValue *)jsMethods isMeta:(BOOL)isMeta {
NSDictionary *methods = [jsMethods toDictionary];
for (NSString *method in methods) {
JSValue *jsMethod = [jsMethods valueForProperty:method];
SEL sel = [self getSelectorWithString:method];
//这里使用class_copyMethodList，其只会获取当前类方法，不会获取父类方法，而class_getInstanceMethod等会获取父类方法
Method ocMethod = isMeta ? JOGetMethodWithSelector(object_getClass(self.class), sel)
: JOGetMethodWithSelector(self.class, sel);
if (ocMethod) {
method_setImplementation(ocMethod, JOGlobalSwizzle);
JOAddJsMethod(self.class, NSStringFromSelector(sel), jsMethod);
continue;
}
Method ocSuperMethod = isMeta ? class_getClassMethod([self.class superclass], sel)
: class_getInstanceMethod([self.class superclass], sel);
if (ocSuperMethod) {
const char *type = method_getTypeEncoding(ocSuperMethod);
class_addMethod(self.class, sel, JOGlobalSwizzle, type);
JOAddJsMethod(self.class, NSStringFromSelector(sel), jsMethod);
continue;
}
char *type = NULL;
for (Protocol *p in self.protocols) {
type = protocol_getMethodDescription(p, sel, YES, !isMeta).types;
if (!type) type = protocol_getMethodDescription(p, sel, NO, !isMeta).types;
if (type) break;
}
//如果协议中也没有此方法签名，表明是由js新创建的方法，则获取js提供的签名
if (type) {
class_addMethod(isMeta ? object_getClass(self.class) : self.class, sel, JOGlobalSwizzle, type);
} else {
NSArray *array = [jsMethod toObject];
if ([array isKindOfClass:[NSArray class]]
&& array.count > 1
&& [array.firstObject isKindOfClass:[NSString class]]) {
const char *type = [array.firstObject UTF8String];
class_addMethod(isMeta ? object_getClass(self.class) : self.class, sel, JOGlobalSwizzle, type);
jsMethod = jsMethod[1];
} else {
continue;
}
}
JOAddJsMethod(self.class, NSStringFromSelector(sel), jsMethod);
}
}
获取JS中的SEL名字构建SEL，在当前类中获取对应的Method，注意使用class_copyMethodList。如果有对应的Method，则只需替换其实现为JOGlobalSwizzle，同时将对应的JS实现以ClassName和SEL为Key存入全局字典。这里就和上篇博客关联起来了，调用链为ClassA的MethodA->JOGlobalSwizzle->...->JOCallJsFunction->JS->(Native)。
如果当前类没有该方法，则跳过该类，去父类中循环获取，如果找到方法，则调用class_addMethod添加方法，相当于当前类重写该方法，调用JOAddJsMethod添加全局字典，并跳到下一次循环。
接下来去协议中查找方法签名，如果找到了则添加方法，如果没有找到，则表明这是个JS新定义的方法，获取JS提供签名后向类添加方法，最后把JS方法添加到全局字典。
目前class方法等注册和方法调用没有加锁，所以在调用时重新注册很可能会凉凉，也就是说最好不要实时跟新代码，注册最好在app启动时完成。
注册dealloc
前面讲到所有的成员变量会调用retain来持有变量，带来的结果就是内存泄露，所有需要在注册类的dealloc中来release一次。
//对JOSetter中retain的对象一次调用release
void JORelease(__unsafe_unretained id obj, SEL sel) {
unsigned int count;
Ivar *v = class_copyIvarList([obj class], &count);
for (int i = 0; i < count; ++i) {
const char *name = ivar_getName(v[i]);
Ivar ivar = class_getInstanceVariable([obj class],name);
__unsafe_unretained id value = object_getIvar(obj, ivar);
object_setIvar(obj, ivar, nil);
JOTools.release(value);
}
free(v);
//#pragma clang diagnostic push
//#pragma clang diagnostic ignored "-Warc-performSelector-leaks"
//#pragma clang diagnostic ignored "-Wundeclared-selector"
// if ([obj respondsToSelector:@selector(JODealloc)]) {
// [obj performSelector:@selector(JODealloc)];
// }
//
//#pragma clang diagnostic pop
//调用父类dealloc实现，重写dealloc后，编译器会默认插入父类dealloc的调用，但这里修改其实现后，必须手动调用
IMP imp = class_getMethodImplementation([[obj class] superclass], sel);
imp ? ((void(*)(id, SEL))imp)(obj, sel) : nil;
}
这里将class所有的Ivar枚举出来，获取所有的成员对象，依次调用release，注意free IvarList（这里我一直忘了free，这么个小错误导致的内存泄露查了好久才查出来，😓）。
本来我是打算让JS通过重写JODealloc来实现自定义的dealloc过程，后来发现会导致crash，原因在于调用JODealloc会让js通过共享对象也持有当前对象，这里调用完成后当前对象已经没了，而js却还持有共享对象。目前我还没有想到好的解决方案，只能暂时不提供该功能，自己能砍需求就是牛逼啊！😎
我们平常重写dealloc方法，Xcode编译器会帮我们插入调用父类dealloc的代码，所以这里需要手动调用一下父类的dealloc，另外需要注意的是在这个函数实现中最好不要retain当前对象，weak也不能用，因为在调用了父类的dealloc后，对象已经释放了，这时候编译器帮你插入的release再调用就会crash。weak对象的问题在于其调用函数时会被retain，调用完会立即release，这也很可能crash。
JS访问所有的Native方法（JS->OC通用调用桥）
JSC提供共享对象，JS和Native可以相互传递参数，同时有了类似于JOGlobalSwizzle可以用于解析参数和转发消息函数之后，JS动态调用OC方法就有了可能，只需要将OC对象和SEL传给Native，就可以动态调用所有OC方法了，若不处理过多（种）的参数，通过performSelector动态调用，甚至只需要少量的代码就可以完成。如果在JSContext中注入一个方法来实现，那么js语法将会很复杂，同时不能使用“.”运算符，为了调用简单，我还是借鉴JSPatch类似的语法（没法子js不精通，玩不出新花样），只不过我这里实现就完全不一样了。
JS根类添加_oc_属性
通过JSContext给js的根类Object的prototype原型添加一个_oc_属性，其描述信息为@{JSPropertyDescriptorValueKey:^{...},JSPropertyDescriptorConfigurableKey:@(NO), JSPropertyDescriptorEnumerableKey:@(NO)}。这里使用JSPropertyDescriptorValueKey，并提供一个block，js就可以直接调用该属性了。具体的玩法，注释里面有描述。
/* 给js的根类添加一个_oc_方法（或者说一个属性吧），其返回了一个block，block第一个参数是selector名称，同时在上下文获取currentThis，从中取出obj，余下的参数则在后面，这里我只写了12个，添加也容易，补上去就行（当然还有其他麻烦一点的办法，比如根据selector动态获取，也可以通过预处理js将参数打包成数组，都可以支持任意长度了）。
js调用会被预处理，例如tableView.setDelegate_(self)，会被转成tableView._oc_('setDelegate_',self)，当然也可以使用其他的语法。在调用原生方法的时候我偷了一下懒，使用了NSInvocation。也可以像获取任意参数一样，强制写入参数到寄存器和栈来调用objc_msgSend（当然也可以直接调用其实现，但可能没有objc_msgSend的缓存效果），就是有点麻烦，后续有时间再改。
*/
[self.jsContext[@"Object"][@"prototype"] defineProperty:@"_oc_" descriptor:@{JSPropertyDescriptorValueKey:^id (JSValue *selName, JSValue *p0, JSValue *p1, JSValue *p2, JSValue *p3, JSValue *p4, JSValue *p5, JSValue *p6, JSValue *p7, JSValue *p8, JSValue *p9, JSValue *p10, JSValue *p11, JSValue *p12) {
NSString *tmp = [[selName toString] stringByReplacingOccurrencesOfString:@"__" withString:@"-"];
tmp = [tmp stringByReplacingOccurrencesOfString:@"_" withString:@":"];
SEL sel = NSSelectorFromString([tmp stringByReplacingOccurrencesOfString:@"-" withString:@"_"]);
id obj = [[JSContext currentThis] toObject];
NSAssert(obj, @"调用者容器不能为空");
if (![obj obj]) return [NSNull null];
obj = [obj obj];
NSMethodSignature *sign = [obj methodSignatureForSelector:sel];
NSAssert(sign, @"签名不能为空，请先检测JS调用函数是否书写正确，再检查OC是否提供此函数");
id params[] = {p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12};//创建c数组
NSInvocation *invoke = [NSInvocation invocationWithMethodSignature:sign];
[invoke setTarget:obj];
[invoke setSelector:sel];
NSUInteger num = [sign numberOfArguments];
for (int i = 2; i < num; ++i) {
const char* type = [sign getArgumentTypeAtIndex:i];
while (*type == 'r' || // const
*type == 'n' || // in
*type == 'N' || // inout
*type == 'o' || // out
*type == 'O' || // bycopy
*type == 'R' || // byref
*type == 'V') { // oneway
type++; // cut off useless prefix
}
switch (type[0]) {
case 'B': {BOOL v = [params[i-2] toBool]; [invoke setArgument:&v atIndex:i]; break;}
case 'c': {char v = [[params[i-2] toNumber] charValue]; [invoke setArgument:&v atIndex:i]; break;}
case 'C': {Byte v = [[params[i-2] toNumber] unsignedCharValue]; [invoke setArgument:&v atIndex:i]; break;}
case 's': {short v = [[params[i-2] toNumber] shortValue]; [invoke setArgument:&v atIndex:i]; break;}
case 'S': {unsigned short v = [[params[i-2] toNumber] unsignedShortValue]; [invoke setArgument:&v atIndex:i]; break;}
case 'i': {int v = [params[i-2] toInt32]; [invoke setArgument:&v atIndex:i]; break;}
case 'I': {unsigned int v = [params[i-2] toUInt32]; [invoke setArgument:&v atIndex:i]; break;}
case 'l': {long v = [[params[i-2] toNumber] longValue]; [invoke setArgument:&v atIndex:i]; break;}
case 'L': {unsigned long v = [[params[i-2] toNumber] unsignedLongValue]; [invoke setArgument:&v atIndex:i]; break;}
case 'q': {long long v = [[params[i-2] toNumber] longLongValue]; [invoke setArgument:&v atIndex:i]; break;}
case 'Q': {unsigned long long v = [[params[i-2] toNumber] unsignedLongLongValue]; [invoke setArgument:&v atIndex:i]; break;}
case 'f': {float v = [[params[i-2] toNumber] floatValue]; [invoke setArgument:&v atIndex:i]; break;}
case 'd': {double v = [params[i-2] toDouble]; [invoke setArgument:&v atIndex:i]; break;}
case '#':
case '@': {
__autoreleasing id v = [params[i-2] toObject];
if ([v isKindOfClass:[NSArray class]]
&& [v count] == 2
&& [v[0] isKindOfClass:[NSString class]]
&& [params[i-2][1] isInstanceOf:[JSContext currentContext][@"Function"] ]) {
//签名字符串不能放在栈上，否则很可能被覆盖掉
NSString *signString = v[0];
char *blockSgin = JOCopySgin(signString);
id jsBlocks = params[i-2][1];
/* 原生方法需要的参数是block，js传过来的参数是function，这时需要构造一个block（无参数无返回），强制修改这个block的签名。然后在block回调的时候才能根据签名解析出参数（Method或者说selector的签名在定义的时候，就由编译器搞定了，protocol也会生成签名，但如果仅仅是在类中声明而不实现是没有签名的，而block的签名则是在定义的时候才有，仅声明也没有，js没有类型信息，所以这里需要在js传funtion的时候手动签名）。JOGlobalParamsResolver只能根据第一个参数也就是block本身，如果不拷贝，则每次都是相同的block，无法获取正确的签名，如果强制每次修改签名，那么在异步执行的情况下，签名会冲突，所以需要拷贝整个block，并重新签名。
*/
v = ^() {
JOGlobalBlockGetParams();
//从x0中获取已经解析出的参数列表，是个NSArray，其中第一个参数是Block本身是隐藏参数
asm volatile("mov x1, x0");
uintptr_t *array = NULL;
void **arrayptr = (void **)&array;
asm volatile("ldr x0, %0": "=m"(arrayptr));
asm volatile("str x1, [x0]");
__autoreleasing NSArray *arr = (__bridge NSArray *)(void *)(*arrayptr);
__autoreleasing JSValue *ret = [jsBlocks callWithArguments:[arr subarrayWithRange:(NSRange){1, arr.count - 1}]];
char returnType = blockSgin[0];
//构建返回值和方法的返回值构建是一样的注意使用__autoreleasing变量以防止x0被破坏
JOConstructReturnValue(ret, returnType);//此句最好在方法的最末
};
v = (__bridge id)JOCopyBlock(v, blockSgin);
//修改block签名，JOGlobalParamsResolver解析参数时会获取该签名
// asm volatile("ldr x0, %0" : "=m"(v));
// asm volatile("ldr x8, [x0, 0x18]");
// asm volatile("add x1, x8, 0x10");
// asm volatile("add x2, x8, 0x20");
// asm volatile("ldr w3, [x0, 0x8]");
// asm volatile("tst w3, #0x2000000");
// asm volatile("csel x2, x1, x2, eq");
// asm volatile("ldr x0, %0": "=m"(blockSgin));
// asm volatile("str x0, [x2]" );
}
if ([v isKindOfClass:JOSelObj.class]) {
SEL s = [v sel];
[invoke setArgument:&s atIndex:i]; break;
} else if ([v isKindOfClass:JOObj.class]) {
v = [v obj];
[invoke setArgument:&v atIndex:i]; break;
} else if ([v isKindOfClass:JOPointerObj.class]) {
void *p = [v ptr];
[invoke setArgument:&p atIndex:i]; break;
} else if ([v isKindOfClass:JOWeakObj.class]) {
v = [v obj];
[invoke setArgument:&v atIndex:i]; break;
} else if ([v isKindOfClass:[NSNull class]]) {
v = nil;
[invoke setArgument:&v atIndex:i];
} else {
[invoke setArgument:&v atIndex:i];
}
break;
}
case '{': {
if (!strcmp(type, @encode(CGRect))) {
CGRect v = [params[i-2] toRect];
[invoke setArgument:&v atIndex:i];
} else if (!strcmp(type, @encode(CGPoint))) {
CGPoint v = [params[i-2] toPoint];
[invoke setArgument:&v atIndex:i];
} else if (!strcmp(type, @encode(CGSize))) {
CGSize v = [params[i-2] toSize];
[invoke setArgument:&v atIndex:i];
} else if (!strcmp(type, @encode(NSRange))) {
NSRange v = [params[i-2] toRange];
[invoke setArgument:&v atIndex:i];
}
//MARK:解析结构体
break;
}
case '^':
case '*': {
__autoreleasing id v = [params[i-2] toObject];
void *p = NULL;
if ([v isKindOfClass:[JOPointerObj class]]) {
p = [v ptr];
}
[invoke setArgument:&p atIndex:i];
break;
}
case ':': {
__autoreleasing id v = [params[i-2] toObject];
void *p = NULL;
if ([v isKindOfClass:[JOSelObj class]]) {
p = [v sel];
}
[invoke setArgument:&p atIndex:i];
break;
}
}
}
[invoke invoke];
const char *type = [sign methodReturnType];
while (*type == 'r' || // const
*type == 'n' || // in
*type == 'N' || // inout
*type == 'o' || // out
*type == 'O' || // bycopy
*type == 'R' || // byref
*type == 'V') { // oneway
type++; // cut off useless prefix
}
switch (type[0]) {
case 'v': return [NSNull null];
case 'B': {BOOL value; [invoke getReturnValue:&value]; return @(value);}
case 'c': {char value; [invoke getReturnValue:&value]; return @(value);}
case 'C': {Byte value; [invoke getReturnValue:&value]; return @(value);}
case 's': {short value; [invoke getReturnValue:&value]; return @(value);}
case 'S': {unsigned short value; [invoke getReturnValue:&value]; return @(value);}
case 'i': {int value; [invoke getReturnValue:&value]; return @(value);}
case 'I': {unsigned int value; [invoke getReturnValue:&value]; return @(value);}
case 'l': {long value; [invoke getReturnValue:&value]; return @(value);}
case 'L': {unsigned long value; [invoke getReturnValue:&value]; return @(value);}
case 'q': {long long value; [invoke getReturnValue:&value];
return @(value);}
case 'Q': {unsigned long long value; [invoke getReturnValue:&value];
return @(value);}
case 'f': {float value; [invoke getReturnValue:&value]; return @(value);}
case 'd': {double value; [invoke getReturnValue:&value]; return @(value);}
case '#': {
id retrunValue = nil;
[invoke getReturnValue:&retrunValue];
return MakeObj(retrunValue) ?: [NSNull null] ;
}
case '@': {
__unsafe_unretained id retrunValue = nil;
[invoke getReturnValue:&retrunValue];
JOObj *o = MakeObj(retrunValue);
if (sel == @selector(alloc) || sel == @selector(new)
|| sel == @selector(copy) || sel == @selector(mutableCopy)
|| (!strncmp(sel_getName(sel), "init", 4) && invoke.target != retrunValue)) {
JOTools.release(retrunValue);
}
return o ?: [NSNull null] ;
}
case '^':
case '*': {
void *retrunValue = NULL;
[invoke getReturnValue:&retrunValue];
return MakePointerObj(retrunValue) ?: [NSNull null] ;
}
case ':': {
void *retrunValue = NULL;
[invoke getReturnValue:&retrunValue];
return MakeSelObj(retrunValue) ?: [NSNull null];
}
case '{': {
if (!strcmp(type, @encode(CGRect))) {
CGRect v; [invoke getReturnValue:&v];
return [JSValue valueWithRect:v inContext:[JSContext currentContext]];
} else if (!strcmp(type, @encode(CGPoint))) {
CGPoint v; [invoke getReturnValue:&v];
return [JSValue valueWithPoint:v inContext:[JSContext currentContext]];
} else if (!strcmp(type, @encode(CGSize))) {
CGSize v; [invoke getReturnValue:&v];
return [JSValue valueWithSize:v inContext:[JSContext currentContext]];
} else if (!strcmp(type, @encode(NSRange))) {
NSRange v; [invoke getReturnValue:&v];
return [JSValue valueWithRange:v inContext:[JSContext currentContext]];
}
//MARK:更完善的结构体解析以后再想办法
}
default : break;
}
return [NSNull null];
}, JSPropertyDescriptorConfigurableKey:@(NO), JSPropertyDescriptorEnumerableKey:@(NO)}];
在这里通过[JSContext currentThis]获取this，就是打包OC中的self，解包得到得到真正的self对象，然后将SEL解析出来，通过创建NSMethodSignature和NSInvocation来调用。这里有个优化点，_oc_调用很频繁，可以缓存这两个对象，因为type字符串确定后这两个对象也就确定了，缓存可以有一些性能提升，之前给忘了。当然也可以通过method_getArgumentType获取参数签名。
使用NSInvocation转发消息，能够比较好的处理参数和返回值。这两个switch我一直想简化，想来想去除了宏似乎也没有别的法子，只是目前为了方便阅读和调试，暂不用宏简化代码。用了NSInvocation，常规参数处理，需要说明一下的是基础数据类型会被封装成NSNumber（不打包成JOObj对象），其和js的Number对应，可以直接被js使用。其他也就没有太多需要介绍的了，JSC有数据转换方法，根据签名转就可以了。
block参数处理
重点说明Block参数，例如：当JS调用Native的enumerateObjectsUsingBlock:方法，需要传递传递一个Function，而这个Function明显不能被Native直接调用，一种朴素的想法就是给enumerateObjectsUsingBlock传一个Block，再在这个Block中调用JS Function。呵呵，想法是没错的，但是实现起来确实很麻烦。
因为Block参数的多样性，这里定义一种的通用Block似乎不够用？如果根据参数和返回值预先定义多个Block，可参数种类有十几种，排列后就需要定义几十上百个Block，😓，就算整型类型合并，只保留id，double，NSInteger，指针还是要定义很多个，想想还是算了吧。定义一种Block真的不够么？有了JOGlobalSwizzle成功思路，似乎也不是不可行。Block本质上也是OC对象，方法也是C语法，符合ARM64 PCSAA调用协议，那么解析参数就和OC完全一致，唯一不一样的是签名，不过只要有签名就可以解析参数。但有一个问题是Block对象在定义的时候编译器才会生成，如果仅仅是声明是没有的，没有Block对象也就没有签名，而Method的也类似，不过协议也会生成Method，但没有实现。因此在JS传入Function的时候需要给出签名，OK，思路有了，下面来看具体实现。
说一下这里的原理，block的签名实际是其包装函数指针的签名，捕获的参数跟签名没有关系，仅需要将签名copy给Block就行（如果每次都是串行调用这个通用Block，实际上不需要copy整个Block，只需要强制修改Block的签名就行了，也就是说block实际上就一个，只是每次调用传参时修改签名，回调是串行，所以签名也就不存在覆盖的情况，这也是我最开始的做法）。但异步调用这种非串行的方式，就不能简单的修改签名了，需要将对应签名Block与JS函数绑定在一起，因此需要将block拷贝一份，然后手动签名。
这里需要先定义一下对应的Block的数据结构，这是一个具体的Block结构，带两个捕获参数。
通用的block定义如下：
typedef struct _JOBlockDescriptor {
void *reserved;
unsigned long int size;
void (*copy)(void *dst, const void *src);
void *dispose;
const char *signature;//目前使size，copy，signatrue字段，其他占位即可
void *layout;
} _JOBlockDescriptor;
typedef struct _JOBlock {
Class isa;
short int retainCount;
short int flag;
int token;
void *BlockFunctionPtr;
_JOBlockDescriptor *descriptor;//目前仅用retainCount，descriptor，其他占位即可
//捕获的参数
JSValue *jsFunction;
char *sign;
} _JOBlock;
JOCopySgin会将签名拷贝到堆上，同时缓存到字典，同一个签名就不用拷贝了。
/* 拷贝一个签名到堆上并返回 */
char *JOCopySgin(NSString *sign) {
[_JOBlockLock lock];
JOPointerObj *obj = _JOBlockSigns[sign];
[_JOBlockLock unlock];
if (obj) return [obj ptr];
const char *type = [sign UTF8String];
void *blockSgin = malloc(strlen(type) + 1);
memcpy(blockSgin, type, strlen(type) + 1);
[_JOBlockLock lock];
_JOBlockSigns[sign] = MakePointerObj(blockSgin);
[_JOBlockLock unlock];
return blockSgin;
}
新分配一个block和descriptor空间，拷贝descriptor和signature。
/*
关注JOBridge中处理JS传过来的block（js function）参数，其都被一个无参数无返回值的block处理，这是一个原型block，其原始签名是固定的，但该block会调用各种不同的js function，也就意味着要处理不同的参数和返回值。如果串行调用，每次根据传入js function的签名修改即可，但如果存在异步操作，就会出问题，所以签名必须和js function对应，而实际上我这里只处理参数，所以只需要关注签名是否一致，不需要关注捕获参数。
为了确保在执行过程中JOSwizzle的JOGlobalParamsResolver取到正确的签名，需要将block拷贝一份，调用copy或者_Block_copy都不行，其检查flags时跳过了拷贝。所以这里只能构造相同的结构体来手动拷贝，_JOBlock与原型block对应，拷贝block，descriptor和sign。最后将修改descriptor和sign。
*/
id JOCopyBlock(id block, _JOBlock *blockCopy, _JOBlockDescriptor *blockDescriptor, char *blockSgin) {
//_Block_copy;
_JOBlock *blockPtr = (__bridge void *)block;
_JOBlockDescriptor *blockDescriptor = malloc(sizeof(_JOBlockDescriptor));
_JOBlock *blockCopy = malloc(sizeof(_JOBlock));
memcpy((void*)blockCopy, (void*)blockPtr, sizeof(_JOBlock));
memcpy(blockDescriptor, blockPtr->descriptor, sizeof(_JOBlockDescriptor));
// blockDescriptor->copy = (void *)_JOCopyHelper;
blockDescriptor->copy(blockCopy, blockPtr);
blockDescriptor->dispose = (void *)_JODisposeHelper;
blockCopy->retainCount = 0x0;
blockCopy->descriptor = blockDescriptor;
blockCopy->descriptor->signature = blockSgin;
return blockCopy;
}
手动调用block的copy函数，拷贝一下捕获的参数，说是copy其实是retain一下jsFunction。这里的copy实现可以不用替换。
替换dispose的实现代码，主要是为了释放descriptor，同时手动release一下jsFunction。
void _JODisposeHelper(_JOBlock *src) {
JOTools.release(src->jsFunction);
free(src->descriptor);
}
将retainCount设置为0，v = (__bridge id)JOCopyBlock(v, blockSgin);赋值时候，会自动将其+1，就懒得前前后后的调用retain和release。ARM64位isa定义中，后19bit为引用计数器，但block似乎不太一样，引用计数器不在isa中，而在下一个4Byte，可能占用了32bit，但也可能不是，所有我这里定义retainCount为short int，16bit，一般也足够用了。
目前block是手动完成copy的，其实挺麻烦的，研究_Block_copy汇编码时，发现其拷贝前检查了一个flag，然后跳过了拷贝，目前这个flag情况不明所以我没有通过强行修改flag的方式去让_Block_copy生效，如果研究清楚了这个flag或许可以调用该方法copy了。
返回值内存管理
其他的情况没有什么特别的（更完善的结构体解析暂不实现），这里需要说明一下这种对象返回值的情况。
case '@': {
__unsafe_unretained id retrunValue = nil;
[invoke getReturnValue:&retrunValue];
JOObj *o = MakeObj(retrunValue);
if (sel == @selector(alloc) || sel == @selector(new)
|| sel == @selector(copy) || sel == @selector(mutableCopy)
|| (!strncmp(sel_getName(sel), "init", 4) && invoke.target != retrunValue)) {
JOTools.release(retrunValue);
}
return o ?: [NSNull null] ;
}
通过getReturnValue获取到返回值retrunValue，然后将其封装到JOObj中。
对于alloc，new，copy，mutableCopy需要调用一次release。为什么呢？因为这几种调用返回的是非autoreleasing对象，其retainCount默认为1，而且与外部声明的获取指针__unsafe_unretained id retrunValue无关，但是返回JOObj给JS持有也会导致其retainCount+1，也就是说调用一次alloc导致retainCount+2了，那就需要release一次。使用MakeObj封装一次后再调用release可以将retrunValue转换成autoreleasing对象，同时返回给JS后交给js管理。
(!strncmp(sel_getName(sel), "init", 4) && invoke.target != retrunValue)又是另外一种情况，当通过alloc和init创建类簇对象的时候，比如[[NSMutableArray alloc] init]，alloc和init调用完后返回的不是同一个对象，alloc返回的是一个__NSPlaceholderArray占位对象，调用init时，这个对象会被销毁再新建一个对应的对象返回。所以判断条件为sel为init打头时，并且self不等于返回值也release一下。
iOS的内存管理说简单也简单，说复杂还是很复杂的，比如在这里JS，OC，汇编，手动的MRC，编译器的ARC，Block拷贝的内存管理（retain和release捕获变量，block自身的内存管理），这些问题糅合在一起，就会让内存管理复杂很多，需要一点一点梳理才能解决，如果对内存管理理解不深刻的话，很容易出现各种问题，而且不知道问题出在什么地方，怎么解决，有兴趣的话可以去看我之前的ARC和block的相关博客，对很多问题都有详细描述和分析。
NULL处理
JSC头文件有说明，js的null和OC的[NSNull null]是可以等价转换的，所以遇到nil可以转成[NSNull null]返给JS。众所周知OC中对nil调用方法是合法的，因为调用都会被转成objc_msgSend的形式，但是js的对null调用方法就会报错。所以对于调用链JOC.class('ZWConfigure').sharedInstance().loginUser().userID(),如果中间的sharedInstance或者loginUser返回了null，js就会报错，但如果每次都需要判断是否为null再调用会有些麻烦。
一种解决方案是返回一个空的JOObj（单独创建一个单例也行），遇到nil要传给js时就使用这个空的JOObj，但这样的话js就不能只检查null还得检查是否为空的JOObj，但这需要单独的语法支持，比如if(JOC.class('ZWConfigure').sharedInstance().loginUser().userID() != JOObjNil) 或者if(JOC.class('ZWConfigure').sharedInstance().loginUser().userID().isNil())。
但是如果是浮点判断怎么处理，比如if(JOC.class('ZWConfigure').sharedInstance().loginUser().userAccountMoney() > 0)。
目前我还没有比较好的办法来解决这个问题，所以暂时我还是使用[NSNull null]来作为nil返回值，JS就麻烦点，调用前先判断是否为null再调用。
最后
虽然实现了功能，也作了一些优化，但依旧不少可以改进和优化的地方，大概列了几个：
1、NSMethodSignature和NSInvocation的复用。
2、传递给JS封装对象的复用，特别是后两者。JS代码只是作为一个桥， 实现功能全靠JS调用的Native，因此需要频繁调用Native方法，每次调用会创建好几个临时对象，而缓存复用就成了提高性能的最有效的方式。
3、Block不使用拷贝的方式处理签名，目前js传递一个function给原生调用时，会被参数解析函数封装成一个特殊的block，在block中再调用该function，但是给block解析参数需要签名。目前的做法是写一个手动拷贝block的函数将block拷贝一份，同时强制替换其签名，这样做的好处是该特殊block可以像普通的block一样调用，但实际上可以在block中捕获签名作为成员变量，这样可以避免拷贝block，但是调用的时候需要和普通的block区别对待。
目来还有不少语法功能未支持，目前以下这些语法都在酝酿中（其实基本已经实现，只是还需要调试），当然还有其他一些细节功能
1、调用父类方法，比如重写init方法，必然要调用父类init。
2、再比如最开始说的变长参数中的匿名参数，最常用的就是stringWithFormat。
3、不通过setter和getter，获取和修改对象的成员变量，比如懒加载重写getter的时候。
4、再比如Masonry的链式语法的支持（我自己也有一个UI创建的链式语法库，主要是为了支持它，😂😂😂）。
最后给一个ARM64程序调用标准的链接：Procedure Call Standard for the ARM 64-bit Architecture
网友评论