From b8030ee1abc92819599b1c6f37dd26d4489ea16f Mon Sep 17 00:00:00 2001
From: zhangzezhong <zhangzezhong8@huawei-partners.com>
Date: Sat, 2 Aug 2025 22:56:50 +0800
Subject: [PATCH] add catch

Signed-off-by: zhangzezhong <zhangzezhong8@huawei-partners.com>
---
 .../src/ets_service_extension_context.cpp     |   4 +
 .../ui_ability/src/ets_ability_context.cpp    |   8 +-
 .../src/ets_ui_extension_content_session.cpp  |   1 +
 .../src/ets_ui_extension_context.cpp          |   1 +
 ....app.ability.UIExtensionContentSession.ets |  32 +-
 .../ets/@ohos.app.ability.abilityManager.ets  |  74 ++-
 .../ets/ets/@ohos.app.ability.appManager.ets  | 549 +++++++++++-------
 .../ets/ets/@ohos.app.ability.application.ets |  26 +-
 .../@ohos.app.ability.insightIntentDriver.ets |   4 +
 .../ets/@ohos.app.ability.missionManager.ets  |  37 +-
 ...@ohos.application.uriPermissionManager.ets | 177 +++---
 .../ets/ets/application/AbilityDelegator.ets  | 198 ++++---
 .../ets/application/ApplicationContext.ets    |  70 ++-
 frameworks/ets/ets/application/Context.ets    |  12 +-
 .../application/ServiceExtensionContext.ets   |  86 +--
 .../ets/ets/application/UIAbilityContext.ets  | 242 +++++---
 .../ets/application/UIExtensionContext.ets    |  86 ++-
 17 files changed, 977 insertions(+), 630 deletions(-)

diff --git a/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp b/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp
index bbda8657de3..7dafe7b4d71 100644
--- a/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp
+++ b/frameworks/ets/ani/service_extension_ability/src/ets_service_extension_context.cpp
@@ -280,6 +280,10 @@ EtsServiceExtensionContext *EtsServiceExtensionContext::GetEtsAbilityContext(
         return nullptr;
     }
     auto weakContext = reinterpret_cast<EtsServiceExtensionContext *>(nativeContextLong);
+    if (weakContext == nullptr) {
+        EtsErrorUtil::ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
+        TAG_LOGE(AAFwkTag::UI_EXT, "weakContext null");
+    }
     return weakContext;
 }
 
diff --git a/frameworks/ets/ani/ui_ability/src/ets_ability_context.cpp b/frameworks/ets/ani/ui_ability/src/ets_ability_context.cpp
index e069362a5fd..6cbc7158768 100644
--- a/frameworks/ets/ani/ui_ability/src/ets_ability_context.cpp
+++ b/frameworks/ets/ani/ui_ability/src/ets_ability_context.cpp
@@ -211,6 +211,10 @@ EtsAbilityContext* EtsAbilityContext::GetEtsAbilityContext(ani_env *env, ani_obj
         return nullptr;
     }
     auto etsContext = reinterpret_cast<EtsAbilityContext *>(etsAbilityContextPtr);
+    if (etsContext == nullptr) {
+        EtsErrorUtil::ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
+        TAG_LOGE(AAFwkTag::UI_EXT, "etsAbilityContext null");
+    }
     return etsContext;
 }
 
@@ -1590,7 +1594,7 @@ ani_object CreateEtsAbilityContext(ani_env *env, std::shared_ptr<AbilityContext>
     ani_ref abilityInfoRef = AppExecFwk::CommonFunAni::ConvertAbilityInfo(env, *abilityInfo);
     ani_status status = env->Object_SetFieldByName_Ref(contextObj, "abilityInfo", abilityInfoRef);
     if (status != ANI_OK) {
-        TAG_LOGE(AAFwkTag::CONTEXT, "Object_SetFieldByName_Ref status: %{public}d", status);
+        TAG_LOGE(AAFwkTag::CONTEXT, "abilityInfo SetField status: %{public}d", status);
         return nullptr;
     }
 
@@ -1601,7 +1605,7 @@ ani_object CreateEtsAbilityContext(ani_env *env, std::shared_ptr<AbilityContext>
     }
     ani_object configurationObj = AppExecFwk::WrapConfiguration(env, *configuration);
     if ((status = env->Object_SetFieldByName_Ref(contextObj, "config", configurationObj)) != ANI_OK) {
-        TAG_LOGE(AAFwkTag::CONTEXT, "Object_SetFieldByName_Ref status: %{public}d", status);
+        TAG_LOGE(AAFwkTag::CONTEXT, "config SetField status: %{public}d", status);
         return nullptr;
     }
     return contextObj;
diff --git a/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_content_session.cpp b/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_content_session.cpp
index 7c1778944f5..261d52a4900 100644
--- a/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_content_session.cpp
+++ b/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_content_session.cpp
@@ -64,6 +64,7 @@ EtsUIExtensionContentSession* EtsUIExtensionContentSession::GetEtsContentSession
     }
     etsContentSession = reinterpret_cast<EtsUIExtensionContentSession *>(etsContentSessionLong);
     if (etsContentSession == nullptr) {
+        EtsErrorUtil::ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
         TAG_LOGE(AAFwkTag::UI_EXT, "etsContentSession null");
         return nullptr;
     }
diff --git a/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_context.cpp b/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_context.cpp
index 59228da3ffe..22cde56b0c2 100644
--- a/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_context.cpp
+++ b/frameworks/ets/ani/ui_extension_ability/src/ets_ui_extension_context.cpp
@@ -676,6 +676,7 @@ EtsUIExtensionContext* EtsUIExtensionContext::GetEtsUIExtensionContext(ani_env *
     }
     etsContext = reinterpret_cast<EtsUIExtensionContext *>(etsContextLong);
     if (etsContext == nullptr) {
+        EtsErrorUtil::ThrowError(env, AbilityErrorCode::ERROR_CODE_INVALID_CONTEXT);
         TAG_LOGE(AAFwkTag::UI_EXT, "etsContext null");
         return nullptr;
     }
diff --git a/frameworks/ets/ets/@ohos.app.ability.UIExtensionContentSession.ets b/frameworks/ets/ets/@ohos.app.ability.UIExtensionContentSession.ets
index 266dbed17a1..353f9a9b094 100644
--- a/frameworks/ets/ets/@ohos.app.ability.UIExtensionContentSession.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.UIExtensionContentSession.ets
@@ -72,16 +72,18 @@ export default class UIExtensionContentSession {
     this.nativeSetReceiveDataForResultCallback(callback);
   }
 
