From bbdff3f7bb9628a06454b7bd10b87202453f9da8 Mon Sep 17 00:00:00 2001 From: zhaowenli Date: Fri, 20 Dec 2024 18:14:24 +0800 Subject: [PATCH 1/2] =?UTF-8?q?=E5=BC=82=E6=AD=A5=E6=95=B4=E6=94=B9?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhaowenli Change-Id: I714af76455df119cf1ca360cfc7eebfa6713a429 --- .../napi/accesstoken/src/napi_atmanager.cpp | 142 ++++++------------ .../accesstoken/src/napi_context_common.cpp | 51 +++---- .../napi_request_global_switch_on_setting.cpp | 84 ++++------- .../src/napi_request_permission.cpp | 112 ++++++-------- .../napi_request_permission_on_setting.cpp | 93 +++++------- .../napi/privacy/src/napi_context_common.cpp | 129 ++++++---------- .../privacy/include/napi_context_common.h | 1 - 7 files changed, 228 insertions(+), 384 deletions(-) diff --git a/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp b/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp index 134967a00..363f0319e 100644 --- a/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp @@ -102,28 +102,6 @@ static void NotifyPermStateChanged(RegisterPermStateChangeWorker* registerPermSt napi_call_function(registerPermStateChangeData->env, undefined, callback, 1, &result, &resultOut)); } -static void UvQueueWorkPermStateChanged(uv_work_t* work, int status) -{ - if (work == nullptr || work->data == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Work == nullptr || work->data == nullptr"); - return; - } - std::unique_ptr uvWorkPtr {work}; - RegisterPermStateChangeWorker* registerPermStateChangeData = - reinterpret_cast(work->data); - std::unique_ptr workPtr {registerPermStateChangeData}; - - napi_handle_scope scope = nullptr; - napi_open_handle_scope(registerPermStateChangeData->env, &scope); - if (scope == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Fail to open scope"); - return; - } - NotifyPermStateChanged(registerPermStateChangeData); - napi_close_handle_scope(registerPermStateChangeData->env, scope); - ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkPermStateChanged end"); -}; - static bool IsPermissionFlagValid(uint32_t flag) { ACCESSTOKEN_LOG_DEBUG(LABEL, "Permission flag is %{public}d", flag); @@ -146,42 +124,41 @@ RegisterPermStateChangeScopePtr::~RegisterPermStateChangeScopePtr() void RegisterPermStateChangeScopePtr::PermStateChangeCallback(PermStateChangeInfo& result) { - std::lock_guard lock(validMutex_); - if (!valid_) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Object is invalid."); - return; - } - uv_loop_s* loop = nullptr; - NAPI_CALL_RETURN_VOID(env_, napi_get_uv_event_loop(env_, &loop)); - if (loop == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Loop instance is nullptr"); - return; - } - uv_work_t* work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); - return; - } - std::unique_ptr uvWorkPtr {work}; - RegisterPermStateChangeWorker* registerPermStateChangeWorker = - new (std::nothrow) RegisterPermStateChangeWorker(); + std::unique_ptr registerPermStateChangeWorker = + std::make_unique(); if (registerPermStateChangeWorker == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!"); return; } - std::unique_ptr workPtr {registerPermStateChangeWorker}; registerPermStateChangeWorker->env = env_; registerPermStateChangeWorker->ref = ref_; registerPermStateChangeWorker->result = result; - ACCESSTOKEN_LOG_DEBUG(LABEL, - "result permStateChangeType = %{public}d, tokenID = %{public}d, permissionName = %{public}s", - result.permStateChangeType, result.tokenID, result.permissionName.c_str()); - registerPermStateChangeWorker->subscriber = shared_from_this(); - work->data = reinterpret_cast(registerPermStateChangeWorker); - NAPI_CALL_RETURN_VOID(env_, - uv_queue_work_with_qos(loop, work, [](uv_work_t* work) {}, UvQueueWorkPermStateChanged, uv_qos_default)); - uvWorkPtr.release(); - workPtr.release(); + RegisterPermStateChangeWorker *event = registerPermStateChangeWorker.get(); + auto task = [event]() { + std::shared_ptr context( + static_cast(event), + [](RegisterPermStateChangeWorker* ptr) { + delete ptr; + }); + if (event == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "event == nullptr"); + return; + } + + napi_handle_scope scope = nullptr; + napi_open_handle_scope(event->env, &scope); + if (scope == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Fail to open scope"); + return; + } + NotifyPermStateChanged(event); + napi_close_handle_scope(event->env, scope); + }; + + if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "PermStateChangeCallback: Failed to SendEvent"); + } + registerPermStateChangeWorker.release(); } void RegisterPermStateChangeScopePtr::SetEnv(const napi_env& env) @@ -203,59 +180,34 @@ void RegisterPermStateChangeScopePtr::SetValid(bool valid) PermStateChangeContext::~PermStateChangeContext() {} -void UvQueueWorkDeleteRef(uv_work_t *work, int32_t status) -{ - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Work == nullptr : %{public}d", work == nullptr); - return; - } else if (work->data == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Work->data == nullptr : %{public}d", work->data == nullptr); - return; - } - RegisterPermStateChangeWorker* registerPermStateChangeWorker = - reinterpret_cast(work->data); - if (registerPermStateChangeWorker == nullptr) { - delete work; - return; - } - napi_delete_reference(registerPermStateChangeWorker->env, registerPermStateChangeWorker->ref); - delete registerPermStateChangeWorker; - registerPermStateChangeWorker = nullptr; - delete work; - ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkDeleteRef end"); -} - void RegisterPermStateChangeScopePtr::DeleteNapiRef() { - uv_loop_s* loop = nullptr; - NAPI_CALL_RETURN_VOID(env_, napi_get_uv_event_loop(env_, &loop)); - if (loop == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Loop instance is nullptr"); - return; - } - uv_work_t* work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); - return; - } - - std::unique_ptr uvWorkPtr {work}; - RegisterPermStateChangeWorker* registerPermStateChangeWorker = - new (std::nothrow) RegisterPermStateChangeWorker(); + std::unique_ptr registerPermStateChangeWorker = + std::make_unique(); if (registerPermStateChangeWorker == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!"); return; } - std::unique_ptr workPtr {registerPermStateChangeWorker}; registerPermStateChangeWorker->env = env_; registerPermStateChangeWorker->ref = ref_; + RegisterPermStateChangeWorker *event = registerPermStateChangeWorker.get(); + auto task = [event]() { + std::shared_ptr context( + static_cast(event), + [](RegisterPermStateChangeWorker* ptr) { + delete ptr; + }); + if (event == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "event == nullptr"); + return; + } + napi_delete_reference(event->env, event->ref); + }; - work->data = reinterpret_cast(registerPermStateChangeWorker); - NAPI_CALL_RETURN_VOID(env_, - uv_queue_work_with_qos(loop, work, [](uv_work_t* work) {}, UvQueueWorkDeleteRef, uv_qos_default)); - ACCESSTOKEN_LOG_DEBUG(LABEL, "DeleteNapiRef"); - uvWorkPtr.release(); - workPtr.release(); + if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "DeleteNapiRef: Failed to SendEvent"); + } + registerPermStateChangeWorker.release(); } void NapiAtManager::SetNamedProperty(napi_env env, napi_value dstObj, const int32_t objValue, const char *propName) diff --git a/frameworks/js/napi/accesstoken/src/napi_context_common.cpp b/frameworks/js/napi/accesstoken/src/napi_context_common.cpp index b5f7dd089..73c366e22 100644 --- a/frameworks/js/napi/accesstoken/src/napi_context_common.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_context_common.cpp @@ -83,41 +83,36 @@ AtManagerAsyncWorkData::~AtManagerAsyncWorkData() ACCESSTOKEN_LOG_ERROR(LABEL, "Invalid env"); return; } - std::unique_ptr workPtr = std::make_unique(); std::unique_ptr workDataRel = std::make_unique(); - uv_loop_s *loop = nullptr; - napi_get_uv_event_loop(env, &loop); - if ((loop == nullptr) || (workPtr == nullptr) || (workDataRel == nullptr)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Fail to init execution environment"); + if (workDataRel == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "workDataRel is nullptr"); return; } workDataRel->env = env; workDataRel->work = work; workDataRel->callbackRef = callbackRef; - workPtr->data = reinterpret_cast(workDataRel.get()); - NAPI_CALL_RETURN_VOID(env, uv_queue_work_with_qos(loop, workPtr.get(), [] (uv_work_t *work) {}, - [] (uv_work_t *work, int status) { - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Work is nullptr"); - return; - } - auto workDataRel = reinterpret_cast(work->data); - if (workDataRel == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "WorkDataRel is nullptr"); - delete work; - return; - } - if (workDataRel->work != nullptr) { - napi_delete_async_work(workDataRel->env, workDataRel->work); - } - if (workDataRel->callbackRef != nullptr) { - napi_delete_reference(workDataRel->env, workDataRel->callbackRef); - } - delete workDataRel; - delete work; - }, uv_qos_default)); + AtManagerAsyncWorkDataRel *event = workDataRel.get(); + auto task = [event]() { + std::shared_ptr context( + static_cast(event), + [](AtManagerAsyncWorkDataRel* ptr) { + delete ptr; + }); + if (event == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "event is nullptr"); + return; + } + if (event->work != nullptr) { + napi_delete_async_work(event->env, event->work); + } + if (event->callbackRef != nullptr) { + napi_delete_reference(event->env, event->callbackRef); + } + }; + if (napi_status::napi_ok != napi_send_event(env, task, napi_eprio_immediate)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "AtManagerAsyncWorkData: Failed to SendEvent"); + } workDataRel.release(); - workPtr.release(); } } // namespace AccessToken } // namespace Security diff --git a/frameworks/js/napi/accesstoken/src/napi_request_global_switch_on_setting.cpp b/frameworks/js/napi/accesstoken/src/napi_request_global_switch_on_setting.cpp index 21aa58ac5..a57909002 100644 --- a/frameworks/js/napi/accesstoken/src/napi_request_global_switch_on_setting.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_request_global_switch_on_setting.cpp @@ -127,70 +127,50 @@ static int32_t TransferToJsErrorCode(int32_t errCode) return jsCode; } -static void ResultCallbackJSThreadWorker(uv_work_t* work, int32_t status) -{ - (void)status; - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Uv_queue_work_with_qos input work is nullptr"); - return; - } - std::unique_ptr uvWorkPtr {work}; - SwitchOnSettingResultCallback *retCB = reinterpret_cast(work->data); - if (retCB == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "RetCB is nullptr"); - return; - } - std::unique_ptr callbackPtr {retCB}; - std::shared_ptr asyncContext = retCB->data; - if (asyncContext == nullptr) { - return; - } - - napi_handle_scope scope = nullptr; - napi_open_handle_scope(asyncContext->env, &scope); - if (scope == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Napi_open_handle_scope failed"); - return; - } - napi_value requestResult = nullptr; - NAPI_CALL_RETURN_VOID(asyncContext->env, napi_get_boolean(asyncContext->env, retCB->switchStatus, &requestResult)); - - ReturnPromiseResult(asyncContext->env, retCB->jsCode, asyncContext->deferred, requestResult); - napi_close_handle_scope(asyncContext->env, scope); -} - static void GlobalSwitchResultsCallbackUI(int32_t jsCode, bool switchStatus, std::shared_ptr& data) { - auto* retCB = new (std::nothrow) SwitchOnSettingResultCallback(); + std::unique_ptr retCB = std::make_unique(); if (retCB == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); return; } - - std::unique_ptr callbackPtr {retCB}; retCB->jsCode = jsCode; retCB->switchStatus = switchStatus; retCB->data = data; + SwitchOnSettingResultCallback *event = retCB.get(); + auto task = [event]() { + std::shared_ptr context( + static_cast(event), + [](SwitchOnSettingResultCallback* ptr) { + delete ptr; + }); + if (event == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "event is nullptr"); + return; + } + std::shared_ptr asyncContext = event->data; + if (asyncContext == nullptr) { + return; + } - uv_loop_s* loop = nullptr; - NAPI_CALL_RETURN_VOID(data->env, napi_get_uv_event_loop(data->env, &loop)); - if (loop == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Loop instance is nullptr"); - return; - } - uv_work_t* work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); - return; - } - std::unique_ptr uvWorkPtr {work}; - work->data = reinterpret_cast(retCB); - NAPI_CALL_RETURN_VOID(data->env, uv_queue_work_with_qos( - loop, work, [](uv_work_t* work) {}, ResultCallbackJSThreadWorker, uv_qos_user_initiated)); + napi_handle_scope scope = nullptr; + napi_open_handle_scope(asyncContext->env, &scope); + if (scope == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Napi_open_handle_scope failed"); + return; + } + napi_value requestResult = nullptr; + NAPI_CALL_RETURN_VOID(asyncContext->env, napi_get_boolean(asyncContext->env, event->switchStatus, &requestResult)); - uvWorkPtr.release(); - callbackPtr.release(); + ReturnPromiseResult(asyncContext->env, event->jsCode, asyncContext->deferred, requestResult); + napi_close_handle_scope(asyncContext->env, scope); + }; + + if (napi_status::napi_ok != napi_send_event(data->env, task, napi_eprio_immediate)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "GlobalSwitchResultsCallbackUI: Failed to SendEvent"); + } + retCB.release(); } void SwitchOnSettingUICallback::ReleaseHandler(int32_t code) diff --git a/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp b/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp index add0e5ea5..395318d69 100644 --- a/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp @@ -271,51 +271,6 @@ static napi_value WrapRequestResult(const napi_env& env, const std::vector uvWorkPtr {work}; - ResultCallback *retCB = reinterpret_cast(work->data); - if (retCB == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "RetCB is nullptr"); - return; - } - std::unique_ptr callbackPtr {retCB}; - - int32_t result = JsErrorCode::JS_OK; - if (retCB->data->result != RET_SUCCESS) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Result is: %{public}d", retCB->data->result); - result = RET_FAILED; - } - if (retCB->grantResults.empty()) { - ACCESSTOKEN_LOG_ERROR(LABEL, "GrantResults empty"); - result = RET_FAILED; - } - napi_handle_scope scope = nullptr; - napi_open_handle_scope(retCB->data->env, &scope); - if (scope == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Napi_open_handle_scope failed"); - return; - } - napi_value requestResult = WrapRequestResult( - retCB->data->env, retCB->permissions, retCB->grantResults, retCB->dialogShownResults, retCB->errorReasons); - if (requestResult == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Wrap requestResult failed"); - result = RET_FAILED; - } - - if (retCB->data->deferred != nullptr) { - ReturnPromiseResult(retCB->data->env, result, retCB->data->deferred, requestResult); - } else { - ReturnCallbackResult(retCB->data->env, result, retCB->data->callbackRef, requestResult); - } - napi_close_handle_scope(retCB->data->env, scope); -} - static void UpdateGrantPermissionResultOnly(const std::vector& permissions, const std::vector& grantResults, std::shared_ptr& data, std::vector& newGrantResults) { @@ -333,41 +288,64 @@ static void UpdateGrantPermissionResultOnly(const std::vector& perm static void RequestResultsHandler(const std::vector& permissionList, const std::vector& permissionStates, std::shared_ptr& data) { - auto* retCB = new (std::nothrow) ResultCallback(); + std::unique_ptr retCB = std::make_unique(); if (retCB == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); return; } - - // only permissions which need to grant change the result, other keey as GetSelfPermissionsState result std::vector newGrantResults; UpdateGrantPermissionResultOnly(permissionList, permissionStates, data, newGrantResults); - - std::unique_ptr callbackPtr {retCB}; retCB->permissions = permissionList; retCB->grantResults = newGrantResults; retCB->dialogShownResults = data->dialogShownResults; retCB->errorReasons = data->errorReasons; retCB->data = data; + ResultCallback *event = retCB.get(); + auto task = [event]() { + std::shared_ptr context( + static_cast(event), + [](ResultCallback* ptr) { + delete ptr; + }); + if (event == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "event == nullptr"); + return; + } - uv_loop_s* loop = nullptr; - NAPI_CALL_RETURN_VOID(data->env, napi_get_uv_event_loop(data->env, &loop)); - if (loop == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Loop instance is nullptr"); - return; - } - uv_work_t* work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); - return; - } - std::unique_ptr uvWorkPtr {work}; - work->data = reinterpret_cast(retCB); - NAPI_CALL_RETURN_VOID(data->env, uv_queue_work_with_qos( - loop, work, [](uv_work_t* work) {}, ResultCallbackJSThreadWorker, uv_qos_user_initiated)); + int32_t result = JsErrorCode::JS_OK; + if (event->data->result != RET_SUCCESS) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Result is: %{public}d", event->data->result); + result = RET_FAILED; + } + if (event->grantResults.empty()) { + ACCESSTOKEN_LOG_ERROR(LABEL, "GrantResults empty"); + result = RET_FAILED; + } + napi_handle_scope scope = nullptr; + napi_open_handle_scope(event->data->env, &scope); + if (scope == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Napi_open_handle_scope failed"); + return; + } + napi_value requestResult = WrapRequestResult( + event->data->env, event->permissions, event->grantResults, event->dialogShownResults, event->errorReasons); + if (requestResult == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Wrap requestResult failed"); + result = RET_FAILED; + } - uvWorkPtr.release(); - callbackPtr.release(); + if (event->data->deferred != nullptr) { + ReturnPromiseResult(event->data->env, result, event->data->deferred, requestResult); + } else { + ReturnCallbackResult(event->data->env, result, event->data->callbackRef, requestResult); + } + napi_close_handle_scope(event->data->env, scope); + }; + + if (napi_status::napi_ok != napi_send_event(data->env, task, napi_eprio_immediate)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "RequestResultsHandler: Failed to SendEvent"); + } + retCB.release(); } void AuthorizationResult::GrantResultsCallback(const std::vector& permissionList, diff --git a/frameworks/js/napi/accesstoken/src/napi_request_permission_on_setting.cpp b/frameworks/js/napi/accesstoken/src/napi_request_permission_on_setting.cpp index dc6681668..e9f7406a9 100644 --- a/frameworks/js/napi/accesstoken/src/napi_request_permission_on_setting.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_request_permission_on_setting.cpp @@ -147,74 +147,55 @@ static int32_t TransferToJsErrorCode(int32_t errCode) return jsCode; } -static void ResultCallbackJSThreadWorker(uv_work_t* work, int32_t status) -{ - (void)status; - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Uv_queue_work_with_qos input work is nullptr"); - return; - } - std::unique_ptr uvWorkPtr {work}; - PermissonOnSettingResultCallback *retCB = reinterpret_cast(work->data); - if (retCB == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "RetCB is nullptr"); - return; - } - std::unique_ptr callbackPtr {retCB}; - std::shared_ptr asyncContext = retCB->data; - if (asyncContext == nullptr) { - return; - } - - int32_t result = retCB->jsCode; - napi_handle_scope scope = nullptr; - napi_open_handle_scope(asyncContext->env, &scope); - if (scope == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Napi_open_handle_scope failed"); - return; - } - napi_value requestResult = WrapRequestResult(asyncContext->env, retCB->stateList); - if ((result == JS_OK) && (requestResult == nullptr)) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Wrap requestResult failed"); - result = JS_ERROR_INNER; - } - - ReturnPromiseResult(asyncContext->env, retCB->jsCode, asyncContext->deferred, requestResult); - napi_close_handle_scope(asyncContext->env, scope); -} - static void PermissionResultsCallbackUI(int32_t jsCode, const std::vector stateList, std::shared_ptr& data) { - auto* retCB = new (std::nothrow) PermissonOnSettingResultCallback(); + std::unique_ptr retCB = + std::make_unique(); if (retCB == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); return; } - - std::unique_ptr callbackPtr {retCB}; retCB->jsCode = jsCode; retCB->stateList = stateList; retCB->data = data; + PermissonOnSettingResultCallback *event = retCB.get(); + auto task = [event]() { + std::shared_ptr context( + static_cast(event), + [](PermissonOnSettingResultCallback* ptr) { + delete ptr; + }); + if (event == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "event is nullptr"); + return; + } + std::shared_ptr asyncContext = event->data; + if (asyncContext == nullptr) { + return; + } - uv_loop_s* loop = nullptr; - NAPI_CALL_RETURN_VOID(data->env, napi_get_uv_event_loop(data->env, &loop)); - if (loop == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Loop instance is nullptr"); - return; - } - uv_work_t* work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); - return; - } - std::unique_ptr uvWorkPtr {work}; - work->data = reinterpret_cast(retCB); - NAPI_CALL_RETURN_VOID(data->env, uv_queue_work_with_qos( - loop, work, [](uv_work_t* work) {}, ResultCallbackJSThreadWorker, uv_qos_user_initiated)); + int32_t result = event->jsCode; + napi_handle_scope scope = nullptr; + napi_open_handle_scope(asyncContext->env, &scope); + if (scope == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Napi_open_handle_scope failed"); + return; + } + napi_value requestResult = WrapRequestResult(asyncContext->env, event->stateList); + if ((result == JS_OK) && (requestResult == nullptr)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Wrap requestResult failed"); + result = JS_ERROR_INNER; + } + + ReturnPromiseResult(asyncContext->env, event->jsCode, asyncContext->deferred, requestResult); + napi_close_handle_scope(asyncContext->env, scope); + }; - uvWorkPtr.release(); - callbackPtr.release(); + if (napi_status::napi_ok != napi_send_event(data->env, task, napi_eprio_immediate)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "PermissionResultsCallbackUI: Failed to SendEvent"); + } + retCB.release(); } void PermissonOnSettingUICallback::ReleaseHandler(int32_t code) diff --git a/frameworks/js/napi/privacy/src/napi_context_common.cpp b/frameworks/js/napi/privacy/src/napi_context_common.cpp index 66e29103d..9cbc54790 100644 --- a/frameworks/js/napi/privacy/src/napi_context_common.cpp +++ b/frameworks/js/napi/privacy/src/napi_context_common.cpp @@ -53,59 +53,32 @@ PermActiveStatusPtr::~PermActiveStatusPtr() DeleteNapiRef(); } -void UvQueueWorkDeleteRef(uv_work_t *work, int32_t status) -{ - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Work == nullptr : %{public}d", work == nullptr); - return; - } else if (work->data == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Work->data == nullptr : %{public}d", work->data == nullptr); - return; - } - PermActiveStatusWorker* permActiveStatusWorker = - reinterpret_cast(work->data); - if (permActiveStatusWorker == nullptr) { - delete work; - return; - } - napi_delete_reference(permActiveStatusWorker->env, permActiveStatusWorker->ref); - delete permActiveStatusWorker; - permActiveStatusWorker = nullptr; - delete work; - ACCESSTOKEN_LOG_DEBUG(LABEL, "UvQueueWorkDeleteRef end"); -} - void PermActiveStatusPtr::DeleteNapiRef() { - uv_loop_s* loop = nullptr; - NAPI_CALL_RETURN_VOID(env_, napi_get_uv_event_loop(env_, &loop)); - if (loop == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Loop instance is nullptr"); - return; - } - uv_work_t* work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); - return; - } - - std::unique_ptr uvWorkPtr {work}; - PermActiveStatusWorker* permActiveStatusWorker = - new (std::nothrow) PermActiveStatusWorker(); + std::unique_ptr permActiveStatusWorker = std::make_unique(); if (permActiveStatusWorker == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!"); return; } - std::unique_ptr workPtr {permActiveStatusWorker}; permActiveStatusWorker->env = env_; permActiveStatusWorker->ref = ref_; - - work->data = reinterpret_cast(permActiveStatusWorker); - NAPI_CALL_RETURN_VOID(env_, - uv_queue_work_with_qos(loop, work, [](uv_work_t* work) {}, UvQueueWorkDeleteRef, uv_qos_default)); - ACCESSTOKEN_LOG_DEBUG(LABEL, "DeleteNapiRef"); - uvWorkPtr.release(); - workPtr.release(); + PermActiveStatusWorker *event = permActiveStatusWorker.get(); + auto task = [event]() { + std::shared_ptr context( + static_cast(event), + [](PermActiveStatusWorker* ptr) { + delete ptr; + }); + if (event == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "event == nullptr : %{public}d", event == nullptr); + return; + } + napi_delete_reference(event->env, event->ref); + }; + if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "DeleteNapiRef: Failed to SendEvent"); + } + permActiveStatusWorker.release(); } void PermActiveStatusPtr::SetEnv(const napi_env& env) @@ -120,57 +93,43 @@ void PermActiveStatusPtr::SetCallbackRef(const napi_ref& ref) void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& result) { - uv_loop_s* loop = nullptr; - NAPI_CALL_RETURN_VOID(env_, napi_get_uv_event_loop(env_, &loop)); - if (loop == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Loop instance is nullptr"); - return; - } - uv_work_t* work = new (std::nothrow) uv_work_t; - if (work == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); - return; - } - std::unique_ptr uvWorkPtr {work}; - PermActiveStatusWorker* permActiveStatusWorker = new (std::nothrow) PermActiveStatusWorker(); + std::unique_ptr permActiveStatusWorker = std::make_unique(); if (permActiveStatusWorker == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!"); return; } - std::unique_ptr workPtr {permActiveStatusWorker}; permActiveStatusWorker->env = env_; permActiveStatusWorker->ref = ref_; permActiveStatusWorker->result = result; ACCESSTOKEN_LOG_DEBUG(LABEL, "result: tokenID = %{public}d, permissionName = %{public}s, type = %{public}d", result.tokenID, result.permissionName.c_str(), result.type); - permActiveStatusWorker->subscriber = shared_from_this(); - work->data = reinterpret_cast(permActiveStatusWorker); - NAPI_CALL_RETURN_VOID(env_, - uv_queue_work_with_qos(loop, work, [](uv_work_t* work) {}, UvQueueWorkActiveStatusChange, uv_qos_default)); - uvWorkPtr.release(); - workPtr.release(); -} - -void UvQueueWorkActiveStatusChange(uv_work_t* work, int status) -{ - (void)status; - if (work == nullptr || work->data == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Work == nullptr || work->data == nullptr"); - return; - } - std::unique_ptr uvWorkPtr {work}; - PermActiveStatusWorker* permActiveStatusData = reinterpret_cast(work->data); - std::unique_ptr workPtr {permActiveStatusData}; - - napi_handle_scope scope = nullptr; - napi_open_handle_scope(permActiveStatusData->env, &scope); - if (scope == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Scope is null"); - return; + permActiveStatusWorker->subscriber = shared_from_this(); + PermActiveStatusWorker *event = permActiveStatusWorker.get(); + auto task = [event]() { + std::shared_ptr context( + static_cast(event), + [](PermActiveStatusWorker* ptr) { + delete ptr; + }); + if (event == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "event == nullptr"); + return; + } + napi_handle_scope scope = nullptr; + napi_open_handle_scope(event->env, &scope); + if (scope == nullptr) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Scope is null"); + return; + } + NotifyChangeResponse(event); + napi_close_handle_scope(event->env, scope); + }; + + if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) { + ACCESSTOKEN_LOG_ERROR(LABEL, "ActiveStatusChangeCallback: Failed to SendEvent"); } - NotifyChangeResponse(permActiveStatusData); - napi_close_handle_scope(permActiveStatusData->env, scope); + permActiveStatusWorker.release(); } void NotifyChangeResponse(const PermActiveStatusWorker* permActiveStatusData) diff --git a/interfaces/kits/js/napi/privacy/include/napi_context_common.h b/interfaces/kits/js/napi/privacy/include/napi_context_common.h index 555e084bf..59772dc47 100644 --- a/interfaces/kits/js/napi/privacy/include/napi_context_common.h +++ b/interfaces/kits/js/napi/privacy/include/napi_context_common.h @@ -69,7 +69,6 @@ struct PermActiveChangeContext { std::thread::id threadId_; }; -void UvQueueWorkActiveStatusChange(uv_work_t* work, int status); bool ConvertActiveChangeResponse(napi_env env, napi_value value, const ActiveChangeResponse& result); void NotifyChangeResponse(const PermActiveStatusWorker* permActiveStatusData); } // namespace AccessToken -- Gitee From 67e19e77f4f8d5b10b1b177084ee8ed3ef8e99f5 Mon Sep 17 00:00:00 2001 From: zhaowenli Date: Mon, 23 Dec 2024 17:29:12 +0800 Subject: [PATCH 2/2] =?UTF-8?q?:=E6=A0=BC=E5=BC=8F?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Signed-off-by: zhaowenli Change-Id: I524aac37885cd7f1ace209bf80b36f256b0b8cfa --- .../napi/accesstoken/src/napi_atmanager.cpp | 55 ++++++------------- .../accesstoken/src/napi_context_common.cpp | 26 +++------ .../napi_request_global_switch_on_setting.cpp | 27 +++------ .../src/napi_request_permission.cpp | 39 ++++--------- .../napi_request_permission_on_setting.cpp | 28 +++------- .../napi/privacy/src/napi_context_common.cpp | 50 +++++------------ 6 files changed, 71 insertions(+), 154 deletions(-) diff --git a/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp b/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp index 363f0319e..824192e55 100644 --- a/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp @@ -124,8 +124,12 @@ RegisterPermStateChangeScopePtr::~RegisterPermStateChangeScopePtr() void RegisterPermStateChangeScopePtr::PermStateChangeCallback(PermStateChangeInfo& result) { - std::unique_ptr registerPermStateChangeWorker = - std::make_unique(); + std::lock_guard lock(validMutex_); + if (!valid_) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Object is invalid."); + return; + } + RegisterPermStateChangeWorker* registerPermStateChangeWorker = new (std::nothrow) RegisterPermStateChangeWorker(); if (registerPermStateChangeWorker == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!"); return; @@ -133,32 +137,21 @@ void RegisterPermStateChangeScopePtr::PermStateChangeCallback(PermStateChangeInf registerPermStateChangeWorker->env = env_; registerPermStateChangeWorker->ref = ref_; registerPermStateChangeWorker->result = result; - RegisterPermStateChangeWorker *event = registerPermStateChangeWorker.get(); - auto task = [event]() { - std::shared_ptr context( - static_cast(event), - [](RegisterPermStateChangeWorker* ptr) { - delete ptr; - }); - if (event == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "event == nullptr"); - return; - } - + auto task = [registerPermStateChangeWorker]() { napi_handle_scope scope = nullptr; - napi_open_handle_scope(event->env, &scope); + napi_open_handle_scope(registerPermStateChangeWorker->env, &scope); if (scope == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Fail to open scope"); + delete registerPermStateChangeWorker; return; } - NotifyPermStateChanged(event); - napi_close_handle_scope(event->env, scope); + NotifyPermStateChanged(registerPermStateChangeWorker); + napi_close_handle_scope(registerPermStateChangeWorker->env, scope); + delete registerPermStateChangeWorker; }; - - if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) { + if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_high)) { ACCESSTOKEN_LOG_ERROR(LABEL, "PermStateChangeCallback: Failed to SendEvent"); } - registerPermStateChangeWorker.release(); } void RegisterPermStateChangeScopePtr::SetEnv(const napi_env& env) @@ -182,32 +175,20 @@ PermStateChangeContext::~PermStateChangeContext() void RegisterPermStateChangeScopePtr::DeleteNapiRef() { - std::unique_ptr registerPermStateChangeWorker = - std::make_unique(); + RegisterPermStateChangeWorker* registerPermStateChangeWorker = new (std::nothrow) RegisterPermStateChangeWorker(); if (registerPermStateChangeWorker == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!"); return; } registerPermStateChangeWorker->env = env_; registerPermStateChangeWorker->ref = ref_; - RegisterPermStateChangeWorker *event = registerPermStateChangeWorker.get(); - auto task = [event]() { - std::shared_ptr context( - static_cast(event), - [](RegisterPermStateChangeWorker* ptr) { - delete ptr; - }); - if (event == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "event == nullptr"); - return; - } - napi_delete_reference(event->env, event->ref); + auto task = [registerPermStateChangeWorker]() { + napi_delete_reference(registerPermStateChangeWorker->env, registerPermStateChangeWorker->ref); + delete registerPermStateChangeWorker; }; - - if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) { + if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_high)) { ACCESSTOKEN_LOG_ERROR(LABEL, "DeleteNapiRef: Failed to SendEvent"); } - registerPermStateChangeWorker.release(); } void NapiAtManager::SetNamedProperty(napi_env env, napi_value dstObj, const int32_t objValue, const char *propName) diff --git a/frameworks/js/napi/accesstoken/src/napi_context_common.cpp b/frameworks/js/napi/accesstoken/src/napi_context_common.cpp index 73c366e22..fe097258a 100644 --- a/frameworks/js/napi/accesstoken/src/napi_context_common.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_context_common.cpp @@ -83,7 +83,7 @@ AtManagerAsyncWorkData::~AtManagerAsyncWorkData() ACCESSTOKEN_LOG_ERROR(LABEL, "Invalid env"); return; } - std::unique_ptr workDataRel = std::make_unique(); + AtManagerAsyncWorkDataRel* workDataRel = new (std::nothrow) AtManagerAsyncWorkDataRel(); if (workDataRel == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "workDataRel is nullptr"); return; @@ -91,28 +91,18 @@ AtManagerAsyncWorkData::~AtManagerAsyncWorkData() workDataRel->env = env; workDataRel->work = work; workDataRel->callbackRef = callbackRef; - AtManagerAsyncWorkDataRel *event = workDataRel.get(); - auto task = [event]() { - std::shared_ptr context( - static_cast(event), - [](AtManagerAsyncWorkDataRel* ptr) { - delete ptr; - }); - if (event == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "event is nullptr"); - return; + auto task = [workDataRel]() { + if (workDataRel->work != nullptr) { + napi_delete_async_work(workDataRel->env, workDataRel->work); } - if (event->work != nullptr) { - napi_delete_async_work(event->env, event->work); - } - if (event->callbackRef != nullptr) { - napi_delete_reference(event->env, event->callbackRef); + if (workDataRel->callbackRef != nullptr) { + napi_delete_reference(workDataRel->env, workDataRel->callbackRef); } + delete workDataRel; }; - if (napi_status::napi_ok != napi_send_event(env, task, napi_eprio_immediate)) { + if (napi_status::napi_ok != napi_send_event(env, task, napi_eprio_high)) { ACCESSTOKEN_LOG_ERROR(LABEL, "AtManagerAsyncWorkData: Failed to SendEvent"); } - workDataRel.release(); } } // namespace AccessToken } // namespace Security diff --git a/frameworks/js/napi/accesstoken/src/napi_request_global_switch_on_setting.cpp b/frameworks/js/napi/accesstoken/src/napi_request_global_switch_on_setting.cpp index a57909002..8a0fd781e 100644 --- a/frameworks/js/napi/accesstoken/src/napi_request_global_switch_on_setting.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_request_global_switch_on_setting.cpp @@ -130,7 +130,7 @@ static int32_t TransferToJsErrorCode(int32_t errCode) static void GlobalSwitchResultsCallbackUI(int32_t jsCode, bool switchStatus, std::shared_ptr& data) { - std::unique_ptr retCB = std::make_unique(); + auto* retCB = new (std::nothrow) SwitchOnSettingResultCallback(); if (retCB == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); return; @@ -138,39 +138,30 @@ static void GlobalSwitchResultsCallbackUI(int32_t jsCode, retCB->jsCode = jsCode; retCB->switchStatus = switchStatus; retCB->data = data; - SwitchOnSettingResultCallback *event = retCB.get(); - auto task = [event]() { - std::shared_ptr context( - static_cast(event), - [](SwitchOnSettingResultCallback* ptr) { - delete ptr; - }); - if (event == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "event is nullptr"); - return; - } - std::shared_ptr asyncContext = event->data; + auto task = [retCB]() { + std::shared_ptr asyncContext = retCB->data; if (asyncContext == nullptr) { + delete retCB; return; } - napi_handle_scope scope = nullptr; napi_open_handle_scope(asyncContext->env, &scope); if (scope == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Napi_open_handle_scope failed"); + delete retCB; return; } napi_value requestResult = nullptr; - NAPI_CALL_RETURN_VOID(asyncContext->env, napi_get_boolean(asyncContext->env, event->switchStatus, &requestResult)); + NAPI_CALL_RETURN_VOID(asyncContext->env, + napi_get_boolean(asyncContext->env, retCB->switchStatus, &requestResult)); - ReturnPromiseResult(asyncContext->env, event->jsCode, asyncContext->deferred, requestResult); + ReturnPromiseResult(asyncContext->env, retCB->jsCode, asyncContext->deferred, requestResult); napi_close_handle_scope(asyncContext->env, scope); + delete retCB; }; - if (napi_status::napi_ok != napi_send_event(data->env, task, napi_eprio_immediate)) { ACCESSTOKEN_LOG_ERROR(LABEL, "GlobalSwitchResultsCallbackUI: Failed to SendEvent"); } - retCB.release(); } void SwitchOnSettingUICallback::ReleaseHandler(int32_t code) diff --git a/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp b/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp index 395318d69..0290e9a6f 100644 --- a/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp @@ -288,7 +288,7 @@ static void UpdateGrantPermissionResultOnly(const std::vector& perm static void RequestResultsHandler(const std::vector& permissionList, const std::vector& permissionStates, std::shared_ptr& data) { - std::unique_ptr retCB = std::make_unique(); + auto* retCB = new (std::nothrow) ResultCallback(); if (retCB == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); return; @@ -300,52 +300,37 @@ static void RequestResultsHandler(const std::vector& permissionList retCB->dialogShownResults = data->dialogShownResults; retCB->errorReasons = data->errorReasons; retCB->data = data; - ResultCallback *event = retCB.get(); - auto task = [event]() { - std::shared_ptr context( - static_cast(event), - [](ResultCallback* ptr) { - delete ptr; - }); - if (event == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "event == nullptr"); - return; - } - + auto task = [retCB]() { int32_t result = JsErrorCode::JS_OK; - if (event->data->result != RET_SUCCESS) { - ACCESSTOKEN_LOG_ERROR(LABEL, "Result is: %{public}d", event->data->result); - result = RET_FAILED; - } - if (event->grantResults.empty()) { - ACCESSTOKEN_LOG_ERROR(LABEL, "GrantResults empty"); + if ((retCB->data->result != RET_SUCCESS) || (retCB->grantResults.empty())) { + ACCESSTOKEN_LOG_ERROR(LABEL, "Result is: %{public}d", retCB->data->result); result = RET_FAILED; } napi_handle_scope scope = nullptr; - napi_open_handle_scope(event->data->env, &scope); + napi_open_handle_scope(retCB->data->env, &scope); if (scope == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Napi_open_handle_scope failed"); + delete retCB; return; } napi_value requestResult = WrapRequestResult( - event->data->env, event->permissions, event->grantResults, event->dialogShownResults, event->errorReasons); + retCB->data->env, retCB->permissions, retCB->grantResults, retCB->dialogShownResults, retCB->errorReasons); if (requestResult == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Wrap requestResult failed"); result = RET_FAILED; } - if (event->data->deferred != nullptr) { - ReturnPromiseResult(event->data->env, result, event->data->deferred, requestResult); + if (retCB->data->deferred != nullptr) { + ReturnPromiseResult(retCB->data->env, result, retCB->data->deferred, requestResult); } else { - ReturnCallbackResult(event->data->env, result, event->data->callbackRef, requestResult); + ReturnCallbackResult(retCB->data->env, result, retCB->data->callbackRef, requestResult); } - napi_close_handle_scope(event->data->env, scope); + napi_close_handle_scope(retCB->data->env, scope); + delete retCB; }; - if (napi_status::napi_ok != napi_send_event(data->env, task, napi_eprio_immediate)) { ACCESSTOKEN_LOG_ERROR(LABEL, "RequestResultsHandler: Failed to SendEvent"); } - retCB.release(); } void AuthorizationResult::GrantResultsCallback(const std::vector& permissionList, diff --git a/frameworks/js/napi/accesstoken/src/napi_request_permission_on_setting.cpp b/frameworks/js/napi/accesstoken/src/napi_request_permission_on_setting.cpp index e9f7406a9..db694d69b 100644 --- a/frameworks/js/napi/accesstoken/src/napi_request_permission_on_setting.cpp +++ b/frameworks/js/napi/accesstoken/src/napi_request_permission_on_setting.cpp @@ -150,8 +150,7 @@ static int32_t TransferToJsErrorCode(int32_t errCode) static void PermissionResultsCallbackUI(int32_t jsCode, const std::vector stateList, std::shared_ptr& data) { - std::unique_ptr retCB = - std::make_unique(); + auto* retCB = new (std::nothrow) PermissonOnSettingResultCallback(); if (retCB == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!"); return; @@ -159,43 +158,34 @@ static void PermissionResultsCallbackUI(int32_t jsCode, retCB->jsCode = jsCode; retCB->stateList = stateList; retCB->data = data; - PermissonOnSettingResultCallback *event = retCB.get(); - auto task = [event]() { - std::shared_ptr context( - static_cast(event), - [](PermissonOnSettingResultCallback* ptr) { - delete ptr; - }); - if (event == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "event is nullptr"); - return; - } - std::shared_ptr asyncContext = event->data; + auto task = [retCB]() { + std::shared_ptr asyncContext = retCB->data; if (asyncContext == nullptr) { + delete retCB; return; } - int32_t result = event->jsCode; + int32_t result = retCB->jsCode; napi_handle_scope scope = nullptr; napi_open_handle_scope(asyncContext->env, &scope); if (scope == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Napi_open_handle_scope failed"); + delete retCB; return; } - napi_value requestResult = WrapRequestResult(asyncContext->env, event->stateList); + napi_value requestResult = WrapRequestResult(asyncContext->env, retCB->stateList); if ((result == JS_OK) && (requestResult == nullptr)) { ACCESSTOKEN_LOG_ERROR(LABEL, "Wrap requestResult failed"); result = JS_ERROR_INNER; } - ReturnPromiseResult(asyncContext->env, event->jsCode, asyncContext->deferred, requestResult); + ReturnPromiseResult(asyncContext->env, retCB->jsCode, asyncContext->deferred, requestResult); napi_close_handle_scope(asyncContext->env, scope); + delete retCB; }; - if (napi_status::napi_ok != napi_send_event(data->env, task, napi_eprio_immediate)) { ACCESSTOKEN_LOG_ERROR(LABEL, "PermissionResultsCallbackUI: Failed to SendEvent"); } - retCB.release(); } void PermissonOnSettingUICallback::ReleaseHandler(int32_t code) diff --git a/frameworks/js/napi/privacy/src/napi_context_common.cpp b/frameworks/js/napi/privacy/src/napi_context_common.cpp index 9cbc54790..ee0468f91 100644 --- a/frameworks/js/napi/privacy/src/napi_context_common.cpp +++ b/frameworks/js/napi/privacy/src/napi_context_common.cpp @@ -55,30 +55,20 @@ PermActiveStatusPtr::~PermActiveStatusPtr() void PermActiveStatusPtr::DeleteNapiRef() { - std::unique_ptr permActiveStatusWorker = std::make_unique(); + PermActiveStatusWorker* permActiveStatusWorker = new (std::nothrow) PermActiveStatusWorker(); if (permActiveStatusWorker == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!"); return; } permActiveStatusWorker->env = env_; permActiveStatusWorker->ref = ref_; - PermActiveStatusWorker *event = permActiveStatusWorker.get(); - auto task = [event]() { - std::shared_ptr context( - static_cast(event), - [](PermActiveStatusWorker* ptr) { - delete ptr; - }); - if (event == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "event == nullptr : %{public}d", event == nullptr); - return; - } - napi_delete_reference(event->env, event->ref); + auto task = [permActiveStatusWorker]() { + napi_delete_reference(permActiveStatusWorker->env, permActiveStatusWorker->ref); + delete permActiveStatusWorker; }; - if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) { + if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_high)) { ACCESSTOKEN_LOG_ERROR(LABEL, "DeleteNapiRef: Failed to SendEvent"); - } - permActiveStatusWorker.release(); + } } void PermActiveStatusPtr::SetEnv(const napi_env& env) @@ -93,7 +83,7 @@ void PermActiveStatusPtr::SetCallbackRef(const napi_ref& ref) void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& result) { - std::unique_ptr permActiveStatusWorker = std::make_unique(); + PermActiveStatusWorker* permActiveStatusWorker = new (std::nothrow) PermActiveStatusWorker(); if (permActiveStatusWorker == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!"); return; @@ -104,32 +94,22 @@ void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& resul ACCESSTOKEN_LOG_DEBUG(LABEL, "result: tokenID = %{public}d, permissionName = %{public}s, type = %{public}d", result.tokenID, result.permissionName.c_str(), result.type); - permActiveStatusWorker->subscriber = shared_from_this(); - PermActiveStatusWorker *event = permActiveStatusWorker.get(); - auto task = [event]() { - std::shared_ptr context( - static_cast(event), - [](PermActiveStatusWorker* ptr) { - delete ptr; - }); - if (event == nullptr) { - ACCESSTOKEN_LOG_ERROR(LABEL, "event == nullptr"); - return; - } + permActiveStatusWorker->subscriber = shared_from_this(); + auto task = [permActiveStatusWorker]() { napi_handle_scope scope = nullptr; - napi_open_handle_scope(event->env, &scope); + napi_open_handle_scope(permActiveStatusWorker->env, &scope); if (scope == nullptr) { ACCESSTOKEN_LOG_ERROR(LABEL, "Scope is null"); + delete permActiveStatusWorker; return; } - NotifyChangeResponse(event); - napi_close_handle_scope(event->env, scope); + NotifyChangeResponse(permActiveStatusWorker); + napi_close_handle_scope(permActiveStatusWorker->env, scope); + delete permActiveStatusWorker; }; - - if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_immediate)) { + if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_high)) { ACCESSTOKEN_LOG_ERROR(LABEL, "ActiveStatusChangeCallback: Failed to SendEvent"); } - permActiveStatusWorker.release(); } void NotifyChangeResponse(const PermActiveStatusWorker* permActiveStatusData) -- Gitee