diff --git a/frameworks/ans/native/src/notification_sorting.cpp b/frameworks/ans/native/src/notification_sorting.cpp
index 0ff27d780b079bb00ea7cfa9404d36a7b35d8109..fc390cfc0224fd99c11a29435392d421d2b3950d 100644
--- a/frameworks/ans/native/src/notification_sorting.cpp
+++ b/frameworks/ans/native/src/notification_sorting.cpp
@@ -39,6 +39,10 @@ NotificationSorting::NotificationSorting(const NotificationSorting &sorting)
 
 void NotificationSorting::SetSlot(const sptr<NotificationSlot> &slot)
 {
+    if (slot == nullptr) {
+        slot_ = new NotificationSlot(NotificationConstant::SlotType::OTHER);
+        return;
+    }
     slot_ = slot;
 }
 
diff --git a/interfaces/innerkits/ans/native/include/notification_sorting.h b/interfaces/innerkits/ans/native/include/notification_sorting.h
index 4be3ba5b49bffb0943175e61a489ee84780aacfd..1efa272e597a02f54a3512e40fa39b93aa63bb85 100644
--- a/interfaces/innerkits/ans/native/include/notification_sorting.h
+++ b/interfaces/innerkits/ans/native/include/notification_sorting.h
@@ -175,7 +175,7 @@ private:
     bool isHiddenNotification_ {};
     std::string groupKeyOverride_ {};
     int32_t visiblenessOverride_ {};
-    sptr<NotificationSlot> slot_ {nullptr};
+    sptr<NotificationSlot> slot_ = new NotificationSlot(NotificationConstant::SlotType::OTHER);
 
     friend class AdvancedNotificationService;
 };
diff --git a/interfaces/kits/napi/ans/include/common.h b/interfaces/kits/napi/ans/include/common.h
index ace3fefc313e264d2d6b7f4a59d386602b4de402..8cd32ef3aa549a898d1ddc18cc1e553604ba6f27 100644
--- a/interfaces/kits/napi/ans/include/common.h
+++ b/interfaces/kits/napi/ans/include/common.h
@@ -132,7 +132,8 @@ public:
     static void SetCallback(
         const napi_env &env, const napi_ref &callbackIn, const int &errorCode, const napi_value &result);
 
-    static void SetPromise(const napi_env &env, const napi_deferred &deferred, const napi_value &result);
+    static void SetPromise(
+        const napi_env &env, const napi_deferred &deferred, const int &errorCode, const napi_value &result);
 
     static napi_value JSParaError(const napi_env &env, const napi_ref &callback);
 
diff --git a/interfaces/kits/napi/ans/src/common.cpp b/interfaces/kits/napi/ans/src/common.cpp
index 45f69f2e8a33e14495e5cf8ced977de093cee4c2..650e0935ea1ba36fca49c9a41a71473d03abed49 100644
--- a/interfaces/kits/napi/ans/src/common.cpp
+++ b/interfaces/kits/napi/ans/src/common.cpp
@@ -138,7 +138,7 @@ void Common::ReturnCallbackPromise(const napi_env &env, const CallbackPromiseInf
     if (info.isCallback) {
         SetCallback(env, info.callback, info.errorCode, result);
     } else {
-        SetPromise(env, info.deferred, result);
+        SetPromise(env, info.deferred, info.errorCode, result);
     }
     ANS_LOGI("ReturnCallbackPromise end");
 }
@@ -160,10 +160,15 @@ void Common::SetCallback(
     ANS_LOGI("end");
 }
 
-void Common::SetPromise(const napi_env &env, const napi_deferred &deferred, const napi_value &result)
+void Common::SetPromise(
+    const napi_env &env, const napi_deferred &deferred, const int &errorCode, const napi_value &result)
 {
     ANS_LOGI("enter");
-    napi_resolve_deferred(env, deferred, result);
+    if (errorCode == ERR_OK) {
+        napi_resolve_deferred(env, deferred, result);
+    } else {
+        napi_reject_deferred(env, deferred, GetCallbackErrorValue(env, errorCode));
+    }
     ANS_LOGI("end");
 }
 
@@ -175,7 +180,7 @@ napi_value Common::JSParaError(const napi_env &env, const napi_ref &callback)
         napi_value promise = nullptr;
         napi_deferred deferred = nullptr;
         napi_create_promise(env, &deferred, &promise);
-        SetPromise(env, deferred, Common::NapiGetNull(env));
+        SetPromise(env, deferred, ERROR, Common::NapiGetNull(env));
         return promise;
     }
 }
diff --git a/interfaces/kits/napi/ans/src/get_active.cpp b/interfaces/kits/napi/ans/src/get_active.cpp
index 788fdd2f2cefe459f564488d828385fc375a9086..c424913327036a505782518472a41873d6b89c78 100644
--- a/interfaces/kits/napi/ans/src/get_active.cpp
+++ b/interfaces/kits/napi/ans/src/get_active.cpp
@@ -23,8 +23,10 @@ const int ACTIVE_OR_NUMS_MAX_PARA = 1;
 struct AsyncCallbackInfoActive {
     napi_env env = nullptr;
     napi_async_work asyncWork = nullptr;
-    napi_value result = nullptr;
     CallbackPromiseInfo info;
+    std::vector<sptr<OHOS::Notification::Notification>> notifications;
+    std::vector<sptr<OHOS::Notification::NotificationRequest>> requests;
+    int32_t num = 0;
 };
 
 napi_value ParseParametersByAllActive(const napi_env &env, const napi_callback_info &info, napi_ref &callback)
