diff --git a/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp b/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp
index 03816cfa7cb3a307abe01223e532ae8422d6bd82..eeb19032c55ab4fd2b17a228bab8bb56de1217e8 100644
--- a/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp
+++ b/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp
@@ -107,28 +107,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<uv_work_t> uvWorkPtr {work};
-    RegisterPermStateChangeWorker* registerPermStateChangeData =
-        reinterpret_cast<RegisterPermStateChangeWorker*>(work->data);
-    std::unique_ptr<RegisterPermStateChangeWorker> 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);
@@ -156,20 +134,7 @@ void RegisterPermStateChangeScopePtr::PermStateChangeCallback(PermStateChangeInf
         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<uv_work_t> uvWorkPtr {work};
-    RegisterPermStateChangeWorker* registerPermStateChangeWorker =
-        new (std::nothrow) RegisterPermStateChangeWorker();
+    RegisterPermStateChangeWorker* registerPermStateChangeWorker = new (std::nothrow) RegisterPermStateChangeWorker();
     if (registerPermStateChangeWorker == nullptr) {
         ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!");
         return;
@@ -178,15 +143,23 @@ void RegisterPermStateChangeScopePtr::PermStateChangeCallback(PermStateChangeInf
     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<void *>(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();
+    auto task = [registerPermStateChangeWorker]() {
+        napi_handle_scope scope = nullptr;
+        napi_open_handle_scope(registerPermStateChangeWorker->env, &scope);
+        if (scope == nullptr) {
+            ACCESSTOKEN_LOG_ERROR(LABEL, "Fail to open scope");
+            delete registerPermStateChangeWorker;
+            return;
+        }
+        NotifyPermStateChanged(registerPermStateChangeWorker);
+        napi_close_handle_scope(registerPermStateChangeWorker->env, scope);
+        delete registerPermStateChangeWorker;
+    };
+    if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_high)) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "PermStateChangeCallback: Failed to SendEvent");
+    } else {
+        workPtr.release();
+    }
 }
 
 void RegisterPermStateChangeScopePtr::SetEnv(const napi_env& env)
@@ -208,45 +181,9 @@ 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<RegisterPermStateChangeWorker*>(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<uv_work_t> uvWorkPtr {work};
-    RegisterPermStateChangeWorker* registerPermStateChangeWorker =
-        new (std::nothrow) RegisterPermStateChangeWorker();
+    RegisterPermStateChangeWorker* registerPermStateChangeWorker = new (std::nothrow) RegisterPermStateChangeWorker();
     if (registerPermStateChangeWorker == nullptr) {
         ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!");
         return;
@@ -254,13 +191,15 @@ void RegisterPermStateChangeScopePtr::DeleteNapiRef()
     std::unique_ptr<RegisterPermStateChangeWorker> workPtr {registerPermStateChangeWorker};
     registerPermStateChangeWorker->env = env_;
     registerPermStateChangeWorker->ref = ref_;
-
-    work->data = reinterpret_cast<void *>(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();
+    auto task = [registerPermStateChangeWorker]() {
+        napi_delete_reference(registerPermStateChangeWorker->env, registerPermStateChangeWorker->ref);
+        delete registerPermStateChangeWorker;
+    };
+    if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_high)) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "DeleteNapiRef: Failed to SendEvent");
+    } else {
+        workPtr.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 b5f7dd089f81528e5855efda0747251274b14b39..9b93663be6ab27e32b62617c75d7122a4df23e42 100644
--- a/frameworks/js/napi/accesstoken/src/napi_context_common.cpp
+++ b/frameworks/js/napi/accesstoken/src/napi_context_common.cpp
@@ -83,41 +83,29 @@ AtManagerAsyncWorkData::~AtManagerAsyncWorkData()
         ACCESSTOKEN_LOG_ERROR(LABEL, "Invalid env");
         return;
     }
-    std::unique_ptr<uv_work_t> workPtr = std::make_unique<uv_work_t>();
-    std::unique_ptr<AtManagerAsyncWorkDataRel> workDataRel = std::make_unique<AtManagerAsyncWorkDataRel>();
-    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");
+    AtManagerAsyncWorkDataRel* workDataRel = new (std::nothrow) AtManagerAsyncWorkDataRel();
+    if (workDataRel == nullptr) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "workDataRel is nullptr");
         return;
     }
+    std::unique_ptr<AtManagerAsyncWorkDataRel> workDataRelPtr {workDataRel};
     workDataRel->env = env;
     workDataRel->work = work;
     workDataRel->callbackRef = callbackRef;
