Update docs against 10847+10918+10962

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

en/application-dev/ability/stage-ability.md

 # Ability Development
 ## When to Use
-Ability development in the [stage model](stage-brief.md) is significantly different from that in the FA model. The stage model requires you to declare the application package structure in the `module.json5` and `app.json5` files during application development. For details about the configuration file, see [Application Package Structure Configuration File](../quick-start/stage-structure.md). To develop an ability based on the stage model, implement the following logic:
+Ability development in the [stage model](stage-brief.md) is significantly different from that in the FA model. The stage model requires you to declare the application package structure in the **module.json5** and **app.json5** files during application development. For details about the configuration file, see [Application Package Structure Configuration File](../quick-start/stage-structure.md). To develop an ability based on the stage model, implement the following logic:
 - Create an ability that supports screen viewing and human-machine interaction. You must implement the following scenarios: ability lifecycle callbacks, obtaining ability configuration, requesting permissions, and notifying environment changes.
 - Start an ability. You need to implement ability startup on the same device, on a remote device, or with a specified UI page.
 - Call abilities. For details, see [Call Development](stage-call.md).
@@ -8,15 +8,15 @@ Ability development in the [stage model](stage-brief.md) is significantly differ
 - Continue the ability on another device. For details, see [Ability Continuation Development](stage-ability-continuation.md).
 
 ### Launch Type
-An ability can be launched in the **standard**, **singleton**, or **specified** mode, as configured by `launchType` in the `module.json5` file. Depending on the launch type, the action performed when the ability is started differs, as described below.
+An ability can be launched in the **standard**, **singleton**, or **specified** mode, as configured by **launchType** in the **module.json5** file. Depending on the launch type, the action performed when the ability is started differs, as described below.
 
 | Launch Type    | Description    |Action            |
 | ----------- | -------  |---------------- |
-| standard    | Multi-instance  | A new instance is started each time an ability starts.|
-| singleton   | Singleton  | The ability has only one instance in the system. If an instance already exists when an ability is started, that instance is reused.|
+| standard    | Multi-instance mode | A new instance is started each time an ability starts.|
+| singleton   | Singleton mode  | The ability has only one instance in the system. If an instance already exists when an ability is started, that instance is reused.|
 | specified   | Instance-specific| The internal service of an ability determines whether to create multiple instances during running.|
 
