diff --git a/frameworks/ets/ani/app_manager/src/ets_app_manager.cpp b/frameworks/ets/ani/app_manager/src/ets_app_manager.cpp
index b6436e2238d83acc719849784ca6916f34e97053..89e65a270a681c855a43af8513ff20485586373e 100644
--- a/frameworks/ets/ani/app_manager/src/ets_app_manager.cpp
+++ b/frameworks/ets/ani/app_manager/src/ets_app_manager.cpp
@@ -59,6 +59,15 @@ static const char *OFF_SIGNATURE_ABILITY_FIRST_FRAME_STATE
     = "Lstd/core/String;Lapplication/AbilityFirstFrameStateObserver/AbilityFirstFrameStateObserver;:V";
 static const char *OFF_SIGNATURE_APP_FOREGROUND_STATE
     = "Lstd/core/String;Lapplication/AppForegroundStateObserver/AppForegroundStateObserver;:V";
+constexpr const char *BUNDLE_NAME_CHECK_SIG = "Lstd/core/String;:V";
+constexpr const char *CLEAR_UP_APPLICATION_DATA_SIG = "Lstd/core/String;Lutils/AbilityUtils/AsyncCallbackWrapper;:V";
+constexpr const char *GET_KEEP_ALIVE_APP_SERVICE_EXTENSION_SIG = "Lutils/AbilityUtils/AsyncCallbackWrapper;:V";
+constexpr const char *SET_KEEP_ALIVE_FOR_APP_SERVICE_EXTENSION_SIG =
+    "Lstd/core/String;ZLutils/AbilityUtils/AsyncCallbackWrapper;:V";
+constexpr const char *CLEAR_UP_APP_DATA_SIG = "Lutils/AbilityUtils/AsyncCallbackWrapper;"
+    "Lstd/core/String;Lstd/core/Int;:V";
+constexpr const char *TERMINATION_SIG = "ILutils/AbilityUtils/AsyncCallbackWrapper;:V";
+constexpr const char *IS_APP_RUNNING_SIG = "Lstd/core/String;Lutils/AbilityUtils/AsyncCallbackWrapper;:V";
 } // namespace
 
 class EtsAppManager final {
@@ -104,7 +113,15 @@ public:
     static void OnOnAbilityFirstFrameState(
         ani_env *env, ani_string type, ani_object aniObserver, ani_object aniBundleName);
     static void OnOffAbilityFirstFrameState(ani_env *env, ani_string type, ani_object aniObserver);
-
+    static void ClearUpApplicationDataCheck(ani_env *env, ani_string aniBundleName);
+    static void ClearUpApplicationData(ani_env *env, ani_string aniBundleName, ani_object callback);
+    static void GetKeepAliveAppServiceExtensions(ani_env *env, ani_object callback);
+    static void SetKeepAliveForAppServiceExtension(ani_env *env, ani_string aniBundleName, ani_boolean enable,
+        ani_object callback);
+    static void ClearUpAppDataCheck(ani_env *env, ani_string aniBundleName);
+    static void ClearUpAppData(ani_env *env, ani_object callback, ani_string aniBundleName, ani_object appCloneIndex);
+    static void TerminateMission(ani_env *env, ani_int missionId, ani_object callback);
+    static void IsApplicationRunning(ani_env *env, ani_string aniBundleName, ani_object callback);
 private:
     static sptr<AppExecFwk::IAppMgr> GetAppManagerInstance();
     static sptr<AAFwk::IAbilityManager> GetAbilityManagerInstance();
@@ -1317,6 +1334,263 @@ void EtsAppManager::OnOffAppForegroundState(ani_env *env, ani_string type, ani_o
     TAG_LOGD(AAFwkTag::APPMGR, "OnOffAppForegroundState end");
 }
 
+void EtsAppManager::ClearUpApplicationDataCheck(ani_env *env, ani_string aniBundleName)
+{
+    TAG_LOGD(AAFwkTag::APPMGR, "ClearUpApplicationDataCheck called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "env null ptr");
+        return;
+    }
+    std::string bundleName;
+    if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName) || bundleName.empty()) {
+        TAG_LOGE(AAFwkTag::APPMGR, "get bundleName failed");
+        AbilityRuntime::EtsErrorUtil::ThrowInvalidParamError(env, "Parse param bundleName failed, must be a string.");
+        return;
+    }
+}
+
+void EtsAppManager::ClearUpApplicationData(ani_env *env, ani_string aniBundleName, ani_object callback)
+{
+    TAG_LOGD(AAFwkTag::APPMGR, "ClearUpApplicationData called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "env null ptr");
+        return;
+    }
+    std::string bundleName;
+    if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName) || bundleName.empty()) {
+        TAG_LOGE(AAFwkTag::APPMGR, "get bundleName failed");
+        return;
+    }
+    sptr<AppExecFwk::IAppMgr> appMgr = GetAppManagerInstance();
+    if (appMgr == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "null appMgr");
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env,
+            static_cast<int32_t>(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr);
+        return;
+    }
+    int32_t ret = appMgr->ClearUpApplicationData(bundleName, 0);
+    TAG_LOGD(AAFwkTag::APPMGR, "ClearUpApplicationData ret %{public}d", ret);
+    if (ret == 0) {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, ret), nullptr);
+    } else if (ret == AAFwk::CHECK_PERMISSION_FAILED || ret == AAFwk::ERR_NOT_SYSTEM_APP) {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, ret, "clear up application failed."), nullptr);
+    } else {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env,
+                static_cast<int32_t>(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER),
+                "clear up application failed."), nullptr);
+    }
+    TAG_LOGD(AAFwkTag::APPMGR, "ClearUpApplicationData end");
+}
+
+void EtsAppManager::GetKeepAliveAppServiceExtensions(ani_env *env, ani_object callback)
+{
+    TAG_LOGD(AAFwkTag::APPMGR, "GetKeepAliveAppServiceExtensions called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "env null ptr");
+        return;
+    }
+    ani_object emptyArray = CreateEmptyAniArray(env);
+    int32_t innerErrCode = static_cast<int32_t>(ERR_OK);
+    auto infoList = std::make_shared<std::vector<AbilityRuntime::KeepAliveInfo>>();
+    if (infoList == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "infoList or inner code null");
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env,
+            static_cast<int32_t>(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray);
+        return;
+    }
+    auto abilityManager = GetAbilityManagerInstance();
+    if (abilityManager == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "null abilityManager");
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env,
+            static_cast<int32_t>(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray);
+        return;
+    }
+    innerErrCode = abilityManager->QueryKeepAliveAppServiceExtensions(*infoList);
+    ani_object arrayObj = CreateKeepAliveInfoArray(env, *infoList);
+    if (arrayObj == nullptr) {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env,
+            static_cast<int32_t>(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), emptyArray);
+        return;
+    }
+    if (innerErrCode != ERR_OK) {
+        TAG_LOGD(AAFwkTag::APPMGR, "QueryKeepAliveAppServiceExtensions failed:%{public}d", innerErrCode);
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, innerErrCode), emptyArray);
+    } else {
+        TAG_LOGD(AAFwkTag::APPMGR, "QueryKeepAliveAppServiceExtensions succeeded.");
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, innerErrCode), arrayObj);
+    }
+    TAG_LOGD(AAFwkTag::APPMGR, "GetKeepAliveAppServiceExtensions end");
+}
+
+void EtsAppManager::SetKeepAliveForAppServiceExtension(ani_env *env, ani_string aniBundleName, ani_boolean enable,
+    ani_object callback)
+{
+    TAG_LOGD(AAFwkTag::APPMGR, "SetKeepAliveForAppServiceExtension called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "env null ptr");
+        return;
+    }
+    std::string bundleName;
+    if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName) || bundleName.empty()) {
+        TAG_LOGE(AAFwkTag::APPMGR, "get bundleName failed");
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateInvalidParamError(
+                env, "Parse param bundleName failed, must be a string."), nullptr);
+        return;
+    }
+    auto abilityManager = GetAbilityManagerInstance();
+    if (abilityManager == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "null abilityManager");
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env,
+            static_cast<int32_t>(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr);
+        return;
+    }
+    int32_t innerErrCode = abilityManager->SetAppServiceExtensionKeepAlive(bundleName, enable);
+    TAG_LOGD(AAFwkTag::APPMGR, "SetAppServiceExtensionKeepAlive innerErrCode:%{public}d", innerErrCode);
+    AppExecFwk::AsyncCallback(env, callback,
+        AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, innerErrCode), nullptr);
+    TAG_LOGD(AAFwkTag::APPMGR, "SetKeepAliveForAppServiceExtension end");
+}
+
+void EtsAppManager::ClearUpAppDataCheck(ani_env *env, ani_string aniBundleName)
+{
+    TAG_LOGD(AAFwkTag::APPMGR, "ClearUpAppDataCheck called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "env null ptr");
+        return;
+    }
+    std::string bundleName;
+    if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName) || bundleName.empty()) {
+        TAG_LOGE(AAFwkTag::APPMGR, "get bundleName failed");
+        AbilityRuntime::EtsErrorUtil::ThrowInvalidParamError(env, "Parse param bundleName failed, must be a string");
+        return;
+    }
+}
+
+void EtsAppManager::ClearUpAppData(ani_env *env, ani_object callback, ani_string aniBundleName,
+    ani_object aniAppCloneIndex)
+{
+    TAG_LOGD(AAFwkTag::APPMGR, "ClearUpAppData called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "env null ptr");
+        return;
+    }
+    std::string bundleName;
+    if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName) || bundleName.empty()) {
+        TAG_LOGE(AAFwkTag::APPMGR, "get bundleName failed");
+        return;
+    }
+    int32_t appCloneIndex = 0;
+    ani_boolean isUndefined = false;
+    ani_status status = ANI_ERROR;
+    if ((status = env->Reference_IsUndefined(aniAppCloneIndex, &isUndefined)) != ANI_OK) {
+        TAG_LOGE(AAFwkTag::APPMGR, "Failed to check undefined status : %{public}d", status);
+        return;
+    }
+    if (!isUndefined) {
+        if ((status = env->Object_CallMethodByName_Int(aniAppCloneIndex,
+            "toInt", nullptr, &appCloneIndex)) != ANI_OK) {
+            TAG_LOGE(AAFwkTag::APPMGR, "Object_CallMethodByName_Int status : %{public}d", status);
+            return;
+        }
+        TAG_LOGD(AAFwkTag::APPMGR, "aniAppCloneIndex: %{public}d", appCloneIndex);
+    }
+    sptr<OHOS::AppExecFwk::IAppMgr> appMgr = GetAppManagerInstance();
+    if (appMgr == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr");
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env,
+                static_cast<int32_t>(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr);
+        return;
+    }
+    int32_t ret = appMgr->ClearUpApplicationData(bundleName, appCloneIndex);
+    TAG_LOGD(AAFwkTag::APPMGR, "ClearUpApplicationData ret:%{public}d", ret);
+    if (ret == 0) {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, ret), nullptr);
+    } else {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, ret,  "clear up application failed."), nullptr);
+    }
+    TAG_LOGD(AAFwkTag::APPMGR, "ClearUpAppData end");
+}
+
+void EtsAppManager::TerminateMission(ani_env *env, ani_int missionId, ani_object callback)
+{
+    TAG_LOGD(AAFwkTag::APPMGR, "TerminateMission call");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "env null ptr");
+        return;
+    }
+    TAG_LOGD(AAFwkTag::APPMGR, "missionId:%{public}d", missionId);
+    auto amsClient = AAFwk::AbilityManagerClient::GetInstance();
+    if (amsClient == nullptr) {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env,
+                static_cast<int32_t>(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)), nullptr);
+        return;
+    }
+    int32_t ret = amsClient->TerminateMission(missionId);
+    TAG_LOGD(AAFwkTag::APPMGR, "TerminateMission ret:%{public}d", ret);
+    if (ret == ERR_OK) {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, ret), nullptr);
+    } else {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, ret,  "Terminate mission failed."), nullptr);
+    }
+    TAG_LOGD(AAFwkTag::APPMGR, "TerminateMission end");
+}
+
+void EtsAppManager::IsApplicationRunning(ani_env *env, ani_string aniBundleName, ani_object callback)
+{
+    TAG_LOGD(AAFwkTag::APPMGR, "IsApplicationRunning called");
+    if (env == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "env null ptr");
+        return;
+    }
+    std::string bundleName;
+    if (!AppExecFwk::GetStdString(env, aniBundleName, bundleName)) {
+        TAG_LOGE(AAFwkTag::APPMGR, "get bundleName failed");
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateInvalidParamError(
+                env, "Parse param bundleName failed, must be a string."), AppExecFwk::CreateBoolean(env, false));
+        return;
+    }
+    sptr<OHOS::AppExecFwk::IAppMgr> appMgr = GetAppManagerInstance();
+    if (appMgr == nullptr) {
+        TAG_LOGE(AAFwkTag::APPMGR, "appManager null ptr");
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env,
+                static_cast<int32_t>(AbilityRuntime::AbilityErrorCode::ERROR_CODE_INNER)),
+            AppExecFwk::CreateBoolean(env, false));
+        return;
+    }
+    bool isRunning = false;
+    int32_t innerErrorCode = appMgr->IsApplicationRunning(bundleName, isRunning);
+    TAG_LOGD(AAFwkTag::APPMGR, "IsApplicationRunning isRunning:%{public}d", isRunning);
+    if (innerErrorCode == ERR_OK) {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, innerErrorCode),
+            AppExecFwk::CreateBoolean(env, isRunning));
+    } else {
+        AppExecFwk::AsyncCallback(env, callback,
+            AbilityRuntime::EtsErrorUtil::CreateErrorByNativeErr(env, innerErrorCode),
+            AppExecFwk::CreateBoolean(env, false));
+    }
+    TAG_LOGD(AAFwkTag::APPMGR, "IsApplicationRunning end");
+}
+
 void EtsAppManagerRegistryInit(ani_env *env)
 {
     TAG_LOGD(AAFwkTag::APPMGR, "EtsAppManagerRegistryInit call");
@@ -1393,6 +1667,22 @@ void EtsAppManagerRegistryInit(ani_env *env)
             reinterpret_cast<void *>(EtsAppManager::OnOnAbilityFirstFrameState)},
         ani_native_function {"nativeOffAbilityFirstFrameState", OFF_SIGNATURE_ABILITY_FIRST_FRAME_STATE,
             reinterpret_cast<void *>(EtsAppManager::OnOffAbilityFirstFrameState)},
