diff --git a/frameworks/ans/src/reminder_request_calendar.cpp b/frameworks/ans/src/reminder_request_calendar.cpp
index 4448f2aef83a843d275fe4b65246ff93a770f7f0..baefcf5d5e608c028ad24375687c963b3a7bf2f9 100644
--- a/frameworks/ans/src/reminder_request_calendar.cpp
+++ b/frameworks/ans/src/reminder_request_calendar.cpp
@@ -572,16 +572,18 @@ void ReminderRequestCalendar::AppendValuesBucket(const sptr<ReminderRequest> &re
     uint8_t minute = 0;
     if (reminder->GetReminderType() == ReminderRequest::ReminderType::CALENDAR) {
         ReminderRequestCalendar* calendar = static_cast<ReminderRequestCalendar*>(reminder.GetRefPtr());
-        repeatDay = calendar->GetRepeatDay();
-        repeatMonth = calendar->GetRepeatMonth();
-        firstDesignateYear = calendar->GetFirstDesignateYear();
-        firstDesignateMonth = calendar->GetFirstDesignageMonth();
-        firstDesignateDay = calendar->GetFirstDesignateDay();
-        year = calendar->GetYear();
-        month = calendar->GetMonth();
-        day = calendar->GetDay();
-        hour = calendar->GetHour();
-        minute = calendar->GetMinute();
+        if (calendar != nullptr) {
+            repeatDay = calendar->GetRepeatDay();
+            repeatMonth = calendar->GetRepeatMonth();
+            firstDesignateYear = calendar->GetFirstDesignateYear();
+            firstDesignateMonth = calendar->GetFirstDesignageMonth();
+            firstDesignateDay = calendar->GetFirstDesignateDay();
+            year = calendar->GetYear();
+            month = calendar->GetMonth();
+            day = calendar->GetDay();
+            hour = calendar->GetHour();
+            minute = calendar->GetMinute();
+        }
     }
     values.PutInt(REPEAT_DAYS, repeatDay);
     values.PutInt(REPEAT_MONTHS, repeatMonth);
diff --git a/frameworks/ans/src/reminder_store.cpp b/frameworks/ans/src/reminder_store.cpp
index 0fce2c8bc69cd96bae4a2c7a5e4d8eefca51f728..e3b8cf9007928414bd164281965f8ba16cc79d6d 100644
--- a/frameworks/ans/src/reminder_store.cpp
+++ b/frameworks/ans/src/reminder_store.cpp
@@ -240,11 +240,9 @@ int64_t ReminderStore::Update(
 
 bool ReminderStore::IsReminderExist(const sptr<ReminderRequest> &reminder)
 {
-    std::string queryCondition = "select " + ReminderRequest::REMINDER_ID
-        + " from " + REMINDER_DB_TABLE + " where "
-        + ReminderRequest::REMINDER_ID + " = " + std::to_string(reminder->GetReminderId());
-    std::vector<std::string> whereArgs;
-    std::unique_ptr<NativeRdb::AbsSharedResultSet> queryResultSet = rdbStore_->QuerySql(queryCondition, whereArgs);
+    NativeRdb::AbsRdbPredicates absRdbPredicates(REMINDER_DB_TABLE);
+    absRdbPredicates.EqualTo(ReminderRequest::REMINDER_ID, std::to_string(reminder->GetReminderId()));
+    std::unique_ptr<NativeRdb::AbsSharedResultSet> queryResultSet = rdbStore_->Query(absRdbPredicates, std::vector<std::string>());
     if (queryResultSet == nullptr) {
         ANSR_LOGE("QueryResultSet is null.");
         return false;
@@ -381,10 +379,9 @@ sptr<ReminderRequest> ReminderStore::BuildReminder(const std::shared_ptr<NativeR
 
 bool ReminderStore::GetBundleOption(const int32_t &reminderId, sptr<NotificationBundleOption> &bundleOption) const
 {
-    std::string queryCondition = "select " + ReminderRequest::PKG_NAME + ", "
-        + ReminderRequest::UID + " from " + REMINDER_DB_TABLE + " where "
-        + ReminderRequest::REMINDER_ID + "=" + std::to_string(reminderId);
-    std::shared_ptr<NativeRdb::AbsSharedResultSet> queryResultSet = Query(queryCondition);
+    NativeRdb::AbsRdbPredicates absRdbPredicates(REMINDER_DB_TABLE);
+    absRdbPredicates.EqualTo(ReminderRequest::REMINDER_ID, std::to_string(reminderId));
+    std::shared_ptr<NativeRdb::AbsSharedResultSet> queryResultSet = rdbStore_->Query(absRdbPredicates, std::vector<std::string>());
     if (queryResultSet == nullptr) {
         return false;
     }
diff --git a/frameworks/js/napi/src/display_badge.cpp b/frameworks/js/napi/src/display_badge.cpp
index f0680657e46f0d4933ec5479fa1d09024164dfd3..cced5ba2df85e502fc911d12e1882ae40f2f6175 100644
--- a/frameworks/js/napi/src/display_badge.cpp
+++ b/frameworks/js/napi/src/display_badge.cpp
@@ -186,15 +186,17 @@ void AsyncCompleteCallbackIsBadgeDisplayed(napi_env env, napi_status status, voi
         return;
     }
     AsyncCallbackInfoIsDisplayBadge *asynccallbackinfo = static_cast<AsyncCallbackInfoIsDisplayBadge *>(data);
-    napi_value result = nullptr;
-    napi_get_boolean(env, asynccallbackinfo->enabled, &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);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        napi_get_boolean(env, asynccallbackinfo->enabled, &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);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
+    }
 }
 
 napi_value IsBadgeDisplayed(napi_env env, napi_callback_info info)
diff --git a/frameworks/js/napi/src/distributed.cpp b/frameworks/js/napi/src/distributed.cpp
index 6f1a492f6072fe4839725047a3a06539840dd5c4..71ef9c72f54cc58e6891206a25cf15a5813849b1 100644
--- a/frameworks/js/napi/src/distributed.cpp
+++ b/frameworks/js/napi/src/distributed.cpp
@@ -156,19 +156,21 @@ void AsyncCompleteCallbackIsDistributedEnabled(napi_env env, napi_status status,
     }
     ANS_LOGI("IsDistributedEnabled napi_create_async_work end");
     AsyncCallbackInfoIsEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabled *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        napi_get_boolean(env, asynccallbackinfo->enable, &result);
-    }
-    Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
+            result = Common::NapiGetNull(env);
+        } else {
+            napi_get_boolean(env, asynccallbackinfo->enable, &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);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value IsDistributedEnabled(napi_env env, napi_callback_info info)
@@ -302,9 +304,10 @@ napi_value EnableDistributedByBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("EnableDistributedByBundle napi_create_async_work start");
             AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::EnableDistributedByBundle(
-                asynccallbackinfo->params.option, asynccallbackinfo->params.enable);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::EnableDistributedByBundle(
+                    asynccallbackinfo->params.option, asynccallbackinfo->params.enable);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("EnableDistributedByBundle napi_create_async_work end");
@@ -358,9 +361,11 @@ napi_value EnableDistributedSelf(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("EnableDistributedSelf napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::EnableDistributedSelf(asynccallbackinfo->params.enable);
-            ANS_LOGI("EnableDistributedSelf enable = %{public}d", asynccallbackinfo->params.enable);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::EnableDistributedSelf(asynccallbackinfo->params.enable);
+                ANS_LOGI("EnableDistributedSelf enable = %{public}d", asynccallbackinfo->params.enable);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("EnableDistributedSelf napi_create_async_work end");
@@ -396,19 +401,21 @@ void AsyncCompleteCallbackIsDistributedEnableByBundle(napi_env env, napi_status
     }
     ANS_LOGI("IsDistributedEnableByBundle napi_create_async_work end");
     AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        napi_get_boolean(env, asynccallbackinfo->enable, &result);
-    }
-    Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
+            result = Common::NapiGetNull(env);
+        } else {
+            napi_get_boolean(env, asynccallbackinfo->enable, &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);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value IsDistributedEnableByBundle(napi_env env, napi_callback_info info)
@@ -438,9 +445,10 @@ napi_value IsDistributedEnableByBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("IsDistributedEnableByBundle napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnableByBundle(
-                asynccallbackinfo->params.option, asynccallbackinfo->enable);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnableByBundle(
+                    asynccallbackinfo->params.option, asynccallbackinfo->enable);
+            }
         },
         AsyncCompleteCallbackIsDistributedEnableByBundle,
         (void *)asynccallbackinfo,
@@ -464,24 +472,26 @@ void AsyncCompleteCallbackGetDeviceRemindType(napi_env env, napi_status status,
     }
     ANS_LOGI("GetDeviceRemindType napi_create_async_work end");
     AsyncCallbackInfoGetRemindType *asynccallbackinfo = static_cast<AsyncCallbackInfoGetRemindType *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        DeviceRemindType outType = DeviceRemindType::IDLE_DONOT_REMIND;
-        if (!Common::DeviceRemindTypeCToJS(asynccallbackinfo->remindType, outType)) {
-            asynccallbackinfo->info.errorCode = ERROR;
+    if (asynccallbackinfo){
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
             result = Common::NapiGetNull(env);
+        } else {
+            DeviceRemindType outType = DeviceRemindType::IDLE_DONOT_REMIND;
+            if (!Common::DeviceRemindTypeCToJS(asynccallbackinfo->remindType, outType)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
+            }
+            napi_create_int32(env, (int32_t)outType, &result);
         }
-        napi_create_int32(env, (int32_t)outType, &result);
-    }
-    Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+        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);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value GetDeviceRemindType(napi_env env, napi_callback_info info)
@@ -510,8 +520,10 @@ napi_value GetDeviceRemindType(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetDeviceRemindType napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetRemindType *>(data);
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::GetDeviceRemindType(asynccallbackinfo->remindType);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::GetDeviceRemindType(asynccallbackinfo->remindType);
+            }
         },
         AsyncCompleteCallbackGetDeviceRemindType,
         (void *)asynccallbackinfo,
diff --git a/frameworks/js/napi/src/disturb_mode.cpp b/frameworks/js/napi/src/disturb_mode.cpp
index 3ba80b6e7cd3324811c30a830b8cb60dbdef54bb..ff1290c969a03bdb2960b5a51e6f89f624bc1a6b 100644
--- a/frameworks/js/napi/src/disturb_mode.cpp
+++ b/frameworks/js/napi/src/disturb_mode.cpp
@@ -162,17 +162,19 @@ napi_value SetDoNotDisturbDate(napi_env env, napi_callback_info info)
         nullptr, resourceName, [](napi_env env, void *data) {
             ANS_LOGI("SetDoNotDisturbDate napi_create_async_work start");
             AsyncCallbackInfoSetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoSetDoNotDisturb *>(data);
-            if (asynccallbackinfo->params.hasUserId) {
-                asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
-                    asynccallbackinfo->params.userId, asynccallbackinfo->params.date);
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
-                    asynccallbackinfo->params.date);
-            }
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->params.hasUserId) {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
+                        asynccallbackinfo->params.userId, asynccallbackinfo->params.date);
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
+                        asynccallbackinfo->params.date);
+                }
 
-            ANS_LOGI("SetDoNotDisturbDate date=%{public}s errorCode=%{public}d, hasUserId=%{public}d",
-                asynccallbackinfo->params.date.Dump().c_str(), asynccallbackinfo->info.errorCode,
-                asynccallbackinfo->params.hasUserId);
+                ANS_LOGI("SetDoNotDisturbDate date=%{public}s errorCode=%{public}d, hasUserId=%{public}d",
+                    asynccallbackinfo->params.date.Dump().c_str(), asynccallbackinfo->info.errorCode,
+                    asynccallbackinfo->params.hasUserId);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("SetDoNotDisturbDate napi_create_async_work end");
@@ -206,20 +208,22 @@ void AsyncCompleteCallbackGetDoNotDisturbDate(napi_env env, napi_status status,
         return;
     }
     AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoGetDoNotDisturb *>(data);
