diff --git a/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp b/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp
index 3eecddd8759b81070cbc178f0a74919472bdb312..10f65a958dbd307d9223ca1084707fbdf1e0b79a 100644
--- a/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp
+++ b/frameworks/js/napi/accesstoken/src/napi_atmanager.cpp
@@ -46,23 +46,23 @@ static const char* REGISTER_SELF_PERMISSION_STATE_CHANGE_TYPE = "selfPermissionS
 constexpr uint32_t THIRD_PARAM = 2;
 constexpr uint32_t FORTH_PARAM = 3;
 
-static void ReturnPromiseResult(napi_env env, int32_t contextResult, napi_deferred deferred, napi_value result)
+static void ReturnPromiseResult(napi_env env, const AtManagerAsyncContext& context, napi_value result)
 {
-    if (contextResult != RET_SUCCESS) {
-        int32_t jsCode = NapiContextCommon::GetJsErrorCode(contextResult);
-        napi_value businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode));
-        NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, deferred, businessError));
+    if (context.errorCode != RET_SUCCESS) {
+        int32_t jsCode = NapiContextCommon::GetJsErrorCode(context.errorCode);
+        napi_value businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode, context.extErrorMsg));
+        NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, context.deferred, businessError));
     } else {
-        NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, deferred, result));
+        NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, context.deferred, result));
     }
 }
 
-static void ReturnCallbackResult(napi_env env, int32_t contextResult, napi_ref &callbackRef, napi_value result)
+static void ReturnCallbackResult(napi_env env, const AtManagerAsyncContext& context, napi_value result)
 {
     napi_value businessError = GetNapiNull(env);
-    if (contextResult != RET_SUCCESS) {
-        int32_t jsCode = NapiContextCommon::GetJsErrorCode(contextResult);
-        businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode));
+    if (context.errorCode != RET_SUCCESS) {
+        int32_t jsCode = NapiContextCommon::GetJsErrorCode(context.errorCode);
+        businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode, context.extErrorMsg));
     }
     napi_value results[ASYNC_CALL_BACK_VALUES_NUM] = { businessError, result };
 
@@ -71,7 +71,7 @@ static void ReturnCallbackResult(napi_env env, int32_t contextResult, napi_ref &
     napi_value thatValue = nullptr;
     NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &thisValue));
     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, 0, &thatValue));
-    NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, callbackRef, &callback));
+    NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, context.callbackRef, &callback));
     NAPI_CALL_RETURN_VOID(env,
         napi_call_function(env, thisValue, callback, ASYNC_CALL_BACK_VALUES_NUM, results, &thatValue));
 }
@@ -342,7 +342,7 @@ bool NapiAtManager::ParseInputVerifyPermissionOrGetFlag(const napi_env env, cons
     asyncContext.env = env;
     // 0: the first parameter of argv
     if (!ParseUint32(env, argv[0], asyncContext.tokenId)) {
-        errMsg = GetParamErrorMsg("tokenId", "number");
+        errMsg = GetParamErrorMsg("tokenID", "number");
         NAPI_CALL_BASE(env,
             napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)), false);
         return false;
@@ -379,7 +379,7 @@ bool NapiAtManager::ParseInputVerifyPermissionSync(const napi_env env, const nap
     syncContext.env = env;
     // 0: the first parameter of argv
     if (!ParseUint32(env, argv[0], syncContext.tokenId)) {
-        errMsg = GetParamErrorMsg("tokenId", "number");
+        errMsg = GetParamErrorMsg("tokenID", "number");
         NAPI_CALL_BASE(env,
             napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)), false);
         return false;
@@ -473,11 +473,13 @@ void NapiAtManager::CheckAccessTokenExecute(napi_env env, void *data)
     }
     if (asyncContext->tokenId == 0) {
         asyncContext->errorCode = JS_ERROR_PARAM_INVALID;
+        asyncContext->extErrorMsg = "The tokenID is 0.";
         return;
     }
     if ((asyncContext->permissionName.empty()) ||
         ((asyncContext->permissionName.length() > NapiContextCommon::MAX_LENGTH))) {
         asyncContext->errorCode = JS_ERROR_PARAM_INVALID;
+        asyncContext->extErrorMsg = "The permission name is empty or exceeds 256 characters.";
         return;
     }
     AccessTokenIDEx selfTokenIdEx = {GetSelfTokenID()};
@@ -503,7 +505,7 @@ void NapiAtManager::CheckAccessTokenComplete(napi_env env, napi_status status, v
 
     napi_value result = nullptr;
     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncContext->result, &result));
-    ReturnPromiseResult(env, asyncContext->errorCode, asyncContext->deferred, result);
+    ReturnPromiseResult(env, *asyncContext, result);
 }
 
 napi_value NapiAtManager::CheckAccessToken(napi_env env, napi_callback_info info)
@@ -608,14 +610,15 @@ napi_value NapiAtManager::VerifyAccessTokenSync(napi_env env, napi_callback_info
         return nullptr;
     }
     if (syncContext->tokenId == 0) {
-        std::string errMsg = GetParamErrorMsg("tokenID", "number");
+        std::string errMsg = GetErrorMessage(JS_ERROR_PARAM_INVALID, "The tokenID is 0.");
         NAPI_CALL(env, napi_throw(env, GenerateBusinessError(env, JS_ERROR_PARAM_INVALID, errMsg)));
         return nullptr;
     }
     if ((syncContext->permissionName.empty()) ||
         ((syncContext->permissionName.length() > NapiContextCommon::MAX_LENGTH))) {
-        std::string errMsg = GetParamErrorMsg("permissionName", "Permissions");
-        NAPI_CALL(env, napi_throw(env, GenerateBusinessError(env, JS_ERROR_PARAM_INVALID, errMsg)));
+            std::string errMsg = GetErrorMessage(
+                JS_ERROR_PARAM_INVALID, "The permissionName is empty or exceeds 256 characters.");
+            NAPI_CALL(env, napi_throw(env, GenerateBusinessError(env, JS_ERROR_PARAM_INVALID, errMsg)));
         return nullptr;
     }
     if (syncContext->tokenId != static_cast<AccessTokenID>(selfTokenId)) {
@@ -658,7 +661,7 @@ bool NapiAtManager::ParseInputGrantOrRevokePermission(const napi_env env, const
     std::string errMsg;
     // 0: the first parameter of argv
     if (!ParseUint32(env, argv[0], asyncContext.tokenId)) {
-        errMsg = GetParamErrorMsg("tokenId", "number");
+        errMsg = GetParamErrorMsg("tokenID", "number");
         NAPI_CALL_BASE(
             env, napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)), false);
         return false;
@@ -740,9 +743,9 @@ void NapiAtManager::GrantUserGrantedPermissionComplete(napi_env env, napi_status
     napi_value result = GetNapiNull(env);
 
     if (context->deferred != nullptr) {
-        ReturnPromiseResult(env, context->result, context->deferred, result);
+        ReturnPromiseResult(env, *context, result);
     } else {
-        ReturnCallbackResult(env, context->result, context->callbackRef, result);
+        ReturnCallbackResult(env, *context, result);
     }
 }
 
@@ -796,7 +799,7 @@ void NapiAtManager::GetVersionComplete(napi_env env, napi_status status, void *d
     LOGD(ATM_DOMAIN, ATM_TAG, "Version result = %{public}d.", asyncContext->result);
 
     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncContext->result, &result));
