| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| |
| #import "WXBridgeContext.h" |
| #import "WXJSCoreBridge.h" |
| #import "WXLog.h" |
| #import "WXUtility.h" |
| #import "WXModuleFactory.h" |
| #import "WXModuleProtocol.h" |
| #import "WXUtility.h" |
| #import "WXSDKError.h" |
| #import "WXMonitor.h" |
| #import "WXAssert.h" |
| #import "WXSDKManager.h" |
| #import "WXDebugTool.h" |
| #import "WXSDKInstance_private.h" |
| #import "WXAppConfiguration.h" |
| #import "WXInvocationConfig.h" |
| #import "WXComponentMethod.h" |
| #import "WXModuleMethod.h" |
| #import "WXCallJSMethod.h" |
| #import "WXSDKInstance_private.h" |
| #import "WXPrerenderManager.h" |
| #import "WXExceptionUtils.h" |
| #import "WXSDKEngine.h" |
| #import "WXPolyfillSet.h" |
| #import "WXJSExceptionProtocol.h" |
| #import "WXMonitor.h" |
| #import "WXAppMonitorProtocol.h" |
| #import "WXConfigCenterProtocol.h" |
| #import "WXSDKInstance_performance.h" |
| #import "JSContext+Weex.h" |
| #import "WXCoreBridge.h" |
| #import "WXJSFrameworkLoadProtocol.h" |
| #import "WXJSFrameworkLoadDefaultImpl.h" |
| #import "WXHandlerFactory.h" |
| #import "WXExtendCallNativeManager.h" |
| #import "WXDataRenderHandler.h" |
| |
| #define SuppressPerformSelectorLeakWarning(Stuff) \ |
| do { \ |
| _Pragma("clang diagnostic push") \ |
| _Pragma("clang diagnostic ignored \"-Warc-performSelector-leaks\"") \ |
| Stuff; \ |
| _Pragma("clang diagnostic pop") \ |
| } while (0) |
| |
| @interface WXBridgeContext () |
| |
| @property (nonatomic, strong) id<WXBridgeProtocol> jsBridge; |
| @property (nonatomic, strong) id<WXBridgeProtocol> devToolSocketBridge; |
| @property (nonatomic, assign) BOOL debugJS; |
| //store the methods which will be executed from native to js |
| @property (nonatomic, strong) NSMutableDictionary *sendQueue; |
| //the instance stack |
| @property (nonatomic, strong) NSMutableArray *insStack; |
| //identify if the JSFramework has been loaded |
| @property (nonatomic) BOOL frameworkLoadFinished; |
| //store some methods temporarily before JSFramework is loaded |
| @property (nonatomic, strong) NSMutableArray *methodQueue; |
| // store service |
| @property (nonatomic, strong) NSMutableArray *jsServiceQueue; |
| |
| @property (nonatomic, readonly) id<WXDataRenderHandler> dataRenderHandler; |
| |
| @end |
| |
| @implementation WXBridgeContext |
| |
| @synthesize dataRenderHandler = _dataRenderHandler; |
| |
| - (instancetype) init |
| { |
| self = [super init]; |
| if (self) { |
| _methodQueue = [NSMutableArray new]; |
| _frameworkLoadFinished = NO; |
| _jsServiceQueue = [NSMutableArray new]; |
| _dataRenderHandler = [WXHandlerFactory handlerForProtocol:@protocol(WXDataRenderHandler)]; |
| if (!_dataRenderHandler) { |
| Class handlerClass = NSClassFromString(@"WXEagleHandler"); |
| if (handlerClass) { |
| _dataRenderHandler = [[handlerClass alloc] init]; |
| [WXSDKEngine registerHandler:_dataRenderHandler withProtocol:@protocol(WXDataRenderHandler)]; |
| } |
| } |
| } |
| return self; |
| } |
| |
| - (id<WXBridgeProtocol>)jsBridge |
| { |
| WXAssertBridgeThread(); |
| _debugJS = [WXDebugTool isDevToolDebug]; |
| |
| Class bridgeClass = _debugJS ? NSClassFromString(@"WXDebugger") : [WXJSCoreBridge class]; |
| |
| if (_jsBridge && [_jsBridge isKindOfClass:bridgeClass]) { |
| return _jsBridge; |
| } |
| |
| if (_jsBridge) { |
| [_methodQueue removeAllObjects]; |
| _frameworkLoadFinished = NO; |
| } |
| |
| // WXDebugger is a singleton actually and should not call its init twice. |
| _jsBridge = _debugJS ? [NSClassFromString(@"WXDebugger") alloc] : [[WXJSCoreBridge alloc] init]; |
| |
| [self registerGlobalFunctions]; |
| |
| return _jsBridge; |
| } |
| |
| - (NSInteger)checkInstance:(WXSDKInstance *)instance |
| { |
| if (!instance) { |
| WXLogInfo(@"instance not found, maybe already destroyed"); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| - (void)registerGlobalFunctions |
| { |
| __weak typeof(self) weakSelf = self; |
| [_jsBridge registerCallNative:^NSInteger(NSString *instance, NSArray *tasks, NSString *callback) { |
| return [weakSelf invokeNative:instance tasks:tasks callback:callback]; |
| }]; |
| |
| [_jsBridge registerCallUpdateComponentData:^NSInteger(NSString *instanceId, NSString *componentId, NSString *jsonData) { |
| if (weakSelf.dataRenderHandler) { |
| WXPerformBlockOnComponentThread(^{ |
| long start = [WXUtility getUnixFixTimeMillis]; |
| WXSDKInstance *instance = [WXSDKManager instanceForID:instanceId]; |
| [instance.apmInstance addUpdateComponentDataTimestamp:start]; |
| [weakSelf.dataRenderHandler callUpdateComponentData:instanceId componentId:componentId jsonData:jsonData]; |
| [instance.apmInstance addUpdateComponentDataTime:[WXUtility getUnixFixTimeMillis] - start]; |
| }); |
| } |
| else { |
| WXSDKInstance *instance = [WXSDKManager instanceForID:instanceId]; |
| WXComponentManager *manager = instance.componentManager; |
| if (manager.isValid) { |
| WXSDKErrCode errorCode = WX_KEY_EXCEPTION_DEGRADE_EAGLE_RENDER_ERROR; |
| NSError *error = [NSError errorWithDomain:WX_ERROR_DOMAIN code:errorCode userInfo:@{@"message":@"No data render handler found!"}]; |
| WXPerformBlockOnComponentThread(^{ |
| [manager renderFailed:error]; |
| }); |
| } |
| } |
| return 0; |
| }]; |
| |
| [_jsBridge registerCallAddElement:^NSInteger(NSString *instanceId, NSString *parentRef, NSDictionary *elementData, NSInteger index) { |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callAddElement:instanceId parentRef:parentRef data:elementData index:(int)index]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callAddElement:instanceId parentRef:parentRef data:elementData index:(int)index]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| |
| [_jsBridge registerCallCreateBody:^NSInteger(NSString *instanceId, NSDictionary *bodyData) { |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callCreateBody:instanceId data:bodyData]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callCreateBody:instanceId data:bodyData]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| |
| [_jsBridge registerCallRemoveElement:^NSInteger(NSString *instanceId, NSString *ref) { |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callRemoveElement:instanceId ref:ref]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callRemoveElement:instanceId ref:ref]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| |
| [_jsBridge registerCallMoveElement:^NSInteger(NSString *instanceId, NSString *ref, NSString *parentRef, NSInteger index) { |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callMoveElement:instanceId ref:ref parentRef:parentRef index:(int)index]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callMoveElement:instanceId ref:ref parentRef:parentRef index:(int)index]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| |
| [_jsBridge registerCallUpdateAttrs:^NSInteger(NSString *instanceId, NSString *ref, NSDictionary *attrsData) { |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callUpdateAttrs:instanceId ref:ref data:attrsData]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callUpdateAttrs:instanceId ref:ref data:attrsData]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| |
| [_jsBridge registerCallUpdateStyle:^NSInteger(NSString *instanceId, NSString *ref, NSDictionary *stylesData) { |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callUpdateStyle:instanceId ref:ref data:stylesData]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callUpdateStyle:instanceId ref:ref data:stylesData]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| |
| [_jsBridge registerCallAddEvent:^NSInteger(NSString *instanceId, NSString *ref, NSString *event) { |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callAddEvent:instanceId ref:ref event:event]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callAddEvent:instanceId ref:ref event:event]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| |
| [_jsBridge registerCallRemoveEvent:^NSInteger(NSString *instanceId, NSString *ref, NSString *event) { |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callRemoveEvent:instanceId ref:ref event:event]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callRemoveEvent:instanceId ref:ref event:event]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| |
| [_jsBridge registerCallCreateFinish:^NSInteger(NSString *instanceId) { |
| |
| WXSDKInstance *instance = [WXSDKManager instanceForID:instanceId]; |
| [instance.apmInstance onStage:KEY_PAGE_STAGES_CREATE_FINISH]; |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callCreateFinish:instanceId]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callCreateFinish:instanceId]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| |
| if ([_jsBridge respondsToSelector:@selector(registerCallRefreshFinish:)]) { |
| [_jsBridge registerCallRefreshFinish:^NSInteger(NSString *instanceId) { |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callRefreshFinish:instanceId]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callRefreshFinish:instanceId]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| } |
| |
| if ([_jsBridge respondsToSelector:@selector(registerCallUpdateFinish:)]) { |
| [_jsBridge registerCallUpdateFinish:^NSInteger(NSString *instanceId) { |
| |
| if ([WXCustomPageBridge isCustomPage:instanceId]) { |
| [[WXCustomPageBridge sharedInstance] callUpdateFinish:instanceId]; |
| } |
| else { |
| WXPerformBlockOnComponentThread(^{ |
| [WXCoreBridge callUpdateFinish:instanceId]; |
| }); |
| } |
| |
| return 0; |
| }]; |
| } |
| |
| [_jsBridge registerCallNativeModule:^NSInvocation*(NSString *instanceId, NSString *moduleName, NSString *methodName, NSArray *arguments, NSDictionary *options) { |
| WXSDKInstance *instance = [WXSDKManager instanceForID:instanceId]; |
| |
| if (!instance) { |
| WXLogInfo(@"instance not found for callNativeModule:%@.%@, maybe already destroyed", moduleName, methodName); |
| return nil; |
| } |
| |
| #ifdef DEBUG |
| WXLogDebug(@"flexLayout -> action: callNativeModule : %@ . %@",moduleName,methodName); |
| #endif |
| NSMutableDictionary * newOptions = options ? [options mutableCopy] : [NSMutableDictionary new]; |
| NSMutableArray * newArguments = [arguments mutableCopy]; |
| |
| if ([instance.bundleType.lowercaseString isEqualToString:@"rax"]) { |
| // we need to adjust __weex_options__ params in arguments to options compatible with rax javaScript framework. |
| NSDictionary * weexOptions = nil; |
| for(int i = 0;i < [arguments count]; i ++) { |
| if ([arguments[i] isKindOfClass:[NSDictionary class]]) { |
| NSDictionary * dict = (NSDictionary*)arguments[i]; |
| if (dict[@"__weex_options__"] && [dict[@"__weex_options__"] isKindOfClass:[NSDictionary class]]) { |
| weexOptions = dict; |
| [newOptions addEntriesFromDictionary:(NSDictionary*)(weexOptions[@"__weex_options__"])]; |
| } |
| } |
| } |
| if (weexOptions) { |
| [newArguments removeObject:weexOptions]; |
| } |
| } |
| WXModuleMethod *method = [[WXModuleMethod alloc] initWithModuleName:moduleName methodName:methodName arguments:[newArguments copy] options:[newOptions copy] instance:instance]; |
| if(![moduleName isEqualToString:@"dom"] && instance.needPrerender){ |
| [WXPrerenderManager storePrerenderModuleTasks:method forUrl:instance.scriptURL.absoluteString]; |
| return nil; |
| } |
| |
| BOOL intercepted = [instance moduleInterceptWithModuleName:moduleName methodName:methodName arguments:[newArguments copy] options:[newOptions copy]]; |
| if (intercepted) { |
| return nil; |
| } |
| return [method invoke]; |
| }]; |
| |
| [_jsBridge registerCallNativeComponent:^void(NSString *instanceId, NSString *componentRef, NSString *methodName, NSArray *args, NSDictionary *options) { |
| |
| #ifdef DEBUG |
| WXLogDebug(@"flexLayout -> action: callNativeComponent ref:%@",componentRef); |
| #endif |
| |
| WXSDKInstance *instance = [WXSDKManager instanceForID:instanceId]; |
| WXComponentMethod *method = [[WXComponentMethod alloc] initWithComponentRef:componentRef methodName:methodName arguments:args instance:instance]; |
| [method invoke]; |
| }]; |
| } |
| |
| - (NSMutableArray *)insStack |
| { |
| if (_insStack) return _insStack; |
| |
| _insStack = [NSMutableArray array]; |
| |
| return _insStack; |
| } |
| |
| - (WXSDKInstance *)topInstance |
| { |
| WXSDKInstance *topInstance = nil; |
| @synchronized(self) { |
| if (self.insStack.count > 0) { |
| topInstance = [WXSDKManager instanceForID:[self.insStack firstObject]]; |
| } |
| } |
| return topInstance; |
| } |
| |
| - (NSMutableDictionary *)sendQueue |
| { |
| WXAssertBridgeThread(); |
| |
| if (_sendQueue) return _sendQueue; |
| |
| _sendQueue = [NSMutableDictionary dictionary]; |
| |
| return _sendQueue; |
| } |
| |
| #pragma mark JS Bridge Management |
| |
| - (NSInteger)invokeNative:(NSString *)instanceId tasks:(NSArray *)tasks callback:(NSString __unused*)callback |
| { |
| WXAssertBridgeThread(); |
| |
| if (!instanceId || !tasks) { |
| WX_MONITOR_FAIL(WXMTNativeRender, WX_ERR_JSFUNC_PARAM, @"JS call Native params error!"); |
| return 0; |
| } |
| |
| WXSDKInstance *instance = [WXSDKManager instanceForID:instanceId]; |
| if (!instance) { |
| WXLogInfo(@"instance already destroyed, task ignored"); |
| return -1; |
| } |
| |
| NSTimeInterval startTime = CACurrentMediaTime()*1000; |
| |
| for (NSDictionary *task in tasks) { |
| NSString *methodName = task[@"method"]; |
| NSArray *arguments = task[@"args"]; |
| if (task[@"component"]) { |
| NSString *ref = task[@"ref"]; |
| WXComponentMethod *method = [[WXComponentMethod alloc] initWithComponentRef:ref methodName:methodName arguments:arguments instance:instance]; |
| [method invoke]; |
| } else { |
| NSString *moduleName = task[@"module"]; |
| NSDictionary *options = task[@"options"]; |
| WXModuleMethod *method = [[WXModuleMethod alloc] initWithModuleName:moduleName methodName:methodName arguments:arguments options:options instance:instance]; |
| [method invoke]; |
| } |
| } |
| |
| [self performSelector:@selector(_sendQueueLoop) withObject:nil]; |
| if (!instance.isJSCreateFinish) { |
| NSTimeInterval diff = CACurrentMediaTime()*1000-startTime; |
| instance.performance.fsCallNativeNum++; |
| instance.performance.fsCallNativeTime = instance.performance.fsCallNativeTime + diff; |
| } |
| if (instance && !instance.apmInstance.isFSEnd) { |
| NSTimeInterval diff = CACurrentMediaTime()*1000 - startTime; |
| [instance.apmInstance updateFSDiffStats:KEY_PAGE_STATS_FS_CALL_NATIVE_NUM withDiffValue:1]; |
| [instance.apmInstance updateFSDiffStats:KEY_PAGE_STATS_FS_CALL_NATIVE_TIME withDiffValue:diff]; |
| } |
| return 1; |
| } |
| |
| - (void)createInstance:(NSString *)instanceIdString |
| template:(NSString *)jsBundleString |
| options:(NSDictionary *)options |
| data:(id)data |
| { |
| WXAssertBridgeThread(); |
| WXAssertParam(instanceIdString); |
| |
| @synchronized(self) { |
| if (![self.insStack containsObject:instanceIdString]) { |
| if ([options[@"RENDER_IN_ORDER"] boolValue]) { |
| [self.insStack addObject:instanceIdString]; |
| } else { |
| [self.insStack insertObject:instanceIdString atIndex:0]; |
| } |
| } |
| } |
| WXSDKInstance *sdkInstance = [WXSDKManager instanceForID:instanceIdString]; |
| if (!sdkInstance) { |
| return; |
| } |
| [sdkInstance.apmInstance onStage:KEY_PAGE_STAGES_LOAD_BUNDLE_START]; |
| |
| //create a sendQueue bind to the current instance |
| NSMutableArray *sendQueue = [NSMutableArray array]; |
| [self.sendQueue setValue:sendQueue forKey:instanceIdString]; |
| |
| if (sdkInstance.dataRender && ![options[@"EXEC_JS"] boolValue]) { |
| if (_dataRenderHandler) { |
| WXPerformBlockOnComponentThread(^{ |
| [_dataRenderHandler createPage:instanceIdString template:jsBundleString options:options data:data]; |
| }); |
| } |
| else { |
| WXComponentManager *manager = sdkInstance.componentManager; |
| if (manager.isValid) { |
| WXSDKErrCode errorCode = WX_KEY_EXCEPTION_DEGRADE_EAGLE_RENDER_ERROR; |
| NSError *error = [NSError errorWithDomain:WX_ERROR_DOMAIN code:errorCode userInfo:@{@"message":@"No data render handler found!"}]; |
| WXPerformBlockOnComponentThread(^{ |
| [manager renderFailed:error]; |
| }); |
| } |
| } |
| return; |
| } |
| |
| NSArray *args = nil; |
| WX_MONITOR_INSTANCE_PERF_START(WXFirstScreenJSFExecuteTime, [WXSDKManager instanceForID:instanceIdString]); |
| WX_MONITOR_INSTANCE_PERF_START(WXPTJSCreateInstance, [WXSDKManager instanceForID:instanceIdString]); |
| |
| NSString * bundleType = [self _pareJSBundleType:instanceIdString jsBundleString:jsBundleString]; // bundleType can be Vue, Rax and the new framework. |
| if (bundleType) { |
| [sdkInstance.apmInstance setProperty:KEY_PAGE_PROPERTIES_BUNDLE_TYPE withValue:bundleType]; |
| NSMutableDictionary *newOptions = [options mutableCopy]; |
| if (!options) { |
| newOptions = [NSMutableDictionary new]; |
| } |
| NSDictionary* immutableEnvDict = [[WXUtility getEnvironment] copy]; |
| if (immutableEnvDict) { |
| [newOptions addEntriesFromDictionary:@{@"env":immutableEnvDict}]; |
| } |
| newOptions[@"bundleType"] = bundleType; |
| __block NSString *raxAPIScript = nil; |
| __block NSString *raxAPIScriptPath = nil; |
| id<WXJSFrameworkLoadProtocol> handler = [WXHandlerFactory handlerForProtocol:@protocol(WXJSFrameworkLoadProtocol)]; |
| sdkInstance.bundleType = bundleType; |
| if ([bundleType.lowercaseString isEqualToString:@"rax"]) { |
| if (handler && [handler respondsToSelector:@selector(loadRaxFramework:)]) { |
| [handler loadRaxFramework:^(NSString *path, NSString *script) { |
| raxAPIScriptPath = path; |
| raxAPIScript = script; |
| }]; |
| } |
| } |
| if ([WXDebugTool isDevToolDebug]) { |
| [self callJSMethod:@"createInstanceContext" args:@[instanceIdString, newOptions, data?:@[],raxAPIScript?:@""]]; |
| |
| if ([NSURL URLWithString:sdkInstance.pageName]) { |
| [sdkInstance.instanceJavaScriptContext executeJavascript:jsBundleString withSourceURL:[NSURL URLWithString:sdkInstance.pageName]]; |
| } else { |
| [sdkInstance.instanceJavaScriptContext executeJavascript:jsBundleString]; |
| } |
| } else { |
| NSDictionary* immutableOptions = [newOptions copy]; |
| sdkInstance.callCreateInstanceContext = [NSString stringWithFormat:@"instanceId:%@\noptions:%@\ndata:%@", instanceIdString, immutableOptions, data]; |
| //add instanceId to weexContext ,if fucn createInstanceContext failure ，then we will know which instance has problem (exceptionhandler) |
| self.jsBridge.javaScriptContext[@"wxExtFuncInfo"]= @{ |
| @"func":@"createInstanceContext", |
| @"arg":@"start", |
| @"instanceId":sdkInstance.instanceId?:@"unknownId" |
| }; |
| __weak typeof(self) weakSelf = self; |
| [sdkInstance.apmInstance onStage:KEY_PAGE_STAGES_LOAD_BUNDLE_END]; |
| [self callJSMethod:@"createInstanceContext" args:@[instanceIdString, immutableOptions, data?:@[]] onContext:nil completion:^(JSValue *instanceContextEnvironment) { |
| if (sdkInstance.pageName) { |
| [sdkInstance.instanceJavaScriptContext.javaScriptContext setName:sdkInstance.pageName]; |
| } |
| weakSelf.jsBridge.javaScriptContext[@"wxExtFuncInfo"]= nil; |
| |
| NSArray* allKeys = [WXUtility extractPropertyNamesOfJSValueObject:instanceContextEnvironment]; |
| sdkInstance.createInstanceContextResult = [NSString stringWithFormat:@"%@", allKeys]; |
| JSGlobalContextRef instanceContextRef = sdkInstance.instanceJavaScriptContext.javaScriptContext.JSGlobalContextRef; |
| JSObjectRef instanceGlobalObject = JSContextGetGlobalObject(instanceContextRef); |
| |
| for (NSString * key in allKeys) { |
| JSStringRef propertyName = JSStringCreateWithUTF8CString([key cStringUsingEncoding:NSUTF8StringEncoding]); |
| if ([key isEqualToString:@"Vue"]) { |
| JSObjectSetPrototype(instanceContextRef, JSValueToObject(instanceContextRef, [instanceContextEnvironment valueForProperty:key].JSValueRef, NULL), JSObjectGetPrototype(instanceContextRef, instanceGlobalObject)); |
| } |
| JSObjectSetProperty(instanceContextRef, instanceGlobalObject, propertyName, [instanceContextEnvironment valueForProperty:key].JSValueRef, 0, NULL); |
| JSStringRelease(propertyName); |
| } |
| |
| if (WX_SYS_VERSION_LESS_THAN(@"10.2")) { |
| if (handler && [handler respondsToSelector:@selector(loadPolyfillFramework:)]) { |
| [handler loadPolyfillFramework:^(NSString *path, NSString *script) { |
| if (script) { |
| [sdkInstance.instanceJavaScriptContext executeJavascript:script withSourceURL:[NSURL URLWithString:path]]; |
| } else { |
| WXLogError(@"weex-pollyfill can not found"); |
| } |
| }]; |
| } |
| } |
| |
| if (raxAPIScript) { |
| [sdkInstance.instanceJavaScriptContext executeJavascript:raxAPIScript withSourceURL:[NSURL URLWithString:raxAPIScriptPath]]; |
| NSArray* allKeys = [WXUtility extractPropertyNamesOfJSValueObject:sdkInstance.instanceJavaScriptContext.javaScriptContext.globalObject]; |
| sdkInstance.executeRaxApiResult = [NSString stringWithFormat:@"%@", allKeys]; |
| } |
| |
| NSDictionary* funcInfo = @{ |
| @"func":@"createInstance", |
| @"arg":@"start", |
| @"instanceId":sdkInstance.instanceId?:@"unknownId" |
| }; |
| sdkInstance.instanceJavaScriptContext.javaScriptContext[@"wxExtFuncInfo"]= funcInfo; |
| if ([NSURL URLWithString:sdkInstance.pageName] || sdkInstance.scriptURL) { |
| [sdkInstance.instanceJavaScriptContext executeJavascript:jsBundleString withSourceURL:[NSURL URLWithString:sdkInstance.pageName]?:sdkInstance.scriptURL]; |
| } else { |
| [sdkInstance.instanceJavaScriptContext executeJavascript:jsBundleString]; |
| } |
| sdkInstance.instanceJavaScriptContext.javaScriptContext[@"wxExtFuncInfo"] = nil; |
| [sdkInstance.apmInstance onStage:KEY_PAGE_STAGES_EXECUTE_BUNDLE_END]; |
| WX_MONITOR_INSTANCE_PERF_END(WXPTJSCreateInstance, [WXSDKManager instanceForID:instanceIdString]); |
| }]; |
| } |
| |
| } else { |
| [sdkInstance.apmInstance setProperty:KEY_PAGE_PROPERTIES_BUNDLE_TYPE withValue:@"other"]; |
| [sdkInstance.apmInstance onStage:KEY_PAGE_STAGES_LOAD_BUNDLE_END]; |
| if (data){ |
| args = @[instanceIdString, jsBundleString, options ?: @{}, data]; |
| } else { |
| args = @[instanceIdString, jsBundleString, options ?: @{}]; |
| } |
| NSDictionary* funcInfo = @{ |
| @"func":@"createInstance", |
| @"arg":@"start", |
| @"instanceId":sdkInstance.instanceId?:@"unknownId" |
| }; |
| sdkInstance.instanceJavaScriptContext.javaScriptContext[@"wxExtFuncInfo"] = funcInfo; |
| [self callJSMethod:@"createInstance" args:args]; |
| sdkInstance.instanceJavaScriptContext.javaScriptContext[@"wxExtFuncInfo"] = nil; |
| [sdkInstance.apmInstance onStage:KEY_PAGE_STAGES_EXECUTE_BUNDLE_END]; |
| WX_MONITOR_INSTANCE_PERF_END(WXPTJSCreateInstance, [WXSDKManager instanceForID:instanceIdString]); |
| } |
| } |
| |
| - (BOOL) _shouldMountExtInfoToInstanceContxt |
| { |
| id configCenter = [WXSDKEngine handlerForProtocol:@protocol(WXConfigCenterProtocol)]; |
| BOOL shouldMountInstanceContextExtInfo = YES; |
| if ([configCenter respondsToSelector:@selector(configForKey:defaultValue:isDefault:)]) { |
| shouldMountInstanceContextExtInfo = [[configCenter configForKey:@"iOS_weex_ext_config.shouldMountInstanceContextExtInfo" defaultValue:@YES isDefault:NULL] boolValue]; |
| } |
| return shouldMountInstanceContextExtInfo; |
| } |
| |
| - (void)createInstance:(NSString *)instanceIdString |
| contents:(NSData *)contents |
| options:(NSDictionary *)options |
| data:(id)data |
| { |
| WXAssertBridgeThread(); |
| WXAssertParam(instanceIdString); |
| |
| @synchronized(self) { |
| if (![self.insStack containsObject:instanceIdString]) { |
| if ([options[@"RENDER_IN_ORDER"] boolValue]) { |
| [self.insStack addObject:instanceIdString]; |
| } else { |
| [self.insStack insertObject:instanceIdString atIndex:0]; |
| } |
| } |
| } |
| WXSDKInstance *sdkInstance = [WXSDKManager instanceForID:instanceIdString]; |
| [sdkInstance.apmInstance onStage:KEY_PAGE_STAGES_LOAD_BUNDLE_START]; |
| |
| //create a sendQueue bind to the current instance |
| NSMutableArray *sendQueue = [NSMutableArray array]; |
| [self.sendQueue setValue:sendQueue forKey:instanceIdString]; |
| |
| if (sdkInstance.dataRender) { |
| if (_dataRenderHandler) { |
| WXPerformBlockOnComponentThread(^{ |
| [_dataRenderHandler createPage:instanceIdString contents:contents options:options data:data]; |
| }); |
| } |
| else { |
| WXComponentManager *manager = sdkInstance.componentManager; |
| if (manager.isValid) { |
| WXSDKErrCode errorCode = WX_KEY_EXCEPTION_DEGRADE_EAGLE_RENDER_ERROR; |
| NSError *error = [NSError errorWithDomain:WX_ERROR_DOMAIN code:errorCode userInfo:@{@"message":@"No data render handler found!"}]; |
| WXPerformBlockOnComponentThread(^{ |
| [manager renderFailed:error]; |
| }); |
| } |
| } |
| return; |
| } |
| } |
| |
| - (NSString *)_pareJSBundleType:(NSString*)instanceIdString jsBundleString:(NSString*)jsBundleString |
| { |
| NSString * bundleType = nil; |
| WXSDKInstance * instance = [WXSDKManager instanceForID:instanceIdString]; |
| NSURLComponents * urlComponent = [NSURLComponents componentsWithString:instance.pageName?:@""]; |
| for (NSURLQueryItem * queryItem in urlComponent.queryItems) { |
| if ([queryItem.name isEqualToString:@"bundleType"] && [@[@"Vue", @"Rax", @"vue", @"rax"] containsObject:queryItem.value]) { |
| bundleType = queryItem.value; |
| return bundleType; |
| } |
| } |
| |
| // find first character that is not space or new line character |
| NSCharacterSet* voidCharSet = [NSCharacterSet whitespaceAndNewlineCharacterSet]; |
| NSUInteger length = [jsBundleString length]; |
| NSUInteger validCharacter = 0; |
| while (validCharacter < length && [voidCharSet characterIsMember:[jsBundleString characterAtIndex:validCharacter]]) { |
| validCharacter ++; |
| } |
| if (validCharacter >= length) { |
| return bundleType; |
| } |
| @try { |
| jsBundleString = [jsBundleString substringWithRange:NSMakeRange(validCharacter, MIN(100, length - validCharacter))]; |
| } |
| @catch (NSException* e) {//!OCLint |
| } |
| if ([jsBundleString length] == 0) { |
| return bundleType; |
| } |
| |
| static NSRegularExpression* headerExp = nil; |
| static NSRegularExpression* vueExp = nil; |
| static NSRegularExpression* raxExp = nil; |
| static dispatch_once_t onceToken; |
| dispatch_once(&onceToken, ^{ |
| headerExp = [NSRegularExpression regularExpressionWithPattern:@"^\\s*\\/\\/ *(\\{[^}]*\\}) *\\r?\\n" options:NSRegularExpressionCaseInsensitive error:NULL]; |
| vueExp = [NSRegularExpression regularExpressionWithPattern:@"(use)(\\s+)(weex:vue)" options:NSRegularExpressionCaseInsensitive error:NULL]; |
| raxExp = [NSRegularExpression regularExpressionWithPattern:@"(use)(\\s+)(weex:rax)" options:NSRegularExpressionCaseInsensitive error:NULL]; |
| }); |
| |
| if ( [self _isParserByRegEx]) { |
| NSTextCheckingResult *match = [headerExp firstMatchInString:jsBundleString options:0 range:NSMakeRange(0, jsBundleString.length)]; |
| if (match) { |
| NSString* bundleTypeStr = [jsBundleString substringWithRange:match.range]; |
| bundleTypeStr = [bundleTypeStr stringByReplacingOccurrencesOfString:@"//" withString:@""]; |
| id vale = [WXUtility objectFromJSON:bundleTypeStr]; |
| bundleType = [vale objectForKey:@"framework"]; |
| }else{ |
| NSTextCheckingResult *match = [vueExp firstMatchInString:jsBundleString options:0 range:NSMakeRange(0, jsBundleString.length)]; |
| if (match) { |
| bundleType = [jsBundleString substringWithRange:match.range]; |
| return bundleType; |
| } |
| match = [raxExp firstMatchInString:jsBundleString options:0 range:NSMakeRange(0, jsBundleString.length)]; |
| if (match) { |
| bundleType = [jsBundleString substringWithRange:match.range]; |
| } |
| } |
| }else{ |
| if ([jsBundleString hasPrefix:@"// { \"framework\": \"Vue\""] || [jsBundleString hasPrefix:@"// { \"framework\": \"vue\""]) { |
| bundleType = @"Vue"; |
| } else if ([jsBundleString hasPrefix:@"// { \"framework\": \"Rax\""] || [jsBundleString hasPrefix:@"// { \"framework\": \"rax\""] || [jsBundleString hasPrefix:@"// {\"framework\" : \"Rax\"}"] || [jsBundleString hasPrefix:@"// {\"framework\" : \"rax\"}"]) { |
| bundleType = @"Rax"; |
| }else { |
| NSTextCheckingResult *match = [vueExp firstMatchInString:jsBundleString options:0 range:NSMakeRange(0, jsBundleString.length)]; |
| if (match) { |
| bundleType = [jsBundleString substringWithRange:match.range]; |
| return bundleType; |
| } |
| match = [raxExp firstMatchInString:jsBundleString options:0 range:NSMakeRange(0, jsBundleString.length)]; |
| if (match) { |
| bundleType = [jsBundleString substringWithRange:match.range]; |
| } |
| } |
| } |
| return bundleType; |
| } |
| |
| - (bool)_isParserByRegEx |
| { |
| return false; |
| // bool useRegEx = true; |
| // id<WXConfigCenterProtocol> configCenter = [WXSDKEngine handlerForProtocol:@protocol(WXConfigCenterProtocol)]; |
| // |
| // if ([configCenter respondsToSelector:@selector(configForKey:defaultValue:isDefault:)]) { |
| // useRegEx = [[configCenter configForKey:@"iOS_weex_ext_config.parserTypeByRegEx" defaultValue:@(YES) isDefault:NULL] boolValue]; |
| // } |
| // return useRegEx; |
| } |
| |
| - (void)destroyInstance:(NSString *)instance |
| { |
| WXAssertBridgeThread(); |
| WXAssertParam(instance); |
| |
| //remove this instance exception history |
| [WXExceptionUtils removeExceptionHistory:instance]; |
| |
| //remove instance from stack |
| @synchronized(self) { |
| [self.insStack removeObject:instance]; |
| } |
| |
| if(_jsBridge && [_jsBridge respondsToSelector:@selector(removeTimers:)]){ |
| [_jsBridge removeTimers:instance]; |
| } |
| |
| if(self.sendQueue[instance]){ |
| [self.sendQueue removeObjectForKey:instance]; |
| } |
| |
| WXSDKInstance *sdkInstance = [WXSDKManager instanceForID:instance]; |
| if (!sdkInstance.wlasmRender) { |
| [self callJSMethod:@"destroyInstance" args:@[instance]]; |
| } |
| } |
| |
| - (void)forceGarbageCollection |
| { |
| if ([self.jsBridge respondsToSelector:@selector(garbageCollect)]) { |
| [self.jsBridge garbageCollect]; |
| } |
| } |
| |
| - (void)refreshInstance:(NSString *)instance |
| data:(id)data |
| { |
| WXAssertBridgeThread(); |
| WXAssertParam(instance); |
| |
| if (!data) return; |
| |
| WXSDKInstance *sdkInstance = [WXSDKManager instanceForID:instance]; |
| if (sdkInstance.dataRender) { |
| if (!_dataRenderHandler) { |
| WXComponentManager *manager = sdkInstance.componentManager; |
| if (manager.isValid) { |
| WXSDKErrCode errorCode = WX_KEY_EXCEPTION_DEGRADE_EAGLE_RENDER_ERROR; |
| NSError *error = [NSError errorWithDomain:WX_ERROR_DOMAIN code:errorCode userInfo:@{@"message":@"No data render handler found!"}]; |
| WXPerformBlockOnComponentThread(^{ |
| [manager renderFailed:error]; |
| }); |
| } |
| return; |
| } |
| WXPerformBlockOnComponentThread(^{ |
| if ([data isKindOfClass:[NSDictionary class]]) { |
| [_dataRenderHandler refreshDataRenderInstance:instance data:[WXUtility JSONString:data]]; |
| } else if ([data isKindOfClass:[NSString class]]) { |
| [_dataRenderHandler refreshDataRenderInstance:instance data:data]; |
| } |
| }); |
| [[WXSDKManager bridgeMgr] callJSMethod:@"callJS" args:@[instance, @[@{@"method":@"fireEvent", @"args":@[@"", @"refresh", [WXUtility objectFromJSON:@"[]"], @"", @{@"params":@[@{@"data":data}]}]}]]]; |
| } else { |
| [self callJSMethod:@"refreshInstance" args:@[instance, data]]; |
| } |
| } |
| |
| - (void)updateState:(NSString *)instance data:(id)data |
| { |
| WXAssertBridgeThread(); |
| WXAssertParam(instance); |
| |
| //[self.jsBridge callJSMethod:@"updateState" args:@[instance, data]]; |
| } |
| |
| - (void)executeJsFramework:(NSString *)script |
| { |
| WXAssertBridgeThread(); |
| WXAssertParam(script); |
| |
| WX_MONITOR_PERF_START(WXPTFrameworkExecute); |
| |
| [self.jsBridge executeJSFramework:script]; |
| |
| WX_MONITOR_PERF_END(WXPTFrameworkExecute); |
| |
| if ([self.jsBridge exception]) { |
| NSString *exception = [[self.jsBridge exception] toString]; |
| NSMutableString *errMsg = [NSMutableString stringWithFormat:@"[WX_KEY_EXCEPTION_SDK_INIT_JSFM_INIT_FAILED] %@",exception]; |
| [WXExceptionUtils commitCriticalExceptionRT:@"WX_KEY_EXCEPTION_SDK_INIT" errCode:[NSString stringWithFormat:@"%d", WX_KEY_EXCEPTION_SDK_INIT] function:@"" exception:errMsg extParams:nil]; |
| WX_MONITOR_FAIL(WXMTJSFramework, WX_ERR_JSFRAMEWORK_EXECUTE, errMsg); |
| } else { |
| WX_MONITOR_SUCCESS(WXMTJSFramework); |
| //the JSFramework has been load successfully. |
| self.frameworkLoadFinished = YES; |
| |
| [self executeAllJsService]; |
| |
| JSValue *frameworkVersion = [self.jsBridge callJSMethod:@"getJSFMVersion" args:nil]; |
| if (frameworkVersion && [frameworkVersion isString]) { |
| [WXAppConfiguration setJSFrameworkVersion:[frameworkVersion toString]]; |
| } |
| |
| if (script) { |
| [WXAppConfiguration setJSFrameworkLibSize:[script lengthOfBytesUsingEncoding:NSUTF8StringEncoding]]; |
| } |
| |
| //execute methods which has been stored in methodQueue temporarily. |
| for (NSDictionary *method in _methodQueue) { |
| [self callJSMethod:method[@"method"] args:method[@"args"]]; |
| } |
| |
| [_methodQueue removeAllObjects]; |
| |
| WX_MONITOR_PERF_END(WXPTInitalize); |
| }; |
| } |
| |
| - (void)executeJsMethod:(WXCallJSMethod *)method |
| { |
| WXAssertBridgeThread(); |
| |
| if (!method.instance) { |
| WXLogError(@"Instance doesn't exist!"); |
| return; |
| } |
| |
| NSMutableArray *sendQueue = self.sendQueue[method.instance.instanceId]; |
| if (!sendQueue) { |
| WXLogInfo(@"No send queue for instance:%@, may it has been destroyed so method:%@ is ignored", method.instance, method.methodName); |
| return; |
| } |
| |
| [sendQueue addObject:method]; |
| [self performSelector:@selector(_sendQueueLoop) withObject:nil]; |
| } |
| |
| - (void)callJSMethod:(NSString *)method args:(NSArray *)args onContext:(id<WXBridgeProtocol>)bridge completion:(void (^)(JSValue * value))completion |
| { |
| NSMutableArray *newArg = nil; |
| if (!bridge) { |
| bridge = self.jsBridge; |
| } |
| if (self.frameworkLoadFinished) { |
| WXLogDebug(@"Calling JS... method:%@, args:%@", method, args); |
| if (([bridge isKindOfClass:[WXJSCoreBridge class]]) || |
| ([bridge isKindOfClass:NSClassFromString(@"WXDebugger") ]) ) { |
| JSValue *value = [bridge callJSMethod:method args:args]; |
| if (completion) { |
| completion(value); |
| } |
| } else { |
| [bridge callJSMethod:method args:args]; |
| } |
| } else { |
| newArg = [args mutableCopy]; |
| if (completion) { |
| [newArg addObject:completion]; |
| } |
| [_methodQueue addObject:@{@"method":method, @"args":[newArg copy]}]; |
| } |
| } |
| |
| - (JSValue *)excuteJSMethodWithResult:(WXCallJSMethod *)method |
| { |
| WXAssertBridgeThread(); |
| return [self.jsBridge callJSMethod:@"callJS" args:@[method.instance.instanceId, @[[method callJSTask]]]]; |
| } |
| |
| - (void)executeAllJsService |
| { |
| for(NSDictionary *service in _jsServiceQueue) { |
| NSString *script = [service valueForKey:@"script"]; |
| NSString *name = [service valueForKey:@"name"]; |
| [self executeJsService:script withName:name]; |
| } |
| |
| [_jsServiceQueue removeAllObjects]; |
| } |
| |
| - (void)executeJsService:(NSString *)script withName:(NSString *)name |
| { |
| if(self.frameworkLoadFinished) { |
| WXAssert(script, @"param script required!"); |
| if ([self.jsBridge respondsToSelector:@selector(javaScriptContext)]) { |
| NSDictionary* funcInfo = @{ |
| @"func":@"executeJsService", |
| @"arg":name?:@"unsetScriptName" |
| }; |
| self.jsBridge.javaScriptContext[@"wxExtFuncInfo"] = funcInfo; |
| } |
| [self.jsBridge executeJavascript:script]; |
| if ([self.jsBridge respondsToSelector:@selector(javaScriptContext)]) { |
| self.jsBridge.javaScriptContext[@"wxExtFuncInfo"] = nil; |
| } |
| |
| if ([self.jsBridge exception]) { |
| NSString *exception = [[self.jsBridge exception] toString]; |
| NSMutableString *errMsg = [NSMutableString stringWithFormat:@"[WX_KEY_EXCEPTION_INVOKE_JSSERVICE_EXECUTE] name:%@,arg:%@,exception :$@",name,exception]; |
| [WXExceptionUtils commitCriticalExceptionRT:@"WX_KEY_EXCEPTION_INVOKE" errCode:[NSString stringWithFormat:@"%d", WX_KEY_EXCEPTION_INVOKE] function:@"executeJsService" exception:errMsg extParams:nil]; |
| WX_MONITOR_FAIL(WXMTJSService, WX_ERR_JSFRAMEWORK_EXECUTE, errMsg); |
| } |
| }else { |
| [_jsServiceQueue addObject:@{ |
| @"name": name, |
| @"script": script |
| }]; |
| } |
| } |
| |
| - (void)registerModules:(NSDictionary *)modules |
| { |
| WXAssertBridgeThread(); |
| |
| if(!modules) return; |
| |
| [self callJSMethod:@"registerModules" args:@[modules]]; |
| if (_dataRenderHandler) { |
| WXPerformBlockOnComponentThread(^{ |
| [_dataRenderHandler registerModules:modules]; |
| }); |
| } |
| } |
| |
| - (void)registerComponents:(NSArray *)components |
| { |
| WXAssertBridgeThread(); |
| |
| if(!components) return; |
| |
| [self callJSMethod:@"registerComponents" args:@[components]]; |
| if (_dataRenderHandler) { |
| WXPerformBlockOnComponentThread(^{ |
| [_dataRenderHandler registerComponents:components]; |
| }); |
| } |
| } |
| |
| - (void)callJSMethod:(NSString *)method args:(NSArray *)args |
| { |
| if (self.frameworkLoadFinished) { |
| [self.jsBridge callJSMethod:method args:args]; |
| } |
| else { |
| [_methodQueue addObject:@{@"method":method, @"args":args}]; |
| } |
| } |
| |
| - (void)resetEnvironment |
| { |
| [_jsBridge resetEnvironment]; |
| } |
| |
| #pragma mark JS Debug Management |
| |
| - (void)connectToDevToolWithUrl:(NSURL *)url |
| { |
| id webSocketBridge = [NSClassFromString(@"WXDebugger") alloc]; |
| if(!webSocketBridge || ![webSocketBridge respondsToSelector:NSSelectorFromString(@"connectToURL:")]) { |
| return; |
| } else { |
| SuppressPerformSelectorLeakWarning( |
| [webSocketBridge performSelector:NSSelectorFromString(@"connectToURL:") withObject:url] |
| ); |
| } |
| } |
| |
| - (void)connectToWebSocket:(NSURL *)url |
| { |
| if (NSClassFromString(@"WXDebugLoggerBridge")) { |
| _devToolSocketBridge = [[NSClassFromString(@"WXDebugLoggerBridge") alloc] initWithURL:url]; |
| } |
| } |
| |
| - (void)logToWebSocket:(NSString *)flag message:(NSString *)message |
| { |
| [_devToolSocketBridge callJSMethod:@"__logger" args:@[flag, message]]; |
| } |
| |
| #pragma mark Private Mehtods |
| |
| - (void)_sendQueueLoop |
| { |
| WXAssertBridgeThread(); |
| |
| BOOL hasTask = NO; |
| NSMutableArray *tasks = [NSMutableArray array]; |
| NSString *execIns = nil; |
| |
| @synchronized(self) { |
| for (NSString *instance in self.insStack) { |
| NSMutableArray *sendQueue = self.sendQueue[instance]; |
| if(sendQueue.count > 0){ |
| hasTask = YES; |
| for(WXCallJSMethod *method in sendQueue){ |
| [tasks addObject:[method callJSTask]]; |
| } |
| [sendQueue removeAllObjects]; |
| execIns = instance; |
| break; |
| } |
| } |
| } |
| |
| if ([tasks count] > 0 && execIns) { |
| WXSDKInstance * execInstance = [WXSDKManager instanceForID:execIns]; |
| NSTimeInterval start = CACurrentMediaTime()*1000; |
| |
| if (execInstance.instanceJavaScriptContext && execInstance.bundleType) { |
| [self callJSMethod:@"__WEEX_CALL_JAVASCRIPT__" args:@[execIns, [tasks copy]] onContext:execInstance.instanceJavaScriptContext completion:nil]; |
| } else { |
| [self callJSMethod:@"callJS" args:@[execIns, [tasks copy]]]; |
| } |
| if (execInstance) { |
| NSTimeInterval diff = CACurrentMediaTime()*1000 - start; |
| execInstance.performance.callJsNum++; |
| execInstance.performance.callJsTime = execInstance.performance.callJsTime+ diff; |
| } |
| if (execInstance && !execInstance.apmInstance.isFSEnd) { |
| NSTimeInterval diff = CACurrentMediaTime()*1000 - start; |
| [execInstance.apmInstance updateFSDiffStats:KEY_PAGE_STATS_FS_CALL_JS_NUM withDiffValue:1]; |
| [execInstance.apmInstance updateFSDiffStats:KEY_PAGE_STATS_FS_CALL_JS_TIME withDiffValue:diff]; |
| } |
| } |
| |
| if (hasTask) { |
| [self performSelector:@selector(_sendQueueLoop) withObject:nil]; |
| } |
| } |
| |
| + (void)mountContextEnvironment:(JSContext*)context |
| { |
| NSDictionary *data = [WXUtility getEnvironment]; |
| context[@"WXEnvironment"] = data; |
| // use latin1 encode also named ISO/IEC_8859-1 more: https://en.wikipedia.org/wiki/ISO/IEC_8859-1 |
| // 8-bit single-byte coded graphic character sets as webkit does |
| // https://github.com/WebKit/webkit/blob/master/Source/WebCore/page/Base64Utilities.cpp |
| context[@"btoa"] = ^(JSValue *value ) { |
| NSData *nsdata = [[value toString] |
| dataUsingEncoding:NSISOLatin1StringEncoding]; |
| NSString *base64Encoded = [nsdata base64EncodedStringWithOptions:0]; |
| return base64Encoded; |
| }; |
| context[@"atob"] = ^(JSValue *value ) { |
| NSData *nsdataFromBase64String = [[NSData alloc] |
| initWithBase64EncodedString:[value toString] options:0]; |
| NSString *base64Decoded = [[NSString alloc] |
| initWithData:nsdataFromBase64String encoding:NSISOLatin1StringEncoding]; |
| return base64Decoded; |
| }; |
| |
| // Avoid exceptionHandler be recursively invoked and finally cause stack overflow. |
| static BOOL gInExceptionHandler = NO; |
| context.exceptionHandler = ^(JSContext *context, JSValue *exception){ |
| if (gInExceptionHandler) { |
| return; |
| } |
| gInExceptionHandler = YES; |
| |
| @try { |
| BOOL tryFindInstanceInfoInGlobalContext = NO; |
| context.exception = exception; |
| NSString *errorCode = [NSString stringWithFormat:@"%d", WX_KEY_EXCEPTION_WXBRIDGE];; |
| NSString *bundleUrl = nil; |
| NSString *message = nil; |
| NSDictionary *userInfo = nil; |
| BOOL commitException = YES; |
| WXSDKInstance * instance = nil; |
| |
| if (context.instanceId) { |
| // instance page javaScript runtime exception |
| instance = [WXSDKManager instanceForID:context.instanceId]; |
| if (instance) { |
| // instance already existed |
| commitException = YES; |
| } else { |
| // instance already destroyed |
| commitException = NO; |
| } |
| } else { |
| // weex-main-jsfm.js runtime exception throws |
| message = [NSString stringWithFormat:@"[WX_KEY_EXCEPTION_WXBRIDGE] [%@:%@:%@] %@ js stack: %@", exception[@"sourceURL"], exception[@"line"], exception[@"column"], [exception toString], [exception[@"stack"] toObject]]; |
| if (!JSValueIsUndefined(context.JSGlobalContextRef, exception[@"sourceURL"].JSValueRef)) { |
| bundleUrl = exception[@"sourceURL"].toString; |
| } else { |
| bundleUrl = @"weex-main-jsfm"; |
| } |
| userInfo = [NSDictionary dictionary]; |
| } |
| |
| NSDictionary* wxExtFuncInfo = [context[@"wxExtFuncInfo"] toDictionary]; |
| NSString* recordFunc = [wxExtFuncInfo objectForKey:@"func"]; |
| NSString* recordArg = [wxExtFuncInfo objectForKey:@"arg"]; |
| NSString* recordInsstanceId = [wxExtFuncInfo objectForKey:@"instanceId"]; |
| if (nil == instance) { |
| instance = [WXSDKManager instanceForID:recordInsstanceId]; |
| tryFindInstanceInfoInGlobalContext = nil!= instance; |
| } |
| |
| if(nil != instance && [recordFunc isEqualToString:@"createInstance"] && !instance.apmInstance.hasAddView){ |
| errorCode = [NSString stringWithFormat:@"%d", WX_KEY_EXCEPTION_EMPTY_SCREEN_JS]; |
| } |
| |
| if (instance) { |
| bundleUrl = instance.pageName?:([instance.scriptURL absoluteString]?:@"WX_KEY_EXCEPTION_WXBRIDGE"); |
| message = [NSString stringWithFormat:@"[WX_KEY_EXCEPTION_WXBRIDGE] exception: %@\n stack:%@",[exception toString],[exception[@"stack"] toObject]]; |
| userInfo = @{@"jsMainBundleStringContentLength":instance.userInfo[@"jsMainBundleStringContentLength"]?:@"", |
| @"jsMainBundleStringContentMd5":instance.userInfo[@"jsMainBundleStringContentMd5"]?:@"", |
| @"sourceURL":[NSString stringWithFormat:@"%@:%@:%@",exception[@"sourceURL"],exception[@"line"],exception[@"column"]], |
| @"callCreateInstanceContext":instance.callCreateInstanceContext?:@"", |
| @"createInstanceContextResult": instance.createInstanceContextResult?:@"", |
| @"executeRaxApiResult":instance.executeRaxApiResult?:@"" |
| }; |
| } |
| |
| if (commitException) { |
| NSMutableDictionary* reportInfo = [[NSMutableDictionary alloc] initWithDictionary:[userInfo mutableCopy]]; |
| [reportInfo setObject:context.name?:@"unknownContextName" forKey:@"wxContextName"]; |
| |
| WXJSExceptionInfo * jsExceptionInfo = [[WXJSExceptionInfo alloc] initWithInstanceId:instance.instanceId bundleUrl:bundleUrl errorCode:errorCode functionName:[NSString stringWithFormat:@"func: %@ arg:%@",recordFunc,recordArg]?:@"exceptionHandler" exception:message userInfo:reportInfo]; |
| |
| if (nil == instance) { |
| [WXExceptionUtils commitCriticalExceptionRT:jsExceptionInfo]; |
| }else{ |
| [WXExceptionUtils commitCriticalExceptionRT:jsExceptionInfo.instanceId errCode:jsExceptionInfo.errorCode function:jsExceptionInfo.functionName exception:jsExceptionInfo.exception extParams:jsExceptionInfo.userInfo]; |
| } |
| |
| WX_MONITOR_FAIL(WXMTJSBridge, WX_ERR_JS_EXECUTE, message); |
| if (instance.onJSRuntimeException && !tryFindInstanceInfoInGlobalContext) { |
| instance.onJSRuntimeException(jsExceptionInfo); |
| } |
| } |
| } |
| @finally { |
| gInExceptionHandler = NO; |
| } |
| }; |
| |
| context[@"console"][@"error"] = ^(){ |
| [WXBridgeContext handleConsoleOutputWithArgument:[JSContext currentArguments] logLevel:WXLogFlagError]; |
| }; |
| context[@"console"][@"warn"] = ^(){ |
| [WXBridgeContext handleConsoleOutputWithArgument:[JSContext currentArguments] logLevel:WXLogFlagWarning]; |
| }; |
| context[@"console"][@"info"] = ^(){ |
| [WXBridgeContext handleConsoleOutputWithArgument:[JSContext currentArguments] logLevel:WXLogFlagInfo]; |
| }; |
| context[@"console"][@"debug"] = ^(){ |
| [WXBridgeContext handleConsoleOutputWithArgument:[JSContext currentArguments] logLevel:WXLogFlagDebug]; |
| }; |
| context[@"console"][@"log"] = ^(){ |
| [WXBridgeContext handleConsoleOutputWithArgument:[JSContext currentArguments] logLevel:WXLogFlagLog]; |
| }; |
| context[@"nativeLog"] = ^() { |
| static NSDictionary *levelMap; |
| static dispatch_once_t onceToken; |
| dispatch_once(&onceToken, ^{ |
| levelMap = @{ |
| @"__ERROR": @(WXLogFlagError), |
| @"__WARN": @(WXLogFlagWarning), |
| @"__INFO": @(WXLogFlagInfo), |
| @"__DEBUG": @(WXLogFlagDebug), |
| @"__LOG": @(WXLogFlagLog) |
| }; |
| }); |
| NSArray * args = [JSContext currentArguments]; |
| NSString * levelStr = [[args lastObject] toString]; |
| [WXBridgeContext handleConsoleOutputWithArgument:args logLevel:(WXLogFlag)[levelMap[levelStr] integerValue]]; |
| }; |
| |
| context[@"extendCallNative"] = ^(JSValue *value ) { |
| return [WXBridgeContext extendCallNative:[value toDictionary]]; |
| }; |
| } |
| |
| + (void)handleConsoleOutputWithArgument:(NSArray *)arguments logLevel:(WXLogFlag)logLevel |
| { |
| NSMutableString *string = [NSMutableString string]; |
| [string appendString:@"jsLog: "]; |
| [arguments enumerateObjectsUsingBlock:^(JSValue *jsVal, NSUInteger idx, BOOL *stop) { |
| [string appendFormat:@"%@ ", jsVal]; |
| if (idx == arguments.count - 1) { |
| if (logLevel) { |
| if (WXLogFlagWarning == logLevel || WXLogFlagError == logLevel) { |
| id<WXAppMonitorProtocol> appMonitorHandler = [WXSDKEngine handlerForProtocol:@protocol(WXAppMonitorProtocol)]; |
| if ([appMonitorHandler respondsToSelector:@selector(commitAppMonitorAlarm:monitorPoint:success:errorCode:errorMsg:arg:)]) { |
| [appMonitorHandler commitAppMonitorAlarm:@"weex" monitorPoint:@"jswarning" success:NO errorCode:@"99999" errorMsg:string arg:[WXSDKEngine topInstance].pageName]; |
| } |
| } |
| WX_LOG(logLevel, @"%@", string); |
| } else { |
| [string appendFormat:@"%@ ", jsVal]; |
| WXLogInfo(@"%@", string); |
| } |
| } |
| }]; |
| } |
| |
| +(id)extendCallNative:(NSDictionary *)dict |
| { |
| if(dict){ |
| return [WXExtendCallNativeManager sendExtendCallNativeEvent:dict]; |
| } |
| return @(-1); |
| } |
| @end |