-    napi_value result = Common::NapiGetNull(env);
-    if (asynccallbackinfo->info.errorCode == ERR_OK) {
-        napi_create_object(env, &result);
-        if (!Common::SetDoNotDisturbDate(env, asynccallbackinfo->date, result)) {
-            asynccallbackinfo->info.errorCode = ERROR;
+    if (asynccallbackinfo) {
+        napi_value result = Common::NapiGetNull(env);
+        if (asynccallbackinfo->info.errorCode == ERR_OK) {
+            napi_create_object(env, &result);
+            if (!Common::SetDoNotDisturbDate(env, asynccallbackinfo->date, result)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+            }
         }
+        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);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    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);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value ParseParameters(const napi_env &env, const napi_callback_info &info, GetDoNotDisturbDateParams &params)
@@ -286,16 +290,18 @@ napi_value GetDoNotDisturbDate(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetDoNotDisturbDate napi_create_async_work start");
             AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoGetDoNotDisturb *>(data);
-            if (asynccallbackinfo->params.hasUserId) {
-                asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(
-                    asynccallbackinfo->params.userId, asynccallbackinfo->date);
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(asynccallbackinfo->date);
-            }
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->params.hasUserId) {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(
+                        asynccallbackinfo->params.userId, asynccallbackinfo->date);
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(asynccallbackinfo->date);
+                }
 
-            ANS_LOGI("GetDoNotDisturbDate errorCode=%{public}d date=%{public}s, hasUserId=%{public}d",
-                asynccallbackinfo->info.errorCode, asynccallbackinfo->date.Dump().c_str(),
-                asynccallbackinfo->params.hasUserId);
+                ANS_LOGI("GetDoNotDisturbDate errorCode=%{public}d date=%{public}s, hasUserId=%{public}d",
+                    asynccallbackinfo->info.errorCode, asynccallbackinfo->date.Dump().c_str(),
+                    asynccallbackinfo->params.hasUserId);
+            }
         },
         AsyncCompleteCallbackGetDoNotDisturbDate,
         (void *)asynccallbackinfo,
@@ -339,10 +345,12 @@ napi_value SupportDoNotDisturbMode(napi_env env, napi_callback_info info)
             ANS_LOGI("SupportDoNotDisturbMode napi_create_async_work start");
             AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
                 static_cast<AsyncCallbackInfoSupportDoNotDisturb *>(data);
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::DoesSupportDoNotDisturbMode(asynccallbackinfo->isSupported);
-            ANS_LOGI("SupportDoNotDisturbMode errorCode=%{public}d isSupported=%{public}d",
-                asynccallbackinfo->info.errorCode, asynccallbackinfo->isSupported);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::DoesSupportDoNotDisturbMode(asynccallbackinfo->isSupported);
+                ANS_LOGI("SupportDoNotDisturbMode errorCode=%{public}d isSupported=%{public}d",
+                    asynccallbackinfo->info.errorCode, asynccallbackinfo->isSupported);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("SupportDoNotDisturbMode napi_create_async_work end");
diff --git a/frameworks/js/napi/src/enable_notification.cpp b/frameworks/js/napi/src/enable_notification.cpp
index 71b10ba00760bb3c9646660935b3700a68b54a99..11632b2658e751bedcaff3e16e1f4a5387da8c20 100644
--- a/frameworks/js/napi/src/enable_notification.cpp
+++ b/frameworks/js/napi/src/enable_notification.cpp
@@ -124,13 +124,15 @@ void AsyncCompleteCallbackEnableNotification(napi_env env, napi_status status, v
         return;
     }
     AsyncCallbackInfoEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoEnable *>(data);
-    Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value EnableNotification(napi_env env, napi_callback_info info)
@@ -160,9 +162,11 @@ napi_value EnableNotification(napi_env env, napi_callback_info info)
             ANS_LOGI("EnableNotification napi_create_async_work start");
             AsyncCallbackInfoEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoEnable *>(data);
             std::string deviceId {""};
-            asynccallbackinfo->info.errorCode = NotificationHelper::SetNotificationsEnabledForSpecifiedBundle(
-                asynccallbackinfo->params.option, deviceId, asynccallbackinfo->params.enable);
-            ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d", asynccallbackinfo->info.errorCode);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::SetNotificationsEnabledForSpecifiedBundle(
+                    asynccallbackinfo->params.option, deviceId, asynccallbackinfo->params.enable);
+                ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d", asynccallbackinfo->info.errorCode);
+            }
         },
         AsyncCompleteCallbackEnableNotification,
         (void *)asynccallbackinfo,
@@ -185,19 +189,21 @@ void AsyncCompleteCallbackIsNotificationEnabled(napi_env env, napi_status status
         return;
     }
     AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-    napi_value result = nullptr;
-    napi_get_boolean(env, asynccallbackinfo->allowed, &result);
-    if (asynccallbackinfo->newInterface) {
-        Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    } else {
-        Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
-    }
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        napi_get_boolean(env, asynccallbackinfo->allowed, &result);
+        if (asynccallbackinfo->newInterface) {
+            Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+        } else {
+            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);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value IsNotificationEnabled(napi_env env, napi_callback_info info)
@@ -226,22 +232,23 @@ napi_value IsNotificationEnabled(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("IsNotificationEnabled napi_create_async_work start");
             AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-
-            if (asynccallbackinfo->params.hasBundleOption) {
-                ANS_LOGI("option.bundle = %{public}s option.uid = %{public}d",
-                    asynccallbackinfo->params.option.GetBundleName().c_str(),
-                    asynccallbackinfo->params.option.GetUid());
-                asynccallbackinfo->info.errorCode =
-                    NotificationHelper::IsAllowedNotify(asynccallbackinfo->params.option, asynccallbackinfo->allowed);
-            } else if (asynccallbackinfo->params.hasUserId) {
-                ANS_LOGI("userId = %{public}d", asynccallbackinfo->params.userId);
-                asynccallbackinfo->info.errorCode =
-                    NotificationHelper::IsAllowedNotify(asynccallbackinfo->params.userId, asynccallbackinfo->allowed);
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotify(asynccallbackinfo->allowed);
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->params.hasBundleOption) {
+                    ANS_LOGI("option.bundle = %{public}s option.uid = %{public}d",
+                        asynccallbackinfo->params.option.GetBundleName().c_str(),
+                        asynccallbackinfo->params.option.GetUid());
+                    asynccallbackinfo->info.errorCode =
+                        NotificationHelper::IsAllowedNotify(asynccallbackinfo->params.option, asynccallbackinfo->allowed);
+                } else if (asynccallbackinfo->params.hasUserId) {
+                    ANS_LOGI("userId = %{public}d", asynccallbackinfo->params.userId);
+                    asynccallbackinfo->info.errorCode =
+                        NotificationHelper::IsAllowedNotify(asynccallbackinfo->params.userId, asynccallbackinfo->allowed);
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotify(asynccallbackinfo->allowed);
+                }
+                ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowed = %{public}d",
+                    asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
             }
-            ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowed = %{public}d",
-                asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
         },
         AsyncCompleteCallbackIsNotificationEnabled,
         (void *)asynccallbackinfo,
@@ -282,14 +289,15 @@ napi_value IsNotificationEnabledSelf(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("IsNotificationEnabledSelf napi_create_async_work start");
             AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-
-            if (asynccallbackinfo->params.hasBundleOption) {
-                ANS_LOGE("Not allowed to query another application");
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotifySelf(asynccallbackinfo->allowed);
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->params.hasBundleOption) {
+                    ANS_LOGE("Not allowed to query another application");
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotifySelf(asynccallbackinfo->allowed);
+                }
+                ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowed = %{public}d",
+                    asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
             }
-            ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowed = %{public}d",
-                asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
         },
         AsyncCompleteCallbackIsNotificationEnabled,
         (void *)asynccallbackinfo,
@@ -330,22 +338,26 @@ napi_value RequestEnableNotification(napi_env env, napi_callback_info info)
         resourceName,
         [](napi_env env, void *data) {
             AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-            std::string deviceId {""};
-            bool popFlag = false;
-            asynccallbackinfo->info.errorCode = NotificationHelper::RequestEnableNotification(deviceId, popFlag);
-            asynccallbackinfo->params.allowToPop = popFlag;
-            ANS_LOGI("errorCode = %{public}d, allowToPop = %{public}d",
-                     asynccallbackinfo->info.errorCode, asynccallbackinfo->params.allowToPop);
-            if (asynccallbackinfo->info.errorCode == ERR_OK && asynccallbackinfo->params.allowToPop) {
-                ANS_LOGI("Begin to start notification dialog");
-                auto *callbackInfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-                StartNotificationDialog(callbackInfo);
+            if (asynccallbackinfo) {
+                std::string deviceId {""};
+                bool popFlag = false;
+                asynccallbackinfo->info.errorCode = NotificationHelper::RequestEnableNotification(deviceId, popFlag);
+                asynccallbackinfo->params.allowToPop = popFlag;
+                ANS_LOGI("errorCode = %{public}d, allowToPop = %{public}d",
+                        asynccallbackinfo->info.errorCode, asynccallbackinfo->params.allowToPop);
+                if (asynccallbackinfo->info.errorCode == ERR_OK && asynccallbackinfo->params.allowToPop) {
+                    ANS_LOGI("Begin to start notification dialog");
+                    auto *callbackInfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
+                    StartNotificationDialog(callbackInfo);
+                }
             }
         },
         [](napi_env env, napi_status status, void *data) {
             AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-            if (!(asynccallbackinfo->info.errorCode == ERR_OK && asynccallbackinfo->params.allowToPop)) {
-                AsyncCompleteCallbackIsNotificationEnabled(env, status, data);
+            if (asynccallbackinfo) {
+                if (!(asynccallbackinfo->info.errorCode == ERR_OK && asynccallbackinfo->params.allowToPop)) {
+                    AsyncCompleteCallbackIsNotificationEnabled(env, status, data);
+                }
             }
         },
         (void *)asynccallbackinfo,
diff --git a/frameworks/js/napi/src/get_active.cpp b/frameworks/js/napi/src/get_active.cpp
index 243f9869a163f192846cff6ad1ae82f3de349b36..571922d096b0b4e2ca81a728baa858156f33c2d7 100644
--- a/frameworks/js/napi/src/get_active.cpp
+++ b/frameworks/js/napi/src/get_active.cpp
@@ -27,41 +27,43 @@ void AsyncCompleteCallbackGetAllActiveNotifications(napi_env env, napi_status st
     }
 
     auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        napi_value arr = nullptr;
-        int32_t count = 0;
-        napi_create_array(env, &arr);
-        for (auto vec : asynccallbackinfo->notifications) {
-            if (!vec) {
-                ANS_LOGW("Invalid Notification object ptr");
-                continue;
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
+            result = Common::NapiGetNull(env);
+        } else {
+            napi_value arr = nullptr;
+            int32_t 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++;
             }
-            napi_value notificationResult = nullptr;
-            napi_create_object(env, &notificationResult);
-            if (!Common::SetNotification(env, vec.GetRefPtr(), notificationResult)) {
-                ANS_LOGW("Set Notification object failed");
-                continue;
+            ANS_LOGI("GetAllActiveNotifications count = %{public}d", count);
+            result = arr;
+            if ((count == 0) && (asynccallbackinfo->notifications.size() > 0)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
             }
-            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);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    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);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value GetAllActiveNotifications(napi_env env, napi_callback_info info)
@@ -90,9 +92,10 @@ napi_value GetAllActiveNotifications(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetAllActiveNotifications napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::GetAllActiveNotifications(asynccallbackinfo->notifications);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::GetAllActiveNotifications(asynccallbackinfo->notifications);
+            }
         },
         AsyncCompleteCallbackGetAllActiveNotifications,
         (void *)asynccallbackinfo,
@@ -117,41 +120,43 @@ void AsyncCompleteCallbackGetActiveNotifications(napi_env env, napi_status statu
     }
 
     auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        napi_value arr = nullptr;
-        int32_t count = 0;
-        napi_create_array(env, &arr);
-        for (auto vec : asynccallbackinfo->requests) {
-            if (!vec) {
-                ANS_LOGW("Invalid NotificationRequest object ptr");
-                continue;
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
+            result = Common::NapiGetNull(env);
+        } else {
+            napi_value arr = nullptr;
+            int32_t 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++;
             }
-            napi_value requestResult = nullptr;
-            napi_create_object(env, &requestResult);
-            if (!Common::SetNotificationRequest(env, vec.GetRefPtr(), requestResult)) {
-                ANS_LOGW("Set NotificationRequest object failed");
-                continue;
+            ANS_LOGI("GetActiveNotifications count = %{public}d", count);
+            result = arr;
+            if ((count == 0) && (asynccallbackinfo->requests.size() > 0)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
             }
-            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);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    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);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value GetActiveNotifications(napi_env env, napi_callback_info info)
@@ -180,9 +185,10 @@ napi_value GetActiveNotifications(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetActiveNotifications napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::GetActiveNotifications(asynccallbackinfo->requests);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::GetActiveNotifications(asynccallbackinfo->requests);
+            }
         },
         AsyncCompleteCallbackGetActiveNotifications,
         (void *)asynccallbackinfo,