-    ReturnPromiseResult(env, asyncContext->errorCode, asyncContext->deferred, result);
+    ReturnPromiseResult(env, *asyncContext, result);
 }
 
 napi_value NapiAtManager::GrantUserGrantedPermission(napi_env env, napi_callback_info info)
@@ -883,9 +886,9 @@ void NapiAtManager::RevokeUserGrantedPermissionComplete(napi_env env, napi_statu
 
     napi_value result = GetNapiNull(env);
     if (asyncContext->deferred != nullptr) {
-        ReturnPromiseResult(env, asyncContext->result, asyncContext->deferred, result);
+        ReturnPromiseResult(env, *asyncContext, result);
     } else {
-        ReturnCallbackResult(env, asyncContext->result, asyncContext->callbackRef, result);
+        ReturnCallbackResult(env, *asyncContext, result);
     }
 }
 
@@ -941,7 +944,7 @@ void NapiAtManager::GetPermissionFlagsComplete(napi_env env, napi_status status,
     napi_value result = nullptr;
     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncContext->flag, &result));
 
-    ReturnPromiseResult(env, asyncContext->result, asyncContext->deferred, result);
+    ReturnPromiseResult(env, *asyncContext, result);
 }
 
 napi_value NapiAtManager::GetPermissionFlags(napi_env env, napi_callback_info info)
@@ -1054,7 +1057,7 @@ void NapiAtManager::SetPermissionRequestToggleStatusComplete(napi_env env, napi_
     napi_value result = nullptr;
     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncContext->result, &result));
 
-    ReturnPromiseResult(env, asyncContext->result, asyncContext->deferred, result);
+    ReturnPromiseResult(env, *asyncContext, result);
 }
 
 void NapiAtManager::GetPermissionRequestToggleStatusExecute(napi_env env, void *data)
@@ -1073,7 +1076,7 @@ void NapiAtManager::GetPermissionRequestToggleStatusComplete(napi_env env, napi_
     napi_value result = nullptr;
     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, asyncContext->status, &result));
 
-    ReturnPromiseResult(env, asyncContext->result, asyncContext->deferred, result);
+    ReturnPromiseResult(env, *asyncContext, result);
 }
 
 napi_value NapiAtManager::SetPermissionRequestToggleStatus(napi_env env, napi_callback_info info)
@@ -1198,7 +1201,7 @@ void NapiAtManager::RequestAppPermOnSettingComplete(napi_env env, napi_status st
     std::unique_ptr<AtManagerAsyncContext> callbackPtr {asyncContext};
 
     napi_value result = GetNapiNull(env);
-    ReturnPromiseResult(env, asyncContext->result, asyncContext->deferred, result);
+    ReturnPromiseResult(env, *asyncContext, result);
 }
 
 napi_value NapiAtManager::RequestAppPermOnSetting(napi_env env, napi_callback_info info)
@@ -1289,7 +1292,8 @@ napi_value NapiAtManager::GetSelfPermissionStatusSync(napi_env env, napi_callbac
 
     if ((syncContext->permissionName.empty()) ||
         ((syncContext->permissionName.length() > NapiContextCommon::MAX_LENGTH))) {
-        std::string errMsg = "Invalid parameter. The permissionName is empty or exceeds 256 characters.";
+        std::string errMsg = GetErrorMessage(
+            JS_ERROR_PARAM_INVALID, "The permissionName is empty or exceeds 256 characters.");
         NAPI_CALL(env, napi_throw(env, GenerateBusinessError(env, JS_ERROR_PARAM_INVALID, errMsg)));
         return nullptr;
     }
@@ -1424,13 +1428,14 @@ napi_value NapiAtManager::RegisterPermStateChangeCallback(napi_env env, napi_cal
         return nullptr;
     }
     if (IsExistRegister(env, registerPermStateChangeInfo)) {
-        LOGE(ATM_DOMAIN, ATM_TAG, "Subscribe failed. The current subscriber has been existed");
+        LOGE(ATM_DOMAIN, ATM_TAG, "Subscribe failed. The current subscriber has been existed.");
+        std::string errMsg = "The API reuses the same input. The subscriber already exists.";
         if (registerPermStateChangeInfo->permStateChangeType == REGISTER_SELF_PERMISSION_STATE_CHANGE_TYPE) {
-            std::string errMsg = GetErrorMessage(JsErrorCode::JS_ERROR_NOT_USE_TOGETHER);
             NAPI_CALL(env, napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_NOT_USE_TOGETHER, errMsg)));
         } else {
-            std::string errMsg = GetErrorMessage(JsErrorCode::JS_ERROR_PARAM_INVALID);
-            NAPI_CALL(env, napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_INVALID, errMsg)));
+            std::string errMsgFull = GetErrorMessage(JS_ERROR_PARAM_INVALID, errMsg);
+            NAPI_CALL(env,
+                napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_INVALID, errMsgFull)));
         }
         return nullptr;
     }
@@ -1526,14 +1531,14 @@ napi_value NapiAtManager::UnregisterPermStateChangeCallback(napi_env env, napi_c
     std::vector<RegisterPermStateChangeInfo*> batchPermStateChangeRegisters;
     if (!FindAndGetSubscriberInVector(unregisterPermStateChangeInfo, batchPermStateChangeRegisters, env)) {
         LOGE(ATM_DOMAIN, ATM_TAG, "Unsubscribe failed. The current subscriber does not exist");
+        std::string errMsg = "The API is not used in pair with 'on'. The subscriber does not exist.";
         if (unregisterPermStateChangeInfo->permStateChangeType == REGISTER_SELF_PERMISSION_STATE_CHANGE_TYPE) {
-            std::string errMsg = GetErrorMessage(JsErrorCode::JS_ERROR_NOT_USE_TOGETHER);
             NAPI_CALL(env,
                 napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_NOT_USE_TOGETHER, errMsg)));
         } else {
-            std::string errMsg = GetErrorMessage(JsErrorCode::JS_ERROR_PARAM_INVALID);
+            std::string errMsgFull = GetErrorMessage(JS_ERROR_PARAM_INVALID, errMsg);
             NAPI_CALL(env,
-                napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_INVALID, errMsg)));
+                napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_INVALID, errMsgFull)));
         }
         return nullptr;
     }
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 ceb3fe322ea03abf61a6d299d83452887cd1cc35..981c13fb29987495dc425922d885a5c93e1568b1 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
@@ -40,13 +40,37 @@ const int32_t GLOBAL_TYPE_IS_NOT_SUPPORT = 2;
 const int32_t SWITCH_IS_ALREADY_OPEN = 3;
 std::mutex g_lockFlag;
 } // namespace