@@ -67,6 +69,58 @@ napi_value ParseParametersByGetActive(const napi_env &env, const napi_callback_i
     return Common::NapiGetNull(env);
 }
 
+void AsyncCompleteCallbackGetAllActiveNotifications(napi_env env, napi_status status, void *data)
+{
+    ANS_LOGI("GetAllActiveNotifications napi_create_async_work end");
+
+    if (!data) {
+        ANS_LOGE("Invalid async callback data");
+        return;
+    }
+
+    AsyncCallbackInfoActive *asynccallbackinfo = (AsyncCallbackInfoActive *)data;
+    napi_value result = nullptr;
+    if (asynccallbackinfo->info.errorCode != ERR_OK) {
+        result = Common::NapiGetNull(env);
+    } else {
+        napi_value arr = nullptr;
+        int count = 0;
+        napi_create_array(env, &arr);
+        for (auto vec : asynccallbackinfo->notifications) {
+            if (!vec) {
+                ANS_LOGW("Invalid Notification object ptr");
+                continue;
+            }
+            napi_value notificationResult = nullptr;
+            napi_create_object(env, &notificationResult);
+            if (!Common::SetNotification(env, vec.GetRefPtr(), notificationResult)) {
+                ANS_LOGW("Set Notification object failed");
+                continue;
+            }
+            napi_set_element(env, arr, count, notificationResult);
+            count++;
+        }
+        ANS_LOGI("GetAllActiveNotifications count = %{public}d", count);
+        result = arr;
+        if ((count == 0) && (asynccallbackinfo->notifications.size() > 0)) {
+            asynccallbackinfo->info.errorCode = ERROR;
+            result = Common::NapiGetNull(env);
+        }
+    }
+
+    Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
+
+    if (asynccallbackinfo->info.callback != nullptr) {
+        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    }
+
+    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+    if (asynccallbackinfo) {
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
+    }
+}
+
 napi_value GetAllActiveNotifications(napi_env env, napi_callback_info info)
 {
     ANS_LOGI("enter");
@@ -95,52 +149,10 @@ napi_value GetAllActiveNotifications(napi_env env, napi_callback_info info)
             ANS_LOGI("GetAllActiveNotifications napi_create_async_work start");
             AsyncCallbackInfoActive *asynccallbackinfo = (AsyncCallbackInfoActive *)data;
 
-            std::vector<sptr<OHOS::Notification::Notification>> notifications;
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetAllActiveNotifications(notifications);
-            if (asynccallbackinfo->info.errorCode != ERR_OK) {
-                asynccallbackinfo->result = Common::NapiGetNull(env);
-                return;
-            }
-            napi_value arr = nullptr;
-            int count = 0;
-            napi_create_array(env, &arr);
-            for (auto vec : notifications) {
-                if (!vec) {
-                    ANS_LOGW("Invalid Notification object ptr");
-                    continue;
-                }
-                napi_value result = nullptr;
-                napi_create_object(env, &result);
-                if (!Common::SetNotification(env, vec.GetRefPtr(), result)) {
-                    ANS_LOGW("Set Notification object failed");
-                    continue;
-                }
-                napi_set_element(env, arr, count, result);
-                count++;
-            }
-            ANS_LOGI("GetAllActiveNotifications count = %{public}d", count);
-            asynccallbackinfo->result = arr;
-            if ((count == 0) && (notifications.size() > 0)) {
-                asynccallbackinfo->info.errorCode = ERROR;
-                asynccallbackinfo->result = Common::NapiGetNull(env);
-            }
-        },
-        [](napi_env env, napi_status status, void *data) {
-            ANS_LOGI("GetAllActiveNotifications napi_create_async_work end");
-            AsyncCallbackInfoActive *asynccallbackinfo = (AsyncCallbackInfoActive *)data;
-
-            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, asynccallbackinfo->result);
-
-            if (asynccallbackinfo->info.callback != nullptr) {
-                napi_delete_reference(env, asynccallbackinfo->info.callback);
-            }
-
-            napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-            if (asynccallbackinfo) {
-                delete asynccallbackinfo;
-                asynccallbackinfo = nullptr;
-            }
+            asynccallbackinfo->info.errorCode =
+                NotificationHelper::GetAllActiveNotifications(asynccallbackinfo->notifications);
         },
+        AsyncCompleteCallbackGetAllActiveNotifications,
         (void *)asynccallbackinfo,
         &asynccallbackinfo->asyncWork);
 
@@ -153,6 +165,57 @@ napi_value GetAllActiveNotifications(napi_env env, napi_callback_info info)
     }
 }
 