@@ -207,19 +213,21 @@ void AsyncCompleteCallbackGetActiveNotificationCount(napi_env env, napi_status s
     }
 
     auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        napi_create_uint32(env, asynccallbackinfo->num, &result);
-    }
-    Common::ReturnCallbackPromise(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
+            result = Common::NapiGetNull(env);
+        } else {
+            napi_create_uint32(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);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value GetActiveNotificationCount(napi_env env, napi_callback_info info)
@@ -248,9 +256,10 @@ napi_value GetActiveNotificationCount(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetActiveNotificationCount napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetActiveNotificationNums(asynccallbackinfo->num);
-            ANS_LOGI("GetActiveNotificationCount count = %{public}" PRIu64 "", asynccallbackinfo->num);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::GetActiveNotificationNums(asynccallbackinfo->num);
+                ANS_LOGI("GetActiveNotificationCount count = %{public}" PRIu64 "", asynccallbackinfo->num);
+            }
         },
         AsyncCompleteCallbackGetActiveNotificationCount,
         (void *)asynccallbackinfo,
diff --git a/frameworks/js/napi/src/manager/napi_display_badge.cpp b/frameworks/js/napi/src/manager/napi_display_badge.cpp
index 990f70b58c0803fa9440808993c39b1247cccbe6..a10fd162e51e3b4612a614c59510dbd9eb81d98c 100644
--- a/frameworks/js/napi/src/manager/napi_display_badge.cpp
+++ b/frameworks/js/napi/src/manager/napi_display_badge.cpp
@@ -88,15 +88,17 @@ void AsyncCompleteCallbackNapiIsBadgeDisplayed(napi_env env, napi_status status,
         return;
     }
     AsyncCallbackInfoIsDisplayBadge *asynccallbackinfo = static_cast<AsyncCallbackInfoIsDisplayBadge *>(data);
-    napi_value result = nullptr;
-    napi_get_boolean(env, asynccallbackinfo->enabled, &result);
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        napi_get_boolean(env, asynccallbackinfo->enabled, &result);
+        Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiIsBadgeDisplayed(napi_env env, napi_callback_info info)
diff --git a/frameworks/js/napi/src/manager/napi_distributed.cpp b/frameworks/js/napi/src/manager/napi_distributed.cpp
index 8b4968f368209c5fca30a5e372a51b137d3c45c4..45d928b28264c7dee7be1ac8b0a384e20a66f546 100644
--- a/frameworks/js/napi/src/manager/napi_distributed.cpp
+++ b/frameworks/js/napi/src/manager/napi_distributed.cpp
@@ -29,19 +29,21 @@ void AsyncCompleteCallbackNapiIsDistributedEnabled(napi_env env, napi_status sta
     }
     ANS_LOGI("IsDistributedEnabled napi_create_async_work end");
     AsyncCallbackInfoIsEnabled *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabled *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        napi_get_boolean(env, asynccallbackinfo->enable, &result);
-    }
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
+            result = Common::NapiGetNull(env);
+        } else {
+            napi_get_boolean(env, asynccallbackinfo->enable, &result);
+        }
+        Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiIsDistributedEnabled(napi_env env, napi_callback_info info)
@@ -178,9 +180,10 @@ napi_value NapiEnableDistributedByBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("EnableDistributedByBundle napi_create_async_work start");
             AsyncCallbackInfoEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoEnabledByBundle *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::EnableDistributedByBundle(
-                asynccallbackinfo->params.option, asynccallbackinfo->params.enable);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::EnableDistributedByBundle(
+                    asynccallbackinfo->params.option, asynccallbackinfo->params.enable);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("EnableDistributedByBundle napi_create_async_work end");
@@ -235,9 +238,11 @@ napi_value NapiEnableDistributedSelf(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("EnableDistributedSelf napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoEnabled *>(data);
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::EnableDistributedSelf(asynccallbackinfo->params.enable);
-            ANS_LOGI("EnableDistributedSelf enable = %{public}d", asynccallbackinfo->params.enable);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::EnableDistributedSelf(asynccallbackinfo->params.enable);
+                ANS_LOGI("EnableDistributedSelf enable = %{public}d", asynccallbackinfo->params.enable);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("EnableDistributedSelf napi_create_async_work end");
@@ -273,19 +278,21 @@ void AsyncCompleteCallbackNapiIsDistributedEnableByBundle(napi_env env, napi_sta
     }
     ANS_LOGI("IsDistributedEnableByBundle napi_create_async_work end");
     AsyncCallbackInfoIsEnabledByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        napi_get_boolean(env, asynccallbackinfo->enable, &result);
-    }
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
+            result = Common::NapiGetNull(env);
+        } else {
+            napi_get_boolean(env, asynccallbackinfo->enable, &result);
+        }
+        Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiIsDistributedEnableByBundle(napi_env env, napi_callback_info info)
@@ -316,9 +323,10 @@ napi_value NapiIsDistributedEnableByBundle(napi_env env, napi_callback_info info
         [](napi_env env, void *data) {
             ANS_LOGI("IsDistributedEnableByBundle napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoIsEnabledByBundle *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnableByBundle(
-                asynccallbackinfo->params.option, asynccallbackinfo->enable);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::IsDistributedEnableByBundle(
+                    asynccallbackinfo->params.option, asynccallbackinfo->enable);
+            }
         },
         AsyncCompleteCallbackNapiIsDistributedEnableByBundle,
         (void *)asynccallbackinfo,
@@ -342,24 +350,26 @@ void AsyncCompleteCallbackNapiGetDeviceRemindType(napi_env env, napi_status stat
     }
     ANS_LOGI("GetDeviceRemindType napi_create_async_work end");
     AsyncCallbackInfoGetRemindType *asynccallbackinfo = static_cast<AsyncCallbackInfoGetRemindType *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        DeviceRemindType outType = DeviceRemindType::IDLE_DONOT_REMIND;
-        if (!Common::DeviceRemindTypeCToJS(asynccallbackinfo->remindType, outType)) {
-            asynccallbackinfo->info.errorCode = ERROR;
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
             result = Common::NapiGetNull(env);
+        } else {
+            DeviceRemindType outType = DeviceRemindType::IDLE_DONOT_REMIND;
+            if (!Common::DeviceRemindTypeCToJS(asynccallbackinfo->remindType, outType)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
+            }
+            napi_create_int32(env, (int32_t)outType, &result);
         }
-        napi_create_int32(env, (int32_t)outType, &result);
-    }
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+        Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiGetDeviceRemindType(napi_env env, napi_callback_info info)
@@ -389,8 +399,10 @@ napi_value NapiGetDeviceRemindType(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetDeviceRemindType napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetRemindType *>(data);
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::GetDeviceRemindType(asynccallbackinfo->remindType);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::GetDeviceRemindType(asynccallbackinfo->remindType);
+            }
         },
         AsyncCompleteCallbackNapiGetDeviceRemindType,
         (void *)asynccallbackinfo,
diff --git a/frameworks/js/napi/src/manager/napi_disturb_mode.cpp b/frameworks/js/napi/src/manager/napi_disturb_mode.cpp
index ed4f9e6d10e5398dc6afff7dd0ef8084298b47d9..f75d8ea6875bb14877c02edc63a306bdaf4ce89d 100644
--- a/frameworks/js/napi/src/manager/napi_disturb_mode.cpp
+++ b/frameworks/js/napi/src/manager/napi_disturb_mode.cpp
@@ -44,17 +44,19 @@ napi_value NapiSetDoNotDisturbDate(napi_env env, napi_callback_info info)
         nullptr, resourceName, [](napi_env env, void *data) {
             ANS_LOGI("SetDoNotDisturbDate napi_create_async_work start");
             AsyncCallbackInfoSetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoSetDoNotDisturb *>(data);
-            if (asynccallbackinfo->params.hasUserId) {
-                asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
-                    asynccallbackinfo->params.userId, asynccallbackinfo->params.date);
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
-                    asynccallbackinfo->params.date);
-            }
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->params.hasUserId) {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
+                        asynccallbackinfo->params.userId, asynccallbackinfo->params.date);
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::SetDoNotDisturbDate(
+                        asynccallbackinfo->params.date);
+                }
 
-            ANS_LOGI("SetDoNotDisturbDate date=%{public}s errorCode=%{public}d, hasUserId=%{public}d",
-                asynccallbackinfo->params.date.Dump().c_str(), asynccallbackinfo->info.errorCode,
-                asynccallbackinfo->params.hasUserId);
+                ANS_LOGI("SetDoNotDisturbDate date=%{public}s errorCode=%{public}d, hasUserId=%{public}d",
+                    asynccallbackinfo->params.date.Dump().c_str(), asynccallbackinfo->info.errorCode,
+                    asynccallbackinfo->params.hasUserId);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("SetDoNotDisturbDate napi_create_async_work end");
@@ -88,20 +90,22 @@ void AsyncCompleteCallbackNapiGetDoNotDisturbDate(napi_env env, napi_status stat
         return;
     }
     AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoGetDoNotDisturb *>(data);
-    napi_value result = Common::NapiGetNull(env);
-    if (asynccallbackinfo->info.errorCode == ERR_OK) {
-        napi_create_object(env, &result);
-        if (!Common::SetDoNotDisturbDate(env, asynccallbackinfo->date, result)) {
-            asynccallbackinfo->info.errorCode = ERROR;
+    if (asynccallbackinfo) {
+        napi_value result = Common::NapiGetNull(env);
+        if (asynccallbackinfo->info.errorCode == ERR_OK) {
+            napi_create_object(env, &result);
+            if (!Common::SetDoNotDisturbDate(env, asynccallbackinfo->date, result)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+            }
         }
+        Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
-    }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiGetDoNotDisturbDate(napi_env env, napi_callback_info info)
@@ -131,16 +135,18 @@ napi_value NapiGetDoNotDisturbDate(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetDoNotDisturbDate napi_create_async_work start");
             AsyncCallbackInfoGetDoNotDisturb *asynccallbackinfo = static_cast<AsyncCallbackInfoGetDoNotDisturb *>(data);
-            if (asynccallbackinfo->params.hasUserId) {
-                asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(
-                    asynccallbackinfo->params.userId, asynccallbackinfo->date);
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(asynccallbackinfo->date);
-            }
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->params.hasUserId) {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(
+                        asynccallbackinfo->params.userId, asynccallbackinfo->date);
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::GetDoNotDisturbDate(asynccallbackinfo->date);
+                }
 
-            ANS_LOGI("GetDoNotDisturbDate errorCode=%{public}d date=%{public}s, hasUserId=%{public}d",
-                asynccallbackinfo->info.errorCode, asynccallbackinfo->date.Dump().c_str(),
-                asynccallbackinfo->params.hasUserId);
+                ANS_LOGI("GetDoNotDisturbDate errorCode=%{public}d date=%{public}s, hasUserId=%{public}d",
+                    asynccallbackinfo->info.errorCode, asynccallbackinfo->date.Dump().c_str(),
+                    asynccallbackinfo->params.hasUserId);
+            }
         },
         AsyncCompleteCallbackNapiGetDoNotDisturbDate,
         (void *)asynccallbackinfo,