-static void ReturnPromiseResult(napi_env env, int32_t jsCode, napi_deferred deferred, napi_value result)
+static int32_t TransferToJsErrorCode(int32_t errCode)
 {
-    if (jsCode != JS_OK) {
-        napi_value businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode));
-        NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, deferred, businessError));
+    int32_t jsCode = JS_ERROR_INNER;
+    switch (errCode) {
+        case RET_SUCCESS:
+            jsCode = JS_OK;
+            break;
+        case REQUEST_REALDY_EXIST:
+            jsCode = JS_ERROR_REQUEST_IS_ALREADY_EXIST;
+            break;
+        case GLOBAL_TYPE_IS_NOT_SUPPORT:
+            jsCode = JS_ERROR_PARAM_INVALID;
+            break;
+        case SWITCH_IS_ALREADY_OPEN:
+            jsCode = JS_ERROR_GLOBAL_SWITCH_IS_ALREADY_OPEN;
+            break;
+        default:
+            break;
+    }
+    LOGI(ATM_DOMAIN, ATM_TAG, "Dialog error(%{public}d) jsCode(%{public}d).", errCode, jsCode);
+    return jsCode;
+}
+
+static void ReturnPromiseResult(napi_env env, const RequestGlobalSwitchAsyncContext& context, napi_value result)
+{
+    if (context.result.errorCode != RET_SUCCESS) {
+        int32_t jsCode = TransferToJsErrorCode(context.result.errorCode);
+        napi_value businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode, context.result.errorMsg));
+        NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, context.deferred, businessError));
     } else {
-        NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, deferred, result));
+        NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, context.deferred, result));
     }
 }
 
@@ -102,32 +126,7 @@ static napi_value GetContext(
     }
 }
 
-
-static int32_t TransferToJsErrorCode(int32_t errCode)
-{
-    int32_t jsCode = JS_OK;
-    switch (errCode) {
-        case RET_SUCCESS:
-            jsCode = JS_OK;
-            break;
-        case REQUEST_REALDY_EXIST:
-            jsCode = JS_ERROR_REQUEST_IS_ALREADY_EXIST;
-            break;
-        case GLOBAL_TYPE_IS_NOT_SUPPORT:
-            jsCode = JS_ERROR_PARAM_INVALID;
-            break;
-        case SWITCH_IS_ALREADY_OPEN:
-            jsCode = JS_ERROR_GLOBAL_SWITCH_IS_ALREADY_OPEN;
-            break;
-        default:
-            jsCode = JS_ERROR_INNER;
-            break;
-    }
-    LOGI(ATM_DOMAIN, ATM_TAG, "dialog error(%{public}d) jsCode(%{public}d).", errCode, jsCode);
-    return jsCode;
-}
-
-static void GlobalSwitchResultsCallbackUI(int32_t jsCode,
+static void GlobalSwitchResultsCallbackUI(int32_t errorCode,
     bool switchStatus, std::shared_ptr<RequestGlobalSwitchAsyncContext>& data)
 {
     auto* retCB = new (std::nothrow) SwitchOnSettingResultCallback();
@@ -136,7 +135,7 @@ static void GlobalSwitchResultsCallbackUI(int32_t jsCode,
         return;
     }
     std::unique_ptr<SwitchOnSettingResultCallback> callbackPtr {retCB};
-    retCB->jsCode = jsCode;
+    retCB->errorCode = errorCode;
     retCB->switchStatus = switchStatus;
     retCB->data = data;
     auto task = [retCB]() {
@@ -145,6 +144,7 @@ static void GlobalSwitchResultsCallbackUI(int32_t jsCode,
         if (asyncContext == nullptr) {
             return;
         }
+        asyncContext->result.errorCode = retCB->errorCode;
         napi_handle_scope scope = nullptr;
         napi_open_handle_scope(asyncContext->env, &scope);
         if (scope == nullptr) {
@@ -155,7 +155,7 @@ static void GlobalSwitchResultsCallbackUI(int32_t jsCode,
         NAPI_CALL_RETURN_VOID(asyncContext->env,
             napi_get_boolean(asyncContext->env, retCB->switchStatus, &requestResult));
 
-        ReturnPromiseResult(asyncContext->env, retCB->jsCode, asyncContext->deferred, requestResult);
+        ReturnPromiseResult(asyncContext->env, *asyncContext, requestResult);
         napi_close_handle_scope(asyncContext->env, scope);
     };
     if (napi_status::napi_ok != napi_send_event(data->env, task, napi_eprio_immediate)) {
@@ -204,8 +204,7 @@ void SwitchOnSettingUICallback::ReleaseHandler(int32_t code)
     }
     RequestGlobalSwitchAsyncInstanceControl::UpdateQueueData(this->reqContext_);
     RequestGlobalSwitchAsyncInstanceControl::ExecCallback(this->reqContext_->instanceId);
-    GlobalSwitchResultsCallbackUI(
-        TransferToJsErrorCode(this->reqContext_->errorCode), this->reqContext_->switchStatus, this->reqContext_);
+    GlobalSwitchResultsCallbackUI(this->reqContext_->errorCode, this->reqContext_->switchStatus, this->reqContext_);
 }
 
 SwitchOnSettingUICallback::SwitchOnSettingUICallback(
@@ -290,7 +289,7 @@ static void CreateUIExtensionMainThread(std::shared_ptr<RequestGlobalSwitchAsync
         Ace::UIContent* uiContent = GetUIContent(asyncContext);
         if (uiContent == nullptr) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Failed to get ui content!");
-            asyncContext->result = RET_FAILED;
+            asyncContext->result.errorCode = RET_FAILED;
             return;
         }
 
@@ -301,7 +300,7 @@ static void CreateUIExtensionMainThread(std::shared_ptr<RequestGlobalSwitchAsync
             sessionId, asyncContext->tokenId, asyncContext->switchType);
         if (sessionId == 0) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Failed to create component, sessionId is 0.");
-            asyncContext->result = RET_FAILED;
+            asyncContext->result.errorCode = RET_FAILED;
             return;
         }
         uiExtCallback->SetSessionId(sessionId);
@@ -342,10 +341,10 @@ static int32_t CreateUIExtension(const Want &want, std::shared_ptr<RequestGlobal
     };
 
     CreateUIExtensionMainThread(asyncContext, want, uiExtensionCallbacks, uiExtCallback);
-    if (asyncContext->result == RET_FAILED) {
+    if (asyncContext->result.errorCode == RET_FAILED) {
         return RET_FAILED;
     }
-    return JS_OK;
+    return RET_SUCCESS;
 }
 
 static int32_t StartUIExtension(std::shared_ptr<RequestGlobalSwitchAsyncContext> asyncContext)
@@ -466,8 +465,7 @@ void RequestGlobalSwitchAsyncInstanceControl::CheckDynamicRequest(
     isDynamic = asyncContext->isDynamic;
     if (!isDynamic) {
         LOGI(ATM_DOMAIN, ATM_TAG, "It does not need to request permission exsion");
-        GlobalSwitchResultsCallbackUI(
-            TransferToJsErrorCode(asyncContext->errorCode), asyncContext->switchStatus, asyncContext);
+        GlobalSwitchResultsCallbackUI(asyncContext->errorCode, asyncContext->switchStatus, asyncContext);
         return;
     }
 }
@@ -573,7 +571,9 @@ void NapiRequestGlobalSwitch::RequestGlobalSwitchExecute(napi_env env, void* dat
         LOGE(ATM_DOMAIN, ATM_TAG,
             "The context(token=%{public}d) is not belong to the current application(currToken=%{public}d).",
             asyncContextHandle->asyncContextPtr->tokenId, currToken);
-        asyncContextHandle->asyncContextPtr->result = ERR_PARAM_INVALID;
+        asyncContextHandle->asyncContextPtr->result.errorCode = ERR_PARAM_INVALID;
+        asyncContextHandle->asyncContextPtr->result.errorMsg =
+            "The specified context does not belong to the current application.";
         return;
     }
 
@@ -581,7 +581,7 @@ void NapiRequestGlobalSwitch::RequestGlobalSwitchExecute(napi_env env, void* dat
     LOGI(ATM_DOMAIN, ATM_TAG, "Start to pop ui extension dialog");
 
     RequestGlobalSwitchAsyncInstanceControl::AddCallbackByInstanceId(asyncContextHandle->asyncContextPtr);
-    if (asyncContextHandle->asyncContextPtr->result != JsErrorCode::JS_OK) {
+    if (asyncContextHandle->asyncContextPtr->result.errorCode != RET_SUCCESS) {
         LOGW(ATM_DOMAIN, ATM_TAG, "Failed to pop uiextension dialog.");
     }
 }
@@ -597,12 +597,12 @@ void NapiRequestGlobalSwitch::RequestGlobalSwitchComplete(napi_env env, napi_sta
     std::unique_ptr<RequestGlobalSwitchAsyncContextHandle> callbackPtr {asyncContextHandle};
 
     // need pop dialog
-    if (asyncContextHandle->asyncContextPtr->result == RET_SUCCESS) {
+    if (asyncContextHandle->asyncContextPtr->result.errorCode == RET_SUCCESS) {
         return;
     }
     // return error
     if (asyncContextHandle->asyncContextPtr->deferred != nullptr) {
-        int32_t jsCode = NapiContextCommon::GetJsErrorCode(asyncContextHandle->asyncContextPtr->result);
+        int32_t jsCode = NapiContextCommon::GetJsErrorCode(asyncContextHandle->asyncContextPtr->result.errorCode);
         napi_value businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode));
         NAPI_CALL_RETURN_VOID(env,
             napi_reject_deferred(env, asyncContextHandle->asyncContextPtr->deferred, businessError));
diff --git a/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp b/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp
index cd2a6c3f6ddb29f86bd3dff8fea0f58f88c50433..1e52f65cc39f6637131548b768c3ddf0353fd3ec 100644
--- a/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp
+++ b/frameworks/js/napi/accesstoken/src/napi_request_permission.cpp
@@ -47,23 +47,23 @@ const std::string WINDOW_RECTANGLE_HEIGHT_KEY = "ohos.ability.params.request.hei
 const std::string WINDOW_RECTANGLE_WIDTH_KEY = "ohos.ability.params.request.width";
 const std::string REQUEST_TOKEN_KEY = "ohos.ability.params.request.token";
 
-static void ReturnPromiseResult(napi_env env, int32_t contextResult, napi_deferred deferred, napi_value result)
+static void ReturnPromiseResult(napi_env env, const RequestAsyncContext& context, napi_value result)
 {
-    if (contextResult != RET_SUCCESS) {
-        int32_t jsCode = NapiContextCommon::GetJsErrorCode(contextResult);
-        napi_value businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode));
-        NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, deferred, businessError));
+    if (context.result.errorCode != RET_SUCCESS) {
+        int32_t jsCode = NapiContextCommon::GetJsErrorCode(context.result.errorCode);
+        napi_value businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode, context.result.errorMsg));
+        NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, context.deferred, businessError));
     } else {
-        NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, deferred, result));
+        NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, context.deferred, result));
     }
 }
 
