diff --git a/frameworks/test/unittest/bgtask_framework_unit_test.cpp b/frameworks/test/unittest/bgtask_framework_unit_test.cpp
index 8fb953e369964febd5bcf2e53c6fb6e96e359131..9a771a93abf131a48026ba263d694eda5e34ac05 100644
--- a/frameworks/test/unittest/bgtask_framework_unit_test.cpp
+++ b/frameworks/test/unittest/bgtask_framework_unit_test.cpp
@@ -856,6 +856,25 @@ HWTEST_F(BgTaskFrameworkUnitTest, RequestGetAllContinuousTasks_001, TestSize.Lev
         ERR_BGTASK_PERMISSION_DENIED);
 }
 
+/**
+ * @tc.name: RequestGetAllContinuousTasks_002
+ * @tc.desc: test RequestGetAllContinuousTasks
+ * @tc.type: FUNC
+ * @tc.require: issuesICRZHF
+ */
+HWTEST_F(BgTaskFrameworkUnitTest, RequestGetAllContinuousTasks_002, TestSize.Level1)
+{
+    DelayedSingleton<BackgroundTaskManager>::GetInstance()->proxy_ = nullptr;
+    SystemAbilityManagerClient::GetInstance().action_ = "set_null";
+    std::vector<std::shared_ptr<ContinuousTaskInfo>> list;
+    EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestGetAllContinuousTasks(list, false),
+        ERR_BGTASK_SERVICE_NOT_CONNECTED);
+
+    SystemAbilityManagerClient::GetInstance().action_ = "";
+    EXPECT_EQ(DelayedSingleton<BackgroundTaskManager>::GetInstance()->RequestGetAllContinuousTasks(list, false),
+        ERR_BGTASK_PERMISSION_DENIED);
+}
+
 /**
  * @tc.name: GetAllTransientTasks_001
  * @tc.desc: test GetAllTransientTasks.
diff --git a/interfaces/innerkits/include/continuous_task_info.h b/interfaces/innerkits/include/continuous_task_info.h
index a9255ed0b9e5db1210b4841b750b22509180dc26..91881ffe26d7b90c0c29ec4cedcba543e6738282 100644
--- a/interfaces/innerkits/include/continuous_task_info.h
+++ b/interfaces/innerkits/include/continuous_task_info.h
@@ -125,6 +125,13 @@ public:
      */
     bool IsFromWebView() const;
 
+    /**
+     * @brief Get suspendState.
+     *
+     * @return the suspend state.
+     */
+    bool GetSuspendState() const;
+
     std::string ToString(const std::vector<uint32_t> &modes) const;
 
 private:
@@ -141,6 +148,7 @@ private:
     int32_t abilityId_ {-1};
     std::string wantAgentBundleName_ {""};
     std::string wantAgentAbilityName_ {""};
+    bool suspendState_ {false};
 };
 }  // namespace BackgroundTaskMgr
 }  // namespace OHOS
diff --git a/interfaces/innerkits/src/continuous_task_info.cpp b/interfaces/innerkits/src/continuous_task_info.cpp
index d66ab3d5e79dd6775d6e90406472578f90af6ccf..25d60f7c622c581715f3f6ba5635808f26ba5693 100644
--- a/interfaces/innerkits/src/continuous_task_info.cpp
+++ b/interfaces/innerkits/src/continuous_task_info.cpp
@@ -74,6 +74,11 @@ bool ContinuousTaskInfo::IsFromWebView() const
     return isFromWebView_;
 }
 
+bool ContinuousTaskInfo::GetSuspendState() const
+{
+    return suspendState_;
+}
+
 std::string ContinuousTaskInfo::ToString(const std::vector<uint32_t> &modes) const
 {
     std::string result;
@@ -103,6 +108,7 @@ bool ContinuousTaskInfo::Marshalling(Parcel& out) const
     WRITE_PARCEL_WITH_RET(out, Int32, abilityId_, false);
     WRITE_PARCEL_WITH_RET(out, String, wantAgentBundleName_, false);
     WRITE_PARCEL_WITH_RET(out, String, wantAgentAbilityName_, false);
+    WRITE_PARCEL_WITH_RET(out, Bool, suspendState_, false);
     return true;
 }
 