-    workPtr->data = reinterpret_cast<void *>(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<AtManagerAsyncWorkDataRel *>(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));
-    workDataRel.release();
-    workPtr.release();
+    auto task = [workDataRel]() {
+        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;
+    };
+    if (napi_status::napi_ok != napi_send_event(env, task, napi_eprio_high)) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "AtManagerAsyncWorkData: Failed to SendEvent");
+    } else {
+        workDataRelPtr.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 21aa58ac586e7529e7e4afd5048e37cc9ed34e54..988d07d91153ade1b007084282d17c9590d83b9e 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,38 +127,6 @@ 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<uv_work_t> uvWorkPtr {work};
-    SwitchOnSettingResultCallback *retCB = reinterpret_cast<SwitchOnSettingResultCallback*>(work->data);
-    if (retCB == nullptr) {
-        ACCESSTOKEN_LOG_ERROR(LABEL, "RetCB is nullptr");
-        return;
-    }
-    std::unique_ptr<SwitchOnSettingResultCallback> callbackPtr {retCB};
-    std::shared_ptr<RequestGlobalSwitchAsyncContext> 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<RequestGlobalSwitchAsyncContext>& data)
 {
@@ -167,30 +135,34 @@ static void GlobalSwitchResultsCallbackUI(int32_t jsCode,
         ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for work!");
         return;
     }
-
     std::unique_ptr<SwitchOnSettingResultCallback> callbackPtr {retCB};
     retCB->jsCode = jsCode;
     retCB->switchStatus = switchStatus;
     retCB->data = data;
+    auto task = [retCB]() {
+        std::unique_ptr<SwitchOnSettingResultCallback> callback {retCB};
+        std::shared_ptr<RequestGlobalSwitchAsyncContext> 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));
 
-    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;
+        ReturnPromiseResult(asyncContext->env, retCB->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");
+    } else {
+        callbackPtr.release();
     }
-    std::unique_ptr<uv_work_t> uvWorkPtr {work};
-    work->data = reinterpret_cast<void *>(retCB);
-    NAPI_CALL_RETURN_VOID(data->env, uv_queue_work_with_qos(
-        loop, work, [](uv_work_t* work) {}, ResultCallbackJSThreadWorker, uv_qos_user_initiated));
-
-    uvWorkPtr.release();
-    callbackPtr.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 72b3ef84b02a5d947e36d761db78b2eabf5eca10..efa139f4c8a304679b139e540ee9e9db5fd31b54 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<std::
     return result;
 }
 
-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<uv_work_t> uvWorkPtr {work};
-    ResultCallback *retCB = reinterpret_cast<ResultCallback*>(work->data);
-    if (retCB == nullptr) {
-        ACCESSTOKEN_LOG_ERROR(LABEL, "RetCB is nullptr");
-        return;
-    }
-    std::unique_ptr<ResultCallback> 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<std::string>& permissions,
     const std::vector<int>& grantResults, std::shared_ptr<RequestAsyncContext>& data, std::vector<int>& newGrantResults)
 {
@@ -338,8 +293,6 @@ static void RequestResultsHandler(const std::vector<std::string>& permissionList
         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<int> newGrantResults;
     UpdateGrantPermissionResultOnly(permissionList, permissionStates, data, newGrantResults);
 
@@ -349,25 +302,39 @@ static void RequestResultsHandler(const std::vector<std::string>& permissionList
     retCB->dialogShownResults = data->dialogShownResults;
     retCB->errorReasons = data->errorReasons;
     retCB->data = data;
+    auto task = [retCB]() {
+        int32_t result = JsErrorCode::JS_OK;
+        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(retCB->data->env, &scope);
+        if (scope == nullptr) {
+            ACCESSTOKEN_LOG_ERROR(LABEL, "Napi_open_handle_scope failed");
+            delete retCB;
+            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;
+        }
 
-    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;
+        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);
+        delete retCB;
+    };
+    if (napi_status::napi_ok != napi_send_event(data->env, task, napi_eprio_immediate)) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "RequestResultsHandler: Failed to SendEvent");
+    } else {
+        callbackPtr.release();
     }