-static void ReturnCallbackResult(napi_env env, int32_t contextResult, napi_ref &callbackRef, napi_value result)
+static void ReturnCallbackResult(napi_env env, const RequestAsyncContext& context, napi_value result)
 {
     napi_value businessError = GetNapiNull(env);
-    if (contextResult != RET_SUCCESS) {
-        int32_t jsCode = NapiContextCommon::GetJsErrorCode(contextResult);
-        businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode));
+    if (context.result.errorCode != RET_SUCCESS) {
+        int32_t jsCode = NapiContextCommon::GetJsErrorCode(context.result.errorCode);
+        businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode, context.result.errorMsg));
     }
     napi_value results[ASYNC_CALL_BACK_VALUES_NUM] = { businessError, result };
 
@@ -72,7 +72,7 @@ static void ReturnCallbackResult(napi_env env, int32_t contextResult, napi_ref &
     napi_value thatValue = nullptr;
     NAPI_CALL_RETURN_VOID(env, napi_get_undefined(env, &thisValue));
     NAPI_CALL_RETURN_VOID(env, napi_create_int32(env, 0, &thatValue));
-    NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, callbackRef, &callback));
+    NAPI_CALL_RETURN_VOID(env, napi_get_reference_value(env, context.callbackRef, &callback));
     NAPI_CALL_RETURN_VOID(env,
         napi_call_function(env, thisValue, callback, ASYNC_CALL_BACK_VALUES_NUM, results, &thatValue));
 }
@@ -133,7 +133,7 @@ static void CreateUIExtensionMainThread(std::shared_ptr<RequestAsyncContext>& as
         Ace::UIContent* uiContent = GetUIContent(asyncContext);
         if (uiContent == nullptr) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Get ui content failed!");
-            asyncContext->result = RET_FAILED;
+            asyncContext->result.errorCode = RET_FAILED;
             asyncContext->uiExtensionFlag = false;
             return;
         }
@@ -146,7 +146,7 @@ static void CreateUIExtensionMainThread(std::shared_ptr<RequestAsyncContext>& as
             sessionId, asyncContext->tokenId, asyncContext->permissionList.size());
         if (sessionId == 0) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Create component failed, sessionId is 0");
-            asyncContext->result = RET_FAILED;
+            asyncContext->result.errorCode = RET_FAILED;
             asyncContext->uiExtensionFlag = false;
             HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::ACCESS_TOKEN, "REQ_PERM_FROM_USER_ERROR",
                 HiviewDFX::HiSysEvent::EventType::FAULT, "ERROR_CODE", CREATE_MODAL_UI_FAILED);
@@ -172,7 +172,7 @@ static void CloseModalUIExtensionMainThread(std::shared_ptr<RequestAsyncContext>
         Ace::UIContent* uiContent = GetUIContent(asyncContext);
         if (uiContent == nullptr) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Get ui content failed!");
-            asyncContext->result = RET_FAILED;
+            asyncContext->result.errorCode = RET_FAILED;
             return;
         }
         uiContent->CloseModalUIExtension(sessionId);
@@ -281,7 +281,7 @@ static void UpdateGrantPermissionResultOnly(const std::vector<std::string>& perm
     for (uint32_t i = 0; i < size; i++) {
         int result = data->permissionsState[i];
         if (data->permissionsState[i] == DYNAMIC_OPER) {
-            result = data->result == RET_SUCCESS ? grantResults[i] : INVALID_OPER;
+            result = data->result.errorCode == RET_SUCCESS ? grantResults[i] : INVALID_OPER;
         }
         newGrantResults.emplace_back(result);
     }
@@ -305,10 +305,9 @@ static void RequestResultsHandler(const std::vector<std::string>& permissionList
     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())) {
-            LOGE(ATM_DOMAIN, ATM_TAG, "Result is: %{public}d", retCB->data->result);
-            result = RET_FAILED;
+        if ((retCB->data->result.errorCode != RET_SUCCESS) || retCB->grantResults.empty()) {
+            LOGE(ATM_DOMAIN, ATM_TAG, "Result is: %{public}d", retCB->data->result.errorCode);
+            retCB->data->result.errorCode = RET_FAILED;
         }
         napi_handle_scope scope = nullptr;
         napi_open_handle_scope(retCB->data->env, &scope);
@@ -321,13 +320,13 @@ static void RequestResultsHandler(const std::vector<std::string>& permissionList
             retCB->data->env, retCB->permissions, retCB->grantResults, retCB->dialogShownResults, retCB->errorReasons);
         if (requestResult == nullptr) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Wrap requestResult failed");
-            result = RET_FAILED;
+            retCB->data->result.errorCode = RET_FAILED;
         }
 
         if (retCB->data->deferred != nullptr) {
-            ReturnPromiseResult(retCB->data->env, result, retCB->data->deferred, requestResult);
+            ReturnPromiseResult(retCB->data->env, *retCB->data, requestResult);
         } else {
-            ReturnCallbackResult(retCB->data->env, result, retCB->data->callbackRef, requestResult);
+            ReturnCallbackResult(retCB->data->env, *retCB->data, requestResult);
         }
         napi_close_handle_scope(retCB->data->env, scope);
         delete retCB;