+void AsyncCompleteCallbackGetActiveNotifications(napi_env env, napi_status status, void *data)
+{
+    ANS_LOGI("GetActiveNotifications napi_create_async_work end");
+
+    if (!data) {
+        ANS_LOGE("Invalid async callback data");
+        return;
+    }
+
+    AsyncCallbackInfoActive *asynccallbackinfo = (AsyncCallbackInfoActive *)data;
+    napi_value result = nullptr;
+    if (asynccallbackinfo->info.errorCode != ERR_OK) {
+        result = Common::NapiGetNull(env);
+    } else {
+        napi_value arr = nullptr;
+        int count = 0;
+        napi_create_array(env, &arr);
+        for (auto vec : asynccallbackinfo->requests) {
+            if (!vec) {
+                ANS_LOGW("Invalid NotificationRequest object ptr");
+                continue;
+            }
+            napi_value requestResult = nullptr;
+            napi_create_object(env, &requestResult);
+            if (!Common::SetNotificationRequest(env, vec.GetRefPtr(), requestResult)) {
+                ANS_LOGW("Set NotificationRequest object failed");
+                continue;
+            }
+            napi_set_element(env, arr, count, requestResult);
+            count++;
+        }
+        ANS_LOGI("GetActiveNotifications count = %{public}d", count);
+        result = arr;
+        if ((count == 0) && (asynccallbackinfo->requests.size() > 0)) {
+            asynccallbackinfo->info.errorCode = ERROR;
+            result = Common::NapiGetNull(env);
+        }
+    }
+    Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
+
+    if (asynccallbackinfo->info.callback != nullptr) {
+        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    }
+
+    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+    if (asynccallbackinfo) {
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
+    }
+}
+
 napi_value GetActiveNotifications(napi_env env, napi_callback_info info)
 {
     ANS_LOGI("enter");
@@ -181,52 +244,10 @@ napi_value GetActiveNotifications(napi_env env, napi_callback_info info)
             ANS_LOGI("GetActiveNotifications napi_create_async_work start");
             AsyncCallbackInfoActive *asynccallbackinfo = (AsyncCallbackInfoActive *)data;
 
-            std::vector<sptr<OHOS::Notification::NotificationRequest>> requests;
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetActiveNotifications(requests);
-            if (asynccallbackinfo->info.errorCode != ERR_OK) {
-                asynccallbackinfo->result = Common::NapiGetNull(env);
-                return;
-            }
-            napi_value arr = nullptr;
-            int count = 0;
-            napi_create_array(env, &arr);
-            for (auto vec : requests) {
-                if (!vec) {
-                    ANS_LOGW("Invalid NotificationRequest object ptr");
-                    continue;
-                }
-                napi_value result = nullptr;
-                napi_create_object(env, &result);
-                if (!Common::SetNotificationRequest(env, vec.GetRefPtr(), result)) {
-                    ANS_LOGW("Set NotificationRequest object failed");
-                    continue;
-                }
-                napi_set_element(env, arr, count, result);
-                count++;
-            }
-            ANS_LOGI("GetActiveNotifications count = %{public}d", count);
-            asynccallbackinfo->result = arr;
-            if ((count == 0) && (requests.size() > 0)) {
-                asynccallbackinfo->info.errorCode = ERROR;
-                asynccallbackinfo->result = Common::NapiGetNull(env);
-            }
-        },
-        [](napi_env env, napi_status status, void *data) {
-            ANS_LOGI("GetActiveNotifications napi_create_async_work end");
-            AsyncCallbackInfoActive *asynccallbackinfo = (AsyncCallbackInfoActive *)data;
-
-            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, asynccallbackinfo->result);
-
-            if (asynccallbackinfo->info.callback != nullptr) {
-                napi_delete_reference(env, asynccallbackinfo->info.callback);
-            }
-
-            napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-            if (asynccallbackinfo) {
-                delete asynccallbackinfo;
-                asynccallbackinfo = nullptr;
-            }
+            asynccallbackinfo->info.errorCode =
+                NotificationHelper::GetActiveNotifications(asynccallbackinfo->requests);
         },
+        AsyncCompleteCallbackGetActiveNotifications,
         (void *)asynccallbackinfo,
         &asynccallbackinfo->asyncWork);
 
@@ -239,6 +260,36 @@ napi_value GetActiveNotifications(napi_env env, napi_callback_info info)
     }
 }
 
+void AsyncCompleteCallbackGetActiveNotificationCount(napi_env env, napi_status status, void *data)
+{
+    ANS_LOGI("GetActiveNotificationCount napi_create_async_work end");
+
+    if (!data) {
+        ANS_LOGE("Invalid async callback data");
+        return;
+    }
+
+    AsyncCallbackInfoActive *asynccallbackinfo = (AsyncCallbackInfoActive *)data;
+    napi_value result = nullptr;
+    if (asynccallbackinfo->info.errorCode != ERR_OK) {
+        result = Common::NapiGetNull(env);
+    } else {
+        napi_create_int32(env, asynccallbackinfo->num, &result);
+    }
+
+    Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
+
+    if (asynccallbackinfo->info.callback != nullptr) {
+        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    }
+
+    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+    if (asynccallbackinfo) {
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
+    }
+}
+
 napi_value GetActiveNotificationCount(napi_env env, napi_callback_info info)
 {
     ANS_LOGI("enter");
@@ -267,31 +318,10 @@ napi_value GetActiveNotificationCount(napi_env env, napi_callback_info info)
             ANS_LOGI("GetActiveNotificationCount napi_create_async_work start");
             AsyncCallbackInfoActive *asynccallbackinfo = (AsyncCallbackInfoActive *)data;
 
-            int32_t num = 0;
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetActiveNotificationNums(num);
-            ANS_LOGI("GetActiveNotificationCount count = %{public}d", num);
-            if (asynccallbackinfo->info.errorCode != ERR_OK) {
-                asynccallbackinfo->result = Common::NapiGetNull(env);
-                return;
-            }
-            napi_create_int32(env, num, &asynccallbackinfo->result);
-        },
-        [](napi_env env, napi_status status, void *data) {
-            ANS_LOGI("GetActiveNotificationCount napi_create_async_work end");
-            AsyncCallbackInfoActive *asynccallbackinfo = (AsyncCallbackInfoActive *)data;
-
-            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, asynccallbackinfo->result);
-
-            if (asynccallbackinfo->info.callback != nullptr) {
-                napi_delete_reference(env, asynccallbackinfo->info.callback);
-            }
-
-            napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-            if (asynccallbackinfo) {
-                delete asynccallbackinfo;
-                asynccallbackinfo = nullptr;
-            }
+            asynccallbackinfo->info.errorCode = NotificationHelper::GetActiveNotificationNums(asynccallbackinfo->num);
+            ANS_LOGI("GetActiveNotificationCount count = %{public}d", asynccallbackinfo->num);
         },
