!14833...

!14833 1）优化errorManager部分示例代码。2）窗口指南的Ability修改为UIAbility。3）“获取UIAbility的Context属性”修改为：“获取UIAbility的上下文信息”；4）优化globalThis作用范围描述；5）新增应用级别状态管理子章节。
Merge pull request !14833 from zyjhandsome/master

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,7 +31,7 @@ import Want from '@ohos.app.ability.Want';
 
 **示例：**
 
-- 基础用法（在UIAbility对象中调用，其中示例中的context为UIAbility的上下文对象）。
+- 基础用法：在UIAbility对象中调用，示例中的context的获取方式请参见[获取UIAbility的上下文信息](../../application-models/uiability-usage.md#获取uiability的上下文信息)。
 
   ```ts
   let want = {
@@ -40,13 +40,14 @@ import Want from '@ohos.app.ability.Want';
     'abilityName': 'FuncAbility',
     'moduleName': 'entry' // moduleName非必选
   };
-    this.context.startAbility(want, (error) => {
+  
+  this.context.startAbility(want, (err) => {
     // 显式拉起Ability，通过bundleName、abilityName和moduleName可以唯一确定一个Ability
-        console.log('error.code = ' + error.code);
+    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
@@ -57,6 +58,10 @@ import Want from '@ohos.app.ability.Want';
             keyForString: 'str',
           },
         };
+        
+        this.context.startAbility(want, (err) => {
+          console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+        });
         ```
     * 数字（Number）
         ```ts
@@ -68,6 +73,10 @@ import Want from '@ohos.app.ability.Want';
             keyForDouble: 99.99,
           },
         };
+        
+        this.context.startAbility(want, (err) => {
+          console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+        });
         ```
     * 布尔（Boolean）
         ```ts
@@ -78,6 +87,10 @@ import Want from '@ohos.app.ability.Want';
             keyForBool: true,
           },
         };
+        
+        this.context.startAbility(want, (err) => {
+          console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+        });
         ```
     * 对象（Object）
         ```ts
@@ -93,6 +106,10 @@ import Want from '@ohos.app.ability.Want';
             },
           },
         };
+        
+        this.context.startAbility(want, (err) => {
+          console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+        });
         ```
     * 数组（Array）
         ```ts
@@ -103,17 +120,22 @@ import Want from '@ohos.app.ability.Want';
             keyForArrayString: ['str1', 'str2', 'str3'],
             keyForArrayInt: [100, 200, 300, 400],
             keyForArrayDouble: [0.1, 0.2],
-                keyForArrayObject: [{obj1: 'aaa'}, {obj2: 100}],
+            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');
-        } catch(e) {
+        } catch (e) {
           console.log('openSync fail:' + JSON.stringify(e));
         }
         let want = {
@@ -122,16 +144,12 @@ import Want from '@ohos.app.ability.Want';
           'abilityName': 'FuncAbility',
           'moduleName': 'entry', // moduleName非必选
           'parameters': {
-                'keyFd':{'type':'FD', 'value':fd} // {'type':'FD', 'value':fd}是固定用法，用于表示该数据是FD
+            '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

@@ -29,8 +29,7 @@ let observer = {
 
 try {
   errorManager.on('error', observer);
-} catch (error) {
-    console.log('registerErrorObserver' + ' failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+} catch (err) {
+  console.log(`registerErrorObserver failed, code is ${err.code}, message is ${err.message}`);
 }
 ```

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,27 +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) {
+try {
+  this.context.startAbility(want, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('startAbility failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('startAbility succeed');
+    console.info('startAbility succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startAbility failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbility failed failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbility
@@ -126,31 +125,29 @@ startAbility(want: Want, options: StartOptions, callback: AsyncCallback<void&
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
-  let options = {
+};
+let options = {
   windowMode: 0
-  };
+};
 
-  try {
-    this.context.startAbility(want, options, (error) => {
-      if (error.code) {
+try {
+  this.context.startAbility(want, options, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('startAbility failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('startAbility succeed');
+    console.info('startAbility succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startAbility failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbility failed failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbility
@@ -200,30 +197,28 @@ startAbility(want: Want, options?: StartOptions): Promise<void>;
 **示例：**
 
   ```ts
-  let want = {
-    bundleName: 'com.example.myapp',
-    abilityName: 'MyAbility'
-  };
-  let options = {
+let want = {
+  bundleName: 'com.example.myapplication',
+  abilityName: 'EntryAbility'
+};
+let options = {
   windowMode: 0,
-  };
+};
 
-  try {
+try {
   this.context.startAbility(want, options)
     .then(() => {
       // 执行正常业务
-        console.log('startAbility succeed');
+      console.info('startAbility succeed');
     })
-      .catch((error) => {
+    .catch((err) => {
       // 处理业务逻辑错误
-        console.log('startAbility failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
     });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startAbility failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbilityForResult
@@ -270,28 +265,26 @@ startAbilityForResult(want: Want, callback: AsyncCallback<AbilityResult>):
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
+};
 
-  try {
-    this.context.startAbilityForResult(want, (error, result) => {
-      if (error.code) {
+try {
+  this.context.startAbilityForResult(want, (err, result) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('startAbilityForResult failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('startAbilityForResult succeed, result.resultCode = ' + result.resultCode)
+    console.info('startAbilityForResult succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startAbilityForResult failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbilityForResult
@@ -300,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`权限
@@ -339,31 +332,29 @@ startAbilityForResult(want: Want, options: StartOptions, callback: AsyncCallback
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
-  let options = {
+};
+let options = {
   windowMode: 0,
-  };
+};
 
-  try {
-    this.context.startAbilityForResult(want, options, (error, result) => {
-      if (error.code) {
+try {
+  this.context.startAbilityForResult(want, options, (err, result) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('startAbilityForResult failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('startAbilityForResult succeed, result.resultCode = ' + result.resultCode);
+    console.info('startAbilityForResult succeed');
   });
-  } catch (paramError) {
+} catch (paramError) {
   // 处理入参错误异常
-    console.log('startAbilityForResult failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -430,17 +421,15 @@ try {
   this.context.startAbilityForResult(want, options)
     .then((result) => {
       // 执行正常业务
-        console.log('startAbilityForResult succeed, result.resultCode = ' + result.resultCode);
+      console.info('startAbilityForResult succeed');
     })
-        .catch((error) => {
+    .catch((err) => {
       // 处理业务逻辑错误
-        console.log('startAbilityForResult failed, error.code: ' + JSON.stringify(error.code) +
-                    ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
     });
-} catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startAbilityForResult failed, error.code: ' + JSON.stringify(paramError.code) +
-                ' error.message: ' + JSON.stringify(paramError.message));
+  console.error(`startAbilityForResult failed, code is ${err.code}, message is ${err.message}`);
 }
   ```
 
@@ -490,30 +479,27 @@ startAbilityForResultWithAccount(want: Want, accountId: number, callback: AsyncC
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
+};
+let accountId = 100;
 
-  try {
-    this.context.startAbilityForResultWithAccount(want, accountId, (error, result) => {
-      if (error.code) {
+try {
+  this.context.startAbilityForResultWithAccount(want, accountId, (err, result) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('startAbilityForResultWithAccount failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('startAbilityForResultWithAccount succeed, result.resultCode = ' +
-      result.resultCode + ' result.want = ' + JSON.stringify(result.want));
+    console.info('startAbilityForResultWithAccount succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startAbilityForResultWithAccount failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -564,32 +550,30 @@ startAbilityForResultWithAccount(want: Want, accountId: number, options: StartOp
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
-  let options = {
+};
+let accountId = 100;
+let options = {
   windowMode: 0
-  };
+};
 
-  try {
-    this.context.startAbilityForResultWithAccount(want, accountId, options, (error) => {
-      if (error.code) {
+try {
+  this.context.startAbilityForResultWithAccount(want, accountId, options, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('startAbilityForResultWithAccount failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('startAbilityForResultWithAccount succeed');
+    console.info('startAbilityForResultWithAccount succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startAbilityForResultWithAccount failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -645,33 +629,30 @@ startAbilityForResultWithAccount(want: Want, accountId: number, options?: StartO
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
-  let options = {
+};
+let accountId = 100;
+let options = {
   windowMode: 0
-  };
+};
 
-  try {
+try {
   this.context.startAbilityForResultWithAccount(want, accountId, options)
     .then((result) => {
       // 执行正常业务
-        console.log('startAbilityForResultWithAccount succeed, result.resultCode = ' +
-        result.resultCode);
+      console.info('startAbilityForResultWithAccount succeed');
     })
-      .catch((error) => {
+    .catch((err) => {
       // 处理业务逻辑错误
-        console.log('startAbilityForResultWithAccount failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
     });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startAbilityForResultWithAccount failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbilityForResultWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 ## UIAbilityContext.startServiceExtensionAbility
 
@@ -706,28 +687,26 @@ startServiceExtensionAbility(want: Want, callback: AsyncCallback\<void>): void;
 **示例：**
 
   ```ts
-  let want = {
+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) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startServiceExtensionAbility failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startServiceExtensionAbility
@@ -762,28 +741,26 @@ startServiceExtensionAbility(want: Want): Promise\<void>;
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'ServiceExtensionAbility'
-  };
+};
 
-  try {
+try {
   this.context.startServiceExtensionAbility(want)
     .then(() => {
       // 执行正常业务
-        console.log('startServiceExtensionAbility succeed');
+      console.info('startServiceExtensionAbility succeed');
     })
-      .catch((error) => {
+    .catch((err) => {
       // 处理业务逻辑错误
-        console.log('startServiceExtensionAbility failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
     });
-  } catch (paramError) {
+} catch (paramError) {
   // 处理入参错误异常
-    console.log('startServiceExtensionAbility failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startServiceExtensionAbilityWithAccount
@@ -822,29 +799,27 @@ startServiceExtensionAbilityWithAccount(want: Want, accountId: number, callback:
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'ServiceExtensionAbility'
-  };
-  let accountId = 100;
+};
+let accountId = 100;
 
-  try {
-    this.context.startServiceExtensionAbilityWithAccount(want, accountId, (error) => {
-      if (error.code) {
+try {
+  this.context.startServiceExtensionAbilityWithAccount(want, accountId, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('startServiceExtensionAbilityWithAccount failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('startServiceExtensionAbilityWithAccount succeed');
+    console.info('startServiceExtensionAbilityWithAccount succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startServiceExtensionAbilityWithAccount failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startServiceExtensionAbilityWithAccount
@@ -882,29 +857,27 @@ startServiceExtensionAbilityWithAccount(want: Want, accountId: number): Promise\
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'ServiceExtensionAbility'
-  };
-  let accountId = 100;
+};
+let accountId = 100;
 
-  try {
+try {
   this.context.startServiceExtensionAbilityWithAccount(want, accountId)
     .then(() => {
       // 执行正常业务
-        console.log('startServiceExtensionAbilityWithAccount succeed');
+      console.info('startServiceExtensionAbilityWithAccount succeed');
     })
-      .catch((error) => {
+    .catch((err) => {
       // 处理业务逻辑错误
-        console.log('startServiceExtensionAbilityWithAccount failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
     });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startServiceExtensionAbilityWithAccount failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 ## UIAbilityContext.stopServiceExtensionAbility
 
@@ -938,28 +911,26 @@ stopServiceExtensionAbility(want: Want, callback: AsyncCallback\<void>): void;
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'ServiceExtensionAbility'
-  };
+};
 
-  try {
-    this.context.stopServiceExtensionAbility(want, (error) => {
-      if (error.code) {
+try {
+  this.context.stopServiceExtensionAbility(want, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('stopServiceExtensionAbility failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`stopServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('stopServiceExtensionAbility succeed');
+    console.info('stopServiceExtensionAbility succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('stopServiceExtensionAbility failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`stopServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.stopServiceExtensionAbility
@@ -993,28 +964,26 @@ stopServiceExtensionAbility(want: Want): Promise\<void>;
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'ServiceExtensionAbility'
-  };
+};
 
-  try {
+try {
   this.context.stopServiceExtensionAbility(want)
     .then(() => {
       // 执行正常业务
-        console.log('stopServiceExtensionAbility succeed');
+      console.info('stopServiceExtensionAbility succeed');
     })
-      .catch((error) => {
+    .catch((err) => {
       // 处理业务逻辑错误
-        console.log('stopServiceExtensionAbility failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`stopServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
     });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('stopServiceExtensionAbility failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`stopServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.stopServiceExtensionAbilityWithAccount
@@ -1052,29 +1021,27 @@ stopServiceExtensionAbilityWithAccount(want: Want, accountId: number, callback:
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'ServiceExtensionAbility'
-  };
-  let accountId = 100;
+};
+let accountId = 100;
 
-  try {
-    this.context.stopServiceExtensionAbilityWithAccount(want, accountId, (error) => {
-      if (error.code) {
+try {
+  this.context.stopServiceExtensionAbilityWithAccount(want, accountId, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('stopServiceExtensionAbilityWithAccount failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`stopServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('stopServiceExtensionAbilityWithAccount succeed');
+    console.info('stopServiceExtensionAbilityWithAccount succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('stopServiceExtensionAbilityWithAccount failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`stopServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.stopServiceExtensionAbilityWithAccount
@@ -1111,29 +1078,27 @@ stopServiceExtensionAbilityWithAccount(want: Want, accountId: number): Promise\<
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'ServiceExtensionAbility'
-  };
-  let accountId = 100;
+};
+let accountId = 100;
 
-  try {
+try {
   this.context.stopServiceExtensionAbilityWithAccount(want, accountId)
     .then(() => {
       // 执行正常业务
-        console.log('stopServiceExtensionAbilityWithAccount succeed');
+      console.info('stopServiceExtensionAbilityWithAccount succeed');
     })
-      .catch((error) => {
+    .catch((err) => {
       // 处理业务逻辑错误
-        console.log('stopServiceExtensionAbilityWithAccount failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`stopServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
     });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('stopServiceExtensionAbilityWithAccount failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`stopServiceExtensionAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.terminateSelf
@@ -1165,20 +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}`);
   }
   ```
 
@@ -1215,17 +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}`);
   }
   ```
 
@@ -1259,33 +1220,31 @@ terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback&lt;voi
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
-  let resultCode = 100;
-  // 返回给接口调用方AbilityResult信息
-  let abilityResult = {
+};
+let resultCode = 100;
+// 返回给接口调用方AbilityResult信息
+let abilityResult = {
   want,
   resultCode
-  };
+};
 
-  try {
-    this.context.terminateSelfWithResult(abilityResult, (error) => {
-      if (error.code) {
+try {
+  this.context.terminateSelfWithResult(abilityResult, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('terminateSelfWithResult failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`terminateSelfWithResult failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('terminateSelfWithResult succeed');
+    console.info('terminateSelfWithResult succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('terminateSelfWithResult failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`terminateSelfWithResult failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -1323,33 +1282,31 @@ terminateSelfWithResult(parameter: AbilityResult): Promise&lt;void&gt;;
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
-  let resultCode = 100;
-  // 返回给接口调用方AbilityResult信息
-  let abilityResult = {
+};
+let resultCode = 100;
+// 返回给接口调用方AbilityResult信息
+let abilityResult = {
   want,
   resultCode
-  };
+};
 
-  try {
+try {
   this.context.terminateSelfWithResult(abilityResult)
     .then(() => {
       // 执行正常业务
-        console.log('terminateSelfWithResult succeed');
+      console.info('terminateSelfWithResult succeed');
     })
-      .catch((error) => {
+    .catch((err) => {
       // 处理业务逻辑错误
-        console.log('terminateSelfWithResult failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`terminateSelfWithResult failed, code is ${err.code}, message is ${err.message}`);
     });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('terminateSelfWithResult failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`terminateSelfWithResult failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.connectServiceExtensionAbility
@@ -1385,31 +1342,30 @@ connectServiceExtensionAbility(want: Want, options: ConnectOptions): number;
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'ServiceExtensionAbility'
-  };
-  let options = {
+};
+let options = {
   onConnect(elementName, remote) {
-      console.log('----------- onConnect -----------')
+    console.info('onConnect...')
   },
   onDisconnect(elementName) {
-      console.log('----------- onDisconnect -----------')
+    console.info('onDisconnect...')
   },
   onFailed(code) {
-      console.log('----------- onFailed -----------')
+    console.info('onFailed...')
   }
-  };
+};
 
-  let connection = null;
-  try {
+let connection = null;
+try {
   connection = this.context.connectServiceExtensionAbility(want, options);
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`connectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -1451,32 +1407,31 @@ connectServiceExtensionAbilityWithAccount(want: Want, accountId: number, options
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'ServiceExtensionAbility'
-  };
-  let accountId = 100;
-  let options = {
+};
+let accountId = 100;
+let options = {
   onConnect(elementName, remote) {
-      console.log('----------- onConnect -----------')
+    console.info('onConnect...')
   },
   onDisconnect(elementName) {
-      console.log('----------- onDisconnect -----------')
+    console.info('onDisconnect...')
   },
   onFailed(code) {
-      console.log('----------- onFailed -----------')
+    console.info('onFailed...')
   }
-  };
+};
 
-  let connection = null;
-  try {
+let connection = null;
+try {
   connection = this.context.connectServiceExtensionAbilityWithAccount(want, accountId, options);
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`connectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.disconnectServiceExtensionAbility
@@ -1511,25 +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) => {
+try {
+  this.context.disconnectServiceExtensionAbility(connection, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('disconnectServiceExtensionAbility failed, error.code: ' + JSON.stringify(error.code) +
-          ' error.message: ' + JSON.stringify(error.message));
+      console.error(`disconnectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+      return;
+    }
+    // 执行正常业务
+    console.info('disconnectServiceExtensionAbility succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('error.code: ' + JSON.stringify(paramError.code) +
-      ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`disconnectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.disconnectServiceExtensionAbility
@@ -1559,25 +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) {
+try {
+  this.context.disconnectServiceExtensionAbility(connection, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('disconnectServiceExtensionAbility failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`disconnectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('disconnectServiceExtensionAbility succeed');
+    console.info('disconnectServiceExtensionAbility succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`disconnectServiceExtensionAbility failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbilityByCall
@@ -1628,66 +1579,62 @@ startAbilityByCall(want: Want): Promise&lt;Caller&gt;;
   后台启动：
 
   ```ts
-  let caller;
+let caller;
 
-  // 后台启动Ability，不配置parameters
-  let wantBackground = {
-    bundleName: 'com.example.myservice',
+// 后台启动Ability，不配置parameters
+let wantBackground = {
+  bundleName: 'com.example.myapplication',
   moduleName: 'entry',
   abilityName: 'EntryAbility',
   deviceId: ''
-  };
+};
 
-  try {
+try {
   this.context.startAbilityByCall(wantBackground)
     .then((obj) => {
       // 执行正常业务
       caller = obj;
-        console.log('startAbilityByCall succeed');
-      }).catch((error) => {
+      console.info('startAbilityByCall succeed');
+    }).catch((err) => {
     // 处理业务逻辑错误
-      console.log('startAbilityByCall failed, error.code: ' + JSON.stringify(error.code) +
-      ' error.message: ' + JSON.stringify(error.message));
+    console.error(`startAbilityByCall failed, code is ${err.code}, message is ${err.message}`);
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbilityByCall failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
-  前台启动：
+前台启动：
 
   ```ts
-  let caller;
+let caller;
 
-  // 前台启动Ability，将parameters中的'ohos.aafwk.param.callAbilityToForeground'配置为true
-  let wantForeground = {
-    bundleName: 'com.example.myservice',
+// 前台启动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 {
+try {
   this.context.startAbilityByCall(wantForeground)
     .then((obj) => {
       // 执行正常业务
       caller = obj;
-        console.log('startAbilityByCall succeed');
+      console.info('startAbilityByCall succeed');
     }).catch((error) => {
     // 处理业务逻辑错误
-      console.log('startAbilityByCall failed, error.code: ' + JSON.stringify(error.code) +
-      ' error.message: ' + JSON.stringify(error.message));
+    console.error(`startAbilityByCall failed, code is ${err.code}, message is ${err.message}`);
   });
-  } catch (paramError) {
+} catch (paramError) {
   // 处理入参错误异常
-    console.log('error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbilityByCall failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 ## UIAbilityContext.startAbilityWithAccount
@@ -1736,29 +1683,27 @@ startAbilityWithAccount(want: Want, accountId: number, callback: AsyncCallback\<
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
+};
+let accountId = 100;
 
-  try {
-    this.context.startAbilityWithAccount(want, accountId, (error) => {
-      if (error.code) {
+try {
+  this.context.startAbilityWithAccount(want, accountId, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('startAbilityWithAccount failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('startAbilityWithAccount succeed');
+    console.info('startAbilityWithAccount succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -1809,32 +1754,30 @@ startAbilityWithAccount(want: Want, accountId: number, options: StartOptions, ca
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
-  let options = {
+};
+let accountId = 100;
+let options = {
   windowMode: 0
-  };
+};
 
-  try {
-    this.context.startAbilityWithAccount(want, accountId, options, (error) => {
-      if (error.code) {
+try {
+  this.context.startAbilityWithAccount(want, accountId, options, (err) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('startAbilityWithAccount failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('startAbilityWithAccount succeed');
+    console.info('startAbilityWithAccount succeed');
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startAbilityWithAccount failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
 
@@ -1884,39 +1827,37 @@ startAbilityWithAccount(want: Want, accountId: number, options?: StartOptions):
 **示例：**
 
   ```ts
-  let want = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'EntryAbility'
-  };
-  let accountId = 100;
-  let options = {
+};
+let accountId = 100;
+let options = {
   windowMode: 0
-  };
+};
 
-  try {
+try {
   this.context.startAbilityWithAccount(want, accountId, options)
     .then(() => {
       // 执行正常业务
-        console.log('startAbilityWithAccount succeed');
+      console.info('startAbilityWithAccount succeed');
     })
-      .catch((error) => {
+    .catch((err) => {
       // 处理业务逻辑错误
-        console.log('startAbilityWithAccount failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`startAbilityWithAccount failed, code is ${err.code}, message is ${err.message}`);
     });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('startAbilityWithAccount failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  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
 
@@ -1931,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)}`);
   });
   ```
 
@@ -1939,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
 
@@ -1966,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
@@ -1999,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 = {
@@ -2012,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}`);
   })
   ```
 
@@ -2065,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
 
@@ -2107,7 +2049,7 @@ restoreWindowStage(localStorage: LocalStorage) : void;
 
 isTerminating(): boolean;
 
-查询ability是否在terminating状态。
+查询UIAbility是否在terminating状态。
 
 **系统能力**：SystemCapability.Ability.AbilityRuntime.Core
 
@@ -2128,7 +2070,7 @@ isTerminating(): boolean;
 
   ```ts
   let isTerminating = this.context.isTerminating();
-  console.log('ability state :' + isTerminating);
+  console.info(`ability state is ${isTerminating}`);
   ```
 
 ## UIAbilityContext.requestDialogService
@@ -2154,30 +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 = {
+let want = {
   deviceId: '',
   bundleName: 'com.example.myapplication',
   abilityName: 'AuthAccountServiceExtension'
-  };
+};
 
-  try {
-    this.context.requestDialogService(want, (error, result) => {
-      if (error && error.code) {
+try {
+  this.context.requestDialogService(want, (err, result) => {
+    if (err.code) {
       // 处理业务逻辑错误
-        console.log('requestDialogService failed, error.code: ' + JSON.stringify(error.code) +
-        ' error.message: ' + JSON.stringify(error.message));
+      console.error(`requestDialogService failed, code is ${err.code}, message is ${err.message}`);
       return;
     }
     // 执行正常业务
-      console.log('requestDialogService succeed, result = ' + JSON.stringify(result));
+    console.info('requestDialogService succeed, result = ' + JSON.stringify(result));
   });
-  } catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('requestDialogService failed, error.code: ' + JSON.stringify(paramError.code) +
-    ' error.message: ' + JSON.stringify(paramError.message));
-  }
+  console.error(`requestDialogService failed, code is ${err.code}, message is ${err.message}`);
+}
   ```
 
   ## UIAbilityContext.requestDialogService
@@ -2220,15 +2160,14 @@ try {
   this.context.requestDialogService(want)
     .then((result) => {
       // 执行正常业务
-        console.log('requestDialogService succeed, result = ' + JSON.stringify(result));
+      console.info('requestDialogService succeed, result = ' + JSON.stringify(result));
     })
-        .catch((error) => {
+    .catch((err) => {
       // 处理业务逻辑错误
-        console.log('requestDialogService failed, error= ' + JSON.stringify(error));
+      console.error(`requestDialogService failed, code is ${err.code}, message is ${err.message}`);
     });
-} catch (paramError) {
+} catch (err) {
   // 处理入参错误异常
-    console.log('requestDialogService failed, error.code: ' + JSON.stringify(paramError.code) +
-                ' error.message: ' + JSON.stringify(paramError.message));
+  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`获取应用主窗口，即可对其进行属性设置等操作。
 
 
 ### 开发步骤