@@ -377,7 +376,7 @@ static void CreateServiceExtension(std::shared_ptr<RequestAsyncContext> asyncCon
     if (!asyncContext->uiAbilityFlag) {
         LOGE(ATM_DOMAIN, ATM_TAG, "UIExtension ability can not pop service ablility window!");
         asyncContext->needDynamicRequest = false;
-        asyncContext->result = RET_FAILED;
+        asyncContext->result.errorCode = RET_FAILED;
         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::ACCESS_TOKEN, "REQ_PERM_FROM_USER_ERROR",
             HiviewDFX::HiSysEvent::EventType::FAULT, "ERROR_CODE", ABILITY_FLAG_ERROR);
         return;
@@ -386,7 +385,7 @@ static void CreateServiceExtension(std::shared_ptr<RequestAsyncContext> asyncCon
     if (remoteObject == nullptr) {
         LOGE(ATM_DOMAIN, ATM_TAG, "Create window failed!");
         asyncContext->needDynamicRequest = false;
-        asyncContext->result = RET_FAILED;
+        asyncContext->result.errorCode = RET_FAILED;
         return;
     }
     AAFwk::Want want;
@@ -460,7 +459,7 @@ void UIExtensionCallback::ReleaseHandler(int32_t code)
         this->reqContext_->releaseFlag = true;
     }
     CloseModalUIExtensionMainThread(this->reqContext_, this->sessionId_);
-    this->reqContext_->result = code;
+    this->reqContext_->result.errorCode = code;
     RequestAsyncInstanceControl::ExecCallback(this->reqContext_->instanceId);
     RequestResultsHandler(this->reqContext_->permissionList, this->reqContext_->permissionsState, this->reqContext_);
 }
@@ -668,7 +667,9 @@ void NapiRequestPermission::RequestPermissionsFromUserExecute(napi_env env, void
     if (asyncContextHandle->asyncContextPtr->tokenId != selfTokenID) {
         LOGE(ATM_DOMAIN, ATM_TAG, "The context tokenID: %{public}d, selfTokenID: %{public}d.",
             asyncContextHandle->asyncContextPtr->tokenId, selfTokenID);
-        asyncContextHandle->asyncContextPtr->result = RET_FAILED;
+        asyncContextHandle->asyncContextPtr->result.errorCode = RET_FAILED;
+        asyncContextHandle->asyncContextPtr->result.errorMsg =
+            "The specified context does not belong to the current application.";
         HiSysEventWrite(HiviewDFX::HiSysEvent::Domain::ACCESS_TOKEN, "REQ_PERM_FROM_USER_ERROR",
             HiviewDFX::HiSysEvent::EventType::FAULT, "ERROR_CODE", TOKENID_INCONSISTENCY,
             "SELF_TOKEN", selfTokenID, "CONTEXT_TOKEN", asyncContextHandle->asyncContextPtr->tokenId);
@@ -721,27 +722,27 @@ void NapiRequestPermission::RequestPermissionsFromUserComplete(napi_env env, nap
         return;
     }
     if ((asyncContextHandle->asyncContextPtr->permissionsState.empty()) &&
-        (asyncContextHandle->asyncContextPtr->result == JsErrorCode::JS_OK)) {
+        (asyncContextHandle->asyncContextPtr->result.errorCode == RET_SUCCESS)) {
         LOGE(ATM_DOMAIN, ATM_TAG, "GrantResults empty");
-        asyncContextHandle->asyncContextPtr->result = RET_FAILED;
+        asyncContextHandle->asyncContextPtr->result.errorCode = RET_FAILED;
     }
     napi_value requestResult = WrapRequestResult(env, asyncContextHandle->asyncContextPtr->permissionList,
         asyncContextHandle->asyncContextPtr->permissionsState, asyncContextHandle->asyncContextPtr->dialogShownResults,
         asyncContextHandle->asyncContextPtr->errorReasons);
     if (requestResult == nullptr) {
         LOGE(ATM_DOMAIN, ATM_TAG, "Wrap requestResult failed");
-        if (asyncContextHandle->asyncContextPtr->result == JsErrorCode::JS_OK) {
-            asyncContextHandle->asyncContextPtr->result = RET_FAILED;
+        if (asyncContextHandle->asyncContextPtr->result.errorCode == RET_SUCCESS) {
+            asyncContextHandle->asyncContextPtr->result.errorCode = RET_FAILED;
         }
     } else {
         asyncContextHandle->asyncContextPtr->requestResult = requestResult;
     }
     if (asyncContextHandle->asyncContextPtr->deferred != nullptr) {
-        ReturnPromiseResult(env, asyncContextHandle->asyncContextPtr->result,
-            asyncContextHandle->asyncContextPtr->deferred, asyncContextHandle->asyncContextPtr->requestResult);
+        ReturnPromiseResult(
+            env, *asyncContextHandle->asyncContextPtr, asyncContextHandle->asyncContextPtr->requestResult);
     } else {
-        ReturnCallbackResult(env, asyncContextHandle->asyncContextPtr->result,
-            asyncContextHandle->asyncContextPtr->callbackRef, asyncContextHandle->asyncContextPtr->requestResult);
+        ReturnCallbackResult(
+            env, *asyncContextHandle->asyncContextPtr, asyncContextHandle->asyncContextPtr->requestResult);
     }
 }
 
@@ -797,7 +798,7 @@ bool NapiRequestPermission::ParseInputToGetQueryResult(const napi_env& env, cons
     asyncContext.env = env;
     // the first parameter of argv
     if (!ParseUint32(env, argv[0], asyncContext.tokenId)) {
-        errMsg = GetParamErrorMsg("tokenId", "number");
+        errMsg = GetParamErrorMsg("tokenID", "number");
         NAPI_CALL_BASE(env,
             napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)), false);
         return false;
@@ -805,7 +806,7 @@ bool NapiRequestPermission::ParseInputToGetQueryResult(const napi_env& env, cons
 
     // the second parameter of argv
     if (!ParseStringArray(env, argv[1], asyncContext.permissionList)) {
-        errMsg = GetParamErrorMsg("permissions", "Array<Permissions>");
+        errMsg = GetParamErrorMsg("permissionList", "Array<Permissions>");
         NAPI_CALL_BASE(
             env, napi_throw(env, GenerateBusinessError(env, JsErrorCode::JS_ERROR_PARAM_ILLEGAL, errMsg)), false);
         return false;
@@ -830,7 +831,7 @@ void NapiRequestPermission::GetPermissionsStatusExecute(napi_env env, void *data
     LOGD(ATM_DOMAIN, ATM_TAG, "PermList size: %{public}zu, asyncContext->permissionList size: %{public}zu.",
         permList.size(), asyncContext->permissionList.size());
 
-    asyncContext->result = AccessTokenKit::GetPermissionsStatus(asyncContext->tokenId, permList);
+    asyncContext->result.errorCode = AccessTokenKit::GetPermissionsStatus(asyncContext->tokenId, permList);
     for (const auto& permState : permList) {
         LOGD(ATM_DOMAIN, ATM_TAG, "Permission: %{public}s", permState.permissionName.c_str());
         asyncContext->permissionQueryResults.emplace_back(permState.state);
@@ -842,9 +843,10 @@ void NapiRequestPermission::GetPermissionsStatusComplete(napi_env env, napi_stat
     RequestAsyncContext* asyncContext = reinterpret_cast<RequestAsyncContext*>(data);
     std::unique_ptr<RequestAsyncContext> callbackPtr {asyncContext};
 
-    if ((asyncContext->permissionQueryResults.empty()) && asyncContext->result == JsErrorCode::JS_OK) {
+    if ((asyncContext->permissionQueryResults.empty()) && asyncContext->result.errorCode == RET_SUCCESS) {
         LOGE(ATM_DOMAIN, ATM_TAG, "PermissionQueryResults empty");
-        asyncContext->result = RET_FAILED;
+        asyncContext->result.errorCode = RET_FAILED;
+        asyncContext->result.errorMsg = "The permissionList is empty.";
     }
     napi_value result;
     NAPI_CALL_RETURN_VOID(env, napi_create_array(env, &result));
@@ -855,7 +857,7 @@ void NapiRequestPermission::GetPermissionsStatusComplete(napi_env env, napi_stat
             asyncContext->permissionQueryResults[i], &nPermissionQueryResult));
         NAPI_CALL_RETURN_VOID(env, napi_set_element(env, result, i, nPermissionQueryResult));
     }
-    ReturnPromiseResult(env, asyncContext->result, asyncContext->deferred, result);
+    ReturnPromiseResult(env, *asyncContext, result);
 }
 
 void RequestAsyncInstanceControl::CheckDynamicRequest(
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 9a16d25efe59e85ad9879e3996d6d24313931026..72fc8068bbf78723bf8ccd96f25d0dae8660af86 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
@@ -42,13 +42,45 @@ const int32_t ALL_PERM_GRANTED = 4;
 const int32_t PERM_REVOKE_BY_USER = 5;
 std::mutex g_lockFlag;
 } // namespace
-static void ReturnPromiseResult(napi_env env, int32_t jsCode, napi_deferred deferred, napi_value result)
+
+static int32_t TransferToJsErrorCode(int32_t errCode)
 {
-    if (jsCode != JS_OK) {
-        napi_value businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode));
-        NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, deferred, businessError));
+    int32_t jsCode = JS_OK;
+    switch (errCode) {
+        case RET_SUCCESS:
+            jsCode = JS_OK;
+            break;
+        case REQUEST_REALDY_EXIST:
+            jsCode = JS_ERROR_REQUEST_IS_ALREADY_EXIST;
+            break;
+        case PERM_NOT_BELONG_TO_SAME_GROUP:
+            jsCode = JS_ERROR_PARAM_INVALID;
+            break;
+        case PERM_IS_NOT_DECLARE:
+            jsCode = JS_ERROR_PARAM_INVALID;
+            break;
+        case ALL_PERM_GRANTED:
+            jsCode = JS_ERROR_ALL_PERM_GRANTED;
+            break;
+        case PERM_REVOKE_BY_USER:
+            jsCode = JS_ERROR_PERM_REVOKE_BY_USER;
+            break;
+        default:
+            jsCode = JS_ERROR_INNER;
+            break;
+    }
+    LOGI(ATM_DOMAIN, ATM_TAG, "dialog error(%{public}d) jsCode(%{public}d).", errCode, jsCode);
+    return jsCode;
+}
+
+static void ReturnPromiseResult(napi_env env, const RequestPermOnSettingAsyncContext& context, napi_value result)
+{
+    if (context.result.errorCode != RET_SUCCESS) {
+        int32_t jsCode = TransferToJsErrorCode(context.result.errorCode);
+        napi_value businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode, context.result.errorMsg));
+        NAPI_CALL_RETURN_VOID(env, napi_reject_deferred(env, context.deferred, businessError));
     } else {
-        NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, deferred, result));
+        NAPI_CALL_RETURN_VOID(env, napi_resolve_deferred(env, context.deferred, result));
     }
 }
 