-    std::unique_ptr<uv_work_t> uvWorkPtr {work};
-    work->data = reinterpret_cast<void *>(retCB);
-    NAPI_CALL_RETURN_VOID(data->env, uv_queue_work_with_qos(
-        loop, work, [](uv_work_t* work) {}, ResultCallbackJSThreadWorker, uv_qos_user_initiated));
-
-    uvWorkPtr.release();
-    callbackPtr.release();
 }
 
 void AuthorizationResult::GrantResultsCallback(const std::vector<std::string>& 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 dc66816689b40a23ff533a5b68711f2f5d8e11df..9f6bf6b336ca204a324378b52ebe0efa762d0105 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,42 +147,6 @@ 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<uv_work_t> uvWorkPtr {work};
-    PermissonOnSettingResultCallback *retCB = reinterpret_cast<PermissonOnSettingResultCallback*>(work->data);
-    if (retCB == nullptr) {
-        ACCESSTOKEN_LOG_ERROR(LABEL, "RetCB is nullptr");
-        return;
-    }
-    std::unique_ptr<PermissonOnSettingResultCallback> callbackPtr {retCB};
-    std::shared_ptr<RequestPermOnSettingAsyncContext> 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<int32_t> stateList, std::shared_ptr<RequestPermOnSettingAsyncContext>& data)
 {
@@ -196,25 +160,36 @@ static void PermissionResultsCallbackUI(int32_t jsCode,
     retCB->jsCode = jsCode;
     retCB->stateList = stateList;
     retCB->data = data;
+    auto task = [retCB]() {
+        std::shared_ptr<RequestPermOnSettingAsyncContext> asyncContext = retCB->data;
+        if (asyncContext == nullptr) {
+            delete retCB;
+            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<uv_work_t> uvWorkPtr {work};
-    work->data = reinterpret_cast<void *>(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 = 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, retCB->stateList);
+        if ((result == JS_OK) && (requestResult == nullptr)) {
+            ACCESSTOKEN_LOG_ERROR(LABEL, "Wrap requestResult failed");
+            result = JS_ERROR_INNER;
+        }
 
-    uvWorkPtr.release();
-    callbackPtr.release();
+        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");
+    } else {
+        callbackPtr.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 66e29103d9a8bf1274bfcfa043c75b008459aedf..d6e819c1f6160e8a02b11329001bcd53c7407f0f 100644
--- a/frameworks/js/napi/privacy/src/napi_context_common.cpp
+++ b/frameworks/js/napi/privacy/src/napi_context_common.cpp
@@ -53,45 +53,9 @@ 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<PermActiveStatusWorker*>(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<uv_work_t> uvWorkPtr {work};
-    PermActiveStatusWorker* permActiveStatusWorker =
-        new (std::nothrow) PermActiveStatusWorker();
+    PermActiveStatusWorker* permActiveStatusWorker = new (std::nothrow) PermActiveStatusWorker();
     if (permActiveStatusWorker == nullptr) {
         ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!");
         return;
@@ -99,13 +63,15 @@ void PermActiveStatusPtr::DeleteNapiRef()
     std::unique_ptr<PermActiveStatusWorker> workPtr {permActiveStatusWorker};
     permActiveStatusWorker->env = env_;
     permActiveStatusWorker->ref = ref_;
-
-    work->data = reinterpret_cast<void *>(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();
+    auto task = [permActiveStatusWorker]() {
+        napi_delete_reference(permActiveStatusWorker->env, permActiveStatusWorker->ref);
+        delete permActiveStatusWorker;
+    };
+    if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_high)) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "DeleteNapiRef: Failed to SendEvent");
+    } else {
+        workPtr.release();
+    }
 }
 
 void PermActiveStatusPtr::SetEnv(const napi_env& env)
@@ -120,18 +86,6 @@ 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<uv_work_t> uvWorkPtr {work};
     PermActiveStatusWorker* permActiveStatusWorker = new (std::nothrow) PermActiveStatusWorker();
     if (permActiveStatusWorker == nullptr) {
         ACCESSTOKEN_LOG_ERROR(LABEL, "Insufficient memory for RegisterPermStateChangeWorker!");
@@ -145,32 +99,23 @@ void PermActiveStatusPtr::ActiveStatusChangeCallback(ActiveChangeResponse& resul
         "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<void *>(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<uv_work_t> uvWorkPtr {work};
-    PermActiveStatusWorker* permActiveStatusData = reinterpret_cast<PermActiveStatusWorker*>(work->data);
-    std::unique_ptr<PermActiveStatusWorker> 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;
+    auto task = [permActiveStatusWorker]() {
+        napi_handle_scope scope = nullptr;
+        napi_open_handle_scope(permActiveStatusWorker->env, &scope);
+        if (scope == nullptr) {
+            ACCESSTOKEN_LOG_ERROR(LABEL, "Scope is null");
+            delete permActiveStatusWorker;
+            return;
+        }
+        NotifyChangeResponse(permActiveStatusWorker);
+        napi_close_handle_scope(permActiveStatusWorker->env, scope);
+        delete permActiveStatusWorker;
+    };
+    if (napi_status::napi_ok != napi_send_event(env_, task, napi_eprio_high)) {
+        ACCESSTOKEN_LOG_ERROR(LABEL, "ActiveStatusChangeCallback: Failed to SendEvent");
+    } else {
+        workPtr.release();
     }
-    NotifyChangeResponse(permActiveStatusData);
-    napi_close_handle_scope(permActiveStatusData->env, scope);
 }
 
 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 555e084bff3fc819977da7e0967194d2e4c4c639..59772dc473b7295745b1f9ba3b7e9d15a5f89cff 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