JavaScriptCore学习之JSPatch源码阅读

JS传递字符串给OC，OC通过Runtime接口调用和替换OC方法。

方法调用

1. require实现

var _require = function(clsName) {
if (!global[clsName]) {
global[clsName] = {
// _clsName表示这是一个OC的对象
__clsName: clsName
}
}
return global[clsName]
}

global.require = function(clsNames) {
var lastRequire
clsNames.split(',').forEach(function(clsName) {
lastRequire = _require(clsName.trim())
})
return lastRequire
}

__clsName

2. JS接口

__c()

UIView.alloc().init()

UIView.__c('alloc')().__c('init')()

__c()

__c

// 为Object的原型定义一个称之为__c的属性，它的值是返回一个function返回值的function，并且设置这个属性configurable:false, enumerable: false。
// JS通过这种为prototype原型添加属性的方式，为所有的JS对象都添加了这个方法。JS对象调用__c方法的时候，通过调用链就可以找到这个方法。
Object.defineProperty(Object.prototype, "__c", {value: function(methodName) {
// ??
if (this instanceof Boolean) {
return function() {
return false
}
}

// 如果对象的__obj和__clsName都是空，表明这是一个JS对象，在对象中查找并返回对应的方法即可
if (!this.__obj && !this.__clsName) {
// 如果在这个JS对象中根本没有这个方法，抛出异常
if (!this[methodName]) {
throw new Error(this + '.' + methodName + ' is undefined')
}
// 调用bind(this)跟JS的语法特性有关系，绑定返回的这个方法的上下文执行环境为这个对象自身，否则调用的时候，方法内部的this会指向其他离它最近的一个执行环境
return this[methodName].bind(this);
}

// 这里使用self变量保存this的原因是，如果我们直接返回这个function，在里面使用this，指向的就不是当前调用这个函数的对象，所以需要使用self保持this，当然也可以使用bind
var self = this
// 在调用super的时候，做了一个特殊处理
if (methodName == 'super') {
return function() {
if (self.__obj) {
self.__obj.__clsDeclaration = self.__clsDeclaration;
}
// 返回一个新的对象，这个对象的__isSuper标识等于1，在OC调用执行的时候，会判断这个标识来决定执行哪一个方法
return {__obj: self.__obj, __clsName: self.__clsName, __isSuper: 1}
}
}

/**
*  _methodFunc的作用是把JS的相关调用信息传递给OC，然后OC通过runtime来执行这些调用，返回结果
*/

if (methodName.indexOf('performSelector') > -1) {
if (methodName == 'performSelector') {
// return的这个function的作用是：直接调用OC对应的SEL，而不是通过OC调用performSelector，与最下面那个直接调用OC方法的function不同的是关于参数的处理
return function(){
var args = Array.prototype.slice.call(arguments)
return _methodFunc(self.__obj, self.__clsName, args[0], args.splice(1), self.__isSuper, true)
}
} else if (methodName == 'performSelectorInOC') {
// 这个与上面的区别在于，这里的调用是异步，为了防止出现线程竞争问题，调用完毕之后进行callback回调
// refer: https://github.com/bang590/JSPatch/wiki/performSelectorInOC-%E4%BD%BF%E7%94%A8%E6%96%87%E6%A1%A3 return function(){
var args = Array.prototype.slice.call(arguments)
return {__isPerformInOC:1, obj:self.__obj, clsName:self.__clsName, sel: args[0], args: args[1], cb: args[2]}
}
}
}

// return的这个function的作用是：处理参数，通过_methodFunc进行OC调用，然后返回执行结果
return function(){
var args = Array.prototype.slice.call(arguments)
return _methodFunc(self.__obj, self.__clsName, methodName, args, self.__isSuper)
}
}, configurable:false, enumerable: false})

3. 消息传递

_methodFunc