+        ani_native_function {"nativeClearUpApplicationDataCheck", BUNDLE_NAME_CHECK_SIG,
+            reinterpret_cast<void *>(EtsAppManager::ClearUpApplicationDataCheck)},
+        ani_native_function {"nativeClearUpApplicationData", CLEAR_UP_APPLICATION_DATA_SIG,
+            reinterpret_cast<void *>(EtsAppManager::ClearUpApplicationData)},
+        ani_native_function {"nativeGetKeepAliveAppServiceExtensions", GET_KEEP_ALIVE_APP_SERVICE_EXTENSION_SIG,
+            reinterpret_cast<void *>(EtsAppManager::GetKeepAliveAppServiceExtensions)},
+        ani_native_function {"nativeSetKeepAliveForAppServiceExtension", SET_KEEP_ALIVE_FOR_APP_SERVICE_EXTENSION_SIG,
+            reinterpret_cast<void *>(EtsAppManager::SetKeepAliveForAppServiceExtension)},
+        ani_native_function {"nativeClearUpAppDataCheck", BUNDLE_NAME_CHECK_SIG,
+            reinterpret_cast<void *>(EtsAppManager::ClearUpAppDataCheck)},
+        ani_native_function {"nativeClearUpAppData", CLEAR_UP_APP_DATA_SIG,
+            reinterpret_cast<void *>(EtsAppManager::ClearUpAppData)},
+        ani_native_function {"nativeTerminateMission", TERMINATION_SIG,
+            reinterpret_cast<void *>(EtsAppManager::TerminateMission)},
+        ani_native_function {"nativeIsApplicationRunning", IS_APP_RUNNING_SIG,
+            reinterpret_cast<void *>(EtsAppManager::IsApplicationRunning)},
 	};
     status = env->Namespace_BindNativeFunctions(ns, kitFunctions.data(), kitFunctions.size());
     if (status != ANI_OK) {
diff --git a/frameworks/ets/ani/app_manager/src/ets_app_manager_utils.cpp b/frameworks/ets/ani/app_manager/src/ets_app_manager_utils.cpp
index 5844ad4197bb944085cf94cbc8460132ae6122fb..8203d0012a591a29892a136c3fe01a0de9c0ce4b 100644
--- a/frameworks/ets/ani/app_manager/src/ets_app_manager_utils.cpp
+++ b/frameworks/ets/ani/app_manager/src/ets_app_manager_utils.cpp
@@ -861,6 +861,11 @@ bool SetKeepAliveInfo(ani_env *env, ani_object object, const AbilityRuntime::Kee
         TAG_LOGE(AAFwkTag::APPMGR, "state failed status:%{public}d", status);
         return false;
     }
+    if ((status = env->Object_SetPropertyByName_Ref(object, "setterUserId",
+        AppExecFwk::CreateInt(env, keepInfo.setterId))) != ANI_OK) {
+        TAG_LOGE(AAFwkTag::ANI, "setterUserId failed status:%{public}d", status);
+        return false;
+    }
     return true;
 }
 