+        AsyncCompleteCallbackGetActiveNotificationCount,
         (void *)asynccallbackinfo,
         &asynccallbackinfo->asyncWork);
 
diff --git a/interfaces/kits/napi/ans/src/slot.cpp b/interfaces/kits/napi/ans/src/slot.cpp
index c5ba3fe797ec355bd0db347207f8081a09224619..4590c92ee27caa823d333eaee768b71750995188 100644
--- a/interfaces/kits/napi/ans/src/slot.cpp
+++ b/interfaces/kits/napi/ans/src/slot.cpp
@@ -77,8 +77,8 @@ struct AsyncCallbackInfoGetSlot {
     napi_env env = nullptr;
     napi_async_work asyncWork = nullptr;
     enum NotificationConstant::SlotType outType = NotificationConstant::SlotType::OTHER;
-    napi_value result = nullptr;
     CallbackPromiseInfo info;
+    sptr<NotificationSlot> slot = nullptr;
 };
 
 struct ParametersInfoGetSlotNumByBundle {
@@ -89,16 +89,16 @@ struct ParametersInfoGetSlotNumByBundle {
 struct AsyncCallbackInfoGetSlotNumByBundle {
     napi_env env = nullptr;
     napi_async_work asyncWork = nullptr;
-    napi_value result = nullptr;
     ParametersInfoGetSlotNumByBundle params;
     CallbackPromiseInfo info;
+    int num = 0;
 };
 
 struct AsyncCallbackInfoGetSlots {
     napi_env env = nullptr;
     napi_async_work asyncWork = nullptr;
-    napi_value result = nullptr;
     CallbackPromiseInfo info;
+    std::vector<sptr<NotificationSlot>> slots;
 };
 
 struct ParametersInfoGetSlotsByBundle {
@@ -109,9 +109,9 @@ struct ParametersInfoGetSlotsByBundle {
 struct AsyncCallbackInfoGetSlotsByBundle {
     napi_env env = nullptr;
     napi_async_work asyncWork = nullptr;
-    napi_value result = nullptr;
     ParametersInfoGetSlotsByBundle params;
     CallbackPromiseInfo info;
+    std::vector<sptr<NotificationSlot>> slots;
 };
 
 struct ParametersInfoRemoveSlot {
@@ -594,6 +594,42 @@ napi_value SetSlotByBundle(napi_env env, napi_callback_info info)
     }
 }
 
+
+void AsyncCompleteCallbackGetSlot(napi_env env, napi_status status, void *data)
+{
+    ANS_LOGI("GetSlot napi_create_async_work end");
+
+    if (!data) {
+        ANS_LOGE("Invalid async callback data");
+        return;
+    }
+
+    AsyncCallbackInfoGetSlot *asynccallbackinfo = (AsyncCallbackInfoGetSlot *)data;
+    napi_value result = Common::NapiGetNull(env);
+    if (asynccallbackinfo->info.errorCode == ERR_OK) {
+        if (asynccallbackinfo->slot == nullptr) {
+            asynccallbackinfo->info.errorCode = ERROR;
+        } else {
+            napi_create_object(env, &result);
+            if (!Common::SetNotificationSlot(env, *asynccallbackinfo->slot, result)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
+            }
+        }
+    }
+    Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
+
+    if (asynccallbackinfo->info.callback != nullptr) {
+        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    }
+
+    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+    if (asynccallbackinfo) {
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
+    }
+}
+
 napi_value GetSlot(napi_env env, napi_callback_info info)
 {
     ANS_LOGI("enter");
@@ -621,39 +657,10 @@ napi_value GetSlot(napi_env env, napi_callback_info info)
             ANS_LOGI("GetSlot napi_create_async_work start");
             AsyncCallbackInfoGetSlot *asynccallbackinfo = (AsyncCallbackInfoGetSlot *)data;
 
-            sptr<NotificationSlot> slot = nullptr;
             asynccallbackinfo->info.errorCode =
-                NotificationHelper::GetNotificationSlot(asynccallbackinfo->outType, slot);
-            asynccallbackinfo->result = Common::NapiGetNull(env);
-            if (asynccallbackinfo->info.errorCode != ERR_OK) {
-                return;
-            }
-            if (slot == nullptr) {
-                asynccallbackinfo->info.errorCode = ERROR;
-                return;
-            }
-            napi_create_object(env, &asynccallbackinfo->result);
-            if (!Common::SetNotificationSlot(env, *slot, asynccallbackinfo->result)) {
-                asynccallbackinfo->info.errorCode = ERROR;
-                asynccallbackinfo->result = Common::NapiGetNull(env);
-            }
-        },
-        [](napi_env env, napi_status status, void *data) {
-            ANS_LOGI("GetSlot napi_create_async_work end");
-            AsyncCallbackInfoGetSlot *asynccallbackinfo = (AsyncCallbackInfoGetSlot *)data;
-
-            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, asynccallbackinfo->result);
-
-            if (asynccallbackinfo->info.callback != nullptr) {
-                napi_delete_reference(env, asynccallbackinfo->info.callback);
-            }
-
-            napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-            if (asynccallbackinfo) {
-                delete asynccallbackinfo;
-                asynccallbackinfo = nullptr;
-            }
+                NotificationHelper::GetNotificationSlot(asynccallbackinfo->outType, asynccallbackinfo->slot);
         },
+        AsyncCompleteCallbackGetSlot,
         (void *)asynccallbackinfo,
         &asynccallbackinfo->asyncWork);
 
@@ -696,15 +703,16 @@ napi_value GetSlotNumByBundle(napi_env env, napi_callback_info info)
             NotificationBundleOption bundleOption;
             bundleOption.SetBundleName(asynccallbackinfo->params.option.bundle);
             bundleOption.SetUid(asynccallbackinfo->params.option.uid);
-            int num = 0;
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotNumAsBundle(bundleOption, num);
-            napi_create_int32(env, num, &asynccallbackinfo->result);
+            asynccallbackinfo->info.errorCode =
+                NotificationHelper::GetNotificationSlotNumAsBundle(bundleOption, asynccallbackinfo->num);
+
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("GetSlotNumByBundle napi_create_async_work end");
             AsyncCallbackInfoGetSlotNumByBundle *asynccallbackinfo = (AsyncCallbackInfoGetSlotNumByBundle *)data;
-
-            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, asynccallbackinfo->result);
+            napi_value result = nullptr;
+            napi_create_int32(env, asynccallbackinfo->num, &result);
+            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
 
             if (asynccallbackinfo->info.callback != nullptr) {
                 napi_delete_reference(env, asynccallbackinfo->info.callback);
@@ -754,42 +762,39 @@ napi_value GetSlots(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetSlots napi_create_async_work start");
             AsyncCallbackInfoGetSlots *asynccallbackinfo = (AsyncCallbackInfoGetSlots *)data;
-
-            std::vector<sptr<NotificationSlot>> slots;
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlots(slots);
-            if (asynccallbackinfo->info.errorCode != ERR_OK) {
-                asynccallbackinfo->result = Common::NapiGetNull(env);
-                return;
-            }
-
-            napi_value arr = nullptr;
-            napi_create_array(env, &arr);
-            size_t count = 0;
-            for (auto vec : slots) {
-                if (!vec) {
-                    ANS_LOGW("Invalid NotificationSlot object ptr");
-                    continue;
-                }
-                napi_value nSlot = nullptr;
-                napi_create_object(env, &nSlot);
-                if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
-                    continue;
-                }
-                napi_set_element(env, arr, count, nSlot);
-                count++;
-            }
-            ANS_LOGI("getSlots count = %{public}zu", count);
-            asynccallbackinfo->result = arr;
-            if ((count == 0) && (slots.size() > 0)) {
-                asynccallbackinfo->info.errorCode = ERROR;
-                asynccallbackinfo->result = Common::NapiGetNull(env);
-            }
+            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlots(asynccallbackinfo->slots);
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("GetSlots napi_create_async_work end");
             AsyncCallbackInfoGetSlots *asynccallbackinfo = (AsyncCallbackInfoGetSlots *)data;
-
-            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, asynccallbackinfo->result);
+            napi_value result = nullptr;
+            if (asynccallbackinfo->info.errorCode != ERR_OK) {
+                result = Common::NapiGetNull(env);
+            } else {
+                napi_value arr = nullptr;
+                napi_create_array(env, &arr);
+                size_t count = 0;
+                for (auto vec : asynccallbackinfo->slots) {
+                    if (!vec) {
+                        ANS_LOGW("Invalid NotificationSlot object ptr");
+                        continue;
+                    }
+                    napi_value nSlot = nullptr;
+                    napi_create_object(env, &nSlot);
+                    if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
+                        continue;
+                    }
+                    napi_set_element(env, arr, count, nSlot);
+                    count++;
+                }
+                ANS_LOGI("getSlots count = %{public}zu", count);
+                result = arr;
+                if ((count == 0) && (asynccallbackinfo->slots.size() > 0)) {
+                    asynccallbackinfo->info.errorCode = ERROR;
+                    result = Common::NapiGetNull(env);
+                }
+            }
+            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
 
             if (asynccallbackinfo->info.callback != nullptr) {
                 napi_delete_reference(env, asynccallbackinfo->info.callback);
@@ -843,42 +848,41 @@ napi_value GetSlotsByBundle(napi_env env, napi_callback_info info)
             NotificationBundleOption bundleOption;
             bundleOption.SetBundleName(asynccallbackinfo->params.option.bundle);
             bundleOption.SetUid(asynccallbackinfo->params.option.uid);
-
-            std::vector<sptr<NotificationSlot>> slots;
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotsForBundle(bundleOption, slots);
-            if (asynccallbackinfo->info.errorCode != ERR_OK) {
-                asynccallbackinfo->result = Common::NapiGetNull(env);
-                return;
-            }
-
-            napi_value arr = nullptr;
-            napi_create_array(env, &arr);
-            size_t count = 0;
-            for (auto vec : slots) {
-                if (!vec) {
-                    ANS_LOGW("Invalid NotificationSlot object ptr");
-                    continue;
-                }
-                napi_value nSlot = nullptr;
-                napi_create_object(env, &nSlot);
-                if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
-                    continue;
-                }
-                napi_set_element(env, arr, count, nSlot);
-                count++;
-            }
-            ANS_LOGI("getSlots count = %{public}zu", count);
-            asynccallbackinfo->result = arr;
-            if ((count == 0) && (slots.size() > 0)) {
-                asynccallbackinfo->info.errorCode = ERROR;
-                asynccallbackinfo->result = Common::NapiGetNull(env);
-            }
+            asynccallbackinfo->info.errorCode =
+                NotificationHelper::GetNotificationSlotsForBundle(bundleOption, asynccallbackinfo->slots);
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("GetSlotsByBundle napi_create_async_work end");
             AsyncCallbackInfoGetSlotsByBundle *asynccallbackinfo = (AsyncCallbackInfoGetSlotsByBundle *)data;
 
