Update docs against 17296+17418+17104+17369+17340+17510+17467+17106+17107+17362

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

en/application-dev/application-models/abilitystage.md

@@ -12,7 +12,7 @@ AbilityStage is not automatically generated in the default project of DevEco Stu
 
 1. In the **ets** directory of the **Module** project, right-click and choose **New > Directory** to create a directory named **myabilitystage**.
 
-2. In the **myabilitystage** directory, right-click and choose **New > ts File** to create a file named **MyAbilityStage.ts**.
+2. In the **myabilitystage** directory, right-click and choose **New > TypeScript File** to create a file named **MyAbilityStage.ts**.
 
 3. Open the **MyAbilityStage.ts** file, and import the dependency package of AbilityStage. Customize a class that inherits from AbilityStage, and add the required lifecycle callbacks. The following code snippet adds the **onCreate()** lifecycle callback.
    
@@ -20,16 +20,27 @@ AbilityStage is not automatically generated in the default project of DevEco Stu
    import AbilityStage from '@ohos.app.ability.AbilityStage';
    
    export default class MyAbilityStage extends AbilityStage {
-       onCreate() {
-           // When the HAP of the application is loaded for the first time, initialize the module.
-       }
-       onAcceptWant(want) {
-           // Triggered only for the ability with the specified launch type.
-           return "MyAbilityStage";
-       }
+     onCreate() {
+       // When the HAP of the application is loaded for the first time, initialize the module.
+     }
+     onAcceptWant(want) {
+       // Triggered only for the ability with the specified launch type.
+       return "MyAbilityStage";
+     }
+   }
+   ```
+   
+4. Set **srcEntry** in the [module.json5 file](../quick-start/module-configuration-file.md) to the code path of the module.
+   ```json
+   {
+     "module": {
+       "name": "entry",
+       "type": "entry",
+       "srcEntry": "./ets/myabilitystage/MyAbilityStage.ts",
+       // ...
+     }
    }
    ```
-
 
 [AbilityStage](../reference/apis/js-apis-app-ability-abilityStage.md) has the lifecycle callback [onCreate()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageoncreate) and the event callbacks [onAcceptWant()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonacceptwant), [onConfigurationUpdated()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonconfigurationupdate), and [onMemoryLevel()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonmemorylevel).
 
@@ -49,9 +60,8 @@ When an application is switched to the background, it is cached in the backgroun
   import AbilityStage from '@ohos.app.ability.AbilityStage';
   
   export default class MyAbilityStage extends AbilityStage {
-      onMemoryLevel(level) {
-          // Release unnecessary memory based on the change of available system memory.
-      }
+    onMemoryLevel(level) {
+      // Release unnecessary memory based on the change of available system memory.
+    }
   }
   ```
-

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