var _methodFunc = function(instance, clsName, methodName, args, isSuper, isPerformSelector) {
var selectorName = methodName
if (!isPerformSelector) {
// 首先对JS的函数名处理成OC的消息名称
// 如果OC的方法名中含有"_"，在JS中调用的时候需要变成"__"，例如OC中_privateMethod，在JS中是__privateMethod()
methodName = methodName.replace(/__/g, "-")
// 处理多参数方法名，例 indexPathForRow_inSection --> indexPathForRow:inSection:以及方法名中含有 "_" 做一下特殊处理
selectorName = methodName.replace(/_/g, ":").replace(/-/g, "_")
var marchArr = selectorName.match(/:/g)
var numOfArgs = marchArr ? marchArr.length : 0
if (args.length > numOfArgs) {
selectorName += ":"
}
}

// 通过self.__obj变量来判断要调用的方法是instance method还是class method
// _OC_call / _OC_callC方法是在OC中实现，然后export到JS中的
var ret = instance ? _OC_callI(instance, selectorName, args, isSuper):
_OC_callC(clsName, selectorName, args)
return _formatOCToJS(ret)
}

_OC_call

_OC_callC

_formatOCToJS

4. 对象持有/转换

UIView.alloc()

a. require('UIView') 这句话在JS全局变量作用域生成了 UIView 对象，它有个属性叫__isCls，表示这代表一个OC类。

b. 调用UIView这个对象的alloc()方法，会去到__c()函数，在这个函数里判断调用者 __isCls 属性，知道它是代表OC类，把方法名和类名传递给OC完成调用

__c()

__obj

__c()

return function(){
var args = Array.prototype.slice.call(arguments)
// self.__obj指向OC对象指针，self.__clsName是OC的class name。所以如果self.__obj有值，则表明这个JS对象是用来wrap OC对象指针的，这里的调用就变成了调用这个OC实例对象的方法。
return _methodFunc(self.__obj, self.__clsName, methodName, args, self.__isSuper)
}

static NSDictionary *_wrapObj(id obj)
{
if (!obj || obj == _nilObj) {
return @{@"__isNil": @(YES)};
}
return @{@"__obj": obj};
}

5. 类型转换

6. 示例