@@ -185,10 +191,12 @@ napi_value NapiSupportDoNotDisturbMode(napi_env env, napi_callback_info info)
             ANS_LOGI("SupportDoNotDisturbMode napi_create_async_work start");
             AsyncCallbackInfoSupportDoNotDisturb *asynccallbackinfo =
                 static_cast<AsyncCallbackInfoSupportDoNotDisturb *>(data);
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::DoesSupportDoNotDisturbMode(asynccallbackinfo->isSupported);
-            ANS_LOGI("SupportDoNotDisturbMode errorCode=%{public}d isSupported=%{public}d",
-                asynccallbackinfo->info.errorCode, asynccallbackinfo->isSupported);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::DoesSupportDoNotDisturbMode(asynccallbackinfo->isSupported);
+                ANS_LOGI("SupportDoNotDisturbMode errorCode=%{public}d isSupported=%{public}d",
+                    asynccallbackinfo->info.errorCode, asynccallbackinfo->isSupported);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("SupportDoNotDisturbMode napi_create_async_work end");
diff --git a/frameworks/js/napi/src/manager/napi_enable_notification.cpp b/frameworks/js/napi/src/manager/napi_enable_notification.cpp
index d328bc47cc6dcb84675ccb4aaecbca1dc6947d94..64a68241cb08382f73f105c1584f8dbbfe3c901a 100644
--- a/frameworks/js/napi/src/manager/napi_enable_notification.cpp
+++ b/frameworks/js/napi/src/manager/napi_enable_notification.cpp
@@ -28,13 +28,15 @@ void AsyncCompleteCallbackNapiEnableNotification(napi_env env, napi_status statu
         return;
     }
     AsyncCallbackInfoEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoEnable *>(data);
-    Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiEnableNotification(napi_env env, napi_callback_info info)
@@ -63,10 +65,12 @@ napi_value NapiEnableNotification(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("EnableNotification napi_create_async_work start");
             AsyncCallbackInfoEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoEnable *>(data);
-            std::string deviceId {""};
-            asynccallbackinfo->info.errorCode = NotificationHelper::SetNotificationsEnabledForSpecifiedBundle(
-                asynccallbackinfo->params.option, deviceId, asynccallbackinfo->params.enable);
-            ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d", asynccallbackinfo->info.errorCode);
+            if (asynccallbackinfo) {
+                std::string deviceId {""};
+                asynccallbackinfo->info.errorCode = NotificationHelper::SetNotificationsEnabledForSpecifiedBundle(
+                    asynccallbackinfo->params.option, deviceId, asynccallbackinfo->params.enable);
+                ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d", asynccallbackinfo->info.errorCode);
+            }
         },
         AsyncCompleteCallbackNapiEnableNotification,
         (void *)asynccallbackinfo,
@@ -88,15 +92,17 @@ void AsyncCompleteCallbackNapiIsNotificationEnabled(napi_env env, napi_status st
         return;
     }
     AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-    napi_value result = nullptr;
-    napi_get_boolean(env, asynccallbackinfo->allowed, &result);
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        napi_get_boolean(env, asynccallbackinfo->allowed, &result);
+        Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiIsNotificationEnabled(napi_env env, napi_callback_info info)
@@ -125,22 +131,23 @@ napi_value NapiIsNotificationEnabled(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("IsNotificationEnabled napi_create_async_work start");
             AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-
-            if (asynccallbackinfo->params.hasBundleOption) {
-                ANS_LOGI("option.bundle = %{public}s option.uid = %{public}d",
-                    asynccallbackinfo->params.option.GetBundleName().c_str(),
-                    asynccallbackinfo->params.option.GetUid());
-                asynccallbackinfo->info.errorCode =
-                    NotificationHelper::IsAllowedNotify(asynccallbackinfo->params.option, asynccallbackinfo->allowed);
-            } else if (asynccallbackinfo->params.hasUserId) {
-                ANS_LOGI("userId = %{public}d", asynccallbackinfo->params.userId);
-                asynccallbackinfo->info.errorCode =
-                    NotificationHelper::IsAllowedNotify(asynccallbackinfo->params.userId, asynccallbackinfo->allowed);
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotify(asynccallbackinfo->allowed);
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->params.hasBundleOption) {
+                    ANS_LOGI("option.bundle = %{public}s option.uid = %{public}d",
+                        asynccallbackinfo->params.option.GetBundleName().c_str(),
+                        asynccallbackinfo->params.option.GetUid());
+                    asynccallbackinfo->info.errorCode =
+                        NotificationHelper::IsAllowedNotify(asynccallbackinfo->params.option, asynccallbackinfo->allowed);
+                } else if (asynccallbackinfo->params.hasUserId) {
+                    ANS_LOGI("userId = %{public}d", asynccallbackinfo->params.userId);
+                    asynccallbackinfo->info.errorCode =
+                        NotificationHelper::IsAllowedNotify(asynccallbackinfo->params.userId, asynccallbackinfo->allowed);
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotify(asynccallbackinfo->allowed);
+                }
+                ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowed = %{public}d",
+                    asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
             }
-            ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowed = %{public}d",
-                asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
         },
         AsyncCompleteCallbackNapiIsNotificationEnabled,
         (void *)asynccallbackinfo,
@@ -180,14 +187,15 @@ napi_value NapiIsNotificationEnabledSelf(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("IsNotificationEnabledSelf napi_create_async_work start");
             AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-
-            if (asynccallbackinfo->params.hasBundleOption) {
-                ANS_LOGE("Not allowed to query another application");
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotifySelf(asynccallbackinfo->allowed);
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->params.hasBundleOption) {
+                    ANS_LOGE("Not allowed to query another application");
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::IsAllowedNotifySelf(asynccallbackinfo->allowed);
+                }
+                ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowed = %{public}d",
+                    asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
             }
-            ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowed = %{public}d",
-                asynccallbackinfo->info.errorCode, asynccallbackinfo->allowed);
         },
         AsyncCompleteCallbackNapiIsNotificationEnabled,
         (void *)asynccallbackinfo,
@@ -225,22 +233,23 @@ napi_value NapiRequestEnableNotification(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("RequestEnableNotification napi_create_async_work start");
             AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-
-            std::string deviceId {""};
-            bool popFlag = false;
-            asynccallbackinfo->info.errorCode = NotificationHelper::RequestEnableNotification(deviceId, popFlag);
-            asynccallbackinfo->params.allowToPop = popFlag;
-            ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowToPop = %{public}d",
-                asynccallbackinfo->info.errorCode, asynccallbackinfo->params.allowToPop);
-            if (asynccallbackinfo->info.errorCode == ERR_OK && asynccallbackinfo->params.allowToPop) {
-                ANS_LOGI("Begin to start notification dialog");
-                auto *callbackInfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-                StartNotificationDialog(callbackInfo);
+            if (asynccallbackinfo) {
+                std::string deviceId {""};
+                bool popFlag = false;
+                asynccallbackinfo->info.errorCode = NotificationHelper::RequestEnableNotification(deviceId, popFlag);
+                asynccallbackinfo->params.allowToPop = popFlag;
+                ANS_LOGI("asynccallbackinfo->info.errorCode = %{public}d, allowToPop = %{public}d",
+                    asynccallbackinfo->info.errorCode, asynccallbackinfo->params.allowToPop);
+                if (asynccallbackinfo->info.errorCode == ERR_OK && asynccallbackinfo->params.allowToPop) {
+                    ANS_LOGI("Begin to start notification dialog");
+                    auto *callbackInfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
+                    StartNotificationDialog(callbackInfo);
+                }
             }
         },
         [](napi_env env, napi_status status, void *data) {
             AsyncCallbackInfoIsEnable *asynccallbackinfo = static_cast<AsyncCallbackInfoIsEnable *>(data);
-            if (!(asynccallbackinfo->info.errorCode == ERR_OK && asynccallbackinfo->params.allowToPop)) {
+            if (asynccallbackinfo != nullptr && !(asynccallbackinfo->info.errorCode == ERR_OK && asynccallbackinfo->params.allowToPop)) {
                 AsyncCompleteCallbackNapiIsNotificationEnabled(env, status, data);
             }
         },
diff --git a/frameworks/js/napi/src/manager/napi_get_active.cpp b/frameworks/js/napi/src/manager/napi_get_active.cpp
index 65b2fe66a9b43102b7f7d431d60af8f445ddaf2c..7619bc9a398f81553d7dfb9eb105b492c331a07e 100644
--- a/frameworks/js/napi/src/manager/napi_get_active.cpp
+++ b/frameworks/js/napi/src/manager/napi_get_active.cpp
@@ -29,41 +29,43 @@ void AsyncCompleteCallbackNapiGetAllActiveNotifications(napi_env env, napi_statu
     }
 
     auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        napi_value arr = nullptr;
-        int32_t count = 0;
-        napi_create_array(env, &arr);
-        for (auto vec : asynccallbackinfo->notifications) {
-            if (!vec) {
-                ANS_LOGW("Invalid Notification object ptr");
-                continue;
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
+            result = Common::NapiGetNull(env);
+        } else {
+            napi_value arr = nullptr;
+            int32_t 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++;
             }
-            napi_value notificationResult = nullptr;
-            napi_create_object(env, &notificationResult);
-            if (!Common::SetNotification(env, vec.GetRefPtr(), notificationResult)) {
-                ANS_LOGW("Set Notification object failed");
-                continue;
+            ANS_LOGI("GetAllActiveNotifications count = %{public}d", count);
+            result = arr;
+            if ((count == 0) && (asynccallbackinfo->notifications.size() > 0)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
             }
-            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::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
         }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
-    }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiGetAllActiveNotifications(napi_env env, napi_callback_info info)
@@ -92,9 +94,10 @@ napi_value NapiGetAllActiveNotifications(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetAllActiveNotifications napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::GetAllActiveNotifications(asynccallbackinfo->notifications);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::GetAllActiveNotifications(asynccallbackinfo->notifications);
+            }
         },
         AsyncCompleteCallbackNapiGetAllActiveNotifications,
         (void *)asynccallbackinfo,
@@ -117,41 +120,43 @@ void AsyncCompleteCallbackNapiGetActiveNotifications(napi_env env, napi_status s
     }
 
     auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        napi_value arr = nullptr;
-        int32_t count = 0;
-        napi_create_array(env, &arr);
-        for (auto vec : asynccallbackinfo->requests) {
-            if (!vec) {
-                ANS_LOGW("Invalid NotificationRequest object ptr");
-                continue;
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
+            result = Common::NapiGetNull(env);
+        } else {
+            napi_value arr = nullptr;
+            int32_t 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++;
             }
-            napi_value requestResult = nullptr;
-            napi_create_object(env, &requestResult);
-            if (!Common::SetNotificationRequest(env, vec.GetRefPtr(), requestResult)) {
-                ANS_LOGW("Set NotificationRequest object failed");
-                continue;
+            ANS_LOGI("GetActiveNotifications count = %{public}d", count);
+            result = arr;
+            if ((count == 0) && (asynccallbackinfo->requests.size() > 0)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
             }
-            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::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
         }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
-    }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiGetActiveNotifications(napi_env env, napi_callback_info info)
@@ -180,9 +185,10 @@ napi_value NapiGetActiveNotifications(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetActiveNotifications napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::GetActiveNotifications(asynccallbackinfo->requests);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::GetActiveNotifications(asynccallbackinfo->requests);
+            }
         },
         AsyncCompleteCallbackNapiGetActiveNotifications,
         (void *)asynccallbackinfo,
@@ -205,19 +211,21 @@ void AsyncCompleteCallbackNapiGetActiveNotificationCount(napi_env env, napi_stat
     }
 
     auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-    napi_value result = nullptr;
-    if (asynccallbackinfo->info.errorCode != ERR_OK) {
-        result = Common::NapiGetNull(env);
-    } else {
-        napi_create_uint32(env, asynccallbackinfo->num, &result);
-    }
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        napi_value result = nullptr;
+        if (asynccallbackinfo->info.errorCode != ERR_OK) {
+            result = Common::NapiGetNull(env);
+        } else {
+            napi_create_uint32(env, asynccallbackinfo->num, &result);
+        }
+        Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiGetActiveNotificationCount(napi_env env, napi_callback_info info)
@@ -246,9 +254,10 @@ napi_value NapiGetActiveNotificationCount(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetActiveNotificationCount napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoActive *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetActiveNotificationNums(asynccallbackinfo->num);
-            ANS_LOGI("GetActiveNotificationCount count = %{public}" PRIu64 "", asynccallbackinfo->num);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::GetActiveNotificationNums(asynccallbackinfo->num);
+                ANS_LOGI("GetActiveNotificationCount count = %{public}" PRIu64 "", asynccallbackinfo->num);
+            }
         },
         AsyncCompleteCallbackNapiGetActiveNotificationCount,
         (void *)asynccallbackinfo,
