Update docs against 15244+14979+15297+15433

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

en/application-dev/application-models/Readme-EN.md

@@ -21,6 +21,7 @@
       - [FormExtensionAbility (Widget)](widget-development-stage.md)
       - [StaticSubscriberExtensionAbility](static-subscriber-extension-ability.md)
       - [AccessibilityExtensionAbility](accessibilityextensionability.md)
+      - [EnterpriseAdminExtensionAbility](enterprise-extensionAbility.md)
       - [WindowExtensionAbility](windowextensionability.md)
     - [AbilityStage Component Container](abilitystage.md)
     - [Context](application-context-stage.md)
@@ -36,6 +37,7 @@
       - [Continuation Overview](inter-device-interaction-hop-overview.md)
       - [Cross-Device Migration (System Applications Only)](hop-cross-device-migration.md)
       - [Multi-device Collaboration (System Applications Only)](hop-multi-device-collaboration.md)
+    - [Subscribing to System Environment Variable Changes](subscribe-system-environment-variable-changes.md)
   - IPC
     - [Process Model](process-model-stage.md)
     - Common Events
@@ -52,6 +54,7 @@
     - [Mission Management Scenarios](mission-management-overview.md)
     - [Mission Management and Launch Type](mission-management-launch-type.md)
     - [Page Stack and MissionList](page-mission-stack.md)
+    - [Setting the Icon and Name of a Mission Snapshot](mission-set-icon-name-for-task-snapshot.md)
   - [Application Configuration File](config-file-stage.md)
 - FA Model Development
   - [FA Model Development Overview](fa-model-development-overview.md)

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

 # Using Explicit Want to Start an Ability
 
+When a user touches a button in an application, the application often needs to start a UIAbility component to complete a specific task. If the **abilityName** and **bundleName** parameters are specified when starting a UIAbility, then the explicit Want is used. 
 