require(‘UIViewController')
var viewController = UIViewController.alloc().init() // UIViewController是如何找到它的alloc()方法的？返回的对象指针，又是如何找到它的init()方法的呢？
var view = viewController.view() // 这里返回一个UIView对象，为什么不需要执行require(‘UIView')?
view.setFrame({x:0, y:0, width:20, height:20}) //  view这个OC对象指针的JS wrapper是如何调用它的setFrame方法的？

方法替换/实现

1.基础原理

self

_cmd

"There are always at least 2 arguments, because an NSMethodSignature object includes the hidden arguments self and _cmd, which are the first two arguments passed to every method implementation."

XXX

_JPXXX

_objc_msgFroward

Use these functions to forward a message as if the receiver did not respond to it.

va_list

_JPXXX

_JSOverideMethods

2. JPForwardInvocation

// 表示这个OC对象是否已经被释放
BOOL deallocFlag = NO;
id slf = assignSlf;
// 初始化获取参数数量
NSMethodSignature *methodSignature = [invocation methodSignature];
NSInteger numberOfArguments = [methodSignature numberOfArguments];

// 转换调用的selector的名字为JSPatch中用来缓存JSValue *function的key的格式
NSString *selectorName = NSStringFromSelector(invocation.selector);
NSString *JPSelectorName = [NSString stringWithFormat:@"_JP%@", selectorName];
SEL JPSelector = NSSelectorFromString(JPSelectorName);

// 容错处理，查看是否有对应的JS函数的实现，没有的话，进入OC正常的消息转发流程
if (!class_respondsToSelector(object_getClass(slf), JPSelector)) {
JPExcuteORIGForwardInvocation(slf, selector, invocation);
return;
}

<Objective-C runtime programming Guide>

// 初始化数组，用来存储从NSInvocation中获取的参数列表，然后传递给对应的JS函数
NSMutableArray *argList = [[NSMutableArray alloc] init];
if ([slf class] == slf) {
// 如果是类方法，设置__clsName标识表明这是一个OC对象
[argList addObject:[JSValue valueWithObject:@{@"__clsName": NSStringFromClass([slf class])} inContext:_context]];
} else if ([selectorName isEqualToString:@"dealloc"]) {
// 针对要被释放的对象，使用assign来保存self指针
[argList addObject:[JPBoxing boxAssignObj:slf]];
deallocFlag = YES;
} else {
// 使用weak来保存self指针
[argList addObject:[JPBoxing boxWeakObj:slf]];
}

// NSInvocation的前两个参数分别为self和_cmd，所以直接从第3个参数开始获取
for (NSUInteger i = 2; i < numberOfArguments; i++) {
const char *argumentType = [methodSignature getArgumentTypeAtIndex:i];
// 判断返回值是否为const，如果const，获取后面的encoding来判断类型
switch(argumentType[0] == 'r' ? argumentType[1] : argumentType[0]) {

#define JP_FWD_ARG_CASE(_typeChar, _type) \
case _typeChar: {   \
_type arg;  \
// 从invocation中获取参数，并将参数添加到argList数组中
[invocation getArgument:&arg atIndex:i];    \
[argList addObject:@(arg)]; \
break;  \
}
JP_FWD_ARG_CASE('c', char)
JP_FWD_ARG_CASE('C', unsigned char)
JP_FWD_ARG_CASE('s', short)
JP_FWD_ARG_CASE('S', unsigned short)
JP_FWD_ARG_CASE('i', int)
JP_FWD_ARG_CASE('I', unsigned int)
JP_FWD_ARG_CASE('l', long)
JP_FWD_ARG_CASE('L', unsigned long)
JP_FWD_ARG_CASE('q', long long)
JP_FWD_ARG_CASE('Q', unsigned long long)
JP_FWD_ARG_CASE('f', float)
JP_FWD_ARG_CASE('d', double)
JP_FWD_ARG_CASE('B', BOOL)
case '@': {
// 处理id类型的参数，使用__unsafe_unretianed参数，避免内存泄露???
__unsafe_unretained id arg;
[invocation getArgument:&arg atIndex:i];
// 对于block参数做特殊处理，需要进行copy；使用_nilObj表示nil，让参数可以完整传递给JS
if ([arg isKindOfClass:NSClassFromString(@"NSBlock")]) {
[argList addObject:(arg ? [arg copy]: _nilObj)];
} else {
[argList addObject:(arg ? arg: _nilObj)];
}
break;
}
case '{': {
// 处理结构体类型参数
// 获取结构体类型的名称，然后根据这个把参数包装为JSValue类型
NSString *typeString = extractStructName([NSString stringWithUTF8String:argumentType]);
#define JP_FWD_ARG_STRUCT(_type, _transFunc) \
if ([typeString rangeOfString:@#_type].location != NSNotFound) {    \
_type arg; \
[invocation getArgument:&arg atIndex:i];    \
[argList addObject:[JSValue _transFunc:arg inContext:_context]];  \
break; \
}
JP_FWD_ARG_STRUCT(CGRect, valueWithRect)
JP_FWD_ARG_STRUCT(CGPoint, valueWithPoint)
JP_FWD_ARG_STRUCT(CGSize, valueWithSize)
JP_FWD_ARG_STRUCT(NSRange, valueWithRange)

// 处理自定义类型的结构体
@synchronized (_context) {
NSDictionary *structDefine = _registeredStruct[typeString];
if (structDefine) {
size_t size = sizeOfStructTypes(structDefine[@"types"]);
if (size) {
void *ret = malloc(size);
[invocation getArgument:ret atIndex:i];
NSDictionary *dict = getDictOfStruct(ret, structDefine);
[argList addObject:[JSValue valueWithObject:dict inContext:_context]];
free(ret);
break;
}
}
}

break;
}
case ':': {
// 处理selector类型参数
SEL selector;
[invocation getArgument:&selector atIndex:i];
NSString *selectorName = NSStringFromSelector(selector);
[argList addObject:(selectorName ? selectorName: _nilObj)];
break;
}
case '^':
case '*': {
// 处理指针类型
void *arg;
[invocation getArgument:&arg atIndex:i];
[argList addObject:[JPBoxing boxPointer:arg]];
break;
}
case '#': {
// Class类类型
Class arg;
[invocation getArgument:&arg atIndex:i];
[argList addObject:[JPBoxing boxClass:arg]];
break;
}
default: {
NSLog(@"error type %s", argumentType);
break;
}
}
}

// 将OC的对象转换为对应的JS类型
static id formatOCToJS(id obj)
{
// 对于这四种类型的数据，其中的NSArray/NSString/NSDictionary类型，JavaScriptCore是支持JS与OC之间的转换的，但是JSPatch对他们做了特殊的处理，所以在JS中下面这些数据的使用跟普通的NSObject一样，如果要使用对应的JS类型，使用toJS()接口转换一下即可。参考：https://github.com/bang590/JSPatch/wiki/JSPatch-%E5%9F%BA%E7%A1%80%E7%94%A8%E6%B3%95#5-nsarray--nsstring--nsdictionary
if ([obj isKindOfClass:[NSString class]] || [obj isKindOfClass:[NSDictionary class]] || [obj isKindOfClass:[NSArray class]] || [obj isKindOfClass:[NSDate class]]) {
return _wrapObj([JPBoxing boxObj:obj]);
}
// 对于NSNumber/NSBlock/JSValue则直接传递这个对象给JS即可
if ([obj isKindOfClass:[NSNumber class]] || [obj isKindOfClass:NSClassFromString(@"NSBlock")] || [obj isKindOfClass:[JSValue class]]) {
return obj;
}
// 否则，对于不在特殊处理范围之内的对象，转换为NSDictioanry的封装 {"__obj":obj} ，用于在JS中识别这是一个OC对象
return _wrapObj(obj);
}

// _formatOCToJSList通过调用formatOCToJS将参数数组转为对应的JS对象数组
NSArray *params = _formatOCToJSList(argList);
// 获取这个method返回值的类型
const char *returnType = [methodSignature methodReturnType];

// 判断返回值是否为const，如果const，获取后面的encoding来判断类型
switch (returnType[0] == 'r' ? returnType[1] : returnType[0]) {
#define JP_FWD_RET_CALL_JS \
// 通过JPSelectorName，获取在overrideMethod()函数中保存的指向对应JS实现的函数指针
JSValue *fun = getJSFunctionInObjectHierachy(slf, JPSelectorName); \
JSValue *jsval; \
[_JSMethodForwardCallLock lock];   \
// 通过JSValue *function这个JS函数指针，调用对应的JS实现，同时传入之前处理得到的参数列表params
jsval = [fun callWithArguments:params]; \
[_JSMethodForwardCallLock unlock]; \
// 如果这个JS函数是特殊的调用，即performSelectorInOC，则直接通过callSelector函数在OC中直接调用处理，参考：https://github.com/bang590/JSPatch/wiki/performSelectorInOC-%E4%BD%BF%E7%94%A8%E6%96%87%E6%A1%A3
while (![jsval isNull] && ![jsval isUndefined] && [jsval hasProperty:@"__isPerformInOC"]) { \
NSArray *args = nil;  \
JSValue *cb = jsval[@"cb"]; \
if ([jsval hasProperty:@"sel"]) {   \
// 直接通过OC调用这个方法
id callRet = callSelector(![jsval[@"clsName"] isUndefined] ? [jsval[@"clsName"] toString] : nil, [jsval[@"sel"] toString], jsval[@"args"], ![jsval[@"obj"] isUndefined] ? jsval[@"obj"] : nil, NO);  \
// 处理调用返回结果，将返回的OC结果处理为JS调用适合的参数类型
args = @[[_context[@"_formatOCToJS"] callWithArguments:callRet ? @[callRet] : _formatOCToJSList(@[_nilObj])]];  \
}   \
[_JSMethodForwardCallLock lock];    \
// 使用之前处理过的参数，执行JS回调
jsval = [cb callWithArguments:args];  \
[_JSMethodForwardCallLock unlock];  \
}

// 根据返回结果的encoding，来设置返回结果的return value
#define JP_FWD_RET_CASE_RET(_typeChar, _type, _retCode)   \
case _typeChar : { \
JP_FWD_RET_CALL_JS \
_retCode \
[invocation setReturnValue:&ret];\
break;  \
}

#define JP_FWD_RET_CASE(_typeChar, _type, _typeSelector)   \
JP_FWD_RET_CASE_RET(_typeChar, _type, _type ret = [[jsval toObject] _typeSelector];)   \

#define JP_FWD_RET_CODE_ID \
id __autoreleasing ret = formatJSToOC(jsval); \
if (ret == _nilObj ||   \
([ret isKindOfClass:[NSNumber class]] && strcmp([ret objCType], "c") == 0 && ![ret boolValue])) ret = nil;  \

#define JP_FWD_RET_CODE_POINTER    \
void *ret; \
id obj = formatJSToOC(jsval); \
if ([obj isKindOfClass:[JPBoxing class]]) { \
ret = [((JPBoxing *)obj) unboxPointer]; \
}

#define JP_FWD_RET_CODE_CLASS    \
Class ret;   \
id obj = formatJSToOC(jsval); \
if ([obj isKindOfClass:[JPBoxing class]]) { \
ret = [((JPBoxing *)obj) unboxClass]; \
}

#define JP_FWD_RET_CODE_SEL    \
SEL ret;   \
id obj = formatJSToOC(jsval); \
if ([obj isKindOfClass:[NSString class]]) { \
ret = NSSelectorFromString(obj); \
}

JP_FWD_RET_CASE_RET('@', id, JP_FWD_RET_CODE_ID)
JP_FWD_RET_CASE_RET('^', void*, JP_FWD_RET_CODE_POINTER)
JP_FWD_RET_CASE_RET('*', void*, JP_FWD_RET_CODE_POINTER)
JP_FWD_RET_CASE_RET('#', Class, JP_FWD_RET_CODE_CLASS)
JP_FWD_RET_CASE_RET(':', SEL, JP_FWD_RET_CODE_SEL)

JP_FWD_RET_CASE('c', char, charValue)
JP_FWD_RET_CASE('C', unsigned char, unsignedCharValue)
JP_FWD_RET_CASE('s', short, shortValue)
JP_FWD_RET_CASE('S', unsigned short, unsignedShortValue)
JP_FWD_RET_CASE('i', int, intValue)
JP_FWD_RET_CASE('I', unsigned int, unsignedIntValue)
JP_FWD_RET_CASE('l', long, longValue)
JP_FWD_RET_CASE('L', unsigned long, unsignedLongValue)
JP_FWD_RET_CASE('q', long long, longLongValue)
JP_FWD_RET_CASE('Q', unsigned long long, unsignedLongLongValue)
JP_FWD_RET_CASE('f', float, floatValue)
JP_FWD_RET_CASE('d', double, doubleValue)
JP_FWD_RET_CASE('B', BOOL, boolValue)

case 'v': {
JP_FWD_RET_CALL_JS
break;
}

case '{': {
NSString *typeString = extractStructName([NSString stringWithUTF8String:returnType]);
#define JP_FWD_RET_STRUCT(_type, _funcSuffix) \
if ([typeString rangeOfString:@#_type].location != NSNotFound) {    \
JP_FWD_RET_CALL_JS \
_type ret = [jsval _funcSuffix]; \
[invocation setReturnValue:&ret];\
break;  \
}
JP_FWD_RET_STRUCT(CGRect, toRect)
JP_FWD_RET_STRUCT(CGPoint, toPoint)
JP_FWD_RET_STRUCT(CGSize, toSize)
JP_FWD_RET_STRUCT(NSRange, toRange)

@synchronized (_context) {
NSDictionary *structDefine = _registeredStruct[typeString];
if (structDefine) {
size_t size = sizeOfStructTypes(structDefine[@"types"]);
JP_FWD_RET_CALL_JS
void *ret = malloc(size);
NSDictionary *dict = formatJSToOC(jsval);
getStructDataWithDict(ret, dict, structDefine);
[invocation setReturnValue:ret];
free(ret);
}
}
break;
}
default: {
break;
}
}

// 如果hook的是dealloc方法，则不能通过调用ORIGXXX()的方式来调用原dealloc方法
if (deallocFlag) {
slf = nil;
Class instClass = object_getClass(assignSlf);
Method deallocMethod = class_getInstanceMethod(instClass, NSSelectorFromString(@"ORIGdealloc"));
// 获取原dealloc的IMP指针，然后直接调用dealloc，防止产生内存泄露
void (*originalDealloc)(__unsafe_unretained id, SEL) = (__typeof__(originalDealloc))method_getImplementation(deallocMethod);
originalDealloc(assignSlf, NSSelectorFromString(@"dealloc"));
}

OC调用