!3334 mission manager错误码整改

Merge pull request !3334 from ccll/dev_errcode
2026-08-24 22:21:36 -04:00 · 2022-10-13 14:14:15 +00:00
parent 70089e2d88 3798dd9743
commit 8e7bdf37de
8 changed files with 370 additions and 115 deletions
@@ -19,11 +19,13 @@
 #include "event_handler.h"
 #include "event_runner.h"
 #include "hilog_wrapper.h"
+#include "js_error_utils.h"
 #include "js_mission_info_utils.h"
 #include "js_mission_listener.h"
 #include "js_runtime_utils.h"
 #include "mission_snapshot.h"
 #include "napi_common_start_options.h"
+#include "permission_constants.h"
 #ifdef SUPPORT_GRAPHICS
 #include "pixel_map_napi.h"
 #endif
@@ -33,13 +35,11 @@

 namespace OHOS {
 namespace AbilityRuntime {
-constexpr size_t ARGC_ONE = 1;
 using namespace OHOS::AppExecFwk;
 using AbilityManagerClient = AAFwk::AbilityManagerClient;
 namespace {
-    constexpr int32_t ARG_COUNT_TWO = 2;
-    constexpr int32_t ARG_COUNT_THREE = 3;
-    constexpr int32_t ERR_NOT_OK = -1;
+constexpr size_t ARGC_ONE = 1;
+constexpr int32_t ARG_COUNT_TWO = 2;
 }
 class JsMissionManager {
 public:
@@ -122,8 +122,9 @@ private:
    NativeValue* OnRegisterMissionListener(NativeEngine &engine, NativeCallbackInfo &info)
    {
        HILOG_INFO("%{public}s is called", __FUNCTION__);
-        if (info.argc != 1) {
+        if (info.argc < 1) {
            HILOG_ERROR("Params not match");
+            ThrowTooFewParametersError(engine);
            return engine.CreateUndefined();
        }

@@ -141,6 +142,11 @@ private:
        } else {
            HILOG_ERROR("RegisterMissionListener failed, ret = %{public}d", ret);
            missionListener_ = nullptr;
+            if (ret == CHECK_PERMISSION_FAILED) {
+                ThrowNoPermissionError(engine, PermissionConstants::PERMISSION_MANAGE_MISSION);
+            } else {
+                ThrowError(engine, AbilityErrorCode::ERROR_CODE_INNER);
+            }
            return engine.CreateUndefined();
        }
    }
@@ -148,28 +154,27 @@ private:
    NativeValue* OnUnregisterMissionListener(NativeEngine &engine, NativeCallbackInfo &info)
    {
        HILOG_INFO("%{public}s is called", __FUNCTION__);
-        int32_t errCode = 0;
        if (info.argc < 1) {
            HILOG_ERROR("Not enough params");
-            errCode = ERR_NOT_OK;
+            ThrowTooFewParametersError(engine);
+            return engine.CreateUndefined();
        }
+
        int32_t missionListenerId = -1;
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[0], missionListenerId)) {
+        if (!ConvertFromJsValue(engine, info.argv[0], missionListenerId)) {
            HILOG_ERROR("Parse missionListenerId failed");
-            errCode = ERR_NOT_OK;
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return engine.CreateUndefined();
        }

        AsyncTask::CompleteCallback complete =
-            [&missionListener = missionListener_, missionListenerId, errCode]
+            [&missionListener = missionListener_, missionListenerId]
            (NativeEngine &engine, AsyncTask &task, int32_t status) {
-                if (errCode != 0) {
-                    task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params."));
-                    return;
-                }
                if (!missionListener || !missionListener->RemoveJsListenerObject(missionListenerId)) {
-                    task.Reject(engine, CreateJsError(engine, ERR_NOT_OK, "Not registered yet."));
+                    task.Reject(engine, CreateJsError(engine, AbilityErrorCode::ERROR_CODE_NO_MISSION_LISTENER));
                    return;
                }
+
                if (!missionListener->IsEmpty()) {
                    task.Resolve(engine, engine.CreateUndefined());
                    return;
@@ -179,7 +184,8 @@ private:
                    task.Resolve(engine, engine.CreateUndefined());
                    missionListener = nullptr;
                } else {
-                    task.Reject(engine, CreateJsError(engine, ret, "Unregister mission listener failed."));
+                    task.Reject(engine,
+                        CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
                }
            };

@@ -193,34 +199,33 @@ private:
    NativeValue* OnGetMissionInfos(NativeEngine &engine, NativeCallbackInfo &info)
    {
        HILOG_INFO("%{public}s is called", __FUNCTION__);
-        int32_t errCode = 0;
-        if (info.argc < 2) {
+        if (info.argc < 2) { // at least 2 parameters.
            HILOG_ERROR("Not enough params");
-            errCode = ERR_NOT_OK;
+            ThrowTooFewParametersError(engine);
+            return engine.CreateUndefined();
        }
        std::string deviceId;
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[0], deviceId)) {
+        if (!ConvertFromJsValue(engine, info.argv[0], deviceId)) {
            HILOG_ERROR("Parse deviceId failed");
-            errCode = ERR_NOT_OK;
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return engine.CreateUndefined();
        }
        int numMax = -1;
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[1], numMax)) {
+        if (!ConvertFromJsValue(engine, info.argv[1], numMax)) {
            HILOG_ERROR("Parse numMax failed");
-            errCode = ERR_NOT_OK;
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return engine.CreateUndefined();
        }

        AsyncTask::CompleteCallback complete =
-            [deviceId, numMax, errCode](NativeEngine &engine, AsyncTask &task, int32_t status) {
-                if (errCode != 0) {
-                    task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params."));
-                    return;
-                }
+            [deviceId, numMax](NativeEngine &engine, AsyncTask &task, int32_t status) {
                std::vector<AAFwk::MissionInfo> missionInfos;
                auto ret = AbilityManagerClient::GetInstance()->GetMissionInfos(deviceId, numMax, missionInfos);
                if (ret == 0) {
                    task.Resolve(engine, CreateJsMissionInfoArray(engine, missionInfos));
                } else {
-                    task.Reject(engine, CreateJsError(engine, ret, "Get mission infos failed."));
+                    task.Reject(engine,
+                        CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
                }
            };

@@ -234,34 +239,33 @@ private:
    NativeValue* OnGetMissionInfo(NativeEngine &engine, NativeCallbackInfo &info)
    {
        HILOG_INFO("%{public}s is called", __FUNCTION__);
-        int32_t errCode = 0;
        if (info.argc < 2) {
            HILOG_ERROR("Not enough params");
-            errCode = ERR_NOT_OK;
+            ThrowTooFewParametersError(engine);
+            return engine.CreateUndefined();
        }
        std::string deviceId;
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[0], deviceId)) {
+        if (!ConvertFromJsValue(engine, info.argv[0], deviceId)) {
            HILOG_ERROR("Parse deviceId failed");
-            errCode = ERR_NOT_OK;
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return engine.CreateUndefined();
        }
        int32_t missionId = -1;
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[1], missionId)) {
+        if (!ConvertFromJsValue(engine, info.argv[1], missionId)) {
            HILOG_ERROR("Parse missionId failed");
-            errCode = ERR_NOT_OK;
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return engine.CreateUndefined();
        }

        AsyncTask::CompleteCallback complete =
-            [deviceId, missionId, errCode](NativeEngine &engine, AsyncTask &task, int32_t status) {
-                if (errCode != 0) {
-                    task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params."));
-                    return;
-                }
+            [deviceId, missionId](NativeEngine &engine, AsyncTask &task, int32_t status) {
                AAFwk::MissionInfo missionInfo;
                auto ret = AbilityManagerClient::GetInstance()->GetMissionInfo(deviceId, missionId, missionInfo);
                if (ret == 0) {
                    task.Resolve(engine, CreateJsMissionInfo(engine, missionInfo));
                } else {
-                    task.Reject(engine, CreateJsError(engine, ret, "Get mission info failed."));
+                    task.Reject(engine,
+                        CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
                }
            };

@@ -275,16 +279,14 @@ private:
    NativeValue* OnGetMissionSnapShot(NativeEngine &engine, NativeCallbackInfo &info, bool isLowResolution)
    {
        HILOG_INFO("%{public}s is called", __FUNCTION__);
-        int32_t errCode = 0;
        std::string deviceId;
        int32_t missionId = -1;
-        CheckMissionSnapShotParams(engine, info, errCode, deviceId, missionId);
+        if (!CheckMissionSnapShotParams(engine, info, deviceId, missionId)) {
+            return engine.CreateUndefined();
+        }
+
        AsyncTask::CompleteCallback complete =
-            [deviceId, missionId, errCode, isLowResolution](NativeEngine &engine, AsyncTask &task, int32_t status) {
-                if (errCode != 0) {
-                    task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params."));
-                    return;
-                }
+            [deviceId, missionId, isLowResolution](NativeEngine &engine, AsyncTask &task, int32_t status) {
                AAFwk::MissionSnapshot missionSnapshot;
                auto ret = AbilityManagerClient::GetInstance()->GetMissionSnapshot(
                    deviceId, missionId, missionSnapshot, isLowResolution);
@@ -305,62 +307,67 @@ private:
 #endif
                    task.Resolve(engine, objValue);
                } else {
-                    task.Reject(engine, CreateJsError(engine, ret, "Get mission snapshot failed."));
+                    task.Reject(engine,
+                        CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
                }
            };
-        NativeValue* lastParam = (info.argc <= ARG_COUNT_TWO) ? nullptr : info.argv[2];
+        NativeValue* lastParam = (info.argc > ARG_COUNT_TWO) ? info.argv[ARG_COUNT_TWO] : nullptr;
        NativeValue* result = nullptr;
        AsyncTask::Schedule("MissioManager::OnGetMissionSnapShot",
            engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
        return result;
    }

-    void CheckMissionSnapShotParams(NativeEngine &engine, NativeCallbackInfo &info, int32_t &errCode,
+    bool CheckMissionSnapShotParams(NativeEngine &engine, NativeCallbackInfo &info,
        std::string &deviceId, int32_t &missionId)
    {
-        if (info.argc != ARG_COUNT_TWO && info.argc != ARG_COUNT_THREE) {
-            HILOG_ERROR("missionSnapshot: need two or three params");
-            errCode = ERR_NOT_OK;
+        if (info.argc < ARG_COUNT_TWO) {
+            ThrowTooFewParametersError(engine);
+            return false;
        }
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[0], deviceId)) {
+
+        if (!ConvertFromJsValue(engine, info.argv[0], deviceId)) {
            HILOG_ERROR("missionSnapshot: Parse deviceId failed");
-            errCode = ERR_NOT_OK;
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return false;
        }
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[1], missionId)) {
+
+        if (!ConvertFromJsValue(engine, info.argv[1], missionId)) {
            HILOG_ERROR("missionSnapshot: Parse missionId failed");
-            errCode = ERR_NOT_OK;
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return false;
        }
+
+        return true;
    }

    NativeValue* OnLockMission(NativeEngine &engine, NativeCallbackInfo &info)
    {
        HILOG_INFO("%{public}s is called", __FUNCTION__);
-        int32_t errCode = 0;
        if (info.argc == 0) {
-            HILOG_ERROR("Not enough params");
-            errCode = ERR_NOT_OK;
+            HILOG_ERROR("OnLockMission Not enough params");
+            ThrowTooFewParametersError(engine);
+            return engine.CreateUndefined();
        }
        int32_t missionId = -1;
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[0], missionId)) {
-            HILOG_ERROR("Parse missionId failed");
-            errCode = ERR_NOT_OK;
+        if (!ConvertFromJsValue(engine, info.argv[0], missionId)) {
+            HILOG_ERROR("OnLockMission Parse missionId failed");
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return engine.CreateUndefined();
        }

        AsyncTask::CompleteCallback complete =
-            [missionId, errCode](NativeEngine &engine, AsyncTask &task, int32_t status) {
-                if (errCode != 0) {
-                    task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params."));
-                    return;
-                }
+            [missionId](NativeEngine &engine, AsyncTask &task, int32_t status) {
                auto ret = AbilityManagerClient::GetInstance()->LockMissionForCleanup(missionId);
                if (ret == 0) {
                    task.Resolve(engine, engine.CreateUndefined());
                } else {
-                    task.Reject(engine, CreateJsError(engine, ret, "Lock mission failed."));
+                    task.Reject(engine,
+                        CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
                }
            };

-        NativeValue* lastParam = (info.argc <= 1) ? nullptr : info.argv[1];
+        NativeValue* lastParam = (info.argc > 1) ?  info.argv[1] : nullptr;
        NativeValue* result = nullptr;
        AsyncTask::Schedule("MissioManager::OnLockMission",
            engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
@@ -370,32 +377,30 @@ private:
    NativeValue* OnUnlockMission(NativeEngine &engine, NativeCallbackInfo &info)
    {
        HILOG_INFO("%{public}s is called", __FUNCTION__);
-        int32_t errCode = 0;
        if (info.argc == 0) {
-            HILOG_ERROR("Not enough params");
-            errCode = ERR_NOT_OK;
+            HILOG_ERROR("OnUnlockMission Not enough params");
+            ThrowTooFewParametersError(engine);
+            return engine.CreateUndefined();
        }
        int32_t missionId = -1;
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[0], missionId)) {
-            HILOG_ERROR("Parse missionId failed");
-            errCode = ERR_NOT_OK;
+        if (!ConvertFromJsValue(engine, info.argv[0], missionId)) {
+            HILOG_ERROR("OnUnlockMission Parse missionId failed");
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return engine.CreateUndefined();
        }

        AsyncTask::CompleteCallback complete =
-            [missionId, errCode](NativeEngine &engine, AsyncTask &task, int32_t status) {
-                if (errCode != 0) {
-                    task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params."));
-                    return;
-                }
+            [missionId](NativeEngine &engine, AsyncTask &task, int32_t status) {
                auto ret = AbilityManagerClient::GetInstance()->UnlockMissionForCleanup(missionId);
                if (ret == 0) {
                    task.Resolve(engine, engine.CreateUndefined());
                } else {
-                    task.Reject(engine, CreateJsError(engine, ret, "Unlock mission failed."));
+                    task.Reject(engine,
+                        CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
                }
            };

-        NativeValue* lastParam = (info.argc <= 1) ? nullptr : info.argv[1];
+        NativeValue* lastParam = (info.argc > 1) ? info.argv[1] : nullptr;
        NativeValue* result = nullptr;
        AsyncTask::Schedule("MissioManager::OnUnlockMission",
            engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
@@ -405,32 +410,30 @@ private:
    NativeValue* OnClearMission(NativeEngine &engine, NativeCallbackInfo &info)
    {
        HILOG_INFO("%{public}s is called", __FUNCTION__);
-        int32_t errCode = 0;
        if (info.argc == 0) {
-            HILOG_ERROR("Not enough params");
-            errCode = ERR_NOT_OK;
+            HILOG_ERROR("OnClearMission Not enough params");
+            ThrowTooFewParametersError(engine);
+            return engine.CreateUndefined();
        }
        int32_t missionId = -1;
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[0], missionId)) {
-            HILOG_ERROR("Parse missionId failed");
-            errCode = ERR_NOT_OK;
+        if (!ConvertFromJsValue(engine, info.argv[0], missionId)) {
+            HILOG_ERROR("OnClearMission Parse missionId failed");
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return engine.CreateUndefined();
        }

        AsyncTask::CompleteCallback complete =
-            [missionId, errCode](NativeEngine &engine, AsyncTask &task, int32_t status) {
-                if (errCode != 0) {
-                    task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params."));
-                    return;
-                }
+            [missionId](NativeEngine &engine, AsyncTask &task, int32_t status) {
                auto ret = AbilityManagerClient::GetInstance()->CleanMission(missionId);
                if (ret == 0) {
                    task.Resolve(engine, engine.CreateUndefined());
                } else {
-                    task.Reject(engine, CreateJsError(engine, ret, "Clear mission failed."));
+                    task.Reject(engine,
+                        CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
                }
            };

-        NativeValue* lastParam = (info.argc <= 1) ? nullptr : info.argv[1];
+        NativeValue* lastParam = (info.argc > 1) ? info.argv[1] : nullptr;
        NativeValue* result = nullptr;
        AsyncTask::Schedule("MissioManager::OnClearMission",
            engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
@@ -446,11 +449,12 @@ private:
                if (ret == 0) {
                    task.Resolve(engine, engine.CreateUndefined());
                } else {
-                    task.Reject(engine, CreateJsError(engine, ret, "Clear all missions failed."));
+                    task.Reject(engine,
+                        CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
                }
            };

-        NativeValue* lastParam = (info.argc == 0) ? nullptr : info.argv[0];
+        NativeValue* lastParam = (info.argc > 0) ? info.argv[0] : nullptr;
        NativeValue* result = nullptr;
        AsyncTask::Schedule("MissioManager::OnMoveMissionToFront",
            engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
@@ -460,15 +464,16 @@ private:
    NativeValue* OnMoveMissionToFront(NativeEngine &engine, NativeCallbackInfo &info)
    {
        HILOG_INFO("%{public}s is called", __FUNCTION__);
-        int32_t errCode = 0;
        if (info.argc == 0) {
-            HILOG_ERROR("Not enough params");
-            errCode = ERR_NOT_OK;
+            HILOG_ERROR("OnMoveMissionToFront Not enough params");
+            ThrowTooFewParametersError(engine);
+            return engine.CreateUndefined();
        }
        int32_t missionId = -1;
-        if (!errCode && !ConvertFromJsValue(engine, info.argv[0], missionId)) {
-            HILOG_ERROR("Parse missionId failed");
-            errCode = ERR_NOT_OK;
+        if (!ConvertFromJsValue(engine, info.argv[0], missionId)) {
+            HILOG_ERROR("OnMoveMissionToFront Parse missionId failed");
+            ThrowError(engine, AbilityErrorCode::ERROR_CODE_INVALID_PARAM);
+            return engine.CreateUndefined();
        }
        decltype(info.argc) unwrapArgc = 1;

@@ -480,21 +485,18 @@ private:
            unwrapArgc++;
        }
        AsyncTask::CompleteCallback complete =
-            [missionId, errCode, startOptions, unwrapArgc](NativeEngine &engine, AsyncTask &task, int32_t status) {
-                if (errCode != 0) {
-                    task.Reject(engine, CreateJsError(engine, errCode, "Invalidate params."));
-                    return;
-                }
+            [missionId, startOptions, unwrapArgc](NativeEngine &engine, AsyncTask &task, int32_t status) {
                auto ret = (unwrapArgc == 1) ? AbilityManagerClient::GetInstance()->MoveMissionToFront(missionId) :
                    AbilityManagerClient::GetInstance()->MoveMissionToFront(missionId, startOptions);
                if (ret == 0) {
                    task.Resolve(engine, engine.CreateUndefined());
                } else {
-                    task.Reject(engine, CreateJsError(engine, ret, "Move mission to front failed."));
+                    task.Reject(engine,
+                        CreateJsErrorByNativeErr(engine, ret, PermissionConstants::PERMISSION_MANAGE_MISSION));
                }
            };

-        NativeValue* lastParam = (info.argc <= unwrapArgc) ? nullptr : info.argv[unwrapArgc];
+        NativeValue* lastParam = (info.argc > unwrapArgc) ? info.argv[unwrapArgc] : nullptr;
        NativeValue* result = nullptr;
        AsyncTask::Schedule("MissioManager::OnMoveMissionToFront",
            engine, CreateAsyncTaskWithLastParam(engine, lastParam, nullptr, std::move(complete), &result));
@@ -489,3 +489,28 @@ ohos_shared_library("service_extension_module") {
  subsystem_name = "ability"
  part_name = "ability_runtime"
 }
+
+config("ability_business_error_config") {
+  visibility = [ ":*" ]
+  include_dirs = [
+    "${ability_runtime_innerkits_path}/ability_manager/include",
+    "${ability_runtime_path}/interfaces/kits/native/ability/native/ability_business_error",
+    "//base/hiviewdfx/hiview/adapter/utility/include/extra",
+  ]
+}
+
+config("ability_business_error_public_config") {
+  visibility = [ ":*" ]
+  include_dirs = [ "${ability_runtime_path}/interfaces/kits/native/ability/native/ability_business_error" ]
+}
+
+ohos_shared_library("ability_business_error") {
+  sources = [ "${ability_runtime_native_path}/ability/native/ability_business_error/ability_business_error.cpp" ]
+
+  configs = [ ":ability_business_error_config" ]
+
+  public_configs = [ ":ability_business_error_public_config" ]
+
+  subsystem_name = "ability"
+  part_name = "ability_runtime"
+}
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "ability_business_error.h"
+
+#include <unordered_map>
+
+#include "ability_manager_errors.h"
+
+namespace OHOS {
+namespace AbilityRuntime {
+using namespace OHOS::AAFwk;
+namespace {
+constexpr const char* TAG_PERMISSION = " permission:";
+constexpr const char* ERROR_MSG_OK = "OK.";
+constexpr const char* ERROR_MSG_PERMISSION_DENIED = "The application does not have permission to call the interface.";
+constexpr const char* ERROR_MSG_INVALID_PARAM = "Invalid input parameter.";
+constexpr const char* ERROR_MSG_SYSTEMCAP = "The specified SystemCapability name was not found.";
+constexpr const char* ERROR_MSG_INNER = "Inner Error.";
+constexpr const char* ERROR_MSG_NO_MISSION_ID = "The specified mission id does not exist.";
+constexpr const char* ERROR_MSG_NO_MISSION_LISTENER = "The specified mission listener does not exist.";
+
+static std::unordered_map<AbilityErrorCode, const char*> ERR_CODE_MAP = {
+    { AbilityErrorCode::ERROR_OK, ERROR_MSG_OK },
+    { AbilityErrorCode::ERROR_CODE_PERMISSION_DENIED, ERROR_MSG_PERMISSION_DENIED },
+    { AbilityErrorCode::ERROR_CODE_INVALID_PARAM, ERROR_MSG_INVALID_PARAM },
+    { AbilityErrorCode::ERROR_CODE_SYSTEMCAP, ERROR_MSG_SYSTEMCAP },
+    { AbilityErrorCode::ERROR_CODE_INNER, ERROR_MSG_INNER },
+    { AbilityErrorCode::ERROR_CODE_NO_MISSION_ID, ERROR_MSG_NO_MISSION_ID },
+    { AbilityErrorCode::ERROR_CODE_NO_MISSION_LISTENER, ERROR_MSG_NO_MISSION_LISTENER }
+};
+
+static std::unordered_map<int32_t, AbilityErrorCode> INNER_TO_JS_ERROR_CODE_MAP {
+    {0, AbilityErrorCode::ERROR_OK},
+    {CHECK_PERMISSION_FAILED, AbilityErrorCode::ERROR_CODE_PERMISSION_DENIED},
+    {MISSION_NOT_FOUND, AbilityErrorCode::ERROR_CODE_NO_MISSION_ID}
+};
+}
+
+std::string GetErrorMsg(const AbilityErrorCode& errCode)
+{
+    auto it = ERR_CODE_MAP.find(errCode);
+    if (it != ERR_CODE_MAP.end()) {
+        return it->second;
+    }
+
+    return "";
+}
+
+std::string GetNoPermissionErrorMsg(const std::string& permission)
+{
+    return std::string(ERROR_MSG_PERMISSION_DENIED) + std::string(TAG_PERMISSION) + permission;
+}
+
+AbilityErrorCode GetJsErrorCodeByNativeError(int32_t errCode)
+{
+    auto it = INNER_TO_JS_ERROR_CODE_MAP.find(errCode);
+    if (it != INNER_TO_JS_ERROR_CODE_MAP.end()) {
+        return it->second;
+    }
+
+    return AbilityErrorCode::ERROR_CODE_INNER;
+}
+}  // namespace AbilityRuntime
+}  // namespace OHOS
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+
+#include "js_error_utils.h"
+
+#include "js_runtime_utils.h"
+
+namespace OHOS {
+namespace AbilityRuntime {
+namespace {
+constexpr const char* ERR_MSG_TOO_FEW_PARAM = "Parameter error. Too few parameters.";
+}
+
+void ThrowError(NativeEngine& engine, int32_t errCode, const std::string& errorMsg)
+{
+    engine.Throw(CreateJsError(engine, errCode, errorMsg));
+}
+
+void ThrowError(NativeEngine& engine, const AbilityErrorCode& err)
+{
+    engine.Throw(CreateJsError(engine, static_cast<int32_t>(err), GetErrorMsg(err)));
+}
+
+void ThrowTooFewParametersError(NativeEngine& engine)
+{
+    engine.Throw(CreateJsError(engine,
+        static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_INVALID_PARAM),
+        ERR_MSG_TOO_FEW_PARAM));
+}
+
+void ThrowNoPermissionError(NativeEngine& engine, const std::string& permission)
+{
+    engine.Throw(CreateJsError(engine,
+        static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_PERMISSION_DENIED),
+        GetNoPermissionErrorMsg(permission)));
+}
+
+NativeValue* CreateJsError(NativeEngine& engine, const AbilityErrorCode& err)
+{
+    return CreateJsError(engine, static_cast<int32_t>(err), GetErrorMsg(err));
+}
+
+NativeValue* CreateNoPermissionError(NativeEngine& engine, const std::string& permission)
+{
+    return CreateJsError(engine,
+        static_cast<int32_t>(AbilityErrorCode::ERROR_CODE_PERMISSION_DENIED),
+        GetNoPermissionErrorMsg(permission));
+}
+
+NativeValue* CreateJsErrorByNativeErr(NativeEngine& engine, int32_t err, const std::string& permission)
+{
+    auto errCode = GetJsErrorCodeByNativeError(err);
+    auto errMsg = (errCode == AbilityErrorCode::ERROR_CODE_PERMISSION_DENIED && !permission.empty()) ?
+        GetNoPermissionErrorMsg(permission) : GetErrorMsg(errCode);
+    return CreateJsError(engine, static_cast<int32_t>(errCode), errMsg);
+}
+}  // namespace AbilityRuntime
+}  // namespace OHOS
@@ -28,7 +28,10 @@ config("runtime_config") {

 config("runtime_public_config") {
  visibility = [ ":*" ]
-  include_dirs = [ "include" ]
+  include_dirs = [
+    "${ability_runtime_path}/interfaces/kits/native/ability/native/ability_business_error",
+    "include",
+  ]
 }

 config("runtime_all_deps_config") {
@@ -41,6 +44,7 @@ ohos_shared_library("runtime") {
    "${ability_runtime_native_path}/runtime/hdc_register.cpp",
    "${ability_runtime_native_path}/runtime/js_console_log.cpp",
    "${ability_runtime_native_path}/runtime/js_data_struct_converter.cpp",
+    "${ability_runtime_native_path}/runtime/js_error_utils.cpp",
    "${ability_runtime_native_path}/runtime/js_module_reader.cpp",
    "${ability_runtime_native_path}/runtime/js_module_searcher.cpp",
    "${ability_runtime_native_path}/runtime/js_runtime.cpp",
@@ -63,6 +67,7 @@ ohos_shared_library("runtime") {
  all_dependent_configs = [ ":runtime_all_deps_config" ]

  deps = [
+    "${ability_runtime_native_path}/ability/native:ability_business_error",
    "${ability_runtime_native_path}/runtime:runtime_extractor",
    "${ability_runtime_native_path}/runtime:string_utils",
    "//arkcompiler/ets_runtime:libark_jsruntime",
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_ABILITY_RUNTIME_JS_ERROR_UTILS_H
+#define OHOS_ABILITY_RUNTIME_JS_ERROR_UTILS_H
+
+#include "ability_business_error.h"
+#include "native_engine/native_engine.h"
+
+namespace OHOS {
+namespace AbilityRuntime {
+
+void ThrowError(NativeEngine& engine, int32_t errCode, const std::string& errorMsg = "");
+void ThrowError(NativeEngine& engine, const AbilityErrorCode& err);
+void ThrowTooFewParametersError(NativeEngine& engine);
+void ThrowNoPermissionError(NativeEngine& engine, const std::string& permission);
+
+NativeValue* CreateJsError(NativeEngine& engine, const AbilityErrorCode& err);
+NativeValue* CreateNoPermissionError(NativeEngine& engine, const std::string& permission);
+NativeValue* CreateJsErrorByNativeErr(NativeEngine& engine, int32_t err, const std::string& permission = "");
+}  // namespace AbilityRuntime
+}  // namespace OHOS
+
+#endif  // OHOS_ABILITY_RUNTIME_JS_ERROR_UTILS_H
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2022 Huawei Device Co., Ltd.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OHOS_ABILITY_RUNTIME_ABILITY_BUSINESS_ERROR_H
+#define OHOS_ABILITY_RUNTIME_ABILITY_BUSINESS_ERROR_H
+
+#include <string>
+
+namespace OHOS {
+namespace AbilityRuntime {
+enum class AbilityErrorCode {
+    ERROR_OK = 0,
+    ERROR_CODE_PERMISSION_DENIED = 201,
+    ERROR_CODE_INVALID_PARAM = 401,
+    ERROR_CODE_SYSTEMCAP = 801,
+    ERROR_CODE_INNER = 16000050, // inner error.
+    ERROR_CODE_NO_MISSION_ID = 16300001,
+    ERROR_CODE_NO_MISSION_LISTENER = 16300002,
+};
+
+std::string GetErrorMsg(const AbilityErrorCode& errCode);
+std::string GetNoPermissionErrorMsg(const std::string& permission);
+AbilityErrorCode GetJsErrorCodeByNativeError(int32_t errCode);
+
+}  // namespace AbilityRuntime
+}  // namespace OHOS
+#endif
@@ -272,7 +272,7 @@ int MissionInfoMgr::GetInnerMissionInfoById(int32_t missionId, InnerMissionInfo
    std::lock_guard<std::recursive_mutex> lock(mutex_);
    if (missionIdMap_.find(missionId) == missionIdMap_.end()) {
        HILOG_ERROR("missionId %{public}d not exists, get inner mission info failed", missionId);
-        return -1;
+        return MISSION_NOT_FOUND;
    }

    auto it = std::find_if(missionInfoList_.begin(), missionInfoList_.end(),
@@ -282,7 +282,7 @@ int MissionInfoMgr::GetInnerMissionInfoById(int32_t missionId, InnerMissionInfo
    );
    if (it == missionInfoList_.end()) {
        HILOG_ERROR("no such mission:%{public}d", missionId);
-        return -1;
+        return MISSION_NOT_FOUND;
    }
    innerMissionInfo = *it;
    return 0;