/**
* Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR
* USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions
* for use, reproduction, and distribution as defined by Sections 1 through 9 of this document.
* "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is
* granting the License. "Legal Entity" shall mean the union of the acting entity and all other
* entities that control, are controlled by, or are under common control with that entity. For the
* purposes of this definition, "control" means (i) the power, direct or indirect, to cause the
* direction or management of such entity, whether by contract or otherwise, or (ii) ownership of
* fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such
* entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted
* by this License. "Source" form shall mean the preferred form for making modifications, including
* but not limited to software source code, documentation source, and configuration files. "Object"
* form shall mean any form resulting from mechanical transformation or translation of a Source
* form, including but not limited to compiled object code, generated documentation, and conversions
* to other media types. "Work" shall mean the work of authorship, whether in Source or Object form,
* made available under the License, as indicated by a copyright notice that is included in or
* attached to the work (an example is provided in the Appendix below). "Derivative Works" shall
* mean any work, whether in Source or Object form, that is based on (or derived from) the Work and
* for which the editorial revisions, annotations, elaborations, or other modifications represent,
* as a whole, an original work of authorship. For the purposes of this License, Derivative Works
* shall not include works that remain separable from, or merely link (or bind by name) to the
* interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of
* authorship, including the original version of the Work and any modifications or additions to that
* Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in
* the Work by the copyright owner or by an individual or Legal Entity authorized to submit on
* behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of
* electronic, verbal, or written communication sent to the Licensor or its representatives,
* including but not limited to communication on electronic mailing lists, source code control
* systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the
* purpose of discussing and improving the Work, but excluding communication that is conspicuously
* marked or otherwise designated in writing by the copyright owner as "Not a Contribution."
* "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a
* Contribution has been received by Licensor and subsequently incorporated within the Work. 2.
* Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor
* hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable
* copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform,
* sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant
* of Patent License. Subject to the terms and conditions of this License, each Contributor hereby
* grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except
* as stated in this section) patent license to make, have made, use, offer to sell, sell, import,
* and otherwise transfer the Work, where such license applies only to those patent claims
* licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or
* by combination of their Contribution(s) with the Work to which such Contribution(s) was
* submitted. If You institute patent litigation against any entity (including a cross-claim or
* counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work
* constitutes direct or contributory patent infringement, then any patent licenses granted to You
* under this License for that Work shall terminate as of the date such litigation is filed. 4.
* Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof
* in any medium, with or without modifications, and in Source or Object form, provided that You
* meet the following conditions: (a) You must give any other recipients of the Work or Derivative
* Works a copy of this License; and (b) You must cause any modified files to carry prominent
* notices stating that You changed the files; and (c) You must retain, in the Source form of any
* Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices
* from the Source form of the Work, excluding those notices that do not pertain to any part of the
* Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution,
* then any Derivative Works that You distribute must include a readable copy of the attribution
* notices contained within such NOTICE file, excluding those notices that do not pertain to any
* part of the Derivative Works, in at least one of the following places: within a NOTICE text file
* distributed as part of the Derivative Works; within the Source form or documentation, if provided
* along with the Derivative Works; or, within a display generated by the Derivative Works, if and
* wherever such third-party notices normally appear. The contents of the NOTICE file are for
* informational purposes only and do not modify the License. You may add Your own attribution
* notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE
* text from the Work, provided that such additional attribution notices cannot be construed as
* modifying the License. You may add Your own copyright statement to Your modifications and may
* provide additional or different license terms and conditions for use, reproduction, or
* distribution of Your modifications, or for any such Derivative Works as a whole, provided Your
* use, reproduction, and distribution of the Work otherwise complies with the conditions stated in
* this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any
* Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be
* under the terms and conditions of this License, without any additional terms or conditions.
* Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate
* license agreement you may have executed with Licensor regarding such Contributions. 6.
* Trademarks. This License does not grant permission to use the trade names, trademarks, service
* marks, or product names of the Licensor, except as required for reasonable and customary use in
* describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer
* of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the
* Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR
* CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties
* or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE.
* You are solely responsible for determining the appropriateness of using or redistributing the
* Work and assume any risks associated with Your exercise of permissions under this License. 8.
* Limitation of Liability. In no event and under no legal theory, whether in tort (including
* negligence), contract, or otherwise, unless required by applicable law (such as deliberate and
* grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for
* damages, including any direct, indirect, special, incidental, or consequential damages of any
* character arising as a result of this License or out of the use or inability to use the Work
* (including but not limited to damages for loss of goodwill, work stoppage, computer failure or
* malfunction, or any and all other commercial damages or losses), even if such Contributor has
* been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability.
* While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a
* fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights
* consistent with this License. However, in accepting such obligations, You may act only on Your
* own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if
* You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by,
* or claims asserted against, such Contributor by reason of your accepting any such warranty or
* additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to
* your work. To apply the Apache License to your work, attach the following boilerplate notice,
* with the fields enclosed by brackets "[]" replaced with your own identifying information. (Don't
* include the brackets!) The text should be enclosed in the appropriate comment syntax for the
* file format. We also recommend that a file or class name and description of purpose be included
* on the same "printed page" as the copyright notice for easier identification within third-party
* archives. Copyright 2016 Alibaba Group Licensed 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.
*/
package com.taobao.weex;
import android.app.Application;
import android.content.Context;
import android.content.Intent;
import android.support.v4.content.LocalBroadcastManager;
import android.text.TextUtils;
import android.util.Log;
import com.taobao.weex.adapter.IWXHttpAdapter;
import com.taobao.weex.adapter.IWXImgLoaderAdapter;
import com.taobao.weex.adapter.IWXUserTrackAdapter;
import com.taobao.weex.appfram.clipboard.WXClipboardModule;
import com.taobao.weex.appfram.navigator.IActivityNavBarSetter;
import com.taobao.weex.appfram.navigator.WXNavigatorModule;
import com.taobao.weex.appfram.storage.IWXStorageAdapter;
import com.taobao.weex.appfram.storage.WXStorageModule;
import com.taobao.weex.bridge.ModuleFactory;
import com.taobao.weex.bridge.WXBridgeManager;
import com.taobao.weex.bridge.WXModuleManager;
import com.taobao.weex.common.Destroyable;
import com.taobao.weex.common.TypeModuleFactory;
import com.taobao.weex.common.WXException;
import com.taobao.weex.common.WXInstanceWrap;
import com.taobao.weex.common.WXModule;
import com.taobao.weex.dom.*;
import com.taobao.weex.ui.*;
import com.taobao.weex.ui.module.WXModalUIModule;
import com.taobao.weex.http.WXStreamModule;
import com.taobao.weex.ui.animation.WXAnimationModule;
import com.taobao.weex.ui.component.*;
import com.taobao.weex.ui.component.list.HorizontalListComponent;
import com.taobao.weex.ui.component.list.WXCell;
import com.taobao.weex.ui.component.list.WXListComponent;
import com.taobao.weex.ui.module.WXTimerModule;
import com.taobao.weex.ui.module.WXWebViewModule;
import com.taobao.weex.utils.WXLogUtils;
import com.taobao.weex.utils.WXSoInstallMgrSdk;
import com.taobao.weex.utils.batch.BatchOperationHelper;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class WXSDKEngine {
public static final String JS_FRAMEWORK_RELOAD="js_framework_reload";
private static final String V8_SO_NAME = "weexv8";
private volatile static boolean mIsInit = false;
private static final Object mLock = new Object();
private static final String TAG = "WXSDKEngine";
/**
* Deprecated. Use {@link #initialize(Application, InitConfig)} instead.
*/
@Deprecated
public static void init(Application application) {
init(application, null);
}
/**
* Deprecated. Use {@link #initialize(Application, InitConfig)} instead.
*/
@Deprecated
public static void init(Application application, IWXUserTrackAdapter utAdapter) {
init(application, utAdapter, null);
}
/**
* Deprecated. Use {@link #initialize(Application, InitConfig)} instead.
*/
@Deprecated
public static void init(Application application, IWXUserTrackAdapter utAdapter, String framework) {
initialize(application,
new InitConfig.Builder()
.setUtAdapter(utAdapter)
.build()
);
}
public static boolean isInitialized(){
synchronized(mLock) {
return mIsInit;
}
}
/**
*
* @param application
* @param config initial configurations or null
*/
public static void initialize(Application application,InitConfig config){
synchronized (mLock) {
if (mIsInit) {
return;
}
long start = System.currentTimeMillis();
WXEnvironment.sSDKInitStart = start;
doInitInternal(application,config);
WXEnvironment.sSDKInitInvokeTime = System.currentTimeMillis()-start;
WXLogUtils.renderPerformanceLog("SDKInitInvokeTime", WXEnvironment.sSDKInitInvokeTime);
mIsInit = true;
}
}
private static void doInitInternal(final Application application,final InitConfig config){
WXEnvironment.sApplication = application;
WXEnvironment.JsFrameworkInit = false;
WXBridgeManager.getInstance().post(new Runnable() {
@Override
public void run() {
long start = System.currentTimeMillis();
WXSDKManager sm = WXSDKManager.getInstance();
if(config != null ) {
sm.setIWXHttpAdapter(config.getHttpAdapter());
sm.setIWXImgLoaderAdapter(config.getImgAdapter());
sm.setIWXUserTrackAdapter(config.getUtAdapter());
sm.setIWXDebugAdapter(config.getDebugAdapter());
sm.setIWXStorageAdapter(config.getStorageAdapter());
if(config.getDebugAdapter()!=null){
config.getDebugAdapter().initDebug(application);
}
}
WXSoInstallMgrSdk.init(application);
boolean isSoInitSuccess = WXSoInstallMgrSdk.initSo(V8_SO_NAME, 1, config!=null?config.getUtAdapter():null);
if (!isSoInitSuccess) {
return;
}
sm.initScriptsFramework(config!=null?config.getFramework():null);
WXEnvironment.sSDKInitExecuteTime = System.currentTimeMillis() - start;
WXLogUtils.renderPerformanceLog("SDKInitExecuteTime", WXEnvironment.sSDKInitExecuteTime);
}
});
register();
}
@Deprecated
public static void init(Application application, String framework, IWXUserTrackAdapter utAdapter, IWXImgLoaderAdapter imgLoaderAdapter, IWXHttpAdapter httpAdapter) {
initialize(application,
new InitConfig.Builder()
.setUtAdapter(utAdapter)
.setHttpAdapter(httpAdapter)
.setImgAdapter(imgLoaderAdapter)
.build()
);
}
private static void register() {
BatchOperationHelper batchHelper = new BatchOperationHelper(WXBridgeManager.getInstance());
try {
registerComponent(
new SimpleComponentHolder(
WXText.class,
new WXText.Creator()
),
false,
WXBasicComponentType.TEXT
);
registerComponent(
new SimpleComponentHolder(
WXDiv.class,
new WXDiv.Ceator()
),
false,
WXBasicComponentType.CONTAINER,
WXBasicComponentType.DIV,
WXBasicComponentType.HEADER,
WXBasicComponentType.FOOTER
);
registerComponent(
new SimpleComponentHolder(
WXImage.class,
new WXImage.Ceator()
),
false,
WXBasicComponentType.IMAGE,
WXBasicComponentType.IMG
);
registerComponent(
new SimpleComponentHolder(
WXScroller.class,
new WXScroller.Creator()
),
false,
WXBasicComponentType.SCROLLER
);
registerComponent(
new SimpleComponentHolder(
WXSlider.class,
new WXSlider.Creator()
),
true,
WXBasicComponentType.SLIDER
);
registerComponent(
new SimpleComponentHolder(
WXSliderNeighbor.class,
new WXSliderNeighbor.Creator()
),
true,
WXBasicComponentType.SLIDER_NEIGHBOR
);
registerComponent(WXListComponent.class, false,WXBasicComponentType.LIST,WXBasicComponentType.VLIST);
registerComponent(HorizontalListComponent.class,false,WXBasicComponentType.HLIST);
registerComponent(WXBasicComponentType.CELL, WXCell.class, true);
registerComponent(WXBasicComponentType.INDICATOR, WXIndicator.class, true);
registerComponent(WXBasicComponentType.VIDEO, WXVideo.class, false);
registerComponent(WXBasicComponentType.INPUT, WXInput.class, false);
registerComponent(WXBasicComponentType.TEXTAREA, Textarea.class,false);
registerComponent(WXBasicComponentType.SWITCH, WXSwitch.class, false);
registerComponent(WXBasicComponentType.A, WXA.class, false);
registerComponent(WXBasicComponentType.EMBED, WXEmbed.class, true);
registerComponent(WXBasicComponentType.WEB, WXWeb.class);
registerComponent(WXBasicComponentType.REFRESH, WXRefresh.class);
registerComponent(WXBasicComponentType.LOADING, WXLoading.class);
registerComponent(WXBasicComponentType.LOADING_INDICATOR, WXLoadingIndicator.class);
registerComponent(WXBasicComponentType.HEADER, WXHeader.class);
registerModule("modal", WXModalUIModule.class, false);
registerModule("instanceWrap", WXInstanceWrap.class, true);
registerModule("animation", WXAnimationModule.class, true);
registerModule("webview", WXWebViewModule.class, true);
registerModule("navigator", WXNavigatorModule.class);
registerModule("stream", WXStreamModule.class);
registerModule("timer", WXTimerModule.class, true);
registerModule("storage", WXStorageModule.class, true);
registerModule("clipboard", WXClipboardModule.class, true);
registerModule("globalEvent",WXGlobalEventModule.class);
registerDomObject(WXBasicComponentType.INDICATOR, WXIndicator.IndicatorDomNode.class);
registerDomObject(WXBasicComponentType.TEXT, WXTextDomObject.class);
registerDomObject(WXBasicComponentType.INPUT, BasicEditTextDomObject.class);
registerDomObject(WXBasicComponentType.TEXTAREA, TextAreaEditTextDomObject.class);
registerDomObject(WXBasicComponentType.SWITCH, WXSwitchDomObject.class);
registerDomObject(WXBasicComponentType.LIST, WXListDomObject.class);
registerDomObject(WXBasicComponentType.VLIST, WXListDomObject.class);
registerDomObject(WXBasicComponentType.HLIST, WXListDomObject.class);
registerDomObject(WXBasicComponentType.SCROLLER, WXScrollerDomObject.class);
} catch (WXException e) {
WXLogUtils.e("[WXSDKEngine] register:", e);
}
batchHelper.flush();
}
/**
*
* Register component. The registration is singleton in {@link WXSDKEngine} level
* @param type name of component. Same as type field in the JS.
* @param clazz the class of the {@link WXComponent} to be registered.
* @param appendTree true for appendTree flag
* @return true for registration success, false for otherwise.
* @throws WXException Throws exception if type conflicts.
*/
public static boolean registerComponent(String type, Class<? extends WXComponent> clazz, boolean appendTree) throws WXException {
return registerComponent(clazz, appendTree,type);
}
public static boolean registerComponent(String type, IExternalComponentGetter componentGetter, boolean appendTree) throws WXException {
return registerComponent(new ExternalLoaderComponentHolder(type,componentGetter), appendTree,type);
}
/**
*
* Register component. The registration is singleton in {@link WXSDKEngine} level
* @param clazz the class of the {@link WXComponent} to be registered.
* @param appendTree true for appendTree flag
* @return true for registration success, false for otherwise.
* @param names names(alias) of component. Same as type field in the JS.
* @throws WXException Throws exception if type conflicts.
*/
public static boolean registerComponent(Class<? extends WXComponent> clazz, boolean appendTree,String ... names) throws WXException {
if(clazz == null){
return false;
}
SimpleComponentHolder holder = new SimpleComponentHolder(clazz);
return registerComponent(holder,appendTree,names);
}
static boolean registerComponent(IFComponentHolder holder, boolean appendTree, String ... names) throws WXException {
boolean result = true;
Map<String, String> componentInfo = new HashMap<>();
if (appendTree) {
componentInfo.put("append", "tree");
}
for(String name:names) {
result = result && WXComponentRegistry.registerComponent(name, holder, componentInfo);
}
return result;
}
/**
* Register module. This is a wrapper method for
* {@link #registerModule(String, Class, boolean)}. The module register here only need to
* be singleton in {@link WXSDKInstance} level.
* @param moduleName module name
* @param moduleClass module to be registered.
* @return true for registration success, false for otherwise.
* {@link WXModuleManager#registerModule(String, ModuleFactory, boolean)}
*/
public static <T extends WXModule> boolean registerModule(String moduleName, Class<T> moduleClass,boolean global) throws WXException {
return moduleClass != null && registerModule(moduleName, new TypeModuleFactory<>(moduleClass), global);
}
/**
* Register module. This is a wrapper method for
* {@link #registerModule(String, Class, boolean)}. The module register here only need to
* be singleton in {@link WXSDKInstance} level.
* @param moduleName module name
* @param factory module factory to be registered. You can override {@link DestroyableModuleFactory#buildInstance()} to customize module creation.
* @return true for registration success, false for otherwise.
* {@link WXModuleManager#registerModule(String, ModuleFactory, boolean)}
*/
public static <T extends WXModule> boolean registerModuleWithFactory(String moduleName, DestroyableModuleFactory factory, boolean global) throws WXException {
return registerModule(moduleName, factory,global);
}
private static <T extends WXModule> boolean registerModule(String moduleName, ModuleFactory factory, boolean global) throws WXException {
return WXModuleManager.registerModule(moduleName, factory,global);
}
public static boolean registerModule(String moduleName, Class<? extends WXModule> moduleClass) throws WXException {
return registerModule(moduleName, moduleClass,false);
}
/**
* module implement {@link Destroyable}
*/
public static abstract class DestroyableModule extends WXModule implements Destroyable {}
public static abstract class DestroyableModuleFactory<T extends DestroyableModule> extends TypeModuleFactory<T> {
public DestroyableModuleFactory(Class<T> clz) {
super(clz);
}
}
public static boolean registerDomObject(String type, Class<? extends WXDomObject> clazz) throws WXException {
return WXDomRegistry.registerDomObject(type, clazz);
}
public static void callback(String instanceId, String funcId, Map<String, Object> data) {
WXSDKManager.getInstance().callback(instanceId, funcId, data);
}
/**
* Model switch, only applicable for developer model
* @param debug
*/
public static void restartBridge(boolean debug) {
WXEnvironment.sDebugMode = debug;
WXSDKManager.getInstance().restartBridge();
}
public static boolean registerComponent(String type, Class<? extends WXComponent> clazz) throws WXException {
return WXComponentRegistry.registerComponent(type, new SimpleComponentHolder(clazz),new HashMap<String, String>());
}
public static boolean registerComponent(Map<String, String> componentInfo, Class<? extends WXComponent> clazz) throws WXException {
if(componentInfo == null){
return false;
}
String type = componentInfo.get("type");
if(TextUtils.isEmpty(type)){
return false;
}
return WXComponentRegistry.registerComponent(type,new SimpleComponentHolder(clazz), componentInfo);
}
public static void addCustomOptions(String key, String value) {
WXEnvironment.addCustomOptions(key, value);
}
public static IWXUserTrackAdapter getIWXUserTrackAdapter() {
return WXSDKManager.getInstance().getIWXUserTrackAdapter();
}
@Deprecated
public static void setIWXUserTrackAdapter(IWXUserTrackAdapter IWXUserTrackAdapter) {
WXSDKManager.getInstance().setIWXUserTrackAdapter(IWXUserTrackAdapter);
}
public static IWXImgLoaderAdapter getIWXImgLoaderAdapter() {
return WXSDKManager.getInstance().getIWXImgLoaderAdapter();
}
@Deprecated
public static void setIWXImgLoaderAdapter(IWXImgLoaderAdapter IWXImgLoaderAdapter) {
if(IWXImgLoaderAdapter==null){
if(WXEnvironment.isApkDebugable()){
throw new IllegalStateException("ImageLoaderAdapter can not be set to null");
}
return;
}
WXSDKManager.getInstance().setIWXImgLoaderAdapter(IWXImgLoaderAdapter);
}
public static IWXHttpAdapter getIWXHttpAdapter() {
return WXSDKManager.getInstance().getIWXHttpAdapter();
}
@Deprecated
public static void setIWXHttpAdapter(IWXHttpAdapter IWXHttpAdapter) {
WXSDKManager.getInstance().setIWXHttpAdapter(IWXHttpAdapter);
}
public static IWXStorageAdapter getIWXStorageAdapter() {
return WXSDKManager.getInstance().getIWXStorageAdapter();
}
public static IActivityNavBarSetter getActivityNavBarSetter() {
return WXSDKManager.getInstance().getActivityNavBarSetter();
}
public static void setActivityNavBarSetter(IActivityNavBarSetter activityNavBarSetter) {
WXSDKManager.getInstance().setActivityNavBarSetter(activityNavBarSetter);
}
public static void show3DLayer(boolean show){
WXEnvironment.sShow3DLayer=show;
}
public static void switchDebugModel(boolean debug, String debugUrl) {
if (!WXEnvironment.isApkDebugable()) {
return;
}
if (debug) {
WXEnvironment.sDebugMode = true;
WXEnvironment.sDebugWsUrl = debugUrl;
try {
Class<?> cls = Class.forName("com.taobao.weex.WXDebugTool");
Method m = cls.getMethod("connect", String.class);
m.invoke(cls, debugUrl);
} catch (Exception e) {
Log.d("weex","WXDebugTool not found!");
}
} else {
WXEnvironment.sDebugMode = false;
WXEnvironment.sDebugWsUrl = null;
try {
Class<?> cls = Class.forName("com.taobao.weex.WXDebugTool");
Method m = cls.getMethod("close");
m.invoke(cls);
} catch (Exception e) {
Log.d("weex","WXDebugTool not found!");
}
}
}
public static void reload(final Context context, boolean remoteDebug) {
WXEnvironment.sRemoteDebugMode = remoteDebug;
WXBridgeManager.getInstance().restart();
WXBridgeManager.getInstance().initScriptsFramework(null);
WXModuleManager.reload();
WXComponentRegistry.reload();
WXSDKManager.getInstance().postOnUiThread(new Runnable() {
@Override
public void run() {
LocalBroadcastManager.getInstance(context).sendBroadcast(new Intent(JS_FRAMEWORK_RELOAD));
}
}, 1000);
}
public static void reload() {
reload(WXEnvironment.getApplication(), WXEnvironment.sRemoteDebugMode);
}
}