@@ -187,13 +187,13 @@ The base class **Context** provides [createBundleContext(bundleName:string)](../
   > **NOTE**
   >
   > To obtain the context of another application:
-  >
+  > 
   > - 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.
-
+  
   ```ts
   import UIAbility from '@ohos.app.ability.UIAbility';
   
@@ -248,7 +248,7 @@ The base class **Context** provides [createBundleContext(bundleName:string)](../
 
 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) 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.
+[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. 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
@@ -308,7 +308,7 @@ export default class EntryAbility extends UIAbility {
     // Obtain the application context.
     let applicationContext = this.context.getApplicationContext();
     // Register the application lifecycle callback.
-    this.lifecycleId = applicationContext.on('Lifecycle', abilityLifecycleCallback);
+    this.lifecycleId = applicationContext.on('abilityLifecycle', abilityLifecycleCallback);
     console.log(TAG, `register callback number: ${this.lifecycleId}`);
   }
 

en/application-dev/application-models/datashareextensionability.md

 # DataShareExtensionAbility (for System Applications Only)
 
 
-DataShareExtensionAbility provides the data sharing capability. System applications can implement a DataShareExtensionAbility or access an existing DataShareExtensionAbility in the system. Third-party applications can only access an existing DataShareExtensionAbility. For details, see [DataShare Development](../database/database-datashare-guidelines.md).
+DataShareExtensionAbility provides the data sharing capability. System applications can implement a DataShareExtensionAbility or access an existing DataShareExtensionAbility in the system. Third-party applications can only access an existing DataShareExtensionAbility. For details, see [Cross-Application Data Sharing Overview](../database/share-device-data-across-apps-overview.md).

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

@@ -187,7 +187,7 @@ On device A, touch the **Start** button provided by the initiator application to
    
    // ...
    
-   // context is the UIAbilityContext of the initiator UIAbility.
+   // context is the AbilityContext of the initiator UIAbility.
    this.context.startAbilityForResult(want).then((data) => {
        if (data?.resultCode === RESULT_CODE) {
            // Parse the information returned by the target UIAbility.
@@ -384,12 +384,12 @@ The following describes how to implement multi-device collaboration through cros
        ```json
        "abilities":[{
            "name": ".CalleeAbility",
-           "srcEntrance": "./ets/CalleeAbility/CalleeAbility.ts",
+           "srcEnty": "./ets/CalleeAbility/CalleeAbility.ts",
            "launchType": "singleton",
            "description": "$string:CalleeAbility_desc",
            "icon": "$media:icon",
            "label": "$string:CalleeAbility_label",
-           "visible": true
+           "exported": true
        }]
        ```
 
@@ -459,7 +459,7 @@ The following describes how to implement multi-device collaboration through cros
        
            onDestroy() {
                try {
-                this.callee.off(MSG_SEND_METHOD)
+                   this.callee.off(MSG_SEND_METHOD)
                } catch (error) {
                    console.error(TAG, `${MSG_SEND_METHOD} unregister failed with error ${JSON.stringify(error)}`)
                }
@@ -491,7 +491,7 @@ 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 CallerAbility.
+                   // Register the onRelease() listener of the CallerAbility.
                    caller.onRelease((msg) => {
                        console.info(`remote caller onRelease is called ${msg}`)
                    })

en/application-dev/application-models/lifecycleapp-switch.md

 # LifecycleApp Switching
 
 
-  | API in the FA Model| Corresponding d.ts File in the Stage Model| Corresponding API in the Stage Model| 
+| API in the FA Model| Corresponding d.ts File in the Stage Model| Corresponding API in the Stage Model|
 | -------- | -------- | -------- |
 | onShow?(): void; | \@ohos.window.d.ts | [on(eventType: 'windowStageEvent', callback: Callback&lt;WindowStageEventType&gt;): void;](../reference/apis/js-apis-window.md#onwindowstageevent9)<br>Listens for the switching to the [foreground](../reference/apis/js-apis-window.md#windowstageeventtype9).|
 | onHide?(): void; | \@ohos.window.d.ts | [on(eventType: 'windowStageEvent', callback: Callback&lt;WindowStageEventType&gt;): void;](../reference/apis/js-apis-window.md#onwindowstageevent9)<br>Listens for the switching to the [background](../reference/apis/js-apis-window.md#windowstageeventtype9).|
-| onDestroy?(): void; | \@ohos.app.ability.UIAbility.d.ts | [onDestroy(): void;](../reference/apis/js-apis-app-ability-uiAbility.md#abilityondestroy) | 
+| onDestroy?(): void; | \@ohos.app.ability.UIAbility.d.ts | [onDestroy(): void;](../reference/apis/js-apis-app-ability-uiAbility.md#abilityondestroy) |
 | onCreate?(): void; | \@ohos.app.ability.UIAbility.d.ts | [onCreate(want: Want, param: AbilityConstant.LaunchParam): void;](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncreate) |
 | onWindowDisplayModeChanged?(isShownInMultiWindow: boolean, newConfig: resourceManager.Configuration): void; | There is no corresponding API in the stage model.| No corresponding API is provided.|
 | onStartContinuation?(): boolean; | There is no corresponding API in the stage model.| In the stage model, an application does not need to detect whether the continuation is successful (detected when the application initiates the continuation request). Therefore, the **onStartContinuation()** callback is deprecated.|
 | onSaveData?(data: Object): boolean; | \@ohos.app.ability.UIAbility.d.ts | [onContinue(wantParam : {[key: string]: any}): AbilityConstant.OnContinueResult;](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncontinue) |
 | onCompleteContinuation?(result: number): void; | application\ContinueCallback.d.ts | [onContinueDone(result: number): void;](../reference/apis/js-apis-distributedMissionManager.md#continuecallback) |
-| onRestoreData?(data: Object): void; | \@ohos.app.ability.UIAbility.d.ts | [onCreate(want: Want, param: AbilityConstant.LaunchParam): void;](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncreate)<br>[onNewWant(want: Want, launchParams: AbilityConstant.LaunchParam): void;](../reference/apis/js-apis-app-ability-uiAbility.md#abilityonnewwant)<br>In standard or singleton mode, the target ability completes data restoration in the **onCreate()** callback. In the callback, **launchParam.launchReason** is used to determine whether it is a continuation-based launch scenario. If it is, the data saved before continuation can be obtained from the **want** parameter.|
+| onRestoreData?(data: Object): void; | \@ohos.app.ability.UIAbility.d.ts | [onCreate(want: Want, param: AbilityConstant.LaunchParam): void;](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncreate)<br>[onNewWant(want: Want, launchParams: AbilityConstant.LaunchParam): void;](../reference/apis/js-apis-app-ability-uiAbility.md#abilityonnewwant)<br>In multiton or singleton mode, the target ability completes data restoration in the **onCreate()** callback. In the callback, **launchParam.launchReason** is used to determine whether it is a continuation-based launch scenario. If it is, the data saved before continuation can be obtained from the **want** parameter.|
 | onRemoteTerminated?(): void; | application\ContinueCallback.d.ts | [onContinueDone(result: number): void;](../reference/apis/js-apis-distributedMissionManager.md#continuecallback) |
 | onSaveAbilityState?(outState: PacMap): void; | \@ohos.app.ability.UIAbility.d.ts | [onSaveState(reason: AbilityConstant.StateType, wantParam : {[key: string]: any}): AbilityConstant.OnSaveResult;](../reference/apis/js-apis-app-ability-uiAbility.md#abilityonsavestate) |
 | onRestoreAbilityState?(inState: PacMap): void; | \@ohos.app.ability.UIAbility.d.ts | [onCreate(want: Want, param: AbilityConstant.LaunchParam): void;](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncreate)<br>After the application is restarted, the **onCreate()** callback is triggered. In the callback, **launchParam.launchReason** is used to determine whether it is a self-recovery scenario. If it is, the data saved before the restart can be obtained from the **want** parameter.|

en/application-dev/application-models/mission-management-launch-type.md

@@ -8,16 +8,19 @@ The following describes how the mission list manager manages the UIAbility insta
 - **singleton**: Only one UIAbility instance exists for an application.
   
   **Figure 1** Missions and singleton mode
+  
   ![mission-and-singleton](figures/mission-and-singleton.png)
   
-- **standard**: Each time **startAbility()** is called, a UIAbility instance is created in the application process.
+- **multiton**: Each time **startAbility()** is called, a **UIAbility** instance is created in the application process.
+  
+  **Figure 2** Missions and multiton mode
   
-  **Figure 2** Missions and standard mode
-  ![mission-and-standard](figures/mission-and-standard.png)
+  ![mission-and-multiton](figures/mission-and-standard.png)
   
-- **specified**: The ([onAcceptWant](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonacceptwant)) method of [AbilityStage](abilitystage.md) determines whether to create an instance.
+- **specified**: The ([onAcceptWant()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonacceptwant)) method of [AbilityStage](abilitystage.md) determines whether to create an instance.
   
   **Figure 3** Missions and specified mode
+  
   ![mission-and-specified](figures/mission-and-specified.png)
 
 

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

@@ -13,6 +13,7 @@ Before getting started with the development of mission management, be familiar w
 - MissionListManager: system mission management module that maintains all the MissionLists and is consistent with the list in **Recents**.
   
   **Figure 1** Mission management 
+  
   ![mission-list-manager](figures/mission-list-manager.png)
 
 

en/application-dev/application-models/module-switch.md

@@ -8,7 +8,7 @@ When switching an application from the FA model to the stage model, you must mig
 | Field Name in the FA Model| Field Description| Field Name in the Stage Model| Difference|
 | -------- | -------- | -------- | -------- |
 | mainAbility | Ability displayed on the Service Center icon. When the resident process is started, the **mainAbility** is started.| mainElement | The field name is changed, and the stage mode does not use the period (.) in ability names.|
-| package | Package name of the HAP file, which must be unique in the application.| / | The stage model uses **name** to ensure application uniqueness. To ensure a successful switching from the FA model to the stage model, **name** in the stage model must be the same as **package** in the FA model.|
+| package | Package name of the HAP file, which must be unique in the application.| / | The stage model uses **name** to ensure application uniqueness. |
 | name | Class name of the HAP file.| / | This configuration is not enabled in the FA model, and the stage model does not have such a field.|
 | supportedModes | Modes supported by the application. Currently, only the **drive** mode is defined.| / | This configuration is deprecated in the stage model.|
 | moduleName in the distro object| Name of the current HAP file.<br>moduleName in the distro object.| name | The field name is changed.|
@@ -21,11 +21,12 @@ When switching an application from the FA model to the stage model, you must mig
 | shortcuts | Shortcuts of the application.| shortcut_config.json| In the stage model, the **shortcut_config.json** file is defined in **resources/base/profile** in the development view.|
 | reqPermissions | Permissions that the application requests from the system when it is running.| requestPermissions | The field name is changed.|
 | colorMode | Color mode of the application.| / | This configuration is not supported in the stage model.|
-| distroFilter | Distribution rules of the application.| distroFilter_config.json| In the stage model, the **distroFilter_config.json** file is defined in **resources/base/profile** in the development view.|
+| distributionFilter | Distribution rules of the application.| distroFilter_config.json| In the stage model, the **distroFilter_config.json** file is defined in **resources/base/profile** in the development view.|
 | reqCapabilities | Device capabilities required for running the application.| / | This configuration is not supported in the stage model.|
 | commonEvents | Common events.| common_event_config.json| In the stage model, the **common_event_config.json** file is defined in **resources/base/profile** in the development view.|
 | entryTheme | Keyword of an OpenHarmony internal theme.| / | This configuration is not supported in the stage model.|
 
+
 ### Table 2 metaData Comparison
 
 | Field Name Under metaData in the FA Model| Field Description| Field Name Under metaData in the Stage Model| Difference|
@@ -40,7 +41,8 @@ When switching an application from the FA model to the stage model, you must mig
 | -------- | -------- | -------- | -------- |
 | name | Key name that identifies a data item. The value is a string with a maximum of 255 bytes.| name | None.|
 | value | Value of the data item. The value is a string with a maximum of 255 bytes.| value | None.|
-| extra | Format of the current custom data. The value is the resource value of **extra**.| resource | The field name is changed. For details, see [Table 4](#table-4-metadata-examples).|
+| extra | Format of the current custom data. The value is the resource value of **extra**.| resource | The field name is changed. For details, see [Table 4](#table 4-metadata-examples).|
+
 
 ### Table 4 metaData Examples
 
@@ -69,5 +71,5 @@ When switching an application from the FA model to the stage model, you must mig
 | formsEnabled | Whether the ability can provide widgets.| / | This configuration is not supported in the stage model.|
 | forms | Information about the widgets used by the ability. This field is valid only when **formsEnabled** is set to **true**.| form_config.json| In the stage model, the **form_config.json** file is defined in **resources/base/profile** in the development view.|
 | srcLanguage | Programming language used to develop the ability.| / | This configuration is not supported in the stage model.|
-| srcPath | Path of the JS component code corresponding to the ability.| srcEntrance | Path of the JS code corresponding to the ability.|
+| srcPath | Path of the JS component code corresponding to the ability.| srcEnty | Path of the JS code corresponding to the ability.|
 | uriPermission | Application data that the ability can access.| / | This configuration is not supported in the stage model.|

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

@@ -5,10 +5,10 @@ Depending on the launch type, the action performed when the PageAbility starts d
 
 **Table 1** PageAbility launch types
 
-| Launch Type| Description|
-| -------- | -------- |
-| singleton | Each time **startAbility()** is called, if an ability instance of this type already exists in the application process, the instance is reused. There is only one ability instance of this type in **Recents**.<br>A typical scenario is as follows: When a user opens a video playback application and watches a video, returns to the home screen, and opens the video playback application again, the video that the user watched before returning to the home screen is still played.|
-| standard | Default type. Each time **startAbility()** is called, a new ability instance is created in the application process. Multiple ability instances of this type are displayed in **Recents**.<br>A typical scenario is as follows: When a user opens a document application and touches **New**, a new document task is created. Multiple new document missions are displayed in **Recents**.|
+| Launch Type| Meaning        | Description|
+| -------- | -------- | -------- |
+| singleton | Singleton mode| Each time **startAbility()** is called, if an ability instance of this type already exists in the application process, the instance is reused. There is only one ability instance of this type in **Recents**.<br>A typical scenario is as follows: When a user opens a video playback application and watches a video, returns to the home screen, and opens the video playback application again, the video that the user watched before returning to the home screen is still played.|
+| standard | Multiton mode| Default type. Each time **startAbility()** is called, a new ability instance is created in the application process. Multiple ability instances of this type are displayed in **Recents**.<br>A typical scenario is as follows: When a user opens a document application and touches **New**, a new document task is created. Multiple new document missions are displayed in **Recents**.|
 
 
 You can set **launchType** in the **config.json** file to configure the launch type. The sample code is as follows:
@@ -19,8 +19,8 @@ You can set **launchType** in the **config.json** file to configure the launch t
     // ...
     "abilities": [
       {
-        // singleton mode.
-        // standard mode.
+        // singleton means the singleton mode.
+        // standard means the multiton mode.
         "launchType": "standard",
         // ...
       }
@@ -30,7 +30,8 @@ You can set **launchType** in the **config.json** file to configure the launch t
 ```
 
 
-When the PageAbility is started for the first time (either in standard or singleton mode), the [PageAbility lifecycle callbacks](pageability-lifecycle.md#table13118194914476) are triggered. When it is not started for the first time in singleton mode, the **onNewWant()** callback (as described in the table below) is triggered, but the **onCreate()** callback is not.
+When the PageAbility is started in multiton mode or it is started in singleton mode for the first time, the [PageAbility lifecycle callbacks](pageability-lifecycle.md#table13118194914476) are triggered. When it is not started for the first time in singleton mode, the **onNewWant()** callback (as described in the table below) is triggered, but the **onCreate()** callback is not.
+
 
 **Table 2** Callbacks specific to the singleton mode
 

en/application-dev/application-models/process-model-stage.md

@@ -15,7 +15,8 @@ The OpenHarmony process model is shown below.
 
 > NOTE
 >
-> You can create ServiceExtensionAbility and DataShareExtensionAbility only for system applications.
+> - You can create ServiceExtensionAbility and DataShareExtensionAbility only for system applications.
+> - To view information about all running processes, run the **hdc shell** command to enter the shell CLI of the device, and run the **ps -ef** command.
 
 A system application can apply for multi-process permissions (as shown in the following figure) and configure a custom process for an HAP. UIAbility, DataShareExtensionAbility, and ServiceExtensionAbility in the HAP run in the custom process. Different HAPs run in different processes by configuring different process names.
 

en/application-dev/application-models/redirection-rules.md

@@ -7,13 +7,14 @@ Generally, UI redirection within an application is triggered by users. However,
 The PageAbility has a UI. It can use **startAbility()** to start an ability that has a UI and is visible to users.
 
 
-The **visible** field under **abilities** in the **config.json** file specifies whether an ability can be started by other application components.
+The **exported** field under **abilities** in the **config.json** file specifies whether an ability can be started by other application components.
 
-**Table 1** Description of visible
+
+**Table 1** Description of exported
 
 | Name| Description| Initial Value Allowed|
 | -------- | -------- | -------- |
-| visible | Whether the ability can be called by other applications.<br>**true**: The ability can be called by any application.<br>**false**: The ability can be called only by other components of the same application.| Yes (initial value: **false**)|
+| exported | Whether the ability can be called by other applications.<br>**true**: The ability can be called by any application.<br>**false**: The ability can be called only by other components of the same application.| Yes (initial value: **false**)|
 
 
 To enable an ability to be called by any application, configure the **config.json** file as follows:
@@ -24,7 +25,7 @@ To enable an ability to be called by any application, configure the **config.jso
     // ...
     "abilities": [
       {
-        "visible": "true",
+        "exported": "true",
         // ...
       }
     ]
@@ -33,4 +34,4 @@ To enable an ability to be called by any application, configure the **config.jso
 ```
 
 
-If the ability contains **skills**, you are advised to set **visible** to **true** so that the ability can be [implicitly started](explicit-implicit-want-mappings.md#matching-rules-of-implicit-want) by other applications. If this attribute is set to **false**, the system returns **PERMISSION_DENIED** when other applications attempt to start the ability. In this case, a system application can request the [START_INVISIBLE_ABILITY](../security/permission-list.md) permission to start the ability. Example abilities with **visible** set to **false** are home screen, voice assistant, or search assistant.
+If the ability contains **skills**, you are advised to set **exported** to **true** so that the ability can be [implicitly started](explicit-implicit-want-mappings.md#matching-rules-of-implicit-want) by other applications. If this attribute is set to **false**, the system returns **PERMISSION_DENIED** when other applications attempt to start the ability. In this case, a system application can request the [START_INVISIBLE_ABILITY](../security/permission-list.md) permission to start the ability. Example abilities with **exported** set to **false** are home screen, voice assistant, or search assistant.

en/application-dev/application-models/start-page.md

@@ -12,7 +12,7 @@ import featureAbility from '@ohos.ability.featureAbility';
 async function restartAbility() {
     let wantInfo = {
         bundleName: "com.sample.MyApplication",
-        abilityName: "EntryAbility",
+        abilityName: "MainAbility",
         parameters: {
             page: "pages/second"
         }
@@ -70,7 +70,7 @@ struct Index {
 ```
 
 
-When the launch type of a PageAbility is set to **standard** or when the PageAbility with the launch type set to **singleton** is started for the first time, you can use the **parameters** parameter in **want** to transfer the pages information and use the **startAbility()** method to start the PageAbility. For details about the launch type, see [PageAbility Launch Type](pageability-launch-type.md). The target PageAbility can use the **featureAbility.getWant()** method in **onCreate** to obtain the **want** parameter, and then call **router.push** to start a specified page.
+When a PageAbility in multiton mode is started or when the PageAbility in singleton mode is started for the first time, you can use the **parameters** parameter in **want** to transfer the pages information and use the **startAbility()** method to start the PageAbility. For details about the launch type, see [PageAbility Launch Type](pageability-launch-type.md). The target PageAbility can use the **featureAbility.getWant()** method in **onCreate** to obtain the **want** parameter, and then call **router.push** to start a specified page.
 
 
 When a user touches the button on the page of the caller PageAbility, the **startAbility()** method is called to start the target PageAbility. The **want** parameter in **startAbility()** carries the specified page information.
@@ -89,7 +89,7 @@ struct Index {
         featureAbility.startAbility({
           want: {
             bundleName: "com.exm.myapplication",
-            abilityName: "com.exm.myapplication.EntryAbility",
+            abilityName: "com.exm.myapplication.MainAbility",
             parameters: { page: "pages/page1" }
           }
         }).then((data) => {
@@ -104,7 +104,7 @@ struct Index {
         featureAbility.startAbility({
           want: {
             bundleName: "com.exm.myapplication",
-            abilityName: "com.exm.myapplication.EntryAbility",
+            abilityName: "com.exm.myapplication.MainAbility",
             parameters: { page: "pages/page2" }
           }
         }).then((data) => {

en/application-dev/application-models/thread-model-stage.md

@@ -2,19 +2,14 @@
 
 For an OpenHarmony application, each process has a main thread to provide the following functionalities:
 
-- Manage other threads.
-
-- Enable multiple UIAbility components of the same application to share the same main thread.
-
-- Distribute input events.
-
 - Draw the UI.
-
-- Invoke application code callbacks (event processing and lifecycle callbacks).
-
+- Manage the ArkTS engine instance of the main thread so that multiple UIAbility components can run on it.
+- Manage ArkTS engine instances of other threads (such as the worker thread), for example, starting and terminating other threads.
+- Distribute interaction events.
+- Process application code callbacks (event processing and lifecycle management).
 - Receive messages sent by the worker thread.
 
-In addition to the main thread, there is an independent thread, named worker. The worker thread is mainly used to perform time-consuming operations. It cannot directly operate the UI. The worker thread is created in the main thread and is independent of the main thread. A maximum of seven worker threads can be created.
+In addition to the main thread, there is an independent thread, named worker. The worker thread is mainly used to perform time-consuming operations. The worker thread is created in the main thread and is independent from the main thread. It cannot directly operate the UI. A maximum of seven worker threads can be created. 
 
 ![thread-model-stage](figures/thread-model-stage.png)
 
@@ -22,4 +17,5 @@ Based on the OpenHarmony thread model, different services run on different threa
 
 > **NOTE**
 > 
-> The stage model provides only the main thread and worker thread. Emitter is mainly used for event synchronization within the main thread or between the main thread and worker thread.
+> - The stage model provides only the main thread and worker thread. Emitter is mainly used for event synchronization within the main thread or between the main thread and worker thread.
+> - To view thread information about an application process, run the **hdc shell** command to enter the shell CLI of the device, and then run the **ps -p *<pid>* -T command**, where *<pid>* indicates the ID of the application process.

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

@@ -38,7 +38,7 @@ Assume that your application has two UIAbility components: EntryAbility and Func
            info: 'From the Index page of EntryAbility',
        },
    }
-   // context is the UIAbilityContext of the initiator UIAbility.
+   // context is the AbilityContext of the initiator UIAbility.
    this.context.startAbility(wantInfo).then(() => {
        // ...
    }).catch((err) => {
@@ -65,7 +65,7 @@ Assume that your application has two UIAbility components: EntryAbility and Func
 3. To stop the **UIAbility** instance after the FuncAbility service is complete, call **terminateSelf()** in FuncAbility.
    
    ```ts
-   // context is the UIAbilityContext of the UIAbility instance to stop.
+   // context is the AbilityContext of the UIAbility instance to stop.
    this.context.terminateSelf((err) => {
        // ...
    });
@@ -88,7 +88,7 @@ When starting FuncAbility from EntryAbility, you want the result to be returned
            info: 'From the Index page of EntryAbility',
        },
    }
-   // context is the UIAbilityContext of the initiator UIAbility.
+   // context is the AbilityContext of the initiator UIAbility.
    this.context.startAbilityForResult(wantInfo).then((data) => {
        // ...
    }).catch((err) => {
@@ -124,7 +124,7 @@ When starting FuncAbility from EntryAbility, you want the result to be returned
    
    // ...
    
-   // context is the UIAbilityContext of the initiator UIAbility.
+   // context is the AbilityContext of the initiator UIAbility.
    this.context.startAbilityForResult(want).then((data) => {
        if (data?.resultCode === RESULT_CODE) {
            // Parse the information returned by the target UIAbility.
@@ -187,7 +187,7 @@ This section describes how to start the UIAbility of another application through
        entities: ['entity.system.default'],
    }
    
-   // context is the UIAbilityContext of the initiator UIAbility.
+   // context is the AbilityContext of the initiator UIAbility.
    this.context.startAbility(wantInfo).then(() => {
        // ...
    }).catch((err) => {
@@ -251,7 +251,7 @@ If you want to obtain the return result when using implicit Want to start the UI
        entities: ['entity.system.default'],
    }
    
-   // context is the UIAbilityContext of the initiator UIAbility.
+   // context is the AbilityContext of the initiator UIAbility.
    this.context.startAbilityForResult(wantInfo).then((data) => {
        // ...
    }).catch((err) => {
@@ -289,7 +289,7 @@ If you want to obtain the return result when using implicit Want to start the UI
      // Want parameter information.
    };
    
-   // context is the UIAbilityContext of the initiator UIAbility.
+   // context is the AbilityContext of the initiator UIAbility.
    this.context.startAbilityForResult(want).then((data) => {
        if (data?.resultCode === RESULT_CODE) {
            // Parse the information returned by the target UIAbility.
@@ -322,7 +322,7 @@ let wantInfo = {
         router: 'funcA',
     },
 }
-// context is the UIAbilityContext of the initiator UIAbility.
+// context is the AbilityContext of the initiator UIAbility.
 this.context.startAbility(wantInfo).then(() => {
     // ...
 }).catch((err) => {
@@ -500,12 +500,12 @@ For the CalleeAbility, implement the callback to receive data and the methods to
    ```json
    "abilities":[{
      "name": ".CalleeAbility",
-     "srcEntrance": "./ets/CalleeAbility/CalleeAbility.ts",
+     "srcEnty": "./ets/CalleeAbility/CalleeAbility.ts",
      "launchType": "singleton",
      "description": "$string:CalleeAbility_desc",
      "icon": "$media:icon",
      "label": "$string:CalleeAbility_label",
-     "visible": true
+     "exported": true
    }]
    ```
 
@@ -596,7 +596,7 @@ For the CalleeAbility, implement the callback to receive data and the methods to
 
 2. Obtain the caller interface.
 
-   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.
+   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** listener of the CallerAbility. You need to implement processing based on service requirements.
 
    
    ```ts

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

@@ -6,7 +6,7 @@ The launch type of the UIAbility component refers to the state of the UIAbility
 
 - [Singleton](#singleton)
 
-- [Standard](#standard)
+- [Multiton](#multiton)
 
 - [Specified](#specified)
 
@@ -18,8 +18,7 @@ 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 
-
-![uiability-launch-type1](figures/uiability-launch-type1.png)
+![uiability-launch-type1](figures/uiability-launch-type1.gif)  
 
 > **NOTE**
 >
@@ -43,15 +42,15 @@ To use the singleton mode, set **launchType** in the [module.json5 configuration
 ```
 
 
-## Standard
+## Multiton
 
-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**.  
+In multiton 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 multiton mode
 
-![standard-mode](figures/standard-mode.png)
+![uiability-launch-type2](figures/uiability-launch-type2.gif)  
 
-To use the standard mode, set **launchType** in the [module.json5 configuration file](../quick-start/module-configuration-file.md) to **standard**.
+To use the multiton mode, set **launchType** in the [module.json5 file](../quick-start/module-configuration-file.md) to **multiton**.
 
 
 ```json
@@ -60,7 +59,7 @@ To use the standard mode, set **launchType** in the [module.json5 configuration
     // ...
     "abilities": [
       {
-        "launchType": "standard",
+        "launchType": "multiton",
         // ...
       }
     ]
@@ -73,14 +72,13 @@ 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 
-
-![uiability-launch-type2](figures/uiability-launch-type2.png)
+**Figure 3** Demonstration effect in specified mode
+![uiability-launch-type3](figures/uiability-launch-type3.gif)  
 
 For example, there are two UIAbility components: EntryAbility and SpecifiedAbility (with the launch type **specified**). You are required to start SpecifiedAbility from EntryAbility.
 
 1. In SpecifiedAbility, set the **launchType** field in the [module.json5 file](../quick-start/module-configuration-file.md) to **specified**.
-   
+
    ```json
    {
      "module": {
@@ -95,8 +93,8 @@ For example, there are two UIAbility components: EntryAbility and SpecifiedAbili
    }
    ```
 
-2. Create a unique string key for the instance. Each time [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) is called, the application, based on the key, identifies the UIAbility instance used to respond to the request. In EntryAbility, add a custom parameter, for example, **instanceKey**, to the [want](want-overview.md) parameter in [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) to distinguish the UIAbility instance.
-   
+2. Create a unique string key for the instance. Each time [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) is called, the application, based on the key, identifies the UIAbility instance used to respond to the request. In EntryAbility, add a custom parameter, for example, **instanceKey**, to the **want** parameter in [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) to distinguish the UIAbility instance.
+
    ```ts
    // Configure an independent key for each UIAbility instance.
    // For example, in the document usage scenario, use the document path as the key.
@@ -120,10 +118,11 @@ For example, there are two UIAbility components: EntryAbility and SpecifiedAbili
        // ...
    })
    ```
-   
-3. During running, the internal service of UIAbility determines whether to create multiple instances. If the key is matched, the UIAbility instance bound to the key is started. Otherwise, a new UIAbility instance is created.
-   The launch type of SpecifiedAbility is set to **specified**. Before SpecifiedAbility is started, the [onAcceptWant()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonacceptwant) callback of the corresponding AbilityStage instance is invoked to parse the input **want** parameter and obtain the custom parameter **instanceKey**. A string key identifier is returned through the [onAcceptWant()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonacceptwant) callback of the AbilityStage instance. [If the returned key corresponds to a started UIAbility instance](mission-management-launch-type.md#fig14520125175314), that UIAbility instance is switched to the foreground and gains focus again. Otherwise, a new instance is created and started.
-   
+
+3. Before SpecifiedAbility is started, the [onAcceptWant()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonacceptwant) callback of the corresponding AbilityStage instance is invoked to obtain the key of the UIAbility, because the launch type of SpecifiedAbility is set to **specified**. If a UIAbility instance matching the key exists, the system starts the UIAbility instance and invokes its [onNewWant()](../reference/apis/js-apis-app-ability-uiAbility.md#abilityonnewwant) callback. Otherwise, the system creates a new UIAbility instance and invokes its [onCreate()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityoncreate) and [onWindowStageCreate()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityonwindowstagecreate) callbacks.
+
+   In the sample code, the [onAcceptWant()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonacceptwant) callback parses the **want** parameter to obtain the custom parameter **instanceKey**. The service logic returns a key string based on **instanceKey** parameter to identify the UIAbility instance. If the returned key maps to a started UIAbility instance, the system pulls the UIAbility instance back to the foreground and obtains the focus. If the returned key does not map to a started UIAbility instance, the system creates a new UIAbility instance and starts it.
+
    ```ts
    import AbilityStage from '@ohos.app.ability.AbilityStage';
    
@@ -140,12 +139,12 @@ For example, there are two UIAbility components: EntryAbility and SpecifiedAbili
        }
    }
    ```
-   
+
    > **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).
-   
+
    For example, in the document application, different keys are bound to different document instances. Each time a document is created, a new key (for example, file path) is passed, and a new UIAbility instance is created when UIAbility is started in AbilityStage. However, when you open an existing document, the same UIAbility instance is started again in AbilityStage.
 
    The following steps are used as an example.
@@ -153,6 +152,4 @@ For example, there are two UIAbility components: EntryAbility and SpecifiedAbili
    1. Open file A. A UIAbility instance, for example, UIAbility instance 1, is started.
    2. Close the process of file A in **Recents**. UIAbility instance 1 is destroyed. Return to the home screen and open file A again. A new UIAbility instance is started, for example, UIAbility instance 2.
    3. Return to the home screen and open file B. A new UIAbility instance is started, for example, UIAbility instance 3.
-   4. Return to the home screen and open file A again. UIAbility instance 2 is started.
-
- 
\ No newline at end of file
+   4. Return to the home screen and open file A again. UIAbility instance 2 is started. This is because the system automatically matches the key of the UIAbility instance and starts the UIAbility instance that has a matching key. In this example, UIAbility instance 2 has the same key as file A. Therefore, the system pulls back UIAbility instance 2 and focuses it without creating a new instance.

en/application-dev/application-models/uiability-overview.md

@@ -37,7 +37,7 @@ To enable an application to properly use a UIAbility component, declare the UIAb
     "abilities": [
       {
         "name": "EntryAbility", // Name of the UIAbility component.
-        "srcEntrance": "./ets/entryability/EntryAbility.ts", // Code path of the UIAbility component.
+        "srcEnty": "./ets/entryability/EntryAbility.ts", // Code path of the UIAbility component.
         "description": "$string:EntryAbility_desc", // Description of the UIAbility component.
         "icon": "$media:icon", // Icon of the UIAbility component.
         "label": "$string:EntryAbility_label", // Label of the UIAbility component.

en/application-dev/application-models/widget-development-fa.md

@@ -364,7 +364,7 @@ You can use the web-like paradigm (HML+CSS+JSON) to develop JS widget pages. Thi
 
 > **NOTE**
 >
-> Only the JavaScript-based web-like development paradigm is supported when developing the widget UI.
+> In the FA model, only the JavaScript-based web-like development paradigm is supported when developing the widget UI.
 
 - HML: uses web-like paradigm components to describe the widget page information.
   
@@ -452,7 +452,7 @@ You can set router and message events for components on a widget. The router eve
 
 2. Set the router event.
    - **action**: **"router"**, which indicates a router event.
-   - **abilityName**: name of the ability to redirect to (PageAbility component in the FA model and UIAbility component in the stage model). For example, the default MainAbility name created by DevEco Studio in the FA model is com.example.entry.MainAbility.
+   - **abilityName**: name of the ability to redirect to (PageAbility component in the FA model and UIAbility component in the stage model). For example, the default UIAbility name created by DevEco Studio in the FA model is com.example.entry.MainAbility.
    - **params**: custom parameters passed to the target ability. Set them as required. The value can be obtained from **parameters** in **want** used for starting the target ability. For example, in the lifecycle function **onCreate** of the MainAbility in the FA model, **featureAbility.getWant()** can be used to obtain **want** and its **parameters** field.
 
 3. Set the message event.
@@ -543,4 +543,3 @@ The following is an example:
     }
   }
   ```
-

en/application-dev/application-models/widget-switch.md

@@ -11,7 +11,7 @@ Widget switching involves the following parts:
 | Configuration Item          | FA Model                                     | Stage Model                                                   |
 | ---------------- | ------------------------------------------- | ------------------------------------------------------------ |
 | Configuration item location      | **formAbility** and **forms** are in the **config.json** file.| **extensionAbilities** (configuration for **formExtensionAbility**) is in the **module.json5** file in the level-1 directory, and **forms** (configuration for **forms** contained in **formExtensionAbility**) is in the **form_config.json** file in the level-2 directory.|
-| Widget code path    | Specified by **srcPath**, without the file name.                        | Specified by **srcEntrance**, with the file name.                                       |
+| Widget code path    | Specified by **srcPath**, without the file name.                        | Specified by **srcEnty**, with the file name.                                          |
 | Programming language            | **srcLanguage** can be set to **js** or **ets**.               | This configuration item is unavailable. Only ets is supported.                                       |
 | Whether to enable widgets    | formsEnabled                                | This configuration item is unavailable. The setting of **type** set to **form** means that the widgets are enabled.                              |
 | Ability type     | type: service                              | type: form                                                  |
@@ -32,7 +32,7 @@ Figure 2 Widget configuration differences
 
 | Item| FA Model| Stage Model|
 | -------- | -------- | -------- |
-| Entry file| **form.ts** in the directory pointed to by **srcPath**| File pointed to by **srcEntrance**|
+| Entry file| **form.ts** in the directory pointed to by **srcPath**| File pointed to by **srcEnty**|
 | Lifecycle| export default| import FormExtension from '\@ohos.app.form.FormExtensionAbility';<br>export default class FormAbility extends FormExtension|
 
 

en/application-dev/application-models/windowextensionability.md

 # WindowExtensionAbility
 
+
 [WindowExtensionAbility](../reference/apis/js-apis-application-windowExtensionAbility.md) is a type of ExtensionAbility component that allows a system application to be embedded in and displayed over another application.
 
 
@@ -14,7 +15,7 @@ the context is [WindowExtensionContext](../reference/apis/js-apis-inner-applicat
 >
 
 
-## Setting an Embedded Ability (for System Applications Only)
+## Setting an Embedded UIAbility (for System Applications Only)
 
 The **WindowExtensionAbility** class provides **onConnect()**, **onDisconnect()**, and **onWindowReady()** lifecycle callbacks, which can be overridden.
 
@@ -58,7 +59,7 @@ To implement an embedded application, manually create a WindowExtensionAbility i
     }
    ```
 
-4. Register the WindowExtensionAbility in the [module.json5 file](../quick-start/module-configuration-file.md) corresponding to the **Module** project. Set **type** to **"window"** and **srcEntrance** to the code path of the ExtensionAbility component.
+4. Register the WindowExtensionAbility in the [module.json5 file](../quick-start/module-configuration-file.md) corresponding to the **Module** project. Set **type** to **"window"** and **srcEnty** to the code path of the ExtensionAbility component.
 
    ```json
    {
@@ -66,11 +67,11 @@ To implement an embedded application, manually create a WindowExtensionAbility i
        "extensionAbilities": [
             {
                 "name": "WindowExtAbility",
-                "srcEntrance": "./ets/WindowExtAbility/WindowExtAbility.ts",
+                "srcEnty": "./ets/WindowExtAbility/WindowExtAbility.ts",
                 "icon": "$media:icon",
                 "description": "WindowExtension",
                 "type": "window",
-                "visible": true,
+                "exported": true,
             }
         ],
      }
@@ -78,7 +79,7 @@ To implement an embedded application, manually create a WindowExtensionAbility i
    ```
 
 
-## Starting an Embedded Ability (for System Applications Only)
+## Starting an Embedded UIAbility (for System Applications Only)
 
 System applications can load the created WindowExtensionAbility through the AbilityComponent.