-            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, asynccallbackinfo->result);
+            napi_value result = nullptr;
+            if (asynccallbackinfo->info.errorCode != ERR_OK) {
+                result = Common::NapiGetNull(env);
+            } else {
+                napi_value arr = nullptr;
+                napi_create_array(env, &arr);
+                size_t count = 0;
+                for (auto vec : asynccallbackinfo->slots) {
+                    if (!vec) {
+                        ANS_LOGW("Invalid NotificationSlot object ptr");
+                        continue;
+                    }
+                    napi_value nSlot = nullptr;
+                    napi_create_object(env, &nSlot);
+                    if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
+                        continue;
+                    }
+                    napi_set_element(env, arr, count, nSlot);
+                    count++;
+                }
+                ANS_LOGI("getSlots count = %{public}zu", count);
+                result = arr;
+                if ((count == 0) && (asynccallbackinfo->slots.size() > 0)) {
+                    asynccallbackinfo->info.errorCode = ERROR;
+                    result = Common::NapiGetNull(env);
+                }
+            }
+            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
 
             if (asynccallbackinfo->info.callback != nullptr) {
                 napi_delete_reference(env, asynccallbackinfo->info.callback);
diff --git a/services/ans/src/advanced_notification_service.cpp b/services/ans/src/advanced_notification_service.cpp
index d67e8c03193704caa31cbd63f33b0f079f710ba1..153e6bc7247116b5c482d596162835dc5a583dd3 100644
--- a/services/ans/src/advanced_notification_service.cpp
+++ b/services/ans/src/advanced_notification_service.cpp
@@ -502,8 +502,13 @@ ErrCode AdvancedNotificationService::GetSlots(std::vector<sptr<NotificationSlot>
     }
 
     ErrCode result = ERR_OK;
-    handler_->PostSyncTask(std::bind(
-        [&]() { result = NotificationPreferences::GetInstance().GetNotificationAllSlots(bundleOption, slots); }));
+    handler_->PostSyncTask(std::bind([&]() {
+        result = NotificationPreferences::GetInstance().GetNotificationAllSlots(bundleOption, slots);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_OK;
+            slots.clear();
+        }
+    }));
     return result;
 }
 
