This is an automated email from the ASF dual-hosted git repository.
zshshr pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-weex.git
The following commit(s) were added to refs/heads/master by this push:
new 4240988 Fork/master 2019 01 30 (#2098)
4240988 is described below
commit 4240988868d99db44b81a04db1461e142eae0916
Author: darin <[email protected]>
AuthorDate: Wed Jan 30 17:26:12 2019 +0800
Fork/master 2019 01 30 (#2098)
Add a backup jsEngine thread to exec js action
---
android/sdk/libs/armeabi-v7a/libJavaScriptCore.so | Bin 5237308 -> 5237308
bytes
android/sdk/libs/armeabi-v7a/libweexcore.so | Bin 0 -> 2152328 bytes
android/sdk/libs/armeabi-v7a/libweexjss.so | Bin 550504 -> 554600 bytes
android/sdk/libs/armeabi/libJavaScriptCore.so | Bin 5237308 -> 5237308
bytes
android/sdk/libs/armeabi/libweexcore.so | Bin 2156424 -> 2156424
bytes
android/sdk/libs/armeabi/libweexjss.so | Bin 550504 -> 554600 bytes
android/sdk/libs/x86/libweexcore.so | Bin 0 -> 3344296 bytes
android/sdk/libs/x86/libweexjss.so | Bin 972408 -> 988792 bytes
.../main/java/com/taobao/weex/WXEnvironment.java | 3 +
.../taobao/weex/adapter/IWXJscProcessManager.java | 1 +
.../com/taobao/weex/bridge/WXBridgeManager.java | 3 +-
.../com/taobao/weex/ui/SimpleComponentHolder.java | 13 +
ios/sdk/WeexSDK/Sources/Bridge/WXBridgeContext.m | 15 +-
.../bridge/script_bridge_in_multi_process.cpp | 8 +-
weex_core/Source/android/jsengine/CMakeLists.txt | 1 +
.../bridge/script/core_side_in_multi_process.cpp | 650 +++++++++------------
.../jsengine/bridge/script/core_side_in_simple.cpp | 3 +-
.../script/script_bridge_in_multi_process.cpp | 11 +
.../bridge/script/script_bridge_in_simple.cpp | 2 +-
.../bridge/script/script_side_in_queue.cpp | 421 +++++++------
.../jsengine/bridge/script/script_side_in_queue.h | 40 +-
.../Source/android/jsengine/object/weex_env.cpp | 13 +-
.../Source/android/jsengine/object/weex_env.h | 24 +-
.../android/jsengine/object/weex_global_object.cpp | 28 +-
.../android/jsengine/object/weex_global_object.h | 5 +
.../android/jsengine/object/weex_object_holder.cpp | 39 +-
.../android/jsengine/object/weex_object_holder.h | 8 +-
.../jsengine/task/back_to_weex_core_queue.cpp | 154 +++++
.../jsengine/task/back_to_weex_core_queue.h | 118 ++++
.../android/jsengine/task/impl/exe_js_task.cpp | 8 +
.../android/jsengine/task/impl/exe_js_task.h | 1 +
.../jsengine/task/impl/init_framework_task.cpp | 3 +
.../jsengine/task/impl/init_framework_task.h | 1 +
.../android/jsengine/task/impl/native_timer_task.h | 4 +-
.../Source/android/jsengine/task/timer_queue.cpp | 1 +
.../Source/android/jsengine/task/timer_queue.h | 3 +-
weex_core/Source/android/jsengine/task/weex_task.h | 5 +-
.../android/jsengine/task/weex_task_queue.cpp | 16 +-
.../Source/android/jsengine/weex_ipc_server.cpp | 10 +
weex_core/Source/android/jsengine/weex_runtime.cpp | 151 +++--
weex_core/Source/android/jsengine/weex_runtime.h | 7 +-
weex_core/Source/base/CMakeLists.txt | 1 +
weex_core/Source/base/android/log_utils.h | 4 +-
weex_core/Source/base/log_defines.h | 4 +-
weex_core/Source/base/time_calculator.h | 143 +++++
weex_core/Source/base/utils/log_utils.h | 4 +-
.../core/bridge/script/core_side_in_script.cpp | 12 +-
47 files changed, 1258 insertions(+), 680 deletions(-)
diff --git a/android/sdk/libs/armeabi-v7a/libJavaScriptCore.so
b/android/sdk/libs/armeabi-v7a/libJavaScriptCore.so
index 03deedb..2d59099 100755
Binary files a/android/sdk/libs/armeabi-v7a/libJavaScriptCore.so and
b/android/sdk/libs/armeabi-v7a/libJavaScriptCore.so differ
diff --git a/android/sdk/libs/armeabi-v7a/libweexcore.so
b/android/sdk/libs/armeabi-v7a/libweexcore.so
new file mode 100644
index 0000000..b45945c
Binary files /dev/null and b/android/sdk/libs/armeabi-v7a/libweexcore.so differ
diff --git a/android/sdk/libs/armeabi-v7a/libweexjss.so
b/android/sdk/libs/armeabi-v7a/libweexjss.so
index 9ca7221..8c66b72 100644
Binary files a/android/sdk/libs/armeabi-v7a/libweexjss.so and
b/android/sdk/libs/armeabi-v7a/libweexjss.so differ
diff --git a/android/sdk/libs/armeabi/libJavaScriptCore.so
b/android/sdk/libs/armeabi/libJavaScriptCore.so
index 03deedb..2d59099 100755
Binary files a/android/sdk/libs/armeabi/libJavaScriptCore.so and
b/android/sdk/libs/armeabi/libJavaScriptCore.so differ
diff --git a/android/sdk/libs/armeabi/libweexcore.so
b/android/sdk/libs/armeabi/libweexcore.so
index 0f7743d..e0e0c90 100644
Binary files a/android/sdk/libs/armeabi/libweexcore.so and
b/android/sdk/libs/armeabi/libweexcore.so differ
diff --git a/android/sdk/libs/armeabi/libweexjss.so
b/android/sdk/libs/armeabi/libweexjss.so
index 0eca098..b5f25f4 100644
Binary files a/android/sdk/libs/armeabi/libweexjss.so and
b/android/sdk/libs/armeabi/libweexjss.so differ
diff --git a/android/sdk/libs/x86/libweexcore.so
b/android/sdk/libs/x86/libweexcore.so
new file mode 100644
index 0000000..de34837
Binary files /dev/null and b/android/sdk/libs/x86/libweexcore.so differ
diff --git a/android/sdk/libs/x86/libweexjss.so
b/android/sdk/libs/x86/libweexjss.so
index f960b90..6f3e7f6 100644
Binary files a/android/sdk/libs/x86/libweexjss.so and
b/android/sdk/libs/x86/libweexjss.so differ
diff --git a/android/sdk/src/main/java/com/taobao/weex/WXEnvironment.java
b/android/sdk/src/main/java/com/taobao/weex/WXEnvironment.java
index eb90d3a..b27d742 100644
--- a/android/sdk/src/main/java/com/taobao/weex/WXEnvironment.java
+++ b/android/sdk/src/main/java/com/taobao/weex/WXEnvironment.java
@@ -28,6 +28,7 @@ import android.os.Environment;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import com.taobao.weex.BuildConfig;
+import com.taobao.weex.adapter.IWXJscProcessManager;
import com.taobao.weex.common.WXConfig;
import com.taobao.weex.utils.FontDO;
import com.taobao.weex.utils.LogLevel;
@@ -167,6 +168,8 @@ public class WXEnvironment {
addCustomOptions(WXConfig.debugMode, "true");
}
addCustomOptions(WXConfig.scale,
Float.toString(sApplication.getResources().getDisplayMetrics().density));
+ IWXJscProcessManager wxJscProcessManager =
WXSDKManager.getInstance().getWXJscProcessManager();
+ addCustomOptions("enableBackupThread",
String.valueOf(wxJscProcessManager != null &&
wxJscProcessManager.enableBackupThread()));
}catch (NullPointerException e){
//There is little chance of NullPointerException as sApplication may be
null.
WXLogUtils.e("WXEnvironment scale Exception: ", e);
diff --git
a/android/sdk/src/main/java/com/taobao/weex/adapter/IWXJscProcessManager.java
b/android/sdk/src/main/java/com/taobao/weex/adapter/IWXJscProcessManager.java
index 59524f1..db15534 100644
---
a/android/sdk/src/main/java/com/taobao/weex/adapter/IWXJscProcessManager.java
+++
b/android/sdk/src/main/java/com/taobao/weex/adapter/IWXJscProcessManager.java
@@ -21,6 +21,7 @@ package com.taobao.weex.adapter;
import com.taobao.weex.WXSDKInstance;
public interface IWXJscProcessManager {
+ boolean enableBackupThread();
boolean shouldReboot();
long rebootTimeout();
boolean withException(WXSDKInstance instance);
diff --git
a/android/sdk/src/main/java/com/taobao/weex/bridge/WXBridgeManager.java
b/android/sdk/src/main/java/com/taobao/weex/bridge/WXBridgeManager.java
index 792c0e7..2729a1e 100644
--- a/android/sdk/src/main/java/com/taobao/weex/bridge/WXBridgeManager.java
+++ b/android/sdk/src/main/java/com/taobao/weex/bridge/WXBridgeManager.java
@@ -901,7 +901,8 @@ public class WXBridgeManager implements Callback,
BactchExecutor {
} else {
WXLogUtils.e("[WXBridgeManager] callReportCrash crash file is
empty");
}
- file.delete();
+ if(!WXEnvironment.isApkDebugable())
+ file.delete();
}
} catch (Throwable throwable) {
WXLogUtils.e("[WXBridgeManager] callReportCrash exception: ",
throwable);
diff --git
a/android/sdk/src/main/java/com/taobao/weex/ui/SimpleComponentHolder.java
b/android/sdk/src/main/java/com/taobao/weex/ui/SimpleComponentHolder.java
index 3d4be30..afd992a 100644
--- a/android/sdk/src/main/java/com/taobao/weex/ui/SimpleComponentHolder.java
+++ b/android/sdk/src/main/java/com/taobao/weex/ui/SimpleComponentHolder.java
@@ -26,11 +26,13 @@ import com.taobao.weex.annotation.JSMethod;
import com.taobao.weex.bridge.Invoker;
import com.taobao.weex.bridge.MethodInvoker;
import com.taobao.weex.annotation.Component;
+import com.taobao.weex.common.WXErrorCode;
import com.taobao.weex.common.WXRuntimeException;
import com.taobao.weex.ui.action.BasicComponentData;
import com.taobao.weex.ui.component.WXComponent;
import com.taobao.weex.ui.component.WXComponentProp;
import com.taobao.weex.ui.component.WXVContainer;
+import com.taobao.weex.utils.WXExceptionUtils;
import com.taobao.weex.utils.WXLogUtils;
import java.lang.annotation.Annotation;
@@ -41,6 +43,8 @@ import java.util.HashMap;
import java.util.Map;
import java.util.Set;
+import static
com.taobao.weex.bridge.WXBridgeManager.METHOD_REGISTER_COMPONENTS;
+
/**
* Created by sospartan on 6/12/16.
*/
@@ -214,6 +218,15 @@ public class SimpleComponentHolder implements
IFComponentHolder{
try {
return keys.toArray(new String[keys.size()]);
} catch (Throwable throwable) {
+ if(mClz != null) {
+ String name = mClz.getName();
+ String errorMsg = name + ": gen methods failed";
+ WXExceptionUtils.commitCriticalExceptionRT(null,
+ WXErrorCode.WX_KEY_EXCEPTION_INVOKE_REGISTER_COMPONENT,
+ METHOD_REGISTER_COMPONENTS, errorMsg,
+ null);
+ }
+
return new String[1];
}
diff --git a/ios/sdk/WeexSDK/Sources/Bridge/WXBridgeContext.m
b/ios/sdk/WeexSDK/Sources/Bridge/WXBridgeContext.m
index 1470df7..e56e076 100644
--- a/ios/sdk/WeexSDK/Sources/Bridge/WXBridgeContext.m
+++ b/ios/sdk/WeexSDK/Sources/Bridge/WXBridgeContext.m
@@ -668,13 +668,14 @@ _Pragma("clang diagnostic pop") \
- (bool)_isParserByRegEx
{
- 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;
+ 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
diff --git a/weex_core/Source/android/bridge/script_bridge_in_multi_process.cpp
b/weex_core/Source/android/bridge/script_bridge_in_multi_process.cpp
index 6cef124..f23a0dd 100644
--- a/weex_core/Source/android/bridge/script_bridge_in_multi_process.cpp
+++ b/weex_core/Source/android/bridge/script_bridge_in_multi_process.cpp
@@ -229,7 +229,8 @@ static std::unique_ptr<IPCResult>
HandleCallGCanvasLinkNative(
IPCArguments *arguments) {
auto arg1 = std::unique_ptr<char[]>(getArumentAsCStr(arguments, 0));
- int type = arguments->get<int32_t>(1);
+ auto typeStr = std::unique_ptr<char[]>(getArumentAsCStr(arguments, 1));
+ int type = atoi(typeStr.get());
auto arg3 = std::unique_ptr<char[]>(getArumentAsCStr(arguments, 2));
weex::base::WaitableEvent event;
char *retVal = nullptr;
@@ -279,7 +280,8 @@ static std::unique_ptr<IPCResult>
HandleCallGCanvasLinkNative(
static std::unique_ptr<IPCResult> HandleT3DLinkNative(IPCArguments *arguments)
{
- int type = arguments->get<int32_t>(0);
+ auto typeStr = std::unique_ptr<char[]>(getArumentAsCStr(arguments, 0));
+ int type = atoi(typeStr.get());
auto arg1 = std::unique_ptr<char[]>(getArumentAsCStr(arguments, 1));
weex::base::WaitableEvent event;
char *retVal = nullptr;
@@ -932,7 +934,7 @@ std::unique_ptr<IPCResult> OnReceivedResult(IPCArguments
*arguments) {
long callback_id = arguments->get<long>(0);
std::unique_ptr<WeexJSResult> result;
result.reset(new WeexJSResult);
- if (arguments->getType(1) == IPCType::BYTEARRAY &&
+ if (arguments->getCount() > 1 && arguments->getType(1) == IPCType::BYTEARRAY
&&
arguments->getByteArray(1)->length > 0) {
result->length = arguments->getByteArray(1)->length;
char *string = new char[result->length + 1];
diff --git a/weex_core/Source/android/jsengine/CMakeLists.txt
b/weex_core/Source/android/jsengine/CMakeLists.txt
index b914ed2..8c2a37c 100644
--- a/weex_core/Source/android/jsengine/CMakeLists.txt
+++ b/weex_core/Source/android/jsengine/CMakeLists.txt
@@ -108,6 +108,7 @@ set(${WEEXJSSERVER_NAME}_SOURCES
task/weex_task_queue.cpp
task/timer_task.cpp
task/timer_queue.cpp
+ task/back_to_weex_core_queue.cpp
wson/wson_jsc.h
wson/wson_jsc.cpp
diff --git
a/weex_core/Source/android/jsengine/bridge/script/core_side_in_multi_process.cpp
b/weex_core/Source/android/jsengine/bridge/script/core_side_in_multi_process.cpp
index 040701d..4590ebb 100644
---
a/weex_core/Source/android/jsengine/bridge/script/core_side_in_multi_process.cpp
+++
b/weex_core/Source/android/jsengine/bridge/script/core_side_in_multi_process.cpp
@@ -47,41 +47,31 @@ namespace weex {
void CoreSideInMultiProcess::CallNative(const char *page_id, const
char *task,
const char *callback) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLNATIVE));
- // instacneID args[0]
- serializer->add(page_id, strlen(page_id));
- // task args[1]
- serializer->add(task, strlen(task));
- // callback args[2]
- serializer->add(callback, strlen(callback));
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLNATIVE);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(task);
+ ipc_task->addParams(callback);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
std::unique_ptr<ValueWithType>
CoreSideInMultiProcess::CallNativeModule(
const char *page_id, const char *module, const char
*method,
const char *arguments, int arguments_length, const char
*options,
int options_length) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLNATIVEMODULE));
-
- // instacneID args[0]
- serializer->add(page_id, strlen(page_id));
- // module args[1]
- serializer->add(module, strlen(module));
- // method args[2]
- serializer->add(method, strlen(method));
- // arguments args[3]
- serializer->add(arguments, arguments_length);
- // options args[4]
- serializer->add(options, options_length);
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
-
- auto ipc_result = sender->send(buffer.get());
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLNATIVEMODULE);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(module);
+ ipc_task->addParams(method);
+ ipc_task->addParams(arguments, arguments_length);
+ ipc_task->addParams(options, options_length);
+ auto future = std::unique_ptr<BackToWeexCoreQueue::Future>(
+ new BackToWeexCoreQueue::Future());
+ ipc_task->set_future(future.get());
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
+
+ std::unique_ptr<IPCResult> ipc_result =
future.get()->waitResult();
std::unique_ptr<ValueWithType> ret(new ValueWithType);
@@ -92,15 +82,18 @@ namespace weex {
break;
case IPCType::STRING:
ret->type = ParamsType::STRING;
- ret->value.string =
genWeexStringSS(ipc_result->getStringContent(), ipc_result->getStringLength());
+ ret->value.string =
genWeexStringSS(ipc_result->getStringContent(),
+
ipc_result->getStringLength());
break;
case IPCType::JSONSTRING:
ret->type = ParamsType::JSONSTRING;
- ret->value.string =
genWeexStringSS(ipc_result->getStringContent(), ipc_result->getStringLength());
+ ret->value.string =
genWeexStringSS(ipc_result->getStringContent(),
+
ipc_result->getStringLength());
break;
case IPCType::BYTEARRAY: {
ret->type = ParamsType::BYTEARRAY;
- ret->value.byteArray =
genWeexByteArraySS(ipc_result->getByteArrayContent(),
ipc_result->getByteArrayLength());
+ ret->value.byteArray =
genWeexByteArraySS(ipc_result->getByteArrayContent(),
+
ipc_result->getByteArrayLength());
}
break;
default:
@@ -113,271 +106,207 @@ namespace weex {
const char *page_id, const char *ref, const char *method,
const char *arguments, int arguments_length, const char
*options,
int options_length) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLNATIVECOMPONENT));
-
- // instacneID args[0]
- serializer->add(page_id, strlen(page_id));
- // module args[1]
- serializer->add(ref, strlen(ref));
- // method args[2]
- serializer->add(method, strlen(method));
- // arguments args[3]
- serializer->add(arguments, arguments_length);
- // options args[4]
- serializer->add(options, options_length);
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallNativeComponent: unexpected result: %d",
- result->getType());
- }
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLNATIVECOMPONENT);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(ref);
+ ipc_task->addParams(method);
+ ipc_task->addParams(arguments, arguments_length);
+ ipc_task->addParams(options, options_length);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
+// if (result->getType() != IPCType::INT32) {
+// LOGE("functionCallNativeComponent: unexpected result:
%d",
+// result->getType());
+// }
}
void CoreSideInMultiProcess::AddElement(const char *page_id,
const char *parent_ref,
const char *dom_str, int
dom_str_length,
const char *index_str) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLADDELEMENT) |
- MSG_FLAG_ASYNC);
-
- // instacneID args[0]
- serializer->add(page_id, strlen(page_id));
- // instacneID args[1]
- serializer->add(parent_ref, strlen(parent_ref));
- // dom node args[2]
- serializer->add(dom_str, dom_str_length);
- // index args[3]
- serializer->add(index_str, strlen(index_str));
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLADDELEMENT);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(parent_ref);
+ ipc_task->addParams(dom_str, dom_str_length);
+ ipc_task->addParams(index_str);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
void CoreSideInMultiProcess::SetTimeout(const char *callback_id,
const char *time) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::SETTIMEOUT));
- // callbackId
- serializer->add(callback_id, strlen(callback_id));
- // time
- serializer->add(time, strlen(time));
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallNativeComponent: unexpected result: %d",
- result->getType());
- }
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::SETTIMEOUT);
+ ipc_task->addParams(callback_id);
+ ipc_task->addParams(time);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
void CoreSideInMultiProcess::NativeLog(const char *str_array) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::NATIVELOG) |
- MSG_FLAG_ASYNC);
- serializer->add(str_array, strlen(str_array));
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- sender->send(buffer.get());
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::NATIVELOG);
+ ipc_task->addParams(str_array);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
void CoreSideInMultiProcess::CreateBody(const char *page_id,
const char *dom_str,
int dom_str_length) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLCREATEBODY));
-
- // page id
- serializer->add(page_id, strlen(page_id));
- // dom node args[2]
- serializer->add(dom_str, dom_str_length);
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallNative: unexpected result: %d",
result->getType());
- }
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLCREATEBODY);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(dom_str, dom_str_length);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
int CoreSideInMultiProcess::UpdateFinish(const char *page_id,
const char *task,
int task_length, const
char *callback,
int callback_length) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLUPDATEFINISH));
- serializer->add(page_id, strlen(page_id));
- serializer->add(task, task_length);
- serializer->add(callback, callback_length);
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallUpdateFinish: unexpected result: %d",
result->getType());
+
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLUPDATEFINISH);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(task, task_length);
+ ipc_task->addParams(callback, callback_length);
+ auto future = std::unique_ptr<BackToWeexCoreQueue::Future>(
+ new BackToWeexCoreQueue::Future());
+ ipc_task->set_future(future.get());
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
+
+ std::unique_ptr<IPCResult> ipc_result =
future.get()->waitResult();
+
+ if (ipc_result->getType() != IPCType::INT32) {
+ LOGE("functionCallUpdateFinish: unexpected result: %d",
ipc_result->getType());
return 0;
}
- return result->get<int32_t>();
+ return ipc_result->get<int32_t>();
}
void CoreSideInMultiProcess::CreateFinish(const char *page_id) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLCREATEFINISH));
- serializer->add(page_id, strlen(page_id));
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallCreateFinish: unexpected result: %d",
result->getType());
- }
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLCREATEFINISH);
+ ipc_task->addParams(page_id);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
int CoreSideInMultiProcess::RefreshFinish(const char *page_id,
const char *task,
const char *callback) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLREFRESHFINISH));
- // instacneID args[0]
- serializer->add(page_id, strlen(page_id));
- // task args[1]
- serializer->add(task, strlen(task));
- // callback args[2]
- serializer->add(callback, strlen(callback));
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallRefreshFinish: unexpected result: %d",
result->getType());
+
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLREFRESHFINISH);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(task);
+ ipc_task->addParams(callback);
+ auto future = std::unique_ptr<BackToWeexCoreQueue::Future>(
+ new BackToWeexCoreQueue::Future());
+ ipc_task->set_future(future.get());
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
+
+ std::unique_ptr<IPCResult> ipc_result =
future.get()->waitResult();
+
+ if (ipc_result->getType() != IPCType::INT32) {
+ LOGE("functionCallRefreshFinish: unexpected result: %d",
ipc_result->getType());
return 0;
}
- return result->get<int32_t>();
+ return ipc_result->get<int32_t>();
}
void CoreSideInMultiProcess::UpdateAttrs(const char *page_id,
const char *ref,
const char *data, int
data_length) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLUPDATEATTRS));
- // instacneID args[0]
- serializer->add(page_id, strlen(page_id));
- // ref args[1]
- serializer->add(ref, strlen(ref));
- // dom node args[2] TODO
- serializer->add(data, data_length);
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallUpdateAttrs: unexpected result: %d",
result->getType());
- }
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLUPDATEATTRS);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(ref);
+ ipc_task->addParams(data, data_length);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
void CoreSideInMultiProcess::UpdateStyle(const char *page_id,
const char *ref,
const char *data, int
data_length) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLUPDATESTYLE));
- // instacneID args[0]
- serializer->add(page_id, strlen(page_id));
- // ref args[1]
- serializer->add(ref, strlen(ref));
- // dom node styles args[2]
- serializer->add(data, data_length);
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallUpdateStyle: unexpected result: %d",
result->getType());
- }
+
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLUPDATESTYLE);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(ref);
+ ipc_task->addParams(data, data_length);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
void CoreSideInMultiProcess::RemoveElement(const char *page_id,
const char *ref) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLREMOVEELEMENT));
- serializer->add(page_id, strlen(page_id));
- serializer->add(ref, strlen(ref));
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallRemoveElement: unexpected result: %d",
result->getType());
- }
+
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLREMOVEELEMENT);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(ref);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
void CoreSideInMultiProcess::MoveElement(const char *page_id,
const char *ref,
const char *parent_ref,
int index) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLMOVEELEMENT));
- serializer->add(page_id, strlen(page_id));
- serializer->add(ref, strlen(ref));
- serializer->add(parent_ref, strlen(parent_ref));
- // Client need string
- auto temp = std::to_string(index);
- serializer->add(temp.c_str(), temp.size());
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallMoveElement: unexpected result: %d",
result->getType());
- }
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLMOVEELEMENT);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(ref);
+ ipc_task->addParams(parent_ref);
+ auto temp = std::to_string(index);
+ ipc_task->addParams(temp.c_str(), temp.length());
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
void CoreSideInMultiProcess::AddEvent(const char *page_id, const
char *ref,
const char *event) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLADDEVENT));
- serializer->add(page_id, strlen(page_id));
- serializer->add(ref, strlen(ref));
- serializer->add(event, strlen(event));
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallAddEvent: unexpected result: %d",
result->getType());
- }
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLADDEVENT);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(ref);
+ ipc_task->addParams(event);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
void CoreSideInMultiProcess::RemoveEvent(const char *page_id,
const char *ref,
const char *event) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLREMOVEEVENT));
- serializer->add(page_id, strlen(page_id));
- serializer->add(ref, strlen(ref));
- serializer->add(event, strlen(event));
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionCallRemoveEvent: unexpected result: %d",
result->getType());
- }
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLREMOVEEVENT);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(ref);
+ ipc_task->addParams(event);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
const char *CoreSideInMultiProcess::CallGCanvasLinkNative(
const char *context_id, int type, const char *arg) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLGCANVASLINK));
- // contextId args[0]
- serializer->add(context_id, strlen(context_id));
- // type args[1]
- serializer->add(type);
- // arg args[2]
- serializer->add(arg, strlen(arg));
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLGCANVASLINK);
+ ipc_task->addParams(context_id);
+ auto temp = std::to_string(type);
+ ipc_task->addParams(temp.c_str(), temp.length());
+ ipc_task->addParams(arg);
+ auto future = std::unique_ptr<BackToWeexCoreQueue::Future>(
+ new BackToWeexCoreQueue::Future());
+ ipc_task->set_future(future.get());
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
+
+ std::unique_ptr<IPCResult> result = future.get()->waitResult();
+
try {
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result =
sender->send(buffer.get());
// LOGE("weexjsc functionGCanvasLinkNative");
// if (result->getType() == IPCType::VOID) {
// return JSValue::encode(ret);
@@ -406,91 +335,79 @@ namespace weex {
int CoreSideInMultiProcess::SetInterval(const char *page_id,
const char *callback_id,
const char *time) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::SETINTERVAL));
- // instacneID args[0]
- serializer->add(page_id, strlen(page_id));
- // task args[1]
- serializer->add(callback_id, strlen(callback_id));
- // callback args[2]
- serializer->add(time, strlen(time));
- try {
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result =
sender->send(buffer.get());
- if (result->getType() != IPCType::INT32) {
- LOGE("functionSetIntervalWeex: unexpected result: %d",
result->getType());
- return 0;
- }
- return result->get<int32_t>();
- } catch (IPCException &e) {
- LOGE("functionSetIntervalWeex exception %s", e.msg());
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::SETINTERVAL);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(callback_id);
+ ipc_task->addParams(time);
+ auto future = std::unique_ptr<BackToWeexCoreQueue::Future>(
+ new BackToWeexCoreQueue::Future());
+ ipc_task->set_future(future.get());
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
+
+ std::unique_ptr<IPCResult> result = future.get()->waitResult();
+ if (result->getType() != IPCType::INT32) {
+ LOGE("functionSetIntervalWeex: unexpected result: %d",
result->getType());
+ return 0;
}
- return 0;
+ return result->get<int32_t>();
}
void CoreSideInMultiProcess::ClearInterval(const char *page_id,
const char
*callback_id) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CLEARINTERVAL));
- // instacneID args[0]
- serializer->add(page_id, strlen(page_id));
- // task args[1]
- serializer->add(callback_id, strlen(callback_id));
- try {
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result =
sender->send(buffer.get());
- } catch (IPCException &e) {
- LOGE("functionClearIntervalWeex exception %s", e.msg());
- }
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CLEARINTERVAL);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(callback_id);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
const char *CoreSideInMultiProcess::CallT3DLinkNative(int type,
const char
*arg) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::CALLT3DLINK));
- // type args[1]
- serializer->add(type);
- // arg args[2]
- serializer->add(arg, strlen(arg));
- try {
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result =
sender->send(buffer.get());
- // LOGE("weexjsc functionT3DLinkNative");
- // if (result->getType() == IPCType::VOID) {
- // return JSValue::encode(ret);
- // } else if (result->getStringLength() > 0) {
- // WTF::String retWString =
jString2String(result->getStringContent(),
- // result->getStringLength()); LOGE("weexjsc
functionT3DLinkNative
- // result length > 1 retWString:%s",
retWString.utf8().data()); ret =
- // String2JSValue(state, retWString);
- // }
- if (result->getType() != IPCType::VOID) {
- if (result->getStringLength() > 0) {
- return jString2String(result->getStringContent(),
- result->getStringLength())
- .utf8()
- .data();
- }
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::CALLT3DLINK);
+ auto temp = std::to_string(type);
+ ipc_task->addParams(temp.c_str(), temp.length());
+ ipc_task->addParams(arg);
+ auto future = std::unique_ptr<BackToWeexCoreQueue::Future>(
+ new BackToWeexCoreQueue::Future());
+ ipc_task->set_future(future.get());
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
+
+ std::unique_ptr<IPCResult> result = future.get()->waitResult();
+ // LOGE("weexjsc functionT3DLinkNative");
+ // if (result->getType() == IPCType::VOID) {
+ // return JSValue::encode(ret);
+ // } else if (result->getStringLength() > 0) {
+ // WTF::String retWString =
jString2String(result->getStringContent(),
+ // result->getStringLength()); LOGE("weexjsc
functionT3DLinkNative
+ // result length > 1 retWString:%s",
retWString.utf8().data()); ret =
+ // String2JSValue(state, retWString);
+
+ // }
+ if (result->getType() != IPCType::VOID) {
+ if (result->getStringLength() > 0) {
+ return jString2String(result->getStringContent(),
+ result->getStringLength())
+ .utf8()
+ .data();
}
- } catch (IPCException &e) {
- LOGE("functionT3DLinkNative exception: %s", e.msg());
- _exit(1);
}
- return NULL;
+ return nullptr;
}
- void CoreSideInMultiProcess::PostMessage(const char *vim_id, const
char *data, int dataLength) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::POSTMESSAGE));
- serializer->add(data, dataLength);
- serializer->add(vim_id, strlen(vim_id));
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
+ void CoreSideInMultiProcess::PostMessage(const char *vim_id, const
char *data,
+ int dataLength) {
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::POSTMESSAGE);
+ ipc_task->addParams(data, dataLength);
+ ipc_task->addParams(vim_id);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
void CoreSideInMultiProcess::DispatchMessage(const char *client_id,
@@ -498,19 +415,14 @@ namespace weex {
int dataLength,
const char *callback,
const char *vm_id) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::DISPATCHMESSAGE));
- // clientid
- serializer->add(client_id, strlen(client_id));
- // data
- serializer->add(data, dataLength);
- // callback
- serializer->add(callback, strlen(callback));
- serializer->add(vm_id, strlen(vm_id));
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::DISPATCHMESSAGE);
+ ipc_task->addParams(client_id);
+ ipc_task->addParams(data, dataLength);
+ ipc_task->addParams(callback);
+ ipc_task->addParams(vm_id);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
std::unique_ptr<WeexJSResult>
@@ -518,84 +430,72 @@ namespace weex {
const char *data,
int dataLength,
const char *vm_id) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());
- serializer->setMsg(
- static_cast<uint32_t>(IPCProxyMsg::DISPATCHMESSAGESYNC));
- // clientid
- serializer->add(client_id, strlen(client_id));
- // data
- serializer->add(data, dataLength);
- serializer->add(vm_id, strlen(vm_id));
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
-
- char *copy = nullptr;
- int length = 0;
- if (result->getType() == IPCType::BYTEARRAY) {
- length = result->getByteArrayLength();
- copy = new char[length];
- strcpy(copy, result->getByteArrayContent());
- }
- return std::unique_ptr<WeexJSResult>(
- new WeexJSResult(std::unique_ptr<char[]>(copy), length));
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::DISPATCHMESSAGESYNC);
+ ipc_task->addParams(client_id);
+ ipc_task->addParams(data, dataLength);
+ ipc_task->addParams(vm_id);
+ auto future = std::unique_ptr<BackToWeexCoreQueue::Future>(
+ new BackToWeexCoreQueue::Future());
+ ipc_task->set_future(future.get());
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
+
+ std::unique_ptr<IPCResult> result = future.get()->waitResult();
+ char *copy = nullptr;
+ int length = 0;
+ if (result->getType() == IPCType::BYTEARRAY) {
+ length = result->getByteArrayLength();
+ copy = new char[length];
+ strcpy(copy, result->getByteArrayContent());
+ }
+ return std::unique_ptr<WeexJSResult>(
+ new WeexJSResult(std::unique_ptr<char[]>(copy),
length));
}
void CoreSideInMultiProcess::ReportException(const char *page_id,
const char *func,
const char
*exception_string) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::REPORTEXCEPTION));
- serializer->add(page_id, strlen(page_id));
- serializer->add(func, strlen(func));
- serializer->add(exception_string, strlen(exception_string));
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::VOID) {
- LOGE("REPORTEXCEPTION: unexpected result: %d",
result->getType());
- }
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::REPORTEXCEPTION);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(func);
+ ipc_task->addParams(exception_string);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
void CoreSideInMultiProcess::SetJSVersion(const char *js_version) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::SETJSFVERSION));
- serializer->add(js_version, strlen(js_version));
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- std::unique_ptr<IPCResult> result = sender->send(buffer.get());
- if (result->getType() != IPCType::VOID) {
- LOGE("setJSFVersion: unexpected result: %d",
result->getType());
- }
+
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::SETJSFVERSION);
+ ipc_task->addParams(js_version);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
- void CoreSideInMultiProcess::OnReceivedResult(long callback_id,
std::unique_ptr<WeexJSResult>& result) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());;
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::ONRECEIVEDRESULT));
- serializer->add(static_cast<int64_t>(callback_id));
+ void CoreSideInMultiProcess::OnReceivedResult(long callback_id,
+
std::unique_ptr<WeexJSResult> &result) {
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::ONRECEIVEDRESULT);
+
+ auto temp = std::to_string(callback_id);
+ ipc_task->addParams(temp.c_str(), temp.length());
if (result != nullptr) {
- serializer->add(result->data.get(), result->length);
- } else {
- serializer->addVoid();
+ ipc_task->addParams(result->data.get(), result->length);
}
-
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- sender->send(buffer.get());
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
- void CoreSideInMultiProcess::UpdateComponentData(const char*
page_id, const char* cid, const char* json_data) {
- IPCSender *sender = client_->getSender();
- std::unique_ptr<IPCSerializer>
serializer(createIPCSerializer());
-
serializer->setMsg(static_cast<uint32_t>(IPCProxyMsg::UPDATECOMPONENTDATA));
- serializer->add(page_id, strlen(page_id));
- serializer->add(cid, strlen(cid));
- serializer->add(json_data, strlen(json_data));
+ void CoreSideInMultiProcess::UpdateComponentData(const char
*page_id, const char *cid,
+ const char
*json_data) {
+
- std::unique_ptr<IPCBuffer> buffer = serializer->finish();
- sender->send(buffer.get());
+ BackToWeexCoreQueue::IPCTask *ipc_task = new
BackToWeexCoreQueue::IPCTask(
+ IPCProxyMsg::UPDATECOMPONENTDATA);
+ ipc_task->addParams(page_id);
+ ipc_task->addParams(cid);
+ ipc_task->addParams(json_data);
+
WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->addTask(ipc_task);
}
} // namespace js
} // namespace bridge
diff --git
a/weex_core/Source/android/jsengine/bridge/script/core_side_in_simple.cpp
b/weex_core/Source/android/jsengine/bridge/script/core_side_in_simple.cpp
index 2b2eea4..368b21d 100644
--- a/weex_core/Source/android/jsengine/bridge/script/core_side_in_simple.cpp
+++ b/weex_core/Source/android/jsengine/bridge/script/core_side_in_simple.cpp
@@ -24,7 +24,6 @@
#include "android/jsengine/object/args.h"
#include "base/android/log_utils.h"
-#include "base/android/log_utils.h"
#include "core/manager/weex_core_manager.h"
#include "core/render/manager/render_manager.h"
#include "third_party/IPC/IPCResult.h"
@@ -217,7 +216,7 @@ void CoreSideInSimple::ReportException(const char *page_id,
const char *func,
}
void CoreSideInSimple::SetJSVersion(const char *js_version) {
- LOGA("init JSFrm version %s", js_version);
+ LOGD("init JSFrm version %s", js_version);
WeexCoreManager::Instance()
->getPlatformBridge()
->platform_side()
diff --git
a/weex_core/Source/android/jsengine/bridge/script/script_bridge_in_multi_process.cpp
b/weex_core/Source/android/jsengine/bridge/script/script_bridge_in_multi_process.cpp
index 4e135f1..56d83ac 100644
---
a/weex_core/Source/android/jsengine/bridge/script/script_bridge_in_multi_process.cpp
+++
b/weex_core/Source/android/jsengine/bridge/script/script_bridge_in_multi_process.cpp
@@ -251,6 +251,17 @@ namespace weex {
memset(init_framework_params, 0,
sizeof(INIT_FRAMEWORK_PARAMS));
init_framework_params->type =
IPCByteArrayToWeexByteArray(ba_type);
init_framework_params->value =
IPCByteArrayToWeexByteArray(ba);
+
+ if(!WeexEnv::getEnv()->enableBackupThread()) {
+ auto type =
String::fromUTF8(init_framework_params->type->content);
+ auto value =
String::fromUTF8(init_framework_params->value->content);
+ if(type == "enableBackupThread") {
+ auto enable = value == "true";
+ LOGE("enable backupThread %d",enable);
+ WeexEnv::getEnv()->setEnableBackupThread(enable);
+ }
+ }
+
params.push_back(init_framework_params);
}
int val = Instance()->script_side()->InitFramework(source,
params);
diff --git
a/weex_core/Source/android/jsengine/bridge/script/script_bridge_in_simple.cpp
b/weex_core/Source/android/jsengine/bridge/script/script_bridge_in_simple.cpp
index e714220..054ff6b 100644
---
a/weex_core/Source/android/jsengine/bridge/script/script_bridge_in_simple.cpp
+++
b/weex_core/Source/android/jsengine/bridge/script/script_bridge_in_simple.cpp
@@ -35,7 +35,7 @@ ScriptBridgeInSimple* ScriptBridgeInSimple::g_instance = NULL;
ScriptBridgeInSimple::ScriptBridgeInSimple() {
WeexEnv::getEnv()->setScriptBridge(this);
- set_script_side(new ScriptSideInSimple(new WeexRuntime(this, false)));
+ set_script_side(new ScriptSideInSimple(new WeexRuntime(nullptr, this,
false)));
set_core_side(new CoreSideInSimple());
}
diff --git
a/weex_core/Source/android/jsengine/bridge/script/script_side_in_queue.cpp
b/weex_core/Source/android/jsengine/bridge/script/script_side_in_queue.cpp
index a4bfe66..3275790 100644
--- a/weex_core/Source/android/jsengine/bridge/script/script_side_in_queue.cpp
+++ b/weex_core/Source/android/jsengine/bridge/script/script_side_in_queue.cpp
@@ -20,6 +20,7 @@
// Created by Darin on 2018/7/22.
//
+#include <object/weex_env.h>
#include "script_side_in_queue.h"
#include "android/jsengine/task/impl/init_framework_task.h"
@@ -38,182 +39,268 @@
#include "android/jsengine/task/impl/native_timer_task.h"
namespace weex {
- namespace bridge {
- namespace js {
- int ScriptSideInQueue::InitFramework(
- const char *script, std::vector<INIT_FRAMEWORK_PARAMS *>
¶ms) {
- LOGD("ScriptSideInQueue::InitFramework");
+namespace bridge {
+namespace js {
+int ScriptSideInQueue::InitFramework(
+ const char *script, std::vector<INIT_FRAMEWORK_PARAMS *> ¶ms) {
+ LOGD("ScriptSideInQueue::InitFramework");
// return runtime_->initFramework(String::fromUTF8(script),
params);
- weexTaskQueue_->addTask(new
InitFrameworkTask(String::fromUTF8(script), params));
- weexTaskQueue_->init();
- return 1;
- }
-
- int ScriptSideInQueue::InitAppFramework(
- const char *instanceId, const char *appFramework,
- std::vector<INIT_FRAMEWORK_PARAMS *> ¶ms) {
- LOGD("ScriptSideInQueue::InitAppFramework");
- weexTaskQueue_->addTask(new
InitFrameworkTask(String::fromUTF8(instanceId),
-
String::fromUTF8(appFramework), params));
- return 1;
+ weexTaskQueue_->addTask(new InitFrameworkTask(String::fromUTF8(script),
params));
+ weexTaskQueue_->init();
+
+ if (WeexEnv::getEnv()->enableBackupThread()) {
+ weexTaskQueue_bk_ = new WeexTaskQueue(weexTaskQueue_->isMultiProgress);
+ weexTaskQueue_bk_->addTask(new InitFrameworkTask(String::fromUTF8(script),
params));
+ weexTaskQueue_bk_->init();
+ }
+
+ return 1;
+}
+
+int ScriptSideInQueue::InitAppFramework(
+ const char *instanceId, const char *appFramework,
+ std::vector<INIT_FRAMEWORK_PARAMS *> ¶ms) {
+ LOGD("ScriptSideInQueue::InitAppFramework");
+ weexTaskQueue_->addTask(new InitFrameworkTask(String::fromUTF8(instanceId),
+
String::fromUTF8(appFramework), params));
+ return 1;
// return
runtime_->initAppFramework(String::fromUTF8(instanceId),
//
String::fromUTF8(appFramework), params);
- }
+}
- int ScriptSideInQueue::CreateAppContext(const char *instanceId,
- const char *jsBundle) {
- LOGD("ScriptSideInQueue::CreateAppContext");
- auto script = String::fromUTF8(jsBundle);
- if(script.isEmpty()) {
- return 0;
- }
- weexTaskQueue_->addTask(new
CreateAppContextTask(String::fromUTF8(instanceId),
- script));
- return 1;
- }
+int ScriptSideInQueue::CreateAppContext(const char *instanceId,
+ const char *jsBundle) {
+ LOGD("ScriptSideInQueue::CreateAppContext");
+ auto script = String::fromUTF8(jsBundle);
+ if (script.isEmpty()) {
+ return 0;
+ }
+ weexTaskQueue_->addTask(new
CreateAppContextTask(String::fromUTF8(instanceId),
+ script));
+ return 1;
+}
- std::unique_ptr<WeexJSResult>
ScriptSideInQueue::ExecJSOnAppWithResult(const char *instanceId,
- const char
*jsBundle) {
- LOGD("ScriptSideInQueue::ExecJSOnAppWithResult");
+std::unique_ptr<WeexJSResult> ScriptSideInQueue::ExecJSOnAppWithResult(const
char *instanceId,
+ const
char *jsBundle) {
+ LOGD("ScriptSideInQueue::ExecJSOnAppWithResult");
- WeexTask *task = new
ExeJsOnAppWithResultTask(String::fromUTF8(instanceId),
-
String::fromUTF8(jsBundle));
+ WeexTask *task = new ExeJsOnAppWithResultTask(String::fromUTF8(instanceId),
+ String::fromUTF8(jsBundle));
- auto future = std::unique_ptr<WeexTask::Future>(new
WeexTask::Future());
- task->set_future(future.get());
+ auto future = std::unique_ptr<WeexTask::Future>(new WeexTask::Future());
+ task->set_future(future.get());
- weexTaskQueue_->addTask(task);
+ weexTaskQueue_->addTask(task);
- return std::move(future->waitResult());
- }
-
- int ScriptSideInQueue::CallJSOnAppContext(
- const char *instanceId, const char *func,
- std::vector<VALUE_WITH_TYPE *> ¶ms) {
- LOGD("ScriptSideInQueue::CallJSOnAppContext");
-
- weexTaskQueue_->addTask(new
CallJsOnAppContextTask(String::fromUTF8(instanceId),
-
String::fromUTF8(func), params));
-
- return 1;
- }
-
- int ScriptSideInQueue::DestroyAppContext(const char *instanceId) {
- LOGD("ScriptSideInQueue::DestroyAppContext");
-
- weexTaskQueue_->addTask(new
DestoryAppContextTask(String::fromUTF8(instanceId)));
-
- return 1;
- }
-
- int ScriptSideInQueue::ExecJsService(const char *source) {
- LOGD("ScriptSideInQueue::ExecJsService");
-
- weexTaskQueue_->addTask(new
ExeJsServicesTask(String::fromUTF8(source)));
-
- return 1;
- }
-
- int ScriptSideInQueue::ExecTimeCallback(const char *source) {
- LOGD("ScriptSideInQueue::ExecTimeCallback");
-
- weexTaskQueue_->addTask(new
CTimeCallBackTask(String::fromUTF8(source)));
-
- return 1;
- }
-
- int ScriptSideInQueue::ExecJS(const char *instanceId, const char
*nameSpace,
- const char *func,
- std::vector<VALUE_WITH_TYPE *>
¶ms) {
- LOGD("ScriptSideInQueue::ExecJS");
-
- ExeJsTask *task = new ExeJsTask(instanceId, params);
-
- task->addExtraArg(String::fromUTF8(nameSpace));
- task->addExtraArg(String::fromUTF8(func));
-
- weexTaskQueue_->addTask(task);
-
- return 1;
- }
-
- std::unique_ptr<WeexJSResult> ScriptSideInQueue::ExecJSWithResult(
- const char *instanceId, const char *nameSpace, const char
*func,
- std::vector<VALUE_WITH_TYPE *> ¶ms) {
- LOGD("ScriptSideInQueue::ExecJSWithResult");
-
- ExeJsTask *task = new ExeJsTask(instanceId, params, true);
-
- auto future = std::unique_ptr<WeexTask::Future>(new
WeexTask::Future());
- task->set_future(future.get());
-
- task->addExtraArg(String::fromUTF8(nameSpace));
- task->addExtraArg(String::fromUTF8(func));
- weexTaskQueue_->addTask(task);
- return std::move(future->waitResult());
- }
-
- void ScriptSideInQueue::ExecJSWithCallback(
- const char *instanceId, const char *nameSpace, const char
*func,
- std::vector<VALUE_WITH_TYPE *> ¶ms, long callback_id) {
- LOGD("ScriptSideInQueue::ExecJSWithCallback");
-
- ExeJsTask *task = new ExeJsTask(instanceId, params,
callback_id);
-
- task->addExtraArg(String::fromUTF8(nameSpace));
- task->addExtraArg(String::fromUTF8(func));
- weexTaskQueue_->addTask(task);
- }
-
- int ScriptSideInQueue::CreateInstance(const char *instanceId,
const char *func,
- const char *script, const
char *opts,
- const char *initData,
- const char *extendsApi,
std::vector<INIT_FRAMEWORK_PARAMS*>& params) {
- LOGD(
- "CreateInstance id = %s, func = %s, script = %s, opts
= %s, initData = "
- "%s, extendsApi = %s",
- instanceId, func, script, opts, initData, extendsApi);
-
- auto string = String::fromUTF8(script);
- if(string.isEmpty()) {
- return 0;
- }
- CreateInstanceTask *task = new
CreateInstanceTask(String::fromUTF8(instanceId),
- string,
params);
-
- task->addExtraArg(String::fromUTF8(func));
- task->addExtraArg(String::fromUTF8(opts));
- task->addExtraArg(String::fromUTF8(initData));
- task->addExtraArg(String::fromUTF8(extendsApi));
- weexTaskQueue_->addTask(task);
-
- return 1;
- }
-
- std::unique_ptr<WeexJSResult>
ScriptSideInQueue::ExecJSOnInstance(const char *instanceId,
- const char *script) {
- LOGD("ScriptSideInQueue::ExecJSOnInstance");
- ExeJsOnInstanceTask *task = new
ExeJsOnInstanceTask(String::fromUTF8(instanceId),
-
String::fromUTF8(script));
- weexTaskQueue_->addTask(task);
- auto future = std::unique_ptr<WeexTask::Future>(new
WeexTask::Future());
- task->set_future(future.get());
- return std::move(future->waitResult());
- }
-
- int ScriptSideInQueue::DestroyInstance(const char *instanceId) {
- LOGD("ScriptSideInQueue::DestroyInstance instanceId: %s \n",
instanceId);
- weexTaskQueue_->addTask(new
DestoryInstanceTask(String::fromUTF8(instanceId)));
- return 1;
- }
-
- int ScriptSideInQueue::UpdateGlobalConfig(const char *config) {
- LOGD("ScriptSideInQueue::UpdateGlobalConfig");
- weexTaskQueue_->addTask(new
UpdateGlobalConfigTask(String::fromUTF8(config)));
- return 1;
- }
- } // namespace js
- } // namespace bridge
+ return std::move(future->waitResult());
+}
+
+int ScriptSideInQueue::CallJSOnAppContext(
+ const char *instanceId, const char *func,
+ std::vector<VALUE_WITH_TYPE *> ¶ms) {
+ LOGD("ScriptSideInQueue::CallJSOnAppContext");
+
+ weexTaskQueue_->addTask(new
CallJsOnAppContextTask(String::fromUTF8(instanceId),
+ String::fromUTF8(func),
params));
+
+ return 1;
+}
+
+int ScriptSideInQueue::DestroyAppContext(const char *instanceId) {
+ LOGD("ScriptSideInQueue::DestroyAppContext");
+
+ weexTaskQueue_->addTask(new
DestoryAppContextTask(String::fromUTF8(instanceId)));
+
+ return 1;
+}
+
+int ScriptSideInQueue::ExecJsService(const char *source) {
+ LOGD("ScriptSideInQueue::ExecJsService");
+
+ weexTaskQueue_->addTask(new ExeJsServicesTask(String::fromUTF8(source)));
+ if (WeexEnv::getEnv()->enableBackupThread() && weexTaskQueue_bk_ != nullptr)
{
+ weexTaskQueue_bk_->addTask(new
ExeJsServicesTask(String::fromUTF8(source)));
+ }
+
+ return 1;
+}
+
+int ScriptSideInQueue::ExecTimeCallback(const char *source) {
+ LOGD("ScriptSideInQueue::ExecTimeCallback");
+
+ weexTaskQueue_->addTask(new CTimeCallBackTask(String::fromUTF8(source)));
+ if (WeexEnv::getEnv()->enableBackupThread() && weexTaskQueue_bk_ != nullptr)
{
+ weexTaskQueue_bk_->addTask(new
CTimeCallBackTask(String::fromUTF8(source)));
+ }
+
+ return 1;
+}
+
+int ScriptSideInQueue::ExecJS(const char *instanceId, const char *nameSpace,
+ const char *func,
+ std::vector<VALUE_WITH_TYPE *> ¶ms) {
+ LOGD("ScriptSideInQueue::ExecJS");
+
+ ExeJsTask *task = new ExeJsTask(instanceId, params);
+
+ task->addExtraArg(String::fromUTF8(nameSpace));
+ task->addExtraArg(String::fromUTF8(func));
+
+ if (instanceId == nullptr || strlen(instanceId) == 0) {
+ if (WeexEnv::getEnv()->enableBackupThread() && weexTaskQueue_bk_ !=
nullptr) {
+ weexTaskQueue_bk_->addTask(task->clone());
+ }
+
+ weexTaskQueue_->addTask(task);
+ } else {
+ taskQueue(instanceId, false)->addTask(task);
+ }
+ return 1;
+}
+
+std::unique_ptr<WeexJSResult> ScriptSideInQueue::ExecJSWithResult(
+ const char *instanceId, const char *nameSpace, const char *func,
+ std::vector<VALUE_WITH_TYPE *> ¶ms) {
+ LOGD("ScriptSideInQueue::ExecJSWithResult");
+
+ ExeJsTask *task = new ExeJsTask(instanceId, params, true);
+
+ auto future = std::unique_ptr<WeexTask::Future>(new WeexTask::Future());
+ task->set_future(future.get());
+
+ task->addExtraArg(String::fromUTF8(nameSpace));
+ task->addExtraArg(String::fromUTF8(func));
+ taskQueue(instanceId, false)->addTask(task);
+ return std::move(future->waitResult());
+}
+
+void ScriptSideInQueue::ExecJSWithCallback(
+ const char *instanceId, const char *nameSpace, const char *func,
+ std::vector<VALUE_WITH_TYPE *> ¶ms, long callback_id) {
+ LOGD("ScriptSideInQueue::ExecJSWithCallback");
+
+ ExeJsTask *task = new ExeJsTask(instanceId, params, callback_id);
+
+ task->addExtraArg(String::fromUTF8(nameSpace));
+ task->addExtraArg(String::fromUTF8(func));
+ taskQueue(instanceId, false)->addTask(task);
+}
+
+int ScriptSideInQueue::CreateInstance(const char *instanceId,
+ const char *func,
+ const char *script,
+ const char *opts,
+ const char *initData,
+ const char *extendsApi,
+ std::vector<INIT_FRAMEWORK_PARAMS *>
¶ms) {
+ LOGD(
+ "CreateInstance id = %s, func = %s, script = %s, opts = %s, initData = "
+ "%s, extendsApi = %s",
+ instanceId, func, script, opts, initData, extendsApi);
+ if (WeexEnv::getEnv()->enableBackupThread()) {
+ for (int i = 0; i < params.size(); ++i) {
+ auto param = params[i];
+ auto type = String::fromUTF8(param->type->content);
+ auto value = String::fromUTF8(param->value->content);
+ if (type == "use_back_thread") {
+ if (value == "true") {
+ useBackUpWeexRuntime(instanceId);
+ }
+ break;
+ }
+ }
+ }
+ auto string = String::fromUTF8(script);
+ if (string.isEmpty()) {
+ return 0;
+ }
+ CreateInstanceTask *task = new
CreateInstanceTask(String::fromUTF8(instanceId),
+ string, params);
+
+ task->addExtraArg(String::fromUTF8(func));
+ task->addExtraArg(String::fromUTF8(opts));
+ task->addExtraArg(String::fromUTF8(initData));
+ task->addExtraArg(String::fromUTF8(extendsApi));
+ auto pQueue = taskQueue(instanceId, true);
+ pQueue->addTask(task);
+ if (!pQueue->isInitOk) {
+ pQueue->init();
+ }
+ return 1;
+}
+
+std::unique_ptr<WeexJSResult> ScriptSideInQueue::ExecJSOnInstance(const char
*instanceId,
+ const char
*script) {
+ LOGD("ScriptSideInQueue::ExecJSOnInstance");
+ ExeJsOnInstanceTask *task = new
ExeJsOnInstanceTask(String::fromUTF8(instanceId),
+
String::fromUTF8(script));
+ taskQueue(instanceId, false)->addTask(task);
+ auto future = std::unique_ptr<WeexTask::Future>(new WeexTask::Future());
+ task->set_future(future.get());
+ return std::move(future->waitResult());
+}
+
+int ScriptSideInQueue::DestroyInstance(const char *instanceId) {
+ LOGD("ScriptSideInQueue::DestroyInstance instanceId: %s \n", instanceId);
+ taskQueue(instanceId,
+ false)->addTask(new
DestoryInstanceTask(String::fromUTF8(instanceId)));
+ deleteBackUpRuntimeInstance(instanceId);
+ return 1;
+}
+
+int ScriptSideInQueue::UpdateGlobalConfig(const char *config) {
+ LOGD("ScriptSideInQueue::UpdateGlobalConfig");
+ weexTaskQueue_->addTask(new
UpdateGlobalConfigTask(String::fromUTF8(config)));
+ if (WeexEnv::getEnv()->enableBackupThread() && weexTaskQueue_bk_ != nullptr)
{
+ weexTaskQueue_bk_->addTask(new
UpdateGlobalConfigTask(String::fromUTF8(config)));
+ }
+
+ return 1;
+}
+
+void ScriptSideInQueue::useBackUpWeexRuntime(std::string id) {
+ usingBackThreadId.push_back(id);
+}
+
+bool ScriptSideInQueue::shouldUseBackUpWeexRuntime(std::string id) {
+ if (id.empty() || !WeexEnv::getEnv()->enableBackupThread())
+ return false;
+ auto iter = std::find(usingBackThreadId.begin(), usingBackThreadId.end(),
id);
+ return iter != usingBackThreadId.end();
+}
+
+void ScriptSideInQueue::deleteBackUpRuntimeInstance(std::string id) {
+ if (!WeexEnv::getEnv()->enableBackupThread()) {
+ return;
+ }
+
+ auto iter = std::find(usingBackThreadId.begin(), usingBackThreadId.end(),
id);
+ if (iter != usingBackThreadId.end()) {
+ usingBackThreadId.erase(iter);
+ }
+}
+
+WeexTaskQueue *ScriptSideInQueue::taskQueue(const char *id, bool log) {
+ if (!WeexEnv::getEnv()->enableBackupThread()) {
+ return weexTaskQueue_;
+ }
+
+ if (id != nullptr && shouldUseBackUpWeexRuntime(id)) {
+ if (weexTaskQueue_bk_ == nullptr) {
+ weexTaskQueue_bk_ = new WeexTaskQueue(weexTaskQueue_->isMultiProgress);
+ }
+ if (log) {
+ LOGE("dyyLog instance %s use back up thread time is %lld", id,
microTime());
+ }
+ return weexTaskQueue_bk_;
+ }
+ if (log && id != nullptr) {
+ LOGE("dyyLog instance %s use main thread time is %lld", id, microTime());
+ }
+ return weexTaskQueue_;
+}
+} // namespace js
+} // namespace bridge
} // namespace weex
diff --git
a/weex_core/Source/android/jsengine/bridge/script/script_side_in_queue.h
b/weex_core/Source/android/jsengine/bridge/script/script_side_in_queue.h
index 39c65eb..5947a25 100644
--- a/weex_core/Source/android/jsengine/bridge/script/script_side_in_queue.h
+++ b/weex_core/Source/android/jsengine/bridge/script/script_side_in_queue.h
@@ -34,10 +34,14 @@ namespace weex {
private:
WeexTaskQueue *weexTaskQueue_;
+ WeexTaskQueue *weexTaskQueue_bk_;
+
public:
- explicit ScriptSideInQueue() : weexTaskQueue_(nullptr) {};
+ explicit ScriptSideInQueue() : weexTaskQueue_(nullptr),
+ weexTaskQueue_bk_(nullptr) {};
- explicit ScriptSideInQueue(WeexTaskQueue *taskQueue) {
weexTaskQueue_ = taskQueue; }
+ explicit ScriptSideInQueue(WeexTaskQueue *taskQueue) :
weexTaskQueue_bk_(
+ nullptr) { weexTaskQueue_ = taskQueue; }
public:
@@ -52,7 +56,7 @@ namespace weex {
int CreateAppContext(const char *instanceId, const char
*jsBundle) override;
std::unique_ptr<WeexJSResult> ExecJSOnAppWithResult(const char
*instanceId,
- const char *jsBundle) override;
+ const char
*jsBundle) override;
int CallJSOnAppContext(const char *instanceId, const char
*func,
std::vector<VALUE_WITH_TYPE *> ¶ms)
override;
@@ -66,24 +70,40 @@ namespace weex {
int ExecJS(const char *instanceId, const char *nameSpace,
const char *func,
std::vector<VALUE_WITH_TYPE *> ¶ms) override;
- std::unique_ptr<WeexJSResult> ExecJSWithResult(const char
*instanceId, const char *nameSpace,
- const char *func,
- std::vector<VALUE_WITH_TYPE *>
¶ms) override;
+ std::unique_ptr<WeexJSResult>
+ ExecJSWithResult(const char *instanceId, const char *nameSpace,
+ const char *func,
+ std::vector<VALUE_WITH_TYPE *> ¶ms)
override;
+
void ExecJSWithCallback(const char *instanceId, const char
*nameSpace,
- const char *func,
- std::vector<VALUE_WITH_TYPE *>
¶ms, long callback_id) override;
+ const char *func,
+ std::vector<VALUE_WITH_TYPE *> ¶ms,
+ long callback_id) override;
int CreateInstance(const char *instanceId, const char *func,
const char *script, const char *opts, const
char *initData,
- const char *extendsApi,
std::vector<INIT_FRAMEWORK_PARAMS*>& params) override;
+ const char *extendsApi,
+ std::vector<INIT_FRAMEWORK_PARAMS *>
¶ms) override;
- std::unique_ptr<WeexJSResult> ExecJSOnInstance(const char
*instanceId, const char *script) override;
+ std::unique_ptr<WeexJSResult>
+ ExecJSOnInstance(const char *instanceId, const char *script)
override;
int DestroyInstance(const char *instanceId) override;
int UpdateGlobalConfig(const char *config) override;
+ private:
+ std::vector<std::string> usingBackThreadId;
+
+ void useBackUpWeexRuntime(std::string id);
+
+ bool shouldUseBackUpWeexRuntime(std::string id);
+
+ void deleteBackUpRuntimeInstance(std::string id);
+
+ WeexTaskQueue *taskQueue(const char *id, bool log);
+
};
} // namespace js
} // namespace bridge
diff --git a/weex_core/Source/android/jsengine/object/weex_env.cpp
b/weex_core/Source/android/jsengine/object/weex_env.cpp
index d982af2..f4d7241 100644
--- a/weex_core/Source/android/jsengine/object/weex_env.cpp
+++ b/weex_core/Source/android/jsengine/object/weex_env.cpp
@@ -24,16 +24,19 @@
WeexEnv *WeexEnv::env_ = nullptr;
-TimerQueue *WeexEnv::timerQueue() { return weexTimerQueue_.get(); }
-
-void WeexEnv::setTimerQueue(TimerQueue *timerQueue) {
weexTimerQueue_.reset(timerQueue); }
-
WeexCore::ScriptBridge *WeexEnv::scriptBridge() { return scriptBridge_; }
-
bool WeexEnv::useWson() { return isUsingWson; }
void WeexEnv::setUseWson(bool useWson) { isUsingWson = useWson; }
void WeexEnv::setScriptBridge(WeexCore::ScriptBridge *scriptBridge) {
scriptBridge_ = scriptBridge; }
+void WeexEnv::initIPC() {
+ // init IpcClient in io Thread
+ m_ipc_client_.reset(new WeexIPCClient(ipcClientFd_));
+}
+WeexEnv::WeexEnv() {
+ this->enableBackupThread__ = false;
+ this->isUsingWson = true;
+}
diff --git a/weex_core/Source/android/jsengine/object/weex_env.h
b/weex_core/Source/android/jsengine/object/weex_env.h
index 192ed0b..207eca7 100644
--- a/weex_core/Source/android/jsengine/object/weex_env.h
+++ b/weex_core/Source/android/jsengine/object/weex_env.h
@@ -24,6 +24,7 @@
#define WEEXV8_WEEXENV_H
#include <mutex>
+#include "android/jsengine/task/back_to_weex_core_queue.h"
#include "android/jsengine/task/timer_queue.h"
#include "android/jsengine/weex_ipc_server.h"
@@ -38,17 +39,12 @@ public:
return env_;
}
+ WeexEnv();
bool useWson();
void setUseWson(bool useWson);
-
- TimerQueue *timerQueue();
-
- void setTimerQueue(TimerQueue *timerQueue);
-
-
WeexCore::ScriptBridge *scriptBridge();
void setScriptBridge(WeexCore::ScriptBridge *scriptBridge);
@@ -78,16 +74,30 @@ public:
}
+ void initIPC();
+
+ void setEnableBackupThread(bool enable) {
+ this->enableBackupThread__ = enable;
+ }
+
+ bool enableBackupThread() {
+ return enableBackupThread__;
+ }
+
+public:
+ std::unique_ptr<BackToWeexCoreQueue> m_back_to_weex_core_thread;
+ volatile bool isMultiProcess = true;
+ std::unique_ptr<WeexIPCClient> m_ipc_client_;
private:
static WeexEnv *env_;
- volatile bool isMultiProcess = true;
volatile bool isUsingWson = true;
std::unique_ptr<TimerQueue> weexTimerQueue_;
WeexCore::ScriptBridge *scriptBridge_;
+ bool enableBackupThread__ = false;
volatile int ipcClientFd_;
volatile int ipcServerFd_;
diff --git a/weex_core/Source/android/jsengine/object/weex_global_object.cpp
b/weex_core/Source/android/jsengine/object/weex_global_object.cpp
index 33952b0..07d9d70 100644
--- a/weex_core/Source/android/jsengine/object/weex_global_object.cpp
+++ b/weex_core/Source/android/jsengine/object/weex_global_object.cpp
@@ -23,9 +23,11 @@
#include "android/jsengine/object/weex_global_object.h"
#include <sys/stat.h>
+#include <base/time_calculator.h>
#include "android/jsengine/object/weex_env.h"
#include "android/jsengine/object/weex_console_object.h"
#include "android/jsengine/task/timer_task.h"
+#include "android/jsengine/task/timer_queue.h"
#include "android/jsengine/weex_jsc_utils.h"
#include "base/utils/log_utils.h"
#include "core/bridge/script_bridge.h"
@@ -401,6 +403,13 @@ JSFUNCTION functionCallNativeModule(ExecState *state) {
getWsonOrJsonArgsFromState(state, 3, arguments);
getWsonOrJsonArgsFromState(state, 4, options);
+// String a;
+// a.append("functionCallNativeModule:");
+// a.append(moduleChar.getValue());
+// a.append(":");
+// a.append(methodChar.getValue());
+// weex::base::TimeCalculator
timeCalculator(weex::base::TaskPlatform::JSS_ENGINE, a.utf8().data(),
instanceId.getValue());
+// timeCalculator.taskStart();
auto result =
globalObject->js_bridge()->core_side()->CallNativeModule(instanceId.getValue(),
moduleChar.getValue(),
methodChar.getValue(),
@@ -408,6 +417,7 @@ JSFUNCTION functionCallNativeModule(ExecState *state) {
arguments.getLength(),
options.getValue(),
options.getLength());
+// timeCalculator.taskEnd();
JSValue ret;
switch (result->type) {
case ParamsType::DOUBLE:
@@ -509,9 +519,15 @@ JSFUNCTION functionCallUpdateFinish(ExecState *state) {
getWsonArgsFromState(state, 1, taskChar);
getWsonArgsFromState(state, 2, callBackChar);
WeexGlobalObject *globalObject = static_cast<WeexGlobalObject
*>(state->lexicalGlobalObject());
+// weex::base::TimeCalculator
timeCalculator(weex::base::TaskPlatform::JSS_ENGINE,
"functionCallUpdateFinish",globalObject->id);
+// timeCalculator.taskStart();
+
+
auto result =
globalObject->js_bridge()->core_side()->UpdateFinish(idChar.getValue(),
taskChar.getValue(),
taskChar.getLength(), callBackChar.getValue(),
callBackChar.getLength());
+
+// timeCalculator.taskEnd();
return JSValue::encode(jsNumber(result));
}
@@ -535,9 +551,14 @@ JSFUNCTION functionCallRefreshFinish(ExecState *state) {
getStringArgsFromState(state, 1, taskChar);
getStringArgsFromState(state, 2, callBackChar);
WeexGlobalObject *globalObject = static_cast<WeexGlobalObject
*>(state->lexicalGlobalObject());
+// weex::base::TimeCalculator
timeCalculator(weex::base::TaskPlatform::JSS_ENGINE,
"functionCallRefreshFinish",globalObject->id);
+// timeCalculator.taskStart();
+
int result =
globalObject->js_bridge()->core_side()->RefreshFinish(idChar.getValue(),
taskChar.getValue(),
callBackChar.getValue());
+
+// timeCalculator.taskEnd();
return JSValue::encode(jsNumber(result));
}
@@ -792,7 +813,7 @@ JSFUNCTION functionNativeSetTimeout(ExecState *state) {
VM &vm = globalObject->vm();
const JSValue value = state->argument(0);
const JSValue jsValue = state->argument(1);
- TimerQueue *timerQueue =WeexEnv::getEnv()->timerQueue();
+ TimerQueue *timerQueue = globalObject->timeQueue;
if (timerQueue != nullptr) {
uint32_t function_id = globalObject->genFunctionID();
globalObject->addTimer(function_id, JSC::Strong<JSC::Unknown> { vm,
JSC::asObject(value) });
@@ -817,7 +838,7 @@ JSFUNCTION functionNativeSetInterval(ExecState *state) {
VM &vm = globalObject->vm();
const JSValue value = state->argument(0);
const JSValue jsValue = state->argument(1);
- TimerQueue *timerQueue =WeexEnv::getEnv()->timerQueue();
+ TimerQueue *timerQueue =globalObject->timeQueue;
if (timerQueue != nullptr) {
uint32_t function_id = globalObject->genFunctionID();
globalObject->addTimer(function_id, JSC::Strong<JSC::Unknown> { vm,
JSC::asObject(value) });
@@ -831,7 +852,8 @@ JSFUNCTION functionNativeSetInterval(ExecState *state) {
}
JSFUNCTION functionNativeClearTimeout(ExecState *state) {
- TimerQueue *timerQueue = WeexEnv::getEnv()->timerQueue();
+ WeexGlobalObject *globalObject = static_cast<WeexGlobalObject
*>(state->lexicalGlobalObject());
+ TimerQueue *timerQueue = globalObject->timeQueue;
const JSValue& value = state->argument(0);
if (timerQueue != nullptr) {
timerQueue->removeTimer(value.asInt32());
diff --git a/weex_core/Source/android/jsengine/object/weex_global_object.h
b/weex_core/Source/android/jsengine/object/weex_global_object.h
index e84773f..dbcd531 100644
--- a/weex_core/Source/android/jsengine/object/weex_global_object.h
+++ b/weex_core/Source/android/jsengine/object/weex_global_object.h
@@ -26,12 +26,16 @@
#include <map>
#include "android/jsengine/weex_ipc_server.h"
#include "android/jsengine/weex_jsc_utils.h"
+
#include "include/WeexApiHeader.h"
#include "APICast.h"
#include "JSStringRef.h"
#include "JSContextRef.h"
using namespace JSC;
+
+class TimerQueue;
+
namespace weex {
class GlobalObjectDelegate;
}
@@ -48,6 +52,7 @@ public:
typedef JSGlobalObject Base;
std::vector<INIT_FRAMEWORK_PARAMS *> m_initFrameworkParams;
std::string id = "";
+ TimerQueue* timeQueue = nullptr;
static WeexGlobalObject* create(VM& vm, Structure* structure)
{
WeexGlobalObject* object = new (NotNull,
allocateCell<WeexGlobalObject>(vm.heap)) WeexGlobalObject(vm, structure);
diff --git a/weex_core/Source/android/jsengine/object/weex_object_holder.cpp
b/weex_core/Source/android/jsengine/object/weex_object_holder.cpp
index 9d89c22..196402f 100644
--- a/weex_core/Source/android/jsengine/object/weex_object_holder.cpp
+++ b/weex_core/Source/android/jsengine/object/weex_object_holder.cpp
@@ -56,45 +56,36 @@ void WeexObjectHolder::initFromIPCArguments(IPCArguments
*arguments, size_t star
}
void WeexObjectHolder::initFromParams(std::vector<INIT_FRAMEWORK_PARAMS *>
¶ms, bool forAppContext) {
- if (!WEEXICU::initICUEnv(isMultiProgress)) {
- LOGE("failed to init ICUEnv single process");
- // return false;
- }
-
- Options::enableRestrictedOptions(true);
-// Initialize JSC before getting VM.
- WTF::initializeMainThread();
- initHeapTimer();
- JSC::initializeThreading();
-#if ENABLE(WEBASSEMBLY)
- JSC::Wasm::enableFastMemory();
-#endif
- VM &vm = VM::sharedInstance();
- JSLockHolder locker(&vm);
- WeexGlobalObject *globalObject = WeexGlobalObject::create(vm,
WeexGlobalObject::createStructure(vm, jsNull()));
+ JSLockHolder locker(this->m_globalVM);
+ VM& vm = *(this->m_globalVM);
+ WeexGlobalObject *globalObject = WeexGlobalObject::create(vm,
WeexGlobalObject::createStructure(
+ vm, jsNull()));
globalObject->initWxEnvironment(params, forAppContext, true);
if (forAppContext)
globalObject->initFunctionForAppContext();
else
globalObject->initFunction();
+ globalObject->timeQueue = this->timeQueue;
m_globalObject.set(vm, globalObject);
vm.heap.setGarbageCollectionTimerEnabled(true);
wson::init(&vm);
}
-WeexObjectHolder::WeexObjectHolder(bool isMultiProgress) {
+WeexObjectHolder::WeexObjectHolder(VM* vm, TimerQueue* timeQueue, bool
isMultiProgress) {
this->isMultiProgress = isMultiProgress;
+ this->timeQueue = timeQueue;
+ this->m_globalVM = vm;
}
-WeexGlobalObject *WeexObjectHolder::cloneWeexObject(bool initContext, bool
forAppContext) {
- VM &vm = VM::sharedInstance();
- JSLockHolder locker(&vm);
+WeexGlobalObject *WeexObjectHolder::cloneWeexObject(std::string page_id, bool
initContext, bool forAppContext) {
+ JSLockHolder locker(this->m_globalVM);
+ VM& vm = *(this->m_globalVM);
auto *temp_object = WeexGlobalObject::create(vm,
WeexGlobalObject::createStructure(vm, jsNull()));
temp_object->initWxEnvironment(m_globalObject->m_initFrameworkParams,
forAppContext, false);
-
+ temp_object->timeQueue = this->timeQueue;
if (forAppContext)
temp_object->initFunctionForAppContext();
else if (initContext)
@@ -102,13 +93,13 @@ WeexGlobalObject *WeexObjectHolder::cloneWeexObject(bool
initContext, bool forAp
else
temp_object->initFunction();
+ temp_object->id = page_id;
return temp_object;
}
WeexObjectHolder::~WeexObjectHolder() {
- VM &vm = VM::sharedInstance();
wson::destory();
- JSLockHolder locker(&vm);
- vm.heap.collectAllGarbage();
+ JSLockHolder locker(this->m_globalVM);
+ this->m_globalVM->heap.collectAllGarbage();
}
diff --git a/weex_core/Source/android/jsengine/object/weex_object_holder.h
b/weex_core/Source/android/jsengine/object/weex_object_holder.h
index 62ecd14..5f73a2d 100644
--- a/weex_core/Source/android/jsengine/object/weex_object_holder.h
+++ b/weex_core/Source/android/jsengine/object/weex_object_holder.h
@@ -23,6 +23,7 @@
#ifndef WEEXV8_WEEXOBJECTHOLDER_H
#define WEEXV8_WEEXOBJECTHOLDER_H
+#include "android/jsengine/task/timer_queue.h"
#include "android/jsengine/object/weex_global_object.h"
#include "android/jsengine/weex_jsc_utils.h"
@@ -31,19 +32,22 @@ class WeexObjectHolder {
public:
Strong<WeexGlobalObject> m_globalObject;
+ VM* m_globalVM;
+
std::map<std::string, WeexGlobalObject *> m_jsInstanceGlobalObjectMap;
~WeexObjectHolder();
- explicit WeexObjectHolder(bool isMultiProgress);
+ explicit WeexObjectHolder(VM* vm, TimerQueue* timeQueue, bool
isMultiProgress);
void initFromIPCArguments(IPCArguments *arguments, size_t startCount, bool
forAppContext);
void initFromParams(std::vector<INIT_FRAMEWORK_PARAMS *> ¶ms, bool
forAppContext);
- WeexGlobalObject *cloneWeexObject(bool initContext, bool forAppContext);
+ WeexGlobalObject *cloneWeexObject(std::string page_id, bool initContext,
bool forAppContext);
+ TimerQueue* timeQueue;
private:
bool isMultiProgress;
diff --git a/weex_core/Source/android/jsengine/task/back_to_weex_core_queue.cpp
b/weex_core/Source/android/jsengine/task/back_to_weex_core_queue.cpp
new file mode 100644
index 0000000..2db1cd9
--- /dev/null
+++ b/weex_core/Source/android/jsengine/task/back_to_weex_core_queue.cpp
@@ -0,0 +1,154 @@
+/**
+ * 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.
+ */
+//
+// Created by 董亚运 on 2019/1/8.
+//
+
+#include <base/android/log_utils.h>
+#include <object/weex_env.h>
+#include "back_to_weex_core_queue.h"
+
+
+static void *startThread(void *td) {
+ auto *self = static_cast<BackToWeexCoreQueue *>(td);
+ WeexEnv::getEnv()->initIPC();
+ self->isInitOk = true;
+ self->start();
+ return NULL;
+}
+
+int BackToWeexCoreQueue::addTask(BackToWeexCoreQueue::IPCTask *task) {
+ threadLocker.lock();
+ taskQueue_.push_back(task);
+ int size = taskQueue_.size();
+ threadLocker.unlock();
+ threadLocker.signal();
+ return size;
+}
+
+void BackToWeexCoreQueue::init() {
+ pthread_t thread;
+ pthread_create(&thread, nullptr, startThread, this);
+ pthread_setname_np(thread, "BackToWeexCoreQueue");
+}
+
+void BackToWeexCoreQueue::start() {
+ while (!m_stop) {
+ BackToWeexCoreQueue::IPCTask *task = getTask();
+ if (task == nullptr) {
+ continue;
+ }
+ task->run();
+ delete task;
+ }
+
+}
+
+BackToWeexCoreQueue::IPCTask *BackToWeexCoreQueue::getTask() {
+ BackToWeexCoreQueue::IPCTask *task = nullptr;
+ while (task == nullptr) {
+ threadLocker.lock();
+ while (taskQueue_.empty() || !isInitOk) {
+ threadLocker.wait();
+ }
+
+ if (taskQueue_.empty()) {
+ threadLocker.unlock();
+ continue;
+ }
+
+ assert(!taskQueue_.empty());
+ task = taskQueue_.front();
+ taskQueue_.pop_front();
+ threadLocker.unlock();
+ }
+
+ return task;
+}
+
+void BackToWeexCoreQueue::stop() {
+ m_stop = true;
+}
+
+void BackToWeexCoreQueue::IPCTask::run() {
+ if (params.empty())
+ return;
+
+ std::unique_ptr<IPCSerializer> serializer(createIPCSerializer());;
+ serializer->setMsg(static_cast<uint32_t>(this->m_type));
+ std::vector<BackToWeexCoreQueue::IPCArgs *>::iterator it;
+ it = params.begin();
+ while (it != params.end()) {
+ IPCArgs *&reference = *it;
+ serializer->add(reference->m_str, reference->m_length);
+ delete reference;
+ it++;
+ }
+
+ std::unique_ptr<IPCBuffer> buffer = serializer->finish();
+ std::unique_ptr<IPCResult> result =
WeexEnv::getEnv()->m_ipc_client_->getSender()->send(
+ buffer.get());
+ if (m_future != nullptr) {
+ m_future->setResult(result);
+ }
+}
+
+void BackToWeexCoreQueue::IPCTask::addParams(const char *str, size_t len) {
+ IPCArgs *x = new BackToWeexCoreQueue::IPCArgs(str, len);
+ this->params.push_back(x);
+}
+
+void BackToWeexCoreQueue::IPCTask::set_future(BackToWeexCoreQueue::Future
*m_feature) {
+ IPCTask::m_future = m_feature;
+}
+
+BackToWeexCoreQueue::IPCTask::~IPCTask() {
+}
+
+
+void BackToWeexCoreQueue::Future::setResult(std::unique_ptr<IPCResult>
&result) {
+ thread_locker_.lock();
+ has_result_ = true;
+ result_ = std::move(result);
+ thread_locker_.unlock();
+ thread_locker_.signal();
+}
+
+std::unique_ptr<IPCResult> BackToWeexCoreQueue::Future::waitResult() {
+ thread_locker_.lock();
+ while (!has_result_) {
+ thread_locker_.wait();
+ }
+ thread_locker_.unlock();
+ return std::move(result_);
+}
+
+BackToWeexCoreQueue::IPCArgs::IPCArgs(const char *str, size_t len) {
+ char *ret = nullptr;
+ size_t strLen = 0;
+ if (str != nullptr) {
+ strLen = len == 0 ? strlen(str) : len;
+ ret = new char[strLen + 1];
+ memcpy(ret, str, static_cast<size_t>(strLen));
+ ret[strLen] = '\0';
+
+ }
+ this->m_str = ret;
+ this->m_length = strLen;
+}
diff --git a/weex_core/Source/android/jsengine/task/back_to_weex_core_queue.h
b/weex_core/Source/android/jsengine/task/back_to_weex_core_queue.h
new file mode 100644
index 0000000..ef808cd
--- /dev/null
+++ b/weex_core/Source/android/jsengine/task/back_to_weex_core_queue.h
@@ -0,0 +1,118 @@
+/**
+ * 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.
+ */
+//
+// Created by 董亚运 on 2019/1/8.
+//
+
+#ifndef WEEX_PROJECT_BACK_TO_WEEX_CORE_QUEUE_H
+#define WEEX_PROJECT_BACK_TO_WEEX_CORE_QUEUE_H
+
+
+#include <deque>
+#include <map>
+#include <third_party/IPC/IPCResult.h>
+#include <third_party/IPC/IPCMessageJS.h>
+#include <vector>
+#include "base/utils/ThreadLocker.h"
+#include "base/closure.h"
+
+class BackToWeexCoreQueue {
+
+public:
+
+ class Future {
+
+ public:
+
+ Future() : has_result_(false) {}
+
+ ~Future() {}
+
+ void setResult(std::unique_ptr<IPCResult> &result);
+
+ std::unique_ptr<IPCResult> waitResult();
+
+ private:
+ bool has_result_ = false;
+ std::unique_ptr<IPCResult> result_;
+ ThreadLocker thread_locker_;
+ };
+
+ class IPCArgs {
+
+ public:
+ explicit IPCArgs(const char *str, size_t len = 0);
+
+ ~IPCArgs() {
+ if (m_str != nullptr)
+ delete (m_str);
+ m_length = 0;
+ }
+
+ public:
+ char *m_str;
+ size_t m_length;
+ };
+
+ class IPCTask {
+ public:
+ std::vector<BackToWeexCoreQueue::IPCArgs *> params;
+
+ explicit IPCTask(IPCProxyMsg type) : m_type(type),
+ m_future(nullptr) {}
+
+ ~IPCTask();
+
+ void run();
+
+ void addParams(const char *str, size_t len = 0);
+
+ void set_future(Future *m_feature);
+
+ private:
+ IPCProxyMsg m_type;
+ Future *m_future;
+
+ };
+
+ explicit BackToWeexCoreQueue():
+ m_stop(false) {};
+
+ BackToWeexCoreQueue::IPCTask *getTask();
+
+ void start();
+
+ void stop();
+
+ void init();
+
+ int addTask(BackToWeexCoreQueue::IPCTask *task);
+
+
+private:
+ std::deque<BackToWeexCoreQueue::IPCTask *> taskQueue_;
+ ThreadLocker threadLocker;
+ bool m_stop;
+
+public:
+ volatile bool isInitOk = false;
+};
+
+
+#endif //WEEX_PROJECT_BACK_TO_WEEX_CORE_QUEUE_H
diff --git a/weex_core/Source/android/jsengine/task/impl/exe_js_task.cpp
b/weex_core/Source/android/jsengine/task/impl/exe_js_task.cpp
index 4b09a4a..85288f4 100644
--- a/weex_core/Source/android/jsengine/task/impl/exe_js_task.cpp
+++ b/weex_core/Source/android/jsengine/task/impl/exe_js_task.cpp
@@ -69,3 +69,11 @@ ExeJsTask::ExeJsTask(const String &instanceId, IPCArguments
*arguments, size_t s
ExeJsTask::~ExeJsTask() {
delete exeJsArgs;
}
+
+ExeJsTask *ExeJsTask::clone() {
+ ExeJsTask *task = new ExeJsTask(instanceId, this->exeJsArgs->params);
+ for (int i = 0; i < this->extraArgs.size(); ++i) {
+ task->addExtraArg(this->extraArgs[i]);
+ }
+ return task;
+}
diff --git a/weex_core/Source/android/jsengine/task/impl/exe_js_task.h
b/weex_core/Source/android/jsengine/task/impl/exe_js_task.h
index e9380a2..dde25b8 100644
--- a/weex_core/Source/android/jsengine/task/impl/exe_js_task.h
+++ b/weex_core/Source/android/jsengine/task/impl/exe_js_task.h
@@ -40,6 +40,7 @@ public:
void run(WeexRuntime *runtime) override;
std::string taskName() override { return "ExeJsTask"; }
+ ExeJsTask * clone();
~ExeJsTask() override;
diff --git
a/weex_core/Source/android/jsengine/task/impl/init_framework_task.cpp
b/weex_core/Source/android/jsengine/task/impl/init_framework_task.cpp
index 7a61b5b..14091c2 100644
--- a/weex_core/Source/android/jsengine/task/impl/init_framework_task.cpp
+++ b/weex_core/Source/android/jsengine/task/impl/init_framework_task.cpp
@@ -55,3 +55,6 @@ InitFrameworkTask::InitFrameworkTask(const String
&instanceId, const String &scr
InitFrameworkTask::~InitFrameworkTask() {
delete args;
}
+InitFrameworkTask *InitFrameworkTask::clone() {
+ return new InitFrameworkTask(this->script.utf8().data(), args->params);
+}
diff --git a/weex_core/Source/android/jsengine/task/impl/init_framework_task.h
b/weex_core/Source/android/jsengine/task/impl/init_framework_task.h
index 336b680..a5f648c 100644
--- a/weex_core/Source/android/jsengine/task/impl/init_framework_task.h
+++ b/weex_core/Source/android/jsengine/task/impl/init_framework_task.h
@@ -46,6 +46,7 @@ public:
std::string taskName() override { return "InitFrameworkTask"; }
+ InitFrameworkTask *clone();
~InitFrameworkTask();
diff --git a/weex_core/Source/android/jsengine/task/impl/native_timer_task.h
b/weex_core/Source/android/jsengine/task/impl/native_timer_task.h
index 0f6209e..d44db17 100644
--- a/weex_core/Source/android/jsengine/task/impl/native_timer_task.h
+++ b/weex_core/Source/android/jsengine/task/impl/native_timer_task.h
@@ -20,8 +20,8 @@
// Created by Darin on 20/07/2018.
//
-#ifndef WEEXV8_TIMERTASK_H
-#define WEEXV8_TIMERTASK_H
+#ifndef WEEXV8_NATIVE_TIMERTASK_H
+#define WEEXV8_NATIVE_TIMERTASK_H
#include "android/jsengine/task/weex_task.h"
diff --git a/weex_core/Source/android/jsengine/task/timer_queue.cpp
b/weex_core/Source/android/jsengine/task/timer_queue.cpp
index be4b4d7..c749a2b 100644
--- a/weex_core/Source/android/jsengine/task/timer_queue.cpp
+++ b/weex_core/Source/android/jsengine/task/timer_queue.cpp
@@ -21,6 +21,7 @@
//
#include "timer_queue.h"
+#include "android/jsengine/task/weex_task_queue.h"
static void *startThread(void *td) {
auto *self = static_cast<TimerQueue *>(td);
diff --git a/weex_core/Source/android/jsengine/task/timer_queue.h
b/weex_core/Source/android/jsengine/task/timer_queue.h
index 51ece91..c185fd8 100644
--- a/weex_core/Source/android/jsengine/task/timer_queue.h
+++ b/weex_core/Source/android/jsengine/task/timer_queue.h
@@ -27,9 +27,10 @@
#include <deque>
#include "android/jsengine/task/timer_task.h"
-#include "android/jsengine/task/weex_task_queue.h"
+#include "base/utils/ThreadLocker.h"
class TimerTask;
+class WeexTaskQueue;
class TimerQueue {
diff --git a/weex_core/Source/android/jsengine/task/weex_task.h
b/weex_core/Source/android/jsengine/task/weex_task.h
index b97eb0d..3b0eaaa 100644
--- a/weex_core/Source/android/jsengine/task/weex_task.h
+++ b/weex_core/Source/android/jsengine/task/weex_task.h
@@ -23,6 +23,7 @@
#ifndef WEEXV8_WEEXTASK_H
#define WEEXV8_WEEXTASK_H
+#include "base/time_calculator.h"
#include "android/jsengine/weex_runtime.h"
#include "base/utils/ThreadLocker.h"
@@ -53,11 +54,12 @@ public:
explicit WeexTask(const String &instanceId, int taskId) :
future_(nullptr), global_object_(nullptr) {
this->instanceId = instanceId;
this->taskId = taskId;
+ this->timeCalculator = new
weex::base::TimeCalculator(weex::base::TaskPlatform::JSS_ENGINE, "",
this->instanceId.utf8().data());
};
explicit WeexTask(const String &instanceId) : WeexTask(instanceId,
genTaskId()) {};
- virtual ~WeexTask() = default;
+ virtual ~WeexTask() {if(timeCalculator != nullptr) delete timeCalculator;};
virtual void run(WeexRuntime *runtime) = 0;
virtual std::string taskName() = 0;
@@ -78,6 +80,7 @@ public:
global_object_ = global_object;
}
+ weex::base::TimeCalculator *timeCalculator;
private:
Future* future_;
WeexGlobalObject* global_object_;
diff --git a/weex_core/Source/android/jsengine/task/weex_task_queue.cpp
b/weex_core/Source/android/jsengine/task/weex_task_queue.cpp
index 65a423d..6fe03ce 100644
--- a/weex_core/Source/android/jsengine/task/weex_task_queue.cpp
+++ b/weex_core/Source/android/jsengine/task/weex_task_queue.cpp
@@ -29,7 +29,10 @@
#include "android/jsengine/object/weex_env.h"
void WeexTaskQueue::run(WeexTask *task) {
+ task->timeCalculator->set_task_name(task->taskName());
+ task->timeCalculator->taskStart();
task->run(weexRuntime);
+ task->timeCalculator->taskEnd();
delete task;
}
@@ -108,14 +111,13 @@ static void *startThread(void *td) {
self->isInitOk = true;
if (self->weexRuntime == nullptr) {
- self->weexRuntime = new WeexRuntime(WeexEnv::getEnv()->scriptBridge(),
self->isMultiProgress);
+ self->weexRuntime = new WeexRuntime(new
TimerQueue(self),WeexEnv::getEnv()->scriptBridge(), self->isMultiProgress);
// init IpcClient in Js Thread
- if (self->isMultiProgress) {
- auto *client = new
WeexIPCClient(WeexEnv::getEnv()->getIpcClientFd());
- static_cast<weex::bridge::js::CoreSideInMultiProcess
*>(weex::bridge::js::ScriptBridgeInMultiProcess::Instance()->core_side())->set_ipc_client(
- client);
- }
- WeexEnv::getEnv()->setTimerQueue(new TimerQueue(self));
+// if (self->isMultiProgress) {
+// auto *client = new
WeexIPCClient(WeexEnv::getEnv()->getIpcClientFd());
+// static_cast<weex::bridge::js::CoreSideInMultiProcess
*>(weex::bridge::js::ScriptBridgeInMultiProcess::Instance()->core_side())->set_ipc_client(
+// client);
+// }
}
auto pTask = self->getTask();
diff --git a/weex_core/Source/android/jsengine/weex_ipc_server.cpp
b/weex_core/Source/android/jsengine/weex_ipc_server.cpp
index 839a1cc..2593a5a 100644
--- a/weex_core/Source/android/jsengine/weex_ipc_server.cpp
+++ b/weex_core/Source/android/jsengine/weex_ipc_server.cpp
@@ -63,6 +63,16 @@ WeexJSServer::WeexJSServerImpl::WeexJSServerImpl(int
serverFd, int clientFd, boo
// initialize signal handler
crashHandler.reset(new CrashHandlerInfo(crashFileName));
crashHandler->initializeCrashHandler();
+
+ WeexEnv::getEnv()->m_back_to_weex_core_thread.reset(new
BackToWeexCoreQueue());
+ WeexEnv::getEnv()->m_back_to_weex_core_thread.get()->init();
+
+ auto pQueue = WeexEnv::getEnv()->m_back_to_weex_core_thread.get();
+ while (!pQueue->isInitOk) {
+ continue;
+ }
+
+ //WeexEnv::getEnv()->initJSC(true);
}
WeexJSServer::WeexJSServer(int serverFd, int clientFd, bool enableTrace,
std::string crashFileName)
diff --git a/weex_core/Source/android/jsengine/weex_runtime.cpp
b/weex_core/Source/android/jsengine/weex_runtime.cpp
index 6238a18..e908cdc 100644
--- a/weex_core/Source/android/jsengine/weex_runtime.cpp
+++ b/weex_core/Source/android/jsengine/weex_runtime.cpp
@@ -33,12 +33,27 @@ using namespace WTF;
using namespace WEEXICU;
-WeexRuntime::WeexRuntime(bool isMultiProgress) :
is_multi_process_(isMultiProgress), script_bridge_(nullptr) {
- weexObjectHolder.reset(new WeexObjectHolder(isMultiProgress));
+WeexRuntime::WeexRuntime(TimerQueue* timeQueue,bool isMultiProgress) :
is_multi_process_(isMultiProgress), script_bridge_(nullptr) {
+ if (!WEEXICU::initICUEnv(isMultiProgress)) {
+ LOGE("failed to init ICUEnv single process");
+ // return false;
+ }
+
+ Options::enableRestrictedOptions(true);
+// Initialize JSC before getting VM.
+ WTF::initializeMainThread();
+ initHeapTimer();
+ JSC::initializeThreading();
+#if ENABLE(WEBASSEMBLY)
+ JSC::Wasm::enableFastMemory();
+#endif
+ m_globalVM = std::move(VM::create(LargeHeap));
+
+ weexObjectHolder.reset(new WeexObjectHolder(m_globalVM.get(), timeQueue,
isMultiProgress));
LOGE("WeexRuntime is running and mode is %s", isMultiProgress ?
"multiProcess" : "singleProcess");
}
-WeexRuntime::WeexRuntime(WeexCore::ScriptBridge *script_bridge, bool
isMultiProgress) : WeexRuntime(isMultiProgress) {
+WeexRuntime::WeexRuntime(TimerQueue* timeQueue, WeexCore::ScriptBridge
*script_bridge, bool isMultiProgress) : WeexRuntime(timeQueue, isMultiProgress)
{
this->script_bridge_ = script_bridge;
}
@@ -65,7 +80,7 @@ int WeexRuntime::initAppFrameworkMultiProcess(const String
&instanceId, const St
IPCArguments *arguments) {
auto pHolder = getLightAppObjectHolder(instanceId);
if (pHolder == nullptr) {
- auto holder = new WeexObjectHolder(true);
+ auto holder = new WeexObjectHolder(this->m_globalVM.get(),
weexObjectHolder->timeQueue, true);
holder->initFromIPCArguments(arguments, 2, true);
appWorkerContextHolderMap[instanceId.utf8().data()] = holder;
}
@@ -79,7 +94,7 @@ int WeexRuntime::initAppFramework(const String &instanceId,
const String &appFra
auto pHolder = getLightAppObjectHolder(instanceId);
LOGE("Weex jsserver initAppFramework %s",instanceId.utf8().data());
if (pHolder == nullptr) {
- auto holder = new WeexObjectHolder(is_multi_process_);
+ auto holder = new WeexObjectHolder(this->m_globalVM.get(),
weexObjectHolder->timeQueue, is_multi_process_);
holder->initFromParams(params, true);
LOGE("Weex jsserver initAppFramework pHolder == null and id
%s",instanceId.utf8().data());
appWorkerContextHolderMap[instanceId.utf8().data()] = holder;
@@ -88,8 +103,7 @@ int WeexRuntime::initAppFramework(const String &instanceId,
const String &appFra
}
int WeexRuntime::_initAppFramework(const String &instanceId, const String
&appFramework) {
- VM &vm = VM::sharedInstance();
- JSLockHolder locker_global(&vm);
+ JSLockHolder locker_global(this->m_globalVM.get());
auto appWorkerObjectHolder = getLightAppObjectHolder(instanceId);
if (appWorkerObjectHolder == nullptr) {
@@ -141,20 +155,19 @@ int WeexRuntime::createAppContext(const String
&instanceId, const String &jsBund
return static_cast<int32_t>(false);
}
- VM &vm_global = VM::sharedInstance();
- JSLockHolder locker_global(&vm_global);
+ JSLockHolder locker_global(this->m_globalVM.get());
- WeexGlobalObject *app_globalObject =
appWorkerObjectHolder->cloneWeexObject(true, true);
+ WeexGlobalObject *app_globalObject =
appWorkerObjectHolder->cloneWeexObject(final_instanceId.utf8().data(),true,
true);
weex::GlobalObjectDelegate *delegate = NULL;
app_globalObject->SetScriptBridge(script_bridge_);
- VM &vm = worker_globalObject->vm();
-
- JSLockHolder locker_1(&vm);
-
- VM &thisVm = app_globalObject->vm();
- JSLockHolder locker_2(&thisVm);
-
- PropertyName createInstanceContextProperty(Identifier::fromString(&vm,
get_context_fun_name));
+// VM &vm = worker_globalObject->vm();
+//
+// JSLockHolder locker_1(&vm);
+//
+// VM &thisVm = app_globalObject->vm();
+// JSLockHolder locker_2(&thisVm);
+//
+ PropertyName
createInstanceContextProperty(Identifier::fromString(this->m_globalVM.get(),
get_context_fun_name));
ExecState *state = worker_globalObject->globalExec();
JSValue createInstanceContextFunction =
worker_globalObject->get(state, createInstanceContextProperty);
MarkedArgumentBuffer args;
@@ -168,7 +181,7 @@ int WeexRuntime::createAppContext(const String &instanceId,
const String &jsBund
String exceptionInfo = exceptionToString(worker_globalObject,
returnedException->value());
return static_cast<int32_t>(false);
}
- app_globalObject->resetPrototype(vm, ret);
+ app_globalObject->resetPrototype(*(this->m_globalVM.get()), ret);
app_globalObject->id = final_instanceId.utf8().data();
// --------------------------------------------------
@@ -205,17 +218,14 @@ WeexRuntime::callJSOnAppContext(const String &instanceId,
const String &func, st
return static_cast<int32_t>(false);
}
// LOGE("Weex jsserver IPCJSMsg::CALLJSONAPPCONTEXT1");
- VM &vm_global = VM::sharedInstance();
- JSLockHolder locker_global(&vm_global);
+ JSLockHolder locker_global(this->m_globalVM.get());
- VM &vm = worker_globalObject->vm();
- JSLockHolder locker(&vm);
// LOGE("Weex jsserver IPCJSMsg::CALLJSONAPPCONTEXT2");
MarkedArgumentBuffer obj;
ExecState *state = worker_globalObject->globalExec();
_getArgListFromJSParams(&obj, state, params);
// LOGE("Weex jsserver IPCJSMsg::CALLJSONAPPCONTEXT3");
- Identifier funcIdentifier = Identifier::fromString(&vm, func);
+ Identifier funcIdentifier =
Identifier::fromString(this->m_globalVM.get(), func);
JSValue function;
JSValue result;
@@ -261,17 +271,14 @@ int WeexRuntime::callJSOnAppContext(IPCArguments
*arguments) {
return static_cast<int32_t>(false);
}
// LOGE("Weex jsserver IPCJSMsg::CALLJSONAPPCONTEXT1");
- VM &vm_global = VM::sharedInstance();
- JSLockHolder locker_global(&vm_global);
- VM &vm = worker_globalObject->vm();
- JSLockHolder locker(&vm);
+ JSLockHolder locker(this->m_globalVM.get());
// LOGE("Weex jsserver IPCJSMsg::CALLJSONAPPCONTEXT2");
MarkedArgumentBuffer obj;
ExecState *state = worker_globalObject->globalExec();
_getArgListFromIPCArguments(&obj, state, arguments, 2);
// LOGE("Weex jsserver IPCJSMsg::CALLJSONAPPCONTEXT3");
- Identifier funcIdentifier = Identifier::fromString(&vm, func);
+ Identifier funcIdentifier =
Identifier::fromString(this->m_globalVM.get(), func);
JSValue function;
JSValue result;
@@ -309,7 +316,8 @@ int WeexRuntime::destroyAppContext(const String
&instanceId) {
objectMap.erase(instanceId.utf8().data());
}
- WeexEnv::getEnv()->timerQueue()->destroyPageTimer(instanceId);
+ if(appWorkerObjectHolder->timeQueue != nullptr)
+
appWorkerObjectHolder->timeQueue->destroyPageTimer(instanceId.utf8().data());
// GC on VM
// WeexGlobalObject* instanceGlobalObject =
mAppInstanceGlobalObjectMap[instanceId.utf8().data()];
@@ -342,8 +350,7 @@ int WeexRuntime::exeJsService(const String &source) {
// JSLockHolder locker_global(&vm_global);
// }
JSGlobalObject *globalObject = weexObjectHolder->m_globalObject.get();
- VM &vm = globalObject->vm();
- JSLockHolder locker(&vm);
+ JSLockHolder locker(this->m_globalVM.get());
if (!ExecuteJavaScript(globalObject, source, ("weex service"), true,
"execjsservice")) {
LOGE("jsLog JNI_Error >>> scriptStr :%s", source.utf8().data());
return static_cast<int32_t>(false);
@@ -355,8 +362,7 @@ int WeexRuntime::exeCTimeCallback(const String &source) {
base::debug::TraceScope traceScope("weex", "EXECTIMERCALLBACK");
// LOGE("IPC EXECTIMERCALLBACK and ExecuteJavaScript");
JSGlobalObject *globalObject = weexObjectHolder->m_globalObject.get();
- VM &vm = globalObject->vm();
- JSLockHolder locker(&vm);
+ JSLockHolder locker(this->m_globalVM.get());
if (!ExecuteJavaScript(globalObject, source, ("weex service"), false,
"timercallback")) {
LOGE("jsLog EXECTIMERCALLBACK >>> scriptStr :%s",
source.utf8().data());
return static_cast<int32_t>(false);
@@ -367,10 +373,9 @@ int WeexRuntime::exeCTimeCallback(const String &source) {
int WeexRuntime::exeJS(const String &instanceId, const String &nameSpace,
const String &func,
std::vector<VALUE_WITH_TYPE *> ¶ms) {
- //LOGE("jsengine shopp EXECJS func:%s and params size is %d",
func.utf8().data(), params.size());
+// LOGE("dyyLog EXECJS func:%s and params size is %d", func.utf8().data(),
params.size());
String runFunc = func;
-
JSGlobalObject *globalObject;
// fix instanceof Object error
// if function is callJs on instance, should us Instance object to call
__WEEX_CALL_JAVASCRIPT__
@@ -386,8 +391,7 @@ int WeexRuntime::exeJS(const String &instanceId, const
String &nameSpace, const
} else {
globalObject = weexObjectHolder->m_globalObject.get();
}
- VM &vm = globalObject->vm();
- JSLockHolder locker(&vm);
+ JSLockHolder locker(this->m_globalVM.get());
// if (weexLiteAppObjectHolder.get() != nullptr) {
// VM & vm_global = *weexLiteAppObjectHolder->m_globalVM.get();
// JSLockHolder locker_global(&vm_global);
@@ -398,14 +402,14 @@ int WeexRuntime::exeJS(const String &instanceId, const
String &nameSpace, const
ExecState *state = globalObject->globalExec();
_getArgListFromJSParams(&obj, state, params);
- Identifier funcIdentifier = Identifier::fromString(&vm, runFunc);
+ Identifier funcIdentifier = Identifier::fromString(this->m_globalVM.get(),
runFunc);
JSValue function;
JSValue result;
if (nameSpace.isEmpty()) {
function = globalObject->get(state, funcIdentifier);
} else {
- Identifier namespaceIdentifier = Identifier::fromString(&vm,
nameSpace);
+ Identifier namespaceIdentifier =
Identifier::fromString(this->m_globalVM.get(), nameSpace);
JSValue master = globalObject->get(state, namespaceIdentifier);
if (!master.isObject()) {
return static_cast<int32_t>(false);
@@ -417,7 +421,7 @@ int WeexRuntime::exeJS(const String &instanceId, const
String &nameSpace, const
NakedPtr<Exception> returnedException;
JSValue ret = call(state, function, callType, callData, globalObject, obj,
returnedException);
- vm.drainMicrotasks();
+ this->m_globalVM.get()->drainMicrotasks();
if (returnedException) {
@@ -584,7 +588,8 @@ int WeexRuntime::destroyInstance(const String &instanceId) {
// LOGE("DestoryInstance map 11 length:%d",
weexObjectHolder->m_jsGlobalObjectMap.size());
weexObjectHolder->m_jsInstanceGlobalObjectMap.erase(instanceId.utf8().data());
// LOGE("DestoryInstance map 22 length:%d",
weexObjectHolder->m_jsGlobalObjectMap.size());
-
WeexEnv::getEnv()->timerQueue()->destroyPageTimer(instanceId.utf8().data());
+ if(weexObjectHolder->timeQueue != nullptr)
+ weexObjectHolder->timeQueue->destroyPageTimer(instanceId.utf8().data());
// release JSGlobalContextRelease
// when instanceId % 20 == 0 GC
bool needGc = false;
@@ -601,8 +606,9 @@ int WeexRuntime::destroyInstance(const String &instanceId) {
VM &vm = exec->vm();
globalObject->resetPrototype(vm, jsNull());
bool protectCountIsZero =
Heap::heap(exec->vmEntryGlobalObject())->unprotect(exec->vmEntryGlobalObject());
- vm.heap.reportAbandonedObjectGraph();
+ vm.heap.reportAbandonedObjectGraph();
//vm.heap.collectSync(CollectionScope::Full);//collectAllGarbage();//collectAsync(CollectionScope::Full);
+ //TODO disable gc temporary
vm.heap.collectAllGarbage();
}
@@ -632,6 +638,7 @@ int WeexRuntime::createInstance(const String &instanceId,
const String &func, co
const String &initData,
const String &extendsApi,
std::vector<INIT_FRAMEWORK_PARAMS*>& params) {
+
JSGlobalObject *impl_globalObject = weexObjectHolder->m_globalObject.get();
JSGlobalObject *globalObject;
if (instanceId == "") {
@@ -647,11 +654,10 @@ int WeexRuntime::createInstance(const String &instanceId,
const String &func, co
// JSLockHolder locker_global(&vm_global);
// }
- temp_object = weexObjectHolder->cloneWeexObject(true, false);
+ temp_object =
weexObjectHolder->cloneWeexObject(instanceId.utf8().data(), true, false);
VM &vm = temp_object->vm();
JSLockHolder locker(&vm);
temp_object->addExtraOptions(params);
- temp_object->id = instanceId.utf8().data();
temp_object->SetScriptBridge(script_bridge_);
@@ -689,12 +695,35 @@ int WeexRuntime::createInstance(const String &instanceId,
const String &func, co
// use it to set Vue prototype to instance context
JSObject *object = ret.toObject(state, temp_object);
JSObjectRef ref = toRef(object);
- JSGlobalContextRef contextRef = toGlobalRef(state);
- JSValueRef vueRef = JSObjectGetProperty(contextRef, ref,
JSStringCreateWithUTF8CString("Vue"), nullptr);
+ JSGlobalContextRef globalContextRef = toGlobalRef(state);
+ JSGlobalContextRef instanceContextRef =
toGlobalRef(temp_object->globalExec());
+ auto instanceGlobalObject =
JSContextGetGlobalObject(instanceContextRef);
+ auto pArray = JSObjectCopyPropertyNames(globalContextRef, ref);
+ size_t keyCount = JSPropertyNameArrayGetCount(pArray);
+// LOGE("dyyLog instance create and id is %s, and time is %lld,
currentThread is %u", instanceId.utf8().data(), microTime(), pthread_self());
+ for (size_t i = 0; i < keyCount; ++i) {
+ auto propertyName_ = JSPropertyNameArrayGetNameAtIndex(pArray,
i);
+ auto propertyValue_ = JSObjectGetProperty(globalContextRef,
ref, propertyName_, NULL);
+ if(propertyValue_ == nullptr) {
+ LOGE("dyy create instance propertyValue_ == null");
+ continue;
+ }
+
+ if(propertyName_ == nullptr) {
+ LOGE("dyy create instance propertyName_ == null");
+ continue;
+ }
+
+ JSObjectSetProperty(instanceContextRef, instanceGlobalObject,
propertyName_, propertyValue_, 0, NULL);
+ }
+
+
+
+ JSValueRef vueRef = JSObjectGetProperty(globalContextRef, ref,
JSStringCreateWithUTF8CString("Vue"), nullptr);
if (vueRef != nullptr) {
- JSObjectRef vueObject = JSValueToObject(contextRef, vueRef,
nullptr);
+ JSObjectRef vueObject = JSValueToObject(globalContextRef,
vueRef, nullptr);
if (vueObject != nullptr) {
- JSGlobalContextRef instanceContextRef =
toGlobalRef(temp_object->globalExec());
+
JSObjectSetPrototype(instanceContextRef, vueObject,
JSObjectGetPrototype(instanceContextRef,
JSContextGetGlobalObject(instanceContextRef)));
@@ -702,7 +731,7 @@ int WeexRuntime::createInstance(const String &instanceId,
const String &func, co
}
//-------------------------------------------------
- temp_object->resetPrototype(vm, ret);
+// temp_object->resetPrototype(vm, ret);
weexObjectHolder->m_jsInstanceGlobalObjectMap[instanceId.utf8().data()] =
temp_object;
// LOGE("create Instance instanceId.utf8().data()
%s",instanceId.utf8().data());
// -----------------------------------------
@@ -741,8 +770,7 @@ int WeexRuntime::createInstance(const String &instanceId,
const String &func, co
}
int WeexRuntime::_initFramework(const String &source) {
- VM &vm = VM::sharedInstance();
- JSLockHolder locker(&vm);
+ JSLockHolder locker(this->m_globalVM.get());
auto globalObject = weexObjectHolder->m_globalObject.get();
globalObject->SetScriptBridge(script_bridge_);
@@ -793,16 +821,25 @@
WeexRuntime::_getArgListFromIPCArguments(MarkedArgumentBuffer *obj, ExecState *s
void WeexRuntime::_getArgListFromJSParams(MarkedArgumentBuffer *obj, ExecState
*state,
std::vector<VALUE_WITH_TYPE *>
¶ms) {
+
+ //dyyLog delete
+// String msg = "exejs Args ";
+
for (unsigned int i = 0; i < params.size(); i++) {
VALUE_WITH_TYPE *paramsObject = params[i];
switch (paramsObject->type) {
case ParamsType::DOUBLE:
obj->append(jsNumber(paramsObject->value.doubleValue));
+// msg.append(":");
+//
msg.append(std::to_string(paramsObject->value.doubleValue).c_str());
break;
case ParamsType::STRING: {
WeexString *ipcstr = paramsObject->value.string;
const String &string2String = weexString2String(ipcstr);
obj->append(jString2JSValue(state, ipcstr->content,
ipcstr->length));
+
+// msg.append(":");
+// msg.append(string2String.utf8().data());
}
break;
case ParamsType::JSONSTRING: {
@@ -811,12 +848,19 @@ void
WeexRuntime::_getArgListFromJSParams(MarkedArgumentBuffer *obj, ExecState *
String str = jString2String(ipcstr->content, ipcstr->length);
JSValue o = parseToObject(state, str);
obj->append(o);
+
+// msg.append(":");
+// msg.append(str.utf8().data());
}
break;
case ParamsType::BYTEARRAY: {
const WeexByteArray *array = paramsObject->value.byteArray;
JSValue o = wson::toJSValue(state, (void *) array->content,
array->length);
+
obj->append(o);
+
+// msg.append(":");
+// msg.append(JSONStringify(state, o, 0).utf8().data());
}
break;
default:
@@ -824,6 +868,8 @@ void
WeexRuntime::_getArgListFromJSParams(MarkedArgumentBuffer *obj, ExecState *
break;
}
}
+
+// LOGE("dyyLog exejs Args is %s", msg.utf8().data());
}
WeexObjectHolder *WeexRuntime::getLightAppObjectHolder(const String
&instanceId) {
@@ -857,7 +903,6 @@ int WeexRuntime::exeTimerFunction(const String &instanceId,
uint32_t timerFuncti
}
ArgList a;
-
JSValue ret = call(globalObject->globalExec(), value, callType, callData,
globalObject, a, returnedException);
uint64_t end = microTime();
diff --git a/weex_core/Source/android/jsengine/weex_runtime.h
b/weex_core/Source/android/jsengine/weex_runtime.h
index 680411c..37f1dbf 100644
--- a/weex_core/Source/android/jsengine/weex_runtime.h
+++ b/weex_core/Source/android/jsengine/weex_runtime.h
@@ -23,6 +23,7 @@
#ifndef WEEXV8_JSRUNTIME_H
#define WEEXV8_JSRUNTIME_H
+#include "android/jsengine/task/timer_queue.h"
#include "android/jsengine/object/weex_object_holder.h"
#include "android/jsengine/weex_ipc_client.h"
@@ -36,9 +37,11 @@ public:
std::unique_ptr<WeexObjectHolder> weexObjectHolder;
std::map<std::string, WeexObjectHolder *> appWorkerContextHolderMap;
- explicit WeexRuntime(bool isMultiProgress = true);
+ RefPtr<VM> m_globalVM;
- explicit WeexRuntime(WeexCore::ScriptBridge *script_bridge, bool
isMultiProgress = true);
+ explicit WeexRuntime(TimerQueue* timeQueue, bool isMultiProgress = true);
+
+ explicit WeexRuntime(TimerQueue* timeQueue, WeexCore::ScriptBridge
*script_bridge, bool isMultiProgress = true);
bool hasInstanceId(String &id);
diff --git a/weex_core/Source/base/CMakeLists.txt
b/weex_core/Source/base/CMakeLists.txt
index 737aa9e..78c424e 100644
--- a/weex_core/Source/base/CMakeLists.txt
+++ b/weex_core/Source/base/CMakeLists.txt
@@ -7,6 +7,7 @@ set(${BASE_LIBRARY_NAME}_SOURCES
common.h
closure.h
make_copyable.h
+ time_calculator.h
time_point.h
time_point.cc
time_unit.h
diff --git a/weex_core/Source/base/android/log_utils.h
b/weex_core/Source/base/android/log_utils.h
index b398194..52b6cf1 100644
--- a/weex_core/Source/base/android/log_utils.h
+++ b/weex_core/Source/base/android/log_utils.h
@@ -35,7 +35,7 @@
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
__VA_ARGS__)
#define LOGA(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG,
__VA_ARGS__)
-#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG,
__VA_ARGS__)
+#define LOGD(...) ((void)0)//__android_log_print(ANDROID_LOG_DEBUG,
LOG_TAG, __VA_ARGS__)
#endif
//#define DEBUG
@@ -53,7 +53,7 @@
#else
#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG,
__VA_ARGS__)
-#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG,
__VA_ARGS__)
+#define LOGD(...) ((void)0)//__android_log_print(ANDROID_LOG_DEBUG,
LOG_TAG, __VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG,
__VA_ARGS__)
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
#define LOG_LINE LOGV("%s, %d", __func__, __LINE__)
diff --git a/weex_core/Source/base/log_defines.h
b/weex_core/Source/base/log_defines.h
index d1f78d8..abf6e05 100644
--- a/weex_core/Source/base/log_defines.h
+++ b/weex_core/Source/base/log_defines.h
@@ -27,8 +27,8 @@
#include <android/log.h>
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
__VA_ARGS__)
-#define LOGA(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG,
__VA_ARGS__)
-#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG,
__VA_ARGS__)
+#define LOGA(...) ((void)0) //__android_log_print(ANDROID_LOG_DEBUG,
LOG_TAG, __VA_ARGS__)
+#define LOGD(...) ((void)0) //__android_log_print(ANDROID_LOG_DEBUG,
LOG_TAG, __VA_ARGS__)
#ifdef DEBUG
diff --git a/weex_core/Source/base/time_calculator.h
b/weex_core/Source/base/time_calculator.h
new file mode 100644
index 0000000..5a91306
--- /dev/null
+++ b/weex_core/Source/base/time_calculator.h
@@ -0,0 +1,143 @@
+/**
+ * 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.
+ */
+//
+// Created by 董亚运 on 2019/1/14.
+//
+
+#ifndef WEEX_PROJECT_TIME_CALCULATOR_H
+#define WEEX_PROJECT_TIME_CALCULATOR_H
+
+#include <string>
+#include "time_point.h"
+#include "time_unit.h"
+#include "android/log_utils.h"
+
+namespace weex {
+namespace base {
+enum TaskPlatform {
+ WEEXCORE,
+ JSS_ENGINE
+};
+
+class TimeCalculator {
+ public:
+ TimeCalculator(TaskPlatform taskPlatform, std::string name, std::string id) :
+ task_name(name),
+ instance_id(id),
+ end(TimePoint::Now()),
+ start(TimePoint::Now()),
+ task_end(TimePoint::Now()),
+ task_start(TimePoint::Now()),
+ task_id(genTaskId()) {
+ if (taskPlatform == TaskPlatform::JSS_ENGINE) {
+ task_platform = "jsengine";
+ } else {
+ task_platform = "weexcore";
+ }
+ }
+
+ int genTaskId() {
+ static int taskIdGenerator = 0;
+ return __sync_fetch_and_add(&taskIdGenerator, 1);
+ }
+
+ ~TimeCalculator() {
+ if (!task_end_flag) {
+ task_end = TimePoint::Now();
+ }
+ end = TimePoint::Now();
+ print();
+ }
+
+ void taskStart() {
+// LOGE(
+// "dyyLog %s taskName is %s : instanceId %s : task_id %d: taskStart",
+// task_platform.c_str(),
+// task_name.c_str(),
+// instance_id.c_str(),
+// task_id);
+ this->task_start = TimePoint::Now();
+ }
+
+ void taskEnd() {
+// LOGE(
+// "dyyLog %s taskName is %s : instanceId %s : task_id %d: taskEnd",
+// task_platform.c_str(),
+// task_name.c_str(),
+// instance_id.c_str(),
+// task_id);
+ this->task_end = TimePoint::Now();
+ task_end_flag = true;
+ }
+
+ void set_task_name(std::string name) {
+ this->task_name = name;
+ }
+
+ void print() {
+ const TimeUnit &allCost = end.ToTimeUnit() - start.ToTimeUnit();
+ const TimeUnit &taskWait = task_start.ToTimeUnit() - start.ToTimeUnit();
+ const TimeUnit &taskCost = task_end.ToTimeUnit() - task_start.ToTimeUnit();
+
+// int64_t taskCostMS = taskCost.ToMilliseconds();
+// if (taskCostMS < 5) {
+// LOGD("dyyLog %s taskName is %s cost less than 5ms",
task_platform.c_str(),
+// task_name.c_str());
+// } else {
+// std::string msg = "normal";
+//
+// if (taskCostMS > 100) {
+// msg = "task cost than 100, ";
+// }
+//
+// if (taskWait.ToMilliseconds() > 100) {
+// std::string a = "wait to long time than 100ms";
+// msg += a;
+// }
+//
+// LOGE(
+// "dyyLog %s taskName is %s : instanceId %s : task_id %d: start :
%lld --- end : %lld --- allCost:%lld --- taskCost:%lld ---
taskWait:%lld --- msg:%s",
+// task_platform.c_str(),
+// task_name.c_str(),
+// instance_id.c_str(),
+// task_id,
+// start.ToTimeUnit().ToMilliseconds(),
+// end.ToTimeUnit().ToMilliseconds(),
+// allCost.ToMilliseconds(),
+// taskCostMS,
+// taskWait.ToMilliseconds(),
+// msg.c_str());
+// }
+ }
+
+ private:
+ std::string task_name;
+ int task_id;
+ std::string instance_id;
+ TimePoint start;
+ TimePoint end;
+ TimePoint task_start;
+ TimePoint task_end;
+ bool task_end_flag = false;
+ std::string task_platform;
+};
+} // namespace base
+} // namespace weex
+
+#endif //WEEX_PROJECT_TIME_CALCULATOR_H
diff --git a/weex_core/Source/base/utils/log_utils.h
b/weex_core/Source/base/utils/log_utils.h
index 4b5607b..1967faf 100644
--- a/weex_core/Source/base/utils/log_utils.h
+++ b/weex_core/Source/base/utils/log_utils.h
@@ -24,13 +24,13 @@
#define LOG_TAG "jsengine"
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG,
__VA_ARGS__)
-#define LOGA(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG,
__VA_ARGS__)
+#define LOGA(...) ((void)0)//__android_log_print(ANDROID_LOG_DEBUG,
LOG_TAG, __VA_ARGS__)
//#define DEBUG
#ifdef DEBUG
#define LOGV(...) __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG,
__VA_ARGS__)
-#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG, LOG_TAG,
__VA_ARGS__)
+#define LOGD(...) ((void)0)//__android_log_print(ANDROID_LOG_DEBUG,
LOG_TAG, __VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG,
__VA_ARGS__)
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__)
#define LOG_LINE LOGV("%s, %d", __func__, __LINE__)
diff --git a/weex_core/Source/core/bridge/script/core_side_in_script.cpp
b/weex_core/Source/core/bridge/script/core_side_in_script.cpp
index 68085a0..e0bbd40 100644
--- a/weex_core/Source/core/bridge/script/core_side_in_script.cpp
+++ b/weex_core/Source/core/bridge/script/core_side_in_script.cpp
@@ -26,7 +26,9 @@
#include "core/data_render/vnode/vnode_render_manager.h"
#include "core/manager/weex_core_manager.h"
#include "core/render/manager/render_manager.h"
+#include "wson/wson_parser.h"
#ifdef OS_ANDROID
+#include <base/time_calculator.h>
#include "android/weex_extend_js_api.h"
#endif
@@ -125,6 +127,14 @@ void CoreSideInScript::CallNativeComponent(const char
*page_id, const char *ref,
void CoreSideInScript::AddElement(const char *page_id, const char *parent_ref,
const char *dom_str, int dom_str_length,
const char *index_str) {
+
+
+// std::string msg = "AddElement :";
+// wson_parser parser(dom_str);
+// msg.append(parser.toStringUTF8().c_str());
+//
+// weex::base::TimeCalculator
timeCalculator(weex::base::TaskPlatform::WEEXCORE, msg.c_str(), page_id);
+
const char *indexChar = index_str == nullptr ? "\0" : index_str;
int index = atoi(indexChar);
if (page_id == nullptr || parent_ref == nullptr || dom_str == nullptr ||
@@ -432,7 +442,7 @@ void CoreSideInScript::ReportException(const char *page_id,
const char *func,
}
void CoreSideInScript::SetJSVersion(const char *js_version) {
- LOGA("init JSFrm version %s", js_version);
+ LOGD("init JSFrm version %s", js_version);
// WeexCoreManager::Instance()->script_thread()->message_loop()->PostTask(
// weex::base::MakeCopyable(