diff --git a/frameworks/js/napi/src/manager/napi_publish.cpp b/frameworks/js/napi/src/manager/napi_publish.cpp
index 1c4d48f07eb1dfe09b5806b7ed1c5a799a69d302..1abec2d77c365aaf92b0ccc5f888621b1e6b0e04 100644
--- a/frameworks/js/napi/src/manager/napi_publish.cpp
+++ b/frameworks/js/napi/src/manager/napi_publish.cpp
@@ -47,13 +47,15 @@ napi_value NapiPublish(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("Publish napi_create_async_work start");
             AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
-            ANS_LOGI("Publish napi_create_async_work start notificationId = %{public}d, contentType = "
-                     "%{public}d",
-                asynccallbackinfo->request.GetNotificationId(),
-                asynccallbackinfo->request.GetContent()->GetContentType());
+            if (asynccallbackinfo) {
+                ANS_LOGI("Publish napi_create_async_work start notificationId = %{public}d, contentType = "
+                        "%{public}d",
+                    asynccallbackinfo->request.GetNotificationId(),
+                    asynccallbackinfo->request.GetContent()->GetContentType());
 
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::PublishNotification(asynccallbackinfo->request);
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::PublishNotification(asynccallbackinfo->request);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("Publish napi_create_async_work complete start");
@@ -106,13 +108,15 @@ napi_value NapiShowNotification(napi_env env, napi_callback_info info)
         resourceName,
         [](napi_env env, void *data) {
             AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
-            ANS_LOGI("Show napi_create_async_work start notificationId = %{public}d, contentType = "
-                     "%{public}d",
-                asynccallbackinfo->request.GetNotificationId(),
-                asynccallbackinfo->request.GetContent()->GetContentType());
+            if (asynccallbackinfo) {
+                ANS_LOGI("Show napi_create_async_work start notificationId = %{public}d, contentType = "
+                        "%{public}d",
+                    asynccallbackinfo->request.GetNotificationId(),
+                    asynccallbackinfo->request.GetContent()->GetContentType());
 
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::PublishNotification(asynccallbackinfo->request);
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::PublishNotification(asynccallbackinfo->request);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("Show napi_create_async_work complete start");
@@ -161,13 +165,15 @@ napi_value NapiPublishAsBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("PublishAsBundle napi_create_async_work start");
             AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
-            ANS_LOGI("PublishAsBundle napi_create_async_work start notificationId = %{public}d, contentType = "
-                     "%{public}d",
-                asynccallbackinfo->request.GetNotificationId(),
-                asynccallbackinfo->request.GetContent()->GetContentType());
+            if (asynccallbackinfo) {
+                ANS_LOGI("PublishAsBundle napi_create_async_work start notificationId = %{public}d, contentType = "
+                        "%{public}d",
+                    asynccallbackinfo->request.GetNotificationId(),
+                    asynccallbackinfo->request.GetContent()->GetContentType());
 
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::PublishNotification(asynccallbackinfo->request);
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::PublishNotification(asynccallbackinfo->request);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("PublishAsBundle napi_create_async_work complete start");
diff --git a/frameworks/js/napi/src/manager/napi_slot.cpp b/frameworks/js/napi/src/manager/napi_slot.cpp
index d394922a78217c5b7609a1293514fc712f3f5730..b31e529a08c5d7355f801fdf5351086722182ad9 100644
--- a/frameworks/js/napi/src/manager/napi_slot.cpp
+++ b/frameworks/js/napi/src/manager/napi_slot.cpp
@@ -51,10 +51,12 @@ napi_value NapiAddSlot(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("AddSlot napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlot *>(data);
-            if (asynccallbackinfo->isAddSlotByType) {
-                asynccallbackinfo->info.errorCode = NotificationHelper::AddSlotByType(asynccallbackinfo->inType);
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlot(asynccallbackinfo->slot);
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->isAddSlotByType) {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::AddSlotByType(asynccallbackinfo->inType);
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlot(asynccallbackinfo->slot);
+                }
             }
         },
         [](napi_env env, napi_status status, void *data) {
@@ -107,7 +109,9 @@ napi_value NapiAddSlots(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("AddSlots napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlots *>(data);
-            asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlots(asynccallbackinfo->slots);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlots(asynccallbackinfo->slots);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("AddSlots napi_create_async_work end");
@@ -159,9 +163,10 @@ napi_value NapiSetSlotByBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("SetSlotByBundle napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoSetSlotByBundle *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::UpdateNotificationSlots(
-                asynccallbackinfo->params.option, asynccallbackinfo->params.slots);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::UpdateNotificationSlots(
+                    asynccallbackinfo->params.option, asynccallbackinfo->params.slots);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("SetSlotByBundle napi_create_async_work end");
@@ -197,25 +202,27 @@ void AsyncCompleteCallbackNapiGetSlot(napi_env env, napi_status status, void *da
     }
 
     auto asynccallbackinfo = static_cast<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)) {
+    if (asynccallbackinfo) {
+        napi_value result = Common::NapiGetNull(env);
+        if (asynccallbackinfo->info.errorCode == ERR_OK) {
+            if (asynccallbackinfo->slot == nullptr) {
                 asynccallbackinfo->info.errorCode = ERROR;
-                result = Common::NapiGetNull(env);
+            } else {
+                napi_create_object(env, &result);
+                if (!Common::SetNotificationSlot(env, *asynccallbackinfo->slot, result)) {
+                    asynccallbackinfo->info.errorCode = ERROR;
+                    result = Common::NapiGetNull(env);
+                }
             }
         }
+        Common::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
-    }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiGetSlot(napi_env env, napi_callback_info info)
@@ -244,9 +251,10 @@ napi_value NapiGetSlot(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetSlot napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoGetSlot *>(data);
-
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::GetNotificationSlot(asynccallbackinfo->outType, asynccallbackinfo->slot);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::GetNotificationSlot(asynccallbackinfo->outType, asynccallbackinfo->slot);
+            }
         },
         AsyncCompleteCallbackNapiGetSlot,
         (void *)asynccallbackinfo,
@@ -286,9 +294,10 @@ napi_value NapiGetSlotNumByBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetSlotNumByBundle napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotNumByBundle *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotNumAsBundle(
-                asynccallbackinfo->params.option, asynccallbackinfo->num);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotNumAsBundle(
+                    asynccallbackinfo->params.option, asynccallbackinfo->num);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("GetSlotNumByBundle napi_create_async_work end");
@@ -325,39 +334,41 @@ void AsyncCompleteCallbackNapiGetSlots(napi_env env, napi_status status, void *d
     }
     napi_value result = nullptr;
     auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlots *>(data);
-    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;
+    if (asynccallbackinfo) {
+        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++;
             }
-            napi_value nSlot = nullptr;
-            napi_create_object(env, &nSlot);
-            if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
-                continue;
+            ANS_LOGI("getSlots count = %{public}zu", count);
+            result = arr;
+            if ((count == 0) && (asynccallbackinfo->slots.size() > 0)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
             }
-            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::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
         }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
-    }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiGetSlots(napi_env env, napi_callback_info info)
@@ -385,7 +396,9 @@ napi_value NapiGetSlots(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetSlots napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlots *>(data);
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlots(asynccallbackinfo->slots);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlots(asynccallbackinfo->slots);
+            }
         },
         AsyncCompleteCallbackNapiGetSlots,
         (void *)asynccallbackinfo,
@@ -409,39 +422,41 @@ void AsyncCompleteCallbackNapiGetSlotsByBundle(napi_env env, napi_status status,
     }
     napi_value result = nullptr;
     auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotsByBundle *>(data);
-    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;
+    if (asynccallbackinfo) {
+        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++;
             }
-            napi_value nSlot = nullptr;
-            napi_create_object(env, &nSlot);
-            if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
-                continue;
+            ANS_LOGI("getSlots count = %{public}zu", count);
+            result = arr;
+            if ((count == 0) && (asynccallbackinfo->slots.size() > 0)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
             }
-            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::CreateReturnValue(env, asynccallbackinfo->info, result);
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
         }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    Common::CreateReturnValue(env, asynccallbackinfo->info, result);
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
-    }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiGetSlotsByBundle(napi_env env, napi_callback_info info)
@@ -470,8 +485,10 @@ napi_value NapiGetSlotsByBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetSlotsByBundle napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotsByBundle *>(data);
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotsForBundle(
-                asynccallbackinfo->params.option, asynccallbackinfo->slots);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotsForBundle(
+                    asynccallbackinfo->params.option, asynccallbackinfo->slots);
+            }
         },
         AsyncCompleteCallbackNapiGetSlotsByBundle,
         (void *)asynccallbackinfo,