@@ -519,6 +524,9 @@ ErrCode AdvancedNotificationService::GetSlotGroup(const std::string &groupId, sp
     ErrCode result = ERR_OK;
     handler_->PostSyncTask(std::bind([&]() {
         result = NotificationPreferences::GetInstance().GetNotificationSlotGroup(bundleOption, groupId, group);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOTGROUP_NOT_EXIST;
+        }
     }));
     return result;
 }
@@ -533,8 +541,13 @@ ErrCode AdvancedNotificationService::GetSlotGroups(std::vector<sptr<Notification
     }
 
     ErrCode result = ERR_OK;
-    handler_->PostSyncTask(std::bind(
-        [&]() { result = NotificationPreferences::GetInstance().GetNotificationAllSlotGroups(bundleOption, groups); }));
+    handler_->PostSyncTask(std::bind([&]() {
+        result = NotificationPreferences::GetInstance().GetNotificationAllSlotGroups(bundleOption, groups);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_OK;
+            groups.clear();
+        }
+    }));
     return result;
 }
 
@@ -548,6 +561,9 @@ ErrCode AdvancedNotificationService::RemoveSlotGroups(const std::vector<std::str
     ErrCode result = ERR_OK;
     handler_->PostSyncTask(std::bind([&]() {
         result = NotificationPreferences::GetInstance().RemoveNotificationSlotGroups(bundleOption, groupIds);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOTGROUP_ID_INVALID;
+        }
     }));
     return result;
 }
@@ -709,6 +725,10 @@ ErrCode AdvancedNotificationService::GetPrivateNotificationsAllowed(bool &allow)
     ErrCode result = ERR_OK;
     handler_->PostSyncTask(std::bind([&]() {
         result = NotificationPreferences::GetInstance().GetPrivateNotificationsAllowed(bundleOption, allow);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_OK;
+            allow = false;
+        }
     }));
     return result;
 }