-When a user touches a button in an application, the application often needs to start a UIAbility component to complete a specific task. If the **abilityName** and **bundleName** parameters are specified when starting a UIAbility, the explicit Want is used. For details about how to use the explicit Want, see [Starting UIAbility in the Same Application](uiability-intra-device-interaction.md#starting-uiability-in-the-same-application).
+## Using Explicit Want
+
+The user touches a button in the application to start the UIAbility component to complete a specific task. To start the UIAbility component in explicit Want mode, the **abilityName** and **bundleName** parameters must be specified. For details, see [Starting UIAbility in the Same Application](uiability-intra-device-interaction.md#starting-uiability-in-the-same-application).

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

 # Using Implicit Want to Open a Website
 
-
-## Prerequisites
-
-One or more browsers are installed on your device.
-
-The **module.json5** of a browser application is as follows:
+This section uses the operation of using a browser to open a website as an example. It is assumed that one or more browser applications are installed on the device. To ensure that the browser application can work properly, configure the [module.json5 file](../quick-start/module-configuration-file.md) as follows:
 
 ```json
-"skills": [
+{
+  "module": {
+    // ...
+    "abilities": [
+      {
+        // ...
+        "skills": [
           {
             "entities": [
+              "entity.system.home",
               "entity.system.browsable"
               // ...
             ],
             "actions": [
+              "action.system.home",
               "ohos.want.action.viewData"
               // ...
             ],
@@ -33,45 +36,45 @@ The **module.json5** of a browser application is as follows:
               }
               // ...
             ]
-  },
-]
+          }
+        ]
+      }
+    ]
+  }
+}
 ```
 
+In the initiator UIAbility, use implicit Want to start the browser application.
 
-## How to Develop
-
-1. Use the custom function **implicitStartAbility** to start an ability.
+```ts
+import common from '@ohos.app.ability.common';
 
-   ```ts
-       async implicitStartAbility() {
-           try {
-               let want = {
+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",
     // entities can be omitted.
-                   "entities": [ "entity.system.browsable" ],
+    "entities": ["entity.system.browsable"],
     "uri": "https://www.test.com:8080/query/student",
     "type": "text/plain"
   }
-               let context = getContext(this) as common.UIAbilityContext;
-               await context.startAbility(want)
-               console.info(`explicit start ability succeed`)
-           } catch (error) {
-               console.info(`explicit start ability failed with ${error.code}`)
-           }
-        }
-   ```
-
-     The matching process is as follows:
-   1. If **action** in the passed **want** parameter is specified and is included in **actions** under **skills**, the matching is successful.
-
-   2. If **entities** in the passed **want** parameter is specified and is included in **entities** under **skills**, the matching is successful.
+  context.startAbility(wantInfo).then(() => {
+    // ...
+  }).catch((err) => {
+    // ...
+  })
+}
+```
 
-   3. If **uri** in the passed **want** parameter is included in **uris** under **skills**, which is concatenated into `https://www.test.com:8080/query*` (where \* is a wildcard), the matching is successful.
+The matching process is as follows:
 
-   4. If **type** in the passed **want** parameter is specified and is included in **type** under **skills**, the matching is successful.
+1. If **action** in the passed **want** parameter is specified and is included in **actions** under **skills** of the ability to match, the matching is successful.
+2. If **entities** in the passed **want** parameter is specified and is included in **entities** under **skills** of the ability to match, the matching is successful.
+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.
 
-2. When there are multiple matching applications, a dialog box is displayed for you to select one of them. 
+When there are multiple matching applications, a dialog box is displayed for you to select one of them. The following figure shows an example. 
 
-   ![stage-want1](figures/stage-want1.png)
+![](figures/ability-startup-with-implicit-want1.png)
\ No newline at end of file

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

@@ -30,6 +30,18 @@ AbilityStage is not automatically generated in the default project of DevEco Stu
    }
    ```
    
+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).
 
@@ -42,6 +54,7 @@ AbilityStage is not automatically generated in the default project of DevEco Stu
 
 - **onMemoryLevel()** event callback: triggered when the system adjusts the memory.
   
+
 When an application is switched to the background, it is cached in the background. This adversely affects the overall system performance. When system resources are insufficient, the system reclaims memory from applications in multiple ways. For example, the system may stop applications to release memory for executing key tasks. To further maintain the balance of the system memory and prevent the system from stopping application processes, you can subscribe to the system memory changes in the **onMemoryLevel()** lifecycle callback of AbilityStage to release unnecessary resources.
 
 
@@ -54,4 +67,3 @@ When an application is switched to the background, it is cached in the backgroun
       }
   }
   ```
-

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

 # Using Want to Share Data Between Applications
 
-
 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.
 
-## Prerequisites
-
-1. There are 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 through **startAbility()**, the application selector is started. 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 that application to complete data sharing.
-
-2. 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 the Want configuration used for 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.
 
-3. The following actions are involved in this section:
-   - **ACTION_SELECT (ohos.want.action.select)**: action of displaying the application selector.  
-   - **ACTION_SEND_DATA (ohos.want.action.sendData)**: action of launching the UI for sending a single data record. It is used to transfer data to the shared party.
+The following actions are involved for data sharing:
 
+- **ohos.want.action.select**: action of starting the application selector.
+- **ohos.want.action.sendData**: action of sending a single data record, that is, transferring data to the shared party.
 
-## How to Develop
+## Sharing Party
 
-- Sharing party
-  1. In the stage mode, the [File Descriptor (FD)](../reference/apis/js-apis-fileio.md#fileioopensync) is used for file transfer. This example assumes that the path of the file to share is obtained.
+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
 
-      ```ts
-      import fileIO from '@ohos.fileio';
+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**.
 
-      // let path = ...
-      // Open the file whose path is a variable.
-      let fileFd = fileIO.openSync(path, 0o102, 0o666);
-      ```
+```ts
+import common from '@ohos.app.ability.common';
 
-  2. As described in the prerequisites, the sharing party starts an application selector and shares the data to the selector, and the selector transfers the data to the shared party. Want of the sharing party must be nested at two layers. At the first layer, implicit Want is used together with the **ohos.want.action.select** action to display the application selector. At the second layer, complete Want is declared in the custom field **parameters** to transfer the data to share.
+let fileType = 'application/pdf';
+let fileName = 'TestFile.pdf';
+let fileFd = -1; // Obtain the file descriptor (FD) of the file to share.
+let fileSize; // Obtain the size of the file to share.
 
-      ```ts
-      import wantConstant from '@ohos.app.ability.wantConstant';
-      
-      // let path = ...
-      // let fileFd = ...
-      // let fileSize = ...
-      let want = {
+function implicitStartAbility() {
+  let context = getContext(this) as common.UIAbilityContext;
+  let wantInfo = {
     / This action is used to implicitly match the application selector.
-          action: wantConstant.Action.ACTION_SELECT,
+    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.
     parameters: {
       // MIME type of PDF.
-              "ability.picker.type": "application/pdf",
-              "ability.picker.fileNames": [path],
+      "ability.picker.type": fileType,
+      "ability.picker.fileNames": [fileName],
       "ability.picker.fileSizes": [fileSize],
-              // This nested Want ,which will be directly sent to the selected application.        
+      // 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}
+          "keyFd": { "type": "FD", "value": fileFd }
         }
       }
     }
   }
-      ```
+  context.startAbility(wantInfo).then(() => {
+    // ...
+  }).catch((err) => {
+    // ...
+  })
+}
+```
 
-      In the preceding code, the custom field **parameters** is used. The **ability.picker.\*** fields in the first-layer **parameters** are used to pass the information to be displayed on the application selector. The following fields are involved:
+> **NOTE**
+>
+> 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).
 
-      - **"ability.picker.type"**: The application selector renders the file type icon based on this field.
-      - **"ability.picker.fileNames"**: The application selector displays the file name based on this field.
-      - **"ability.picker.fileSizes"**: The application selector displays the file size based on this field. The unit is byte.
-      - **"ability.picker.fileNames"** and **"ability.picker.fileSizes"** are arrays and have a one-to-one mapping.
+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:
 
-      For example, when **"ability.picker.type"** is **"application/pdf"**, **"ability.picker.fileNames"** is **"["APIs.pdf"]"**, and **"ability.picker.fileSizes"** is **"[350 \* 1024]"**, the application selector is displayed as follows:
+- **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.
 
-      ![stage-want2](figures/stage-want2.png)
+The following figure shows an example.  
+![](figures/ability-startup-with-implicit-want2.png)
 
-      In the preceding code, the **ability.want.params.INTENT** field is nested Want. In this field, **action** and **type** are used for implicit matching by the application selector. For details about implicit matching, see [Matching Rules of Implicit Want](explicit-implicit-want-mappings.md#matching-rules-of-implicit-want). After the user selects an application, the nested Want of the **ability.want.params.INTENT** field is passed to that application.
+## Shared Party
 
-- Shared party
-  1. As mentioned above, the application selector performs implicit matching based on the **ability.want.params.INTENT** field. Therefore, you must set **skills** in the ability configuration file (**module.json5** file in the stage model) of the shared party as follows:
+To enable the shared party to identify the shared content, configure **skills** in the [module.json5 file](../quick-start/module-configuration-file.md) of the UIAbility of the shared party. The **actions** and **type** fields in **uris** match the **action** and **type** fields in **ability.want.params.INTENT** of the sharing party, respectively.
 
-      ```ts
+```json
+{
+  "module": {
+    // ...
+    "abilities": [
+      {
+        // ...
         "skills": [
           {
-          "entities": [
             // ...
-          ],
             "actions": [
+              "action.system.home",
               "ohos.want.action.sendData"
               // ...
             ],
@@ -88,24 +92,41 @@ Users often need to share data (such as a text or an image) from one application
               {
                 "type": "application/pdf"
               },
-            // ...
             ]
-        },
+          }
+        ]
+      }
     ]
-      ```
+  }
+}
+```
 
-      The **actions** and **type** fields in **uris** match the **action** and **type** fields in **ability.want.params.INTENT**, respectively.
+After the user selects an application, the Want nested in the **ability.want.params.INTENT** field is passed to that application. The UIAbility of the shared party, after being started, can call [onCreate()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityoncreate) or [onNewWant()](../reference/apis/js-apis-app-ability-uiAbility.md#uiabilityonnewwant) to obtain the passed Want.
 
-      Files can be transferred in FD mode, but not URI mode. In implicit matching, the **type** field in Want must match the **type** field in **uris** under **skills** of the shared party. Therefore, specify only the **type** field in **uris**. If **host** and **port** are specified, the matching fails. The application selector initiates implicit matching based on **ability.want.params.INTENT**. Therefore, when the **uri** field added to **ability.want.params.INTENT** matches the **uris** field under **skills**, the matching is successful and additional data can be transferred.
-  2. After the application selector starts the shared party, the system calls **onCreate** and passes **ability.want.params.INTENT** to the **want** parameter.
+The following is an example of the Want obtained. You can use the FD of the shared file to perform required operations.
 
-      ```ts
-      onCreate(want, launchParam) {
-        // When keyFd is undefined, the application crashes.
-        if (want["parameters"]["keyFd"] !== undefined) {
-          // Receive the file descriptor.
-          let fd = want["parameters"]["keyFd"].value;
-          // ...
-        }
-      }
-      ```
+```json
+{
+    "deviceId": "",
+    "bundleName": "com.example.myapplication",
+    "abilityName": "EntryAbility",
+    "moduleName": "entry",
+    "uri": "",
+    "type": "application/pdf",
+    "flags": 0,
+    "action": "ohos.want.action.sendData",
+    "parameters": {
+        "component.startup.newRules": true,
+        "keyFd": {
+            "type": "FD",
+            "value": 36
+        },
+        "mime-type": "application/pdf",
+        "moduleName": "entry",
+        "ohos.aafwk.param.callerPid": 3488,
+        "ohos.aafwk.param.callerToken": 537379209,
+        "ohos.aafwk.param.callerUid": 20010014
+    },
+    "entities": []
+}
+```

en/application-dev/application-models/mission-set-icon-name-for-task-snapshot.md

+# Setting the Icon and Name of a Mission Snapshot
+
+Setting a unique icon and name for each mission snapshot of an application helps you better manage the missions and functions of the application.
+
+By default, the **icon** and **label** fields in the [abilities tag](../quick-start/module-configuration-file.md#abilities) of the [module.json5 file](../quick-start/module-configuration-file.md) are used to set the icon and label.
+
+Figure 1 Mission snapshot of a UIAbility
+
+![](figures/mission-list-recent.png)
+
+You can also use [UIAbilityContext.setMissionIcon()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextsetmissionicon) and [UIAbilityContext.setMissionLabel()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextsetmissionlabel) to customize the icon and name for a mission snapshot. For example, for a UIAbility instance with the launch type set to **standard**, you can configure the icon and name for each mission snapshot based on different functions.
+
+This document describes the following operations:
+
+- [Setting a Mission Snapshot Icon (System Applications Only)](#setting-a-mission-snapshot-icon-system-applications-only)
+- [Setting a Mission Snapshot Name](#setting-a-mission-snapshot-name)
+
+## Setting a Mission Snapshot Icon (System Applications Only)
+
+Call [UIAbilityContext.setMissionIcon()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextsetmissionicon) to set the icon of a mission snapshot. The icon is an object of the [PixelMap](../reference/apis/js-apis-image.md#pixelmap7) type. For details about how to obtain the context, see [Obtaining the Context of UIAbility](uiability-usage.md#obtaining-the-context-of-uiability).
+```ts
+let imagePixelMap: PixelMap = undefined; // Obtain the PixelMap information.
+
+this.context.setMissionIcon(imagePixelMap, (err) => {
+  console.error(`setMissionLabel failed, code is ${err.code}, message is ${err.message}`);
+})
+```
+
+The display effect is shown below.
+
+Figure 2 Mission snapshot icon
+
+![](figures/mission-set-task-snapshot-icon.png)
+
+## Setting a Mission Snapshot Name
+
+Call [UIAbilityContext.setMissionLabel()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextsetmissionlabel) to set the name of a mission snapshot.
+
+```ts
+this.context.setMissionLabel('test').then(() => {
+  console.info('setMissionLabel succeeded.');
+}).catch((err) => {
+  console.error(`setMissionLabel failed, code is ${err.code}, message is ${err.message}`);
+});
+```
+
+The display effect is shown below.
+
+Figure 3 Mission snapshot name
+
+![](figures/mission-set-task-snapshot-label.png)
\ No newline at end of file

en/application-dev/application-models/subscribe-system-environment-variable-changes.md

+# Subscribing to System Environment Variable Changes
+
+System environment variables are system settings (for example, the system language or screen direction) of a device that may change during the running of an application.
+
+By subscribing to the changes of system environment variables, the application can detect the changes in a timely manner and process the changes accordingly, providing better user experience. For example, when the system language changes, the application can display the UI in the new language; when the user rotates the device to landscape or portrait mode, the application can re-arrange the UI to adapt to the new screen orientation and size.
+
+The system environment variable changes are usually triggered by options in **Settings** or icons in **Control Panel**. For details about the system environment variables that support subscription, see [Configuration](../reference/apis/js-apis-app-ability-configuration.md).
+
+In OpenHarmony, you can subscribe to system environment variable changes in the following ways:
+
+- [Using ApplicationContext for Subscription](#using-applicationcontext-for-subscription)
+- [Using AbilityStage for Subscription](#using-abilitystage-for-subscription)
+- [Using UIAbility for Subscription](#using-uiability-for-subscription)
+- [Using ExtensionAbility for Subscription](#using-extensionability-for-subscription)
+
+## Using ApplicationContext for Subscription
+
+[ApplicationContext](../reference/apis/js-apis-inner-application-applicationContext.md) provides an API for registering a callback function to subscribe to the system environment variable changes. It also provides an API for deregistration so you can release related resources when they are no longer needed.
+
+1. Call **ApplicationContext.on(type: 'environment', callback: EnvironmentCallback)** to subscribe to changes in system environment variables. The code snippet below is used to subscribe to system language changes on a page.
+
+   ```ts
+   import common from '@ohos.app.ability.common';
+   
+   @Entry
+   @Component
+   struct Index {
+     private context = getContext(this) as common.UIAbilityContext;
+     private callbackId: number; // ID of the subscription for system environment variable changes.
+   
+     subscribeConfigurationUpdate() {
+       let systemLanguage: string = this.context.config.language; // Obtain the system language in use.
+   
+       // 1. Obtain an ApplicationContext object.
+       let applicationContext = this.context.getApplicationContext();
+   
+       // 2. Subscribe to system environment variable changes through ApplicationContext.
+       let environmentCallback = {
+         onConfigurationUpdated(newConfig) {
+           console.info(`onConfigurationUpdated systemLanguage is ${systemLanguage}, newConfig: ${JSON.stringify(newConfig)}`);
+   
+           if (this.systemLanguage !== newConfig.language) {
+             console.info(`systemLanguage from ${systemLanguage} changed to ${newConfig.language}`);
+             systemLanguage = newConfig.language; // Save the new system language as the system language in use, which will be used for comparison.
+           }
+         },
+         onMemoryLevel(level) {
+           console.info(`onMemoryLevel level: ${level}`);
+         }
+       }
+   
+       this.callbackId = applicationContext.on('environment', environmentCallback);
+     }
+   
+     // Page display.
+     build() {
+       // ...
+     }
+   }
+   ```
+
+2. Call **ApplicationContext.off(type: 'environment', callbackId: number)** to release the resources.
+
+   ```ts
+   import common from '@ohos.app.ability.common';
+   
+   @Entry
+   @Component
+   struct Index {
+     private context = getContext(this) as common.UIAbilityContext;
+     private callbackId: number; // ID of the subscription for system environment variable changes.
+   
+     unsubscribeConfigurationUpdate() {
+       let applicationContext = this.context.getApplicationContext();
+       applicationContext.off('environment', this.callbackId);
+     }
+   
+     // Page display.
+     build() {
+       // ...
+     }
+   }
+   ```
+
+## Using AbilityStage for Subscription
+
+The AbilityStage component provides the [AbilityStage.onConfigurationUpdate()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonconfigurationupdate) callback for subscribing to system environment variable changes. This callback is invoked when a system environment variable changes. In this callback, the latest system environment configuration is obtained through the [Configuration](../reference/apis/js-apis-app-ability-configuration.md) object.  
+
+> **NOTE**
+>
+> - 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).
+> - The callback used to subscribe to system environment variable changes has the same lifecycle as the [AbilityStage](../reference/apis/js-apis-app-ability-abilityStage.md) instance and will be destroyed when the instance is destroyed.
+
+The code snippet below uses the [AbilityStage.onConfigurationUpdate()](../reference/apis/js-apis-app-ability-abilityStage.md#abilitystageonconfigurationupdate) callback to subscribe to the system language changes.
+
+```ts
+import AbilityStage from '@ohos.app.ability.AbilityStage';
+
+let systemLanguage: string; // System language in use.
+
+export default class MyAbilityStage extends AbilityStage {
+    onCreate() {
+        systemLanguage = this.context.config.language; // Obtain the system language in use when the AbilityStage instance is loaded for the first time.
+        console.info(`systemLanguage is ${systemLanguage} `);
+    }
+
+    onConfigurationUpdate(newConfig) {
+        console.info(`onConfigurationUpdated systemLanguage is ${systemLanguage}, newConfig: ${JSON.stringify(newConfig)}`);
+
+        if (systemLanguage !== newConfig.language) {
+            console.info(`systemLanguage from ${systemLanguage} changed to ${newConfig.language}`);
+            systemLanguage = newConfig.language; // Save the new system language as the system language in use, which will be used for comparison.
+        }
+    }
+}
+```
+
+## Using UIAbility for Subscription
+
+The UIAbility component provides the **UIAbility.onConfigurationUpdate()** callback for subscribing to system environment variable changes. This callback is invoked when a system environment variable changes. In this callback, the latest system environment configuration is obtained through the [Configuration](../reference/apis/js-apis-app-ability-configuration.md) object, without restarting the UIAbility.
+
+> **NOTE**
+>
+> The callback used to subscribe to system environment variable changes has the same lifecycle as the UIAbility instance and will be destroyed when the instance is destroyed.
+
+The code snippet below uses the **onConfigurationUpdate()** callback to subscribe to the system language changes.
+
+```ts
+import UIAbility from '@ohos.app.ability.UIAbility';
+
+let systemLanguage: string; // System language in use.
+
+export default class EntryAbility extends UIAbility {
+    onCreate(want, launchParam) {
+        systemLanguage = this.context.config.language; // Obtain the system language in use when the UIAbility instance is loaded for the first time.
+        console.info(`systemLanguage is ${systemLanguage} `);
+    }
+
+    onConfigurationUpdate(newConfig) {
+        console.info(`onConfigurationUpdated systemLanguage is ${systemLanguage}, newConfig: ${JSON.stringify(newConfig)}`);
+
+        if (systemLanguage !== newConfig.language) {
+            console.info(`systemLanguage from ${systemLanguage} changed to ${newConfig.language}`);
+            systemLanguage = newConfig.language; // Save the new system language as the system language in use, which will be used for comparison.
+        }
+    }
+
+    // ...
+}
+```
+
+## Using ExtensionAbility for Subscription
+
+The ExtensionAbility component provides the **onConfigurationUpdate()** callback for subscribing system environment variable changes. This callback is invoked when a system environment variable changes. In this callback, the latest system environment configuration is obtained through the [Configuration](../reference/apis/js-apis-app-ability-configuration.md) object.
+
+> **NOTE**
+>
+> The callback used to subscribe to system environment variable changes has the same lifecycle as the ExtensionAbility instance and will be destroyed when the instance is destroyed.
+
+The code snippet below uses FormExtensionAbility as an example to describe how to use the **onConfigurationUpdate()** callback to subscribe to system environment variable changes.
+
+```ts
+import FormExtensionAbility from '@ohos.app.form.FormExtensionAbility';
+
+export default class EntryFormAbility extends FormExtensionAbility {
+    onConfigurationUpdate(newConfig) {
+        console.info(`newConfig is ${JSON.stringify(newConfig)}`);
+    }
+
+    // ...
+}
+```

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

@@ -15,6 +15,8 @@ This topic describes the UIAbility interaction modes in the following scenarios.
 
 - [Starting UIAbility of Another Application and Obtaining the Return Result](#starting-uiability-of-another-application-and-obtaining-the-return-result)
 
+- [Starting UIAbility with Window Mode Specified (System Applications Only)](#starting-uiability-with-window-mode-specified-system-applications-only)
+
 - [Starting a Specified Page of UIAbility](#starting-a-specified-page-of-uiability)
 
 - [Using Ability Call to Implement UIAbility Interaction (System Applications Only)](#using-ability-call-to-implement-uiability-interaction-system-applications-only)
@@ -202,8 +204,7 @@ This section describes how to start the UIAbility of another application through
    ```
 
    The following figure shows the effect. When you click **Open PDF**, a dialog box is displayed for you to select.
-
-   ![uiability-intra-device-interaction](figures/uiability-intra-device-interaction.png)
+   ![](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).
    
@@ -307,6 +308,55 @@ If you want to obtain the return result when using implicit Want to start the UI
    })
    ```
 
+## Starting UIAbility with Window Mode Specified (System Applications Only)
+
+By specifying the window mode when starting the UIAbility of an application, the application can be displayed in different window modes, which can be full-screen, floating window, or split-screen.
+
+In full-screen mode, an application occupies the entire screen after being started. Users cannot view other windows or applications. This mode is suitable for an application that requires users to focus on a specific task or UI.
+
+In floating window mode, an application is displayed on the screen as a floating window after being started. Users can easily switch to other windows or applications. The mode is suitable for an application that requires users to process multiple tasks at the same time.
+
+In split-screen mode, two applications occupy the entire screen, with one on the left or in the upper part of the screen and the other on the right or in the lower part. This mode helps users improve multi-task processing efficiency.
+
+The window mode is specified by the **windowMode** field in the [StartOptions](../reference/apis/js-apis-app-ability-startOptions.md) parameter of [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability).
+
+> **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.
+
+The following uses the floating window mode as an example to describe how to start the FuncAbility from the EntryAbility page.
+
+1. Add the [StartOptions](../reference/apis/js-apis-app-ability-startOptions.md) parameter in [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability).
+2. Set the **windowMode** field in the [StartOptions](../reference/apis/js-apis-app-ability-startOptions.md) parameter to **WINDOW_MODE_FLOATING**, indicating that the UIAbility will be displayed in a floating window.
+
+For details about how to obtain the context, see [Obtaining the Context of UIAbility](uiability-usage.md#obtaining-the-context-of-uiability).
+
+```ts
+import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+
+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',
+  },
+}
+let options = {
+  windowMode: AbilityConstant.WindowMode.WINDOW_MODE_FLOATING
+}
+// context is the ability-level context of the initiator UIAbility.
+this.context.startAbility(wantInfo, options).then(() => {
+  // ...
+}).catch((err) => {
+  // ...
+})
+```
+
+The display effect is shown below.  
+![](figures/start-uiability-floating-window.png)
 
 ## Starting a Specified Page of UIAbility
 
@@ -438,7 +488,7 @@ Ability call is usually used in the following scenarios:
 
 - Starting the callee ability in the background
 
-**Table 1** Terms used in the ability call
+  **Table 1** Terms used in the ability call
 
 | **Term**| Description|
 | -------- | -------- |
@@ -449,9 +499,9 @@ Ability call is usually used in the following scenarios:
 
 The following figure shows the ability call process.
 
-Figure 1 Ability call process
+  Figure 1 Ability call process
 
-![call](figures/call.png)
+  ![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.
 
@@ -469,7 +519,7 @@ Figure 1 Ability call process
 
 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).
 
-**Table 2** Ability call APIs
+ **Table 2** Ability call APIs
 
 | API| Description|
 | -------- | -------- |
@@ -502,6 +552,7 @@ For the callee ability, implement the callback to receive data and the methods t
    
    An example of the ability configuration is as follows:
    
+   
    ```json
    "abilities":[{
      "name": ".CalleeAbility",
@@ -524,6 +575,7 @@ For the callee ability, implement the callback to receive data and the methods t
 
    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 MySequenceable {
        num: number = 0
@@ -551,7 +603,6 @@ For the callee ability, implement the callback to receive data and the methods t
 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 sequenceable 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';
@@ -588,7 +639,6 @@ For the callee ability, implement the callback to receive data and the methods t
    }
    ```
 
-
 ### Accessing the Callee Ability
 
 1. Import the **UIAbility** module.

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

@@ -18,12 +18,9 @@ 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)  
 
-> **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.
+> **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.
 
 To use the singleton mode, set **launchType** in the [module.json5 configuration file](../quick-start/module-configuration-file.md) to **singleton**.
 
@@ -48,7 +45,6 @@ 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  
-
 ![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**.
@@ -74,12 +70,11 @@ 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)  
 
-For example, there are EntryAbility and SpecifiedAbility, and the launch type of SpecifiedAbility is set to **specified**. You are required to start SpecifiedAbility from EntryAbility.
+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 configuration file](../quick-start/module-configuration-file.md) to **specified**.
+1. In SpecifiedAbility, set the **launchType** field in the [module.json5 file](../quick-start/module-configuration-file.md) to **specified**.
 
    ```json
    {
@@ -95,8 +90,7 @@ For example, there are EntryAbility and SpecifiedAbility, and the launch type of
    }
    ```
 
-2. Before a UIAbility instance is created, you can create a unique string key for the instance. The key is bound to the UIAbility instance when it is created. Each time [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) is called, the application is asked which UIAbility instance is used to respond to the [startAbility()](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability) 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 instances.
+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.
@@ -122,8 +116,9 @@ For example, there are EntryAbility and SpecifiedAbility, and the launch type of
    })
    ```
 
-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';
@@ -133,7 +128,7 @@ For example, there are EntryAbility and SpecifiedAbility, and the launch type of
            // In the AbilityStage instance of the callee, a key value corresponding to a UIAbility instance is returned for UIAbility whose launch type is specified.
            // In this example, SpecifiedAbility of module1 is returned.
            if (want.abilityName === 'SpecifiedAbility') {
-               // The returned string key is a custom string.
+               // The returned key string is a custom string.
                return `SpecifiedAbilityInstance_${want.parameters.instanceKey}`;
            }
    
@@ -142,21 +137,16 @@ For example, there are EntryAbility and SpecifiedAbility, and the launch type of
    }
    ```
 
-   > **NOTE**
+   > **NOTE**<br>
    >
    > 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 key values are bound to different document instances. Each time a document is created, a new key value (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.
+   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.
 
-The following steps are used as an example.
    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_check--> 
+   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.
\ No newline at end of file