-  terminateSelf(callback:AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+  terminateSelf(callback: AsyncCallback<void>): void {
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.terminateSelfSync(myCall);
+      this.terminateSelfSync(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   terminateSelf(): Promise<void> {
-    let p = new Promise<void>((resolve: (data: undefined) => void, reject:(err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+    let p = new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -89,22 +91,26 @@ export default class UIExtensionContentSession {
         }
       });
       taskpool.execute((): void => {
-        this.terminateSelfSync(myCall);
+        this.terminateSelfSync(asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
     return p;
   }
 
   terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.terminateSelfWithResultSync(parameter, myCall);
+      this.terminateSelfWithResultSync(parameter, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   terminateSelfWithResult(parameter: AbilityResult): Promise<void> {
-    let p = new Promise<void>((resolve: (data: undefined) => void, reject:(err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+    let p = new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -112,7 +118,9 @@ export default class UIExtensionContentSession {
         }
       });
       taskpool.execute((): void => {
-        this.terminateSelfWithResultSync(parameter, myCall);
+        this.terminateSelfWithResultSync(parameter, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
     return p;
@@ -129,7 +137,7 @@ export default class UIExtensionContentSession {
         callback(null, undefined);
       } else {
         callback(retError, undefined);
-      }      
+      }
     }, (err: Error): void => {
       callback(err as BusinessError, undefined);
     });
diff --git a/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets b/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets
index 6d653337ba1..f40ffa0b203 100644
--- a/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.abilityManager.ets
@@ -33,13 +33,14 @@ export default namespace abilityManager {
   export native function nativeOn(type:string, observer: AbilityForegroundStateObserver): void;
   export native function nativeOff(type:string, observer?: AbilityForegroundStateObserver): void;
 
-  export function getForegroundUIAbilities():Promise<Array<AbilityStateData>> {
-    let p = new Promise<Array<AbilityStateData>>((resolve: (data: Array<AbilityStateData>) => void, reject: (error: Error) => void): void => {
+  export function getForegroundUIAbilities(): Promise<Array<AbilityStateData>> {
+    let p = new Promise<Array<AbilityStateData>>((resolve: (data: Array<AbilityStateData>) => void,
+      reject: (error: Error) => void): void => {
       let executeFunc = (): Array<AbilityStateData> => {
         return nativeGetForegroundUIAbilities();
       };
       let p1 = taskpool.execute(executeFunc);
-      p1.then((e :NullishType)=>{
+      p1.then((e: NullishType) => {
         let abilities: Array<AbilityStateData> = e as Array<AbilityStateData>;
         resolve(abilities);
       }, (err: Error): void => {
@@ -50,39 +51,47 @@ export default namespace abilityManager {
   }
 
   export function getForegroundUIAbilities(callback: AsyncCallback<Array<AbilityStateData>, void>): void {
-      let myCall = new AsyncCallbackWrapper<Array<AbilityStateData>>(callback);
-      taskpool.execute((): void => {
-        abilityManager.getForegroundUIAbilitiesCallback(myCall);
-      })
+    let asyncCall = new AsyncCallbackWrapper<Array<AbilityStateData>>(callback);
+    taskpool.execute((): void => {
+      abilityManager.getForegroundUIAbilitiesCallback(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
+    });
   }
 
-  export function getTopAbility():Promise<ElementName> {
-    let p = new Promise<ElementName>((resolve: (data: ElementName)=>void, reject:(err: BusinessError)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<ElementName>((err: BusinessError | null, data: ElementName | undefined)=>{
-        if (err == null || err.code == 0) {
-          resolve(data as ElementName);
-        } else {
-          reject(err);
-        }
+  export function getTopAbility(): Promise<ElementName> {
+    let p =
+      new Promise<ElementName>((resolve: (data: ElementName) => void, reject: (err: BusinessError) => void): void => {
+        let asyncCall =
+          new AsyncCallbackWrapper<ElementName>((err: BusinessError | null, data: ElementName | undefined) => {
+            if (err == null || err.code == 0) {
+              resolve(data as ElementName);
+            } else {
+              reject(err);
+            }
+          });
+        taskpool.execute((): void => {
+          abilityManager.nativeGetTopAbility(asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
+        });
       });
-      taskpool.execute((): void => {
-        abilityManager.nativeGetTopAbility(myCall);
-      });
-    });
     return p;
   }
 
   export function getTopAbility(callback: AsyncCallback<ElementName, void>): void {
-      let myCall = new AsyncCallbackWrapper<ElementName>(callback);
-      taskpool.execute( (): void => {
-          abilityManager.nativeGetTopAbility(myCall);
-      });
+    let asyncCall = new AsyncCallbackWrapper<ElementName>(callback);
+    taskpool.execute((): void => {
+      abilityManager.nativeGetTopAbility(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
+    });
   }
 
   function getAbilityRunningInfos(): Promise<Array<AbilityRunningInfo>> {
     return new Promise<Array<AbilityRunningInfo>>((resolve: (data: Array<AbilityRunningInfo>) => void,
       reject: (err: BusinessError) => void): void => {
-      let syncCall = new AsyncCallbackWrapper<Array<AbilityRunningInfo>>((err: BusinessError | null,
+      let asyncCall = new AsyncCallbackWrapper<Array<AbilityRunningInfo>>((err: BusinessError | null,
         data: Array<AbilityRunningInfo> | undefined) => {
         if (err == null || err.code == 0) {
           resolve(data as Array<AbilityRunningInfo>);
@@ -91,21 +100,26 @@ export default namespace abilityManager {
         }
       });
       taskpool.execute((): void => {
-        abilityManager.nativeGetAbilityRunningInfos(syncCall);
+        abilityManager.nativeGetAbilityRunningInfos(asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
   }
 
   function getAbilityRunningInfos(callback: AsyncCallback<Array<AbilityRunningInfo>>): void {
-    let syncCall = new AsyncCallbackWrapper<Array<AbilityRunningInfo>>(callback);
+    let asyncCall = new AsyncCallbackWrapper<Array<AbilityRunningInfo>>(callback);
     taskpool.execute((): void => {
-      abilityManager.nativeGetAbilityRunningInfos(syncCall);
+      abilityManager.nativeGetAbilityRunningInfos(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   function isEmbeddedOpenAllowed(context: Context, appId: string): Promise<boolean> {
-    return new Promise<boolean>((resolve:(data:boolean)=>void, reject:(err: BusinessError | null)=>void):void => {
-      let asyncCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined)=>{
+    return new Promise<boolean>((resolve: (data: boolean) => void,
+      reject: (err: BusinessError | null) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined) => {
         if (err == null || err.code == 0) {
           resolve(data as boolean);
         } else {
@@ -114,6 +128,8 @@ export default namespace abilityManager {
       });
       taskpool.execute((): void => {
         abilityManager.nativeIsEmbeddedOpenAllowed(context, appId, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
   }
diff --git a/frameworks/ets/ets/@ohos.app.ability.appManager.ets b/frameworks/ets/ets/@ohos.app.ability.appManager.ets
index 836870f7f0f..577b60996db 100644
--- a/frameworks/ets/ets/@ohos.app.ability.appManager.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.appManager.ets
@@ -83,9 +83,11 @@ export class KeepAliveBundleInfoInner implements KeepAliveBundleInfo {
 
 export native function nativePreloadApplication(callback: AsyncCallbackWrapper<void>, bundleName: string, userId: int,
     mode: PreloadMode, appIndex?: int): void;
-export function preloadApplication(bundleName: string, userId: int, mode: PreloadMode, appIndex?: int): Promise<void>{
-   let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError | null)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null)=>{
+export function preloadApplication(bundleName: string, userId: int, mode: PreloadMode,
+  appIndex?: int): Promise<void> {
+  let p: Promise<void> =
+    new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError | null) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -93,124 +95,154 @@ export function preloadApplication(bundleName: string, userId: int, mode: Preloa
         }
       });
       taskpool.execute((): void => {
-        appManager.nativePreloadApplication(myCall, bundleName, userId, mode, appIndex);
+        appManager.nativePreloadApplication(asyncCall, bundleName, userId, mode, appIndex);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
-    return p;
+  return p;
 }
 
 export native function nativeGetRunningProcessInformation(callback: AsyncCallbackWrapper<Array<ProcessInformation>>): void;
 export function getRunningProcessInformation(callback: AsyncCallback<Array<ProcessInformation>>): void {
-   let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
-    taskpool.execute((): void => {
-      appManager.nativeGetRunningProcessInformation(myCall);
-    });
+  let asyncCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
+  taskpool.execute((): void => {
+    appManager.nativeGetRunningProcessInformation(asyncCall);
+  }).catch((err: BusinessError): void => {
+    callback(err, undefined);
+  });
 }
 
 export function getRunningProcessInformation(): Promise<Array<ProcessInformation>> {
-    let p = new Promise<Array<ProcessInformation>>((resolve:(data:Array<ProcessInformation>)=>void, reject:(err: BusinessError)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null, data: Array<ProcessInformation> | undefined)=>{
-        if (err == null || err.code == 0) {
-          resolve(data as Array<ProcessInformation>);
-        } else {
-          reject(err);
-        }
-      });
-      taskpool.execute((): void => {
-        appManager.nativeGetRunningProcessInformation(myCall);
-      });
+  let p = new Promise<Array<ProcessInformation>>((resolve: (data: Array<ProcessInformation>) => void,
+    reject: (err: BusinessError) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null,
+      data: Array<ProcessInformation> | undefined) => {
+      if (err == null || err.code == 0) {
+        resolve(data as Array<ProcessInformation>);
+      } else {
+        reject(err);
+      }
     });
-    return p;
+    taskpool.execute((): void => {
+      appManager.nativeGetRunningProcessInformation(asyncCall);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
+    });
+  });
+  return p;
 }
 
 export native function nativeGetForegroundApplications(callback:AsyncCallbackWrapper<Array<AppStateData>>): void;
 export function getForegroundApplications(callback: AsyncCallback<Array<AppStateData>>): void {
-    let myCall = new AsyncCallbackWrapper<Array<AppStateData>>(callback);
-    taskpool.execute((): void => {
-      appManager.nativeGetForegroundApplications(myCall);
-    });
+  let asyncCall = new AsyncCallbackWrapper<Array<AppStateData>>(callback);
+  taskpool.execute((): void => {
+    appManager.nativeGetForegroundApplications(asyncCall);
+  }).catch((err: BusinessError): void => {
+    callback(err, undefined);
+  });
 }
 
 export function getForegroundApplications(): Promise<Array<AppStateData>> {
-    let p = new Promise<Array<AppStateData>>((resolve:(data:Array<AppStateData>)=>void, reject:(err: BusinessError)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<Array<AppStateData>>((err: BusinessError | null, data: Array<AppStateData> | undefined)=>{
-        if (err == null || err.code == 0) {
-          resolve(data as Array<AppStateData>);
-        } else {
-          reject(err);
-        }
-      });
-      taskpool.execute((): void => {
-        appManager.nativeGetForegroundApplications(myCall);
-      });
+  let p = new Promise<Array<AppStateData>>((resolve: (data: Array<AppStateData>) => void,
+    reject: (err: BusinessError) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<Array<AppStateData>>((err: BusinessError | null,
+      data: Array<AppStateData> | undefined) => {
+      if (err == null || err.code == 0) {
+        resolve(data as Array<AppStateData>);
+      } else {
+        reject(err);
+      }
+    });
+    taskpool.execute((): void => {
+      appManager.nativeGetForegroundApplications(asyncCall);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
     });
-    return p;
+  });
+  return p;
 }
 
 export native function nativeGetRunningMultiAppInfo(bundleName: string, callback: AsyncCallbackWrapper<RunningMultiAppInfo>): void;
 export function getRunningMultiAppInfo(bundleName: string): Promise<RunningMultiAppInfo> {
-    let p = new Promise<RunningMultiAppInfo>((resolve:(data: RunningMultiAppInfo)=>void, reject:(err: BusinessError)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<RunningMultiAppInfo>((err: BusinessError | null, data: RunningMultiAppInfo | undefined)=>{
-        if (err == null || err.code == 0) {
-          resolve(data as RunningMultiAppInfo);
-        } else {
-          reject(err);
-        }
-      });
-      taskpool.execute((): void => {
-        appManager.nativeGetRunningMultiAppInfo(bundleName, myCall);
-      });
+  let p = new Promise<RunningMultiAppInfo>((resolve: (data: RunningMultiAppInfo) => void,
+    reject: (err: BusinessError) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<RunningMultiAppInfo>((err: BusinessError | null,
+      data: RunningMultiAppInfo | undefined) => {
+      if (err == null || err.code == 0) {
+        resolve(data as RunningMultiAppInfo);
+      } else {
+        reject(err);
+      }
     });
-    return p;
+    taskpool.execute((): void => {
+      appManager.nativeGetRunningMultiAppInfo(bundleName, asyncCall);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
+    });
+  });
+  return p;
 }
 
 export native function nativeGetRunningProcessInfoByBundleName(bundleName: string, callback:AsyncCallbackWrapper<Array<ProcessInformation>>):void;
 export function getRunningProcessInfoByBundleName(bundleName: string, callback: AsyncCallback<Array<ProcessInformation>>): void  {
-    let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
-    taskpool.execute((): void => {
-      appManager.nativeGetRunningProcessInfoByBundleName(bundleName, myCall);
-    });
+  let asyncCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
+  taskpool.execute((): void => {
+    appManager.nativeGetRunningProcessInfoByBundleName(bundleName, asyncCall);
+  }).catch((err: BusinessError): void => {
+    callback(err, undefined);
+  });
 }
 
 export function getRunningProcessInfoByBundleName(bundleName: string): Promise<Array<ProcessInformation>> {
-    let p = new Promise<Array<ProcessInformation>>((resolve:(data: Array<ProcessInformation>)=>void, reject:(err: BusinessError)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null, data: Array<ProcessInformation> | undefined)=>{
-        if (err == null || err.code == 0) {
-          resolve(data as Array<ProcessInformation>);
-        } else {
-          reject(err);
-        }
-      });
-      taskpool.execute((): void => {
-        appManager.nativeGetRunningProcessInfoByBundleName(bundleName, myCall);
-      });
+  let p = new Promise<Array<ProcessInformation>>((resolve: (data: Array<ProcessInformation>) => void,
+    reject: (err: BusinessError) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null,
+      data: Array<ProcessInformation> | undefined) => {
+      if (err == null || err.code == 0) {
+        resolve(data as Array<ProcessInformation>);
+      } else {
+        reject(err);
+      }
     });
-    return p;
+    taskpool.execute((): void => {
+      appManager.nativeGetRunningProcessInfoByBundleName(bundleName, asyncCall);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
+    });
+  });
+  return p;
 }
 
 export native function nativeGetRunningProcessInfoByBundleNameAndUserId(bundleName: string,
-  userId: int, callback:AsyncCallbackWrapper<Array<ProcessInformation>>):void;
+  userId: int, callback: AsyncCallbackWrapper<Array<ProcessInformation>>): void;
 export function getRunningProcessInfoByBundleName(bundleName: string, userId: int, callback: AsyncCallback<Array<ProcessInformation>>): void {
-    let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
-    taskpool.execute((): void => {
-      appManager.nativeGetRunningProcessInfoByBundleNameAndUserId(bundleName, userId, myCall);
-    });
+  let asyncCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
+  taskpool.execute((): void => {
+    appManager.nativeGetRunningProcessInfoByBundleNameAndUserId(bundleName, userId, asyncCall);
+  }).catch((err: BusinessError): void => {
+    callback(err, undefined);
+  });
 }
 
 export function getRunningProcessInfoByBundleName(bundleName: string, userId: int): Promise<Array<ProcessInformation>> {
-    let p = new Promise<Array<ProcessInformation>>((resolve:(data: Array<ProcessInformation>)=>void, reject:(err: BusinessError)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null, data: Array<ProcessInformation> | undefined)=>{
-        if (err == null || err.code == 0) {
-          resolve(data as Array<ProcessInformation>);
-        } else {
-          reject(err);
-        }
-      });
-      taskpool.execute((): void => {
-        appManager.nativeGetRunningProcessInfoByBundleNameAndUserId(bundleName, userId, myCall);
-      });
+  let p = new Promise<Array<ProcessInformation>>((resolve: (data: Array<ProcessInformation>) => void,
+    reject: (err: BusinessError) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null,
+      data: Array<ProcessInformation> | undefined) => {
+      if (err == null || err.code == 0) {
+        resolve(data as Array<ProcessInformation>);
+      } else {
+        reject(err);
+      }
     });
-    return p;
+    taskpool.execute((): void => {
+      appManager.nativeGetRunningProcessInfoByBundleNameAndUserId(bundleName, userId, asyncCall);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
+    });
+  });
+  return p;
 }
 
 export native function nativeOn(type: string, observer: ApplicationStateObserver, bundleNameList?: Array<string>) : int;
@@ -226,15 +258,18 @@ export function on(type: 'applicationState', observer: ApplicationStateObserver,
 
 export native function nativeOff(type:string, observerId: int, callback: AsyncCallbackWrapper<void>) : void;
 export function off(type: 'applicationState', observerId: int, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
-    taskpool.execute((): void => {
-      appManager.nativeOff(type, observerId, myCall);
-    });
+  let asyncCall = new AsyncCallbackWrapper<void>(callback);
+  taskpool.execute((): void => {
+    appManager.nativeOff(type, observerId, asyncCall);
+  }).catch((err: BusinessError): void => {
+    callback(err, undefined);
+  });
 }
 
 export function off(type: 'applicationState', observerId: int): Promise<void> {
-    let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError | null)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null)=>{
+  let p: Promise<void> =
+    new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError | null) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -242,46 +277,56 @@ export function off(type: 'applicationState', observerId: int): Promise<void> {
         }
       });
       taskpool.execute((): void => {
-        appManager.nativeOff(type, observerId, myCall);
+        appManager.nativeOff(type, observerId, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
-    return p;
+  return p;
 }
 
 export native function nativeGetAppMemorySize(callback: AsyncCallbackWrapper<int>) : void;
 export function getAppMemorySize(callback: AsyncCallback<int>): void
 {
-    let myCall = new AsyncCallbackWrapper<int>(callback);
+    let asyncCall = new AsyncCallbackWrapper<int>(callback);
     taskpool.execute((): void => {
-      appManager.nativeGetAppMemorySize(myCall);
+      appManager.nativeGetAppMemorySize(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
 }
+
 export function getAppMemorySize(): Promise<int> {
-    let p = new Promise<int>((resolve:(data:int)=>void, reject:(err: BusinessError | null)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<int>((err: BusinessError | null, data: int | undefined)=>{
-        if (err == null || err.code == 0) {
-          resolve(data as int);
-        } else {
-          reject(err);
-        }
-      });
-      taskpool.execute((): void => {
-        appManager.nativeGetAppMemorySize(myCall);
-      });
+  let p = new Promise<int>((resolve: (data: int) => void, reject: (err: BusinessError | null) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<int>((err: BusinessError | null, data: int | undefined) => {
+      if (err == null || err.code == 0) {
+        resolve(data as int);
+      } else {
+        reject(err);
+      }
+    });
+    taskpool.execute((): void => {
+      appManager.nativeGetAppMemorySize(asyncCall);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
     });
-    return p;
+  });
+  return p;
 }
 
 export native function nativeIsRamConstrainedDevice(callback: AsyncCallbackWrapper<boolean>) : void;
 export function isRamConstrainedDevice(callback: AsyncCallback<boolean>): void {
-    let myCall = new AsyncCallbackWrapper<boolean>(callback);
-    taskpool.execute((): void => {
-      appManager.nativeIsRamConstrainedDevice(myCall);
-    });
+  let asyncCall = new AsyncCallbackWrapper<boolean>(callback);
+  taskpool.execute((): void => {
+    appManager.nativeIsRamConstrainedDevice(asyncCall);
+  }).catch((err: BusinessError): void => {
+    callback(err, undefined);
+  });
 }
 export function isRamConstrainedDevice(): Promise<boolean> {
-    let p = new Promise<boolean>((resolve:(data:boolean)=>void, reject:(err: BusinessError | null)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined)=>{
+  let p =
+    new Promise<boolean>((resolve: (data: boolean) => void, reject: (err: BusinessError | null) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined) => {
         if (err == null || err.code == 0) {
           resolve(data as boolean);
         } else {
@@ -289,22 +334,27 @@ export function isRamConstrainedDevice(): Promise<boolean> {
         }
       });
       taskpool.execute((): void => {
-        appManager.nativeIsRamConstrainedDevice(myCall);
+        appManager.nativeIsRamConstrainedDevice(asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
-    return p;
+  return p;
 }
 
-export native function nativeIsRunningInStabilityTest(callback: AsyncCallbackWrapper<boolean>) : void;
+export native function nativeIsRunningInStabilityTest(callback: AsyncCallbackWrapper<boolean>): void;
 export function isRunningInStabilityTest(callback: AsyncCallback<boolean>): void {
-    let myCall = new AsyncCallbackWrapper<boolean>(callback);
-    taskpool.execute((): void => {
-      appManager.nativeIsRunningInStabilityTest(myCall);
-    });
+  let asyncCall = new AsyncCallbackWrapper<boolean>(callback);
+  taskpool.execute((): void => {
+    appManager.nativeIsRunningInStabilityTest(asyncCall);
+  }).catch((err: BusinessError): void => {
+    callback(err, undefined);
+  });
 }
 export function isRunningInStabilityTest(): Promise<boolean> {
-    let p = new Promise<boolean>((resolve:(data:boolean)=>void, reject:(err: BusinessError | null)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined)=>{
+  let p =
+    new Promise<boolean>((resolve: (data: boolean) => void, reject: (err: BusinessError | null) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined) => {
         if (err == null || err.code == 0) {
           resolve(data as boolean);
         } else {
@@ -312,23 +362,28 @@ export function isRunningInStabilityTest(): Promise<boolean> {
         }
       });
       taskpool.execute((): void => {
-        appManager.nativeIsRunningInStabilityTest(myCall);
+        appManager.nativeIsRunningInStabilityTest(asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
-    return p;
+  return p;
 }
 
 export native function nativeKillProcessesByBundleNameSync(bundleName: string, callback: AsyncCallbackWrapper<void>) : void;
 export native function nativeKillProcessesByBundleName(callback: AsyncCallbackWrapper<void>, bundleName: string, clearPageStack: boolean, appIndex?: int) : void;
 export function killProcessesByBundleName(bundleName: string, callback: AsyncCallback<void>) : void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
-    taskpool.execute((): void => {
-      appManager.nativeKillProcessesByBundleNameSync(bundleName, myCall);
-    });
+  let asyncCall = new AsyncCallbackWrapper<void>(callback);
+  taskpool.execute((): void => {
+    appManager.nativeKillProcessesByBundleNameSync(bundleName, asyncCall);
+  }).catch((err: BusinessError): void => {
+    callback(err, undefined);
+  });
 }
 export function killProcessesByBundleName(bundleName: string): Promise<void> {
-    let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError | null)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null)=>{
+  let p: Promise<void> =
+    new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError | null) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -336,14 +391,18 @@ export function killProcessesByBundleName(bundleName: string): Promise<void> {
         }
       });
       taskpool.execute((): void => {
-        appManager.nativeKillProcessesByBundleNameSync(bundleName, myCall);
+        appManager.nativeKillProcessesByBundleNameSync(bundleName, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
-    return p;
+  return p;
 }
-export function killProcessesByBundleName(bundleName: string, clearPageStack: boolean, appIndex?: int): Promise<void> {
-    let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError | null)=>void):void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null)=>{
+export function killProcessesByBundleName(bundleName: string, clearPageStack: boolean,
+  appIndex?: int): Promise<void> {
+  let p: Promise<void> =
+    new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError | null) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -351,10 +410,12 @@ export function killProcessesByBundleName(bundleName: string, clearPageStack: bo
         }
       });
       taskpool.execute((): void => {
-        appManager.nativeKillProcessesByBundleName(myCall, bundleName, clearPageStack, appIndex);
+        appManager.nativeKillProcessesByBundleName(asyncCall, bundleName, clearPageStack, appIndex);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
-    return p;
+  return p;
 }
 
 export native function nativeOnAbilityFirstFrameState(type: string, observer: AbilityFirstFrameStateObserver, bundleName?: string) : void;
@@ -379,56 +440,66 @@ export function off(type: 'appForegroundState', observer?: AppForegroundStateObs
 
 export native function nativeKillProcessWithAccountSync(bundleName: string, accountId: int, callback: AsyncCallbackWrapper<void>) : void;
 export function killProcessWithAccount(bundleName: string, accountId: int, callback: AsyncCallback<void>): void {
-  let myCall = new AsyncCallbackWrapper<void>(callback);
+  let asyncCall = new AsyncCallbackWrapper<void>(callback);
   taskpool.execute((): void => {
-    appManager.nativeKillProcessWithAccountSync(bundleName, accountId, myCall);
+    appManager.nativeKillProcessWithAccountSync(bundleName, accountId, asyncCall);
+  }).catch((err: BusinessError): void => {
+    callback(err, undefined);
   });
 }
 export function killProcessWithAccount(bundleName: string, accountId: int): Promise<void> {
-  let p:Promise<void> = 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.nativeKillProcessWithAccountSync(bundleName, accountId, myCall);
+  let p: Promise<void> =
+    new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        if (err == null || err.code == 0) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
+      });
+      taskpool.execute((): void => {
+        appManager.nativeKillProcessWithAccountSync(bundleName, accountId, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
+      });
     });
-  });
   return p;
 }
 export native function nativeKillProcessWithAccount(callback: AsyncCallbackWrapper<void>,
   bundleName: string, accountId: int, clearPageStack: boolean, appIndex?: int) : void;
 export function killProcessWithAccount(bundleName: string, accountId: int,
-  clearPageStack: boolean, appIndex?: int): Promise<void>
-{
-  let p:Promise<void> = 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.nativeKillProcessWithAccount(myCall, bundleName, accountId, clearPageStack, appIndex);
+  clearPageStack: boolean, appIndex?: int): Promise<void> {
+  let p: Promise<void> =
+    new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        if (err == null || err.code == 0) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
+      });
+      taskpool.execute((): void => {
+        appManager.nativeKillProcessWithAccount(asyncCall, bundleName, accountId, clearPageStack, appIndex);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
+      });
     });
-  });
   return p;
 }
 
 export native function nativeGetProcessMemoryByPid(pid: int, callback: AsyncCallbackWrapper<int>) : void;
-export function getProcessMemoryByPid(pid: int, callback: AsyncCallback<int>): void {
-  let myCall = new AsyncCallbackWrapper<int>(callback);
-  taskpool.execute((): void => {
-    appManager.nativeGetProcessMemoryByPid(pid, myCall);
-  });
-}
+  export function getProcessMemoryByPid(pid: int, callback: AsyncCallback<int>): void {
+    let asyncCall = new AsyncCallbackWrapper<int>(callback);
+    taskpool.execute((): void => {
+      appManager.nativeGetProcessMemoryByPid(pid, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
+    });
+  }
+
 export function getProcessMemoryByPid(pid: int): Promise<int> {
-  let p = new Promise<int>((resolve:(data:int)=>void, reject:(err: BusinessError)=>void):void => {
-    let myCall = new AsyncCallbackWrapper<int>((err: BusinessError | null, data: int | undefined)=>{
+  let p = new Promise<int>((resolve: (data: int) => void, reject: (err: BusinessError) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<int>((err: BusinessError | null, data: int | undefined) => {
       if (err == null || err.code == 0) {
         resolve(data as int);
       } else {
@@ -436,7 +507,9 @@ export function getProcessMemoryByPid(pid: int): Promise<int> {
       }
     });
     taskpool.execute((): void => {
-      appManager.nativeGetProcessMemoryByPid(pid, myCall);
+      appManager.nativeGetProcessMemoryByPid(pid, asyncCall);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
     });
   });
   return p;
@@ -444,10 +517,12 @@ export function getProcessMemoryByPid(pid: int): Promise<int> {
 
 export native function nativeGetRunningProcessInformationByBundleType(bundleType: bundleManager.BundleType,
   callback: AsyncCallbackWrapper<Array<ProcessInformation>>) : void;
-export function getRunningProcessInformationByBundleType(bundleType: bundleManager.BundleType): Promise<Array<ProcessInformation>>
+export function getRunningProcessInformationByBundleType(bundleType: bundleManager.BundleType): Promise<Array<ProcessInformation>> 
 {
-  let p = new Promise<Array<ProcessInformation>>((resolve:(data:Array<ProcessInformation>)=>void, reject:(err: BusinessError)=>void):void => {
-    let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null, data: Array<ProcessInformation> | undefined)=>{
+  let p = new Promise<Array<ProcessInformation>>((resolve: (data: Array<ProcessInformation>) => void,
+    reject: (err: BusinessError) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null,
+      data: Array<ProcessInformation> | undefined) => {
       if (err == null || err.code == 0) {
         resolve(data as Array<ProcessInformation>);
       } else {
@@ -455,22 +530,26 @@ export function getRunningProcessInformationByBundleType(bundleType: bundleManag
       }
     });
     taskpool.execute((): void => {
-      appManager.nativeGetRunningProcessInformationByBundleType(bundleType, myCall);
+      appManager.nativeGetRunningProcessInformationByBundleType(bundleType, asyncCall);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
     });
   });
   return p;
 }
 
 export native function nativeIsSharedBundleRunning(bundleName: string, versionCode: long, callback: AsyncCallbackWrapper<boolean>) : void;
-export function isSharedBundleRunning(bundleName: string, versionCode: long, callback: AsyncCallback<boolean>): void {
-  let myCall = new AsyncCallbackWrapper<boolean>(callback);
-  taskpool.execute((): void => {
-    appManager.nativeIsSharedBundleRunning(bundleName, versionCode, myCall);
-  });
-}
+  export function isSharedBundleRunning(bundleName: string, versionCode: long, callback: AsyncCallback<boolean>): void {
+    let asyncCall = new AsyncCallbackWrapper<boolean>(callback);
+    taskpool.execute((): void => {
+      appManager.nativeIsSharedBundleRunning(bundleName, versionCode, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
+    });
+  }
 export function isSharedBundleRunning(bundleName: string, versionCode: long): 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)=>{
+  let p = new Promise<boolean>((resolve: (data: boolean) => void, reject: (err: BusinessError) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined) => {
       if (err == null || err.code == 0) {
         resolve(data as boolean);
       } else {
@@ -478,7 +557,9 @@ export function isSharedBundleRunning(bundleName: string, versionCode: long): Pr
       }
     });
     taskpool.execute((): void => {
-      appManager.nativeIsSharedBundleRunning(bundleName, versionCode, myCall);
+      appManager.nativeIsSharedBundleRunning(bundleName, versionCode, asyncCall);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
     });
   });
   return p;
@@ -486,42 +567,49 @@ export function isSharedBundleRunning(bundleName: string, versionCode: long): Pr
 
 export native function nativeGetSupportedProcessCachePids(bundleName: string, callback: AsyncCallbackWrapper<Array<int>>) : void;
 export function getSupportedProcessCachePids(bundleName: string): Promise<Array<int>> {
-  let p = new Promise<Array<int>>((resolve:(data:Array<int>)=>void, reject:(err: BusinessError)=>void):void => {
-    let myCall = new AsyncCallbackWrapper<Array<int>>((err: BusinessError | null, data: Array<int> | undefined)=>{
-      if (err == null || err.code == 0) {
-        resolve(data as Array<int>);
-      } else {
-        reject(err);
-      }
-    });
-    taskpool.execute((): void => {
-      appManager.nativeGetSupportedProcessCachePids(bundleName, myCall);
+  let p =
+    new Promise<Array<int>>((resolve: (data: Array<int>) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall =
+        new AsyncCallbackWrapper<Array<int>>((err: BusinessError | null, data: Array<int> | undefined) => {
+          if (err == null || err.code == 0) {
+            resolve(data as Array<int>);
+          } else {
+            reject(err);
+          }
+        });
+      taskpool.execute((): void => {
+        appManager.nativeGetSupportedProcessCachePids(bundleName, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
+      });
     });
-  });
   return p;
 }
 
-export native function nativeKillProcessesInBatch(pids: Array<int>, callback: AsyncCallbackWrapper<void>) : void;
-export function killProcessesInBatch(pids: Array<int>) : Promise<void> {
-  let p:Promise<void> = 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.nativeKillProcessesInBatch(pids, myCall);
+export native function nativeKillProcessesInBatch(pids: Array<int>, callback: AsyncCallbackWrapper<void>): void;
+export function killProcessesInBatch(pids: Array<int>): Promise<void> {
+  let p: Promise<void> =
+    new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        if (err == null || err.code == 0) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
+      });
+      taskpool.execute((): void => {
+        appManager.nativeKillProcessesInBatch(pids, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
+      });
     });
-  });
   return p;
 }
 
-export native function nativeIsAppRunning(callback: AsyncCallbackWrapper<boolean>, bundleName: string, appCloneIndex?: int) : void;
+export native function nativeIsAppRunning(callback: AsyncCallbackWrapper<boolean>, bundleName: string, appCloneIndex?: int): void;
 export function isAppRunning(bundleName: string, appCloneIndex?: int): 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)=>{
+  let p = new Promise<boolean>((resolve: (data: boolean) => void, reject: (err: BusinessError) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<boolean>((err: BusinessError | null, data: boolean | undefined) => {
       if (err == null || err.code == 0) {
         resolve(data as boolean);
       } else {
@@ -529,35 +617,42 @@ export function isAppRunning(bundleName: string, appCloneIndex?: int): Promise<b
       }
     });
     taskpool.execute((): void => {
-      appManager.nativeIsAppRunning(myCall, bundleName, appCloneIndex);
+      appManager.nativeIsAppRunning(asyncCall, bundleName, appCloneIndex);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
     });
   });
   return p;
 }
 
 export native function nativeSetKeepAliveForBundle(bundleName: string,
-  userId: int, enable: boolean, callback: AsyncCallbackWrapper<void>) : void;
+  userId: int, enable: boolean, callback: AsyncCallbackWrapper<void>): void;
 export function setKeepAliveForBundle(bundleName: string, userId: int, enable: boolean): Promise<void> {
-  let p:Promise<void> = 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.nativeSetKeepAliveForBundle(bundleName, userId, enable, myCall);
+  let p: Promise<void> =
+    new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        if (err == null || err.code == 0) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
+      });
+      taskpool.execute((): void => {
+        appManager.nativeSetKeepAliveForBundle(bundleName, userId, enable, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
+      });
     });
-  });
   return p;
 }
 
 export native function nativeGetKeepAliveBundles(callback: AsyncCallbackWrapper<Array<KeepAliveBundleInfo>>,
-  type: KeepAliveAppType, userId?: int) : void;
+  type: KeepAliveAppType, userId?: int): void;
 export function getKeepAliveBundles(type: KeepAliveAppType, userId?: int): 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)=>{
+  let p = new Promise<Array<KeepAliveBundleInfo>>((resolve: (data: Array<KeepAliveBundleInfo>) => void,
+    reject: (err: BusinessError) => void): void => {
+    let asyncCall = new AsyncCallbackWrapper<Array<KeepAliveBundleInfo>>((err: BusinessError | null,
+      data: Array<KeepAliveBundleInfo> | undefined) => {
       if (err == null || err.code == 0) {
         resolve(data as Array<KeepAliveBundleInfo>);
       } else {
@@ -565,7 +660,9 @@ export function getKeepAliveBundles(type: KeepAliveAppType, userId?: int): Promi
       }
     });
     taskpool.execute((): void => {
-      appManager.nativeGetKeepAliveBundles(myCall, type, userId);
+      appManager.nativeGetKeepAliveBundles(asyncCall, type, userId);
+    }).catch((err: Error): void => {
+      reject(err as BusinessError);
     });
   });
   return p;
diff --git a/frameworks/ets/ets/@ohos.app.ability.application.ets b/frameworks/ets/ets/@ohos.app.ability.application.ets
index 91f63543512..031ac1e06dd 100644
--- a/frameworks/ets/ets/@ohos.app.ability.application.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.application.ets
@@ -34,7 +34,7 @@ export default namespace application {
   export function createModuleContext(context: Context, moduleName: string): Promise<Context> {
     let p =
       new Promise<Context>((resolve: (data: Context) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<Context>((err: BusinessError | null, data: Context | undefined) => {
+        let asyncCall = new AsyncCallbackWrapper<Context>((err: BusinessError | null, data: Context | undefined) => {
           if (err == null || err.code == 0) {
             resolve(data as Context);
           } else {
@@ -42,7 +42,9 @@ export default namespace application {
           }
         });
         taskpool.execute((): void => {
-          application.nativeCreateModuleContext(context, "", moduleName, myCall);
+          application.nativeCreateModuleContext(context, "", moduleName, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
@@ -51,7 +53,7 @@ export default namespace application {
   export function createModuleContext(context: Context, bundleName: string, moduleName: string): Promise<Context> {
     let p =
       new Promise<Context>((resolve: (data: Context) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<Context>((err: BusinessError | null, data: Context | undefined) => {
+        let asyncCall = new AsyncCallbackWrapper<Context>((err: BusinessError | null, data: Context | undefined) => {
           if (err == null || err.code == 0) {
             resolve(data as Context);
           } else {
@@ -59,7 +61,9 @@ export default namespace application {
           }
         });
         taskpool.execute((): void => {
-          application.nativeCreateModuleContext(context, bundleName, moduleName, myCall);
+          application.nativeCreateModuleContext(context, bundleName, moduleName, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
@@ -68,7 +72,7 @@ export default namespace application {
   export function createBundleContext(context: Context, bundleName: string): Promise<Context> {
     let p =
       new Promise<Context>((resolve: (data: Context) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<Context>((err: BusinessError | null, data: Context | undefined) => {
+        let asyncCall = new AsyncCallbackWrapper<Context>((err: BusinessError | null, data: Context | undefined) => {
           if (err == null || err.code == 0) {
             resolve(data as Context);
           } else {
@@ -76,17 +80,19 @@ export default namespace application {
           }
         });
         taskpool.execute((): void => {
-          application.nativeCreateBundleContext(context, bundleName, myCall);
+          application.nativeCreateBundleContext(context, bundleName, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
-    export function createPluginModuleContext(context: Context, pluginBundleName: string,
+  export function createPluginModuleContext(context: Context, pluginBundleName: string,
     pluginModuleName: string): Promise<Context> {
     let p =
       new Promise<Context>((resolve: (data: Context) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<Context>((err: BusinessError | null, data: Context | undefined) => {
+        let asyncCall = new AsyncCallbackWrapper<Context>((err: BusinessError | null, data: Context | undefined) => {
           if (err == null || err.code == 0) {
             resolve(data as Context);
           } else {
@@ -94,7 +100,9 @@ export default namespace application {
           }
         });
         taskpool.execute((): void => {
-          application.nativeCreatePluginModuleContext(context, pluginBundleName, pluginModuleName, myCall);
+          application.nativeCreatePluginModuleContext(context, pluginBundleName, pluginModuleName, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
diff --git a/frameworks/ets/ets/@ohos.app.ability.insightIntentDriver.ets b/frameworks/ets/ets/@ohos.app.ability.insightIntentDriver.ets
index 20c9bcfe130..11970755fbd 100644
--- a/frameworks/ets/ets/@ohos.app.ability.insightIntentDriver.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.insightIntentDriver.ets
@@ -43,6 +43,8 @@ export default namespace insightIntentDriver {
     let pCallback = new AsyncCallbackWrapper<insightIntent.ExecuteResult>(callback);
     taskpool.execute((): void => {
       nativeExecuteSync(param, pCallback, true);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
@@ -60,6 +62,8 @@ export default namespace insightIntentDriver {
       });
       taskpool.execute((): void => {
         nativeExecuteSync(param, pCallback, false);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
     return pPromise;
diff --git a/frameworks/ets/ets/@ohos.app.ability.missionManager.ets b/frameworks/ets/ets/@ohos.app.ability.missionManager.ets
index ad2ec9c8f72..8c2dc751553 100644
--- a/frameworks/ets/ets/@ohos.app.ability.missionManager.ets
+++ b/frameworks/ets/ets/@ohos.app.ability.missionManager.ets
@@ -23,16 +23,18 @@ export default namespace missionManager {
     callback: AsyncCallbackWrapper<MissionInfo>): void;
 
   export function clearAllMissions(callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      missionManager.nativeClearAllMissions(myCall);
+      missionManager.nativeClearAllMissions(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   export function clearAllMissions(): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError | null) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -40,31 +42,38 @@ export default namespace missionManager {
           }
         });
         taskpool.execute((): void => {
-          missionManager.nativeClearAllMissions(myCall);
+          missionManager.nativeClearAllMissions(asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
   export function getMissionInfo(deviceId: string, missionId: int, callback: AsyncCallback<MissionInfo>): void {
-    let myCall = new AsyncCallbackWrapper<MissionInfo>(callback);
+    let asyncCall = new AsyncCallbackWrapper<MissionInfo>(callback);
     taskpool.execute((): void => {
-      missionManager.nativeGetMissionInfo(deviceId, missionId, myCall);
+      missionManager.nativeGetMissionInfo(deviceId, missionId, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   export function getMissionInfo(deviceId: string, missionId: int): Promise<MissionInfo> {
     let p =
       new Promise<MissionInfo>((resolve: (data: MissionInfo) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<MissionInfo>((err: BusinessError | null, data: MissionInfo | undefined) => {
-          if (err == null || err.code == 0) {
-            resolve(data as MissionInfo);
-          } else {
-            reject(err);
-          }
-        });
+        let asyncCall =
+          new AsyncCallbackWrapper<MissionInfo>((err: BusinessError | null, data: MissionInfo | undefined) => {
+            if (err == null || err.code == 0) {
+              resolve(data as MissionInfo);
+            } else {
+              reject(err);
+            }
+          });
         taskpool.execute((): void => {
-          missionManager.nativeGetMissionInfo(deviceId, missionId, myCall);
+          missionManager.nativeGetMissionInfo(deviceId, missionId, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
diff --git a/frameworks/ets/ets/@ohos.application.uriPermissionManager.ets b/frameworks/ets/ets/@ohos.application.uriPermissionManager.ets
index 93bdc519cb1..d8c2e69b1c0 100644
--- a/frameworks/ets/ets/@ohos.application.uriPermissionManager.ets
+++ b/frameworks/ets/ets/@ohos.application.uriPermissionManager.ets
@@ -25,92 +25,109 @@ export default namespace uriPermissionManager {
     export native function revokeUriPermissionCallbackSync(uri: string, targetBundleName: string, appCloneIndex: int,
         callback: AsyncCallbackWrapper<number>): void;
 
-    export function grantUriPermission(uri: string, flag: wantConstant.Flags, targetBundleName: string): Promise<number> {
-        let p:Promise<number> = new Promise<number>((resolve: (data: number)=>void, reject:(err: BusinessError)=>void):void => {
-            let myCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined)=>{
-                if (err === null || err.code === 0) {
-                    if (data === undefined) {
-                        resolve(-1);
-                    } else {
-                        resolve(data);
-                    }
-                } else {
-                    reject(err);
-                }
-            });
-            taskpool.execute((): void => {
-                uriPermissionManager.grantUriPermissionCallbackSync(uri, flag, targetBundleName, 0, myCall);
-            });
+  export function grantUriPermission(uri: string, flag: wantConstant.Flags, targetBundleName: string): Promise<number> {
+    let p: Promise<number> =
+      new Promise<number>((resolve: (data: number) => void, reject: (err: BusinessError) => void): void => {
+        let asyncCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined) => {
+          if (err === null || err.code === 0) {
+            if (data === undefined) {
+              resolve(-1);
+            } else {
+              resolve(data);
+            }
+          } else {
+            reject(err);
+          }
         });
-        return p;
-    }
-
-    export function grantUriPermission(uri: string, flag: wantConstant.Flags, targetBundleName: string,
-        appCloneIndex: int): Promise<void> {
-        let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError)=>void):void => {
-            let myCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined)=>{
-                if (err === null || err.code === 0) {
-                    resolve(undefined);
-                } else {
-                    reject(err);
-                }
-            });
-            taskpool.execute((): void => {
-                uriPermissionManager.grantUriPermissionCallbackSync(uri,
-                    flag, targetBundleName, appCloneIndex, myCall);
-            });
+        taskpool.execute((): void => {
+          uriPermissionManager.grantUriPermissionCallbackSync(uri, flag, targetBundleName, 0, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
-        return p;
-    }
+      });
+    return p;
+  }
 
-    export function grantUriPermission(uri: string, flag: wantConstant.Flags, targetBundleName: string,
-        callback: AsyncCallback<number, void>): void {
-        let myCall = new AsyncCallbackWrapper<number>(callback);
+  export function grantUriPermission(uri: string, flag: wantConstant.Flags, targetBundleName: string,
+    appCloneIndex: int): Promise<void> {
+    let p: Promise<void> =
+      new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+        let asyncCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined) => {
+          if (err === null || err.code === 0) {
+            resolve(undefined);
+          } else {
+            reject(err);
+          }
+        });
         taskpool.execute((): void => {
-            uriPermissionManager.grantUriPermissionCallbackSync(uri, flag, targetBundleName, 0, myCall);
-        })
-    }
-
-    export function revokeUriPermission(uri: string, targetBundleName: string): Promise<number> {
-        let p:Promise<number> = new Promise<number>((resolve: (data: number)=>void, reject:(err: BusinessError)=>void):void => {
-            let myCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined)=>{
-                if (err === null || err.code === 0) {
-                    if (data === undefined) {
-                        resolve(-1);
-                    } else {
-                        resolve(data);
-                    }
-                } else {
-                    reject(err);
-                }
-            });
-            taskpool.execute((): void => {
-                uriPermissionManager.revokeUriPermissionCallbackSync(uri, targetBundleName, 0, myCall);
-            });
+          uriPermissionManager.grantUriPermissionCallbackSync(uri,
+            flag, targetBundleName, appCloneIndex, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
-        return p;
-    }
+      });
+    return p;
+  }
+
+  export function grantUriPermission(uri: string, flag: wantConstant.Flags, targetBundleName: string,
+    callback: AsyncCallback<number, void>): void {
+    let asyncCall = new AsyncCallbackWrapper<number>(callback);
+    taskpool.execute((): void => {
+      uriPermissionManager.grantUriPermissionCallbackSync(uri, flag, targetBundleName, 0, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
+    });
+  }
 
-    export function revokeUriPermission(uri: string, targetBundleName: string, appCloneIndex: int): Promise<void> {
-        let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject:(err: BusinessError)=>void):void => {
-            let myCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined)=>{
-                if (err === null || err.code === 0) {
-                    resolve(undefined);
-                } else {
-                    reject(err);
-                }
-            });
-            taskpool.execute((): void => {
-                uriPermissionManager.revokeUriPermissionCallbackSync(uri, targetBundleName, appCloneIndex, myCall);
-            });
+  export function revokeUriPermission(uri: string, targetBundleName: string): Promise<number> {
+    let p: Promise<number> =
+      new Promise<number>((resolve: (data: number) => void, reject: (err: BusinessError) => void): void => {
+        let asyncCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined) => {
+          if (err === null || err.code === 0) {
+            if (data === undefined) {
+              resolve(-1);
+            } else {
+              resolve(data);
+            }
+          } else {
+            reject(err);
+          }
         });
-        return p;
-    }
+        taskpool.execute((): void => {
+          uriPermissionManager.revokeUriPermissionCallbackSync(uri, targetBundleName, 0, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
+        });
+      });
+    return p;
+  }
 
-    export function revokeUriPermission(uri: string, targetBundleName: string, callback: AsyncCallback<number, void>): void {
-        let myCall = new AsyncCallbackWrapper<number>(callback);
+  export function revokeUriPermission(uri: string, targetBundleName: string, appCloneIndex: int): Promise<void> {
+    let p: Promise<void> =
+      new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+        let asyncCall = new AsyncCallbackWrapper<number>((err: BusinessError | null, data: number | undefined) => {
+          if (err === null || err.code === 0) {
+            resolve(undefined);
+          } else {
+            reject(err);
+          }
+        });
         taskpool.execute((): void => {
-            uriPermissionManager.revokeUriPermissionCallbackSync(uri, targetBundleName, 0, myCall);
-        })
-    }
-}
\ No newline at end of file
+          uriPermissionManager.revokeUriPermissionCallbackSync(uri, targetBundleName, appCloneIndex, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
+        });
+      });
+    return p;
+  }
+
+  export function revokeUriPermission(uri: string, targetBundleName: string,
+    callback: AsyncCallback<number, void>): void {
+    let asyncCall = new AsyncCallbackWrapper<number>(callback);
+    taskpool.execute((): void => {
+      uriPermissionManager.revokeUriPermissionCallbackSync(uri, targetBundleName, 0, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
+    });
+  }
+}
diff --git a/frameworks/ets/ets/application/AbilityDelegator.ets b/frameworks/ets/ets/application/AbilityDelegator.ets
index fec39c5bcea..e586f25fcc6 100644
--- a/frameworks/ets/ets/application/AbilityDelegator.ets
+++ b/frameworks/ets/ets/application/AbilityDelegator.ets
@@ -147,15 +147,17 @@ class AbilityDelegatorInner implements AbilityDelegator {
   public native nativeStartAbility(want: Want, callback: AsyncCallbackWrapper<void>): void;
 
   finishTest(msg: string, code: long, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeFinishTest(msg, code, myCall);
+      this.nativeFinishTest(msg, code, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   finishTest(msg: string, code: long): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -163,7 +165,9 @@ class AbilityDelegatorInner implements AbilityDelegator {
           }
         });
         taskpool.execute((): void => {
-          this.nativeFinishTest(msg, code, myCall);
+          this.nativeFinishTest(msg, code, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
@@ -171,21 +175,25 @@ class AbilityDelegatorInner implements AbilityDelegator {
 
   executeShellCommand(cmd: string, callback: AsyncCallback<ShellCmdResult, void>): void {
     let timeoutSecs = 0;
-    let myCall = new AsyncCallbackWrapper<ShellCmdResult>(callback);
+    let asyncCall = new AsyncCallbackWrapper<ShellCmdResult>(callback);
     taskpool.execute((): void => {
-      this.nativeExecuteShellCommand(cmd, timeoutSecs, myCall);
+      this.nativeExecuteShellCommand(cmd, timeoutSecs, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   executeShellCommand(cmd: string, timeoutSecs: long, callback: AsyncCallback<ShellCmdResult, void>): void {
-    let myCall = new AsyncCallbackWrapper<ShellCmdResult>(callback);
+    let asyncCall = new AsyncCallbackWrapper<ShellCmdResult>(callback);
     taskpool.execute((): void => {
-      this.nativeExecuteShellCommand(cmd, timeoutSecs, myCall);
+      this.nativeExecuteShellCommand(cmd, timeoutSecs, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   executeShellCommand(cmd: string, timeoutSecs?: long): Promise<ShellCmdResult> {
     let p = new Promise<ShellCmdResult>((resolve: (data: ShellCmdResult) => void,
       reject: (err: BusinessError) => void): void => {
-      let myCall =
+      let asyncCall =
         new AsyncCallbackWrapper<ShellCmdResult>((err: BusinessError | null, data: ShellCmdResult | undefined) => {
           if (err == null || err.code == 0) {
             resolve(data as ShellCmdResult);
@@ -195,25 +203,29 @@ class AbilityDelegatorInner implements AbilityDelegator {
         });
       taskpool.execute((): void => {
         if (timeoutSecs == null) {
-          this.nativeExecuteShellCommand(cmd, 0, myCall);
+          this.nativeExecuteShellCommand(cmd, 0, asyncCall);
         } else {
-          this.nativeExecuteShellCommand(cmd, timeoutSecs as long, myCall);
+          this.nativeExecuteShellCommand(cmd, timeoutSecs as long, asyncCall);
         }
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
     return p;
   }
 
   addAbilityMonitor(monitor: AbilityMonitor, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeAddAbilityMonitor(monitor, myCall);
+      this.nativeAddAbilityMonitor(monitor, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   addAbilityMonitor(monitor: AbilityMonitor): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -221,22 +233,26 @@ class AbilityDelegatorInner implements AbilityDelegator {
           }
         });
         taskpool.execute((): void => {
-          this.nativeAddAbilityMonitor(monitor, myCall);
+          this.nativeAddAbilityMonitor(monitor, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
   removeAbilityMonitor(monitor: AbilityMonitor, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.removeAbilityMonitorAsync(monitor, myCall);
+      this.removeAbilityMonitorAsync(monitor, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   removeAbilityMonitor(monitor: AbilityMonitor): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -244,7 +260,9 @@ class AbilityDelegatorInner implements AbilityDelegator {
           }
         });
         taskpool.execute((): void => {
-          this.removeAbilityMonitorAsync(monitor, myCall);
+          this.removeAbilityMonitorAsync(monitor, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
@@ -252,21 +270,25 @@ class AbilityDelegatorInner implements AbilityDelegator {
 
   waitAbilityMonitor(monitor: AbilityMonitor, callback: AsyncCallback<UIAbility, void>): void {
     let timeout = -1;
-    let myCall = new AsyncCallbackWrapper<UIAbility>(callback);
+    let asyncCall = new AsyncCallbackWrapper<UIAbility>(callback);
     taskpool.execute((): void => {
-      this.waitAbilityMonitorAsync(monitor, timeout, myCall);
+      this.waitAbilityMonitorAsync(monitor, timeout, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   waitAbilityMonitor(monitor: AbilityMonitor, timeout: long, callback: AsyncCallback<UIAbility, void>): void {
-    let myCall = new AsyncCallbackWrapper<UIAbility>(callback);
+    let asyncCall = new AsyncCallbackWrapper<UIAbility>(callback);
     taskpool.execute((): void => {
-      this.waitAbilityMonitorAsync(monitor, timeout, myCall);
+      this.waitAbilityMonitorAsync(monitor, timeout, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   waitAbilityMonitor(monitor: AbilityMonitor, timeout?: long): Promise<UIAbility> {
     let p = new Promise<UIAbility>((resolve: (data: UIAbility) => void,
       reject: (err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<UIAbility>((err: BusinessError | null, data: UIAbility | undefined) => {
+      let asyncCall = new AsyncCallbackWrapper<UIAbility>((err: BusinessError | null, data: UIAbility | undefined) => {
         if (err == null || err.code == 0) {
           resolve(data as UIAbility);
         } else {
@@ -275,25 +297,29 @@ class AbilityDelegatorInner implements AbilityDelegator {
       });
       taskpool.execute((): void => {
         if (timeout == null) {
-          this.waitAbilityMonitorAsync(monitor, -1, myCall);
+          this.waitAbilityMonitorAsync(monitor, -1, asyncCall);
         } else {
-          this.waitAbilityMonitorAsync(monitor, timeout as long, myCall);
+          this.waitAbilityMonitorAsync(monitor, timeout as long, asyncCall);
         }
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
     return p;
   }
 
   addAbilityStageMonitor(monitor: AbilityStageMonitor, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.addAbilityStageMonitorAsync(monitor, myCall);
+      this.addAbilityStageMonitorAsync(monitor, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   addAbilityStageMonitor(monitor: AbilityStageMonitor): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -301,22 +327,26 @@ class AbilityDelegatorInner implements AbilityDelegator {
           }
         });
         taskpool.execute((): void => {
-          this.addAbilityStageMonitorAsync(monitor, myCall);
+          this.addAbilityStageMonitorAsync(monitor, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
   removeAbilityStageMonitor(monitor: AbilityStageMonitor, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.removeAbilityStageMonitorAsync(monitor, myCall);
+      this.removeAbilityStageMonitorAsync(monitor, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   removeAbilityStageMonitor(monitor: AbilityStageMonitor): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -324,7 +354,9 @@ class AbilityDelegatorInner implements AbilityDelegator {
           }
         });
         taskpool.execute((): void => {
-          this.removeAbilityStageMonitorAsync(monitor, myCall);
+          this.removeAbilityStageMonitorAsync(monitor, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
@@ -332,22 +364,26 @@ class AbilityDelegatorInner implements AbilityDelegator {
 
   waitAbilityStageMonitor(monitor: AbilityStageMonitor, callback: AsyncCallback<AbilityStage, void>): void {
     let timeout = -1;
-    let myCall = new AsyncCallbackWrapper<AbilityStage>(callback);
+    let asyncCall = new AsyncCallbackWrapper<AbilityStage>(callback);
     taskpool.execute((): void => {
-      this.waitAbilityStageMonitorAsync(monitor, timeout, myCall);
+      this.waitAbilityStageMonitorAsync(monitor, timeout, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   waitAbilityStageMonitor(monitor: AbilityStageMonitor, timeout: long,
     callback: AsyncCallback<AbilityStage, void>): void {
-    let myCall = new AsyncCallbackWrapper<AbilityStage>(callback);
+    let asyncCall = new AsyncCallbackWrapper<AbilityStage>(callback);
     taskpool.execute((): void => {
-      this.waitAbilityStageMonitorAsync(monitor, timeout, myCall);
+      this.waitAbilityStageMonitorAsync(monitor, timeout, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   waitAbilityStageMonitor(monitor: AbilityStageMonitor, timeout?: long): Promise<AbilityStage> {
     let p = new Promise<AbilityStage>((resolve: (data: AbilityStage) => void,
       reject: (err: BusinessError) => void): void => {
-      let myCall =
+      let asyncCall =
         new AsyncCallbackWrapper<AbilityStage>((err: BusinessError | null, data: AbilityStage | undefined) => {
           if (err == null || err.code == 0) {
             resolve(data as AbilityStage);
@@ -357,25 +393,29 @@ class AbilityDelegatorInner implements AbilityDelegator {
         });
       taskpool.execute((): void => {
         if (timeout == null) {
-          this.waitAbilityStageMonitorAsync(monitor, -1, myCall);
+          this.waitAbilityStageMonitorAsync(monitor, -1, asyncCall);
         } else {
-          this.waitAbilityStageMonitorAsync(monitor, timeout as long, myCall);
+          this.waitAbilityStageMonitorAsync(monitor, timeout as long, asyncCall);
         }
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
     return p;
   }
 
   doAbilityForeground(ability: UIAbility, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.doAbilityForegroundAsync(ability, myCall);
+      this.doAbilityForegroundAsync(ability, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   doAbilityForeground(ability: UIAbility): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -383,22 +423,26 @@ class AbilityDelegatorInner implements AbilityDelegator {
           }
         });
         taskpool.execute((): void => {
-          this.doAbilityForegroundAsync(ability, myCall);
+          this.doAbilityForegroundAsync(ability, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
   doAbilityBackground(ability: UIAbility, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.doAbilityBackgroundAsync(ability, myCall);
+      this.doAbilityBackgroundAsync(ability, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   doAbilityBackground(ability: UIAbility): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -406,22 +450,26 @@ class AbilityDelegatorInner implements AbilityDelegator {
           }
         });
         taskpool.execute((): void => {
-          this.doAbilityBackgroundAsync(ability, myCall);
+          this.doAbilityBackgroundAsync(ability, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
   print(msg: string, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.printAsync(msg, myCall);
+      this.printAsync(msg, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   print(msg: string): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -429,22 +477,26 @@ class AbilityDelegatorInner implements AbilityDelegator {
           }
         });
         taskpool.execute((): void => {
-          this.printAsync(msg, myCall);
+          this.printAsync(msg, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
   startAbility(want: Want, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbility(want, myCall);
+      this.nativeStartAbility(want, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
   startAbility(want: Want): Promise<void> {
     let p: Promise<void> =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -452,7 +504,9 @@ class AbilityDelegatorInner implements AbilityDelegator {
           }
         });
         taskpool.execute((): void => {
-          this.nativeStartAbility(want, myCall);
+          this.nativeStartAbility(want, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
@@ -462,23 +516,29 @@ class AbilityDelegatorInner implements AbilityDelegator {
     let getCurrentTopAbilityCall = new AsyncCallbackWrapper<UIAbility>(callback);
     let p = taskpool.execute((): UIAbility => {
       this.nativeGetCurrentTopAbility(getCurrentTopAbilityCall)
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
     console.log("getCurrentTopAbility callback2_04");
   }
   getCurrentTopAbility(): Promise<UIAbility> {
-    let p: Promise<UIAbility>  = new Promise<UIAbility>((resolve: (v: UIAbility) => void, reject: (error: Error) => void) => {
-      console.log("getCurrentTopAbility promise1_01");
-      let getCurrentTopAbilityCall = new AsyncCallbackWrapper<UIAbility>((err: BusinessError | null, data: UIAbility | undefined) => {
-        if (err == null || err.code == 0) {
-          resolve(data as UIAbility);
-        } else {
-          reject(err);
-        }
-      });
-      taskpool.execute((): UIAbility => {
-        this.nativeGetCurrentTopAbility(getCurrentTopAbilityCall);
+    let p: Promise<UIAbility> =
+      new Promise<UIAbility>((resolve: (v: UIAbility) => void, reject: (error: Error) => void) => {
+        console.log("getCurrentTopAbility promise1_01");
+        let getCurrentTopAbilityCall =
+          new AsyncCallbackWrapper<UIAbility>((err: BusinessError | null, data: UIAbility | undefined) => {
+            if (err == null || err.code == 0) {
+              resolve(data as UIAbility);
+            } else {
+              reject(err);
+            }
+          });
+        taskpool.execute((): UIAbility => {
+          this.nativeGetCurrentTopAbility(getCurrentTopAbilityCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
+        });
       });
-    });
     return p;
   }
 }
diff --git a/frameworks/ets/ets/application/ApplicationContext.ets b/frameworks/ets/ets/application/ApplicationContext.ets
index 5565205a386..7d649aea7d0 100644
--- a/frameworks/ets/ets/application/ApplicationContext.ets
+++ b/frameworks/ets/ets/application/ApplicationContext.ets
@@ -94,7 +94,7 @@ export default class ApplicationContext extends Context {
   preloadUIExtensionAbility(want: Want): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -102,23 +102,27 @@ export default class ApplicationContext extends Context {
           }
         });
         taskpool.execute((): void => {
-          this.nativepreloadUIExtensionAbilitySync(want, myCall);
+          this.nativepreloadUIExtensionAbilitySync(want, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
   killAllProcesses(callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativekillAllProcessesSync(false, myCall);
+      this.nativekillAllProcessesSync(false, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   killAllProcesses(): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -126,7 +130,9 @@ export default class ApplicationContext extends Context {
           }
         });
         taskpool.execute((): void => {
-          this.nativekillAllProcessesSync(false, myCall);
+          this.nativekillAllProcessesSync(false, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
@@ -135,7 +141,7 @@ export default class ApplicationContext extends Context {
   killAllProcesses(clearPageStack: 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) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -143,23 +149,27 @@ export default class ApplicationContext extends Context {
           }
         });
         taskpool.execute((): void => {
-          this.nativekillAllProcessesSync(clearPageStack, myCall);
+          this.nativekillAllProcessesSync(clearPageStack, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
   getRunningProcessInformation(callback: AsyncCallback<Array<ProcessInformation>>): void {
-    let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
+    let asyncCall = new AsyncCallbackWrapper<Array<ProcessInformation>>(callback);
     taskpool.execute((): void => {
-      this.nativegetRunningProcessInformation(myCall);
+      this.nativegetRunningProcessInformation(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   getRunningProcessInformation(): Promise<Array<ProcessInformation>> {
     let p = new Promise<Array<ProcessInformation>>((resolve: (data: Array<ProcessInformation>) => void,
       reject: (err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null,
+      let asyncCall = new AsyncCallbackWrapper<Array<ProcessInformation>>((err: BusinessError | null,
         data: Array<ProcessInformation> | undefined) => {
         if (err == null || err.code == 0) {
           resolve(data as Array<ProcessInformation>);
@@ -168,23 +178,27 @@ export default class ApplicationContext extends Context {
         }
       });
       taskpool.execute((): void => {
-        this.nativegetRunningProcessInformation(myCall);
+        this.nativegetRunningProcessInformation(asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
     return p;
   }
 
   clearUpApplicationData(callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeclearUpApplicationData(myCall);
+      this.nativeclearUpApplicationData(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   clearUpApplicationData(): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -192,7 +206,9 @@ export default class ApplicationContext extends Context {
           }
         });
         taskpool.execute((): void => {
-          this.nativeclearUpApplicationData(myCall);
+          this.nativeclearUpApplicationData(asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
@@ -221,7 +237,7 @@ export default class ApplicationContext extends Context {
   getAllRunningInstanceKeys(): Promise<Array<string>> {
     let p = new Promise<Array<string>>((resolve: (data: Array<string>) => void,
       reject: (err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<Array<string>>((err: BusinessError | null,
+      let asyncCall = new AsyncCallbackWrapper<Array<string>>((err: BusinessError | null,
         data: Array<string> | undefined) => {
         if (err == null || err.code == 0) {
           resolve(data as Array<string>);
@@ -230,7 +246,9 @@ export default class ApplicationContext extends Context {
         }
       });
       taskpool.execute((): void => {
-        this.nativeGetAllRunningInstanceKeys(myCall);
+        this.nativeGetAllRunningInstanceKeys(asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
     return p;
@@ -241,20 +259,22 @@ export default class ApplicationContext extends Context {
   }
 
   off(type: string, callbackId: int, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       if (type == 'environment') {
-        this.nativeOffEnvironmentSync(callbackId, myCall);
+        this.nativeOffEnvironmentSync(callbackId, asyncCall);
       } else if (type == 'abilityLifecycle') {
-        this.nativeOffLifecycleCallbackSync(type, callbackId, myCall);
+        this.nativeOffLifecycleCallbackSync(type, callbackId, asyncCall);
       }
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   off(type: string, callbackId: 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) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -263,10 +283,12 @@ export default class ApplicationContext extends Context {
         });
         taskpool.execute((): void => {
           if (type == 'environment') {
-            this.nativeOffEnvironmentSync(callbackId, myCall);
+            this.nativeOffEnvironmentSync(callbackId, asyncCall);
           } else if (type == 'abilityLifecycle') {
-            this.nativeOffLifecycleCallbackSync(type, callbackId, myCall);
+            this.nativeOffLifecycleCallbackSync(type, callbackId, asyncCall);
           }
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
diff --git a/frameworks/ets/ets/application/Context.ets b/frameworks/ets/ets/application/Context.ets
index e285cb169af..476e97c0aa8 100644
--- a/frameworks/ets/ets/application/Context.ets
+++ b/frameworks/ets/ets/application/Context.ets
@@ -105,15 +105,17 @@ export class Context extends BaseContext {
   }
 
   getGroupDir(dataGroupID: string, callback: AsyncCallback<string>): void {
-    let myCall = new AsyncCallbackWrapper<string>(callback);
+    let asyncCall = new AsyncCallbackWrapper<string>(callback);
     taskpool.execute((): void => {
-      this.nativeGetGroupDir(dataGroupID, myCall);
+      this.nativeGetGroupDir(dataGroupID, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   getGroupDir(dataGroupID: string): Promise<string> {
     return new Promise<string>((resolve: (data: string) => void, reject: (err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<string>((err: BusinessError | null, data: string | undefined) => {
+      let asyncCall = new AsyncCallbackWrapper<string>((err: BusinessError | null, data: string | undefined) => {
         if (err == null || err.code == 0) {
           resolve(data as string);
         } else {
@@ -121,7 +123,9 @@ export class Context extends BaseContext {
         }
       });
       taskpool.execute((): void => {
-        this.nativeGetGroupDir(dataGroupID, myCall);
+        this.nativeGetGroupDir(dataGroupID, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
   }
diff --git a/frameworks/ets/ets/application/ServiceExtensionContext.ets b/frameworks/ets/ets/application/ServiceExtensionContext.ets
index 2bb11c2f1f5..2dba2398478 100644
--- a/frameworks/ets/ets/application/ServiceExtensionContext.ets
+++ b/frameworks/ets/ets/application/ServiceExtensionContext.ets
@@ -73,37 +73,43 @@ export default class ServiceExtensionContext extends ExtensionContext {
   native nativeDisconnectServiceExtensionAbility(connection: long, callback: AsyncCallbackWrapper<void>): void;
 
   terminateSelf(callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeTerminateSelf(myCall);
+      this.nativeTerminateSelf(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   terminateSelf(): Promise<void> {
     return 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 => {
-          this.nativeTerminateSelf(myCall);
-        });
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        if (err == null || err.code == 0) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
       });
+      taskpool.execute((): void => {
+        this.nativeTerminateSelf(asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
+      });
+    });
   }
 
   startAbility(want: Want, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbility(want, myCall);
+      this.nativeStartAbility(want, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startAbility(want: Want, options?: StartOptions): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -112,9 +118,9 @@ export default class ServiceExtensionContext extends ExtensionContext {
       });
       taskpool.execute((): void => {
         if (options == null) {
-          this.nativeStartAbility(want, myCall);
+          this.nativeStartAbility(want, asyncCall);
         } else {
-          this.nativeStartAbility(want, options as StartOptions, myCall);
+          this.nativeStartAbility(want, options as StartOptions, asyncCall);
         }
       }).catch((err: Error): void => {
         reject(err as BusinessError);
@@ -123,37 +129,43 @@ export default class ServiceExtensionContext extends ExtensionContext {
   }
 
   startServiceExtensionAbility(want: Want, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeStartServiceExtensionAbility(want, myCall);
+      this.nativeStartServiceExtensionAbility(want, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startServiceExtensionAbility(want: Want): Promise<void> {
     return 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 => {
-          this.nativeStartServiceExtensionAbility(want, myCall);
-        });
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        if (err == null || err.code == 0) {
+          resolve(undefined);
+        } else {
+          reject(err);
+        }
+      });
+      taskpool.execute((): void => {
+        this.nativeStartServiceExtensionAbility(want, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
+    });
   }
 
   stopServiceExtensionAbility(want: Want, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeStopServiceExtensionAbility(want, myCall);
+      this.nativeStopServiceExtensionAbility(want, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   stopServiceExtensionAbility(want: Want): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -161,7 +173,9 @@ export default class ServiceExtensionContext extends ExtensionContext {
         }
       });
       taskpool.execute((): void => {
-        this.nativeStopServiceExtensionAbility(want, myCall);
+        this.nativeStopServiceExtensionAbility(want, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
   }
@@ -174,6 +188,8 @@ export default class ServiceExtensionContext extends ExtensionContext {
     let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
       this.nativeDisconnectServiceExtensionAbility(connection, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
@@ -188,7 +204,9 @@ export default class ServiceExtensionContext extends ExtensionContext {
       });
       taskpool.execute((): void => {
         this.nativeDisconnectServiceExtensionAbility(connection, asyncCall);
-      })
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
+      });
     });
   }
 }
diff --git a/frameworks/ets/ets/application/UIAbilityContext.ets b/frameworks/ets/ets/application/UIAbilityContext.ets
index d4798301488..6686fa08d91 100644
--- a/frameworks/ets/ets/application/UIAbilityContext.ets
+++ b/frameworks/ets/ets/application/UIAbilityContext.ets
@@ -140,22 +140,26 @@ export default class UIAbilityContext extends Context {
 
   private native nativeOpenAtomicService(appId: string, callback: AsyncCallbackWrapper<AbilityResult>, options?: AtomicServiceOptions): void;
   startAbility(want: Want, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbilitySync(want, myCall);
+      this.nativeStartAbilitySync(want, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startAbility(want: Want, options: StartOptions, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbilitySync(want, options, myCall);
+      this.nativeStartAbilitySync(want, options, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startAbility(want: Want, options?: StartOptions): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -164,9 +168,9 @@ export default class UIAbilityContext extends Context {
       });
       taskpool.execute((): void => {
         if (options == null) {
-          this.nativeStartAbilitySync(want, myCall);
+          this.nativeStartAbilitySync(want, asyncCall);
         } else {
-          this.nativeStartAbilitySync(want, options as StartOptions, myCall);
+          this.nativeStartAbilitySync(want, options as StartOptions, asyncCall);
         }
       }).catch((err: Error): void => {
         reject(err as BusinessError);
@@ -175,23 +179,27 @@ export default class UIAbilityContext extends Context {
   }
 
   startAbilityForResult(want: Want, callback: AsyncCallback<AbilityResult, void>): void {
-    let myCall = new AsyncCallbackWrapper<AbilityResult>(callback);
+    let asyncCall = new AsyncCallbackWrapper<AbilityResult>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbilityForResult(want, myCall);
+      this.nativeStartAbilityForResult(want, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startAbilityForResult(want: Want, startOptions: StartOptions, callback: AsyncCallback<AbilityResult, void>): void {
-    let myCall = new AsyncCallbackWrapper<AbilityResult>(callback);
+    let asyncCall = new AsyncCallbackWrapper<AbilityResult>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbilityForResult(want, startOptions, myCall);
+      this.nativeStartAbilityForResult(want, startOptions, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startAbilityForResult(want: Want, startOptions?: StartOptions): Promise<AbilityResult> {
     return new Promise<AbilityResult>((resolve: (data: AbilityResult) => void,
       reject: (err: BusinessError) => void): void => {
-      let myCall =
+      let asyncCall =
         new AsyncCallbackWrapper<AbilityResult>((err: BusinessError | null, data: AbilityResult | undefined) => {
           if (err == null || err.code == 0) {
             resolve(data as AbilityResult);
@@ -201,9 +209,9 @@ export default class UIAbilityContext extends Context {
         });
       taskpool.execute((): void => {
         if (startOptions == null) {
-          this.nativeStartAbilityForResult(want, myCall);
+          this.nativeStartAbilityForResult(want, asyncCall);
         } else {
-          this.nativeStartAbilityForResult(want, startOptions as StartOptions, myCall);
+          this.nativeStartAbilityForResult(want, startOptions as StartOptions, asyncCall);
         }
       }).catch((err: Error): void => {
         reject(err as BusinessError);
@@ -218,16 +226,18 @@ export default class UIAbilityContext extends Context {
   }
 
   terminateSelf(callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeTerminateSelfSync(myCall);
+      this.nativeTerminateSelfSync(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   terminateSelf(): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -235,23 +245,27 @@ export default class UIAbilityContext extends Context {
           }
         });
         taskpool.execute((): void => {
-          this.nativeTerminateSelfSync(myCall);
+          this.nativeTerminateSelfSync(asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
   terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeTerminateSelfWithResult(parameter, myCall);
+      this.nativeTerminateSelfWithResult(parameter, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   terminateSelfWithResult(parameter: AbilityResult): Promise<void> {
     let p =
       new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-        let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
           if (err == null || err.code == 0) {
             resolve(undefined);
           } else {
@@ -259,40 +273,52 @@ export default class UIAbilityContext extends Context {
           }
         });
         taskpool.execute((): void => {
-          this.nativeTerminateSelfWithResult(parameter, myCall);
+          this.nativeTerminateSelfWithResult(parameter, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
         });
       });
     return p;
   }
 
   reportDrawnCompleted(callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeReportDrawnCompletedSync(myCall);
+      this.nativeReportDrawnCompletedSync(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startServiceExtensionAbility(want: Want, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
-    this.nativeStartServiceExtensionAbility(want, myCall);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
+    taskpool.execute((): void => {
+      this.nativeStartServiceExtensionAbility(want, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
+    });
   }
 
   startServiceExtensionAbility(want: Want): Promise<void> {
-    return new Promise<void>((resolve: (data: undefined)=>void, reject:(err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+    return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
           reject(err);
         }
       });
-      this.nativeStartServiceExtensionAbility(want, myCall);
+      taskpool.execute((): void => {
+        this.nativeStartServiceExtensionAbility(want, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
+      });
     });
   }
 
   openLink(link: string, options?: OpenLinkOptions, callback?: AsyncCallback<AbilityResult, void>): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -304,7 +330,9 @@ export default class UIAbilityContext extends Context {
         callParam = new AsyncCallbackWrapper<AbilityResult>(callback);
       }
       taskpool.execute(() => {
-        this.nativeOpenLink(link, myCall, options, callParam);
+        this.nativeOpenLink(link, asyncCall, options, callParam);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
   }
@@ -315,7 +343,7 @@ export default class UIAbilityContext extends Context {
 
   moveAbilityToBackground(): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-      let syncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -323,21 +351,25 @@ export default class UIAbilityContext extends Context {
         }
       });
       taskpool.execute(() => {
-        this.nativeMoveAbilityToBackground(syncCall);
+        this.nativeMoveAbilityToBackground(asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
   }
 
   requestModalUIExtension(pickerWant: Want, callback: AsyncCallback<void>): void {
-    let syncCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeRequestModalUIExtension(pickerWant, syncCall);
+      this.nativeRequestModalUIExtension(pickerWant, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   requestModalUIExtension(pickerWant: Want): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-      let syncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -345,14 +377,16 @@ export default class UIAbilityContext extends Context {
         }
       });
       taskpool.execute(() => {
-        this.nativeRequestModalUIExtension(pickerWant, syncCall);
+        this.nativeRequestModalUIExtension(pickerWant, asyncCall);
+      }).catch((err: BusinessError): void => {
+        reject(err);
       });
     });
   }
 
   backToCallerAbilityWithResult(abilityResult: AbilityResult, requestCode: string): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-      let syncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -360,21 +394,23 @@ export default class UIAbilityContext extends Context {
         }
       });
       taskpool.execute(() => {
-        this.nativeBackToCallerAbilityWithResult(abilityResult, requestCode, syncCall);
+        this.nativeBackToCallerAbilityWithResult(abilityResult, requestCode, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
   }
 
   setMissionLabel(label: string, callback: AsyncCallback<void>): void {
-    let syncCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeSetMissionLabel(label, syncCall);
+      this.nativeSetMissionLabel(label, asyncCall);
     });
   }
 
   setMissionLabel(label: string): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-      let syncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -382,7 +418,9 @@ export default class UIAbilityContext extends Context {
         }
       });
       taskpool.execute(() => {
-        this.nativeSetMissionLabel(label, syncCall);
+        this.nativeSetMissionLabel(label, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
   }
@@ -392,9 +430,11 @@ export default class UIAbilityContext extends Context {
   }
 
   disconnectServiceExtensionAbility(connection: long, callback: AsyncCallback<void>): void {
-    let syncCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeDisconnectServiceExtensionAbility(connection, syncCall);
+      this.nativeDisconnectServiceExtensionAbility(connection, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
@@ -409,7 +449,9 @@ export default class UIAbilityContext extends Context {
       });
       taskpool.execute((): void => {
         this.nativeDisconnectServiceExtensionAbility(connection, callback);
-      })
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
+      });
     });
   }
 
@@ -428,45 +470,49 @@ export default class UIAbilityContext extends Context {
         callback(null, undefined);
       } else {
         callback(retError, undefined);
-      }    
+      }
     }, (err: Error): void => {
       callback(err as BusinessError, undefined);
     });
   }
 
   showAbility(): Promise<void> {
-  let p: Promise<void> =
-    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);
-        }
+    let p: Promise<void> =
+      new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+          if (err == null || err.code == 0) {
+            resolve(undefined);
+          } else {
+            reject(err);
+          }
+        });
+        taskpool.execute((): void => {
+          this.nativeChangeAbilityVisibility(true, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
+        });
       });
-    taskpool.execute((): void => {
-      this.nativeChangeAbilityVisibility(true, myCall);
-    });
-  });
-  return p;
-}
+    return p;
+  }
 
-hideAbility(): Promise<void> {
-  let p: Promise<void> =
-    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);
-        }
+  hideAbility(): Promise<void> {
+    let p: Promise<void> =
+      new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+          if (err == null || err.code == 0) {
+            resolve(undefined);
+          } else {
+            reject(err);
+          }
+        });
+        taskpool.execute((): void => {
+          this.nativeChangeAbilityVisibility(false, asyncCall);
+        }).catch((err: Error): void => {
+          reject(err as BusinessError);
+        });
       });
-    taskpool.execute((): void => {
-      this.nativeChangeAbilityVisibility(false, myCall);
-    });
-  });
-  return p;
-}
+    return p;
+  }
 
   startAbilityByType(type: string, wantParam: Record<string, Object>,
     startCallback: AbilityStartCallback): Promise<void> {
@@ -489,34 +535,40 @@ hideAbility(): Promise<void> {
   }
 
   openAtomicService(appId: string, options?: AtomicServiceOptions): Promise<AbilityResult> {
-    return new Promise<AbilityResult>((resolve: (data: AbilityResult) => void, reject: (err: BusinessError) => void): void => {
-      let asyncCall = new AsyncCallbackWrapper<AbilityResult>((err: BusinessError | null, data: AbilityResult | undefined) => {
-        if (err == null || err.code == 0) {
-          resolve(data as AbilityResult);
-        } else {
-          reject(err);
-        }
-      });
+    return new Promise<AbilityResult>((resolve: (data: AbilityResult) => void,
+      reject: (err: BusinessError) => void): void => {
+      let asyncCall =
+        new AsyncCallbackWrapper<AbilityResult>((err: BusinessError | null, data: AbilityResult | undefined) => {
+          if (err == null || err.code == 0) {
+            resolve(data as AbilityResult);
+          } else {
+            reject(err);
+          }
+        });
       taskpool.execute(() => {
         this.nativeOpenAtomicService(appId, asyncCall, options);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
   }
 
-
   setAbilityInstanceInfo(label: string, icon: image.PixelMap): Promise<void> {
-    let p:Promise<void> = new Promise<void>((resolve: (data:undefined)=>void, reject: (err: BusinessError)=>void):void => {
-      let syncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null)=>{
-        if (err == null || err.code == 0) {
-          resolve(undefined);
-        } else {
+    let p: Promise<void> =
+      new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+        let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+          if (err == null || err.code == 0) {
+            resolve(undefined);
+          } else {
+            reject(err);
+          }
+        });
+        taskpool.execute((): void => {
+          this.nativeSetAbilityInstanceInfo(label, icon, asyncCall);
+        }).catch((err: BusinessError): void => {
           reject(err);
-        }
-      });
-      taskpool.execute((): void => {
-        this.nativeSetAbilityInstanceInfo(label, icon, syncCall);
+        });
       });
-    });
     return p;
   }
 }
diff --git a/frameworks/ets/ets/application/UIExtensionContext.ets b/frameworks/ets/ets/application/UIExtensionContext.ets
index fc684e9764f..014e493259e 100644
--- a/frameworks/ets/ets/application/UIExtensionContext.ets
+++ b/frameworks/ets/ets/application/UIExtensionContext.ets
@@ -65,16 +65,18 @@ export default class UIExtensionContext extends ExtensionContext {
   native setColorMode(colorMode: ConfigurationConstant.ColorMode): void;
   native nativeReportDrawnCompleted(callback:AsyncCallbackWrapper<void>): void;
 
-  terminateSelf(callback:AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+  terminateSelf(callback: AsyncCallback<void>): void {
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.terminateSelfSync(myCall);
+      this.terminateSelfSync(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   terminateSelf(): Promise<void> {
-    let p = new Promise<void>((resolve: (data: undefined) => void, reject:(err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+    let p = new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -82,22 +84,26 @@ export default class UIExtensionContext extends ExtensionContext {
         }
       });
       taskpool.execute((): void => {
-        this.terminateSelfSync(myCall);
+        this.terminateSelfSync(asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
     return p;
   }
 
   terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.terminateSelfWithResultSync(parameter, myCall);
+      this.terminateSelfWithResultSync(parameter, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   terminateSelfWithResult(parameter: AbilityResult): Promise<void> {
-    let p = new Promise<void>((resolve: (data: undefined)=>void, reject:(err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+    let p = new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -105,29 +111,35 @@ export default class UIExtensionContext extends ExtensionContext {
         }
       });
       taskpool.execute((): void => {
-        this.terminateSelfWithResultSync(parameter, myCall);
+        this.terminateSelfWithResultSync(parameter, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
       });
     });
     return p;
   }
 
   startAbility(want: Want, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbility(want, myCall);
+      this.nativeStartAbility(want, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startAbility(want: Want, options: StartOptions, callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbility(want, options, myCall);
+      this.nativeStartAbility(want, options, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startAbility(want: Want, options?: StartOptions): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-      let myCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -136,9 +148,9 @@ export default class UIExtensionContext extends ExtensionContext {
       });
       taskpool.execute((): void => {
         if (options == null) {
-          this.nativeStartAbility(want, myCall);
+          this.nativeStartAbility(want, asyncCall);
         } else {
-          this.nativeStartAbility(want, options as StartOptions, myCall);
+          this.nativeStartAbility(want, options as StartOptions, asyncCall);
         }
       }).catch((err: Error): void => {
         reject(err as BusinessError);
@@ -151,15 +163,17 @@ export default class UIExtensionContext extends ExtensionContext {
   }
 
   disconnectServiceExtensionAbility(connection: long, callback: AsyncCallback<void>): void {
-    let syncCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeDisconnectServiceExtensionAbilitySync(connection, syncCall);
+      this.nativeDisconnectServiceExtensionAbilitySync(connection, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   disconnectServiceExtensionAbility(connection: long): Promise<void> {
     return new Promise<void>((resolve: (data: undefined) => void, reject: (err: BusinessError) => void): void => {
-      let syncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
+      let asyncCall = new AsyncCallbackWrapper<void>((err: BusinessError | null) => {
         if (err == null || err.code == 0) {
           resolve(undefined);
         } else {
@@ -167,29 +181,35 @@ export default class UIExtensionContext extends ExtensionContext {
         }
       });
       taskpool.execute((): void => {
-        this.nativeDisconnectServiceExtensionAbilitySync(connection, syncCall);
-      })
+        this.nativeDisconnectServiceExtensionAbilitySync(connection, asyncCall);
+      }).catch((err: Error): void => {
+        reject(err as BusinessError);
+      });
     });
   }
 
   startAbilityForResult(want: Want, callback: AsyncCallback<AbilityResult, void>): void {
-    let myCall = new AsyncCallbackWrapper<AbilityResult>(callback);
+    let asyncCall = new AsyncCallbackWrapper<AbilityResult>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbilityForResult(want, myCall);
+      this.nativeStartAbilityForResult(want, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startAbilityForResult(want: Want, startOptions: StartOptions, callback: AsyncCallback<AbilityResult, void>): void {
-    let myCall = new AsyncCallbackWrapper<AbilityResult>(callback);
+    let asyncCall = new AsyncCallbackWrapper<AbilityResult>(callback);
     taskpool.execute((): void => {
-      this.nativeStartAbilityForResult(want, startOptions, myCall);
+      this.nativeStartAbilityForResult(want, startOptions, asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 
   startAbilityForResult(want: Want, startOptions?: StartOptions): Promise<AbilityResult> {
     return new Promise<AbilityResult>((resolve: (data: AbilityResult) => void,
       reject: (err: BusinessError) => void): void => {
-      let myCall =
+      let asyncCall =
         new AsyncCallbackWrapper<AbilityResult>((err: BusinessError | null, data: AbilityResult | undefined) => {
           if (err == null || err.code == 0) {
             resolve(data as AbilityResult);
@@ -199,9 +219,9 @@ export default class UIExtensionContext extends ExtensionContext {
         });
       taskpool.execute((): void => {
         if (startOptions == null) {
-          this.nativeStartAbilityForResult(want, myCall);
+          this.nativeStartAbilityForResult(want, asyncCall);
         } else {
-          this.nativeStartAbilityForResult(want, startOptions as StartOptions, myCall);
+          this.nativeStartAbilityForResult(want, startOptions as StartOptions, asyncCall);
         }
       }).catch((err: Error): void => {
         reject(err as BusinessError);
@@ -210,9 +230,11 @@ export default class UIExtensionContext extends ExtensionContext {
   }
 
   reportDrawnCompleted(callback: AsyncCallback<void>): void {
-    let myCall = new AsyncCallbackWrapper<void>(callback);
+    let asyncCall = new AsyncCallbackWrapper<void>(callback);
     taskpool.execute((): void => {
-      this.nativeReportDrawnCompleted(myCall);
+      this.nativeReportDrawnCompleted(asyncCall);
+    }).catch((err: BusinessError): void => {
+      callback(err, undefined);
     });
   }
 }
\ No newline at end of file
-- 
Gitee