@@ -511,7 +528,9 @@ napi_value NapiRemoveSlot(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("removeSlot napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveSlot *>(data);
-            asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotificationSlot(asynccallbackinfo->outType);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotificationSlot(asynccallbackinfo->outType);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("removeSlot napi_create_async_work end");
@@ -562,7 +581,9 @@ napi_value NapiRemoveAllSlots(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("RemoveAllSlots napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveAllSlots *>(data);
-            asynccallbackinfo->info.errorCode = NotificationHelper::RemoveAllSlots();
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveAllSlots();
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("RemoveAllSlots napi_create_async_work end");
@@ -614,9 +635,10 @@ napi_value NapiEnableNotificationSlot(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("EnableNotificationSlot napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoEnableSlot *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::SetEnabledForBundleSlot(
-                asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->params.enable);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::SetEnabledForBundleSlot(
+                    asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->params.enable);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("EnableNotificationSlot napi_create_async_work end");
@@ -668,9 +690,10 @@ napi_value NapiIsEnableNotificationSlot(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("IsEnableNotificationSlot napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoIsEnableSlot *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetEnabledForBundleSlot(
-                asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->isEnable);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::GetEnabledForBundleSlot(
+                    asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->isEnable);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("IsEnableNotificationSlot napi_create_async_work end");
diff --git a/frameworks/js/napi/src/publish.cpp b/frameworks/js/napi/src/publish.cpp
index d83738e5e6730cb34339388bc2f65831650c7d86..00a4917ee48dbc466c0389d7390b9a25b7722b1b 100644
--- a/frameworks/js/napi/src/publish.cpp
+++ b/frameworks/js/napi/src/publish.cpp
@@ -121,13 +121,15 @@ napi_value Publish(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("Publish napi_create_async_work start");
             AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
-            ANS_LOGI("Publish napi_create_async_work start notificationId = %{public}d, contentType = "
-                     "%{public}d",
-                asynccallbackinfo->request.GetNotificationId(),
-                asynccallbackinfo->request.GetContent()->GetContentType());
+            if (asynccallbackinfo) {
+                ANS_LOGI("Publish napi_create_async_work start notificationId = %{public}d, contentType = "
+                        "%{public}d",
+                    asynccallbackinfo->request.GetNotificationId(),
+                    asynccallbackinfo->request.GetContent()->GetContentType());
 
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::PublishNotification(asynccallbackinfo->request);
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::PublishNotification(asynccallbackinfo->request);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("Publish napi_create_async_work complete start");
@@ -317,13 +319,15 @@ napi_value ShowNotification(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("Show napi_create_async_work start");
             AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
-            ANS_LOGI("Show napi_create_async_work start notificationId = %{public}d, contentType = "
-                     "%{public}d",
-                asynccallbackinfo->request.GetNotificationId(),
-                asynccallbackinfo->request.GetContent()->GetContentType());
+            if (asynccallbackinfo) {
+                ANS_LOGI("Show napi_create_async_work start notificationId = %{public}d, contentType = "
+                        "%{public}d",
+                    asynccallbackinfo->request.GetNotificationId(),
+                    asynccallbackinfo->request.GetContent()->GetContentType());
 
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::PublishNotification(asynccallbackinfo->request);
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::PublishNotification(asynccallbackinfo->request);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("Show napi_create_async_work complete start");
@@ -431,13 +435,15 @@ napi_value PublishAsBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("PublishAsBundle napi_create_async_work start");
             AsyncCallbackInfoPublish *asynccallbackinfo = static_cast<AsyncCallbackInfoPublish *>(data);
-            ANS_LOGI("PublishAsBundle napi_create_async_work start notificationId = %{public}d, contentType = "
-                     "%{public}d",
-                asynccallbackinfo->request.GetNotificationId(),
-                asynccallbackinfo->request.GetContent()->GetContentType());
+            if (asynccallbackinfo) {
+                ANS_LOGI("PublishAsBundle napi_create_async_work start notificationId = %{public}d, contentType = "
+                        "%{public}d",
+                    asynccallbackinfo->request.GetNotificationId(),
+                    asynccallbackinfo->request.GetContent()->GetContentType());
 
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::PublishNotification(asynccallbackinfo->request);
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::PublishNotification(asynccallbackinfo->request);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("PublishAsBundle napi_create_async_work complete start");
diff --git a/frameworks/js/napi/src/reminder/publish.cpp b/frameworks/js/napi/src/reminder/publish.cpp
index 4d4e65b1be9a0fa1d43916a9cc0b2b2317e390f5..7d086fe7280f396adbc3864bafa308280b037d7a 100644
--- a/frameworks/js/napi/src/reminder/publish.cpp
+++ b/frameworks/js/napi/src/reminder/publish.cpp
@@ -300,7 +300,9 @@ napi_value CancelReminderInner(napi_env env, napi_callback_info info, bool isThr
         [](napi_env env, void *data) {
             ANSR_LOGI("Cancel napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfo *>(data);
-            asynccallbackinfo->info.errorCode = ReminderHelper::CancelReminder(asynccallbackinfo->reminderId);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = ReminderHelper::CancelReminder(asynccallbackinfo->reminderId);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANSR_LOGI("Cancel napi_create_async_work complete start");
@@ -366,7 +368,9 @@ napi_value CancelAllRemindersInner(napi_env env, napi_callback_info info, bool i
         [](napi_env env, void *data) {
             ANSR_LOGI("CancelAll napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfo *>(data);
-            asynccallbackinfo->info.errorCode = ReminderHelper::CancelAllReminders();
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = ReminderHelper::CancelAllReminders();
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANSR_LOGD("CancelAll napi_create_async_work complete start");
@@ -838,11 +842,12 @@ napi_value AddSlotInner(napi_env env, napi_callback_info info, bool isThrow)
         },
         [](napi_env env, napi_status status, void *data) {
             AsyncCallbackInfo *asynccallbackinfo = static_cast<AsyncCallbackInfo *>(data);
-            std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
-
-            ReminderCommon::ReturnCallbackPromise(
-                env, asynccallbackinfo->info, NotificationNapi::Common::NapiGetNull(env), asynccallbackinfo->isThrow);
-            ANSR_LOGD("AddSlot napi_create_async_work complete end.");
+            if (asynccallbackinfo) {
+                std::unique_ptr<AsyncCallbackInfo> callbackPtr { asynccallbackinfo };
+                ReminderCommon::ReturnCallbackPromise(
+                    env, asynccallbackinfo->info, NotificationNapi::Common::NapiGetNull(env), asynccallbackinfo->isThrow);
+                ANSR_LOGD("AddSlot napi_create_async_work complete end.");
+            }
         },
         (void *)asynccallbackinfo,
         &asynccallbackinfo->asyncWork);
diff --git a/frameworks/js/napi/src/remove.cpp b/frameworks/js/napi/src/remove.cpp
index a5423b20e6bd7bb021a91b50d6be52b606f37181..e5944aa07a41ae409a24f9db873215f79f9842f5 100644
--- a/frameworks/js/napi/src/remove.cpp
+++ b/frameworks/js/napi/src/remove.cpp
@@ -235,13 +235,15 @@ void RemoveExecuteCallback(napi_env env, void *data)
         return;
     }
     auto removeInfo = static_cast<AsyncCallbackInfoRemove *>(data);
-    if (removeInfo->params.hashcode.has_value()) {
-        removeInfo->info.errorCode = NotificationHelper::RemoveNotification(removeInfo->params.hashcode.value(),
-            removeInfo->params.removeReason);
-    } else if (removeInfo->params.bundleAndKeyInfo.has_value()) {
-        auto &infos = removeInfo->params.bundleAndKeyInfo.value();
-        removeInfo->info.errorCode = NotificationHelper::RemoveNotification(infos.option,
-            infos.key.id, infos.key.label, removeInfo->params.removeReason);
+    if (removeInfo) {
+        if (removeInfo->params.hashcode.has_value()) {
+            removeInfo->info.errorCode = NotificationHelper::RemoveNotification(removeInfo->params.hashcode.value(),
+                removeInfo->params.removeReason);
+        } else if (removeInfo->params.bundleAndKeyInfo.has_value()) {
+            auto &infos = removeInfo->params.bundleAndKeyInfo.value();
+            removeInfo->info.errorCode = NotificationHelper::RemoveNotification(infos.option,
+                infos.key.id, infos.key.label, removeInfo->params.removeReason);
+        }
     }
 }
 
@@ -253,13 +255,15 @@ void RemoveCompleteCallback(napi_env env, napi_status status, void *data)
         return;
     }
     auto removeInfo = static_cast<AsyncCallbackInfoRemove *>(data);
-    Common::ReturnCallbackPromise(env, removeInfo->info, Common::NapiGetNull(env));
-    if (removeInfo->info.callback != nullptr) {
-        napi_delete_reference(env, removeInfo->info.callback);
+    if (removeInfo) {
+        Common::ReturnCallbackPromise(env, removeInfo->info, Common::NapiGetNull(env));
+        if (removeInfo->info.callback != nullptr) {
+            napi_delete_reference(env, removeInfo->info.callback);
+        }
+        napi_delete_async_work(env, removeInfo->asyncWork);
+        delete removeInfo;
+        removeInfo = nullptr;
     }
-    napi_delete_async_work(env, removeInfo->asyncWork);
-    delete removeInfo;
-    removeInfo = nullptr;
 }
 
 napi_value Remove(napi_env env, napi_callback_info info)
@@ -315,16 +319,17 @@ napi_value RemoveAll(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("RemoveAll napi_create_async_work start");
             AsyncCallbackInfoRemove *asynccallbackinfo = static_cast<AsyncCallbackInfoRemove *>(data);
-
-            if (asynccallbackinfo->params.bundleAndKeyInfo.has_value()) {
-                auto &infos = asynccallbackinfo->params.bundleAndKeyInfo.value();
-
-                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveAllNotifications(infos.option);
-            } else if (asynccallbackinfo->params.hasUserId) {
-                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotifications(
-                    asynccallbackinfo->params.userId);
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotifications();
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->params.bundleAndKeyInfo.has_value()) {
+                    auto &infos = asynccallbackinfo->params.bundleAndKeyInfo.value();
+
+                    asynccallbackinfo->info.errorCode = NotificationHelper::RemoveAllNotifications(infos.option);
+                } else if (asynccallbackinfo->params.hasUserId) {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotifications(
+                        asynccallbackinfo->params.userId);
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotifications();
+                }
             }
         },
         [](napi_env env, napi_status status, void *data) {
@@ -360,13 +365,15 @@ void AsyncCompleteCallbackRemoveGroupByBundle(napi_env env, napi_status status,
         return;
     }
     AsyncCallbackInfoRemoveGroupByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoRemoveGroupByBundle *>(data);
-    Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo) {
+        Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value RemoveGroupByBundle(napi_env env, napi_callback_info info)
@@ -396,12 +403,14 @@ napi_value RemoveGroupByBundle(napi_env env, napi_callback_info info)
             ANS_LOGI("RemoveGroupByBundle napi_create_async_work start");
             AsyncCallbackInfoRemoveGroupByBundle *asynccallbackinfo =
                 static_cast<AsyncCallbackInfoRemoveGroupByBundle *>(data);
-            ANS_LOGI("option.bundle = %{public}s, option.uid = %{public}d, groupName = %{public}s",
-                asynccallbackinfo->params.option.GetBundleName().c_str(),
-                asynccallbackinfo->params.option.GetUid(),
-                asynccallbackinfo->params.groupName.c_str());
-            asynccallbackinfo->info.errorCode = NotificationHelper::RemoveGroupByBundle(
-                asynccallbackinfo->params.option, asynccallbackinfo->params.groupName);
+            if (asynccallbackinfo) {
+                ANS_LOGI("option.bundle = %{public}s, option.uid = %{public}d, groupName = %{public}s",
+                    asynccallbackinfo->params.option.GetBundleName().c_str(),
+                    asynccallbackinfo->params.option.GetUid(),
+                    asynccallbackinfo->params.groupName.c_str());
+                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveGroupByBundle(
+                    asynccallbackinfo->params.option, asynccallbackinfo->params.groupName);
+            }
         },
         AsyncCompleteCallbackRemoveGroupByBundle,
         (void *)asynccallbackinfo,
diff --git a/frameworks/js/napi/src/slot.cpp b/frameworks/js/napi/src/slot.cpp
index 1b98786bace056eb22303e7ddb140153e9867c7f..4d35b7801d873e56ffc858507578e992e51536c5 100644
--- a/frameworks/js/napi/src/slot.cpp
+++ b/frameworks/js/napi/src/slot.cpp
@@ -506,10 +506,12 @@ napi_value AddSlot(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("AddSlot napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlot *>(data);
-            if (asynccallbackinfo->isAddSlotByType) {
-                asynccallbackinfo->info.errorCode = NotificationHelper::AddSlotByType(asynccallbackinfo->inType);
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlot(asynccallbackinfo->slot);
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->isAddSlotByType) {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::AddSlotByType(asynccallbackinfo->inType);
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlot(asynccallbackinfo->slot);
+                }
             }
         },
         [](napi_env env, napi_status status, void *data) {
@@ -563,7 +565,9 @@ napi_value AddSlots(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("AddSlots napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoAddSlots *>(data);
-            asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlots(asynccallbackinfo->slots);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::AddNotificationSlots(asynccallbackinfo->slots);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("AddSlots napi_create_async_work end");
@@ -616,9 +620,10 @@ napi_value SetSlotByBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("SetSlotByBundle napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoSetSlotByBundle *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::UpdateNotificationSlots(
-                asynccallbackinfo->params.option, asynccallbackinfo->params.slots);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::UpdateNotificationSlots(
+                    asynccallbackinfo->params.option, asynccallbackinfo->params.slots);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("SetSlotByBundle napi_create_async_work end");
@@ -656,25 +661,27 @@ void AsyncCompleteCallbackGetSlot(napi_env env, napi_status status, void *data)
     }
 
     auto asynccallbackinfo = static_cast<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)) {
+    if (asynccallbackinfo) {
+        napi_value result = Common::NapiGetNull(env);
+        if (asynccallbackinfo->info.errorCode == ERR_OK) {
+            if (asynccallbackinfo->slot == nullptr) {
                 asynccallbackinfo->info.errorCode = ERROR;
-                result = Common::NapiGetNull(env);
+            } 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);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    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);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value GetSlot(napi_env env, napi_callback_info info)
@@ -703,9 +710,10 @@ napi_value GetSlot(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetSlot napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoGetSlot *>(data);
-
-            asynccallbackinfo->info.errorCode =
-                NotificationHelper::GetNotificationSlot(asynccallbackinfo->outType, asynccallbackinfo->slot);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode =
+                    NotificationHelper::GetNotificationSlot(asynccallbackinfo->outType, asynccallbackinfo->slot);
+            }
         },
         AsyncCompleteCallbackGetSlot,
         (void *)asynccallbackinfo,
@@ -746,9 +754,10 @@ napi_value GetSlotNumByBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetSlotNumByBundle napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotNumByBundle *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotNumAsBundle(
-                asynccallbackinfo->params.option, asynccallbackinfo->num);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotNumAsBundle(
+                    asynccallbackinfo->params.option, asynccallbackinfo->num);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("GetSlotNumByBundle napi_create_async_work end");
@@ -786,39 +795,41 @@ void AsyncCompleteCallbackGetSlots(napi_env env, napi_status status, void *data)
     }
     napi_value result = nullptr;
     auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlots *>(data);
-    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;
+    if (asynccallbackinfo) {
+        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++;
             }
-            napi_value nSlot = nullptr;
-            napi_create_object(env, &nSlot);
-            if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
-                continue;
+            ANS_LOGI("getSlots count = %{public}zu", count);
+            result = arr;
+            if ((count == 0) && (asynccallbackinfo->slots.size() > 0)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
             }
-            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);
         }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    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);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value GetSlots(napi_env env, napi_callback_info info)
@@ -846,7 +857,9 @@ napi_value GetSlots(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetSlots napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlots *>(data);
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlots(asynccallbackinfo->slots);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlots(asynccallbackinfo->slots);
+            }
         },
         AsyncCompleteCallbackGetSlots,
         (void *)asynccallbackinfo,
@@ -870,39 +883,41 @@ void AsyncCompleteCallbackGetSlotsByBundle(napi_env env, napi_status status, voi
     }
     napi_value result = nullptr;
     auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotsByBundle *>(data);
-    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;
+    if (asynccallbackinfo) {
+        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++;
             }
-            napi_value nSlot = nullptr;
-            napi_create_object(env, &nSlot);
-            if (!Common::SetNotificationSlot(env, *vec, nSlot)) {
-                continue;
+            ANS_LOGI("getSlots count = %{public}zu", count);
+            result = arr;
+            if ((count == 0) && (asynccallbackinfo->slots.size() > 0)) {
+                asynccallbackinfo->info.errorCode = ERROR;
+                result = Common::NapiGetNull(env);
             }
-            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);
         }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    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);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value GetSlotsByBundle(napi_env env, napi_callback_info info)
@@ -931,8 +946,10 @@ napi_value GetSlotsByBundle(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("GetSlotsByBundle napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoGetSlotsByBundle *>(data);
+            if (asynccallbackinfo) {
             asynccallbackinfo->info.errorCode = NotificationHelper::GetNotificationSlotsForBundle(
                 asynccallbackinfo->params.option, asynccallbackinfo->slots);
+            }
         },
         AsyncCompleteCallbackGetSlotsByBundle,
         (void *)asynccallbackinfo,
@@ -973,7 +990,9 @@ napi_value RemoveSlot(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("removeSlot napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveSlot *>(data);
-            asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotificationSlot(asynccallbackinfo->outType);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotificationSlot(asynccallbackinfo->outType);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("removeSlot napi_create_async_work end");
@@ -1025,7 +1044,9 @@ napi_value RemoveAllSlots(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("RemoveAllSlots napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoRemoveAllSlots *>(data);
-            asynccallbackinfo->info.errorCode = NotificationHelper::RemoveAllSlots();
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveAllSlots();
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("RemoveAllSlots napi_create_async_work end");
@@ -1138,9 +1159,10 @@ napi_value EnableNotificationSlot(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("EnableNotificationSlot napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoEnableSlot *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::SetEnabledForBundleSlot(
-                asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->params.enable);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::SetEnabledForBundleSlot(
+                    asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->params.enable);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("EnableNotificationSlot napi_create_async_work end");
@@ -1245,9 +1267,10 @@ napi_value IsEnableNotificationSlot(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("IsEnableNotificationSlot napi_create_async_work start");
             auto asynccallbackinfo = static_cast<AsyncCallbackInfoInfoIsEnableSlot *>(data);
-
-            asynccallbackinfo->info.errorCode = NotificationHelper::GetEnabledForBundleSlot(
-                asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->isEnable);
+            if (asynccallbackinfo) {
+                asynccallbackinfo->info.errorCode = NotificationHelper::GetEnabledForBundleSlot(
+                    asynccallbackinfo->params.option, asynccallbackinfo->params.outType, asynccallbackinfo->isEnable);
+            }
         },
         [](napi_env env, napi_status status, void *data) {
             ANS_LOGI("IsEnableNotificationSlot napi_create_async_work end");
diff --git a/frameworks/js/napi/src/subscribe.cpp b/frameworks/js/napi/src/subscribe.cpp
index c3d9eef18fddadd8e79809ca04d1071e18d4341f..2cd810e4c10e8806f456dcac329877efe4ac50e0 100644
--- a/frameworks/js/napi/src/subscribe.cpp
+++ b/frameworks/js/napi/src/subscribe.cpp
@@ -1176,16 +1176,18 @@ napi_value Subscribe(napi_env env, napi_callback_info info)
                 return;
             }
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoSubscribe *>(data);
-            if (asynccallbackinfo->subscriberInfo.hasSubscribeInfo) {
-                ANS_LOGI("Subscribe with NotificationSubscribeInfo");
-                OHOS::Notification::NotificationSubscribeInfo subscribeInfo;
-                subscribeInfo.AddAppNames(asynccallbackinfo->subscriberInfo.bundleNames);
-                subscribeInfo.AddAppUserId(asynccallbackinfo->subscriberInfo.userId);
-                asynccallbackinfo->info.errorCode =
-                    NotificationHelper::SubscribeNotification(*(asynccallbackinfo->objectInfo), subscribeInfo);
-            } else {
-                asynccallbackinfo->info.errorCode =
-                    NotificationHelper::SubscribeNotification(*(asynccallbackinfo->objectInfo));
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->subscriberInfo.hasSubscribeInfo) {
+                    ANS_LOGI("Subscribe with NotificationSubscribeInfo");
+                    OHOS::Notification::NotificationSubscribeInfo subscribeInfo;
+                    subscribeInfo.AddAppNames(asynccallbackinfo->subscriberInfo.bundleNames);
+                    subscribeInfo.AddAppUserId(asynccallbackinfo->subscriberInfo.userId);
+                    asynccallbackinfo->info.errorCode =
+                        NotificationHelper::SubscribeNotification(*(asynccallbackinfo->objectInfo), subscribeInfo);
+                } else {
+                    asynccallbackinfo->info.errorCode =
+                        NotificationHelper::SubscribeNotification(*(asynccallbackinfo->objectInfo));
+                }
             }
         },
         [](napi_env env, napi_status status, void *data) {
@@ -1195,15 +1197,17 @@ napi_value Subscribe(napi_env env, napi_callback_info info)
                 return;
             }
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoSubscribe *>(data);
-            Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+            if (asynccallbackinfo) {
+                Common::ReturnCallbackPromise(env, asynccallbackinfo->info, Common::NapiGetNull(env));
 
-            if (asynccallbackinfo->info.callback != nullptr) {
-                napi_delete_reference(env, asynccallbackinfo->info.callback);
-            }
-            napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
 
-            delete asynccallbackinfo;
-            asynccallbackinfo = nullptr;
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
         },
         (void *)asynccallbackinfo,
         &asynccallbackinfo->asyncWork);
diff --git a/frameworks/js/napi/src/subscribe/napi_remove.cpp b/frameworks/js/napi/src/subscribe/napi_remove.cpp
index a4838e9d9f17d962a5618decea0160566174c1c2..afcaee725f67f138b77949b517451bf0b3cd1c62 100644
--- a/frameworks/js/napi/src/subscribe/napi_remove.cpp
+++ b/frameworks/js/napi/src/subscribe/napi_remove.cpp
@@ -28,13 +28,15 @@ void NapiRemoveExecuteCallback(napi_env env, void *data)
         return;
     }
     auto removeInfo = static_cast<AsyncCallbackInfoRemove *>(data);
-    if (removeInfo->params.hashcode.has_value()) {
-        removeInfo->info.errorCode = NotificationHelper::RemoveNotification(removeInfo->params.hashcode.value(),
-            removeInfo->params.removeReason);
-    } else if (removeInfo->params.bundleAndKeyInfo.has_value()) {
-        auto &infos = removeInfo->params.bundleAndKeyInfo.value();
-        removeInfo->info.errorCode = NotificationHelper::RemoveNotification(infos.option,
-            infos.key.id, infos.key.label, removeInfo->params.removeReason);
+    if (removeInfo) {
+        if (removeInfo->params.hashcode.has_value()) {
+            removeInfo->info.errorCode = NotificationHelper::RemoveNotification(removeInfo->params.hashcode.value(),
+                removeInfo->params.removeReason);
+        } else if (removeInfo->params.bundleAndKeyInfo.has_value()) {
+            auto &infos = removeInfo->params.bundleAndKeyInfo.value();
+            removeInfo->info.errorCode = NotificationHelper::RemoveNotification(infos.option,
+                infos.key.id, infos.key.label, removeInfo->params.removeReason);
+        }
     }
 }
 
@@ -46,13 +48,15 @@ void NapiRemoveCompleteCallback(napi_env env, napi_status status, void *data)
         return;
     }
     auto removeInfo = static_cast<AsyncCallbackInfoRemove *>(data);
-    Common::CreateReturnValue(env, removeInfo->info, Common::NapiGetNull(env));
-    if (removeInfo->info.callback != nullptr) {
-        napi_delete_reference(env, removeInfo->info.callback);
+    if (removeInfo) {
+        Common::CreateReturnValue(env, removeInfo->info, Common::NapiGetNull(env));
+        if (removeInfo->info.callback != nullptr) {
+            napi_delete_reference(env, removeInfo->info.callback);
+        }
+        napi_delete_async_work(env, removeInfo->asyncWork);
+        delete removeInfo;
+        removeInfo = nullptr;
     }
-    napi_delete_async_work(env, removeInfo->asyncWork);
-    delete removeInfo;
-    removeInfo = nullptr;
 }
 
 napi_value NapiRemove(napi_env env, napi_callback_info info)
@@ -109,15 +113,16 @@ napi_value NapiRemoveAll(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("RemoveAll napi_create_async_work start");
             AsyncCallbackInfoRemove *asynccallbackinfo = static_cast<AsyncCallbackInfoRemove *>(data);
-
-            if (asynccallbackinfo->params.bundleAndKeyInfo.has_value()) {
-                auto &infos = asynccallbackinfo->params.bundleAndKeyInfo.value();
-                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveAllNotifications(infos.option);
-            } else if (asynccallbackinfo->params.hasUserId) {
-                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotifications(
-                    asynccallbackinfo->params.userId);
-            } else {
-                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotifications();
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->params.bundleAndKeyInfo.has_value()) {
+                    auto &infos = asynccallbackinfo->params.bundleAndKeyInfo.value();
+                    asynccallbackinfo->info.errorCode = NotificationHelper::RemoveAllNotifications(infos.option);
+                } else if (asynccallbackinfo->params.hasUserId) {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotifications(
+                        asynccallbackinfo->params.userId);
+                } else {
+                    asynccallbackinfo->info.errorCode = NotificationHelper::RemoveNotifications();
+                }
             }
         },
         [](napi_env env, napi_status status, void *data) {
@@ -153,13 +158,15 @@ void AsyncCompleteCallbackNapiRemoveGroupByBundle(napi_env env, napi_status stat
         return;
     }
     AsyncCallbackInfoRemoveGroupByBundle *asynccallbackinfo = static_cast<AsyncCallbackInfoRemoveGroupByBundle *>(data);
-    Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
-    if (asynccallbackinfo->info.callback != nullptr) {
-        napi_delete_reference(env, asynccallbackinfo->info.callback);
+    if (asynccallbackinfo){
+        Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+        if (asynccallbackinfo->info.callback != nullptr) {
+            napi_delete_reference(env, asynccallbackinfo->info.callback);
+        }
+        napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+        delete asynccallbackinfo;
+        asynccallbackinfo = nullptr;
     }
-    napi_delete_async_work(env, asynccallbackinfo->asyncWork);
-    delete asynccallbackinfo;
-    asynccallbackinfo = nullptr;
 }
 
 napi_value NapiRemoveGroupByBundle(napi_env env, napi_callback_info info)
@@ -189,12 +196,14 @@ napi_value NapiRemoveGroupByBundle(napi_env env, napi_callback_info info)
             ANS_LOGI("RemoveGroupByBundle napi_create_async_work start");
             AsyncCallbackInfoRemoveGroupByBundle *asynccallbackinfo =
                 static_cast<AsyncCallbackInfoRemoveGroupByBundle *>(data);
-            ANS_LOGI("option.bundle = %{public}s, option.uid = %{public}d, groupName = %{public}s",
-                asynccallbackinfo->params.option.GetBundleName().c_str(),
-                asynccallbackinfo->params.option.GetUid(),
-                asynccallbackinfo->params.groupName.c_str());
-            asynccallbackinfo->info.errorCode = NotificationHelper::RemoveGroupByBundle(
-                asynccallbackinfo->params.option, asynccallbackinfo->params.groupName);
+            if (asynccallbackinfo) {
+                ANS_LOGI("option.bundle = %{public}s, option.uid = %{public}d, groupName = %{public}s",
+                    asynccallbackinfo->params.option.GetBundleName().c_str(),
+                    asynccallbackinfo->params.option.GetUid(),
+                    asynccallbackinfo->params.groupName.c_str());
+                asynccallbackinfo->info.errorCode = NotificationHelper::RemoveGroupByBundle(
+                    asynccallbackinfo->params.option, asynccallbackinfo->params.groupName);
+            }
         },
         AsyncCompleteCallbackNapiRemoveGroupByBundle,
         (void *)asynccallbackinfo,
diff --git a/frameworks/js/napi/src/subscribe/napi_subscribe.cpp b/frameworks/js/napi/src/subscribe/napi_subscribe.cpp
index c3b009c8971743b6d295978838427185112bac7d..b73236cfa605f5f51706605d5ad878ec1afb7642 100644
--- a/frameworks/js/napi/src/subscribe/napi_subscribe.cpp
+++ b/frameworks/js/napi/src/subscribe/napi_subscribe.cpp
@@ -62,16 +62,18 @@ napi_value NapiSubscribe(napi_env env, napi_callback_info info)
                 return;
             }
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoSubscribe *>(data);
-            if (asynccallbackinfo->subscriberInfo.hasSubscribeInfo) {
-                ANS_LOGI("Subscribe with NotificationSubscribeInfo");
-                OHOS::Notification::NotificationSubscribeInfo subscribeInfo;
-                subscribeInfo.AddAppNames(asynccallbackinfo->subscriberInfo.bundleNames);
-                subscribeInfo.AddAppUserId(asynccallbackinfo->subscriberInfo.userId);
-                asynccallbackinfo->info.errorCode =
-                    NotificationHelper::SubscribeNotification(*(asynccallbackinfo->objectInfo), subscribeInfo);
-            } else {
-                asynccallbackinfo->info.errorCode =
-                    NotificationHelper::SubscribeNotification(*(asynccallbackinfo->objectInfo));
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->subscriberInfo.hasSubscribeInfo) {
+                    ANS_LOGI("Subscribe with NotificationSubscribeInfo");
+                    OHOS::Notification::NotificationSubscribeInfo subscribeInfo;
+                    subscribeInfo.AddAppNames(asynccallbackinfo->subscriberInfo.bundleNames);
+                    subscribeInfo.AddAppUserId(asynccallbackinfo->subscriberInfo.userId);
+                    asynccallbackinfo->info.errorCode =
+                        NotificationHelper::SubscribeNotification(*(asynccallbackinfo->objectInfo), subscribeInfo);
+                } else {
+                    asynccallbackinfo->info.errorCode =
+                        NotificationHelper::SubscribeNotification(*(asynccallbackinfo->objectInfo));
+                }
             }
         },
         [](napi_env env, napi_status status, void *data) {
@@ -81,15 +83,17 @@ napi_value NapiSubscribe(napi_env env, napi_callback_info info)
                 return;
             }
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoSubscribe *>(data);
-            Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
+            if (asynccallbackinfo) {
+                Common::CreateReturnValue(env, asynccallbackinfo->info, Common::NapiGetNull(env));
 
-            if (asynccallbackinfo->info.callback != nullptr) {
-                napi_delete_reference(env, asynccallbackinfo->info.callback);
-            }
-            napi_delete_async_work(env, asynccallbackinfo->asyncWork);
+                if (asynccallbackinfo->info.callback != nullptr) {
+                    napi_delete_reference(env, asynccallbackinfo->info.callback);
+                }
+                napi_delete_async_work(env, asynccallbackinfo->asyncWork);
 
-            delete asynccallbackinfo;
-            asynccallbackinfo = nullptr;
+                delete asynccallbackinfo;
+                asynccallbackinfo = nullptr;
+            }
         },
         (void *)asynccallbackinfo,
         &asynccallbackinfo->asyncWork);