@@ -843,8 +863,13 @@ ErrCode AdvancedNotificationService::GetSlotsByBundle(
     }
 
     ErrCode result = ERR_OK;
-    handler_->PostSyncTask(
-        std::bind([&]() { result = NotificationPreferences::GetInstance().GetNotificationAllSlots(bundle, slots); }));
+    handler_->PostSyncTask(std::bind([&]() {
+        result = NotificationPreferences::GetInstance().GetNotificationAllSlots(bundle, slots);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_OK;
+            slots.clear();
+        }
+    }));
     return result;
 }
 
@@ -863,8 +888,12 @@ ErrCode AdvancedNotificationService::UpdateSlots(
     }
 
     ErrCode result = ERR_OK;
-    handler_->PostSyncTask(
-        std::bind([&]() { result = NotificationPreferences::GetInstance().UpdateNotificationSlots(bundle, slots); }));
+    handler_->PostSyncTask(std::bind([&]() {
+        result = NotificationPreferences::GetInstance().UpdateNotificationSlots(bundle, slots);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOT_TYPE_NOT_EXIST;
+        }
+    }));
     return result;
 }
 
@@ -883,8 +912,12 @@ ErrCode AdvancedNotificationService::UpdateSlotGroups(
     }
 
     ErrCode result = ERR_OK;
-    handler_->PostSyncTask(std::bind(
-        [&]() { result = NotificationPreferences::GetInstance().UpdateNotificationSlotGroups(bundle, groups); }));
+    handler_->PostSyncTask(std::bind([&]() {
+        result = NotificationPreferences::GetInstance().UpdateNotificationSlotGroups(bundle, groups);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOTGROUP_NOT_EXIST;
+        }
+    }));
     return result;
 }
 
@@ -943,8 +976,13 @@ ErrCode AdvancedNotificationService::GetShowBadgeEnabled(bool &enabled)
     }
 
     ErrCode result = ERR_OK;
-    handler_->PostSyncTask(
-        std::bind([&]() { result = NotificationPreferences::GetInstance().IsShowBadge(bundleOption, enabled); }));
+    handler_->PostSyncTask(std::bind([&]() {
+        result = NotificationPreferences::GetInstance().IsShowBadge(bundleOption, enabled);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_OK;
+            enabled = false;
+        }
+    }));
     return result;
 }
 
@@ -1029,8 +1067,12 @@ ErrCode AdvancedNotificationService::GetSlotByType(
     }
 
     ErrCode result = ERR_OK;
-    handler_->PostSyncTask(std::bind(
-        [&]() { result = NotificationPreferences::GetInstance().GetNotificationSlot(bundleOption, slotType, slot); }));
+    handler_->PostSyncTask(std::bind([&]() {
+        result = NotificationPreferences::GetInstance().GetNotificationSlot(bundleOption, slotType, slot);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOT_TYPE_NOT_EXIST;
+        }
+    }));
     return result;
 }
 
@@ -1044,8 +1086,12 @@ ErrCode AdvancedNotificationService::RemoveSlotByType(const NotificationConstant
     }
 
     ErrCode result = ERR_OK;
-    handler_->PostSyncTask(std::bind(
-        [&]() { result = NotificationPreferences::GetInstance().RemoveNotificationSlot(bundleOption, slotType); }));
+    handler_->PostSyncTask(std::bind([&]() {
+        result = NotificationPreferences::GetInstance().RemoveNotificationSlot(bundleOption, slotType);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOT_TYPE_NOT_EXIST;
+        }
+    }));
     return result;
 }
 
@@ -1200,6 +1246,10 @@ ErrCode AdvancedNotificationService::IsSpecialBundleAllowedNotify(
         result = NotificationPreferences::GetInstance().GetNotificationsEnabled(allowed);
         if (result == ERR_OK && allowed) {
             result = NotificationPreferences::GetInstance().GetNotificationsEnabledForBundle(targetBundle, allowed);
+            if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+                result = ERR_OK;
+                allowed = true;
+            }
         }
     }));
     return result;
@@ -1428,8 +1478,12 @@ ErrCode AdvancedNotificationService::RemoveAllSlots()
     }
 
     ErrCode result = ERR_OK;
-    handler_->PostSyncTask(
-        std::bind([&]() { result = NotificationPreferences::GetInstance().RemoveNotificationAllSlots(bundleOption); }));
+    handler_->PostSyncTask(std::bind([&]() {
+        result = NotificationPreferences::GetInstance().RemoveNotificationAllSlots(bundleOption);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_OK;
+        }
+    }));
     return result;
 }
 
@@ -1555,8 +1609,13 @@ ErrCode AdvancedNotificationService::GetSlotNumAsBundle(const sptr<NotificationB
 
     ErrCode result = ERR_OK;
 
-    handler_->PostSyncTask(std::bind(
-        [&]() { result = NotificationPreferences::GetInstance().GetNotificationSlotsNumForBundle(bundle, num); }));
+    handler_->PostSyncTask(std::bind([&]() {
+        result = NotificationPreferences::GetInstance().GetNotificationSlotsNumForBundle(bundle, num);
+        if (result == ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST) {
+            result = ERR_OK;
+            num = 0;
+        }
+    }));
 
     return result;
 }