diff --git a/frameworks/ets/ets/@ohos.app.ability.appManager.ets b/frameworks/ets/ets/@ohos.app.ability.appManager.ets
index 5995889d83ffaa28974448b508fda4cadf525a20..bc7ea3a43789ff8275687fcf89817a023460c7d3 100644
--- a/frameworks/ets/ets/@ohos.app.ability.appManager.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.appManager.ets
@@ -73,12 +73,16 @@ export interface KeepAliveBundleInfo {
     bundleName: string;
     type: KeepAliveAppType;
     setter: KeepAliveSetter;
+    setterUserId?: int;
+    allowUserToCancel?: boolean;
 }
 
 export class KeepAliveBundleInfoInner implements KeepAliveBundleInfo {
     bundleName: string = '';
     type: KeepAliveAppType = KeepAliveAppType.ALL;
     setter: KeepAliveSetter = KeepAliveSetter.SYSTEM;
+    setterUserId?: int;
+    allowUserToCancel?: boolean;
 }
 
 export native function nativePreloadApplication(callback: AsyncCallbackWrapper<void>, bundleName: string, userId: int,
@@ -574,4 +578,126 @@ export function getKeepAliveBundles(type: KeepAliveAppType, userId?: int): Promi
   return p;
 }
 
+export native function nativeClearUpApplicationDataCheck(bundleName: string) : void;
+export native function nativeClearUpApplicationData(bundleName: string, callback: AsyncCallbackWrapper<void>) : void;
+export function clearUpApplicationData(bundleName: string, callback: AsyncCallback<void>): void {
+  let myCall = new AsyncCallbackWrapper<void>(callback);
+  taskpool.execute((): void => {
+    appManager.nativeClearUpApplicationData(bundleName, myCall);
+  });
+}
+
+function clearUpApplicationData(bundleName: string): Promise<void> {
+  appManager.nativeClearUpApplicationDataCheck(bundleName);
+  let p = new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+    let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      if (err == null || err.code == 0) {
+        resolve(undefined);
+      } else {
+        reject(err);
+      }
+    });
+    taskpool.execute((): void => {
+      appManager.nativeClearUpApplicationData(bundleName, myCall);
+    });
+  });
+  return p;
+}
+
+export native function nativeGetKeepAliveAppServiceExtensions(callback: AsyncCallbackWrapper<Array<KeepAliveBundleInfo>>) : void;
+export function getKeepAliveAppServiceExtensions(): Promise<Array<KeepAliveBundleInfo>> {
+  let p = new Promise<Array<KeepAliveBundleInfo>>((resolve: (data: Array<KeepAliveBundleInfo>) => void, reject: (err: BusinessError) => void): void => {
+    let myCall = new AsyncCallbackWrapper<Array<KeepAliveBundleInfo>>((err: BusinessError | null, data: Array<KeepAliveBundleInfo> | undefined) => {
+      if (err == null || err.code == 0) {
+        resolve(data as Array<KeepAliveBundleInfo>);
+      } else {
+        reject(err);
+      }
+    });
+    taskpool.execute((): void => {
+      appManager.nativeGetKeepAliveAppServiceExtensions(myCall);
+    });
+  });
+  return p;
+}
+
+export native function nativeSetKeepAliveForAppServiceExtension(bundleName: string, enabled: boolean,
+  callback: AsyncCallbackWrapper<void>) : void;
+export function setKeepAliveForAppServiceExtension(bundleName: string, enabled: boolean): Promise<void> {
+  let p = new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+    let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      if (err == null || err.code == 0) {
+        resolve(undefined);
+      } else {
+        reject(err);
+      }
+    });
+    taskpool.execute((): void => {
+      appManager.nativeSetKeepAliveForAppServiceExtension(bundleName, enabled, myCall);
+    });
+  });
+  return p;
+}
+
+export native function nativeClearUpAppDataCheck(bundleName: string) : void;
+export native function nativeClearUpAppData(callback: AsyncCallbackWrapper<void>, bundleName: string,
+  appCloneIndex?: int) : void;
+export function clearUpAppData(bundleName: string, appCloneIndex?: int): Promise<void> {
+  appManager.nativeClearUpAppDataCheck(bundleName);
+  let p = new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+    let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      if (err == null || err.code == 0) {
+        resolve(undefined);
+      } else {
+        reject(err);
+      }
+    });
+    taskpool.execute((): void => {
+      appManager.nativeClearUpAppData(myCall, bundleName, appCloneIndex);
+    });
+  });
+  return p;
+}
+
+export native function nativeTerminateMission(missionId: int, callback: AsyncCallbackWrapper<void>) : void;
+export function terminateMission(missionId: int): Promise<void> {
+  let p = new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+    let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      if (err == null || err.code == 0) {
+        resolve(undefined);
+      } else {
+        reject(err);
+      }
+    });
+    taskpool.execute((): void => {
+      appManager.nativeTerminateMission(missionId, myCall);
+    });
+  });
+  return p;
+}
+
+export native function nativeIsApplicationRunning(bundleName: string, callback: AsyncCallbackWrapper<boolean>) : void;
+export function isApplicationRunning(bundleName: string): Promise<boolean>
+{
+  let p = new Promise<boolean>((resolve: (data: boolean) => void, reject: (err: BusinessError) => void): void => {
+    let myCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined) => {
+      if (err == null || err.code == 0) {
+        resolve(data as boolean);
+      } else {
+        reject(err);
+      }
+    });
+    taskpool.execute((): void => {
+      appManager.nativeIsApplicationRunning(bundleName, myCall);
+    });
+  });
+  return p;
+}
+
+export function isApplicationRunning(bundleName: string, callback: AsyncCallback<boolean>): void {
+  let myCall = new AsyncCallbackWrapper<boolean>(callback);
+  taskpool.execute((): void => {
+    appManager.nativeIsApplicationRunning(bundleName, myCall);
+  });
+}
 } // namespace appManager