@@ -129,22 +133,23 @@ napi_value NapiUnsubscribe(napi_env env, napi_callback_info info)
         [](napi_env env, void *data) {
             ANS_LOGI("Unsubscribe napi_create_async_work start");
             auto asynccallbackinfo = reinterpret_cast<AsyncCallbackInfoUnsubscribe *>(data);
+            if (asynccallbackinfo) {
+                if (asynccallbackinfo->objectInfo == nullptr) {
+                    ANS_LOGE("invalid object info");
+                    asynccallbackinfo->info.errorCode = ERR_ANS_INVALID_PARAM;
+                    return;
+                }
 
-            if (asynccallbackinfo->objectInfo == nullptr) {
-                ANS_LOGE("invalid object info");
-                asynccallbackinfo->info.errorCode = ERR_ANS_INVALID_PARAM;
-                return;
-            }
-
-            bool ret = AddDeletingSubscriber(asynccallbackinfo->objectInfo);
-            if (ret) {
-                asynccallbackinfo->info.errorCode =
-                    NotificationHelper::UnSubscribeNotification(*(asynccallbackinfo->objectInfo));
-                if (asynccallbackinfo->info.errorCode != ERR_OK) {
-                    DelDeletingSubscriber(asynccallbackinfo->objectInfo);
+                bool ret = AddDeletingSubscriber(asynccallbackinfo->objectInfo);
+                if (ret) {
+                    asynccallbackinfo->info.errorCode =
+                        NotificationHelper::UnSubscribeNotification(*(asynccallbackinfo->objectInfo));
+                    if (asynccallbackinfo->info.errorCode != ERR_OK) {
+                        DelDeletingSubscriber(asynccallbackinfo->objectInfo);
+                    }
+                } else {
+                    asynccallbackinfo->info.errorCode = ERR_ANS_SUBSCRIBER_IS_DELETING;
                 }
-            } else {
-                asynccallbackinfo->info.errorCode = ERR_ANS_SUBSCRIBER_IS_DELETING;
             }
         },
         [](napi_env env, napi_status status, void *data) {
diff --git a/test/fuzztest/anscallbackstub_fuzzer/anscallbackstub_fuzzer.cpp b/test/fuzztest/anscallbackstub_fuzzer/anscallbackstub_fuzzer.cpp
index 17d19877d640174603ae57ffd9fa78d0df9ae9f5..cbbaac7561ad1fed1cc3759d69c060b007e90305 100644
--- a/test/fuzztest/anscallbackstub_fuzzer/anscallbackstub_fuzzer.cpp
+++ b/test/fuzztest/anscallbackstub_fuzzer/anscallbackstub_fuzzer.cpp
@@ -33,7 +33,6 @@ class AnsCallbackStubImpl : public AnsCallbackStub {
 
 bool DoSomethingInterestingWithMyAPI(const char* data, size_t size)
 {
-    std::string stringData(data);
     std::shared_ptr<AnsCallbackStubImpl> ansCallbackStub =
         std::make_shared<AnsCallbackStubImpl>();
     uint32_t code = GetU32Data(data);
diff --git a/test/fuzztest/anssubscriberproxy_fuzzer/anssubscriberproxy_fuzzer.cpp b/test/fuzztest/anssubscriberproxy_fuzzer/anssubscriberproxy_fuzzer.cpp
index 85ee11544080bc783c829c08c3c9bf665fdccedc..112ed301158b53b1a5b9f8b9b78cefc5e2555286 100644
--- a/test/fuzztest/anssubscriberproxy_fuzzer/anssubscriberproxy_fuzzer.cpp
+++ b/test/fuzztest/anssubscriberproxy_fuzzer/anssubscriberproxy_fuzzer.cpp
@@ -25,7 +25,6 @@
 namespace OHOS {
     bool DoSomethingInterestingWithMyAPI(const char* data, size_t size)
     {
-        std::string stringData(data);
         sptr<IRemoteObject> impl;
         Notification::AnsSubscriberProxy ansSubscriberProxy(impl);
         uint32_t code = GetU32Data(data);
diff --git a/test/fuzztest/anssubscriberstub_fuzzer/anssubscriberstub_fuzzer.cpp b/test/fuzztest/anssubscriberstub_fuzzer/anssubscriberstub_fuzzer.cpp
index 25e72818e1ebb6ea6f8fe2dc5bb0bed49458d55c..6c0611243e80e1b53ff2789810d2ace425245aca 100644
--- a/test/fuzztest/anssubscriberstub_fuzzer/anssubscriberstub_fuzzer.cpp
+++ b/test/fuzztest/anssubscriberstub_fuzzer/anssubscriberstub_fuzzer.cpp
@@ -24,7 +24,6 @@
 namespace OHOS {
     bool DoSomethingInterestingWithMyAPI(const char* data, size_t size)
     {
-        std::string stringData(data);
         Notification::AnsSubscriberStub ansSubscriberStub;
         uint32_t code = GetU32Data(data);
         MessageParcel datas;
diff --git a/test/fuzztest/notificationcontent_fuzzer/notificationcontent_fuzzer.cpp b/test/fuzztest/notificationcontent_fuzzer/notificationcontent_fuzzer.cpp
index 2b913e0a6e3c3fd8eafbb7910dad03242cd81ecf..f3e4b2be4ccbfa1cc9743c1b47f13d5d3b8e1aee 100644
--- a/test/fuzztest/notificationcontent_fuzzer/notificationcontent_fuzzer.cpp
+++ b/test/fuzztest/notificationcontent_fuzzer/notificationcontent_fuzzer.cpp
@@ -35,10 +35,6 @@ namespace OHOS {
         std::make_shared<Notification::NotificationMultiLineContent>();
         std::shared_ptr<Notification::NotificationMediaContent> mediaContent =
         std::make_shared<Notification::NotificationMediaContent>();
-        if ((normalContent == nullptr) || (longTextContent == nullptr) || (pictureContent == nullptr) ||
-            (conversationContent == nullptr) || (multiLineContent == nullptr) || (mediaContent == nullptr)) {
-            return false;
-        }
         Notification::NotificationContent notificationContent(normalContent);
         Notification::NotificationContent notificationLongTextContent(longTextContent);
         Notification::NotificationContent notificationPictureContent(pictureContent);
diff --git a/test/fuzztest/notificationuserinputannex_fuzzer/notificationuserinputannex_fuzzer.cpp b/test/fuzztest/notificationuserinputannex_fuzzer/notificationuserinputannex_fuzzer.cpp
index 3b9fc30ea9174fb99145799b61e91370876e4aa8..4533cfa0a067c03aae65e668692a87d8faa9ebbf 100644
--- a/test/fuzztest/notificationuserinputannex_fuzzer/notificationuserinputannex_fuzzer.cpp
+++ b/test/fuzztest/notificationuserinputannex_fuzzer/notificationuserinputannex_fuzzer.cpp
@@ -43,8 +43,7 @@ namespace OHOS {
         uint8_t inputEditTypes = *data % INPUT_EDIT_TYPE;
         Notification::NotificationConstant::InputEditType inputEditType =
             Notification::NotificationConstant::InputEditType(inputEditTypes);
-        std::shared_ptr<Notification::NotificationUserInput> notificationUserInputs =
-            Notification::NotificationUserInput::Create(inputKey, tag, options, permitFreeFormInput,
+        Notification::NotificationUserInput::Create(inputKey, tag, options, permitFreeFormInput,
                 permitMimeTypes, additional, inputEditType);
         Notification::NotificationUserInput notificationUserInputannex
             (inputKey, tag, options, permitFreeFormInput, permitMimeTypes, additional, inputEditType);
diff --git a/test/fuzztest/reminderrequestannexthree_fuzzer/reminderrequestannexthree_fuzzer.cpp b/test/fuzztest/reminderrequestannexthree_fuzzer/reminderrequestannexthree_fuzzer.cpp
index 8e0a45d9de28f8cf6a37b5a349a9d09d4af5a5d6..707db3d974416ee9294271090678279032aeb15f 100644
--- a/test/fuzztest/reminderrequestannexthree_fuzzer/reminderrequestannexthree_fuzzer.cpp
+++ b/test/fuzztest/reminderrequestannexthree_fuzzer/reminderrequestannexthree_fuzzer.cpp
@@ -23,7 +23,6 @@
 namespace OHOS {
     bool DoSomethingInterestingWithMyAPI(const char* data, size_t size)
     {
-        std::string stringData(data);
         int32_t reminderId = static_cast<int32_t>(GetU32Data(data));
         Notification::ReminderRequest reminderRequest(reminderId);
         reminderRequest.GetTitle();