From adfe0a0216538f09ecedcc28d9d6ed75996487a9 Mon Sep 17 00:00:00 2001 From: njupthan Date: Sun, 30 Jan 2022 00:02:16 +0800 Subject: [PATCH] test Signed-off-by: njupthan --- .../src/local_call_container.cpp | 2 +- .../native/src/ability_runtime/js_ability.cpp | 3 + .../ability_runtime/js_ability_context.cpp | 141 +++++++++++++----- .../src/ability_runtime/js_caller_complex.cpp | 2 + .../aafwk/ability_context/ability_context.js | 4 +- interfaces/kits/napi/aafwk/caller/caller.js | 33 +++- 6 files changed, 143 insertions(+), 42 deletions(-) diff --git a/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp b/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp index 8ef298e70f4..13ed5205b1c 100644 --- a/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp +++ b/frameworks/kits/ability/ability_runtime/src/local_call_container.cpp @@ -24,7 +24,7 @@ int LocalCallContainer::StartAbilityInner( HILOG_DEBUG("start ability by call."); if (!callback) { - HILOG_ERROR("callbackļ¼‰is nullptr."); + HILOG_ERROR("callback is nullptr."); return ERR_INVALID_VALUE; } diff --git a/frameworks/kits/ability/native/src/ability_runtime/js_ability.cpp b/frameworks/kits/ability/native/src/ability_runtime/js_ability.cpp index 314e95709ee..401d3fc7204 100755 --- a/frameworks/kits/ability/native/src/ability_runtime/js_ability.cpp +++ b/frameworks/kits/ability/native/src/ability_runtime/js_ability.cpp @@ -307,6 +307,9 @@ void JsAbility::OnAbilityResult(int requestCode, int resultCode, const Want &res sptr JsAbility::CallRequest() { HILOG_INFO("JsAbility::CallRequest begin."); + + // return GetToken(); + if (jsAbilityObj_ == nullptr) { HILOG_WARN("JsAbility::CallRequest Obj is nullptr"); return nullptr; diff --git a/frameworks/kits/ability/native/src/ability_runtime/js_ability_context.cpp b/frameworks/kits/ability/native/src/ability_runtime/js_ability_context.cpp index 404dd116c9b..ec57269bf79 100755 --- a/frameworks/kits/ability/native/src/ability_runtime/js_ability_context.cpp +++ b/frameworks/kits/ability/native/src/ability_runtime/js_ability_context.cpp @@ -40,6 +40,15 @@ constexpr size_t ARGC_TWO = 2; constexpr size_t ARGC_THREE = 3; constexpr int32_t ERROR_CODE_ONE = 1; +class StartAbilityByCallParameters { +public: + sptr remoteCallee = nullptr; + std::shared_ptr callerCallBack = nullptr; + std::weak_ptr weak_context; + std::mutex mutexlock; + std::condition_variable condition; +}; + void JsAbilityContext::Finalizer(NativeEngine* engine, void* data, void* hint) { HILOG_INFO("JsAbilityContext::Finalizer is called"); @@ -226,54 +235,110 @@ NativeValue* JsAbilityContext::OnStartAbilityWithAccount(NativeEngine& engine, N NativeValue* JsAbilityContext::OnStartAbilityByCall(NativeEngine& engine, NativeCallbackInfo& info) { - int errCode = 0; - sptr remoteCallee; - if (info.argc != ARGC_ONE || info.argv[0]->TypeOf() != NATIVE_OBJECT) { + HILOG_DEBUG("JsAbilityContext::%{public}s, called", __func__); + constexpr size_t ARGC_ONE = 1; + constexpr size_t ARGC_TWO = 2; + if (info.argc < ARGC_ONE || info.argv[0]->TypeOf() != NATIVE_OBJECT) { HILOG_ERROR("int put params count error"); return engine.CreateUndefined(); } + AAFwk::Want want; OHOS::AppExecFwk::UnwrapWant(reinterpret_cast(&engine), reinterpret_cast(info.argv[0]), want); - NativeValue* callerComplex = nullptr; - std::mutex mutexlock; - std::condition_variable condition; - auto callBackDone = [&mutexlock, &condition, &remoteCallee](const sptr &obj) { - std::unique_lock lock(mutexlock); - remoteCallee = obj; - condition.notify_all(); - HILOG_INFO("OnStartAbilityByCall callBackDone is called"); + + StartAbilityByCallParameters *callParameters = new (std::nothrow) StartAbilityByCallParameters(); + if (callParameters == nullptr) { + HILOG_ERROR("callParameters create error"); + return engine.CreateUndefined(); + } + HILOG_INFO("OnStartAbilityByCall callParameters is %{public}p", callParameters); + + callParameters->weak_context = context_; + callParameters->callerCallBack = std::make_shared(); + auto callBackDone = [callParameters](const sptr &obj) { + HILOG_INFO("OnStartAbilityByCall callBackDone is called begin callParameters is %{public}p", callParameters); + if (callParameters != nullptr) { + callParameters->remoteCallee = obj; + } else { + HILOG_ERROR("OnStartAbilityByCall callBackDone callParameters is nullptr"); + } + HILOG_INFO("OnStartAbilityByCall callBackDone mutexlock"); + std::unique_lock lock(callParameters->mutexlock); + HILOG_INFO("OnStartAbilityByCall callBackDone mutexlock notify"); + callParameters->condition.notify_all(); + HILOG_INFO("OnStartAbilityByCall callBackDone is called end"); }; auto releaseListen = [](const std::string &str) { HILOG_INFO("OnStartAbilityByCall releaseListen is called %{public}s", str.c_str()); }; - auto context = context_.lock(); - constexpr int CALLER_TIME_OUT = 5; // 5s - if (!context) { - HILOG_ERROR("context is released"); - errCode = -1; - return engine.CreateUndefined(); - } - std::shared_ptr callerCallBack = std::make_shared(); - callerCallBack->SetCallBack(callBackDone); - callerCallBack->SetOnRelease(releaseListen); - HILOG_INFO("OnStartAbilityByCall execute is StartAbility"); - errCode = context->StartAbility(want, callerCallBack); - if (remoteCallee == nullptr) { - HILOG_INFO("OnStartAbilityByCall lock mutexlock Done"); - std::unique_lock lock(mutexlock); - HILOG_INFO("OnStartAbilityByCall lock waiting callBackDone"); - if (condition.wait_for(lock, std::chrono::seconds(CALLER_TIME_OUT)) == std::cv_status::timeout) { - remoteCallee = nullptr; - errCode = -1; - HILOG_ERROR("Waiting callee timeout"); - return engine.CreateUndefined(); - } - } else { - HILOG_INFO("OnStartAbilityByCall remoteCallee isn~t nullptr"); - } - callerComplex = CreateJsCallerComplex(engine, context, remoteCallee, callerCallBack); - return callerComplex; + callParameters->callerCallBack->SetCallBack(callBackDone); + callParameters->callerCallBack->SetOnRelease(releaseListen); + AsyncTask::ExecuteCallback callExecute = + [callParameters, want] ( + NativeEngine& engine, AsyncTask& task) { + constexpr int CALLER_TIME_OUT = 10; // 10s + if (callParameters == nullptr) { + HILOG_ERROR("callParameters is released"); + return; + } + HILOG_INFO("OnStartAbilityByCall callExecute callParameters is %{public}p", callParameters); + auto context = callParameters->weak_context.lock(); + if (context == nullptr) { + HILOG_ERROR("context is released"); + return; + } + + HILOG_INFO("OnStartAbilityByCall execute is StartAbility"); + if (context->StartAbility(want, callParameters->callerCallBack) != 0) { + HILOG_ERROR("StartAbility is failed"); + return; + } + HILOG_INFO("OnStartAbilityByCall lock waiting callBackDone"); + if (callParameters->remoteCallee == nullptr) { + HILOG_INFO("OnStartAbilityByCall lock mutexlock"); + std::unique_lock lock(callParameters->mutexlock); + if (callParameters->condition.wait_for( + lock, std::chrono::seconds(CALLER_TIME_OUT)) == std::cv_status::timeout) { + HILOG_ERROR("Waiting callee timeout"); + } + } + HILOG_DEBUG("JsAbilityContext::%{public}s, end", "OnStartAbilityByCall::ExecuteCallback"); + }; + AsyncTask::CompleteCallback callComplete = + [callParameters] ( + NativeEngine& engine, AsyncTask& task, int32_t status) { + HILOG_DEBUG("JsAbilityContext::%{public}s, begin callParameters is %{public}p", "OnStartAbilityByCall::CompleteCallback", callParameters); + if (callParameters == nullptr) { + HILOG_ERROR("callParameters is released"); + task.Reject(engine, CreateJsError(engine, -1, "callParameters Create Call Failed.")); + // delete callParameters; + // callParameters = nullptr; + return; + } + + auto context = callParameters->weak_context.lock(); + if (context != nullptr && callParameters->callerCallBack != nullptr && + callParameters->remoteCallee != nullptr) { + task.Resolve(engine, CreateJsCallerComplex(engine, context, callParameters->remoteCallee, + callParameters->callerCallBack)); + } else { + task.Reject(engine, CreateJsError(engine, -1, "callParameters Create Call Failed.")); + } + + // delete callParameters; + // callParameters = nullptr; + HILOG_DEBUG("JsAbilityContext::%{public}s, end", "OnStartAbilityByCall::CompleteCallback"); + }; + + NativeValue* lastParam = ((info.argc == ARGC_TWO) ? info.argv[ARGC_ONE] : nullptr); + NativeValue* retsult = nullptr; + AsyncTask::Schedule( + engine, + CreateAsyncTaskWithLastParam(engine, lastParam, std::move(callExecute), std::move(callComplete), &retsult)); + + HILOG_DEBUG("JsAbilityContext::%{public}s, called end", __func__); + return retsult; } NativeValue* JsAbilityContext::OnStartAbilityForResult(NativeEngine& engine, NativeCallbackInfo& info) diff --git a/frameworks/kits/ability/native/src/ability_runtime/js_caller_complex.cpp b/frameworks/kits/ability/native/src/ability_runtime/js_caller_complex.cpp index bb553457003..43daaa9c787 100644 --- a/frameworks/kits/ability/native/src/ability_runtime/js_caller_complex.cpp +++ b/frameworks/kits/ability/native/src/ability_runtime/js_caller_complex.cpp @@ -128,6 +128,8 @@ private: NativeValue* callback = jsreleaseCallBackObj_->Get(); NativeValue* args[] = { CreateJsValue(releaseCallBackEngine_, str) }; releaseCallBackEngine_.CallFunction(value, callback, args, 1); + HILOG_DEBUG("OnReleaseNotifyTask CallFunction call done"); + callee_ = nullptr; HILOG_DEBUG("OnReleaseNotifyTask end"); } diff --git a/interfaces/kits/napi/aafwk/ability_context/ability_context.js b/interfaces/kits/napi/aafwk/ability_context/ability_context.js index 7922079eeaa..c053519cd7c 100755 --- a/interfaces/kits/napi/aafwk/ability_context/ability_context.js +++ b/interfaces/kits/napi/aafwk/ability_context/ability_context.js @@ -36,13 +36,13 @@ class AbilityContext extends Context { return this.__context_impl__.startAbilityWithAccount(want, accountId, options, callback) } - startAbilityByCall(want) { + async startAbilityByCall(want) { if (typeof want !== 'object' || want == null) { console.log("AbilityContext::startAbilityByCall input param error"); return null; } - let callee = this.__context_impl__.startAbilityByCall(want); + let callee = await this.__context_impl__.startAbilityByCall(want); if (typeof callee === 'object' && callee != null) { console.log("AbilityContext::startAbilityByCall"); return new Caller(callee); diff --git a/interfaces/kits/napi/aafwk/caller/caller.js b/interfaces/kits/napi/aafwk/caller/caller.js index 1cf63fb8ceb..b35ca262250 100644 --- a/interfaces/kits/napi/aafwk/caller/caller.js +++ b/interfaces/kits/napi/aafwk/caller/caller.js @@ -22,7 +22,7 @@ class Caller { constructor(obj) { console.log("Caller::constructor obj is " + typeof obj); this.__call_obj__ = obj; - this.releaseCallback = null; + this.releaseCall = false; } async call(method, data) { @@ -33,6 +33,12 @@ class Caller { return; } + if (this.releaseCall) { + console.log("Caller call this.callee release"); + throw new Error("Function inner object error"); + return; + } + if (this.__call_obj__.callee == null) { console.log("Caller call this.callee is nullptr"); throw new Error("Function inner object error"); @@ -73,6 +79,12 @@ class Caller { return undefined; } + if (this.releaseCall) { + console.log("Caller callWithResult this.callee release"); + throw new Error("Function inner object error"); + return; + } + if (this.__call_obj__.callee == null) { console.log("Caller callWithResult this.callee is nullptr"); return undefined; @@ -107,7 +119,20 @@ class Caller { release() { console.log("Caller release js called."); + if (this.releaseCall == true) { + console.log("Caller release remoteObj releaseState is true"); + throw new Error("Caller release call remoteObj is released"); + return; + } + + if (this.__call_obj__.callee == null) { + console.log("Caller release call remoteObj is released"); + throw new Error("Caller release call remoteObj is released"); + return; + } + this.__call_obj__.release(); + this.releaseCall = true; } onRelease(callback) { @@ -118,6 +143,12 @@ class Caller { return; } + if (this.releaseCall == true) { + console.log("Caller onRelease remoteObj releaseState is true"); + throw new Error("Caller onRelease call remoteObj is released"); + return; + } + this.__call_obj__.onRelease(callback); } } -- Gitee