@@ -136,6 +142,7 @@ bool ContinuousTaskInfo::ReadFromParcel(Parcel& in)
     READ_PARCEL_WITH_RET(in, Int32, abilityId_, false);
     READ_PARCEL_WITH_RET(in, String, wantAgentBundleName_, false);
     READ_PARCEL_WITH_RET(in, String, wantAgentAbilityName_, false);
+    READ_PARCEL_WITH_RET(in, Bool, suspendState_, false);
     return true;
 }
 }  // namespace BackgroundTaskMgr
diff --git a/interfaces/kits/napi/src/bg_continuous_task_napi_module.cpp b/interfaces/kits/napi/src/bg_continuous_task_napi_module.cpp
index 4e0cd48cf381e3dc3d81e03a9d2173cacb129ded..07e23b01b123d3d456f31c462ea5d3ebbd37a549 100644
--- a/interfaces/kits/napi/src/bg_continuous_task_napi_module.cpp
+++ b/interfaces/kits/napi/src/bg_continuous_task_napi_module.cpp
@@ -42,7 +42,7 @@ namespace {
 static constexpr uint32_t MAX_START_BG_RUNNING_PARAMS = 4;
 static constexpr uint32_t MAX_STOP_BG_RUNNING_PARAMS = 2;
 static constexpr uint32_t MAX_UPDATE_BG_RUNNING_PARAMS = 2;
-static constexpr uint32_t MAX_GET_ALL_CONTINUOUSTASK_PARAMS = 1;
+static constexpr uint32_t MAX_GET_ALL_CONTINUOUSTASK_PARAMS = 2;
 static constexpr uint32_t CALLBACK_RESULT_PARAMS_NUM = 2;
 static constexpr uint32_t BG_MODE_ID_BEGIN = 1;
 static constexpr uint32_t BG_MODE_ID_END = 9;
@@ -82,6 +82,7 @@ struct AsyncCallbackInfo : public AsyncWorkData {
     std::shared_ptr<AbilityRuntime::WantAgent::WantAgent> wantAgent {nullptr};
     std::vector<uint32_t> bgModes {};
     bool isBatchApi {false};
+    bool includeSuspended {false};
     int32_t notificationId {-1}; // out
     int32_t continuousTaskId {-1}; // out
     std::vector<std::shared_ptr<ContinuousTaskInfo>> list; // out
@@ -504,6 +505,45 @@ napi_value GetWantAgent(const napi_env &env, const napi_value &value,
     return WrapVoidToJS(env);
 }
 
+napi_value GetIncludeSuspended(const napi_env &env, const napi_value &value, bool &includeSuspended)
+{
+    napi_valuetype valuetype = napi_undefined;
+    NAPI_CALL(env, napi_typeof(env, value, &valuetype));
+    if (valuetype != napi_boolean) {
+        Common::HandleParamErr(env, ERR_WANTAGENT_NULL_OR_TYPE_ERR, true);
+        return nullptr;
+    }
+    napi_get_value_bool(env, value, &includeSuspended);
+    return WrapVoidToJS(env);
+}
+
+bool GetAllContinuousTasksCheckParamBeforeSubmit(napi_env env, size_t argc, napi_value *argv, bool isThrow,
+    AsyncCallbackInfo *asyncCallbackInfo)
+{
+    if (argc > MAX_GET_ALL_CONTINUOUSTASK_PARAMS || argc < ARGC_ONE) {
+        BGTASK_LOGE("wrong param nums");
+        Common::HandleParamErr(env, ERR_PARAM_NUMBER_ERR, isThrow);
+        asyncCallbackInfo->errCode = ERR_PARAM_NUMBER_ERR;
+        return false;
+    }
+    // argv[0] : context : AbilityContext
+    if (GetAbilityContext(env, argv[0], asyncCallbackInfo->abilityContext) == nullptr) {
+        BGTASK_LOGE("GetAllContinuousTasks Get ability context failed");
+        Common::HandleParamErr(env, ERR_CONTEXT_NULL_OR_TYPE_ERR, isThrow);
+        asyncCallbackInfo->errCode = ERR_CONTEXT_NULL_OR_TYPE_ERR;
+        return false;
+    }
+
+    // argv[1] : includeSuspended : includeSuspended
+    if (argc == ARGC_TWO && GetIncludeSuspended(env, argv[1], asyncCallbackInfo->includeSuspended) == nullptr) {
+        BGTASK_LOGE("GetAllContinuousTasks Get includeSuspended failed");
+        Common::HandleParamErr(env, ERR_BGMODE_NULL_OR_TYPE_ERR, isThrow);
+        asyncCallbackInfo->errCode = ERR_BGMODE_NULL_OR_TYPE_ERR;
+        return false;
+    }
+    return true;
+}
+
 bool StartBackgroundRunningCheckParamBeforeSubmit(napi_env env, napi_value *argv, size_t len, bool isThrow,
     AsyncCallbackInfo *asyncCallbackInfo)
 {
@@ -946,6 +986,19 @@ void GetAllContinuousTasksExecuteCB(napi_env env, void *data)
     asyncCallbackInfo->errCode = BackgroundTaskMgrHelper::RequestGetAllContinuousTasks(asyncCallbackInfo->list);
 }
 
+void GetAllContinuousTasksIncludeSuspendedExecuteCB(napi_env env, void *data)
+{
+    HitraceScoped traceScoped(HITRACE_TAG_OHOS,
+        "BackgroundTaskManager::ContinuousTask::Napi::GetAllContinuousTasksIncludeSuspendedExecuteCB");
+    AsyncCallbackInfo *asyncCallbackInfo = static_cast<AsyncCallbackInfo *>(data);
+    if (asyncCallbackInfo == nullptr || asyncCallbackInfo->errCode != ERR_OK) {
+        BGTASK_LOGE("input params error");
+        return;
+    }
+    asyncCallbackInfo->errCode = BackgroundTaskMgrHelper::RequestGetAllContinuousTasks(
+        asyncCallbackInfo->list, asyncCallbackInfo->includeSuspended);
+}
+
 void GetAllContinuousTasksPromiseCompletedCB(napi_env env, napi_status status, void *data)
 {
     HitraceScoped traceScoped(HITRACE_TAG_OHOS,
@@ -998,6 +1051,30 @@ napi_value GetAllContinuousTasksPromise(napi_env env, AsyncCallbackInfo *asyncCa
     return promise;
 }
 
+napi_value GetAllContinuousTasksIncludeSuspendedPromise(
+    napi_env env, AsyncCallbackInfo *asyncCallbackInfo, bool isThrow)
+{
+    if (asyncCallbackInfo == nullptr) {
+        BGTASK_LOGE("param is nullptr");
+        return nullptr;
+    }
+    napi_value resourceName;
+    NAPI_CALL(env, napi_create_string_latin1(env, __func__, NAPI_AUTO_LENGTH, &resourceName));
+    napi_deferred deferred;
+    napi_value promise {nullptr};
+    NAPI_CALL(env, napi_create_promise(env, &deferred, &promise));
+    asyncCallbackInfo->deferred = deferred;
+    NAPI_CALL(env, napi_create_async_work(env,
+        nullptr,
+        resourceName,
+        GetAllContinuousTasksIncludeSuspendedExecuteCB,
+        GetAllContinuousTasksPromiseCompletedCB,
+        static_cast<void *>(asyncCallbackInfo),
+        &asyncCallbackInfo->asyncWork));
+    NAPI_CALL(env, napi_queue_async_work(env, asyncCallbackInfo->asyncWork));
+    return promise;
+}
+
 napi_value GetAllContinuousTasks(napi_env env, napi_callback_info info, bool isThrow)
 {
     HitraceScoped traceScoped(HITRACE_TAG_OHOS,
@@ -1017,21 +1094,8 @@ napi_value GetAllContinuousTasks(napi_env env, napi_callback_info info, bool isT
     size_t argc = MAX_GET_ALL_CONTINUOUSTASK_PARAMS;
     napi_value argv[MAX_GET_ALL_CONTINUOUSTASK_PARAMS] = {nullptr};
     NAPI_CALL(env, napi_get_cb_info(env, info, &argc, argv, NULL, NULL));
-    if (argc != MAX_GET_ALL_CONTINUOUSTASK_PARAMS) {
-        BGTASK_LOGE("wrong param nums");
-        Common::HandleParamErr(env, ERR_PARAM_NUMBER_ERR, isThrow);
-        callbackPtr.release();
-        if (asyncCallbackInfo != nullptr) {
-            delete asyncCallbackInfo;
-            asyncCallbackInfo = nullptr;
-        }
-        return WrapVoidToJS(env);
-    }
 
-    // argv[0] : context : AbilityContext
-    if (GetAbilityContext(env, argv[0], asyncCallbackInfo->abilityContext) == nullptr) {
-        BGTASK_LOGE("Get ability context failed");
-        Common::HandleParamErr(env, ERR_CONTEXT_NULL_OR_TYPE_ERR, isThrow);
+    if (!GetAllContinuousTasksCheckParamBeforeSubmit(env, argc, argv, isThrow, asyncCallbackInfo)) {
         callbackPtr.release();
         if (asyncCallbackInfo != nullptr) {
             delete asyncCallbackInfo;
@@ -1041,7 +1105,11 @@ napi_value GetAllContinuousTasks(napi_env env, napi_callback_info info, bool isT
     }
 
     napi_value ret {nullptr};
-    ret = GetAllContinuousTasksPromise(env, asyncCallbackInfo, isThrow);
+    if (argc == ARGC_ONE) {
+        ret = GetAllContinuousTasksPromise(env, asyncCallbackInfo, isThrow);
+    } else {
+        ret = GetAllContinuousTasksIncludeSuspendedPromise(env, asyncCallbackInfo, isThrow);
+    }
     callbackPtr.release();
     if (ret == nullptr) {
         BGTASK_LOGE("ret is nullpter");
diff --git a/interfaces/kits/napi/src/common.cpp b/interfaces/kits/napi/src/common.cpp
index 97db68f2ad146aa8f74933c2500ef62d040a57a2..177e04989f72cf6b131b1137a981523744454207 100644
--- a/interfaces/kits/napi/src/common.cpp
+++ b/interfaces/kits/napi/src/common.cpp
@@ -519,6 +519,11 @@ napi_value Common::GetNapiContinuousTaskInfo(napi_env env,
     NAPI_CALL(env, napi_create_string_utf8(env, continuousTaskInfo->GetWantAgentAbilityName().c_str(),
         continuousTaskInfo->GetWantAgentAbilityName().length(), &napiWantAgentAbilityName));
     NAPI_CALL(env, napi_set_named_property(env, napiInfo, "wantAgentAbilityName", napiWantAgentAbilityName));
+
+    // suspend state.
+    napi_value napiSuspendState = nullptr;
+    NAPI_CALL(env, napi_get_boolean(env, continuousTaskInfo->GetSuspendState(), &napiSuspendState));
+    NAPI_CALL(env, napi_set_named_property(env, napiInfo, "suspendState", napiSuspendState));
     return napiInfo;
 }
 
diff --git a/interfaces/test/unittest/bgtask_manager_client_test/bgtask_client_unit_test.cpp b/interfaces/test/unittest/bgtask_manager_client_test/bgtask_client_unit_test.cpp
index 7cf12f88d1481beb8aaef4c4379f1ca77016d505..05702633a14fcb89d12d5ef1b1c00ce10879a1b0 100644
--- a/interfaces/test/unittest/bgtask_manager_client_test/bgtask_client_unit_test.cpp
+++ b/interfaces/test/unittest/bgtask_manager_client_test/bgtask_client_unit_test.cpp
@@ -853,6 +853,18 @@ HWTEST_F(BgTaskClientUnitTest, RequestGetAllContinuousTasks_001, TestSize.Level1
     EXPECT_NE(BackgroundTaskMgrHelper::RequestGetAllContinuousTasks(list), ERR_OK);
 }
 
+/**
+ * @tc.name: RequestGetAllContinuousTasks_002
+ * @tc.desc: test RequestGetAllContinuousTasks interface.
+ * @tc.type: FUNC
+ * @tc.require: issuesICRZHF
+ */
+HWTEST_F(BgTaskClientUnitTest, RequestGetAllContinuousTasks_002, TestSize.Level1)
+{
+    std::vector<std::shared_ptr<ContinuousTaskInfo>> list;
+    EXPECT_NE(BackgroundTaskMgrHelper::RequestGetAllContinuousTasks(list, true), ERR_OK);
+}
+
 /**
  * @tc.name: RequestGetContinuousTasksByUidForInner_001
  * @tc.desc: test RequestGetContinuousTasksByUidForInner interface.
diff --git a/services/continuous_task/include/bg_continuous_task_mgr.h b/services/continuous_task/include/bg_continuous_task_mgr.h
index 5de1673004e72885bc61805308378bbddca781db..43633275433e715420a7bc485d2a588e13c85df9 100644
--- a/services/continuous_task/include/bg_continuous_task_mgr.h
+++ b/services/continuous_task/include/bg_continuous_task_mgr.h
@@ -114,7 +114,9 @@ private:
     ErrCode StartBackgroundRunningForInner(const sptr<ContinuousTaskParamForInner> &taskParam);
     ErrCode StopBackgroundRunningInner(int32_t uid, const std::string &abilityName, int32_t abilityId);
     ErrCode StopBackgroundRunningForInner(const sptr<ContinuousTaskParamForInner> &taskParam);
-    ErrCode GetAllContinuousTasksInner(int32_t uid, std::vector<std::shared_ptr<ContinuousTaskInfo>> &list);
+    ErrCode GetAllContinuousTasksInner(int32_t uid, std::vector<std::shared_ptr<ContinuousTaskInfo>> &list,
+        bool includeSuspended = true);
+    ErrCode CheckIsSysReadyAndPermission(int32_t callingUid);
     ErrCode AddSubscriberInner(const std::shared_ptr<SubscriberInfo> subscriberInfo);
     ErrCode RemoveSubscriberInner(const sptr<IBackgroundTaskSubscriber> &subscriber);
     ErrCode ShellDumpInner(const std::vector<std::string> &dumpOption, std::vector<std::string> &dumpInfo);
diff --git a/services/continuous_task/src/bg_continuous_task_mgr.cpp b/services/continuous_task/src/bg_continuous_task_mgr.cpp
index 6eefd02d5ea3a74ffe7cfbf98603e64a5e7a23ae..0eff3430c9dcd532b36338bd95213855ca5a0f5a 100644
--- a/services/continuous_task/src/bg_continuous_task_mgr.cpp
+++ b/services/continuous_task/src/bg_continuous_task_mgr.cpp
@@ -758,16 +758,11 @@ ErrCode BgContinuousTaskMgr::CheckSubMode(const std::shared_ptr<AAFwk::Want> wan
 ErrCode BgContinuousTaskMgr::UpdateBackgroundRunning(const sptr<ContinuousTaskParam> &taskParam)
 {
     BgTaskHiTraceChain traceChain(__func__);
-    if (!isSysReady_.load()) {
-        BGTASK_LOGW("manager is not ready");
-        return ERR_BGTASK_SYS_NOT_READY;
-    }
-    if (!BundleManagerHelper::GetInstance()->CheckPermission(BGMODE_PERMISSION)) {
-        BGTASK_LOGE("background mode permission is not passed");
-        return ERR_BGTASK_PERMISSION_DENIED;
-    }
-    ErrCode result = ERR_OK;
     int32_t callingUid = IPCSkeleton::GetCallingUid();
+    ErrCode result = CheckIsSysReadyAndPermission(callingUid);
+    if (result != ERR_OK) {
+        return result;
+    }
 
     HitraceScoped traceScoped(HITRACE_TAG_OHOS,
         "BackgroundTaskManager::ContinuousTask::Service::UpdateBackgroundRunningInner");
@@ -1052,20 +1047,11 @@ ErrCode BgContinuousTaskMgr::StopBackgroundRunningInner(int32_t uid, const std::
 
 ErrCode BgContinuousTaskMgr::GetAllContinuousTasks(std::vector<std::shared_ptr<ContinuousTaskInfo>> &list)
 {
-    if (!isSysReady_.load()) {
-        BGTASK_LOGW("manager is not ready");
-        return ERR_BGTASK_SYS_NOT_READY;
-    }
     int32_t callingUid = IPCSkeleton::GetCallingUid();
-    if (!BundleManagerHelper::GetInstance()->CheckPermission(BGMODE_PERMISSION)) {
-        BGTASK_LOGE("uid: %{public}d no have permission", callingUid);
-        return ERR_BGTASK_PERMISSION_DENIED;
-    }
-    if (callingUid < 0) {
-        BGTASK_LOGE("param callingUid: %{public}d is invaild", callingUid);
-        return ERR_BGTASK_INVALID_UID;
+    ErrCode result = CheckIsSysReadyAndPermission(callingUid);
+    if (result != ERR_OK) {
+        return result;
     }
-    ErrCode result = ERR_OK;
     HitraceScoped traceScoped(HITRACE_TAG_OHOS,
         "BackgroundTaskManager::ContinuousTask::Service::GetAllContinuousTasks");
     handler_->PostSyncTask([this, callingUid, &list, &result]() {
@@ -1077,17 +1063,43 @@ ErrCode BgContinuousTaskMgr::GetAllContinuousTasks(std::vector<std::shared_ptr<C
 ErrCode BgContinuousTaskMgr::GetAllContinuousTasks(
     std::vector<std::shared_ptr<ContinuousTaskInfo>> &list, bool includeSuspended)
 {
+    int32_t callingUid = IPCSkeleton::GetCallingUid();
+    ErrCode result = CheckIsSysReadyAndPermission(callingUid);
+    if (result != ERR_OK) {
+        return result;
+    }
     HitraceScoped traceScoped(HITRACE_TAG_OHOS,
         "BackgroundTaskManager::ContinuousTask::Service::GetAllContinuousTasksIncludeSuspended");
+    handler_->PostSyncTask([this, callingUid, &list, &result, includeSuspended]() {
+        result = this->GetAllContinuousTasksInner(callingUid, list, includeSuspended);
+        }, AppExecFwk::EventQueue::Priority::HIGH);
+    return result;
+}
+
+ErrCode BgContinuousTaskMgr::CheckIsSysReadyAndPermission(int32_t callingUid)
+{
+    if (!isSysReady_.load()) {
+        BGTASK_LOGW("manager is not ready");
+        return ERR_BGTASK_SYS_NOT_READY;
+    }
+    if (!BundleManagerHelper::GetInstance()->CheckPermission(BGMODE_PERMISSION)) {
+        BGTASK_LOGE("uid: %{public}d no have permission", callingUid);
+        return ERR_BGTASK_PERMISSION_DENIED;
+    }
+    if (callingUid < 0) {
+        BGTASK_LOGE("param callingUid: %{public}d is invaild", callingUid);
+        return ERR_BGTASK_INVALID_UID;
+    }
     return ERR_OK;
 }
 
 ErrCode BgContinuousTaskMgr::GetAllContinuousTasksInner(int32_t uid,
-    std::vector<std::shared_ptr<ContinuousTaskInfo>> &list)
+    std::vector<std::shared_ptr<ContinuousTaskInfo>> &list, bool includeSuspended)
 {
     if (continuousTaskInfosMap_.empty()) {
         return ERR_OK;
     }
+    BGTASK_LOGW("GetAllContinuousTasksInner, includeSuspended: %{public}d", includeSuspended);
     for (const auto &record : continuousTaskInfosMap_) {
         if (!record.second) {
             continue;
@@ -1095,6 +1107,9 @@ ErrCode BgContinuousTaskMgr::GetAllContinuousTasksInner(int32_t uid,
         if (record.second->uid_ != uid) {
             continue;
         }
+        if (!includeSuspended && record.second->suspendState_) {
+            continue;
+        }
         std::string wantAgentBundleName {"NULL"};
         std::string wantAgentAbilityName {"NULL"};
         if (record.second->wantAgentInfo_ != nullptr) {
diff --git a/services/test/unittest/bg_continuous_task_mgr_test.cpp b/services/test/unittest/bg_continuous_task_mgr_test.cpp
index b5e599a20f4a39fdc7bb7344c4c28727e5188875..319e6ac7c136b6a929f17f3b306d0d379e91ee1b 100644
--- a/services/test/unittest/bg_continuous_task_mgr_test.cpp
+++ b/services/test/unittest/bg_continuous_task_mgr_test.cpp
@@ -1219,6 +1219,77 @@ HWTEST_F(BgContinuousTaskMgrTest, GetAllContinuousTasks_001, TestSize.Level1)
     EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasks(list2), ERR_OK);
 }
 
+/**
+ * @tc.name: GetAllContinuousTasks_002
+ * @tc.desc: test GetAllContinuousTasks interface.
+ * @tc.type: FUNC
+ * @tc.require: issuesICRZHF
+ */
+HWTEST_F(BgContinuousTaskMgrTest, GetAllContinuousTasks_002, TestSize.Level1)
+{
+    bgContinuousTaskMgr_->isSysReady_.store(false);
+    std::vector<std::shared_ptr<ContinuousTaskInfo>> list;
+    EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasks(list, true), ERR_BGTASK_SYS_NOT_READY);
+
+    bgContinuousTaskMgr_->isSysReady_.store(true);
+    EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasks(list, true), ERR_OK);
+
+    bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
+    std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
+    continuousTaskRecord1->abilityName_ = "abilityName";
+    continuousTaskRecord1->uid_ = 1;
+    continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
+    continuousTaskRecord1->bgModeIds_.push_back(TEST_NUM_TWO);
+    continuousTaskRecord1->bgSubModeIds_.push_back(TEST_NUM_TWO);
+    continuousTaskRecord1->notificationId_ = 1;
+    continuousTaskRecord1->continuousTaskId_ = 1;
+    continuousTaskRecord1->abilityId_ = 1;
+    continuousTaskRecord1->suspendState_ = true;
+
+    std::shared_ptr<WantAgentInfo> info = std::make_shared<WantAgentInfo>();
+    info->bundleName_ = "wantAgentBundleName";
+    info->abilityName_ = "wantAgentAbilityName";
+    continuousTaskRecord1->wantAgentInfo_ = info;
+    bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
+
+    std::vector<std::shared_ptr<ContinuousTaskInfo>> list2;
+    EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasks(list2, false), ERR_OK);
+    EXPECT_TRUE(list2.empty());
+}
+
+/**
+ * @tc.name: GetAllContinuousTasksInner_001
+ * @tc.desc: test GetAllContinuousTasksInner interface.
+ * @tc.type: FUNC
+ * @tc.require: issuesICRZHF
+ */
+HWTEST_F(BgContinuousTaskMgrTest, GetAllContinuousTasksInner_001, TestSize.Level1)
+{
+    bgContinuousTaskMgr_->continuousTaskInfosMap_.clear();
+    std::shared_ptr<ContinuousTaskRecord> continuousTaskRecord1 = std::make_shared<ContinuousTaskRecord>();
+    continuousTaskRecord1->abilityName_ = "abilityName";
+    continuousTaskRecord1->uid_ = 1;
+    continuousTaskRecord1->bgModeId_ = TEST_NUM_TWO;
+    continuousTaskRecord1->bgModeIds_.push_back(TEST_NUM_TWO);
+    continuousTaskRecord1->bgSubModeIds_.push_back(TEST_NUM_TWO);
+    continuousTaskRecord1->notificationId_ = 1;
+    continuousTaskRecord1->continuousTaskId_ = 1;
+    continuousTaskRecord1->abilityId_ = 1;
+    continuousTaskRecord1->suspendState_ = true;
+
+    std::shared_ptr<WantAgentInfo> info = std::make_shared<WantAgentInfo>();
+    info->bundleName_ = "wantAgentBundleName";
+    info->abilityName_ = "wantAgentAbilityName";
+    continuousTaskRecord1->wantAgentInfo_ = info;
+    bgContinuousTaskMgr_->continuousTaskInfosMap_["key1"] = continuousTaskRecord1;
+
+    std::vector<std::shared_ptr<ContinuousTaskInfo>> list3;
+    EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasksInner(100, list3, true), ERR_OK);
+    EXPECT_TRUE(list3.empty());
+    EXPECT_EQ(bgContinuousTaskMgr_->GetAllContinuousTasksInner(1, list3, true), ERR_OK);
+    EXPECT_FALSE(list3.empty());
+}
+
 /**
  * @tc.name: RequestGetContinuousTasksByUidForInner_001
  * @tc.desc: test RequestGetContinuousTasksByUidForInner interface.