Update docs against 16246+16893++16836+16709+16805

Signed-off-by: wusongqing<wusongqing@huawei.com>

en/application-dev/application-models/ability-startup-with-implicit-want.md

@@ -27,8 +27,7 @@ This section uses the operation of using a browser to open a website as an examp
                 "host": "www.test.com",
                 "port": "8080",
                 // Prefix matching is used.
-                "pathStartWith": "query",
-                "type": "text/*"
+                "pathStartWith": "query"
               },
               {
                 "scheme": "http",
@@ -53,12 +52,11 @@ function implicitStartAbility() {
   let context = getContext(this) as common.UIAbilityContext;
   let wantInfo = {
     // Uncomment the line below if you want to implicitly query data only in the specific bundle.
-    // bundleName: "com.example.myapplication",
-    "action": "ohos.want.action.viewData",
+    // bundleName: 'com.example.myapplication',
+    'action': 'ohos.want.action.viewData',
     // entities can be omitted.
-    "entities": ["entity.system.browsable"],
-    "uri": "https://www.test.com:8080/query/student",
-    "type": "text/plain"
+    'entities': ['entity.system.browsable'],
+    'uri': 'https://www.test.com:8080/query/student'
   }
   context.startAbility(wantInfo).then(() => {
     // ...
@@ -75,6 +73,6 @@ The matching process is as follows:
 3. If **uri** in the passed **want** parameter is included in **uris** under **skills** of the ability to match, which is concatenated into https://www.test.com:8080/query* (where * is a wildcard), the matching is successful.
 4. If **type** in the passed **want** parameter is specified and is included in **type** under **skills** of the ability to match, the matching is successful.
 
-When there are multiple matching applications, a dialog box is displayed for you to select one of them. The following figure shows an example. 
+If there are multiple matching applications, the system displays a dialog box for you to select one of them. The following figure shows an example. 
 
 ![](figures/ability-startup-with-implicit-want1.png)
\ No newline at end of file

en/application-dev/application-models/application-context-stage.md

@@ -19,10 +19,10 @@
      ```ts
      import UIAbility from '@ohos.app.ability.UIAbility';
      export default class EntryAbility extends UIAbility {
-         onCreate(want, launchParam) {
-             let uiAbilityContext = this.context;
-             // ...
-         }
+       onCreate(want, launchParam) {
+         let uiAbilityContext = this.context;
+         // ...
+       }
      }
      ```
      
@@ -34,21 +34,21 @@
      ```ts
      import ServiceExtensionAbility from '@ohos.app.ability.ServiceExtensionAbility';
      export default class MyService extends ServiceExtensionAbility {
-         onCreate(want) {
-             let serviceExtensionContext = this.context;
-             // ...
-         }
+       onCreate(want) {
+         let serviceExtensionContext = this.context;
+         // ...
+       }
      }
      ```
   - [AbilityStageContext](../reference/apis/js-apis-inner-application-abilityStageContext.md): module-level context. It provides **HapModuleInfo** and **Configuration** in addition to those provided by the base class **Context**.
     
      ```ts
-     import AbilityStage from "@ohos.app.ability.AbilityStage";
+     import AbilityStage from '@ohos.app.ability.AbilityStage';
      export default class MyAbilityStage extends AbilityStage {
-         onCreate() {
-             let abilityStageContext = this.context;
-             // ...
-         }
+       onCreate() {
+         let abilityStageContext = this.context;
+         // ...
+       }
      }
      ```
   - [ApplicationContext](../reference/apis/js-apis-inner-application-applicationContext.md): application-level context. It provides APIs for subscribing to application component lifecycle changes, system memory changes, and system environment changes. The application-level context can be obtained from UIAbility, ExtensionAbility, and AbilityStage.
@@ -56,10 +56,10 @@
      ```ts
      import UIAbility from '@ohos.app.ability.UIAbility';
      export default class EntryAbility extends UIAbility {
-         onCreate(want, launchParam) {
-             let applicationContext = this.context.getApplicationContext();
-             // ...
-         }
+       onCreate(want, launchParam) {
+         let applicationContext = this.context.getApplicationContext();
+         // ...
+       }
      }
      ```
 
@@ -71,7 +71,7 @@ This topic describes how to use the context in the following scenarios:
 
 
 - [Obtaining the Application Development Path](#obtaining-the-application-development-path)
-- [Obtaining and Modifying Encrypted Areas](#obtaining-and-modifying-encrypted-areas)
+- [Obtaining and Modifying Encryption Areas](#obtaining-and-modifying-encryption-areas)
 - [Creating Context of Another Application or Module](#creating-context-of-another-application-or-module)
 - [Subscribing to UIAbility Lifecycle Changes in a Process](#subscribing-to-uiability-lifecycle-changes-in-a-process)
 
@@ -84,13 +84,13 @@ The following table describes the application development paths obtained from co
 
 | Name| Type| Readable| Writable| Description|
 | -------- | -------- | -------- | -------- | -------- |
-| cacheDir | string | Yes| No| Cache directory of the application on the internal storage.<br>It is the content of **Storage** of an application under **Settings > Apps & services > Apps**.|
-| tempDir | string | Yes| No| Temporary file directory of the application.<br>Files in this directory are deleted after the application is uninstalled.|
-| filesDir | string | Yes| No| File directory of the application on the internal storage.<br>Files in this directory may be synchronized to other directories during application migration or backup.|
-| databaseDir | string | Yes| No| Storage directory of the local database.|
-| bundleCodeDir | string | Yes| No| Installation directory of the application on the internal storage.|
-| distributedFilesDir | string | Yes| No| Storage directory of distributed application data files.|
-| preferencesDir | string | Yes| Yes| Preferences directory of the application.|
+| bundleCodeDir       | string   | Yes  | No  | Path for storing the application's installation package, that is, installation directory of the application on the internal storage.                  |
+| cacheDir | string | Yes| No| Path for storing the application's cache files, that is, cache directory of the application on the internal storage.<br>It is the content of **Storage** of an application under **Settings > Apps & services > Apps**.|
+| filesDir            | string   | Yes  | No  | Path for storing the application's common files, that is, file directory of the application on the internal storage.<br>Files in this directory may be synchronized to other directories during application migration or backup.|
+| preferencesDir      | string   | Yes  | Yes  | Path for storing the application's preference files, that is, preferences directory of the application.                |
+| tempDir             | string   | Yes  | No  | Path for storing the application's temporary files.<br>Files in this directory are deleted after the application is uninstalled.|
+| databaseDir         | string   | Yes  | No  | Path for storing the application's database, that is, storage directory of the local database.                        |
+| distributedFilesDir | string | Yes| No| Path for storing the application's distributed files.|
 
 The capability of obtaining the application development path is provided by the base class **Context**. This capability is also provided by **ApplicationContext**, **AbilityStageContext**, **UIAbilityContext**, and **ExtensionContext**. However, the paths obtained from different contexts may differ, as shown below.
 
@@ -127,16 +127,16 @@ The sample code for obtaining the application development paths is as follows:
 import UIAbility from '@ohos.app.ability.UIAbility';
 
 export default class EntryAbility extends UIAbility {
-    onCreate(want, launchParam) {
-        let cacheDir = this.context.cacheDir;
-        let tempDir = this.context.tempDir;
-        let filesDir = this.context.filesDir;
-        let databaseDir = this.context.databaseDir;
-        let bundleCodeDir = this.context.bundleCodeDir;
-        let distributedFilesDir = this.context.distributedFilesDir;
-        let preferencesDir = this.context.preferencesDir;
-        // ...
-    }
+  onCreate(want, launchParam) {
+    let cacheDir = this.context.cacheDir;
+    let tempDir = this.context.tempDir;
+    let filesDir = this.context.filesDir;
+    let databaseDir = this.context.databaseDir;
+    let bundleCodeDir = this.context.bundleCodeDir;
+    let distributedFilesDir = this.context.distributedFilesDir;
+    let preferencesDir = this.context.preferencesDir;
+    // ...
+  }
 }
 ```
 
@@ -144,45 +144,52 @@ export default class EntryAbility extends UIAbility {
 >
 > The sample code obtains the sandbox path of the application development path. The absolute path can be obtained by running the **find / -name <fileName>** command in the hdc shell after file creation or modification.
 
-### Obtaining and Modifying Encrypted Areas
+### Obtaining and Modifying Encryption Areas
 
-You can read and write [the area attribute in the context](../reference/apis/js-apis-inner-application-context.md) to obtain and set an encrypted area. Two encryption levels are supported:
+Encrypting application files enhances data security by preventing files from unauthorized access. Different application files require different levels of protection. For private files, such as alarms and wallpapers, the application must place them in the device-level encryption area (EL1) to ensure that they can be accessed before the user enters the password. For sensitive files, such as personal privacy data, the application must place them in the user-level encryption area (EL2).
 
-- AreaMode.EL1: device-level encryption area, which is accessible after the device is powered on.
+In practice, you need to select a proper encrypted area based on scenario-specific requirements to protect application data security. The proper use of EL1 and the EL2 can efficiently improve the security.
 
-- AreaMode.EL2: user-level encryption area, which is accessible only after the device is powered on and the password is entered (for the first time).
+> **NOTE**
+>
+> - AreaMode.EL1: device-level encryption area, which is accessible after the device is powered on.
+>
+> - AreaMode.EL2: user-level encryption area, which is accessible only after the device is powered on and the password is entered (for the first time).
+
+You can obtain and set the encryption area by reading and writing the [area attribute in Context](../reference/apis/js-apis-inner-application-context.md).
 
 ```ts
 import UIAbility from '@ohos.app.ability.UIAbility';
 
 export default class EntryAbility extends UIAbility {
-    onCreate(want, launchParam) {
-        // Before storing common information, switch the encryption level to EL1.
-        if (this.context.area === 1) {// Obtain the area.
-            this.context.area = 0; // Modify the area.
-        }
-        // Store common information.
-
-        // Before storing sensitive information, switch the encryption level to EL2.
-        if (this.context.area === 0) { // Obtain the area.
-            this.context.area = 1;     // Modify the area.
-        }
-        // Store sensitive information.
+  onCreate(want, launchParam) {
+    // Before storing common information, switch the encryption level to EL1.
+    if (this.context.area === 1) {// Obtain the area.
+      this.context.area = 0; // Modify the area.
     }
+    // Store common information.
+
+    // Before storing sensitive information, switch the encryption level to EL2.
+    if (this.context.area === 0) { // Obtain the area.
+      this.context.area = 1; // Modify the area.
+    }
+    // Store sensitive information.
+  }
 }
 ```
 
 
 ### Creating Context of Another Application or Module
 
-The base class **Context** provides the [createBundleContext(bundleName:string)](../reference/apis/js-apis-inner-application-context.md#contextcreatebundlecontext), [createModuleContext(moduleName:string)](../reference/apis/js-apis-inner-application-context.md#contextcreatemodulecontext), and [createModuleContext(bundleName:string, moduleName:string)](../reference/apis/js-apis-inner-application-context.md#contextcreatemodulecontext-1) methods for creating the context of other applications or modules, so as to obtain the resource information, for example, [obtaining the application development paths](#obtaining-the-application-development-path) of other modules.
+The base class **Context** provides [createBundleContext(bundleName:string)](../reference/apis/js-apis-inner-application-context.md#contextcreatebundlecontext), [createModuleContext(moduleName:string)](../reference/apis/js-apis-inner-application-context.md#contextcreatemodulecontext), and [createModuleContext(bundleName:string, moduleName:string)](../reference/apis/js-apis-inner-application-context.md#contextcreatemodulecontext-1) to create the context of other applications or modules, so as to obtain the resource information, for example, [obtaining the application development paths](#obtaining-the-application-development-path) of other modules.
 
 - Call **createBundleContext(bundleName:string)** to create the context of another application.
   > **NOTE**
   >
   > To obtain the context of another application:
   >
-  > - Request the **ohos.permission.GET_BUNDLE_INFO_PRIVILEGED** permission. For details, see [Permission Application Guide](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
+  > - Request the **ohos.permission.GET_BUNDLE_INFO_PRIVILEGED** permission. For details, see [Declaring Permissions in the Configuration File](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
+  >
   > - This is a system API and cannot be called by third-party applications.
 
   For example, application information displayed on the home screen includes the application name and icon. The home screen application calls the foregoing method to obtain the context information, so as to obtain the resource information including the application name and icon.
@@ -191,12 +198,12 @@ The base class **Context** provides the [createBundleContext(bundleName:string)]
   import UIAbility from '@ohos.app.ability.UIAbility';
   
   export default class EntryAbility extends UIAbility {
-      onCreate(want, launchParam) {
-          let bundleName2 = "com.example.application";
-          let context2 = this.context.createBundleContext(bundleName2);
-          let label2 = context2.applicationInfo.label;
-          // ...
-      }
+    onCreate(want, launchParam) {
+      let bundleName2 = 'com.example.application';
+      let context2 = this.context.createBundleContext(bundleName2);
+      let label2 = context2.applicationInfo.label;
+      // ...
+    }
   }
   ```
 
@@ -205,99 +212,113 @@ The base class **Context** provides the [createBundleContext(bundleName:string)]
   >
   > To obtain the context of a specified module of another application:
   >
-  > - Request the **ohos.permission.GET_BUNDLE_INFO_PRIVILEGED** permission. For details, see [Permission Application Guide](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
+  > - Request the **ohos.permission.GET_BUNDLE_INFO_PRIVILEGED** permission. For details, see [Declaring Permissions in the Configuration File](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
+  >
   > - This is a system API and cannot be called by third-party applications.
-
+  
   ```ts
   import UIAbility from '@ohos.app.ability.UIAbility';
   
   export default class EntryAbility extends UIAbility {
-      onCreate(want, launchParam) {
-          let bundleName2 = "com.example.application";
-          let moduleName2 = "module1";
-          let context2 = this.context.createModuleContext(bundleName2, moduleName2);
-          // ...
-      }
+    onCreate(want, launchParam) {
+      let bundleName2 = 'com.example.application';
+      let moduleName2 = 'module1';
+      let context2 = this.context.createModuleContext(bundleName2, moduleName2);
+      // ...
+    }
   }
   ```
-
+  
 - Call **createModuleContext(moduleName:string)** to obtain the context of another module in the current application. After obtaining the context, you can obtain the resource information of that module.
   
   ```ts
   import UIAbility from '@ohos.app.ability.UIAbility';
   
   export default class EntryAbility extends UIAbility {
-      onCreate(want, launchParam) {
-          let moduleName2 = "module1";
-          let context2 = this.context.createModuleContext(moduleName2);
-          // ...
-      }
+    onCreate(want, launchParam) {
+      let moduleName2 = 'module1';
+      let context2 = this.context.createModuleContext(moduleName2);
+      // ...
+    }
   }
   ```
 
 
 ### Subscribing to UIAbility Lifecycle Changes in a Process
 
-In the DFX statistics scenario of an application, if you need to collect statistics on the stay duration and access frequency of a page, you can subscribe to UIAbility lifecycle changes.
+In the DFX statistics scenario of an application, if you need to collect statistics on the stay duration and access frequency of a page, you can subscribe to UIAbility lifecycle changes in a process.
 
-[ApplicationContext](../reference/apis/js-apis-inner-application-applicationContext.md) provides APIs for subscribing to UIAbility lifecycle changes in a process. When the UIAbility lifecycle changes in a process, for example, being created or destroyed, becoming visible or invisible, or gaining or losing focus, the corresponding callback is triggered, and a listener ID is returned. The ID is incremented by 1 each time the listener is registered. When the number of listeners exceeds the upper limit (2^63-1), -1 is returned. The following uses [UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md) as an example.
+[ApplicationContext](../reference/apis/js-apis-inner-application-applicationContext) provides APIs for subscribing to UIAbility lifecycle changes in a process. When the UIAbility lifecycle changes in a process, for example, being created or destroyed, becoming visible or invisible, or gaining or losing focus, the corresponding callback is triggered. Each time the callback is registered, a listener lifecycle ID is returned, with the value incremented by 1 each time. When the number of listeners exceeds the upper limit (2^63-1), **-1** is returned. The following uses [UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md) as an example.
 
 
 ```ts
 import UIAbility from '@ohos.app.ability.UIAbility';
 import window from '@ohos.window';
 
-const TAG: string = "[Example].[Entry].[EntryAbility]";
+const TAG: string = '[Example].[Entry].[EntryAbility]';
 
 export default class EntryAbility extends UIAbility {
-    lifecycleId: number;
-
-    onCreate(want, launchParam) {
-        let abilityLifecycleCallback = {
-            onAbilityCreate(uiability) {
-                console.info(TAG, "onAbilityCreate uiability:" + JSON.stringify(uiability));
-            },
-            onWindowStageCreate(uiability, windowStage) {
-                console.info(TAG, "onWindowStageCreate uiability:" + JSON.stringify(uiability));
-                console.info(TAG, "onWindowStageCreate windowStage:" + JSON.stringify(windowStage));
-            },
-            onWindowStageActive(uiability, windowStage) {
-                console.info(TAG, "onWindowStageActive uiability:" + JSON.stringify(uiability));
-                console.info(TAG, "onWindowStageActive windowStage:" + JSON.stringify(windowStage));
-            },
-            onWindowStageInactive(uiability, windowStage) {
-                console.info(TAG, "onWindowStageInactive uiability:" + JSON.stringify(uiability));
-                console.info(TAG, "onWindowStageInactive windowStage:" + JSON.stringify(windowStage));
-            },
-            onWindowStageDestroy(uiability, windowStage) {
-                console.info(TAG, "onWindowStageDestroy uiability:" + JSON.stringify(uiability));
-                console.info(TAG, "onWindowStageDestroy windowStage:" + JSON.stringify(windowStage));
-            },
-            onAbilityDestroy(uiability) {
-                console.info(TAG, "onAbilityDestroy uiability:" + JSON.stringify(uiability));
-            },
-            onAbilityForeground(uiability) {
-                console.info(TAG, "onAbilityForeground uiability:" + JSON.stringify(uiability));
-            },
-            onAbilityBackground(uiability) {
-                console.info(TAG, "onAbilityBackground uiability:" + JSON.stringify(uiability));
-            },
-            onAbilityContinue(uiability) {
-                console.info(TAG, "onAbilityContinue uiability:" + JSON.stringify(uiability));
-            }
-        }
-        // 1. Obtain the application context through the context attribute.
-        let applicationContext = this.context.getApplicationContext();
-        // 2. Register a listener for the lifecycle changes through the application context.
-        this.lifecycleId = applicationContext.on("abilityLifecycle", abilityLifecycleCallback);
-        console.info(TAG, "register callback number: " + JSON.stringify(this.lifecycleId));
+  // Define a lifecycle ID.
+  lifecycleId: number;
+
+  onCreate(want, launchParam) {
+    // Define a lifecycle callback object.
+    let abilityLifecycleCallback = {
+      // Called when a UIAbility is created.
+      onAbilityCreate(uiAbility) {
+        console.log(TAG, `onAbilityCreate uiAbility.launchWant: ${JSON.stringify(uiAbility.launchWant)}`);
+      },
+      // Called when a window is created.
+      onWindowStageCreate(uiAbility, windowStage: window.WindowStage) {
+        console.log(TAG, `onWindowStageCreate uiAbility.launchWant: ${JSON.stringify(uiAbility.launchWant)}`);
+        console.log(TAG, `onWindowStageCreate windowStage: ${JSON.stringify(windowStage)}`);
+      },
+      // Called when the window becomes active.
+      onWindowStageActive(uiAbility, windowStage: window.WindowStage) {
+        console.log(TAG, `onWindowStageActive uiAbility.launchWant: ${JSON.stringify(uiAbility.launchWant)}`);
+        console.log(TAG, `onWindowStageActive windowStage: ${JSON.stringify(windowStage)}`);
+      },
+      // Called when the window becomes inactive.
+      onWindowStageInactive(uiAbility, windowStage: window.WindowStage) {
+        console.log(TAG, `onWindowStageInactive uiAbility.launchWant: ${JSON.stringify(uiAbility.launchWant)}`);
+        console.log(TAG, `onWindowStageInactive windowStage: ${JSON.stringify(windowStage)}`);
+      },
+      // Called when the window is destroyed.
+      onWindowStageDestroy(uiAbility, windowStage: window.WindowStage) {
+        console.log(TAG, `onWindowStageDestroy uiAbility.launchWant: ${JSON.stringify(uiAbility.launchWant)}`);
+        console.log(TAG, `onWindowStageDestroy windowStage: ${JSON.stringify(windowStage)}`);
+      },
+      // Called when the UIAbility is destroyed.
+      onAbilityDestroy(uiAbility) {
+        console.log(TAG, `onAbilityDestroy uiAbility.launchWant: ${JSON.stringify(uiAbility.launchWant)}`);
+      },
+      // Called when the UIAbility is switched from the background to the foreground.
+      onAbilityForeground(uiAbility) {
+        console.log(TAG, `onAbilityForeground uiAbility.launchWant: ${JSON.stringify(uiAbility.launchWant)}`);
+      },
+      // Called when the UIAbility is switched from the foreground to the background.
+      onAbilityBackground(uiAbility) {
+        console.log(TAG, `onAbilityBackground uiAbility.launchWant: ${JSON.stringify(uiAbility.launchWant)}`);
+      },
+      // Called when UIAbility is continued on another device.
+      onAbilityContinue(uiAbility) {
+        console.log(TAG, `onAbilityContinue uiAbility.launchWant: ${JSON.stringify(uiAbility.launchWant)}`);
+      }
     }
+    // Obtain the application context.
+    let applicationContext = this.context.getApplicationContext();
+    // Register the application lifecycle callback.
+    this.lifecycleId = applicationContext.on('abilityLifecycle', abilityLifecycleCallback);
+    console.log(TAG, `register callback number: ${this.lifecycleId}`);
+  }
 
-    onDestroy() {
-        let applicationContext = this.context.getApplicationContext();
-        applicationContext.off("abilityLifecycle", this.lifecycleId, (error, data) => {
-            console.info(TAG, "unregister callback success, err: " + JSON.stringify(error));
-        });
-    }
+  // ...
+
+  onDestroy() {
+    // Obtain the application context.
+    let applicationContext = this.context.getApplicationContext();
+    // Deregister the application lifecycle callback.
+    applicationContext.off('abilityLifecycle', this.lifecycleId);
+  }
 }
 ```

en/application-dev/application-models/component-startup-rules.md

@@ -30,7 +30,7 @@ In view of this, OpenHarmony formulates a set of component startup rules, as fol
   - An application is considered as a foreground application only when the application process gains focus or its UIAbility component is running in the foreground.
   - Verify the **ohos.permission.START_ABILITIES_FROM_BACKGROUND** permission.
 
-- **When the startAbilityByCall() method is used, verify the call permission.** For details, see [Using Ability Call to Implement UIAbility Interaction](uiability-intra-device-interaction.md#using-ability-call-to-implement-uiability-interaction) and [Using Cross-Device Ability Call](hop-multi-device-collaboration.md#using-cross-device-ability-call).
+- **When the startAbilityByCall() method is used, verify the call permission.** For details, see [Using Call to Implement UIAbility Interaction](uiability-intra-device-interaction.md#using-call-to-implement-uiability-interaction) and [Using Cross-Device Call](hop-multi-device-collaboration.md#using-cross-device-call).
   - Verify the **ohos.permission.ABILITY_BACKGROUND_COMMUNICATION** permission.
 
 

en/application-dev/application-models/create-pageability.md

@@ -76,22 +76,22 @@ In the FA model, you can call **getContext** of **featureAbility** to obtain the
 The following code snippet shows how to use **getContext()** to obtain the application context and distributed directory:
 
 ```ts
-import featureAbility from '@ohos.ability.featureAbility'
-import fileIo from '@ohos.fileio'
+import featureAbility from '@ohos.ability.featureAbility';
+import fs from '@ohos.file.fs';
 
 (async () => {
-  let dir: string
+  let dir: string;
   try {
-    console.info('Begin to getOrCreateDistributedDir')
-    dir = await featureAbility.getContext().getOrCreateDistributedDir()
+    console.info('Begin to getOrCreateDistributedDir');
+    dir = await featureAbility.getContext().getOrCreateDistributedDir();
     console.info('distribute dir is ' + dir)
   } catch (error) {
-    console.error('getOrCreateDistributedDir failed with ' + error)
+    console.error('getOrCreateDistributedDir failed with ' + error);
   }
 
   let fd: number;
   let path = dir + "/a.txt";
-  fd = fileIo.openSync(path, 0o2 | 0o100, 0o666);
-  fileIo.close(fd);
+  fd = fs.openSync(path, fs.OpenMode.READ_WRITE).fd;
+  fs.close(fd);
 })()
 ```

en/application-dev/application-models/data-share-via-want.md

@@ -2,20 +2,20 @@
 
 Users often need to share data (such as a text or an image) from one application to another. The following uses PDF file sharing as an example to describe how to use Want to share data between applications.
 
-Data sharing requires two UIAbility components (one for the sharing party and the other for the shared party) and one system component (used as the application selector). When the sharing party initiates data sharing by calling **startAbility()**, the system implicitly matches and displays all applications that support the type of data to share. After the user selects an application, the system starts the application to complete data sharing.
+Data sharing requires two UIAbility components (one for the sharing party and the other for the shared party) and one system component (used as the application sharing box). When the sharing party initiates data sharing by calling **startAbility()**, the system implicitly matches and displays all applications that support the type of data to share. After the user selects an application, the system starts the application to complete data sharing.
 
 In this section, data sharing is triggered by touching a button. You can use other ways to trigger data sharing during application development. This section focuses on how to configure Want to implement data sharing.
 
 The following actions are involved for data sharing:
 
-- **ohos.want.action.select**: action of starting the application selector.
+- **ohos.want.action.select**: action of starting the application sharing box.
 - **ohos.want.action.sendData**: action of sending a single data record, that is, transferring data to the shared party.
 
 ## Sharing Party
 
-The sharing party starts an application selector and transfers the data to the shared party. Therefore, Want of the sharing party must be nested at two layers. In the first layer, implicit Want is used together with the **ohos.want.action.select** action to display the application selector. In the second layer, the data to share is declared
+The sharing party starts an application sharing box and transfers the data to the shared party. Therefore, Want of the sharing party must be nested at two layers. In the first layer, implicit Want is used together with the **ohos.want.action.select** action to display the application sharing box. In the second layer, the data to share is declared
 
-in the custom field **parameters**, and then the Want that includes the **ohos.want.action.sendData** action and the **parameters** field is transferred to the application selector. The shared party obtains the shared data from **parameters**.
+in the custom field **parameters**, and then the Want that includes the **ohos.want.action.sendData** action and the **parameters** field is transferred to the application sharing box. The shared party obtains the shared data from **parameters**.
 
 ```ts
 import common from '@ohos.app.ability.common';
@@ -28,21 +28,21 @@ let fileSize; // Obtain the size of the file to share.
 function implicitStartAbility() {
   let context = getContext(this) as common.UIAbilityContext;
   let wantInfo = {
-    / This action is used to implicitly match the application selector.
+    / This action is used to implicitly match the application sharing box.
     action: 'ohos.want.action.select',
     // This is the custom parameter in the first layer of Want,
-    / which is intended to add information to the application selector.
+    / which is intended to add information to the application sharing box.
     parameters: {
       // MIME type of PDF.
-      "ability.picker.type": fileType,
-      "ability.picker.fileNames": [fileName],
-      "ability.picker.fileSizes": [fileSize],
+      'ability.picker.type': fileType,
+      'ability.picker.fileNames': [fileName],
+      'ability.picker.fileSizes': [fileSize],
       // This is nested Want ,which will be directly sent to the selected application.
-      "ability.want.params.INTENT": {
-        "action": "ohos.want.action.sendData",
-        "type": "application/pdf",
-        "parameters": {
-          "keyFd": { "type": "FD", "value": fileFd }
+      'ability.want.params.INTENT': {
+        'action': 'ohos.want.action.sendData',
+        'type': 'application/pdf',
+        'parameters': {
+          'keyFd': { 'type': 'FD', 'value': fileFd }
         }
       }
     }
@@ -59,14 +59,15 @@ function implicitStartAbility() {
 >
 > Data sharing can be implemented only in FD format. For details about how to obtain the FD and file name, see [File Management](../reference/apis/js-apis-file-fs.md).
 
-In the preceding code, under the custom field **parameters**, the following **ability.picker.*** fields are used to pass the information to be displayed on the application selector:
+In the preceding code, under the custom field **parameters**, the following **ability.picker.*** fields are used to pass the information to be displayed on the application sharing box:
 
 - **ability.picker.type**: file type icon.
 - **ability.picker.fileNames**: file name.
 - **ability.picker.fileSizes**: file size, in bytes.
 - **ability.picker.fileNames** and **ability.picker.fileSizes** are arrays and have a one-to-one mapping.
 
-The following figure shows an example.  
+The following figure shows an example. 
+
 ![](figures/ability-startup-with-implicit-want2.png)
 
 ## Shared Party

en/application-dev/application-models/explicit-implicit-want-mappings.md

@@ -62,7 +62,7 @@ The system matches the **action** attribute in the **want** parameter passed by
 
   **Figure 1** Matching rules of action in the want parameter
 
-  ![want-action](figures/want-action.png)
+  ![want-action](figures/want-action.png)  
 
 
 ### Matching Rules of entities in the want Parameter
@@ -79,19 +79,15 @@ The system matches the **entities** attribute in the **want** parameter passed b
 
 - If **entities** in the passed **want** parameter is specified, and **entities** under **skills** of an ability is specified but does not contain **entities** in the passed **want** parameter, the matching fails.
 
-  Figure 2 Matching rule of entities in the want parameter
+  **Figure 2** Matching rule of entities in the want parameter
 
-  ![want-entities](figures/want-entities.png) 
+  ![want-entities](figures/want-entities.png)  
 
 
 ### Matching Rules of uri and type in the want Parameter
 
 When the **uri** and **type** parameters are specified in the **want** parameter to initiate a component startup request, the system traverses the list of installed components and matches the **uris** array under **skills** of the abilities one by one. If one of the **uris** arrays under **skills** matches the **uri** and **type** in the passed **want**, the matching is successful.
 
-Figure 3 Matching rules when uri and type are specified in the want parameter
-
-![want-uri-type1](figures/want-uri-type1.png) 
-
 There are four combinations of **uri** and **type** settings. The matching rules are as follows:
 
 - Neither **uri** or **type** is specified in the **want** parameter.
@@ -111,11 +107,17 @@ There are four combinations of **uri** and **type** settings. The matching rules
   - If the **uris** array under **skills** of an ability is unspecified, the matching fails.
   - If the **uris** array under **skills** of an ability contains an element whose [uri is matched](#matching-rules-of-uri) and [type is matched](#matching-rules-of-type), the matching is successful. Otherwise, the matching fails.
 
+Leftmost URI matching: When only **scheme**, a combination of **scheme** and **host**, or a combination of **scheme**, **host**, and **port** is configured in the **uris** array under **skills** of the ability,
+the matching is successful only if the leftmost URI in the passed **want** parameter matches **scheme**, the combination of **scheme** and **host**, or the combination of **scheme**, **host**, and **port**.
 
-To simplify the description, **uri** and **type** passed in the **want** parameter are called **w_uri** and **w_type**, respectively; the **uris** array under **skills** of an ability to match is called **s_uris**; each element in the array is called **s_uri**. Matching is performed from top to bottom.
+**Figure 3** Matching rules when uri and type are specified in the want parameter
 
+  ![want-uri-type1](figures/want-uri-type1.png)  
+
+
+To simplify the description, **uri** and **type** passed in the **want** parameter are called **w_uri** and **w_type**, respectively; the **uris** array under **skills** of an ability to match is called **s_uris**; each element in the array is called **s_uri**. Matching is performed from top to bottom.
 
-Figure 4 Matching rules of uri and type in the want parameter
+**Figure 4** Matching rules of uri and type in the want parameter
 
 ![want-uri-type2](figures/want-uri-type2.png)  
 
@@ -128,7 +130,9 @@ To simplify the description, **uri** in the passed **want** parameter is called
 
 - If **host** of **s_uri** is unspecified and **scheme** of **w_uri** and **scheme** of **s_uri** are the same, the matching is successful. Otherwise, the matching fails.
 
-- If **path**, **pathStartWith**, and **pathRegex** of **s_uri** are unspecified and **w_uri** and **s_uri** are the same, the matching is successful. Otherwise, the matching fails.
+- If **port** of **s_uri** is unspecified and the combination of **scheme** and **host** of **w_uri** is the same as the combination of **scheme** and **host** of **s_uri**, the matching is successful. Otherwise, the matching fails.
+
+- If **path**, **pathStartWith**, and **pathRegex** of **s_uri** are unspecified and the combination of **scheme**, **host**, and **port** of **w_uri** is the same as the combination of **scheme**, **host**, and **port** of **s_uri**, the matching is successful. Otherwise, the matching fails.
 
 - If **path** of **s_uri** is specified and the **full path expressions** of **w_uri** and **s_uri** are the same, the matching is successful. Otherwise, the matching of **pathStartWith** continues.
 
@@ -139,12 +143,17 @@ To simplify the description, **uri** in the passed **want** parameter is called
 > **NOTE**
 >
 > The **scheme**, **host**, **port**, **path**, **pathStartWith**, and **pathRegex** attributes of **uris** under **skills** of an ability are concatenated. If **path**, **pathStartWith**, and **pathRegex** are declared in sequence, **uris** can be concatenated into the following expressions:
->
+> 
 > - **Full path expression**: `scheme://host:port/path`
->
+> 
 > - **Prefix expression**: `scheme://host:port/pathStartWith`
->
+> 
 > - **Regular expression**: `scheme://host:port/pathRegex`
+>
+> - **Prefix URI expression**: When only **scheme**, a combination of **scheme** and **host**, or a combination of **scheme**, **host**, and **port** is configured in the configuration file, the matching is successful if a URI prefixed with the configuration file is passed in.
+>     * `scheme://`
+>     * `scheme://host`
+>     * `scheme://host:port`
 
 
 ### Matching Rules of type

en/application-dev/application-models/hop-cross-device-migration.md

-# Cross-Device Migration (for System Applications Only)]
+# Cross-Device Migration (for System Applications Only)
 
 
 ## When to Use
@@ -47,25 +47,16 @@ The table below describes the main APIs used for cross-device migration. For det
 
 ## How to Develop
 
-1. Configure the data synchronization permission in the **module.json5** file. The sample code is as follows:
-   
-   ```json
-   {
-     "module": {
-       "requestPermissions":[  
-         {  
-           "name" : "ohos.permission.DISTRIBUTED_DATASYNC",
-         }
-       ]
-     }
-   }
-   ```
+1. Request the **ohos.permission.DISTRIBUTED_DATASYNC** permission. For details, see [Declaring Permissions in the Configuration File](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
 
-2. Configure the fields related to cross-device migration in the configuration file.
-   - Configure the application to support migration.
-     
+2. Display a dialog box to ask authorization from the user when the application is started for the first time. For details, see [Requesting User Authorization](../security/accesstoken-guidelines.md#requesting-user-authorization).
 
-     Set the **continuable** field in the **module.json5** file to **true**. The default value is **false**. If this parameter is set to **false**, the application cannot be continued on the target device.     
+3. Configure the fields related to cross-device migration in the configuration file.
+
+   Configure the application to support migration.
+   Set the **continuable** field in the **module.json5** file to **true**. The default value is **false**. If this parameter is set to **false**, the application cannot be continued on the target device.
+   
+   
       ```json
       {
         "module": {
@@ -80,47 +71,31 @@ The table below describes the main APIs used for cross-device migration. For det
       }
       ```
 
-   - Configure the application launch type. For details, see [UIAbility Component Launch Type](uiability-launch-type.md).
-
-3. Request the data synchronization permission. The sample code for displaying a dialog box to request the permission is as follows:
-   
-   ```ts
-   requestPermission() {   
-       let context = this.context
-       let permissions: Array<string> = ['ohos.permission.DISTRIBUTED_DATASYNC']   
-       context.requestPermissionsFromUser(permissions).then((data) => {   
-           console.info("Succeed to request permission from user with data: "+ JSON.stringify(data))
-       }).catch((error) => {       
-           console.info("Failed to request permission from user with error: "+ JSON.stringify(error))   
-       }) 
-   }
-   ```
+   Configure the application launch type. For details, see [UIAbility Component Launch Type](uiability-launch-type.md).
 
 4. Implement [onContinue()](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncontinue) in the UIAbility of the initiator.
-
    [onContinue()](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncontinue) is called on the initiator. You can save the  data in this method to implement application compatibility check and migration decision.
-
    - Saving migrated data: You can save the data to be migrated in key-value pairs in **wantParam**.
 
    - Checking application compatibility: You can obtain the version number of the target application from **wantParam** and check the compatibility between the target application and the current application.
 
    - Making a migration decision: You can determine whether to support the migration based on the return value of **onContinue()**. For details about the return value, see [Available APIs](#available-apis).
 
-   The sample code is as follows:
-   
-   ```ts
-   import UIAbility from '@ohos.app.ability.UIAbility';
-   import AbilityConstant from '@ohos.app.ability.AbilityConstant';
-   
-   onContinue(wantParam : {[key: string]: any}) {         
-       console.info(`onContinue version = ${wantParam.version}, targetDevice: ${wantParam.targetDevice}`)         
-       let workInput = AppStorage.Get<string>('ContinueWork');         
-       // Set the user input data into wantParam.        
-       wantParam["work"] = workInput // set user input data into want params         
-       console.info(`onContinue input = ${wantParam["input"]}`);         
-       return AbilityConstant.OnContinueResult.AGREE     
-   }
-   ```
+     The sample code is as follows:
+     
+     ```ts
+     import UIAbility from '@ohos.app.ability.UIAbility';
+     import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+     
+     onContinue(wantParam : {[key: string]: any}) {         
+         console.info(`onContinue version = ${wantParam.version}, targetDevice: ${wantParam.targetDevice}`)         
+         let workInput = AppStorage.Get<string>('ContinueWork');         
+         // Set the user input data into wantParam.        
+         wantParam["work"] = workInput // set user input data into want params         
+         console.info(`onContinue input = ${wantParam["input"]}`);         
+         return AbilityConstant.OnContinueResult.AGREE     
+     }
+     ```
 
 5. Implement **onCreate()** and **onNewWant()** in the UIAbility of the target application to implement data restoration.
    - Implementation example of **onCreate** in the multi-instance scenario

en/application-dev/application-models/hop-multi-device-collaboration.md

@@ -11,7 +11,7 @@ Multi-device coordination involves the following scenarios:
 
 - [Connecting to ServiceExtensionAbility Across Devices](#connecting-to-serviceextensionability-across-devices)
 
-- [Using Cross-Device Ability Call](#using-cross-device-ability-call)
+- [Using Cross-Device Call](#using-cross-device-call)
 
 
 ## Multi-Device Collaboration Process
@@ -47,24 +47,12 @@ On device A, touch the **Start** button provided by the initiator application to
 
 ### How to Develop
 
-1. Request the **ohos.permission.DISTRIBUTED_DATASYNC** permission. For details, see [Permission Application Guide](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
+1. Request the **ohos.permission.DISTRIBUTED_DATASYNC** permission. For details, see [Declaring Permissions in the Configuration File](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
 
-2. Request the data synchronization permission. The sample code for displaying a dialog box to request the permission is as follows:
-   
-   ```ts
-   requestPermission() {   
-       let context = this.context;
-       let permissions: Array<string> = ['ohos.permission.DISTRIBUTED_DATASYNC'];
-       context.requestPermissionsFromUser(permissions).then((data) => {
-           console.info("Succeed to request permission from user with data: "+ JSON.stringify(data));
-       }).catch((error) => {
-           console.info("Failed to request permission from user with error: "+ JSON.stringify(error));
-       })
-   }
-   ```
+2. Display a dialog box to ask authorization from the user when the application is started for the first time. For details, see [Requesting User Authorization](../security/accesstoken-guidelines.md#requesting-user-authorization).
 
 3. Obtain the device ID of the target device.
-   
+
    ```ts
    import deviceManager from '@ohos.distributedHardware.deviceManager';
    
@@ -94,7 +82,7 @@ On device A, touch the **Start** button provided by the initiator application to
    ```
 
 4. Set the target component parameters, and call [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) to start UIAbility or ServiceExtensionAbility.
-   
+
    ```ts
    let want = {
        deviceId: getRemoteDeviceId(), 
@@ -102,7 +90,7 @@ On device A, touch the **Start** button provided by the initiator application to
        abilityName: 'FuncAbility',
        moduleName: 'module1', // moduleName is optional.
    }
-   // context is the ability-level context of the initiator UIAbility.
+   // context is the AbilityContext of the initiator UIAbility.
    this.context.startAbility(want).then(() => {
        // ...
    }).catch((err) => {
@@ -118,35 +106,23 @@ On device A, touch the **Start** button provided by the initiator application to
 
 ### Available APIs
 
-**Table 2** APIs for starting an ability across devices and returning the result data
+**Table 2** APIs for starting a UIAbility across devices and returning the result data
 
 | API| Description|
 | -------- | -------- |
 | startAbilityForResult(want: Want, callback: AsyncCallback&lt;AbilityResult&gt;): void; | Starts a UIAbility. This API uses an asynchronous callback to return the result when the UIAbility is terminated.|
-| terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback&lt;void&gt;): void;| Terminates this UIAbility. This API uses an asynchronous callback to return the ability result information. It is used together with **startAbilityForResult**.|
-| terminateSelfWithResult(parameter: AbilityResult): Promise&lt;void&gt;; | Terminates this UIAbility. This API uses a promise to return the ability result information. It is used together with **startAbilityForResult**.|
+| terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback&lt;void&gt;): void;| Terminates this UIAbility. This API uses an asynchronous callback to return the result information. It is used together with **startAbilityForResult**.|
+| terminateSelfWithResult(parameter: AbilityResult): Promise&lt;void&gt;; | Terminates this UIAbility. This API uses a promise to return the result information. It is used together with **startAbilityForResult**.|
 
 
 ### How to Develop
 
-1. Request the **ohos.permission.DISTRIBUTED_DATASYNC** permission. For details, see [Permission Application Guide](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
+1. Request the **ohos.permission.DISTRIBUTED_DATASYNC** permission. For details, see [Declaring Permissions in the Configuration File](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
 
-2. Request the data synchronization permission. The sample code for displaying a dialog box to request the permission is as follows:
-   
-   ```ts
-   requestPermission() {   
-       let context = this.context;
-       let permissions: Array<string> = ['ohos.permission.DISTRIBUTED_DATASYNC'];
-       context.requestPermissionsFromUser(permissions).then((data) => {
-           console.info("Succeed to request permission from user with data: "+ JSON.stringify(data));
-       }).catch((error) => {
-           console.info("Failed to request permission from user with error: "+ JSON.stringify(error));
-       })
-   }
-   ```
+2. Display a dialog box to ask authorization from the user when the application is started for the first time. For details, see [Requesting User Authorization](../security/accesstoken-guidelines.md#requesting-user-authorization).
 
 3. Set the target component parameters on the initiator, and call **startAbilityForResult()** to start the target UIAbility. **data** in the asynchronous callback is used to receive the information returned by the target UIAbility to the initiator UIAbility after the target UIAbility terminates itself. For details about how to implement **getRemoteDeviceId()**, see [Starting UIAbility and ServiceExtensionAbility Across Devices (No Data Returned)](#starting-uiability-and-serviceextensionability-across-devices-no-data-returned).
-   
+
    ```ts
    let want = {
        deviceId: getRemoteDeviceId(), 
@@ -154,7 +130,7 @@ On device A, touch the **Start** button provided by the initiator application to
        abilityName: 'FuncAbility',
        moduleName: 'module1', // moduleName is optional.
    }
-   // context is the ability-level context of the initiator UIAbility.
+   // context is the AbilityContext of the initiator UIAbility.
    this.context.startAbilityForResult(want).then((data) => {
        // ...
    }).catch((err) => {
@@ -163,7 +139,7 @@ On device A, touch the **Start** button provided by the initiator application to
    ```
 
 4. After the UIAbility task at the target device is complete, call **terminateSelfWithResult()** to return the data to the initiator UIAbility.
-   
+
    ```ts
    const RESULT_CODE: number = 1001;
    let abilityResult = {
@@ -174,20 +150,20 @@ On device A, touch the **Start** button provided by the initiator application to
            moduleName: 'module1',
        },
    }
-   // context is the ability-level context of the target UIAbility.
+   // context is the AbilityContext of the target UIAbility.
    this.context.terminateSelfWithResult(abilityResult, (err) => {
        // ...
    });
    ```
 
 5. The initiator UIAbility receives the information returned by the target UIAbility and processes the information.
-   
+
    ```ts
    const RESULT_CODE: number = 1001;
    
    // ...
    
-   // context is the ability-level context of the initiator UIAbility.
+   // context is the UIAbilityContext of the initiator UIAbility.
    this.context.startAbilityForResult(want).then((data) => {
        if (data?.resultCode === RESULT_CODE) {
            // Parse the information returned by the target UIAbility.
@@ -218,21 +194,9 @@ A system application can connect to a service on another device by calling [conn
 
 ### How to Develop
 
-1. Request the **ohos.permission.DISTRIBUTED_DATASYNC** permission. For details, see [Permission Application Guide](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
-   
-2. Request the data synchronization permission. The sample code for displaying a dialog box to request the permission is as follows:
-   
-   ```ts
-   requestPermission() {   
-       let context = this.context;
-       let permissions: Array<string> = ['ohos.permission.DISTRIBUTED_DATASYNC'];
-       context.requestPermissionsFromUser(permissions).then((data) => {
-           console.info("Succeed to request permission from user with data: "+ JSON.stringify(data));
-       }).catch((error) => {
-           console.info("Failed to request permission from user with error: "+ JSON.stringify(error));
-       })
-   }
-   ```
+1. Request the **ohos.permission.DISTRIBUTED_DATASYNC** permission. For details, see [Declaring Permissions in the Configuration File](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
+
+2. Display a dialog box to ask authorization from the user when the application is started for the first time. For details, see [Requesting User Authorization](../security/accesstoken-guidelines.md#requesting-user-authorization).
 
 3. (Optional) [Implement a background service](serviceextensionability.md#implementing-a-background-service). Perform this operation only if no background service is available.
 
@@ -292,7 +256,7 @@ A system application can connect to a service on another device by calling [conn
       For details about how to implement **getRemoteDeviceId()**, see [Starting UIAbility and ServiceExtensionAbility Across Devices (No Data Returned)](#starting-uiability-and-serviceextensionability-across-devices-no-data-returned).
 
 5. Disconnect the connection. Use **disconnectServiceExtensionAbility()** to disconnect from the background service.
-   
+
    ```ts
    let connectionId = 1 // ID returned when the service is connected through connectServiceExtensionAbility.
    this.context.disconnectServiceExtensionAbility(connectionId).then((data) => {
@@ -303,145 +267,134 @@ A system application can connect to a service on another device by calling [conn
    ```
 
 
-## Using Cross-Device Ability Call
+## Using Cross-Device Call
 
-The basic principle of cross-device ability call is the same as that of intra-device ability call. For details, see [Using Ability Call to Implement UIAbility Interaction (for System Applications Only)](uiability-intra-device-interaction.md#using-ability-call-to-implement-uiability-interaction-for-system-applications-only).
+The basic principle of cross-device call is the same as that of intra-device call. For details, see [Using Call to Implement UIAbility Interaction (for System Applications Only)](uiability-intra-device-interaction.md#using-call-to-implement-uiability-interaction-for-system-applications-only).
 
-The following describes how to implement multi-device collaboration through cross-device ability call.
+The following describes how to implement multi-device collaboration through cross-device call.
 
 
 ### Available APIs
 
-**Table 4** Ability call APIs
+**Table 4** Call APIs
 
 | API| Description|
 | -------- | -------- |
 | startAbilityByCall(want: Want): Promise&lt;Caller&gt;; | Starts a UIAbility in the foreground or background and obtains the caller object for communicating with the UIAbility.|
-| on(method: string, callback: CalleeCallBack): void | Callback invoked when the callee ability registers a method.|
-| off(method: string): void | Callback invoked when the callee ability deregisters a method.|
-| call(method: string, data: rpc.Parcelable): Promise&lt;void&gt; | Sends agreed parcelable data to the callee ability.|
-| callWithResult(method: string, data: rpc.Parcelable): Promise&lt;rpc.MessageSequence&gt;| Sends agreed parcelable data to the callee ability and obtains the agreed parcelable data returned by the callee ability.|
+| on(method: string, callback: CalleeCallBack): void | Callback invoked when the CalleeAbility registers a method.|
+| off(method: string): void | Callback invoked when the CalleeAbility deregisters a method.|
+| call(method: string, data: rpc.Parcelable): Promise&lt;void&gt; | Sends agreed parcelable data to the CalleeAbility.|
+| callWithResult(method: string, data: rpc.Parcelable): Promise&lt;rpc.MessageSequence&gt;| Sends agreed parcelable data to the CalleeAbility and obtains the agreed parcelable data returned by the CalleeAbility.|
 | release(): void | Releases the caller object.|
 | on(type: "release", callback: OnReleaseCallback): void | Callback invoked when the caller object is released.|
 
 
 ### How to Develop
 
-1. Request the **ohos.permission.DISTRIBUTED_DATASYNC** permission. For details, see [Permission Application Guide](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
-   
-2. Request the data synchronization permission. The sample code for displaying a dialog box to request the permission is as follows:
-   
-   ```ts
-   requestPermission() {   
-       let context = this.context;
-       let permissions: Array<string> = ['ohos.permission.DISTRIBUTED_DATASYNC'];
-       context.requestPermissionsFromUser(permissions).then((data) => {
-           console.info("Succeed to request permission from user with data: "+ JSON.stringify(data));
-       }).catch((error) => {
-           console.info("Failed to request permission from user with error: "+ JSON.stringify(error));
-       })
-   }
-   ```
+1. Request the **ohos.permission.DISTRIBUTED_DATASYNC** permission. For details, see [Declaring Permissions in the Configuration File](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
 
-3. Create the callee ability.
+2. Display a dialog box to ask authorization from the user when the application is started for the first time. For details, see [Requesting User Authorization](../security/accesstoken-guidelines.md#requesting-user-authorization).
+
+3. Create the CalleeAbility.
    
-   For the callee ability, implement the callback to receive data and the methods to marshal and unmarshal data. When data needs to be received, use **on()** to register a listener. When data does not need to be received, use **off()** to deregister the listener.
+     For the CalleeAbility, implement the callback to receive data and the methods to marshal and unmarshal data. When data needs to be received, use **on()** to register a listener. When data does not need to be received, use **off()** to deregister the listener.
 
-   1. Configure the launch type of the UIAbility.
-       Set **launchType** of the callee ability to **singleton** in the **module.json5** file.
+     1. Configure the launch type of the UIAbility.
 
-       | JSON Field| Description|
-       | -------- | -------- |
-       | "launchType"| Ability launch type. Set this parameter to **singleton**.|
+         Set **launchType** of the CalleeAbility to **singleton** in the **module.json5** file.
 
-       An example of the UIAbility configuration is as follows:
+         | JSON Field| Description|
+         | -------- | -------- |
+         | "launchType"| UIAbility launch type. Set this parameter to **singleton**.|
 
-       
-       ```json
-       "abilities":[{
-           "name": ".CalleeAbility",
-           "srcEntrance": "./ets/CalleeAbility/CalleeAbility.ts",
-           "launchType": "singleton",
-           "description": "$string:CalleeAbility_desc",
-           "icon": "$media:icon",
-           "label": "$string:CalleeAbility_label",
-           "visible": true
-       }]
-       ```
-   2. Import the **UIAbility** module.
-      
-       ```ts
-       import Ability from '@ohos.app.ability.UIAbility';
-       ```
-   3. Define the agreed parcelable data.
-
-       The data formats sent and received by the caller and callee abilities must be consistent. In the following example, the data formats are number and string.
-
-       
-       ```ts
-       export default class MyParcelable {
-           num: number = 0;
-           str: string = "";
-       
-           constructor(num, string) {
-               this.num = num;
-               this.str = string;
-           }
-       
-           marshalling(messageSequence) {
-               messageSequence.writeInt(this.num);
-               messageSequence.writeString(this.str);
-               return true;
-           }
-       
-           unmarshalling(messageSequence) {
-               this.num = messageSequence.readInt();
-               this.str = messageSequence.readString();
-               return true;
-           }
-       }
-       ```
-   4. Implement **Callee.on** and **Callee.off**.
+         An example of the UIAbility configuration is as follows:
 
-         In the following example, the **MSG_SEND_METHOD** listener is registered in **onCreate()** of the ability and deregistered in **onDestroy()**. After receiving parcelable data, the application processes the data and returns the data result. You need to implement processing based on service requirements.
          
-       ```ts
-       const TAG: string = '[CalleeAbility]';
-       const MSG_SEND_METHOD: string = 'CallSendMsg';
-       
-       function sendMsgCallback(data) {
-           console.info('CalleeSortFunc called');
-       
-           // Obtain the parcelable data sent by the caller ability.
-           let receivedData = new MyParcelable(0, '');
-           data.readParcelable(receivedData);
-           console.info(`receiveData[${receivedData.num}, ${receivedData.str}]`);
-       
-           // Process the data.
-           // Return the parcelable data result to the caller ability.
-           return new MyParcelable(receivedData.num + 1, `send ${receivedData.str} succeed`);
-       }
-       
-       export default class CalleeAbility extends Ability {
-           onCreate(want, launchParam) {
-               try {
-                   this.callee.on(MSG_SEND_METHOD, sendMsgCallback);
-               } catch (error) {
-                   console.info(`${MSG_SEND_METHOD} register failed with error ${JSON.stringify(error)}`);
-               }
-           }
-       
-           onDestroy() {
-               try {
-                   this.callee.off(MSG_SEND_METHOD);
-               } catch (error) {
-                   console.error(TAG, `${MSG_SEND_METHOD} unregister failed with error ${JSON.stringify(error)}`);
-               }
-           }
-       }
-       ```
+         ```json
+         "abilities":[{
+             "name": ".CalleeAbility",
+             "srcEntrance": "./ets/CalleeAbility/CalleeAbility.ts",
+             "launchType": "singleton",
+             "description": "$string:CalleeAbility_desc",
+             "icon": "$media:icon",
+             "label": "$string:CalleeAbility_label",
+             "visible": true
+         }]
+         ```
+     2. Import the **UIAbility** module.
+        
+         ```ts
+         import Ability from '@ohos.app.ability.UIAbility';
+         ```
+     3. Define the agreed parcelable data.
+
+         The data formats sent and received by the CallerAbility and CalleeAbility must be consistent. In the following example, the data formats are number and string.
 
-4. Obtain the caller object and access the callee ability.
+         
+         ```ts
+         export default class MyParcelable {
+             num: number = 0;
+             str: string = "";
+         
+             constructor(num, string) {
+                 this.num = num;
+                 this.str = string;
+             }
+         
+             marshalling(messageSequence) {
+                 messageSequence.writeInt(this.num);
+                 messageSequence.writeString(this.str);
+                 return true;
+             }
+         
+             unmarshalling(messageSequence) {
+                 this.num = messageSequence.readInt();
+                 this.str = messageSequence.readString();
+                 return true;
+             }
+         }
+         ```
+     4. Implement **Callee.on** and **Callee.off**.
+
+           In the following example, the **MSG_SEND_METHOD** listener is registered in **onCreate()** of the UIAbility and deregistered in **onDestroy()**. After receiving parcelable data, the application processes the data and returns the data result. You need to implement processing based on service requirements.
+           
+         ```ts
+         const TAG: string = '[CalleeAbility]';
+         const MSG_SEND_METHOD: string = 'CallSendMsg';
+         
+         function sendMsgCallback(data) {
+             console.info('CalleeSortFunc called');
+         
+             // Obtain the parcelable data sent by the CallerAbility.
+             let receivedData = new MyParcelable(0, '');
+             data.readParcelable(receivedData);
+             console.info(`receiveData[${receivedData.num}, ${receivedData.str}]`);
+         
+             // Process the data.
+             // Return the parcelable data result to the CallerAbility.
+             return new MyParcelable(receivedData.num + 1, `send ${receivedData.str} succeed`);
+         }
+         
+         export default class CalleeAbility extends Ability {
+             onCreate(want, launchParam) {
+                 try {
+                     this.callee.on(MSG_SEND_METHOD, sendMsgCallback);
+                 } catch (error) {
+                     console.info(`${MSG_SEND_METHOD} register failed with error ${JSON.stringify(error)}`);
+                 }
+             }
+         
+             onDestroy() {
+                 try {
+                     this.callee.off(MSG_SEND_METHOD);
+                 } catch (error) {
+                     console.error(TAG, `${MSG_SEND_METHOD} unregister failed with error ${JSON.stringify(error)}`);
+                 }
+             }
+         }
+         ```
+
+4. Obtain the caller object and access the CalleeAbility.
    1. Import the **UIAbility** module.
       
        ```ts
@@ -449,7 +402,7 @@ The following describes how to implement multi-device collaboration through cros
        ```
    2. Obtain the caller object.
 
-       The **context** attribute of the ability implements **startAbilityByCall** to obtain the caller object for communication. The following example uses **this.context** to obtain the **context** attribute of the ability, uses **startAbilityByCall** to start the callee ability, obtain the caller object, and register the **onRelease** listener of the caller ability. You need to implement processing based on service requirements.
+       The **context** attribute of the UIAbility implements **startAbilityByCall** to obtain the caller object for communication. The following example uses **this.context** to obtain the **context** attribute of the UIAbility, uses **startAbilityByCall** to start the CalleeAbility, obtain the caller object, and register the **onRelease** and **onRemoteStateChange** listeners of the CallerAbility. You need to implement processing based on service requirements.
 
        
        ```ts
@@ -465,11 +418,19 @@ The following describes how to implement multi-device collaboration through cros
                if (data != null) {
                    caller = data;
                    console.info('get remote caller success');
-                   // Register the onRelease() listener of the caller ability.
+                   // Register the onRelease listener of the CallerAbility.
                    caller.onRelease((msg) => {
                        console.info(`remote caller onRelease is called ${msg}`);
                    })
                    console.info('remote caller register OnRelease succeed');
+                   // Register the onRemoteStateChange listener of the CallerAbility.
+                   try {
+                        caller.onRemoteStateChange((str) => {
+                            console.log('Remote state changed ' + str);
+                        });
+                    } catch (error) {
+                        console.log('Caller.onRemoteStateChange catch error, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
+                    }
                }
            }).catch((error) => {
                console.error(`get remote caller failed with ${error}`);
@@ -479,8 +440,8 @@ The following describes how to implement multi-device collaboration through cros
 
        For details about how to implement **getRemoteDeviceId()**, see [Starting UIAbility and ServiceExtensionAbility Across Devices (No Data Returned)](#starting-uiability-and-serviceextensionability-across-devices-no-data-returned).
 
-5. Sends agreed parcelable data to the callee ability.
-   1. The parcelable data can be sent to the callee ability with or without a return value. The method and parcelable data must be consistent with those of the callee ability. The following example describes how to send data to the callee ability.
+5. Sends agreed parcelable data to the CalleeAbility.
+   1. The parcelable data can be sent to the CalleeAbility with or without a return value. The method and parcelable data must be consistent with those of the CalleeAbility. The following example describes how to send data to the CalleeAbility.
       
        ```ts
        const MSG_SEND_METHOD: string = 'CallSendMsg';
@@ -493,7 +454,7 @@ The following describes how to implement multi-device collaboration through cros
            }
        }
        ```
-   2. In the following, **CallWithResult** is used to send data **originMsg** to the callee ability and assign the data processed by the **CallSendMsg** method to **backMsg**.
+   2. In the following, **CallWithResult** is used to send data **originMsg** to the CalleeAbility and assign the data processed by the **CallSendMsg** method to **backMsg**.
       
        ```ts
        const MSG_SEND_METHOD: string = 'CallSendMsg';
@@ -517,8 +478,8 @@ The following describes how to implement multi-device collaboration through cros
 
 6. Release the caller object.
 
-     When the caller object is no longer required, use **release()** to release it.
-     
+   When the caller object is no longer required, use **release()** to release it.
+
    ```ts
    releaseCall() {
        try {

en/application-dev/application-models/mission-management-overview.md

@@ -30,102 +30,100 @@ Missions are managed by system applications (such as home screen), rather than t
 
 A UIAbility instance corresponds to an independent mission. Therefore, when an application calls [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) to start a UIAbility, a mission is created.
 
-
-To call [missionManager](../reference/apis/js-apis-application-missionManager.md) to manage missions, the home screen application must request the **ohos.permission.MANAGE_MISSIONS** permission. For details about the configuration, see [Permission Application Guide](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
-
-
-You can use **missionManager** to manage missions, for example, listening for mission changes, obtaining mission information or snapshots, and clearing, locking, or unlocking missions. The sample code is as follows:
-
-
-
-```ts
-import missionManager from '@ohos.app.ability.missionManager'
-
-let listener = {
-    // Listen for mission creation.
-    onMissionCreated: function (mission) {
-        console.info("--------onMissionCreated-------")
-    },
-    // Listen for mission destruction.
-    onMissionDestroyed: function (mission) {
-        console.info("--------onMissionDestroyed-------")
-    },
-    // Listen for mission snapshot changes.
-    onMissionSnapshotChanged: function (mission) {
-        console.info("--------onMissionSnapshotChanged-------")
-    },
-    // Listen for switching the mission to the foreground.
-    onMissionMovedToFront: function (mission) {
-        console.info("--------onMissionMovedToFront-------")
-    },
-    // Listen for mission icon changes.
-    onMissionIconUpdated: function (mission, icon) {
-        console.info("--------onMissionIconUpdated-------")
-    },
-    // Listen for mission name changes.
-    onMissionLabelUpdated: function (mission) {
-        console.info("--------onMissionLabelUpdated-------")
-    },
-    // Listen for mission closure events.
-    onMissionClosed: function (mission) {
-        console.info("--------onMissionClosed-------")
-    }
-};
-
-// 1. Register a mission change listener.
-let listenerId = missionManager.on('mission', listener);
-
-// 2. Obtain the latest 20 missions in the system.
-missionManager.getMissionInfos("", 20, (error, missions) => {
-    console.info("getMissionInfos is called, error.code = " + error.code);
-    console.info("size = " + missions.length);
-    console.info("missions = " + JSON.stringify(missions));
-});
-
-// 3. Obtain the detailed information about a mission.
-let missionId = 11; // The mission ID 11 is only an example.
-let mission = missionManager.getMissionInfo("", missionId).catch(function (err) {
-    console.info(err);
-});
-
-// 4. Obtain the mission snapshot.
-missionManager.getMissionSnapShot("", missionId, (error, snapshot) => {
-    console.info("getMissionSnapShot is called, error.code = " + error.code);
-    console.info("bundleName = " + snapshot.ability.bundleName);
-})
-
-// 5. Obtain the low-resolution mission snapshot.
-missionManager.getLowResolutionMissionSnapShot("", missionId, (error, snapshot) => {
-    console.info("getLowResolutionMissionSnapShot is called, error.code = " + error.code);
-    console.info("bundleName = " + snapshot.ability.bundleName);
-})
-
-// 6. Lock or unlock the mission.
-missionManager.lockMission(missionId).then(() => {
-    console.info("lockMission is called ");
-});
-
-missionManager.unlockMission(missionId).then(() => {
-    console.info("unlockMission is called ");
-});
-
-// 7. Switch the mission to the foreground.
-missionManager.moveMissionToFront(missionId).then(() => {
-    console.info("moveMissionToFront is called ");
-});
-
-// 8. Clear a single mission.
-missionManager.clearMission(missionId).then(() => {
-    console.info("clearMission is called ");
-});
-
-// 9. Clear all missions.
-missionManager.clearAllMissions().catch(function (err) {
-    console.info(err);
-});
-
-// 10. Deregister the mission change listener.
-missionManager.off('mission', listenerId, (error) => {
-    console.info("unregisterMissionListener");
-})
-```
+To call [missionManager](../reference/apis/js-apis-application-missionManager.md) to manage missions, the home screen application must request the **ohos.permission.MANAGE_MISSIONS** permission. For details about the configuration, see [Declaring Permissions in the Configuration File](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
+
+You can use **missionManager** to manage missions, for example, listening for mission changes, obtaining mission information or snapshots, and clearing, locking, or unlocking missions.
+
+   ```ts
+   import missionManager from '@ohos.app.ability.missionManager'
+   
+   let listener = {
+       // Listen for mission creation.
+       onMissionCreated: function (mission) {
+           console.info("--------onMissionCreated-------")
+       },
+       // Listen for mission destruction.
+       onMissionDestroyed: function (mission) {
+           console.info("--------onMissionDestroyed-------")
+       },
+       // Listen for mission snapshot changes.
+       onMissionSnapshotChanged: function (mission) {
+           console.info("--------onMissionSnapshotChanged-------")
+       },
+       // Listen for switching the mission to the foreground.
+       onMissionMovedToFront: function (mission) {
+           console.info("--------onMissionMovedToFront-------")
+       },
+       // Listen for mission icon changes.
+       onMissionIconUpdated: function (mission, icon) {
+           console.info("--------onMissionIconUpdated-------")
+       },
+       // Listen for mission name changes.
+       onMissionLabelUpdated: function (mission) {
+           console.info("--------onMissionLabelUpdated-------")
+       },
+       // Listen for mission closure events.
+       onMissionClosed: function (mission) {
+           console.info("--------onMissionClosed-------")
+       }
+   };
+   
+   // 1. Register a mission change listener.
+   let listenerId = missionManager.on('mission', listener);
+   
+   // 2. Obtain the latest 20 missions in the system.
+   missionManager.getMissionInfos("", 20, (error, missions) => {
+       console.info("getMissionInfos is called, error.code = " + error.code);
+       console.info("size = " + missions.length);
+       console.info("missions = " + JSON.stringify(missions));
+   });
+   
+   // 3. Obtain the detailed information about a mission.
+   let missionId = 11; // The mission ID 11 is only an example.
+   let mission = missionManager.getMissionInfo("", missionId).catch(function (err) {
+       console.info(err);
+   });
+   
+   // 4. Obtain the mission snapshot.
+   missionManager.getMissionSnapShot("", missionId, (error, snapshot) => {
+       console.info("getMissionSnapShot is called, error.code = " + error.code);
+       console.info("bundleName = " + snapshot.ability.bundleName);
+   })
+   
+   // 5. Obtain the low-resolution mission snapshot.
+   missionManager.getLowResolutionMissionSnapShot("", missionId, (error, snapshot) => {
+       console.info("getLowResolutionMissionSnapShot is called, error.code = " + error.code);
+       console.info("bundleName = " + snapshot.ability.bundleName);
+   })
+   
+   // 6. Lock or unlock the mission.
+   missionManager.lockMission(missionId).then(() => {
+       console.info("lockMission is called ");
+   });
+   
+   missionManager.unlockMission(missionId).then(() => {
+       console.info("unlockMission is called ");
+   });
+   
+   // 7. Switch the mission to the foreground.
+   missionManager.moveMissionToFront(missionId).then(() => {
+       console.info("moveMissionToFront is called ");
+   });
+   
+   // 8. Clear a single mission.
+   missionManager.clearMission(missionId).then(() => {
+       console.info("clearMission is called ");
+   });
+   
+   // 9. Clear all missions.
+   missionManager.clearAllMissions().catch(function (err) {
+       console.info(err);
+   });
+   
+   // 10. Deregister the mission change listener.
+   missionManager.off('mission', listenerId, (error) => {
+       console.info("unregisterMissionListener");
+   })
+   ```
+
+   

en/application-dev/application-models/request-permissions.md

@@ -9,37 +9,7 @@ During application development, you must declare the required permission in the
 
 To declare a permission in **config.json**, add **reqPermissions** under **module** and list the permission.
 
+For example, to request the permission to access the calendar, perform the following steps:
 
-For example, to declare the permission to access the calendar, request the **ohos.permission.READ_CALENDAR** permission. For details, see [Permission Application Guide](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
-
-
-The sample code in the **config.json** file is as follows:
-
-```json
-{
-  "module": {
-    // ...
-    "reqPermissions": [
-      {
-        "name": "ohos.permission.READ_CALENDAR"
-        // ...
-      }
-    ]
-  }
-}
-```
-
-
-Request the permission from uses in the form of a dialog box:
-
-```ts
-import featureAbility from '@ohos.ability.featureAbility';
-
-let context = featureAbility.getContext();  
-let permissions: Array<string> = ['ohos.permission.READ_CALENDAR']
-context.requestPermissionsFromUser(permissions, 1).then((data) => {    
-    console.info("Succeed to request permission from user with data: " + JSON.stringify(data))
-}).catch((error) => {    
-    console.info("Failed to request permission from user with error: " + JSON.stringify(error))
-})
-```
+1. Request the **ohos.permission.DISTRIBUTED_DATASYNC** permission. For details, see [Declaring Permissions in the Configuration File](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
+2. Display a dialog box to ask authorization from the user when the application is started for the first time. For details, see [Requesting User Authorization](../security/accesstoken-guidelines.md#requesting-user-authorization).

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

@@ -80,7 +80,7 @@ Before using the APIs provided by **EventHub**, you must obtain an **EventHub**
 4. After **event1** is used, you can call [eventHub.off()](../reference/apis/js-apis-inner-application-eventHub.md#eventhuboff) to unsubscribe from the event.
 
    ```ts
-   // context is the ability-level context of the UIAbility instance.
+   // context is the AbilityContext of the UIAbility instance.
    this.context.eventHub.off('event1');
    ```
 
@@ -240,10 +240,6 @@ The following provides an example to describe the object overwritten problem in
    struct Index {
      onPageShow() {
        let ctx = globalThis.context; // Obtain the context from globalThis and use it.
-       let permissions = ['com.example.permission']
-       ctx.requestPermissionsFromUser(permissions,(result) => {
-          // ...
-       });
      }
      // Page display.
      build() {
@@ -251,7 +247,7 @@ The following provides an example to describe the object overwritten problem in
      }
    }
    ```
-
+   
 3. In the UIAbilityB file, [UIAbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md) is stored in **globalThis** and has the same name as that in the UIAbilityA file.
 
    ```ts
@@ -274,10 +270,6 @@ The following provides an example to describe the object overwritten problem in
    struct Index {
      onPageShow() {
        let ctx = globalThis.context; // Obtain the context from globalThis and use it.
-       let permissions = ['com.example.permission']
-       ctx.requestPermissionsFromUser(permissions,(result) => {
-         console.info('requestPermissionsFromUser result:' + JSON.stringify(result));
-       });
      }
      // Page display.
      build() {
@@ -285,7 +277,7 @@ The following provides an example to describe the object overwritten problem in
      }
    }
    ```
-
+   
 5. Switch the UIAbilityB instance to the background and switch the UIAbilityA instance to the foreground. In this case, UIAbilityA will not enter the **onCreate()** lifecycle again.
 
    ```ts
@@ -307,10 +299,6 @@ The following provides an example to describe the object overwritten problem in
    struct Index {
      onPageShow() {
        let ctx = globalThis.context; // The context in globalThis is the context of UIAbilityB.
-       let permissions=['com.example.permission'];
-       ctx.requestPermissionsFromUser(permissions,(result) => { // Using this object causes a process breakdown.
-          console.info('requestPermissionsFromUser result:' + JSON.stringify(result));
-       });
      }
      // Page display.
      build() {

en/application-dev/application-models/uiability-intra-device-interaction.md

@@ -19,7 +19,7 @@ This topic describes the UIAbility interaction modes in the following scenarios.
 
 - [Starting a Specified Page of UIAbility](#starting-a-specified-page-of-uiability)
 
-- [Using Ability Call to Implement UIAbility Interaction (for System Applications Only)](#using-ability-call-to-implement-uiability-interaction-for-system-applications-only)
+- [Using Call to Implement UIAbility Interaction (for System Applications Only)](#using-call-to-implement-uiability-interaction-for-system-applications-only)
 
 
 ## Starting UIAbility in the Same Application
@@ -31,45 +31,52 @@ Assume that your application has two UIAbility components: EntryAbility and Func
 1. In EntryAbility, call [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) to start UIAbility. The [want](../reference/apis/js-apis-app-ability-want.md) parameter is the entry parameter for starting the UIAbility instance. In the **want** parameter, **bundleName** indicates the bundle name of the application to start; **abilityName** indicates the name of the UIAbility to start; **moduleName** is required only when the target UIAbility belongs to a different module; **parameters** is used to carry custom information. For details about how to obtain the context, see [Obtaining the Context of UIAbility](uiability-usage.md#obtaining-the-context-of-uiability).
    
    ```ts
+   let context = ...; // UIAbilityContext
    let wantInfo = {
-       deviceId: '', // An empty deviceId indicates the local device.
-       bundleName: 'com.example.myapplication',
-       abilityName: 'FuncAbility',
-       moduleName: 'module1', // moduleName is optional.
-       parameters: {// Custom information.
-           info: 'From the Index page of EntryAbility',
-       },
+     deviceId: '', // An empty deviceId indicates the local device.
+     bundleName: 'com.example.myapplication',
+     abilityName: 'FuncAbility',
+     moduleName: 'module1', // moduleName is optional.
+     parameters: {// Custom information.
+       info: 'From the Index page of EntryAbility',
+     },
    }
-   // context is the ability-level context of the initiator UIAbility.
-   this.context.startAbility(wantInfo).then(() => {
-       // ...
+   // context is the UIAbilityContext of the initiator UIAbility.
+   context.startAbility(wantInfo).then(() => {
+     // ...
    }).catch((err) => {
-       // ...
+     // ...
    })
    ```
-
-2. Use the FuncAbility lifecycle callback to receive the parameters passed from EntryAbility.
+   
+2. In FuncAbility, use [onCreate()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityoncreate) or [onNewWant()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityonnewwant) to receive the parameters passed in by EntryAbility.
    
    ```ts
    import UIAbility from '@ohos.app.ability.UIAbility';
    import window from '@ohos.window';
    
    export default class FuncAbility extends UIAbility {
-       onCreate(want, launchParam) {
-   	// Receive the parameters passed by the caller UIAbility.
-           let funcAbilityWant = want;
-           let info = funcAbilityWant?.parameters?.info;
-           // ...
-       }
+     onCreate(want, launchParam) {
+       // Receive the parameters passed by the initiator UIAbility.
+       let funcAbilityWant = want;
+       let info = funcAbilityWant?.parameters?.info;
+       // ...
+     }
    }
    ```
 
+   > **NOTE**<br>
+   >
+   > In FuncAbility started, you can obtain the PID and bundle name of the UIAbility through **parameters** in the passed **want** parameter.
+   
 3. To stop the **UIAbility** instance after the FuncAbility service is complete, call [terminateSelf()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateself) in FuncAbility.
    
    ```ts
-   // context is the ability-level context of the UIAbility instance to stop.
-   this.context.terminateSelf((err) => {
-       // ...
+   let context = ...; // UIAbilityContext
+   
+   // context is the UIAbilityContext of the UIAbility instance to stop.
+   context.terminateSelf((err) => {
+     // ...
    });
    ```
    
@@ -87,67 +94,70 @@ When starting FuncAbility from EntryAbility, you want the result to be returned
 1. In EntryAbility, call [startAbilityForResult()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateselfwithresult) to start FuncAbility. Use **data** in the asynchronous callback to receive information returned after FuncAbility stops itself. For details about how to obtain the context, see [Obtaining the Context of UIAbility](uiability-usage.md#obtaining-the-context-of-uiability).
    
    ```ts
+   let context = ...; // UIAbilityContext
    let wantInfo = {
-       deviceId: '', // An empty deviceId indicates the local device.
-       bundleName: 'com.example.myapplication',
-       abilityName: 'FuncAbility',
-       moduleName: 'module1', // moduleName is optional.
-       parameters: {// Custom information.
-           info: 'From the Index page of EntryAbility',
-       },
+     deviceId: '', // An empty deviceId indicates the local device.
+     bundleName: 'com.example.myapplication',
+     abilityName: 'FuncAbility',
+     moduleName: 'module1', // moduleName is optional.
+     parameters: {// Custom information.
+       info: 'From the Index page of EntryAbility',
+     },
    }
-   // context is the ability-level context of the initiator UIAbility.
-   this.context.startAbilityForResult(wantInfo).then((data) => {
-       // ...
+   // context is the UIAbilityContext of the initiator UIAbility.
+   context.startAbilityForResult(wantInfo).then((data) => {
+     // ...
    }).catch((err) => {
-       // ...
+     // ...
    })
    ```
-
+   
 2. Call [terminateSelfWithResult()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateselfwithresult) to stop FuncAbility. Use the input parameter **abilityResult** to carry the information that FuncAbility needs to return to EntryAbility.
    
    ```ts
+   let context = ...; // UIAbilityContext
    const RESULT_CODE: number = 1001;
    let abilityResult = {
-       resultCode: RESULT_CODE,
-       want: {
-           bundleName: 'com.example.myapplication',
-           abilityName: 'FuncAbility',
-           moduleName: 'module1',
-           parameters: {
-               info: 'From the Index page of FuncAbility',
-           },
+     resultCode: RESULT_CODE,
+     want: {
+       bundleName: 'com.example.myapplication',
+       abilityName: 'FuncAbility',
+       moduleName: 'module1',
+       parameters: {
+         info: 'From the Index page of FuncAbility',
        },
+     },
    }
-   // context is the ability-level context of the callee UIAbility.
-   this.context.terminateSelfWithResult(abilityResult, (err) => {
-       // ...
+   // context is the AbilityContext of the target UIAbility.
+   context.terminateSelfWithResult(abilityResult, (err) => {
+     // ...
    });
    ```
-
+   
 3. After FuncAbility stops itself, EntryAbility uses [startAbilityForResult()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateselfwithresult) to receive the information returned by FuncAbility. The value of **RESULT_CODE** must be the same as the preceding value.
    
    ```ts
+   let context = ...; // UIAbilityContext
    const RESULT_CODE: number = 1001;
    
    // ...
    
-   // context is the ability-level context of the initiator UIAbility.
-   this.context.startAbilityForResult(want).then((data) => {
-       if (data?.resultCode === RESULT_CODE) {
-           // Parse the information returned by the callee UIAbility.
-           let info = data.want?.parameters?.info;
-           // ...
-       }
-   }).catch((err) => {
+   // context is the UIAbilityContext of the initiator UIAbility.
+   context.startAbilityForResult(wantInfo).then((data) => {
+     if (data?.resultCode === RESULT_CODE) {
+       // Parse the information returned by the target UIAbility.
+       let info = data.want?.parameters?.info;
        // ...
+     }
+   }).catch((err) => {
+     // ...
    })
    ```
 
 
 ## Starting UIAbility of Another Application
 
-Generally, the user only needs to do a common operation (for example, selecting a document application to view the document content) to start the UIAbility of another application. The [implicit Want launch mode](want-overview.md#types-of-want) is recommended. The system identifies a matched UIAbility and starts it based on the **want** parameter of the caller.
+Generally, the user only needs to do a common operation (for example, selecting a document application to view the document content) to start the UIAbility of another application. The [implicit Want launch mode](want-overview.md#types-of-want) is recommended. The system identifies a matched UIAbility and starts it based on the **want** parameter of the initiator UIAbility.
 
 There are two ways to start **UIAbility**: [explicit and implicit](want-overview.md).
 
@@ -183,35 +193,38 @@ This section describes how to start the UIAbility of another application through
    }
    ```
 
-2. Include **entities** and **actions** of the caller's **want** parameter into **entities** and **actions** under **skills** of the target UIAbility. After the system matches the UIAbility that meets the **entities** and **actions** information, a dialog box is displayed, showing the list of matched UIAbility instances for users to select. For details about how to obtain the context, see [Obtaining the Context of UIAbility](uiability-usage.md#obtaining-the-context-of-uiability).
+2. Include **entities** and **actions** of the initiator UIAbility's **want** parameter into **entities** and **actions** under **skills** of the target UIAbility. After the system matches the UIAbility that meets the **entities** and **actions** information, a dialog box is displayed, showing the list of matched UIAbility instances for users to select. For details about how to obtain the context, see [Obtaining the Context of UIAbility](uiability-usage.md#obtaining-the-context-of-uiability).
    
    ```ts
+   let context = ...; // UIAbilityContext
    let wantInfo = {
-       deviceId: '', // An empty deviceId indicates the local device.
-       // Uncomment the line below if you want to implicitly query data only in the specific bundle.
-       // bundleName: 'com.example.myapplication',
-       action: 'ohos.want.action.viewData',
-       // entities can be omitted.
-       entities: ['entity.system.default'],
+     deviceId: '', // An empty deviceId indicates the local device.
+     // Uncomment the line below if you want to implicitly query data only in the specific bundle.
+     // bundleName: 'com.example.myapplication',
+     action: 'ohos.want.action.viewData',
+     // entities can be omitted.
+     entities: ['entity.system.default'],
    }
    
-   // context is the ability-level context of the initiator UIAbility.
-   this.context.startAbility(wantInfo).then(() => {
-       // ...
+   // context is the UIAbilityContext of the initiator UIAbility.
+   context.startAbility(wantInfo).then(() => {
+     // ...
    }).catch((err) => {
-       // ...
+     // ...
    })
    ```
-
-   The following figure shows the effect. When you click **Open PDF**, a dialog box is displayed for you to select.
+   
+   The following figure shows the effect. When you click **Open PDF**, a dialog box is displayed for you to select.  
    ![](figures/uiability-intra-device-interaction.png)
    
 3. To stop the **UIAbility** instance after the document application is used, call [terminateSelf()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateself).
    
    ```ts
-   // context is the ability-level context of the UIAbility instance to stop.
-   this.context.terminateSelf((err) => {
-       // ...
+   let context = ...; // UIAbilityContext
+   
+   // context is the AbilityContext of the UIAbility instance to stop.
+   context.terminateSelf((err) => {
+     // ...
    });
    ```
 
@@ -246,65 +259,68 @@ If you want to obtain the return result when using implicit Want to start the UI
    }
    ```
 
-2. Call [startAbilityForResult()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateselfwithresult) to start the UIAbility of the payment application. Include **entities** and **actions** of the caller's **want** parameter into **entities** and **actions** under **skills** of the target UIAbility. Use **data** in the asynchronous callback to receive the information returned to the caller after the payment UIAbility stops itself. After the system matches the UIAbility that meets the **entities** and **actions** information, a dialog box is displayed, showing the list of matched UIAbility instances for users to select.
+2. Call [startAbilityForResult()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateselfwithresult) to start the UIAbility of the payment application. Include **entities** and **actions** of the initiator UIAbility's **want** parameter into **entities** and **actions** under **skills** of the target UIAbility. Use **data** in the asynchronous callback to receive the information returned to the initiator UIAbility after the payment UIAbility stops itself. After the system matches the UIAbility that meets the **entities** and **actions** information, a dialog box is displayed, showing the list of matched UIAbility instances for users to select.
    
    ```ts
+   let context = ...; // UIAbilityContext
    let wantInfo = {
-       deviceId: '', // An empty deviceId indicates the local device.
-       // Uncomment the line below if you want to implicitly query data only in the specific bundle.
-       // bundleName: 'com.example.myapplication',
-       action: 'ohos.want.action.editData',
-       // entities can be omitted.
-       entities: ['entity.system.default'],
+     deviceId: '', // An empty deviceId indicates the local device.
+     // Uncomment the line below if you want to implicitly query data only in the specific bundle.
+     // bundleName: 'com.example.myapplication',
+     action: 'ohos.want.action.editData',
+     // entities can be omitted.
+     entities: ['entity.system.default'],
    }
    
-   // context is the ability-level context of the initiator UIAbility.
-   this.context.startAbilityForResult(wantInfo).then((data) => {
-       // ...
+   // context is the UIAbilityContext of the initiator UIAbility.
+   context.startAbilityForResult(wantInfo).then((data) => {
+     // ...
    }).catch((err) => {
-       // ...
+     // ...
    })
    ```
-
+   
 3. After the payment is finished, call [terminateSelfWithResult()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateselfwithresult) to stop the payment UIAbility and return the **abilityResult** parameter.
    
    ```ts
+   let context = ...; // UIAbilityContext
    const RESULT_CODE: number = 1001;
    let abilityResult = {
-       resultCode: RESULT_CODE,
-       want: {
-           bundleName: 'com.example.myapplication',
-           abilityName: 'EntryAbility',
-           moduleName: 'entry',
-           parameters: {
-               payResult: 'OKay',
-           },
+     resultCode: RESULT_CODE,
+     want: {
+       bundleName: 'com.example.myapplication',
+       abilityName: 'EntryAbility',
+       moduleName: 'entry',
+       parameters: {
+         payResult: 'OKay',
        },
+     },
    }
-   // context is the ability-level context of the callee UIAbility.
-   this.context.terminateSelfWithResult(abilityResult, (err) => {
-       // ...
+   // context is the AbilityContext of the target UIAbility.
+   context.terminateSelfWithResult(abilityResult, (err) => {
+     // ...
    });
    ```
-
+   
 4. Receive the information returned by the payment application in the callback of the [startAbilityForResult()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateselfwithresult) method. The value of **RESULT_CODE** must be the same as that returned by [terminateSelfWithResult()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextterminateselfwithresult).
    
    ```ts
+   let context = ...; // UIAbilityContext
    const RESULT_CODE: number = 1001;
    
    let want = {
      // Want parameter information.
    };
    
-   // context is the ability-level context of the initiator UIAbility.
-   this.context.startAbilityForResult(want).then((data) => {
-       if (data?.resultCode === RESULT_CODE) {
-           // Parse the information returned by the callee UIAbility.
-           let payResult = data.want?.parameters?.payResult;
-           // ...
-       }
-   }).catch((err) => {
+   // context is the UIAbilityContext of the initiator UIAbility.
+   context.startAbilityForResult(want).then((data) => {
+     if (data?.resultCode === RESULT_CODE) {
+       // Parse the information returned by the target UIAbility.
+       let payResult = data.want?.parameters?.payResult;
        // ...
+     }
+   }).catch((err) => {
+     // ...
    })
    ```
 
@@ -323,7 +339,7 @@ The window mode is specified by the **windowMode** field in the [StartOptions](.
 > **NOTE**
 >
 > 1. If the **windowMode** field is not specified, the UIAbility is started in the default window mode.
-> 2. To ensure that the application can be displayed in the required window mode, check the **supportWindowMode** field in the [abilities tag](../quick-start/module-configuration-file.md#abilities) in the [module.json5 file](../quick-start/module-configuration-file.md) of the UIAbility and make sure the specified window mode is supported.
+> 2. To ensure that the application can be displayed in the required window mode, check the **supportWindowMode** field in the [abilities](../quick-start/module-configuration-file.md#abilities) tag in the [module.json5 file](../quick-start/module-configuration-file.md) of the UIAbility and make sure the specified window mode is supported.
 
 The following uses the floating window mode as an example to describe how to start the FuncAbility from the EntryAbility page.
 
@@ -335,6 +351,7 @@ For details about how to obtain the context, see [Obtaining the Context of UIAbi
 ```ts
 import AbilityConstant from '@ohos.app.ability.AbilityConstant';
 
+let context = ...; // UIAbilityContext
 let wantInfo = {
   deviceId: '', // An empty deviceId indicates the local device.
   bundleName: 'com.example.myapplication',
@@ -347,8 +364,8 @@ let wantInfo = {
 let options = {
   windowMode: AbilityConstant.WindowMode.WINDOW_MODE_FLOATING
 }
-// context is the ability-level context of the initiator UIAbility.
-this.context.startAbility(wantInfo, options).then(() => {
+// context is the UIAbilityContext of the initiator UIAbility.
+context.startAbility(wantInfo, options).then(() => {
   // ...
 }).catch((err) => {
   // ...
@@ -365,10 +382,11 @@ A UIAbility component can have multiple pages. When it is started in different s
 
 ### Specifying a Startup Page
 
-When the caller UIAbility starts another UIAbility, it usually needs to redirect to a specified page. For example, FuncAbility contains two pages: Index (corresponding to the home page) and Second (corresponding to function A page). You can configure the specified page URL in the **want** parameter by adding a custom parameter to **parameters** in **want**. For details about how to obtain the context, see [Obtaining the Context of UIAbility](uiability-usage.md#obtaining-the-context-of-uiability).
+When the initiator UIAbility starts another UIAbility, it usually needs to redirect to a specified page. For example, FuncAbility contains two pages: Index (corresponding to the home page) and Second (corresponding to function A page). You can configure the specified page URL in the **want** parameter by adding a custom parameter to **parameters** in **want**. For details about how to obtain the context, see [Obtaining the Context of UIAbility](uiability-usage.md#obtaining-the-context-of-uiability).
 
 
 ```ts
+let context = ...; // UIAbilityContext
 let wantInfo = {
     deviceId: '', // An empty deviceId indicates the local device.
     bundleName: 'com.example.myapplication',
@@ -378,8 +396,8 @@ let wantInfo = {
         router: 'funcA',
     },
 }
-// context is the ability-level context of the initiator UIAbility.
-this.context.startAbility(wantInfo).then(() => {
+// context is the UIAbilityContext of the initiator UIAbility.
+context.startAbility(wantInfo).then(() => {
     // ...
 }).catch((err) => {
     // ...
@@ -397,25 +415,25 @@ import UIAbility from '@ohos.app.ability.UIAbility'
 import Window from '@ohos.window'
 
 export default class FuncAbility extends UIAbility {
-    funcAbilityWant;
-
-    onCreate(want, launchParam) {
-        // Receive the parameters passed by the caller UIAbility.
-        this.funcAbilityWant = want;
-    }
-
-    onWindowStageCreate(windowStage: Window.WindowStage) {
-        // Main window is created. Set a main page for this ability.
-        let url = 'pages/Index';
-        if (this.funcAbilityWant?.parameters?.router) {
-            if (this.funcAbilityWant.parameters.router === 'funA') {
-                url = 'pages/Second';
-            }
-        }
-        windowStage.loadContent(url, (err, data) => {
-            // ...
-        });
+  funcAbilityWant;
+
+  onCreate(want, launchParam) {
+    // Receive the parameters passed by the initiator UIAbility.
+    this.funcAbilityWant = want;
+  }
+
+  onWindowStageCreate(windowStage: Window.WindowStage) {
+    // Main window is created. Set a main page for this UIAbility.
+    let url = 'pages/Index';
+    if (this.funcAbilityWant?.parameters?.router) {
+      if (this.funcAbilityWant.parameters.router === 'funA') {
+        url = 'pages/Second';
+      }
     }
+    windowStage.loadContent(url, (err, data) => {
+      // ...
+    });
+  }
 }
 ```
 
@@ -434,11 +452,11 @@ In summary, when a UIAbility instance of application A has been created and the
    import UIAbility from '@ohos.app.ability.UIAbility'
    
    export default class FuncAbility extends UIAbility {
-       onNewWant(want, launchParam) {
-           // Receive the parameters passed by the caller UIAbility.
-           globalThis.funcAbilityWant = want;
-           // ...
-       }
+     onNewWant(want, launchParam) {
+       // Receive the parameters passed by the initiator UIAbility.
+       globalThis.funcAbilityWant = want;
+       // ...
+     }
    }
    ```
 
@@ -469,215 +487,200 @@ In summary, when a UIAbility instance of application A has been created and the
 
 > **NOTE**
 >
-> When the [launch type of the callee UIAbility](uiability-launch-type.md) is set to **standard**, a new instance is created each time the callee UIAbility is started. In this case, the [onNewWant()](../reference/apis/js-apis-app-ability-uiAbility.md#abilityonnewwant) callback will not be invoked.
+> When the [launch type of the target UIAbility](uiability-launch-type.md) is set to **standard**, a new instance is created each time the target UIAbility is started. In this case, the [onNewWant()](../reference/apis/js-apis-app-ability-uiAbility.md#abilityonnewwant) callback will not be invoked.
 
 
-## Using Ability Call to Implement UIAbility Interaction (for System Applications Only)
+## Using Call to Implement UIAbility Interaction (for System Applications Only)
 
-Ability call is an extension of the UIAbility capability. It enables the UIAbility to be invoked by and communicate with external systems. The UIAbility invoked can be either started in the foreground or created and run in the background. You can use the ability call to implement data sharing between two UIAbility instances (caller ability and callee ability) through IPC.
+Call is an extension of the UIAbility capability. It enables the UIAbility to be invoked by and communicate with external systems. The UIAbility invoked can be either started in the foreground or created and run in the background. You can use the call to implement data sharing between two UIAbility instances (CallerAbility and CalleeAbility) through IPC.
 
-The core API used for the ability call is **startAbilityByCall**, which differs from **startAbility** in the following ways:
+The core API used for the call is **startAbilityByCall**, which differs from **startAbility** in the following ways:
 
-- **startAbilityByCall** supports ability launch in the foreground and background, whereas **startAbility** supports ability launch in the foreground only.
+- **startAbilityByCall** supports UIAbility launch in the foreground and background, whereas **startAbility** supports UIAbility launch in the foreground only.
 
-- The caller ability can use the caller object returned by **startAbilityByCall** to communicate with the callee ability, but **startAbility** does not provide the communication capability.
+- The CallerAbility can use the caller object returned by **startAbilityByCall** to communicate with the CalleeAbility, but **startAbility** does not provide the communication capability.
 
-Ability call is usually used in the following scenarios:
+Call is usually used in the following scenarios:
 
-- Communicating with the callee ability
+- Communicating with the CalleeAbility
 
-- Starting the callee ability in the background
+- Starting the CalleeAbility in the background
 
-**Table 1** Terms used in the ability call
+**Table 1** Terms used in the call
 
 | **Term**| Description|
 | -------- | -------- |
-| CallerAbility | UIAbility that triggers the ability call.|
-| CalleeAbility | UIAbility invoked by the ability call.|
-| Caller | Object returned by **startAbilityByCall** and used by the caller ability to communicate with the callee ability.|
-| Callee | Object held by the callee ability to communicate with the caller ability.|
+| CallerAbility| UIAbility that triggers the call.|
+| CalleeAbility | UIAbility invoked by the call.|
+| Caller | Object returned by **startAbilityByCall** and used by the CallerAbility to communicate with the CalleeAbility.|
+| Callee | Object held by the CalleeAbility to communicate with the CallerAbility.|
 
-The following figure shows the ability call process.
+The following figure shows the call process.
 
-  Figure 1 Ability call process
+  Figure 1 Call process
 
   ![call](figures/call.png)  
 
-- The caller ability uses **startAbilityByCall** to obtain a caller object and uses **call()** of the caller object to send data to the callee ability.
+- The CallerAbility uses **startAbilityByCall** to obtain a caller object and uses **call()** of the caller object to send data to the CalleeAbility.
 
-- The callee ability, which holds a **Callee** object, uses **on()** of the **Callee** object to register a callback. This callback is invoked when the callee ability receives data from the caller ability.
+- The CalleeAbility, which holds a **Callee** object, uses **on()** of the **Callee** object to register a callback. This callback is invoked when the CalleeAbility receives data from the CallerAbility.
 
 > **NOTE**
-> 1. Currently, only system applications can use the ability call.
+> 1. Currently, only system applications can use the call.
 > 
-> 2. The launch type of the callee ability must be **singleton**.
+> 2. The launch type of the CalleeAbility must be **singleton**.
 > 
-> 3. Both local (intra-device) and cross-device ability calls are supported. The following describes how to initiate a local call. For details about how to initiate a cross-device ability call, see [Using Cross-Device Ability Call](hop-multi-device-collaboration.md#using-cross-device-ability-call).
+> 3. Both local (intra-device) and cross-device calls are supported. The following describes how to initiate a local call. For details about how to initiate a cross-device call, see [Using Cross-Device Call](hop-multi-device-collaboration.md#using-cross-device-call).
 
 
 ### Available APIs
 
-The following table describes the main APIs used for the ability call. For details, see [AbilityContext](../reference/apis/js-apis-app-ability-uiAbility.md#caller).
+The following table describes the main APIs used for the call. For details, see [AbilityContext](../reference/apis/js-apis-app-ability-uiAbility.md#caller).
 
-**Table 2** Ability call APIs
+  **Table 2** Call APIs
 
 | API| Description|
 | -------- | -------- |
 | startAbilityByCall(want: Want): Promise&lt;Caller&gt; | Starts a UIAbility in the foreground (through the **want** configuration) or background (default) and obtains the caller object for communication with the UIAbility. For details, see [AbilityContext](../reference/apis/js-apis-inner-application-uiAbilityContext.md#abilitycontextstartabilitybycall) or [ServiceExtensionContext](../reference/apis/js-apis-inner-application-serviceExtensionContext.md#serviceextensioncontextstartabilitybycall).|
-| on(method: string, callback: CalleeCallBack): void | Callback invoked when the callee ability registers a method.|
-| off(method: string): void | Callback invoked when the callee ability deregisters a method.|
-| call(method: string, data: rpc.Parcelable): Promise&lt;void&gt; | Sends agreed parcelable data to the callee ability.|
-| callWithResult(method: string, data: rpc.Parcelable): Promise&lt;rpc.MessageSequence&gt; | Sends agreed parcelable data to the callee ability and obtains the agreed parcelable data returned by the callee ability.|
+| on(method: string, callback: CalleeCallBack): void | Callback invoked when the CalleeAbility registers a method.|
+| off(method: string): void | Callback invoked when the CalleeAbility deregisters a method.|
+| call(method: string, data: rpc.Parcelable): Promise&lt;void&gt; | Sends agreed parcelable data to the CalleeAbility.|
+| callWithResult(method: string, data: rpc.Parcelable): Promise&lt;rpc.MessageSequence&gt; | Sends agreed parcelable data to the CalleeAbility and obtains the agreed parcelable data returned by the CalleeAbility.|
 | release(): void | Releases the caller object.|
 | on(type: "release", callback: OnReleaseCallback): void | Callback invoked when the caller object is released.|
 
-The implementation of using the ability call for UIAbility interaction involves two parts.
+The implementation of using the call for UIAbility interaction involves two parts.
 
-- [Creating a Callee Ability](#creating-a-callee-ability)
+- [Creating a CalleeAbility](#creating-a-calleeability)
 
-- [Accessing the Callee Ability](#accessing-the-callee-ability)
+- [Accessing the CalleeAbility](#accessing-the-calleeability)
 
 
-### Creating a Callee Ability
+### Creating a CalleeAbility
 
-For the callee ability, implement the callback to receive data and the methods to marshal and unmarshal data. When data needs to be received, use **on()** to register a listener. When data does not need to be received, use **off()** to deregister the listener.
+For the CalleeAbility, implement the callback to receive data and the methods to marshal and unmarshal data. When data needs to be received, use **on()** to register a listener. When data does not need to be received, use **off()** to deregister the listener.
 
-1. Configure the ability launch type.
-   
-   Set **launchType** of the callee ability to **singleton** in the **module.json5** file.
+1. Configure the launch type of the UIAbility.
    
-   | JSON Field| Description|
-   | -------- | -------- |
-   | "launchType" | Ability launch type. Set this parameter to **singleton**.|
-   
-   An example of the ability configuration is as follows:
-   
-   
-   ```json
-   "abilities":[{
-     "name": ".CalleeAbility",
-     "srcEntrance": "./ets/CalleeAbility/CalleeAbility.ts",
-     "launchType": "singleton",
-     "description": "$string:CalleeAbility_desc",
-     "icon": "$media:icon",
-     "label": "$string:CalleeAbility_label",
-     "visible": true
-   }]
-   ```
+   For example, set the launch type of the CalleeAbility to **singleton**. For details, see [UIAbility Component Launch Type](uiability-launch-type.md).
    
 2. Import the **UIAbility** module.
-
+   
    ```ts
-   import Ability from '@ohos.app.ability.UIAbility';
+   import UIAbility from '@ohos.app.ability.UIAbility';
    ```
 
 3. Define the agreed parcelable data.
 
-   The data formats sent and received by the caller and callee abilities must be consistent. In the following example, the data formats are number and string.
-   
+   The data formats sent and received by the CallerAbility and CalleeAbility must be consistent. In the following example, the data formats are number and string.
+
    
    ```ts
    export default class MyParcelable {
-       num: number = 0
-       str: string = ""
+     num: number = 0;
+     str: string = '';
    
-       constructor(num, string) {
-           this.num = num
-           this.str = string
-       }
+     constructor(num, string) {
+       this.num = num;
+       this.str = string;
+     }
    
-       marshalling(messageSequence) {
-           messageSequence.writeInt(this.num)
-           messageSequence.writeString(this.str)
-           return true
-       }
+     marshalling(messageSequence) {
+       messageSequence.writeInt(this.num);
+       messageSequence.writeString(this.str);
+       return true
+     }
    
-       unmarshalling(messageSequence) {
-           this.num = messageSequence.readInt()
-           this.str = messageSequence.readString()
-           return true
-       }
+     unmarshalling(messageSequence) {
+       this.num = messageSequence.readInt();
+       this.str = messageSequence.readString();
+       return true;
+     }
    }
    ```
 
 4. Implement **Callee.on** and **Callee.off**.
 
-   The time to register a listener for the callee ability depends on your application. The data sent and received before the listener is registered and that after the listener is deregistered are not processed. In the following example, the **MSG_SEND_METHOD** listener is registered in **onCreate** of the ability and deregistered in **onDestroy**. After receiving parcelable data, the application processes the data and returns the data result. You need to implement processing based on service requirements. The sample code is as follows:
+   The time to register a listener for the CalleeAbility depends on your application. The data sent and received before the listener is registered and that after the listener is deregistered are not processed. In the following example, the **MSG_SEND_METHOD** listener is registered in **onCreate** of the UIAbility and deregistered in **onDestroy**. After receiving parcelable data, the application processes the data and returns the data result. You need to implement processing based on service requirements. The sample code is as follows:
+
+   
    ```ts
    const TAG: string = '[CalleeAbility]';
    const MSG_SEND_METHOD: string = 'CallSendMsg';
    
    function sendMsgCallback(data) {
-       console.info('CalleeSortFunc called');
+     console.info('CalleeSortFunc called');
    
-       // Obtain the parcelable data sent by the caller ability.
-       let receivedData = new MyParcelable(0, '');
-       data.readParcelable(receivedData);
-       console.info(`receiveData[${receivedData.num}, ${receivedData.str}]`);
+     // Obtain the parcelable data sent by the CallerAbility.
+     let receivedData = new MyParcelable(0, '');
+     data.readParcelable(receivedData);
+     console.info(`receiveData[${receivedData.num}, ${receivedData.str}]`);
    
-       // Process the data.
-       // Return the parcelable data result to the caller ability.
-       return new MyParcelable(receivedData.num + 1, `send ${receivedData.str} succeed`);
+     // Process the data.
+     // Return the parcelable data result to the CallerAbility.
+     return new MyParcelable(receivedData.num + 1, `send ${receivedData.str} succeed`);
    }
    
-   export default class CalleeAbility extends Ability {
-       onCreate(want, launchParam) {
-           try {
-               this.callee.on(MSG_SEND_METHOD, sendMsgCallback);
-           } catch (error) {
-               console.info(`${MSG_SEND_METHOD} register failed with error ${JSON.stringify(error)}`);
-           }
+   export default class CalleeAbility extends UIAbility {
+     onCreate(want, launchParam) {
+       try {
+         this.callee.on(MSG_SEND_METHOD, sendMsgCallback);
+       } catch (error) {
+         console.info(`${MSG_SEND_METHOD} register failed with error ${JSON.stringify(error)}`);
        }
+     }
    
-       onDestroy() {
-           try {
-               this.callee.off(MSG_SEND_METHOD);
-           } catch (error) {
-               console.error(TAG, `${MSG_SEND_METHOD} unregister failed with error ${JSON.stringify(error)}`);
-           }
+     onDestroy() {
+       try {
+         this.callee.off(MSG_SEND_METHOD);
+       } catch (error) {
+         console.error(TAG, `${MSG_SEND_METHOD} unregister failed with error ${JSON.stringify(error)}`);
        }
+     }
    }
    ```
 
-### Accessing the Callee Ability
+
+### Accessing the CalleeAbility
 
 1. Import the **UIAbility** module.
    
    ```ts
-   import Ability from '@ohos.app.ability.UIAbility';
+   import UIAbility from '@ohos.app.ability.UIAbility';
    ```
 
 2. Obtain the caller interface.
 
-   The **context** attribute of the ability implements **startAbilityByCall** to obtain the caller object for communication. The following example uses **this.context** to obtain the **context** attribute of the ability, uses **startAbilityByCall** to start the callee ability, obtain the caller object, and register the **onRelease** listener of the caller ability. You need to implement processing based on service requirements.
+   The **UIAbilityContext** attribute implements **startAbilityByCall** to obtain the caller object for communication. The following example uses **this.context** to obtain the **UIAbilityContext**, uses **startAbilityByCall** to start the CalleeAbility, obtain the caller object, and register the **onRelease** listener of the CallerAbility. You need to implement processing based on service requirements.
+
    
    ```ts
-   // Register the onRelease() listener of the caller ability.
+   // Register the onRelease() listener of the CallerAbility.
    private regOnRelease(caller) {
-       try {
-           caller.on("release", (msg) => {
-               console.info(`caller onRelease is called ${msg}`);
-           })
-           console.info('caller register OnRelease succeed');
-       } catch (error) {
-           console.info(`caller register OnRelease failed with ${error}`);
-       }
+     try {
+       caller.on('release', (msg) => {
+         console.info(`caller onRelease is called ${msg}`);
+       })
+       console.info('caller register OnRelease succeed');
+     } catch (error) {
+       console.info(`caller register OnRelease failed with ${error}`);
+     }
    }
    
    async onButtonGetCaller() {
-       try {
-           this.caller = await context.startAbilityByCall({
-               bundleName: 'com.samples.CallApplication',
-               abilityName: 'CalleeAbility'
-           })
-           if (this.caller === undefined) {
-               console.info('get caller failed')
-               return
-           }
-           console.info('get caller success')
-           this.regOnRelease(this.caller)
-       } catch (error) {
-           console.info(`get caller failed with ${error}`)
+     try {
+       this.caller = await context.startAbilityByCall({
+         bundleName: 'com.samples.CallApplication',
+         abilityName: 'CalleeAbility'
+       })
+       if (this.caller === undefined) {
+         console.info('get caller failed')
+         return
        }
+       console.info('get caller success')
+       this.regOnRelease(this.caller)
+     } catch (error) {
+       console.info(`get caller failed with ${error}`)
+     }
    }
    ```

en/application-dev/application-models/uiability-launch-type.md

@@ -17,10 +17,13 @@ The launch type of the UIAbility component refers to the state of the UIAbility
 
 Each time [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) is called, if a UIAbility instance of this type already exists in the application process, the instance is reused. Therefore, only one UIAbility instance of this type exists in the system, that is, displayed in **Recents**.
 
-**Figure 1** Demonstration effect in singleton mode  
+**Figure 1** Demonstration effect in singleton mode 
+
 ![uiability-launch-type1](figures/uiability-launch-type1.png)  
 
-> **NOTE**<br>Assume that the application already has a UIAbility instance created, and the launch type of the UIAbility instance is set to **singleton**. If [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) is called again to start the UIAbility instance, the original UIAbility instance is started, and no new UIAbility instance is created. In this case, the [onNewWant()](../reference/apis/js-apis-app-ability-uiAbility.md#abilityonnewwant) callback is invoked, but the [onCreate()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityoncreate) and [onWindowStageCreate()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityonwindowstagecreate) callbacks are not.
+> **NOTE**
+>
+> Assume that the application already has a UIAbility instance created, and the launch type of the UIAbility instance is set to **singleton**. If [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) is called again to start the UIAbility instance, the original UIAbility instance is started, and no new UIAbility instance is created. In this case, the [onNewWant()](../reference/apis/js-apis-app-ability-uiAbility.md#abilityonnewwant) callback is invoked, but the [onCreate()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityoncreate) and [onWindowStageCreate()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityonwindowstagecreate) callbacks are not.
 
 To use the singleton mode, set **launchType** in the [module.json5 configuration file](../quick-start/module-configuration-file.md) to **singleton**.
 
@@ -44,7 +47,8 @@ To use the singleton mode, set **launchType** in the [module.json5 configuration
 
 In standard mode, each time [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) is called, a new UIAbility instance of this type is created in the application process. Multiple UIAbility instances of this type are displayed in **Recents**.  
 
-**Figure 2** Demonstration effect in standard mode  
+**Figure 2** Demonstration effect in standard mode
+
 ![standard-mode](figures/standard-mode.png)  
 
 To use the standard mode, set **launchType** in the [module.json5 configuration file](../quick-start/module-configuration-file.md) to **standard**.
@@ -69,7 +73,8 @@ To use the standard mode, set **launchType** in the [module.json5 configuration
 
 The **specified** mode is used in some special scenarios. For example, in a document application, you want a document instance to be created each time you create a document, but you want to use the same document instance when you repeatedly open an existing document.
 
-**Figure 3** Demonstration effect in specified mode   
+**Figure 3** Demonstration effect in specified mode 
+
 ![uiability-launch-type2](figures/uiability-launch-type2.png)  
 
 For example, there are two UIAbility components: EntryAbility and SpecifiedAbility (with the launch type **specified**). You are required to start SpecifiedAbility from EntryAbility.
@@ -108,7 +113,7 @@ For example, there are two UIAbility components: EntryAbility and SpecifiedAbili
            instanceKey: getInstance(),
        },
    }
-   // context is the ability-level context of the initiator UIAbility.
+   // context is the UIAbilityContext of the initiator UIAbility.
    this.context.startAbility(want).then(() => {
        // ...
    }).catch((err) => {
@@ -137,7 +142,7 @@ For example, there are two UIAbility components: EntryAbility and SpecifiedAbili
    }
    ```
 
-   > **NOTE**<br>
+   > **NOTE**
    >
    > 1. Assume that the application already has a UIAbility instance created, and the launch type of the UIAbility instance is set to **specified**. If [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) is called again to start the UIAbility instance, and the [onAcceptWant()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonacceptwant) callback of [AbilityStage](../reference/apis/js-apis-app-ability-abilityStage.md) matches a created UIAbility instance, the original UIAbility instance is started, and no new UIAbility instance is created. In this case, the [onNewWant()](../reference/apis/js-apis-app-ability-uiAbility.md#abilityonnewwant) callback is invoked, but the [onCreate()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityoncreate) and [onWindowStageCreate()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityonwindowstagecreate) callbacks are not.
    > 2. AbilityStage is not automatically generated in the default project of DevEco Studio. For details about how to create an AbilityStage file, see [AbilityStage Component Container](abilitystage.md).

en/application-dev/task-management/reminder-agent-development.md

@@ -5,21 +5,21 @@
 
 The agent-powered reminder feature provides APIs for publishing background reminders. You can call these APIs to create scheduled reminders for countdown timers, calendar events, and alarm clocks. The APIs are encapsulated in the [reminderAgentManager](../reference/apis/js-apis-reminderAgentManager.md) class.
 
-  **Table 1** Major APIs in reminderAgentManager
+**Table 1** Major APIs in reminderAgentManager
 
-| API                                     | Description                                      |
-| ---------------------------------------- | ---------------------------------------- |
-| publishReminder(reminderReq: ReminderRequest, callback: AsyncCallback&lt;number&gt;): void<br>publishReminder(reminderReq: ReminderRequest): Promise&lt;number&gt; | Publishes a scheduled reminder.<br>The maximum number of valid notifications (excluding expired ones that will not pop up again) is 30 for one application<br>and 2000 for the entire system.|
-| cancelReminder(reminderId: number, callback: AsyncCallback&lt;void&gt;): void<br>cancelReminder(reminderId: number): Promise&lt;void&gt; | Cancels a specified reminder. (The value of **reminderId** is obtained from the return value of **publishReminder**.)|
-| getValidReminders(callback: AsyncCallback&lt;Array&lt;ReminderRequest&gt;&gt;): void<br>getValidReminders(): Promise&lt;Array&lt;ReminderRequest&gt;&gt; | Obtains all valid reminders set by the current application.                       |
-| cancelAllReminders(callback: AsyncCallback&lt;void&gt;): void<br>cancelAllReminders(): Promise&lt;void&gt; | Cancels all reminders set by the current application.                          |
-| addNotificationSlot(slot: NotificationSlot, callback: AsyncCallback&lt;void&gt;): void<br>addNotificationSlot(slot: NotificationSlot): Promise&lt;void&gt; | Registers a **NotificationSlot** instance to be used by the reminder.           |
-| removeNotificationSlot(slotType: notification.SlotType, callback: AsyncCallback&lt;void&gt;): void<br>removeNotificationSlot(slotType: notification.SlotType): Promise&lt;void&gt; | Removes a **NotificationSlot** instance of a specified type.                |
+| API                                                          | Description                                                  |
+| ------------------------------------------------------------ | ------------------------------------------------------------ |
+| publishReminder(reminderReq: ReminderRequest, callback: AsyncCallback&lt;number&gt;): void<br>publishReminder(reminderReq: ReminderRequest): Promise&lt;number&gt; | Publishes a scheduled reminder.<br>The maximum number of valid notifications (excluding expired ones that will not pop up again) is 30 for one application and 2000 for the entire system. |
+| cancelReminder(reminderId: number, callback: AsyncCallback&lt;void&gt;): void<br>cancelReminder(reminderId: number): Promise&lt;void&gt; | Cancels a specified reminder. (The value of **reminderId** is obtained from the return value of **publishReminder**.) |
+| getValidReminders(callback: AsyncCallback&lt;Array&lt;ReminderRequest&gt;&gt;): void<br>getValidReminders(): Promise&lt;Array&lt;ReminderRequest&gt;&gt; | Obtains all valid reminders set by the current application.  |
+| cancelAllReminders(callback: AsyncCallback&lt;void&gt;): void<br>cancelAllReminders(): Promise&lt;void&gt; | Cancels all reminders set by the current application.        |
+| addNotificationSlot(slot: NotificationSlot, callback: AsyncCallback&lt;void&gt;): void<br>addNotificationSlot(slot: NotificationSlot): Promise&lt;void&gt; | Registers a **NotificationSlot** instance to be used by the reminder. |
+| removeNotificationSlot(slotType: notification.SlotType, callback: AsyncCallback&lt;void&gt;): void<br>removeNotificationSlot(slotType: notification.SlotType): Promise&lt;void&gt; | Removes a **NotificationSlot** instance of a specified type. |
 
 
 ## How to Develop
 
-1. Request the **ohos.permission.PUBLISH_AGENT_REMINDER** permission. For details, see [Permission Application Guide](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
+1. Request the **ohos.permission.PUBLISH_AGENT_REMINDER** permission. For details, see [Declaring Permissions in the Configuration File](../security/accesstoken-guidelines.md#declaring-permissions-in-the-configuration-file).
 
 2. [Enable the notification feature](../notification/notification-enable.md).
 
@@ -95,7 +95,7 @@ The agent-powered reminder feature provides APIs for publishing background remin
         snoozeTimes: 2, // Number of reminder snooze times.
         timeInterval: 5, // Reminder snooze interval, in seconds.
         title: 'this is title', // Reminder title.
-        content:'this is content', // Reminder content.
+        content: 'this is content', // Reminder content.
         expiredContent: 'this reminder has expired', // Content to be displayed after the reminder expires.
         snoozeContent: 'remind later', // Content to be displayed when the reminder is snoozed.
         notificationId: 100, // Notification ID used by the reminder. If there are reminders with the same notification ID, the later one will overwrite the earlier one.