diff --git a/services/ans/src/notification_preferences.cpp b/services/ans/src/notification_preferences.cpp
index dc3ebcb9b7e32ff62def86d7468aab6312d15eff..a95b1fcc5771c4cd458655b148c9382d9426fab2 100644
--- a/services/ans/src/notification_preferences.cpp
+++ b/services/ans/src/notification_preferences.cpp
@@ -295,7 +295,7 @@ ErrCode NotificationPreferences::GetNotificationAllSlots(
     if (preferencesInfo_.GetBundleInfo(bundleOption, bundleInfo)) {
         bundleInfo.GetAllSlots(slots);
     } else {
-        ANS_LOGE("Notification bundle does not exsit.");
+        ANS_LOGW("Notification bundle does not exsit.");
         result = ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST;
     }
 
@@ -333,7 +333,7 @@ ErrCode NotificationPreferences::GetNotificationSlotGroup(
             result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOTGROUP_NOT_EXIST;
         }
     } else {
-        ANS_LOGE("Notification bundle does not exsit.");
+        ANS_LOGW("Notification bundle does not exsit.");
         result = ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST;
     }
     return result;
@@ -351,7 +351,7 @@ ErrCode NotificationPreferences::GetNotificationAllSlotGroups(
     if (preferencesInfo_.GetBundleInfo(bundleOption, bundleInfo)) {
         bundleInfo.GetAllGroups(groups);
     } else {
-        ANS_LOGE("Notification bundle does not exsit.");
+        ANS_LOGW("Notification bundle does not exsit.");
         result = ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST;
     }
     return result;
@@ -369,7 +369,7 @@ ErrCode NotificationPreferences::GetNotificationAllSlotInSlotGroup(const sptr<No
     if (preferencesInfo_.GetBundleInfo(bundleOption, bundleInfo)) {
         bundleInfo.GetAllSlotsInGroup(groupId, slots);
     } else {
-        ANS_LOGE("Notification bundle does not exsit.");
+        ANS_LOGW("Notification bundle does not exsit.");
         result = ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST;
     }
     return result;
@@ -608,7 +608,7 @@ ErrCode NotificationPreferences::CheckSlotForRemoveSlot(const sptr<NotificationB
             result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOT_TYPE_NOT_EXIST;
         }
     } else {
-        ANS_LOGE("Notification bundle does not exsit.");
+        ANS_LOGW("Notification bundle does not exsit.");
         result = ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST;
     }
     return result;
@@ -628,7 +628,7 @@ ErrCode NotificationPreferences::CheckGroupForRemoveSlotGroup(const sptr<Notific
             result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOTGROUP_ID_INVALID;
         }
     } else {
-        ANS_LOGE("Notification bundle does not exsit.");
+        ANS_LOGW("Notification bundle does not exsit.");
         result = ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST;
     }
     return result;
@@ -655,7 +655,7 @@ ErrCode NotificationPreferences::CheckSlotForUpdateSlot(const sptr<NotificationB
             result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOT_TYPE_NOT_EXIST;
         }
     } else {
-        ANS_LOGE("Notification bundle does not exsit.");
+        ANS_LOGW("Notification bundle does not exsit.");
         result = ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST;
     }
 
@@ -677,7 +677,7 @@ ErrCode NotificationPreferences::CheckGroupForUpdateSlotGroup(const sptr<Notific
             result = ERR_ANS_PREFERENCES_NOTIFICATION_SLOTGROUP_NOT_EXIST;
         }
     } else {
-        ANS_LOGE("Notification slot is nullptr.");
+        ANS_LOGW("Notification slot is nullptr.");
         result = ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST;
     }
     return result;
@@ -760,7 +760,7 @@ ErrCode NotificationPreferences::GetBundleProperty(
                 break;
         }
     } else {
-        ANS_LOGE("Notification bundle does not exsit.");
+        ANS_LOGW("Notification bundle does not exsit.");
         result = ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST;
     }
     return result;
diff --git a/services/ans/test/unittest/advanced_notification_service_test.cpp b/services/ans/test/unittest/advanced_notification_service_test.cpp
index f79dc6a38fbb6d3ca24a017f98a34403f8eb23e4..b54d4b57f5205b39505d2ce2827c520cd2020e6e 100644
--- a/services/ans/test/unittest/advanced_notification_service_test.cpp
+++ b/services/ans/test/unittest/advanced_notification_service_test.cpp
@@ -1251,7 +1251,7 @@ HWTEST_F(AdvancedNotificationServiceTest, AdvancedNotificationServiceTest_09800,
     bool allowed = true;
     EXPECT_EQ((int)advancedNotificationService_->IsSpecialBundleAllowedNotify(
                   new NotificationBundleOption(TEST_DEFUALT_BUNDLE, SYSTEM_APP_UID), allowed),
-        (int)ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST);
+        (int)ERR_OK);
 }
 
 /**
@@ -1264,7 +1264,7 @@ HWTEST_F(AdvancedNotificationServiceTest, AdvancedNotificationServiceTest_09900,
     std::vector<sptr<NotificationSlot>> slots;
     EXPECT_EQ((int)advancedNotificationService_->GetSlotsByBundle(
                   new NotificationBundleOption(TEST_DEFUALT_BUNDLE, NON_SYSTEM_APP_UID), slots),
-        (int)ERR_ANS_PREFERENCES_NOTIFICATION_BUNDLE_NOT_EXIST);
+        (int)ERR_OK);
 }
 
 inline std::shared_ptr<PixelMap> MakePixelMap(int32_t width, int32_t height)