@@ -117,37 +149,7 @@ static napi_value WrapRequestResult(const napi_env& env, const std::vector<int32
     return result;
 }
 
-static int32_t TransferToJsErrorCode(int32_t errCode)
-{
-    int32_t jsCode = JS_OK;
-    switch (errCode) {
-        case RET_SUCCESS:
-            jsCode = JS_OK;
-            break;
-        case REQUEST_REALDY_EXIST:
-            jsCode = JS_ERROR_REQUEST_IS_ALREADY_EXIST;
-            break;
-        case PERM_NOT_BELONG_TO_SAME_GROUP:
-            jsCode = JS_ERROR_PARAM_INVALID;
-            break;
-        case PERM_IS_NOT_DECLARE:
-            jsCode = JS_ERROR_PARAM_INVALID;
-            break;
-        case ALL_PERM_GRANTED:
-            jsCode = JS_ERROR_ALL_PERM_GRANTED;
-            break;
-        case PERM_REVOKE_BY_USER:
-            jsCode = JS_ERROR_PERM_REVOKE_BY_USER;
-            break;
-        default:
-            jsCode = JS_ERROR_INNER;
-            break;
-    }
-    LOGI(ATM_DOMAIN, ATM_TAG, "dialog error(%{public}d) jsCode(%{public}d).", errCode, jsCode);
-    return jsCode;
-}
-
-static void PermissionResultsCallbackUI(int32_t jsCode,
+static void PermissionResultsCallbackUI(int32_t errorCode,
     const std::vector<int32_t> stateList, std::shared_ptr<RequestPermOnSettingAsyncContext>& data)
 {
     auto* retCB = new (std::nothrow) PermissonOnSettingResultCallback();
@@ -157,7 +159,7 @@ static void PermissionResultsCallbackUI(int32_t jsCode,
     }
 
     std::unique_ptr<PermissonOnSettingResultCallback> callbackPtr {retCB};
-    retCB->jsCode = jsCode;
+    retCB->errorCode = errorCode;
     retCB->stateList = stateList;
     retCB->data = data;
     auto task = [retCB]() {
@@ -167,7 +169,7 @@ static void PermissionResultsCallbackUI(int32_t jsCode,
             return;
         }
 
-        int32_t result = retCB->jsCode;
+        int32_t result = retCB->errorCode;
         napi_handle_scope scope = nullptr;
         napi_open_handle_scope(asyncContext->env, &scope);
         if (scope == nullptr) {
@@ -176,12 +178,12 @@ static void PermissionResultsCallbackUI(int32_t jsCode,
             return;
         }
         napi_value requestResult = WrapRequestResult(asyncContext->env, retCB->stateList);
-        if ((result == JS_OK) && (requestResult == nullptr)) {
+        if ((result == RET_SUCCESS) && (requestResult == nullptr)) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Wrap requestResult failed");
-            result = JS_ERROR_INNER;
+            asyncContext->result.errorCode = RET_FAILED;
         }
 
-        ReturnPromiseResult(asyncContext->env, retCB->jsCode, asyncContext->deferred, requestResult);
+        ReturnPromiseResult(asyncContext->env, *asyncContext, requestResult);
         napi_close_handle_scope(asyncContext->env, scope);
         delete retCB;
     };
@@ -231,8 +233,7 @@ void PermissonOnSettingUICallback::ReleaseHandler(int32_t code)
     }
     RequestOnSettingAsyncInstanceControl::UpdateQueueData(this->reqContext_);
     RequestOnSettingAsyncInstanceControl::ExecCallback(this->reqContext_->instanceId);
-    PermissionResultsCallbackUI(
-        TransferToJsErrorCode(this->reqContext_->errorCode), this->reqContext_->stateList, this->reqContext_);
+    PermissionResultsCallbackUI(this->reqContext_->errorCode, this->reqContext_->stateList, this->reqContext_);
 }
 
 PermissonOnSettingUICallback::PermissonOnSettingUICallback(
@@ -317,7 +318,7 @@ static void CreateUIExtensionMainThread(std::shared_ptr<RequestPermOnSettingAsyn
         Ace::UIContent* uiContent = GetUIContent(asyncContext);
         if (uiContent == nullptr) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Failed to get ui content!");
-            asyncContext->result = RET_FAILED;
+            asyncContext->result.errorCode = RET_FAILED;
             return;
         }
 
@@ -328,7 +329,7 @@ static void CreateUIExtensionMainThread(std::shared_ptr<RequestPermOnSettingAsyn
             sessionId, asyncContext->tokenId);
         if (sessionId == 0) {
             LOGE(ATM_DOMAIN, ATM_TAG, "Failed to create component, sessionId is 0.");
-            asyncContext->result = RET_FAILED;
+            asyncContext->result.errorCode = RET_FAILED;
             return;
         }
         uiExtCallback->SetSessionId(sessionId);
@@ -369,10 +370,10 @@ static int32_t CreateUIExtension(const Want &want, std::shared_ptr<RequestPermOn
     };
 
     CreateUIExtensionMainThread(asyncContext, want, uiExtensionCallbacks, uiExtCallback);
-    if (asyncContext->result == RET_FAILED) {
+    if (asyncContext->result.errorCode == RET_FAILED) {
         return RET_FAILED;
     }
-    return JS_OK;
+    return RET_SUCCESS;
 }
 
 static int32_t StartUIExtension(std::shared_ptr<RequestPermOnSettingAsyncContext> asyncContext)
@@ -519,8 +520,7 @@ void RequestOnSettingAsyncInstanceControl::CheckDynamicRequest(
     isDynamic = asyncContext->isDynamic;
     if (!isDynamic) {
         LOGI(ATM_DOMAIN, ATM_TAG, "It does not need to request permission exsion");
-        PermissionResultsCallbackUI(
-            TransferToJsErrorCode(asyncContext->errorCode), asyncContext->stateList, asyncContext);
+        PermissionResultsCallbackUI(asyncContext->errorCode, asyncContext->stateList, asyncContext);
         return;
     }
 }
@@ -627,7 +627,9 @@ void NapiRequestPermissionOnSetting::RequestPermissionOnSettingExecute(napi_env
         LOGE(ATM_DOMAIN, ATM_TAG,
             "The context(token=%{public}d) is not belong to the current application(currToken=%{public}d).",
             asyncContextHandle->asyncContextPtr->tokenId, currToken);
-        asyncContextHandle->asyncContextPtr->result = ERR_PARAM_INVALID;
+        asyncContextHandle->asyncContextPtr->result.errorCode = ERR_PARAM_INVALID;
+        asyncContextHandle->asyncContextPtr->result.errorMsg =
+            "The specified context does not belong to the current application.";
         return;
     }
 
@@ -635,7 +637,7 @@ void NapiRequestPermissionOnSetting::RequestPermissionOnSettingExecute(napi_env
     LOGI(ATM_DOMAIN, ATM_TAG, "Start to pop ui extension dialog");
 
     RequestOnSettingAsyncInstanceControl::AddCallbackByInstanceId(asyncContextHandle->asyncContextPtr);
-    if (asyncContextHandle->asyncContextPtr->result != JsErrorCode::JS_OK) {
+    if (asyncContextHandle->asyncContextPtr->result.errorCode != RET_SUCCESS) {
         LOGW(ATM_DOMAIN, ATM_TAG, "Failed to pop uiextension dialog.");
     }
 }
@@ -651,12 +653,12 @@ void NapiRequestPermissionOnSetting::RequestPermissionOnSettingComplete(napi_env
     std::unique_ptr<RequestOnSettingAsyncContextHandle> callbackPtr {asyncContextHandle};
 
     // need pop dialog
-    if (asyncContextHandle->asyncContextPtr->result == RET_SUCCESS) {
+    if (asyncContextHandle->asyncContextPtr->result.errorCode == RET_SUCCESS) {
         return;
     }
     // return error
     if (asyncContextHandle->asyncContextPtr->deferred != nullptr) {
-        int32_t jsCode = NapiContextCommon::GetJsErrorCode(asyncContextHandle->asyncContextPtr->result);
+        int32_t jsCode = NapiContextCommon::GetJsErrorCode(asyncContextHandle->asyncContextPtr->result.errorCode);
         napi_value businessError = GenerateBusinessError(env, jsCode, GetErrorMessage(jsCode));
         NAPI_CALL_RETURN_VOID(env,
             napi_reject_deferred(env, asyncContextHandle->asyncContextPtr->deferred, businessError));
diff --git a/frameworks/js/napi/common/src/napi_error.cpp b/frameworks/js/napi/common/src/napi_error.cpp
index 8704aa48ad5ca715637836b431b4ea25876f3347..6b3ae3d679e20f62be46802c5111ba6d9d08100f 100644
--- a/frameworks/js/napi/common/src/napi_error.cpp
+++ b/frameworks/js/napi/common/src/napi_error.cpp
@@ -47,11 +47,11 @@ std::string GetParamErrorMsg(const std::string& param, const std::string& type)
     return msg;
 }
 
-std::string GetErrorMessage(uint32_t errCode)
+std::string GetErrorMessage(int32_t errCode, const std::string& extendMsg)
 {
     auto iter = g_errorStringMap.find(errCode);
     if (iter != g_errorStringMap.end()) {
-        return iter->second;
+        return iter->second + (extendMsg.empty() ? "" : (" " + extendMsg));
     }
     std::string errMsg = "Unknown error, errCode + " + std::to_string(errCode) + ".";
     return errMsg;
diff --git a/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp b/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp
index 37f3e0a2e300096045872520749f32542f12d400..34bf56d0a81bcd32ca3cf0db992e07e9ea49d332 100644
--- a/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp
+++ b/frameworks/js/napi/privacy/src/permission_record_manager_napi.cpp
@@ -289,7 +289,7 @@ static bool ParseStartAndStopUsingPermission(
     asyncContext.env = env;
     // 0: the first parameter of argv is tokenId
     if (!ParseUint32(env, argv[FIRST_PARAM], asyncContext.tokenId)) {
-        ParamResolveErrorThrow(env, "tokenId", "number");
+        ParamResolveErrorThrow(env, "tokenID", "number");
         return false;
     }
 
@@ -943,7 +943,7 @@ static bool ParseInputToRegister(const napi_env env, const napi_callback_info cb
     std::vector<std::string> permList;
     // 1: the second parameter of argv
     if (!ParseStringArray(env, argv[1], permList)) {
-        ParamResolveErrorThrow(env, "permList", "Array<Permissions>");
+        ParamResolveErrorThrow(env, "permissionList", "Array<Permissions>");
         return false;
     }
     std::sort(permList.begin(), permList.end());
@@ -985,7 +985,7 @@ static bool ParseInputToUnregister(const napi_env env, const napi_callback_info
     // 1: the second parameter of argv
     std::vector<std::string> permList;
     if (!ParseStringArray(env, argv[1], permList)) {
-        ParamResolveErrorThrow(env, "permList", "Array<Permissions>");
+        ParamResolveErrorThrow(env, "permissionList", "Array<Permissions>");
         return false;
     }
     std::sort(permList.begin(), permList.end());
@@ -1175,7 +1175,7 @@ static bool ParseGetPermissionUsedType(const napi_env env, const napi_callback_i
     if (argc == GET_PERMISSION_USED_TYPE_ONE_PARAMS) {
         // one param: only tokenId
         if (!ParseUint32(env, argv[0], tokenId)) {
-            ParamResolveErrorThrow(env, "tokenId", "number");
+            ParamResolveErrorThrow(env, "tokenID", "number");
             return false;
         }
     } else if (argc == GET_PERMISSION_USED_TYPE_MAX_PARAMS) {
@@ -1183,7 +1183,7 @@ static bool ParseGetPermissionUsedType(const napi_env env, const napi_callback_i
         if (!IsUndefinedOrNull(env, argv[0])) {
             // if first param is null, ignore it, otherwise that is tokenId: number
             if (!ParseUint32(env, argv[0], tokenId)) {
-                ParamResolveErrorThrow(env, "tokenId", "number");
+                ParamResolveErrorThrow(env, "tokenID", "number");
                 return false;
             }
         }
diff --git a/interfaces/kits/js/napi/accesstoken/include/napi_atmanager.h b/interfaces/kits/js/napi/accesstoken/include/napi_atmanager.h
index 5545ecaa247b56c0d287d24f8c4604a5f1fd4854..6e9172cf16ac79d64c533712ef88dff540b4674b 100644
--- a/interfaces/kits/js/napi/accesstoken/include/napi_atmanager.h
+++ b/interfaces/kits/js/napi/accesstoken/include/napi_atmanager.h
@@ -83,6 +83,7 @@ struct AtManagerAsyncContext : public AtManagerAsyncWorkData {
     };
     int32_t result = RET_FAILED;
     int32_t errorCode = 0;
+    std::string extErrorMsg = "";
 };
 
 struct AtManagerSyncContext {
diff --git a/interfaces/kits/js/napi/accesstoken/include/napi_request_global_switch_on_setting.h b/interfaces/kits/js/napi/accesstoken/include/napi_request_global_switch_on_setting.h
index ee549aabe1dc8db215f753e384764c640615cfca..bd56414b122e29bb44866b7538537a819dec6e9c 100644
--- a/interfaces/kits/js/napi/accesstoken/include/napi_request_global_switch_on_setting.h
+++ b/interfaces/kits/js/napi/accesstoken/include/napi_request_global_switch_on_setting.h
@@ -40,7 +40,7 @@ struct RequestGlobalSwitchAsyncContext : public AtManagerAsyncWorkData {
     }
 
     AccessTokenID tokenId = 0;
-    int32_t result = RET_SUCCESS;
+    AtmResult result;
     PermissionGrantInfo info;
     int32_t resultCode = -1;
     int32_t switchType = -1;
@@ -99,7 +99,7 @@ private:
 };
 
 struct SwitchOnSettingResultCallback {
-    int32_t jsCode;
+    int32_t errorCode;
     bool switchStatus;
     std::shared_ptr<RequestGlobalSwitchAsyncContext> data = nullptr;
 };
diff --git a/interfaces/kits/js/napi/accesstoken/include/napi_request_permission.h b/interfaces/kits/js/napi/accesstoken/include/napi_request_permission.h
index 8e74fc9548f1abe2f7bb26c711ff6ca7ea77b5f0..45cd3f3905961fae5d4da412c5c66caa42e98f4c 100644
--- a/interfaces/kits/js/napi/accesstoken/include/napi_request_permission.h
+++ b/interfaces/kits/js/napi/accesstoken/include/napi_request_permission.h
@@ -38,7 +38,7 @@ struct RequestAsyncContext : public AtManagerAsyncWorkData {
     AccessTokenID tokenId = 0;
     std::string bundleName = "";
     bool needDynamicRequest = true;
-    int32_t result = RET_SUCCESS;
+    AtmResult result;
     int32_t instanceId = -1;
     std::vector<std::string> permissionList;
     std::vector<int32_t> permissionsState;
diff --git a/interfaces/kits/js/napi/accesstoken/include/napi_request_permission_on_setting.h b/interfaces/kits/js/napi/accesstoken/include/napi_request_permission_on_setting.h
index 603f53fd2d857b79645dfbfdca9b19a2cb4304f8..8c0e8dbb1cfd83d3fc3cc4f2fe072c0ee3f08760 100644
--- a/interfaces/kits/js/napi/accesstoken/include/napi_request_permission_on_setting.h
+++ b/interfaces/kits/js/napi/accesstoken/include/napi_request_permission_on_setting.h
@@ -34,7 +34,7 @@ struct RequestPermOnSettingAsyncContext : public AtManagerAsyncWorkData {
     }
 
     AccessTokenID tokenId = 0;
-    int32_t result = RET_SUCCESS;
+    AtmResult result;
     PermissionGrantInfo info;
     int32_t resultCode = -1;
 
@@ -94,7 +94,7 @@ private:
 };
 
 struct PermissonOnSettingResultCallback {
-    int32_t jsCode;
+    int32_t errorCode;
     std::vector<int32_t> stateList;
     std::shared_ptr<RequestPermOnSettingAsyncContext> data = nullptr;
 };
diff --git a/interfaces/kits/js/napi/common/include/napi_error.h b/interfaces/kits/js/napi/common/include/napi_error.h
index ad696a7be5f8b68fa10091d65c0beb99f66cbb84..4d38988e0d42a89182ed29f2c8b7cb927db96ab9 100644
--- a/interfaces/kits/js/napi/common/include/napi_error.h
+++ b/interfaces/kits/js/napi/common/include/napi_error.h
@@ -47,9 +47,14 @@ typedef enum {
     JS_ERROR_GLOBAL_SWITCH_IS_ALREADY_OPEN = 12100013,
 } JsErrorCode;
 
+struct AtmResult {
+    int32_t errorCode = 0;
+    std::string errorMsg = "";
+};
+
 std::string GetParamErrorMsg(const std::string& param, const std::string& type);
 napi_value GenerateBusinessError(napi_env env, int32_t errCode, const std::string& errMsg);
-std::string GetErrorMessage(uint32_t errCode);
+std::string GetErrorMessage(int32_t errCode, const std::string& extendMsg = "");
 napi_value GetNapiNull(napi_env env);
 }  // namespace AccessToken
 }  // namespace Security