Merge branch 'master' of gitee.com:openharmony/docs into master

Signed-off-by: Nmingxihua <mingxihua@huawei.com>

zh-cn/application-dev/application-models/application-context-stage.md

@@ -14,7 +14,7 @@
   ![context-holding](figures/context-holding.png)
 
 - 各类Context的获取方式
-  - 获取[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)。每个UIAbility中都包含了一个Context属性，提供操作Ability、获取Ability的配置信息等能力。
+  - 获取[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)。每个UIAbility中都包含了一个Context属性，提供操作应用组件、获取应用组件的配置信息等能力。
     
      ```ts
      import UIAbility from '@ohos.app.ability.UIAbility';
@@ -51,7 +51,7 @@
          }
      }
      ```
-  - 获取[ApplicationContext](../reference/apis/js-apis-inner-application-applicationContext.md)。应用级别的Context。ApplicationContext在基类Context的基础上提供了订阅应用内Ability的生命周期的变化、订阅系统内存变化和订阅应用内系统环境的变化的能力，在UIAbility、ExtensionAbility、AbilityStage中均可以获取。
+  - 获取[ApplicationContext](../reference/apis/js-apis-inner-application-applicationContext.md)。应用级别的Context。ApplicationContext在基类Context的基础上提供了订阅应用内应用组件的生命周期的变化、订阅系统内存变化和订阅应用内系统环境的变化的能力，在UIAbility、ExtensionAbility、AbilityStage中均可以获取。
     
      ```ts
      import UIAbility from '@ohos.app.ability.UIAbility';

zh-cn/application-dev/application-models/serviceextensionability.md

@@ -165,7 +165,7 @@
 > **说明：**
 > ServiceExtensionContext的[startServiceExtensionAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#abilitycontextstartserviceextensionability)、[stopServiceExtensionAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#abilitycontextstopserviceextensionability)和[terminateSelf()](../reference/apis/js-apis-inner-application-serviceExtensionContext.md#serviceextensioncontextterminateself)为系统接口，三方应用不支持调用。
 
-1. 在系统应用中启动一个新的ServiceExtensionAbility。示例中的context的获取方式参见[获取UIAbility的Context属性](uiability-usage.md#获取uiability的上下文信息)。
+1. 在系统应用中启动一个新的ServiceExtensionAbility。示例中的context的获取方式请参见[获取UIAbility的上下文信息](uiability-usage.md#获取uiability的上下文信息)。
    
    ```ts
    let want = {
@@ -223,7 +223,7 @@
 
 ServiceExtensionAbility服务组件在[onConnect()](../reference/apis/js-apis-app-ability-serviceExtensionAbility.md#serviceextensionabilityonconnect)中返回IRemoteObject对象，开发者通过该IRemoteObject定义通信接口，用于客户端与服务端进行RPC交互。多个客户端可以同时连接到同一个后台服务，客户端完成与服务的交互后，客户端需要通过调用[disconnectServiceExtensionAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#abilitycontextdisconnectserviceextensionability)来断开连接。如果所有连接到某个后台服务的客户端均已断开连接，则系统会销毁该服务。
 
-- 使用connectServiceExtensionAbility()建立与后台服务的连接。示例中的context的获取方式参见[获取UIAbility的Context属性](uiability-usage.md#获取uiability的上下文信息)。
+- 使用connectServiceExtensionAbility()建立与后台服务的连接。示例中的context的获取方式请参见[获取UIAbility的上下文信息](uiability-usage.md#获取uiability的上下文信息)。
   
   ```ts
   import rpc from '@ohos.rpc';

zh-cn/application-dev/application-models/uiability-data-sync-with-ui.md

 # UIAbility组件与UI的数据同步
 
 
-基于OpenHarmony的应用模型，可以通过以下三种方式来实现UIAbility组件与UI之间的数据同步。
+基于OpenHarmony的应用模型，可以通过以下几种方式来实现UIAbility组件与UI之间的数据同步。
 
-- EventHub：[基类Context](application-context-stage.md)提供了EventHub的能力，通过发布订阅方式来实现。事件需要先订阅后发布，订阅者收到消息后进行处理。
-
-- globalThis：ArkTS引擎实例内部的一个全局对象，在ArkTS引擎实例内部都能访问。
-- LocalStorage/AppStorage：参见[应用级变量的状态管理](../quick-start/arkts-state-mgmt-application-level.md)。
+- [使用EventHub进行数据通信](#使用eventhub进行数据通信)：在基类Context中提供了EventHub对象，可以通过发布订阅方式来实现事件的传递。在事件传递前，订阅者需要先进行订阅，当发布者发布事件时，订阅者将接收到事件并进行相应处理。
+- [使用globalThis进行数据同步](#使用globalthis进行数据同步)：在ArkTS引擎实例内部，globalThis是一个全局对象，可以被UIAbility、ExtensionAbility、Page等组件访问。
+- [使用AppStorage/LocalStorage进行数据同步](#使用appstorage/localstorage进行数据同步)：ArkUI提供了AppStorage和LocalStorage两种应用级别的状态管理方案，可用于实现应用级别和UIAbility级别的数据同步。
 
 
 ## 使用EventHub进行数据通信
 
-[EventHub](../reference/apis/js-apis-inner-application-eventHub.md)提供了UIAbility组件/ExtensionAbility组件级别的事件机制，以UIAbility组件/ExtensionAbility组件为中心提供了订阅、取消订阅和触发事件的数据通信能力。
+[EventHub](../reference/apis/js-apis-inner-application-eventHub.md)为UIAbility组件/ExtensionAbility组件提供了事件机制，使它们能够进行订阅、取消订阅和触发事件等数据通信能力。
 
-[基类Context](application-context-stage.md)提供了EventHub对象，在使用EventHub之前，首先需要获取EventHub对象。本章节以使用EventHub实现UIAbility与UI之间的数据通信为例进行说明。
+在[基类Context](application-context-stage.md)中，提供了EventHub对象，使用EventHub实现UIAbility与UI之间的数据通信需要先获取EventHub对象。本章节将以此为例进行说明。
 
 1. 在UIAbility中调用[eventHub.on()](../reference/apis/js-apis-inner-application-eventHub.md#eventhubon)方法注册一个自定义事件“event1”，[eventHub.on()](../reference/apis/js-apis-inner-application-eventHub.md#eventhubon)有如下两种调用方式，使用其中一种即可。
 
@@ -88,8 +87,7 @@
 
 ## 使用globalThis进行数据同步
 
-
-globalThis是ArkTS引擎实例内部的一个全局对象，引擎内部的UIAbility/ExtensionAbility/Page都可以使用，因此可以使用globalThis全局对象进行数据同步。
+globalThis是[ArkTS引擎实例](thread-model-stage.md)内部的一个全局对象，引擎内部的UIAbility/ExtensionAbility/Page都可以使用，因此可以使用globalThis对象进行数据同步。
 
   **图1** 使用globalThis进行数据同步
 
@@ -105,7 +103,7 @@ globalThis是ArkTS引擎实例内部的一个全局对象，引擎内部的UIAbi
 
 ### UIAbility和Page之间使用globalThis
 
-globalThis为[ArkTS引擎实例](thread-model-stage.md)下的全局对象，可以通过globalThis绑定属性/方法来进行UIAbility组件与UI的数据同步。例如在UIAbility组件中绑定want参数，即可在UIAbility对应的UI界面上使用want参数信息。
+通过在globalThis对象上绑定属性/方法，可以实现UIAbility组件与UI之间的数据同步。例如在UIAbility组件中绑定want参数，即可在UIAbility对应的UI界面上使用want参数信息。
 
 1. 调用[startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability)方法启动一个UIAbility实例时，被启动的UIAbility创建完成后会进入onCreate()生命周期回调，且在onCreate()生命周期回调中能够接受到传递过来的want参数，可以将want参数绑定到globalThis上。
 
@@ -144,29 +142,29 @@ globalThis为[ArkTS引擎实例](thread-model-stage.md)下的全局对象，可
 
 ### UIAbility和UIAbility之间使用globalThis
 
-同一个应用中UIAbility和UIAbility之间的数据传递，可以通过将数据绑定到全局变量globalThis上进行同步，如在AbilityA中将数据保存在globalThis，然后跳转到AbilityB中取得该数据：
+在同一个应用中，UIAbility与UIAbility之间的数据传递可以通过将数据绑定到全局变量globalThis上进行同步。例如，在UIAbilityA中将数据保存在globalThis对象中，然后跳转到UIAbilityB中就可以获取该数据。
 
-1. AbilityA中保存数据一个字符串数据并挂载到globalThis上。
+1. UIAbilityA中保存数据一个字符串数据并挂载到globalThis上。
 
    ```ts
    import UIAbility from '@ohos.app.ability.UIAbility'
 
-   export default class AbilityA extends UIAbility {
+   export default class UIAbilityA extends UIAbility {
        onCreate(want, launch) {
-           globalThis.entryAbilityStr = 'AbilityA'; // AbilityA存放字符串“AbilityA”到globalThis
+           globalThis.entryAbilityStr = 'UIAbilityA'; // UIAbilityA存放字符串“UIAbilityA”到globalThis
            // ...
        }
    }
    ```
 
-2. AbilityB中获取对应的数据。
+2. UIAbilityB中获取对应的数据。
 
    ```ts
    import UIAbility from '@ohos.app.ability.UIAbility'
    
-   export default class AbilityB extends UIAbility {
+   export default class UIAbilityB extends UIAbility {
        onCreate(want, launch) {
-           // AbilityB从globalThis读取name并输出
+           // UIAbilityB从globalThis读取name并输出
            console.info('name from entryAbilityStr: ' + globalThis.entryAbilityStr);
            // ...
        }
@@ -176,17 +174,17 @@ globalThis为[ArkTS引擎实例](thread-model-stage.md)下的全局对象，可
 
 ### UIAbility和ExtensionAbility之间使用globalThis
 
-同一个应用中UIAbility和ExtensionAbility之间的数据传递，也可以通过将数据绑定到全局变量globalThis上进行同步，如在AbilityA中保存数据，在ServiceExtensionAbility中获取数据。
+在同一个应用中，UIAbility和ExtensionAbility之间的数据传递也可以通过将数据绑定到全局变量globalThis上进行同步。例如，在UIAbilityA中保存数据，在ServiceExtensionAbility中就可以获取该数据。
 
-1. AbilityA中保存数据一个字符串数据并挂载到globalThis上。
+1. UIAbilityA中保存数据一个字符串数据并挂载到globalThis上。
 
    ```ts
    import UIAbility from '@ohos.app.ability.UIAbility'
 
-   export default class AbilityA extends UIAbility {
+   export default class UIAbilityA extends UIAbility {
        onCreate(want, launch) {
-           // AbilityA存放字符串“AbilityA”到globalThis
-           globalThis.entryAbilityStr = 'AbilityA';
+           // UIAbilityA存放字符串“UIAbilityA”到globalThis
+           globalThis.entryAbilityStr = 'UIAbilityA';
            // ...
        }
    }
@@ -213,7 +211,7 @@ globalThis为[ArkTS引擎实例](thread-model-stage.md)下的全局对象，可
 
 ![globalThis2](figures/globalThis2.png)
 
-- Stage模型下进程内的UIAbility组件共享ArkTS引擎实例，使用globalThis时需要避免存放相同名称的对象。例如AbilityA和AbilityB可以使用globalThis共享数据，在存放相同名称的对象时，先存放的对象会被后存放的对象覆盖。
+- Stage模型下进程内的UIAbility组件共享ArkTS引擎实例，使用globalThis时需要避免存放相同名称的对象。例如UIAbilityA和UIAbilityB可以使用globalThis共享数据，在存放相同名称的对象时，先存放的对象会被后存放的对象覆盖。
 
 - FA模型因为每个UIAbility组件之间引擎隔离，不会存在该问题。
 
@@ -221,20 +219,20 @@ globalThis为[ArkTS引擎实例](thread-model-stage.md)下的全局对象，可
 
 Stage模型上同名对象覆盖导致问题的场景举例说明。
 
-1. 在AbilityA文件中使用globalThis中存放了[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)。
+1. 在UIAbilityA文件中使用globalThis中存放了[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)。
 
    ```ts
    import UIAbility from '@ohos.app.ability.UIAbility'
 
-   export default class AbilityA extends UIAbility {
+   export default class UIAbilityA extends UIAbility {
        onCreate(want, launch) {
-           globalThis.context = this.context; // AbilityA存放context到globalThis
+           globalThis.context = this.context; // UIAbilityA存放context到globalThis
            // ...
        }
    }
    ```
 
-2. 在AbilityA的页面中获取该[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)并进行使用。使用完成后将AbilityA实例切换至后台。
+2. 在UIAbilityA的页面中获取该[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)并进行使用。使用完成后将UIAbilityA实例切换至后台。
 
    ```ts
    @Entry
@@ -254,21 +252,21 @@ Stage模型上同名对象覆盖导致问题的场景举例说明。
    }
    ```
 
-3. 在AbilityB文件中使用globalThis中存放了[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)，并且命名为相同的名称。
+3. 在UIAbilityB文件中使用globalThis中存放了[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)，并且命名为相同的名称。
 
    ```ts
    import UIAbility from '@ohos.app.ability.UIAbility'
 
-   export default class AbilityB extends UIAbility {
+   export default class UIAbilityB extends UIAbility {
        onCreate(want, launch) {
-           // AbilityB覆盖了AbilityA在globalThis中存放的context
+           // UIAbilityB覆盖了UIAbilityA在globalThis中存放的context
            globalThis.context = this.context;
            // ...
        }
    }
    ```
 
-4. 在AbilityB的页面中获取该[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)并进行使用。此时获取到的globalThis.context已经表示为AbilityB中赋值的[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)内容。
+4. 在UIAbilityB的页面中获取该[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)并进行使用。此时获取到的globalThis.context已经表示为UIAbilityB中赋值的[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)内容。
 
    ```ts
    @Entry
@@ -288,27 +286,27 @@ Stage模型上同名对象覆盖导致问题的场景举例说明。
    }
    ```
 
-5. 在AbilityB实例切换至后台，将AbilityA实例从后台切换回到前台。此时AbilityA的onCreate生命周期不会再次进入。
+5. 在UIAbilityB实例切换至后台，将UIAbilityA实例从后台切换回到前台。此时UIAbilityA的onCreate生命周期不会再次进入。
 
    ```ts
    import UIAbility from '@ohos.app.ability.UIAbility'
 
-   export default class AbilityA extends UIAbility {
-       onCreate(want, launch) { // AbilityA从后台进入前台，不会再走这个生命周期
+   export default class UIAbilityA extends UIAbility {
+       onCreate(want, launch) { // UIAbilityA从后台进入前台，不会再走这个生命周期
            globalThis.context = this.context;
            // ...
        }
    }
    ```
 
-6. 在AbilityA的页面再次回到前台时，其获取到的globalThis.context表示的为AbilityB的[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)，而不是AbilityA的[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)，在AbilityA的页面中使用则会出错。
+6. 在UIAbilityA的页面再次回到前台时，其获取到的globalThis.context表示的为UIAbilityB的[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)，而不是UIAbilityA的[UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md)，在UIAbilityA的页面中使用则会出错。
 
    ```ts
    @Entry
    @Component
    struct Index {
      onPageShow() {
-       let ctx = globalThis.context; // 这时候globalThis中的context是AbilityB的context
+       let ctx = globalThis.context; // 这时候globalThis中的context是UIAbilityB的context
        let permissions=['com.example.permission'];
        ctx.requestPermissionsFromUser(permissions,(result) => { // 使用这个对象就会导致进程崩溃
           console.info('requestPermissionsFromUser result:' + JSON.stringify(result));
@@ -320,3 +318,7 @@ Stage模型上同名对象覆盖导致问题的场景举例说明。
      }
    }
    ```
+
+## 使用AppStorage/LocalStorage进行数据同步
+
+ArkUI提供了AppStorage和LocalStorage两种应用级别的状态管理方案，可用于实现应用级别和UIAbility级别的数据同步。使用这些方案可以方便地管理应用状态，提高应用性能和用户体验。其中，AppStorage是一个全局的状态管理器，适用于多个UIAbility共享同一状态数据的情况；而LocalStorage则是一个局部的状态管理器，适用于单个UIAbility内部使用的状态数据。通过这两种方案，开发者可以更加灵活地控制应用状态，提高应用的可维护性和可扩展性。详细请参见[应用级变量的状态管理](../quick-start/arkts-state-mgmt-application-level.md)。

zh-cn/application-dev/application-models/uiability-intra-device-interaction.md

@@ -26,7 +26,7 @@ UIAbility是系统调度的最小单元。在设备内的功能模块之间跳
 
 假设应用中有两个UIAbility：EntryAbility和FuncAbility（可以在应用的一个Module中，也可以在的不同Module中），需要从EntryAbility的页面中启动FuncAbility。
 
-1. 在EntryAbility中，通过调用[startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability)方法启动UIAbility，[want](../reference/apis/js-apis-app-ability-want.md)为UIAbility实例启动的入口参数，其中bundleName为待启动应用的Bundle名称，abilityName为待启动的Ability名称，moduleName在待启动的UIAbility属于不同的Module时添加，parameters为自定义信息参数。示例中的context的获取方式参见[获取UIAbility的Context属性](uiability-usage.md#获取uiability的上下文信息)。
+1. 在EntryAbility中，通过调用[startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability)方法启动UIAbility，[want](../reference/apis/js-apis-app-ability-want.md)为UIAbility实例启动的入口参数，其中bundleName为待启动应用的Bundle名称，abilityName为待启动的Ability名称，moduleName在待启动的UIAbility属于不同的Module时添加，parameters为自定义信息参数。示例中的context的获取方式请参见[获取UIAbility的上下文信息](uiability-usage.md#获取uiability的上下文信息)。
    
    ```ts
    let wantInfo = {
@@ -82,7 +82,7 @@ UIAbility是系统调度的最小单元。在设备内的功能模块之间跳
 
 在一个EntryAbility启动另外一个FuncAbility时，希望在被启动的FuncAbility完成相关业务后，能将结果返回给调用方。例如在应用中将入口功能和帐号登录功能分别设计为两个独立的UIAbility，在帐号登录UIAbility中完成登录操作后，需要将登录的结果返回给入口UIAbility。
 
-1. 在EntryAbility中，调用[startAbilityForResult()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateselfwithresult)接口启动FuncAbility，异步回调中的data用于接收FuncAbility停止自身后返回给EntryAbility的信息。示例中的context的获取方式参见[获取UIAbility的Context属性](uiability-usage.md#获取uiability的上下文信息)。
+1. 在EntryAbility中，调用[startAbilityForResult()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateselfwithresult)接口启动FuncAbility，异步回调中的data用于接收FuncAbility停止自身后返回给EntryAbility的信息。示例中的context的获取方式请参见[获取UIAbility的上下文信息](uiability-usage.md#获取uiability的上下文信息)。
    
    ```ts
    let wantInfo = {
@@ -181,7 +181,7 @@ UIAbility是系统调度的最小单元。在设备内的功能模块之间跳
    }
    ```
 
-2. 在调用方want参数中的entities和action需要被包含在待匹配UIAbility的skills配置的entities和actions中。系统匹配到符合entities和actions参数条件的UIAbility后，会弹出选择框展示匹配到的UIAbility实例列表供用户选择使用。示例中的context的获取方式参见[获取UIAbility的Context属性](uiability-usage.md#获取uiability的上下文信息)。
+2. 在调用方want参数中的entities和action需要被包含在待匹配UIAbility的skills配置的entities和actions中。系统匹配到符合entities和actions参数条件的UIAbility后，会弹出选择框展示匹配到的UIAbility实例列表供用户选择使用。示例中的context的获取方式请参见[获取UIAbility的上下文信息](uiability-usage.md#获取uiability的上下文信息)。
    
    ```ts
    let wantInfo = {
@@ -315,7 +315,7 @@ UIAbility是系统调度的最小单元。在设备内的功能模块之间跳
 
 ### 调用方UIAbility指定启动页面
 
-调用方UIAbility启动另外一个UIAbility时，通常需要跳转到指定的页面。例如FuncAbility包含两个页面（Index对应首页，Second对应功能A页面），此时需要在传入的want参数中配置指定的页面路径信息，可以通过want中的parameters参数增加一个自定义参数传递页面跳转信息。示例中的context的获取方式参见[获取UIAbility的Context属性](uiability-usage.md#获取uiability的上下文信息)。
+调用方UIAbility启动另外一个UIAbility时，通常需要跳转到指定的页面。例如FuncAbility包含两个页面（Index对应首页，Second对应功能A页面），此时需要在传入的want参数中配置指定的页面路径信息，可以通过want中的parameters参数增加一个自定义参数传递页面跳转信息。示例中的context的获取方式请参见[获取UIAbility的上下文信息](uiability-usage.md#获取uiability的上下文信息)。
 
 
 ```ts

zh-cn/application-dev/application-models/want-overview.md

@@ -3,17 +3,18 @@
 
 ## Want的定义与用途
 
-[Want](../reference/apis/js-apis-app-ability-want.md)是对象间信息传递的载体，可以用于应用组件间的信息传递。其使用场景之一是作为[startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability)的参数，包含了指定的启动目标以及启动时需携带的相关数据，如bundleName和abilityName字段分别指明目标Ability所在应用的Bundle名称以及对应包内的Ability名称。当UIAbilityA启动UIAbilityB并需要传入一些数据给UIAbilityB时，Want可以作为一个载体将数据传给UIAbilityB。
+[Want](../reference/apis/js-apis-app-ability-want.md)是一种对象，用于在应用组件之间传递信息。
 
-  **图1** Want用法示意
+其中，一种常见的使用场景是作为[startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability)方法的参数。例如，当UIAbilityA需要启动UIAbilityB并向UIAbilityB传递一些数据时，可以使用Want作为一个载体，将数据传递给UIAbilityB。
 
-  ![usage-of-want](figures/usage-of-want.png)  
+**图1** Want用法示意  
+![usage-of-want](figures/usage-of-want.png)  
 
 
 ## Want的类型
 
-- **显式Want**：在启动Ability时指定了abilityName和bundleName的Want称为显式Want。
-    当有明确处理请求的对象时，通过提供目标Ability所在应用的Bundle名称信息（bundleName），并在Want内指定abilityName便可启动目标Ability。显式Want通常用于在当前应用开发中启动某个已知的Ability。
+- **显式Want**：在启动Ability时，如果指定了abilityName和bundleName，则称为显式Want。
+    显式Want通常用于在当前应用中启动已知的目标Ability，通过提供目标Ability所在应用的Bundle名称信息（bundleName）并在Want对象内指定abilityName来启动目标Ability。当有明确处理请求的对象时，显式Want是一种简单有效的启动目标Ability的方式。
     
   ```ts
   let wantInfo = {
@@ -23,8 +24,8 @@
   }
   ```
 
-- **隐式Want**：在启动Ability时未指定abilityName的Want称为隐式Want。
-  当请求处理的对象不明确时，希望在当前应用中使用其他应用提供的某个能力（通过[skills标签](../quick-start/module-configuration-file.md#skills标签)定义），而不关心提供该能力的具体应用，可以使用隐式Want。例如使用隐式Want描述需要打开一个链接的请求，而不关心通过具体哪个应用打开，系统将匹配声明支持该请求的所有应用。
+- **隐式Want**：在启动Ability时，如果未指定abilityName，则称为隐式Want。
+  当需要处理的对象不明确时，可以使用隐式Want，在当前应用中使用其他应用提供的某个能力，而不关心提供该能力的具体应用。隐式Want使用[skills标签](../quick-start/module-configuration-file.md#skills标签)来定义需要使用的能力，并由系统匹配声明支持该请求的所有应用来处理请求。例如，需要打开一个链接的请求，系统将匹配所有声明支持该请求的应用，然后让用户选择使用哪个应用打开链接。
 
   
   ```ts

zh-cn/application-dev/quick-start/module-configuration-file.md

@@ -395,7 +395,11 @@ extensionAbilities示例：
 
 该标签标识应用运行时需向系统申请的权限集合。
 
-  **表8** **requestPermissions标签说明**
+> **说明：**
+>
+> 在requestPermissions标签中配置的权限项将在应用级别生效，即该权限适用于整个应用程序。
+
+**表8** **requestPermissions标签说明**
 
 | 属性 | 含义 | 类型 | 取值范围 | 默认值 |
 | -------- | -------- | -------- | -------- | -------- |

zh-cn/application-dev/reference/apis/js-apis-app-ability-want.md

 # @ohos.app.ability.Want (Want)
 
-Want是对象间信息传递的载体, 可以用于应用组件间的信息传递。 Want的使用场景之一是作为startAbility的参数, 其包含了指定的启动目标, 以及启动时需携带的相关数据, 如bundleName和abilityName字段分别指明目标Ability所在应用的包名以及对应包内的Ability名称。当UIAbilityA需要启动UIAbilityB并传入一些数据时, 可使用Want作为载体将这些数据传递给UIAbilityB。
+Want是对象间信息传递的载体，可以用于应用组件间的信息传递。Want的使用场景之一是作为startAbility的参数，其包含了指定的启动目标，以及启动时需携带的相关数据，例如bundleName和abilityName字段分别指明目标Ability所在应用的包名以及对应包内的Ability名称。当UIAbilityA需要启动UIAbilityB并传入一些数据时，可使用Want作为载体将这些数据传递给UIAbilityB。
 
 > **说明：**
 >
@@ -22,8 +22,8 @@ import Want from '@ohos.app.ability.Want';
 | bundleName   | string               | 否   | 表示待启动Ability所在的应用Bundle名称。 |
 | moduleName | string | 否 | 表示待启动的Ability所属的模块名称。 |
 | abilityName  | string               | 否   | 表示待启动Ability名称。如果在Want中该字段同时指定了BundleName和AbilityName，则Want可以直接匹配到指定的Ability。AbilityName需要在一个应用的范围内保证唯一。 |
-| [action](js-apis-app-ability-wantConstant.md#wantConstant.Action) | string               | 否   | 表示要执行的通用操作（如：查看、分享、应用详情）。在隐式Want中，您可以定义该字段，配合uri或parameters来表示对数据要执行的操作。隐式Want定义及匹配规则请参见[显式Want与隐式Want匹配规则](application-models/explicit-implicit-want-mappings.md)。                     |
-| [entities](js-apis-app-ability-wantConstant.md#wantConstant.Entity) | Array\<string> | 否 | 表示目标Ability额外的类别信息（如：浏览器、视频播放器）。在隐式Want中是对action字段的补充。在隐式Want中，您可以定义该字段，来过滤匹配Ability类型。 |
+| action | string               | 否   | 表示要执行的通用操作（如：查看、分享、应用详情）。在隐式Want中，您可以定义该字段，配合uri或parameters来表示对数据要执行的操作。隐式Want定义及匹配规则请参见[显式Want与隐式Want匹配规则](../../application-models/explicit-implicit-want-mappings.md)。             |
+| entities | Array\<string> | 否 | 表示目标Ability额外的类别信息（如：浏览器、视频播放器）。在隐式Want中是对action字段的补充。在隐式Want中，您可以定义该字段，来过滤匹配Ability类型。 |
 | uri | string | 否 | 表示携带的数据，一般配合type使用，指明待处理的数据类型。如果在Want中指定了uri，则Want将匹配指定的Uri信息，包括`scheme`、`schemeSpecificPart`、`authority`和`path`信息。 |
 | type | string | 否 | 表示MIME type类型描述，打开文件的类型，主要用于文管打开文件。比如：'text/xml' 、 'image/*'等，MIME定义请参见https://www.iana.org/assignments/media-types/media-types.xhtml?utm_source=ld246.com。 |
 | parameters   | {[key: string]: any} | 否   | 表示WantParams描述，由开发者自行决定传入的键值对。默认会携带以下key值：<br />- ohos.aafwk.callerPid：表示拉起方的pid。<br />- ohos.aafwk.param.callerToken：表示拉起方的token。<br />- ohos.aafwk.param.callerUid：表示[BundleInfo](js-apis-bundleManager-bundleInfo.md#bundleinfo-1)中的uid，应用包里应用程序的uid。<br />- component.startup.newRules：表示是否启用新的管控规则。<br />- moduleName：表示拉起方的模块名，该字段的值即使定义成其他字符串，在传递到另一端时会被修改为正确的值。<br />- ohos.dlp.params.sandbox：表示dlp文件才会有。           |
@@ -31,85 +31,107 @@ import Want from '@ohos.app.ability.Want';
 
 **示例：**
 
-- 基础用法（在UIAbility对象中调用，其中示例中的context为UIAbility的上下文对象）。
+- 基础用法：在UIAbility对象中调用，示例中的context的获取方式请参见[获取UIAbility的上下文信息](../../application-models/uiability-usage.md#获取uiability的上下文信息)。
 
   ```ts
-    let want = {
-        'deviceId': '', // deviceId为空表示本设备
-        'bundleName': 'com.example.myapplication',
-        'abilityName': 'FuncAbility',
-        'moduleName': 'entry' // moduleName非必选
-    };
-    this.context.startAbility(want, (error) => {
-        // 显式拉起Ability，通过bundleName、abilityName和moduleName可以唯一确定一个Ability
-        console.log('error.code = ${error.code}');
-    });
+  let want = {
+    'deviceId': '', // deviceId为空表示本设备
+    'bundleName': 'com.example.myapplication',
+    'abilityName': 'FuncAbility',
+    'moduleName': 'entry' // moduleName非必选
+  };
+  
+  this.context.startAbility(want, (err) => {
+    // 显式拉起Ability，通过bundleName、abilityName和moduleName可以唯一确定一个Ability
+    console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+  });
   ```
 
-- 通过自定字段传递数据, 以下为当前支持类型（在UIAbility对象中调用，其中示例中的context为UIAbility的上下文对象）。
+- 通过自定字段传递数据，以下为当前支持类型（在UIAbility对象中调用，示例中的context的获取方式请参见[获取UIAbility的上下文信息](../../application-models/uiability-usage.md#获取uiability的上下文信息)）。
 
     * 字符串（String）
         ```ts
         let want = {
-            bundleName: 'com.example.myapplication',
-            abilityName: 'FuncAbility',
-            parameters: {
-                keyForString: 'str',
-            },
+          bundleName: 'com.example.myapplication',
+          abilityName: 'FuncAbility',
+          parameters: {
+            keyForString: 'str',
+          },
         };
+        
+        this.context.startAbility(want, (err) => {
+          console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+        });
         ```
     * 数字（Number）
         ```ts
         let want = {
-            bundleName: 'com.example.myapplication',
-            abilityName: 'FuncAbility',
-            parameters: {
-                keyForInt: 100,
-                keyForDouble: 99.99,
-            },
+          bundleName: 'com.example.myapplication',
+          abilityName: 'FuncAbility',
+          parameters: {
+            keyForInt: 100,
+            keyForDouble: 99.99,
+          },
         };
+        
+        this.context.startAbility(want, (err) => {
+          console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+        });
         ```
     * 布尔（Boolean）
         ```ts
         let want = {
-            bundleName: 'com.example.myapplication',
-            abilityName: 'FuncAbility',
-            parameters: {
-                keyForBool: true,
-            },
+          bundleName: 'com.example.myapplication',
+          abilityName: 'FuncAbility',
+          parameters: {
+            keyForBool: true,
+          },
         };
+        
+        this.context.startAbility(want, (err) => {
+          console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+        });
         ```
     * 对象（Object）
         ```ts
         let want = {
-            bundleName: 'com.example.myapplication',
-            abilityName: 'FuncAbility',
-            parameters: {
-                keyForObject: {
-                    keyForObjectString: 'str',
-                    keyForObjectInt: -200,
-                    keyForObjectDouble: 35.5,
-                    keyForObjectBool: false,
-                },
+          bundleName: 'com.example.myapplication',
+          abilityName: 'FuncAbility',
+          parameters: {
+            keyForObject: {
+              keyForObjectString: 'str',
+              keyForObjectInt: -200,
+              keyForObjectDouble: 35.5,
+              keyForObjectBool: false,
             },
+          },
         };
+        
+        this.context.startAbility(want, (err) => {
+          console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+        });
         ```
     * 数组（Array）
         ```ts
         let want = {
-            bundleName: 'com.example.myapplication',
-            abilityName: 'FuncAbility',
-            parameters: {
-                keyForArrayString: ['str1', 'str2', 'str3'],
-                keyForArrayInt: [100, 200, 300, 400],
-                keyForArrayDouble: [0.1, 0.2],
-                keyForArrayObject: [{obj1: 'aaa'}, {obj2: 100}],
-            },
+          bundleName: 'com.example.myapplication',
+          abilityName: 'FuncAbility',
+          parameters: {
+            keyForArrayString: ['str1', 'str2', 'str3'],
+            keyForArrayInt: [100, 200, 300, 400],
+            keyForArrayDouble: [0.1, 0.2],
+            keyForArrayObject: [{ obj1: 'aaa' }, { obj2: 100 }],
+          },
         };
+        
+        this.context.startAbility(want, (err) => {
+          console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+        });
         ```
     * 文件描述符（FD）
         ```ts
         import fileio from '@ohos.fileio';
+        
         let fd;
         try {
             fd = fileio.openSync('/data/storage/el2/base/haps/pic.png');
@@ -117,21 +139,17 @@ import Want from '@ohos.app.ability.Want';
             console.log('openSync fail: ${JSON.stringify(e)}');
         }
         let want = {
-            'deviceId': '', // deviceId为空表示本设备
-            'bundleName': 'com.example.myapplication',
-            'abilityName': 'FuncAbility',
-            'moduleName': 'entry', // moduleName非必选
-            'parameters': {
-                'keyFd':{'type':'FD', 'value':fd} // {'type':'FD', 'value':fd}是固定用法，用于表示该数据是FD
-            }
+          'deviceId': '', // deviceId为空表示本设备
+          'bundleName': 'com.example.myapplication',
+          'abilityName': 'FuncAbility',
+          'moduleName': 'entry', // moduleName非必选
+          'parameters': {
+            'keyFd': { 'type': 'FD', 'value': fd } // {'type':'FD', 'value':fd}是固定用法，用于表示该数据是FD
+          }
         };
-        this.context.startAbility(want, (error) => {
-            // 显式拉起Ability，通过bundleName、abilityName和moduleName可以唯一确定一个Ability
-            console.log('error.code = ${error.code}');
+        
+        this.context.startAbility(want, (err) => {
+          console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
         });
         ```
 
-- 更多详细说明和示例请参见： [应用模型](../../application-models/Readme-CN.md)的信息传递载体Want
-
-  <!--no_check-->
-

zh-cn/application-dev/reference/apis/js-apis-inner-application-errorObserver.md

@@ -22,9 +22,9 @@ onUnhandledException(errMsg: string): void;
 import errorManager from '@ohos.app.ability.errorManager';
 
 let observer = {
-    onUnhandledException(errorMsg) {
-        console.log('onUnhandledException, errorMsg: ', errorMsg);
-    }
+  onUnhandledException(errorMsg) {
+    console.log('onUnhandledException, errorMsg: ', errorMsg);
+  }
 };
 
 try {

zh-cn/application-dev/reference/apis/js-apis-inner-application-uiAbilityContext.md

@@ -18,7 +18,8 @@ UIAbilityContext是[UIAbility](js-apis-app-ability-uiAbility.md)的上下文环
 | config | [Configuration](js-apis-app-ability-configuration.md) | 是 | 否 | 与UIAbility相关的配置信息，如语言、颜色模式等。 |
 
 > **关于示例代码的说明：**
-> - 本文档中的示例，通过this.context获取UIAbilityContext，this代表的是继承自UIAbility的UIAbility实例，若需要在页面中使用UIAbilityContext的能力，请参照[获取UIAbility的上下文信息](../../application-models/uiability-usage.md#获取uiability的上下文信息)
+>
+> 在本文档的示例中，通过`this.context`来获取`UIAbilityContext`，其中`this`代表继承自`UIAbility`的`UIAbility`实例。如需要在页面中使用`UIAbilityContext`提供的能力，请参见[获取UIAbility的上下文信息](../../application-models/uiability-usage.md#获取uiability的上下文信息)。
 
 ## UIAbilityContext.startAbility
 
@@ -61,25 +62,25 @@ startAbility(want: Want, callback: AsyncCallback<void>): void;
 **示例：**
 
   ```ts
-  let want = {
-    bundleName: 'com.example.myapp',
-    abilityName: 'MyAbility'
-  };
+let want = {
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
 
-  try {
-    this.context.startAbility(want, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('startAbility failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('startAbility succeed');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbility failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbility(want, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('startAbility succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbility failed failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbility
@@ -124,29 +125,29 @@ startAbility(want: Want, options: StartOptions, callback: AsyncCallback<void&
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
-  let options = {
-    windowMode: 0
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let options = {
+  windowMode: 0
+};
 
-  try {
-    this.context.startAbility(want, options, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('startAbility failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('startAbility succeed');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbility failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbility(want, options, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('startAbility succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbility failed failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbility
@@ -196,28 +197,28 @@ startAbility(want: Want, options?: StartOptions): Promise<void>;
 **示例：**
 
   ```ts
-  let want = {
-    bundleName: 'com.example.myapp',
-    abilityName: 'MyAbility'
-  };
-  let options = {
-    windowMode: 0,
-  };
+let want = {
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let options = {
+  windowMode: 0,
+};
 
-  try {
-    this.context.startAbility(want, options)
-      .then(() => {
-        // 执行正常业务
-        console.log('startAbility succeed');
-      })
-      .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('startAbility failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-      });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbility failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbility(want, options)
+    .then(() => {
+      // 执行正常业务
+      console.info('startAbility succeed');
+    })
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+    });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbilityForResult
@@ -264,26 +265,26 @@ startAbilityForResult(want: Want, callback: AsyncCallback<AbilityResult>):
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
 
-  try {
-    this.context.startAbilityForResult(want, (error, result) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('startAbilityForResult failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('startAbilityForResult succeed, result.resultCode = ${result.resultCode}');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbilityForResult failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbilityForResult(want, (err, result) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('startAbilityForResult succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbilityForResult
@@ -292,8 +293,8 @@ startAbilityForResult(want: Want, options: StartOptions, callback: AsyncCallback
 
 启动一个Ability。Ability被启动后，有如下情况(callback形式):
  - 正常情况下可通过调用[terminateSelfWithResult](#uiabilitycontextterminateselfwithresult)接口使之终止并且返回结果给调用方。
- - 异常情况下比如杀死Ability会返回异常信息给调用方, 异常信息中resultCode为-1。
- - 如果被启动的Ability模式是单实例模式, 不同应用多次调用该接口启动这个Ability，当这个Ability调用[terminateSelfWithResult](#uiabilitycontextterminateselfwithresult)接口使之终止时，只将正常结果返回给最后一个调用方, 其它调用方返回异常信息, 异常信息中resultCode为-1。
+ - 异常情况下比如杀死Ability会返回异常信息给调用方，异常信息中resultCode为-1。
+ - 如果被启动的Ability模式是单实例模式, 不同应用多次调用该接口启动这个Ability，当这个Ability调用[terminateSelfWithResult](#uiabilitycontextterminateselfwithresult)接口使之终止时，只将正常结果返回给最后一个调用方，其它调用方返回异常信息, 异常信息中resultCode为-1。
 
 使用规则：
  - 调用方应用位于后台时，使用该接口启动Ability需申请`ohos.permission.START_ABILITIES_FROM_BACKGROUND`权限
@@ -331,29 +332,29 @@ startAbilityForResult(want: Want, options: StartOptions, callback: AsyncCallback
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
-  let options = {
-    windowMode: 0,
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let options = {
+  windowMode: 0,
+};
 
-  try {
-    this.context.startAbilityForResult(want, options, (error, result) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('startAbilityForResult failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('startAbilityForResult succeed, result.resultCode = ${result.resultCode}');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbilityForResult failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbilityForResult(want, options, (err, result) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('startAbilityForResult succeed');
+  });
+} catch (paramError) {
+  // 处理入参错误异常
+  console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -409,26 +410,26 @@ startAbilityForResult(want: Want, options?: StartOptions): Promise<AbilityRes
 
   ```ts
 let want = {
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
 };
 let options = {
-    windowMode: 0,
+  windowMode: 0,
 };
 
 try {
-    this.context.startAbilityForResult(want, options)
-        .then((result) => {
-        // 执行正常业务
-        console.log('startAbilityForResult succeed, result.resultCode = ${result.resultCode}');
+  this.context.startAbilityForResult(want, options)
+    .then((result) => {
+      // 执行正常业务
+      console.info('startAbilityForResult succeed');
     })
-        .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('startAbilityForResult failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
     });
-} catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbilityForResult failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
 }
   ```
 
@@ -478,27 +479,27 @@ startAbilityForResultWithAccount(want: Want, accountId: number, callback: AsyncC
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let accountId = 100;
 
-  try {
-    this.context.startAbilityForResultWithAccount(want, accountId, (error, result) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('startAbilityForResultWithAccount failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('startAbilityForResultWithAccount succeed, result.resultCode = ${result.resultCode}, result.want = ${JSON.stringify(result.want)}');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbilityForResultWithAccount failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbilityForResultWithAccount(want, accountId, (err, result) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('startAbilityForResultWithAccount succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -549,30 +550,30 @@ startAbilityForResultWithAccount(want: Want, accountId: number, options: StartOp
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
-  let options = {
-    windowMode: 0
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let accountId = 100;
+let options = {
+  windowMode: 0
+};
 
-  try {
-    this.context.startAbilityForResultWithAccount(want, accountId, options, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('startAbilityForResultWithAccount failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('startAbilityForResultWithAccount succeed');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbilityForResultWithAccount failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbilityForResultWithAccount(want, accountId, options, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('startAbilityForResultWithAccount succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -628,30 +629,30 @@ startAbilityForResultWithAccount(want: Want, accountId: number, options?: StartO
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
-  let options = {
-    windowMode: 0
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let accountId = 100;
+let options = {
+  windowMode: 0
+};
 
-  try {
-    this.context.startAbilityForResultWithAccount(want, accountId, options)
-      .then((result) => {
-        // 执行正常业务
-        console.log('startAbilityForResultWithAccount succeed, result.resultCode = ${result.resultCode}');
-      })
-      .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('startAbilityForResultWithAccount failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-      });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbilityForResultWithAccount failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbilityForResultWithAccount(want, accountId, options)
+    .then((result) => {
+      // 执行正常业务
+      console.info('startAbilityForResultWithAccount succeed');
+    })
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
+    });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 ## UIAbilityContext.startServiceExtensionAbility
 
@@ -686,26 +687,26 @@ startServiceExtensionAbility(want: Want, callback: AsyncCallback\<void>): void;
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'ServiceExtensionAbility'
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'ServiceExtensionAbility'
+};
 
-  try {
-    this.context.startServiceExtensionAbility(want, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('startServiceExtensionAbility failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
+try {
+  this.context.startServiceExtensionAbility(want)
+    .then(() => {
       // 执行正常业务
-      console.log('startServiceExtensionAbility succeed');
+      console.info('startServiceExtensionAbility succeed');
+    })
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`startServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
     });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startServiceExtensionAbility failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startServiceExtensionAbility
@@ -740,26 +741,26 @@ startServiceExtensionAbility(want: Want): Promise\<void>;
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'ServiceExtensionAbility'
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'ServiceExtensionAbility'
+};
 
-  try {
-    this.context.startServiceExtensionAbility(want)
-      .then(() => {
-        // 执行正常业务
-        console.log('startServiceExtensionAbility succeed');
-      })
-      .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('startServiceExtensionAbility failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-      });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startServiceExtensionAbility failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startServiceExtensionAbility(want)
+    .then(() => {
+      // 执行正常业务
+      console.info('startServiceExtensionAbility succeed');
+    })
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`startServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+    });
+} catch (paramError) {
+  // 处理入参错误异常
+  console.error(`startServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startServiceExtensionAbilityWithAccount
@@ -798,27 +799,27 @@ startServiceExtensionAbilityWithAccount(want: Want, accountId: number, callback:
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'ServiceExtensionAbility'
-  };
-  let accountId = 100;
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'ServiceExtensionAbility'
+};
+let accountId = 100;
 
-  try {
-    this.context.startServiceExtensionAbilityWithAccount(want, accountId, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('startServiceExtensionAbilityWithAccount failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('startServiceExtensionAbilityWithAccount succeed');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startServiceExtensionAbilityWithAccount failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startServiceExtensionAbilityWithAccount(want, accountId, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`startServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('startServiceExtensionAbilityWithAccount succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startServiceExtensionAbilityWithAccount
@@ -856,27 +857,27 @@ startServiceExtensionAbilityWithAccount(want: Want, accountId: number): Promise\
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'ServiceExtensionAbility'
-  };
-  let accountId = 100;
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'ServiceExtensionAbility'
+};
+let accountId = 100;
 
-  try {
-    this.context.startServiceExtensionAbilityWithAccount(want, accountId)
-      .then(() => {
-        // 执行正常业务
-        console.log('startServiceExtensionAbilityWithAccount succeed');
-      })
-      .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('startServiceExtensionAbilityWithAccount failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-      });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startServiceExtensionAbilityWithAccount failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startServiceExtensionAbilityWithAccount(want, accountId)
+    .then(() => {
+      // 执行正常业务
+      console.info('startServiceExtensionAbilityWithAccount succeed');
+    })
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`startServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+    });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 ## UIAbilityContext.stopServiceExtensionAbility
 
@@ -910,26 +911,26 @@ stopServiceExtensionAbility(want: Want, callback: AsyncCallback\<void>): void;
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'ServiceExtensionAbility'
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'ServiceExtensionAbility'
+};
 
-  try {
-    this.context.stopServiceExtensionAbility(want, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('stopServiceExtensionAbility failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('stopServiceExtensionAbility succeed');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('stopServiceExtensionAbility failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.stopServiceExtensionAbility(want, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`stopServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('stopServiceExtensionAbility succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`stopServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.stopServiceExtensionAbility
@@ -963,26 +964,26 @@ stopServiceExtensionAbility(want: Want): Promise\<void>;
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'ServiceExtensionAbility'
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'ServiceExtensionAbility'
+};
 
-  try {
-    this.context.stopServiceExtensionAbility(want)
-      .then(() => {
-        // 执行正常业务
-        console.log('stopServiceExtensionAbility succeed');
-      })
-      .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('stopServiceExtensionAbility failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-      });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('stopServiceExtensionAbility failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.stopServiceExtensionAbility(want)
+    .then(() => {
+      // 执行正常业务
+      console.info('stopServiceExtensionAbility succeed');
+    })
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`stopServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+    });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`stopServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.stopServiceExtensionAbilityWithAccount
@@ -1020,27 +1021,27 @@ stopServiceExtensionAbilityWithAccount(want: Want, accountId: number, callback:
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'ServiceExtensionAbility'
-  };
-  let accountId = 100;
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'ServiceExtensionAbility'
+};
+let accountId = 100;
 
-  try {
-    this.context.stopServiceExtensionAbilityWithAccount(want, accountId, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('stopServiceExtensionAbilityWithAccount failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('stopServiceExtensionAbilityWithAccount succeed');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('stopServiceExtensionAbilityWithAccount failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.stopServiceExtensionAbilityWithAccount(want, accountId, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`stopServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('stopServiceExtensionAbilityWithAccount succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`stopServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.stopServiceExtensionAbilityWithAccount
@@ -1077,27 +1078,27 @@ stopServiceExtensionAbilityWithAccount(want: Want, accountId: number): Promise\<
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'ServiceExtensionAbility'
-  };
-  let accountId = 100;
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'ServiceExtensionAbility'
+};
+let accountId = 100;
 
-  try {
-    this.context.stopServiceExtensionAbilityWithAccount(want, accountId)
-      .then(() => {
-        // 执行正常业务
-        console.log('stopServiceExtensionAbilityWithAccount succeed');
-      })
-      .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('stopServiceExtensionAbilityWithAccount failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-      });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('stopServiceExtensionAbilityWithAccount failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.stopServiceExtensionAbilityWithAccount(want, accountId)
+    .then(() => {
+      // 执行正常业务
+      console.info('stopServiceExtensionAbilityWithAccount succeed');
+    })
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`stopServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+    });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`stopServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.terminateSelf
@@ -1129,18 +1130,18 @@ terminateSelf(callback: AsyncCallback&lt;void&gt;): void;
 
   ```ts
   try {
-    this.context.terminateSelf((error) => {
-      if (error.code) {
+    this.context.terminateSelf((err) => {
+      if (err.code) {
         // 处理业务逻辑错误
-        console.log('terminateSelf failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
+        console.error(`terminateSelf failed, code is ${err.code}, message is ${err.message}`);
         return;
       }
       // 执行正常业务
-      console.log('terminateSelf succeed');
+      console.info('terminateSelf succeed');
     });
-  } catch (error) {
+  } catch (err) {
     // 捕获同步的参数错误
-    console.log('terminateSelf failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
+    console.error(`terminateSelf failed, code is ${err.code}, message is ${err.message}`);
   }
   ```
 
@@ -1177,15 +1178,15 @@ terminateSelf(): Promise&lt;void&gt;;
     this.context.terminateSelf()
       .then(() => {
         // 执行正常业务
-        console.log('terminateSelf succeed');
+        console.info('terminateSelf succeed');
       })
-      .catch((error) => {
+      .catch((err) => {
         // 处理业务逻辑错误
-        console.log('terminateSelf failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
+        console.error(`terminateSelf failed, code is ${err.code}, message is ${err.message}`);
       });
   } catch (error) {
     // 捕获同步的参数错误
-    console.log('terminateSelf failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
+    console.error(`terminateSelf failed, code is ${err.code}, message is ${err.message}`);
   }
   ```
 
@@ -1219,31 +1220,31 @@ terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback&lt;voi
 **示例：**
 
   ```ts
-  let want = {
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
-  let resultCode = 100;
-  // 返回给接口调用方AbilityResult信息
-  let abilityResult = {
-    want,
-    resultCode
-  };
+let want = {
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let resultCode = 100;
+// 返回给接口调用方AbilityResult信息
+let abilityResult = {
+  want,
+  resultCode
+};
 
-  try {
-    this.context.terminateSelfWithResult(abilityResult, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('terminateSelfWithResult failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('terminateSelfWithResult succeed');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('terminateSelfWithResult failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.terminateSelfWithResult(abilityResult, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`terminateSelfWithResult failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('terminateSelfWithResult succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`terminateSelfWithResult failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -1281,31 +1282,31 @@ terminateSelfWithResult(parameter: AbilityResult): Promise&lt;void&gt;;
 **示例：**
 
   ```ts
-  let want = {
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
-  let resultCode = 100;
-  // 返回给接口调用方AbilityResult信息
-  let abilityResult = {
-    want,
-    resultCode
-  };
+let want = {
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let resultCode = 100;
+// 返回给接口调用方AbilityResult信息
+let abilityResult = {
+  want,
+  resultCode
+};
 
-  try {
-    this.context.terminateSelfWithResult(abilityResult)
-      .then(() => {
-        // 执行正常业务
-        console.log('terminateSelfWithResult succeed');
-      })
-      .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('terminateSelfWithResult failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-      });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('terminateSelfWithResult failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.terminateSelfWithResult(abilityResult)
+    .then(() => {
+      // 执行正常业务
+      console.info('terminateSelfWithResult succeed');
+    })
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`terminateSelfWithResult failed, code is ${err.code}, message is ${err.message}`);
+    });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`terminateSelfWithResult failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.connectServiceExtensionAbility
@@ -1341,30 +1342,30 @@ connectServiceExtensionAbility(want: Want, options: ConnectOptions): number;
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'ServiceExtensionAbility'
-  };
-  let options = {
-    onConnect(elementName, remote) {
-      console.log('----------- onConnect -----------')
-    },
-    onDisconnect(elementName) {
-      console.log('----------- onDisconnect -----------')
-    },
-    onFailed(code) {
-      console.log('----------- onFailed -----------')
-    }
-  };
-
-  let connection = null;
-  try {
-    connection = this.context.connectServiceExtensionAbility(want, options);
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'ServiceExtensionAbility'
+};
+let options = {
+  onConnect(elementName, remote) {
+    console.info('onConnect...')
+  },
+  onDisconnect(elementName) {
+    console.info('onDisconnect...')
+  },
+  onFailed(code) {
+    console.info('onFailed...')
   }
+};
+
+let connection = null;
+try {
+  connection = this.context.connectServiceExtensionAbility(want, options);
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`connectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -1406,31 +1407,31 @@ connectServiceExtensionAbilityWithAccount(want: Want, accountId: number, options
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'ServiceExtensionAbility'
-  };
-  let accountId = 100;
-  let options = {
-    onConnect(elementName, remote) {
-      console.log('----------- onConnect -----------')
-    },
-    onDisconnect(elementName) {
-      console.log('----------- onDisconnect -----------')
-    },
-    onFailed(code) {
-      console.log('----------- onFailed -----------')
-    }
-  };
-
-  let connection = null;
-  try {
-    connection = this.context.connectServiceExtensionAbilityWithAccount(want, accountId, options);
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'ServiceExtensionAbility'
+};
+let accountId = 100;
+let options = {
+  onConnect(elementName, remote) {
+    console.info('onConnect...')
+  },
+  onDisconnect(elementName) {
+    console.info('onDisconnect...')
+  },
+  onFailed(code) {
+    console.info('onFailed...')
   }
+};
+
+let connection = null;
+try {
+  connection = this.context.connectServiceExtensionAbilityWithAccount(want, accountId, options);
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`connectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.disconnectServiceExtensionAbility
@@ -1465,23 +1466,23 @@ disconnectServiceExtensionAbility(connection: number): Promise\<void>;
 **示例：**
 
   ```ts
-  // connection为connectServiceExtensionAbility中的返回值
-  let connection = 1;
+// connection为connectServiceExtensionAbility中的返回值
+let connection = 1;
 
-  try {
-    this.context.disconnectServiceExtensionAbility(connection)
-      .then(() => {
-        // 执行正常业务
-        console.log('disconnectServiceExtensionAbility succeed');
-      })
-      .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('disconnectServiceExtensionAbility failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-      });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.disconnectServiceExtensionAbility(connection, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`disconnectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('disconnectServiceExtensionAbility succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`disconnectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.disconnectServiceExtensionAbility
@@ -1511,23 +1512,23 @@ disconnectServiceExtensionAbility(connection: number, callback:AsyncCallback\<vo
 **示例：**
 
   ```ts
-  // connection为connectServiceExtensionAbility中的返回值
-  let connection = 1;
+// connection为connectServiceExtensionAbility中的返回值
+let connection = 1;
 
-  try {
-    this.context.disconnectServiceExtensionAbility(connection, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('disconnectServiceExtensionAbility failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('disconnectServiceExtensionAbility succeed');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.disconnectServiceExtensionAbility(connection, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`disconnectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('disconnectServiceExtensionAbility succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`disconnectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbilityByCall
@@ -1578,62 +1579,62 @@ startAbilityByCall(want: Want): Promise&lt;Caller&gt;;
   后台启动：
 
   ```ts
-  let caller;
-
-  // 后台启动Ability，不配置parameters
-  let wantBackground = {
-    bundleName: 'com.example.myservice',
-    moduleName: 'entry',
-    abilityName: 'EntryAbility',
-    deviceId: ''
-  };
+let caller;
+
+// 后台启动Ability，不配置parameters
+let wantBackground = {
+  bundleName: 'com.example.myapplication',
+  moduleName: 'entry',
+  abilityName: 'EntryAbility',
+  deviceId: ''
+};
 
-  try {
-    this.context.startAbilityByCall(wantBackground)
-      .then((obj) => {
-        // 执行正常业务
-        caller = obj;
-        console.log('startAbilityByCall succeed');
-      }).catch((error) => {
-      // 处理业务逻辑错误
-      console.log('startAbilityByCall failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbilityByCall(wantBackground)
+    .then((obj) => {
+      // 执行正常业务
+      caller = obj;
+      console.info('startAbilityByCall succeed');
+    }).catch((err) => {
+    // 处理业务逻辑错误
+    console.error(`startAbilityByCall failed, code is ${err.code}, message is ${err.message}`);
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbilityByCall failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
-  前台启动：
+前台启动：
 
   ```ts
-  let caller;
-
-  // 前台启动Ability，将parameters中的'ohos.aafwk.param.callAbilityToForeground'配置为true
-  let wantForeground = {
-    bundleName: 'com.example.myservice',
-    moduleName: 'entry',
-    abilityName: 'EntryAbility',
-    deviceId: '',
-    parameters: {
-      'ohos.aafwk.param.callAbilityToForeground': true
-    }
-  };
-
-  try {
-    this.context.startAbilityByCall(wantForeground)
-      .then((obj) => {
-        // 执行正常业务
-        caller = obj;
-        console.log('startAbilityByCall succeed');
-      }).catch((error) => {
-      // 处理业务逻辑错误
-      console.log('startAbilityByCall failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
+let caller;
+
+// 前台启动Ability，将parameters中的'ohos.aafwk.param.callAbilityToForeground'配置为true
+let wantForeground = {
+  bundleName: 'com.example.myapplication',
+  moduleName: 'entry',
+  abilityName: 'EntryAbility',
+  deviceId: '',
+  parameters: {
+    'ohos.aafwk.param.callAbilityToForeground': true
   }
+};
+
+try {
+  this.context.startAbilityByCall(wantForeground)
+    .then((obj) => {
+      // 执行正常业务
+      caller = obj;
+      console.info('startAbilityByCall succeed');
+    }).catch((error) => {
+    // 处理业务逻辑错误
+    console.error(`startAbilityByCall failed, code is ${err.code}, message is ${err.message}`);
+  });
+} catch (paramError) {
+  // 处理入参错误异常
+  console.error(`startAbilityByCall failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbilityWithAccount
@@ -1682,27 +1683,27 @@ startAbilityWithAccount(want: Want, accountId: number, callback: AsyncCallback\<
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let accountId = 100;
 
-  try {
-    this.context.startAbilityWithAccount(want, accountId, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('startAbilityWithAccount failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('startAbilityWithAccount succeed');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbilityWithAccount(want, accountId, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('startAbilityWithAccount succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -1753,30 +1754,30 @@ startAbilityWithAccount(want: Want, accountId: number, options: StartOptions, ca
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
-  let options = {
-    windowMode: 0
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let accountId = 100;
+let options = {
+  windowMode: 0
+};
 
-  try {
-    this.context.startAbilityWithAccount(want, accountId, options, (error) => {
-      if (error.code) {
-        // 处理业务逻辑错误
-        console.log('startAbilityWithAccount failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('startAbilityWithAccount succeed');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbilityWithAccount failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbilityWithAccount(want, accountId, options, (err) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('startAbilityWithAccount succeed');
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -1826,37 +1827,37 @@ startAbilityWithAccount(want: Want, accountId: number, options?: StartOptions):
 **示例：**
 
   ```ts
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
-  let options = {
-    windowMode: 0
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let accountId = 100;
+let options = {
+  windowMode: 0
+};
 
-  try {
-    this.context.startAbilityWithAccount(want, accountId, options)
-      .then(() => {
-        // 执行正常业务
-        console.log('startAbilityWithAccount succeed');
-      })
-      .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('startAbilityWithAccount failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-      });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('startAbilityWithAccount failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.startAbilityWithAccount(want, accountId, options)
+    .then(() => {
+      // 执行正常业务
+      console.info('startAbilityWithAccount succeed');
+    })
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+    });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.setMissionLabel
 
 setMissionLabel(label: string, callback:AsyncCallback&lt;void&gt;): void;
 
-设置ability在任务中显示的名称（callback形式）。
+设置UIAbility在任务中显示的名称（callback形式）。
 
 **系统能力**：SystemCapability.Ability.AbilityRuntime.Core
 
@@ -1871,7 +1872,7 @@ setMissionLabel(label: string, callback:AsyncCallback&lt;void&gt;): void;
 
   ```ts
   this.context.setMissionLabel('test', (result) => {
-    console.log('setMissionLabel:${JSON.stringify(result)}');
+    console.info(`setMissionLabel: ${JSON.stringify(result)}`);
   });
   ```
 
@@ -1879,7 +1880,7 @@ setMissionLabel(label: string, callback:AsyncCallback&lt;void&gt;): void;
 
 setMissionLabel(label: string): Promise&lt;void&gt;;
 
-设置ability在任务中显示的名称（promise形式）。
+设置UIAbility在任务中显示的名称（promise形式）。
 
 **系统能力**：SystemCapability.Ability.AbilityRuntime.Core
 
@@ -1906,9 +1907,9 @@ setMissionLabel(label: string): Promise&lt;void&gt;;
 
   ```ts
   this.context.setMissionLabel('test').then(() => {
-    console.log('success');
-  }).catch((error) => {
-    console.log('failed:${JSON.stringify(error)}');
+    console.info('success');
+  }).catch((err) => {
+    console.error(`setMissionLabel failed, code is ${err.code}, message is ${err.message}`);
   });
   ```
 ## UIAbilityContext.setMissionIcon
@@ -1939,6 +1940,7 @@ setMissionIcon(icon: image.PixelMap, callback:AsyncCallback\<void>): void;
 
   ```ts
   import image from '@ohos.multimedia.image';
+  
   let imagePixelMap;
   let color = new ArrayBuffer(0);
   let initializationOptions = {
@@ -1952,10 +1954,10 @@ setMissionIcon(icon: image.PixelMap, callback:AsyncCallback\<void>): void;
       imagePixelMap = data;
     })
     .catch((err) => {
-      console.log('--------- createPixelMap fail, err: ---------', err);
+      console.error(`createPixelMap failed, code is ${err.code}, message is ${err.message}`);
     });
   this.context.setMissionIcon(imagePixelMap, (err) => {
-    console.log('---------- setMissionIcon fail, err: -----------', err);
+    console.error(`setMissionLabel failed, code is ${err.code}, message is ${err.message}`);
   })
   ```
 
@@ -2005,21 +2007,21 @@ setMissionIcon(icon: image.PixelMap): Promise\<void>;
       imagePixelMap = data;
     })
     .catch((err) => {
-      console.log('--------- createPixelMap fail, err: ---------', err);
+      console.error(`createPixelMap failed, code is ${err.code}, message is ${err.message}`);
     });
   this.context.setMissionIcon(imagePixelMap)
     .then(() => {
-      console.log('-------------- setMissionIcon success -------------');
+      console.info('setMissionIcon succeed');
     })
     .catch((err) => {
-      console.log('-------------- setMissionIcon fail, err: -------------', err);
+      console.error(`setMissionLabel failed, code is ${err.code}, message is ${err.message}`);
     });
   ```
 ## UIAbilityContext.restoreWindowStage
 
 restoreWindowStage(localStorage: LocalStorage) : void;
 
-恢复ability中的window stage数据。
+恢复UIAbility中的WindowStage数据。
 
 **系统能力**：SystemCapability.Ability.AbilityRuntime.Core
 
@@ -2047,7 +2049,7 @@ restoreWindowStage(localStorage: LocalStorage) : void;
 
 isTerminating(): boolean;
 
-查询ability是否在terminating状态。
+查询UIAbility是否在terminating状态。
 
 **系统能力**：SystemCapability.Ability.AbilityRuntime.Core
 
@@ -2068,7 +2070,7 @@ isTerminating(): boolean;
 
   ```ts
   let isTerminating = this.context.isTerminating();
-  console.log('ability state :${isTerminating}');
+  console.info(`ability state is ${isTerminating}`);
   ```
 
 ## UIAbilityContext.requestDialogService
@@ -2094,28 +2096,28 @@ requestDialogService(want: Want, result: AsyncCallback&lt;dialogRequest.RequestR
 **示例：**
 
   ```ts
-  import dialogRequest from '@ohos.app.ability.dialogRequest';
+import dialogRequest from '@ohos.app.ability.dialogRequest';
 
-  let want = {
-    deviceId: '',
-    bundleName: 'com.example.myapplication',
-    abilityName: 'AuthAccountServiceExtension'
-  };
+let want = {
+  deviceId: '',
+  bundleName: 'com.example.myapplication',
+  abilityName: 'AuthAccountServiceExtension'
+};
 
-  try {
-    this.context.requestDialogService(want, (error, result) => {
-      if (error && error.code) {
-        // 处理业务逻辑错误
-        console.log('requestDialogService failed, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
-        return;
-      }
-      // 执行正常业务
-      console.log('requestDialogService succeed, result = ${JSON.stringify(result)}');
-    });
-  } catch (paramError) {
-    // 处理入参错误异常
-    console.log('requestDialogService failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
-  }
+try {
+  this.context.requestDialogService(want, (err, result) => {
+    if (err.code) {
+      // 处理业务逻辑错误
+      console.error(`requestDialogService failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('requestDialogService succeed, result = ' + JSON.stringify(result));
+  });
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`requestDialogService failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
   ## UIAbilityContext.requestDialogService
@@ -2150,22 +2152,22 @@ requestDialogService(want: Want): Promise&lt;dialogRequest.RequestResult&gt;;
 import dialogRequest from '@ohos.app.ability.dialogRequest';
 
 let want = {
-    bundleName: 'com.example.myapplication',
-    abilityName: 'AuthAccountServiceExtension'
+  bundleName: 'com.example.myapplication',
+  abilityName: 'AuthAccountServiceExtension'
 };
 
 try {
-    this.context.requestDialogService(want)
-        .then((result) => {
-        // 执行正常业务
-        console.log('requestDialogService succeed, result = ${JSON.stringify(result)}');
+  this.context.requestDialogService(want)
+    .then((result) => {
+      // 执行正常业务
+      console.info('requestDialogService succeed, result = ' + JSON.stringify(result));
     })
-        .catch((error) => {
-        // 处理业务逻辑错误
-        console.log('requestDialogService failed, error= ${JSON.stringify(error)}');
+    .catch((err) => {
+      // 处理业务逻辑错误
+      console.error(`requestDialogService failed, code is ${err.code}, message is ${err.message}`);
     });
-} catch (paramError) {
-    // 处理入参错误异常
-    console.log('requestDialogService failed, error.code: ${JSON.stringify(paramError.code)}, error.message: ${JSON.stringify(paramError.message)}');
+} catch (err) {
+  // 处理入参错误异常
+  console.error(`requestDialogService failed, code is ${err.code}, message is ${err.message}`);
 }
   ```

zh-cn/application-dev/windowmanager/application-window-stage.md

@@ -51,7 +51,7 @@
 
 ## 设置应用主窗口
 
-在`Stage`模型下，应用主窗口由`Ability`创建并维护生命周期。在`Ability`的`onWindowStageCreate`回调中，通过`WindowStage`获取应用主窗口，即可对其进行属性设置等操作。
+在`Stage`模型下，应用主窗口由`UIAbility`创建并维护生命周期。在`UIAbility`的`onWindowStageCreate`回调中，通过`WindowStage`获取应用主窗口，即可对其进行属性设置等操作。
 
 
 ### 开发步骤