-By default, the singleton mode is used. The following is an example of the `module.json5` file:
+By default, the singleton mode is used. The following is an example of the **module.json5** file:
 ```json
 {
   "module": {
@@ -30,7 +30,7 @@ By default, the singleton mode is used. The following is an example of the `modu
 ```
 ## Creating an Ability
 ### Available APIs
-The table below describes the APIs provided by the `AbilityStage` class, which has the `context` attribute. For details about the APIs, see [AbilityStage](../reference/apis/js-apis-application-abilitystage.md).
+The table below describes the APIs provided by the **AbilityStage** class, which has the **context** attribute. For details about the APIs, see [AbilityStage](../reference/apis/js-apis-application-abilitystage.md).
 
 **Table 1** AbilityStage APIs
 |API|Description|
@@ -39,7 +39,7 @@ The table below describes the APIs provided by the `AbilityStage` class, which h
 |onAcceptWant(want: Want): string|Called when a specified ability is started.|
 |onConfigurationUpdated(config: Configuration): void|Called when the global configuration is updated.|
 
-The table below describes the APIs provided by the `Ability` class. For details about the APIs, see [Ability](../reference/apis/js-apis-application-ability.md).
+The table below describes the APIs provided by the **Ability** class. For details about the APIs, see [Ability](../reference/apis/js-apis-application-ability.md).
 
 **Table 2** Ability APIs
 
@@ -47,19 +47,19 @@ The table below describes the APIs provided by the `Ability` class. For details
 |:------|:------|
 |onCreate(want: Want, param: AbilityConstant.LaunchParam): void|Called when an ability is created.|
 |onDestroy(): void|Called when the ability is destroyed.|
-|onWindowStageCreate(windowStage: window.WindowStage): void|Called when a `WindowStage` is created for the ability. You can use the `window.WindowStage` APIs to implement operations such as page loading.|
-|onWindowStageDestroy(): void|Called when the `WindowStage` is destroyed for the ability.|
+|onWindowStageCreate(windowStage: window.WindowStage): void|Called when a **WindowStage** is created for the ability. You can use the **window.WindowStage** APIs to implement operations such as page loading.|
+|onWindowStageDestroy(): void|Called when the **WindowStage** is destroyed for the ability.|
 |onForeground(): void|Called when the ability is switched to the foreground.|
 |onBackground(): void|Called when the ability is switched to the background.|
-|onNewWant(want: Want, launchParams: AbilityConstant.LaunchParam): void|Called when the ability launch type is set to `singleton`.|
+|onNewWant(want: Want, launchParams: AbilityConstant.LaunchParam): void|Called when the ability launch type is set to **singleton**.|
 |onConfigurationUpdated(config: Configuration): void|Called when the configuration of the environment where the ability is running is updated.|
 ### Implementing AbilityStage and Ability Lifecycle Callbacks
-To create Page abilities for an application in the stage model, you must implement the `AbilityStage` class and ability lifecycle callbacks, and use the `Window` APIs to set the pages. The sample code is as follows:
-1. Import the `AbilityStage` module.
+To create Page abilities for an application in the stage model, you must implement the **AbilityStage** class and ability lifecycle callbacks, and use the **Window** class to set the pages. The sample code is as follows:
+1. Import the **AbilityStage** module.
    ```
    import AbilityStage from "@ohos.application.AbilityStage"
    ```
-2. Implement the `AbilityStage` class. The default relative path generated by the APIs is **entry\src\main\ets\Application\AbilityStage.ts**.
+2. Implement the **AbilityStage** class. The default relative path generated by the APIs is **entry\src\main\ets\Application\AbilityStage.ts**.
    ```ts
    export default class MyAbilityStage extends AbilityStage {
     onCreate() {
@@ -67,13 +67,13 @@ To create Page abilities for an application in the stage model, you must impleme
     }
    }
    ```
-3. Import the `Ability` module.
+3. Import the **Ability** module.
    ```js
    import Ability from '@ohos.application.Ability'
    ```
-4. Implement the lifecycle callbacks of the `Ability` class. The default relative path generated by the APIs is **entry\src\main\ets\MainAbility\MainAbility.ts**.
+4. Implement the lifecycle callbacks of the **Ability** class. The default relative path generated by the APIs is **entry\src\main\ets\MainAbility\MainAbility.ts**.
 
-   In the `onWindowStageCreate(windowStage)` API, use `loadContent` to set the application page to be loaded. For details about how to use the `Window` APIs, see [Window Development](../windowmanager/application-window-stage.md).
+   In the **onWindowStageCreate(windowStage)** API, use **loadContent** to set the application page to be loaded. For details about how to use the **Window** APIs, see [Window Development](../windowmanager/application-window-stage.md).
    ```ts
    export default class MainAbility extends Ability {
     onCreate(want, launchParam) {
@@ -108,9 +108,9 @@ To create Page abilities for an application in the stage model, you must impleme
    }
    ```
 ### Obtaining AbilityStage and Ability Configurations
-Both the `AbilityStage` and `Ability` classes have the `context` attribute. An application can obtain the context of an `Ability` instance through `this.context` to obtain the configuration details.
+Both the **AbilityStage** and **Ability** classes have the **context** attribute. An application can obtain the context of an **Ability** instance through **this.context** to obtain the configuration details.
 
-The following example shows how an application obtains the bundle code directory, HAP file name, ability name, and system language through the `context` attribute in the `AbilityStage` class. The sample code is as follows:
+The following example shows how an application obtains the bundle code directory, HAP file name, ability name, and system language through the **context** attribute in the **AbilityStage** class. The sample code is as follows:
 
 ```ts
 import AbilityStage from "@ohos.application.AbilityStage"
@@ -130,7 +130,7 @@ export default class MyAbilityStage extends AbilityStage {
 }
 ```
 
-The following example shows how an application obtains the bundle code directory, HAP file name, ability name, and system language through the `context` attribute in the `Ability` class. The sample code is as follows:
+The following example shows how an application obtains the bundle code directory, HAP file name, ability name, and system language through the **context** attribute in the **Ability** class. The sample code is as follows:
 ```ts
 import Ability from '@ohos.application.Ability'
 export default class MainAbility extends Ability {
@@ -149,9 +149,9 @@ export default class MainAbility extends Ability {
 }
 ```
 ### Requesting Permissions
-If an application needs to obtain user privacy information or use system capabilities, for example, obtaining location information or using the camera to take photos or record videos, it must request the respective permission from consumers. During application development, you need to specify the involved sensitive permissions, declare the required permissions in `module.json5`, and use the `requestPermissionsFromUser` API to request the permission from consumers in the form of a dialog box. The following uses the permission for calendar access as an example.
+If an application needs to obtain user privacy information or use system capabilities, for example, obtaining location information or using the camera to take photos or record videos, it must request the respective permission from consumers. During application development, you need to specify the involved sensitive permissions, declare the required permissions in **module.json5**, and use the **requestPermissionsFromUser** API to request the permission from consumers in the form of a dialog box. The following uses the permission for calendar access as an example.
 
-Declare the required permission in the `module.json5` file.
+Declare the required permission in the **module.json5** file.
 ```json
 "requestPermissions": [
     {
@@ -170,13 +170,13 @@ context.requestPermissionsFromUser(permissions).then((data) => {
 })
 ```
 ### Notifying of Environment Changes
-Environment changes include changes of global configurations and ability configurations. Currently, the global configurations include the system language and color mode. The change of global configurations is generally triggered by configuration items in **Settings** or icons in **Control Panel**. The ability configuration is specific to a single `Ability` instance, including the display ID, screen resolution, and screen orientation. The configuration is related to the display where the ability is located, and the change is generally triggered by the window. For details on the configuration, see [Configuration](../reference/apis/js-apis-configuration.md).
+Environment changes include changes of global configurations and ability configurations. Currently, the global configurations include the system language and color mode. The change of global configurations is generally triggered by configuration items in **Settings** or icons in **Control Panel**. The ability configuration is specific to a single **Ability** instance, including the display ID, screen resolution, and screen orientation. The configuration is related to the display where the ability is located, and the change is generally triggered by the window. For details on the configuration, see [Configuration](../reference/apis/js-apis-configuration.md).
 
-For an application in the stage model, when the configuration changes, its abilities are not restarted, but the `onConfigurationUpdated(config: Configuration)` callback is triggered. If the application needs to perform processing based on the change, you can overwrite `onConfigurationUpdated`. Note that the `Configuration` object in the callback contains all the configurations of the current ability, not only the changed configurations.
+For an application in the stage model, when the configuration changes, its abilities are not restarted, but the **onConfigurationUpdated(config: Configuration)** callback is triggered. If the application needs to perform processing based on the change, you can overwrite **onConfigurationUpdated**. Note that the **Configuration** object in the callback contains all the configurations of the current ability, not only the changed configurations.
 
-The following example shows the implementation of the `onConfigurationUpdated` callback in the `AbilityStage` class. The callback is triggered when the system language and color mode are changed.  
+The following example shows the implementation of the **onConfigurationUpdated** callback in the **AbilityStage** class. The callback is triggered when the system language and color mode are changed.  
 ```ts
-import Ability from '@ohos.application.Ability'
+import AbilityStage from '@ohos.application.AbilityStage'
 import ConfigurationConstant from '@ohos.application.ConfigurationConstant'
 
 export default class MyAbilityStage extends AbilityStage {
@@ -188,7 +188,7 @@ export default class MyAbilityStage extends AbilityStage {
 }
 ```
 
-The following example shows the implementation of the `onConfigurationUpdated` callback in the `Ability` class. The callback is triggered when the system language, color mode, or display parameters (such as the direction and density) change.  
+The following example shows the implementation of the **onConfigurationUpdated** callback in the **Ability** class. The callback is triggered when the system language, color mode, or display parameters (such as the direction and density) change.  
 ```ts
 import Ability from '@ohos.application.Ability'
 import ConfigurationConstant from '@ohos.application.ConfigurationConstant'
@@ -209,7 +209,7 @@ export default class MainAbility extends Ability {
 ```
 ## Starting an Ability
 ### Available APIs
-The `Ability` class has the `context` attribute, which belongs to the `AbilityContext` class. The `AbilityContext` class has the `abilityInfo`, `currentHapModuleInfo`, and other attributes as well as the APIs used for starting abilities. For details, see [AbilityContext](../reference/apis/js-apis-ability-context.md).
+The **Ability** class has the **context** attribute, which belongs to the **AbilityContext** class. The **AbilityContext** class has the **abilityInfo**, **currentHapModuleInfo**, and other attributes as well as the APIs used for starting abilities. For details, see [AbilityContext](../reference/apis/js-apis-ability-context.md).
 
 **Table 3** AbilityContext APIs
 |API|Description|
@@ -223,7 +223,7 @@ The `Ability` class has the `context` attribute, which belongs to the `AbilityCo
 |startAbilityForResultWithAccount(want: Want, accountId: number, callback: AsyncCallback\<AbilityResult>): void|Starts an ability with the execution result and account ID.|
 |startAbilityForResultWithAccount(want: Want, accountId: number, options?: StartOptions): Promise\<AbilityResult>|Starts an ability with the execution result and account ID.|
 ### Starting an Ability on the Same Device
-An application can obtain the context of an `Ability` instance through `this.context` and then use the `startAbility` API in the `AbilityContext` class to start the ability. The ability can be started by specifying `Want`, `StartOptions`, and `accountId`, and the operation result can be returned using a callback or `Promise` instance. The sample code is as follows:
+An application can obtain the context of an **Ability** instance through **this.context** and then use the **startAbility** API in the **AbilityContext** class to start the ability. The ability can be started by specifying **Want**, **StartOptions**, and **accountId**, and the operation result can be returned using a callback or **Promise** instance. The sample code is as follows:
 ```ts
 let context = this.context
 var want = {
@@ -239,7 +239,7 @@ context.startAbility(want).then(() => {
 ```
 
 ### Starting an Ability on a Remote Device
->This feature applies only to system applications, since the `getTrustedDeviceListSync` API of the `DeviceManager` class is open only to system applications.
+>This feature applies only to system applications, since the **getTrustedDeviceListSync** API of the **DeviceManager** class is open only to system applications.
 In the cross-device scenario, you must specify the ID of the remote device. The sample code is as follows:
 ```ts
 let context = this.context
@@ -254,7 +254,7 @@ context.startAbility(want).then(() => {
     console.error("Failed to start remote ability with error: " + JSON.stringify(error))
 })
 ```
-Obtain the ID of a specified device from `DeviceManager`. The sample code is as follows:
+Obtain the ID of a specified device from **DeviceManager**. The sample code is as follows:
 ```ts
 import deviceManager from '@ohos.distributedHardware.deviceManager';
 function getRemoteDeviceId() {
@@ -271,11 +271,11 @@ function getRemoteDeviceId() {
     }
 }
 ```
-Request the permission `ohos.permission.DISTRIBUTED_DATASYNC` from consumers. This permission is used for data synchronization. For details about the sample code for requesting the permission, see [Requesting Permissions](##requesting-permissions).
+Request the permission **ohos.permission.DISTRIBUTED_DATASYNC** from consumers. This permission is used for data synchronization. For details about the sample code for requesting the permission, see [Requesting Permissions](#requesting-permissions).
 ### Starting an Ability with the Specified Page
-If the launch type of an ability is set to `singleton` and the ability has been started, the `onNewWant` callback is triggered when the ability is started again. You can pass start options through the `want`. For example, to start an ability with the specified page, use the `uri` or `parameters` parameter in the `want` to pass the page information. Currently, the ability in the stage model cannot directly use the `router` capability. You must pass the start options to the custom component and invoke the `router` method to display the specified page during the custom component lifecycle management. The sample code is as follows:
+If the launch type of an ability is set to **singleton** and the ability has been started, the **onNewWant** callback is triggered when the ability is started again. You can pass start options through the **want**. For example, to start an ability with the specified page, use the **uri** or **parameters** parameter in the **want** to pass the page information. Currently, the ability in the stage model cannot directly use the **router** capability. You must pass the start options to the custom component and invoke the **router** method to display the specified page during the custom component lifecycle management. The sample code is as follows:
 
-When using `startAbility` to start an ability again, use the `uri` parameter in the `want` to pass the page information.
+When using **startAbility** to start an ability again, use the **uri** parameter in the **want** to pass the page information.
 ```ts
 async function reStartAbility() {
   try {
@@ -291,7 +291,7 @@ async function reStartAbility() {
 }
 ```
 
-Obtain the `want` parameter that contains the page information from the `onNewWant` callback of the ability.
+Obtain the **want** parameter that contains the page information from the **onNewWant** callback of the ability.
 ```ts
 import Ability from '@ohos.application.Ability'
 
@@ -302,7 +302,7 @@ export default class MainAbility extends Ability {
 }
 ```
 
-Obtain the `want` parameter that contains the page information from the custom component and process the route based on the URI.
+Obtain the **want** parameter that contains the page information from the custom component and process the route based on the URI.
 ```ts
 import router from '@ohos.router'
 

en/application-dev/reference/apis/js-apis-configuration.md

@@ -23,4 +23,4 @@ import Configuration from '@ohos.application.Configuration';
 | direction<sup>9+</sup> | Direction | Yes| No| Screen orientation, which can be **DIRECTION_HORIZONTAL** or **DIRECTION_VERTICAL**.|
 | screenDensity<sup>9+</sup>  | ScreenDensity | Yes| No| Screen resolution, which can be **SCREEN_DENSITY_SDPI** (120), **SCREEN_DENSITY_MDPI** (160), **SCREEN_DENSITY_LDPI** (240), **SCREEN_DENSITY_XLDPI** (320), **SCREEN_DENSITY_XXLDPI** (480), or **SCREEN_DENSITY_XXXLDPI** (640).|
 | displayId<sup>9+</sup>  | number | Yes| No| ID of the display where the application is located.|
-| hasPointerDevice<sup>9+</sup>  | boolean | Yes| No| Whether the pointer device is connected.| 
+| hasPointerDevice<sup>9+</sup>  | boolean | Yes| No| Whether a pointer device, such as a keyboard, mouse, or touchpad, is connected.|

en/application-dev/webgl/webgl-overview.md

 # WebGL Overview
 
-Web Graphic Library (WebGL) is used for rendering interactive 2D and 3D graphics. WebGL used in OpenHarmony is based on OpenGL for Embedded Systems (OpenGL ES). It can be used in the **<canvas>** object of HTML5 without using plug-ins and supports cross-platform. WebGL is programmed by JavaScript code. Its APIs can implement graphics rendering and acceleration by using GPU hardware provided by the user equipment.
+Web Graphic Library (WebGL) is used for rendering interactive 2D and 3D graphics. WebGL used in OpenHarmony is based on OpenGL for Embedded Systems (OpenGL ES). It can be used in the **\<canvas>** object of HTML5 without using plug-ins and supports cross-platform. WebGL is programmed by JavaScript code. Its APIs can implement graphics rendering and acceleration by using GPU hardware provided by the user equipment. For more information, see [WebGL™](https://www.khronos.org/registry/webgl/specs/latest/1.0/).
 
 
 ## Basic Concepts
@@ -31,7 +31,7 @@ The WebGLProgram is a JavaScript object responsible for associating the shader w
 
 ## Working Principles
 
-  **Figure 1** WebGL working principles
+**Figure 1** WebGL working principles
 
 ![en-us_image_0000001238544451](figures/en-us_image_0000001238544451.png)
 
@@ -40,7 +40,7 @@ The WebGLProgram is a JavaScript object responsible for associating the shader w
 
 - Native APIs complete the interaction between JavaScript and C++ code.
 
-- JavaScript engine is a graphics framework that provides the **Surface** object for the WebGL module.
+- JavaScript engine is the graphics framework that provides the **Surface** object for the WebGL module.
 
 - The WebGL module exposes the GPU drawing APIs of OpenGL ES.
 

en/release-notes/OpenHarmony-v3.2-beta3.md

@@ -53,8 +53,8 @@ The distributed database supports cross-device and cross-application sharing. Th
 | Software/Tool| Version| Remarks|
 | -------- | -------- | -------- |
 | OpenHarmony | 3.2 Beta3| NA |
-| Public SDK | Ohos_sdk_public 3.2.7.5 (API Version 9 Beta3)| This toolkit is intended for application developers and does not contain system APIs that require system permissions.<br>It is provided as standard in DevEco Studio.|
-| Full SDK | Ohos_sdk_full 3.2.7.5 (API Version 9 Beta3)| This toolkit is intended for original equipment manufacturers (OEMs) and contains system APIs that require system permissions.<br>To use the full SDK, manually obtain it from the mirror and switch to it in DevEco Studio. For details, see [Guide to Switching to Full SDK](../application-dev/quick-start/full-sdk-switch-guide.md).|
+| Public SDK | Ohos_sdk_public 3.2.7.5 (API Version 9 Beta3) | This toolkit is intended for application developers and does not contain system APIs that require system permissions.<br>It is provided as standard in DevEco Studio.|
+| Full SDK | Ohos_sdk_full 3.2.7.5 (API Version 9 Beta3)   | This toolkit is intended for original equipment manufacturers (OEMs) and contains system APIs that require system permissions.<br>To use the full SDK, manually obtain it from the mirror and switch to it in DevEco Studio. For details, see [Guide to Switching to Full SDK](../application-dev/quick-start/full-sdk-switch-guide.md).|
 | (Optional) HUAWEI DevEco Studio| 3.0 Release| Recommended for developing OpenHarmony applications.|
 | (Optional) HUAWEI DevEco Device Tool| 3.0 Release| Recommended for developing OpenHarmony devices.|
 
@@ -167,10 +167,12 @@ This version has the following updates to OpenHarmony 3.2 Beta2.
 | Multi-language runtime subsystem| The front-end compilation performance is improved, for example, by using the es2abc component.<br>Runtime performance is improved through ISA reconstruction, assembly interpreter, and TS Ahead of Time (AOT) compiler.<br>New functions are added, such as ES2021 in strict mode, modularization, runtime debugging and tuning enhancement, and bytecode hot reload.<br>The following requirements are involved:<br>I5MYM9 [New specifications] Merging and adaptation of the abc file for multiple modules<br>I59TAQ [New specifications] Standard compilation lowering of the TS AOT compiler and pass description optimization<br>I5OJ8Q [New specifications] Displaying the attribute types defined ES2021 in DevEco Studio<br>I5ODV4 [New feature] Uninstalling bytecode patch files<br>I5OXSC [New feature] Installing bytecode patch files<br>I5HNNZ [New feature] Enabling the namespace of the loader<br>I5HVQE [New feature] Product-specific stack size setting of the thread, and stack page guard<br>I5MCUF [Enhanced feature] New CAPIs of libc and support for symbols such as pthread<br>I5HVNH [New feature] RM.006. Enhanced dynamic library symbol management<br>I5HVQ0 [New feature] RM.008. Fortify supported by musl<br>I5KT7X [New feature] RM.002. API detection for API header files<br>I5TB3Y [New feature] ABI using emutls by default<br>I5R119 [Enhanced feature] Separated use of memory for loader and libc<br>Open-source Clang toolchain<br>I5MYM9 [New specifications] Modular compilation supported by the front-end compiler toolchain<br>I5IKO1 [New specifications] Compiling Commonjs module with the es2abc component<br>I5RRAJ [New specifications] Patch file source code identification tool<br>I5PRFT [New specifications] Patch bytecode compiler<br>I5RHDH [New specifications] Hot loading of ArkCompiler bytecode<br>I5RA7C [New specifications] Support for ES2021 in strict mode<br>I5HRUY [New specifications] Converting from JS code to ArkCompiler bytecode by the es2abc component| NA |
 | IAM account subsystem and program access control subsystem| User identity authentication is added to the IAM account subsystem. The permission service supports precise positioning and fuzzy positioning, and other capabilities are enhanced. The privacy management service is provided.<br>The following requirements are involved:<br>I5N90B [New specifications] Application accounts adaptation to sandbox applications<br>I5N90O [New specifications] User identity authentication of the IAM account subsystem<br>I5NOQI [New feature] Precise positioning and fuzzy positioning of the permission service<br>I5NT1X [New feature] Enhanced permission usage record management<br>I5NU8U [New feature] Improved UX effect for the permission request dialog box<br>I5P4IU [New feature] Privacy management<br>I5P530 [New feature] Location service usage status management| NA |
 | Globalization subsystem| The pseudo-localization capability is added.<br>The following requirement is involved:<br>I4WLSJ [New feature] Pseudo-localization| NA |
-| Misc services subsystem| The following basic module features are added: pasteboard, upload and download, screen lock, and input method framework.<br>The following requirements are involved:<br>I5JPMG [request] [download] Background task notification<br>I5NXHK [input_method_fwk] Binding of only the innerkits interface of the input method and the JS interface that independently controls the display and hiding of the soft keyboard<br>I5NG2X [theme_screenlock] Screen lock requested by specific system applications<br>I5IU1Z Adding image data to pasteboard data<br>I5OGA3 Cross-device pasteboard switch at the device level<br>I5NMKI [pasteboard] Adding binary data to pasteboard data<br>I5MAMN Limiting the pasteboard data range to within the application<br>I5OX20 [input_method_fwk] Added the API for obtaining the input method| NA |
+| Misc services subsystem| The following basic module features are added: pasteboard, upload and download, screen lock, and input method framework.<br>The following requirements are involved:<br>I5JPMG [request] [download] Background task notification<br>I5NXHK [input_method_fwk] Binding of only the innerkits interface of the input method and the JS interface that independently controls the display and hiding of the soft keyboard<br>I5NG2X [theme_screenlock] Screen lock requested by specific system applications<br>I5IU1Z Adding image data to pasteboard data<br>I5OGA3 Cross-device pasteboard switch at the device level<br>I5NMKI [pasteboard] Adding binary data to pasteboard data<br>I5MAMN Limiting the pasteboard data range to within the application<br>I5OX20 [input_method_fwk] Added the API for obtaining the input method | NA |
 | ArkUI development framework| The following capabilities are enhanced: ArkUI component, resource and media query, DFX, and toolchain. The memory and performance are optimized.<br>The following requirements are involved:<br>I5IZZ7 [ace_engine_standard] Separate **borderRadius** setting for each corner by the **\<panel>** component<br>I5JQ1R [ace_engine_standard] Image copy and paste<br>I5JQ3F [ace_engine_standard] Enhanced text box capabilities<br>I5JQ3J [ace_engine_standard] Event topology of the **\<stack>** component<br>I5JQ54 [ace_engine_standard] Specifying a component to get the focus<br>I5MX7J [ace_engine_standard] Left sliding, right sliding, and rebound effect of the **\<list>** component<br>I5MWS0 [ace_engine_standard] Height notification of the **\<panel>** component<br>I5IZVY [ace_engine_standard] Component refresh upon the keyboard and mouse connection<br>I5JQ5Y [ace_engine_standard] Enhanced focus navigation<br>I5IY7K [New requirement] [ace_engine_standard] Theme capability<br>I5MWTB [ace_engine_standard] vp query for media<br>I5IZU9 [ace_engine_standard] Optimization of the resident memory of ui_service<br>I5JQ26 [ace_engine_standard] Optimized Vsync request mechanism<br>I5JQ2O [ace_engine] Preloading of public resources<br>I5JQ2D [ace_engine_standard] Optimized resampling of move events<br>I5IZXS [toolchain] Display of the plaintext of the developer variable name in the DFX error stack print<br>I5IZYG [toolchain] Display of the plaintext of the developer variable name in the DFX error stack print<br>I5IZX0 [toolchain] Adding the **bundleName** and **moduleName** parameters to **$r** during compilation<br>I5J09I [toolchain] Export of \@Builder| NA |
 
+For details about the API changes, see the following:
 
+[API Differences](api-change/v3.2-beta3/Readme-EN.md)
 
 
 ### Chip and Development Board Adaptation
@@ -186,7 +188,7 @@ For details about the adaptation status, see [SIG-Devboard](https://gitee.com/op
 | -------- | -------- | -------- | -------- |
 | ArkUI development framework| [HealthyDiet](https://gitee.com/openharmony/applications_app_samples/tree/master/ETSUI/HealthyDiet)| This sample app helps you keep food records and view food information. After you add food records, including the food type, weight, and meal time, the app can calculate nutrition data (calories, proteins, fats, and carbon water) for the meals and display the data in a bar chart.| eTS |
 | ArkUI development framework| [MusicAlbum](https://gitee.com/openharmony/applications_app_samples/tree/master/MultiDeviceAppDev/MusicAlbum)| This sample shows the home page of a music album app. The adaptive layout and responsive layout are used to ensure that the app can be properly displayed on devices irrespective of screen sizes.| eTS |
-| Ability framework and file management subsystem| [Share](https://gitee.com/openharmony/applications_app_samples/tree/master/Share/Share)| Using this sample app, you can share texts, links, and images with third-party applications and display them in these applications.| eTS |
+| Ability framework and file management subsystem| [Share](https://gitee.com/openharmony/applications_app_samples/tree/master/Share/CustomShare)| Using this sample app, you can share texts, links, and images with third-party applications and display them in these applications.| eTS |
 | Ability framework| [GalleryForm](https://gitee.com/openharmony/applications_app_samples/tree/master/ability/GalleryForm)| This sample demonstrates the display of **Gallery** images in a widget and periodic update of the widget.| eTS |
 | ArkUI development framework| [AppMarket](https://gitee.com/openharmony/applications_app_samples/tree/master/MultiDeviceAppDev/AppMarket)| This sample shows the home page of an application market, which contains the tab bar, banner, featured apps, and featured games.| eTS |
 | ArkUI development framework| [Weather](https://gitee.com/openharmony/applications_app_samples/tree/master/MultiDeviceAppDev/Weather)| This sample demonstrates one-time development for multi-device deployment by showing how to develop a weather app and deploy it across different devices. The demo app includes the following: home page, **Manage City** page, **Add City** page, and **Update Time** page.| eTS |