!21472 [翻译完成】#I7JHZC

Merge pull request !21472 from Annie_wang/PR20586

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

@@ -16,7 +16,11 @@
   - [Database Backup and Restoration](data-backup-and-restore.md)
   - [Database Encryption](data-encryption.md)
   - [Access Control by Device and Data Level](access-control-by-device-and-data-level.md)
-- Cross-Application Data Sharing (for System Applications Only)
-  - [Cross-Application Data Sharing Overview](share-device-data-across-apps-overview.md)
+- Cross-Application Data Sharing
+  - [Data Sharing Overview](data-share-overview.md)
+  - [Unified Data Definition](unified-data-definition.md)
+  - One-to-Many Data Sharing (Only for System Applications)
   - [Sharing Data Using DataShareExtensionAbility](share-data-by-datashareextensionability.md)
-  - [Sharing Data in Silent Access](share-data-by-silent-access.md)
+  - [Silent Access via the DatamgrService](share-data-by-silent-access.md)
+  - Many-to-Many Data Sharing 
+    - [Sharing Data Using Unified Data Channels](unified-data-channels.md)
\ No newline at end of file

en/application-dev/database/data-mgmt-overview.md

@@ -3,7 +3,7 @@
 
 ## Function
 
-Data management provides data storage, management, and synchronization capabilities. For example, you can store the Contacts application data in database for secure management and shared access, and synchronize the contacts information with a smart watch.
+Data management provides data storage, management, and synchronization capabilities. For example, you can store the Contacts application data in database for secure management and shared access, and synchronize the Contacts information with a smart watch.
 
 - Data storage: provides data persistence capabilities, which can be classified into user preferences, key-value (KV) stores, and relational database (RDB) stores by data characteristics.
 
@@ -16,9 +16,9 @@ The database stores created by an application are saved to the application sandb
 
 ## Working Principles
 
-The data management module includes user preferences (**Preferences**), KV data management (**KV-Store**), RDB data management (**RelationalStore**), distributed data object (**DataObject**), and cross-application data management (**DataShare**). The interface layer provides standard JavaScript APIs for application development. The Frameworks&System service layer implements storage and synchronization of component data, and provides dependencies for SQLite and other subsystems.
+The data management module includes preferences, KV data management (KV-Store), relational data management (RelatoinalStore), distributed data object (DataObject), cross-application data management (DataShare), and unified data management framework (UDMF). The interface layer provides standard JavaScript APIs for application development. The Frameworks&System service layer implements storage and synchronization of component data, and provides dependencies for SQLite and other subsystems.
 
-  **Figure 1** Data management architecture 
+**Figure 1** Data management architecture
 
 ![dataManagement](figures/dataManagement.jpg)
 
@@ -33,4 +33,7 @@ The data management module includes user preferences (**Preferences**), KV data
 
 - **DataShare**: provides the data provider-consumer mode to implement addition, deletion, modification, and query of cross-application data on a device, and notification subscription. **DataShare** is not bound to any database and can interact with RDB and KV stores. You can also encapsulate your own databases for C/C++ applications.<br> In addition to the provider-consumer mode, **DataShare** provides silent access, which allows direct access to the provider's data via the DatamgrService proxy instead of starting the provider. Currently, only the RDB stores support silent access.
 
+- **UDMF**: defines the data language and standards for cross-application and cross-device data interaction, improving data interaction efficiency. The UDMF provides secure and standard data transmission channels and supports different levels of data access permissions and lifecycle management policies. It helps implement efficient data sharing across applications and devices.
+
 - **DatamgrService**: implements synchronization and cross-application sharing for other components, including cross-device synchronization of **RelationalStore** and **KV-Store**, silent access to provider data of **DataShare**, and temporary storage of **DataObject** synchronization object data.
+

en/application-dev/database/data-persistence-by-rdb-store.md

@@ -18,7 +18,7 @@ A relational database (RDB) store is used to store data in complex relational mo
 **RelationalStore** provides APIs for applications to perform data operations. With SQLite as the underlying persistent storage engine, **RelationalStore** provides SQLite database features, including transactions, indexes, views, triggers, foreign keys, parameterized queries, prepared SQL statements, and more.
 
 **Figure 1** Working mechanism
- 
+
 ![relationStore_local](figures/relationStore_local.jpg)
 
 
@@ -37,15 +37,15 @@ A relational database (RDB) store is used to store data in complex relational mo
 
 The following table lists the APIs used for RDB data persistence. Most of the APIs are executed asynchronously, using a callback or promise to return the result. The following table uses the callback-based APIs as an example. For more information about the APIs, see [RDB Store](../reference/apis/js-apis-data-relationalStore.md).
 
-| API| Description| 
+| API| Description|
 | -------- | -------- |
-| getRdbStore(context: Context, config: StoreConfig, callback: AsyncCallback<RdbStore>): void | Obtains a **RdbStore** instance to implement RDB store operations. You can set **RdbStore** parameters based on actual requirements and use **RdbStore** APIs to perform data operations.| 
-| executeSql(sql: string, bindArgs: Array<ValueType>, callback: AsyncCallback<void>):void | Executes an SQL statement that contains specified arguments but returns no value.| 
-| insert(table: string, values: ValuesBucket, callback: AsyncCallback<number>):void | Inserts a row of data into a table.| 
-| update(values: ValuesBucket, predicates: RdbPredicates, callback: AsyncCallback<number>):void | Updates data in the RDB store based on the specified **RdbPredicates** instance.| 
-| delete(predicates: RdbPredicates, callback: AsyncCallback<number>):void | Deletes data from the RDB store based on the specified **RdbPredicates** instance.| 
-| query(predicates: RdbPredicates, columns: Array<string>, callback: AsyncCallback<ResultSet>):void | Queries data in the RDB store based on specified conditions.| 
-| deleteRdbStore(context: Context, name: string, callback: AsyncCallback<void>): void | Deletes an RDB store.| 
+| getRdbStore(context: Context, config: StoreConfig, callback: AsyncCallback<RdbStore>): void | Obtains a **RdbStore** instance to implement RDB store operations. You can set **RdbStore** parameters based on actual requirements and use **RdbStore** APIs to perform data operations.|
+| executeSql(sql: string, bindArgs: Array<ValueType>, callback: AsyncCallback<void>):void | Executes an SQL statement that contains specified arguments but returns no value.|
+| insert(table: string, values: ValuesBucket, callback: AsyncCallback<number>):void | Inserts a row of data into a table.|
+| update(values: ValuesBucket, predicates: RdbPredicates, callback: AsyncCallback<number>):void | Updates data in the RDB store based on the specified **RdbPredicates** instance.|
+| delete(predicates: RdbPredicates, callback: AsyncCallback<number>):void | Deletes data from the RDB store based on the specified **RdbPredicates** instance.|
+| query(predicates: RdbPredicates, columns: Array<string>, callback: AsyncCallback<ResultSet>):void | Queries data in the RDB store based on specified conditions.|
+| deleteRdbStore(context: Context, name: string, callback: AsyncCallback<void>): void | Deletes an RDB store.|
 
 
 ## How to Develop
@@ -53,7 +53,7 @@ The following table lists the APIs used for RDB data persistence. Most of the AP
 1. Obtain an **RdbStore** instance.<br> Example:
 
    Stage model:
-     
+   
    ```js
    import relationalStore from '@ohos.data.relationalStore'; // Import the module.
    import UIAbility from '@ohos.app.ability.UIAbility';
@@ -65,7 +65,7 @@ The following table lists the APIs used for RDB data persistence. Most of the AP
          securityLevel: relationalStore.SecurityLevel.S1 // Database security level.
        };
 
-       // The current RDB store version is 3, and the table structure is EMPLOYEE (NAME, AGE, SALARY, CODES).
+       // The RDB store version is 3, and the table structure is EMPLOYEE (NAME, AGE, SALARY, CODES).
        const SQL_CREATE_TABLE ='CREATE TABLE IF NOT EXISTS EMPLOYEE (ID INTEGER PRIMARY KEY AUTOINCREMENT, NAME TEXT NOT NULL, AGE INTEGER, SALARY REAL, CODES BLOB)'; // SQL statement for creating a data table.
 
        relationalStore.getRdbStore(this.context, STORE_CONFIG, (err, store) => {
@@ -106,7 +106,7 @@ The following table lists the APIs used for RDB data persistence. Most of the AP
 
    FA model:
 
-     
+   
    ```js
    import relationalStore from '@ohos.data.relationalStore'; // Import the module.
    import featureAbility from '@ohos.ability.featureAbility';
@@ -160,10 +160,12 @@ The following table lists the APIs used for RDB data persistence. Most of the AP
    >
    > - The RDB store created by an application varies with the context. Multiple RDB stores are created for the same database name with different application contexts. For example, each UIAbility has its own context.
    > 
-   > - When an application calls **getRdbStore()** to obtain an RDB store instance for the first time, the corresponding database file is generated in the application sandbox. If you want to move the files of an RDB store to another place for view, you must also move the temporary files with finename extensions **-wal** or **-shm** in the same directory. Once an application is uninstalled, the database files and temporary files generated by the application on the device are also removed.
+   > - When an application calls **getRdbStore()** to obtain an RDB store instance for the first time, the corresponding database file is generated in the application sandbox. When the RDB store is used, temporary files ended with **-wal** and **-shm** may be generated in the same directory as the database file. If you want to move the database files to other places, you must also move these temporary files. After the application is uninstalled, the database files and temporary files generated on the device are also removed.
 
-2. Use **insert()** to insert data to the RDB store. Example:
-     
+2. Use **insert()** to insert data to the RDB store. 
+   
+   Example:
+   
    ```js
    const valueBucket = {
      'NAME': 'Lisa',
@@ -177,13 +179,13 @@ The following table lists the APIs used for RDB data persistence. Most of the AP
        return;
      }
      console.info(`Succeeded in inserting data. rowId:${rowId}`);
-   })
+})
    ```
-
+   
    > **NOTE**
-   >
+>
    > **RelationalStore** does not provide explicit flush operations for data persistence. Data inserted by **insert()** is stored in files persistently.
-
+   
 3. Modify or delete data based on the specified **Predicates** instance.
 
    Use **update()** to modify data and **delete()** to delete data. 
@@ -254,13 +256,15 @@ The following table lists the APIs used for RDB data persistence. Most of the AP
 
 5. Delete the RDB store.
 
-   Use **deleteRdbStore()** to delete the RDB store and related database files. 
+   Use **deleteRdbStore()** to delete the RDB store and related database files.
 
-   Example:
+   > **NOTE**
+   >
+   > After the deletion, you are advised to set the database object to null.
 
    Stage model:
 
-     
+
    ```js
    import UIAbility from '@ohos.app.ability.UIAbility';
    
@@ -271,6 +275,7 @@ The following table lists the APIs used for RDB data persistence. Most of the AP
            console.error(`Failed to delete RdbStore. Code:${err.code}, message:${err.message}`);
            return;
          }
+         store = null;
          console.info('Succeeded in deleting RdbStore.');
        });
      }
@@ -279,7 +284,7 @@ The following table lists the APIs used for RDB data persistence. Most of the AP
 
    FA model:
 
-     
+
    ```js
    import featureAbility from '@ohos.ability.featureAbility';
    
@@ -291,6 +296,7 @@ The following table lists the APIs used for RDB data persistence. Most of the AP
        console.error(`Failed to delete RdbStore. Code:${err.code}, message:${err.message}`);
        return;
      }
+     store = null;
      console.info('Succeeded in deleting RdbStore.');
    });
    ```

en/application-dev/database/data-share-overview.md

+# Cross-Application Data Sharing
+
+## Introduction
+
+OpenHarmony provides APIs for an application to manage its own data and share data with other applications.
+
+Data needs to be shared in a wealth of scenarios. For example, the Contacts, short message service (SMS), and Gallery data always needs to be shared with other applications. However, certain data, such as accounts and passwords, cannot be shared. Some data, such as SMS messages, can be queried but not modified by other applications. Therefore, a secure and efficient cross-application data sharing mechanism for different data sharing scenarios and data privacy protection is very important.
+
+Currently, OpenHarmony supports one-to-many and many-to-many cross-application data sharing, based on the number of the data provider applications involved.
+
+## Basic Concepts
+
+Before you start, understand the following concepts:
+
+- **Data provider**: an application that provides data and implements related services. It is also called the producer or server.
+
+- **Data consumer**: an application that accesses the data or services provided by the data provider. It is also called the client.
+
+- **ValuesBucket**: a set of data to be inserted. It can be one or more data records in key-value (KV) pairs. In each KV pair, the key must be of the string type, and the value can be a number, a string, a Boolean value, or an unsigned integer array.
+
+- **ResultSet**: a set of query results. It provides flexible modes for users to obtain various data.
+
+- **Predicates**: an object that specifies the conditions for updating, deleting, or querying data in a database.
+
+## Unified Data Definition
+
+When data needs to be shared among multiple applications, a large amount of data needs to be converted for data interaction because the data definition and format vary with applications. To reduce application/service data interaction costs, OpenHarmony uses the unified data definition as the unified data language to build cross-application data interaction standards.
+
+The unified data definition defines common data types. Applications can use the APIs provided by the Unified Data Management Framework (UDMF) to create and use these data types. For details, see [Unified Data Definition](unified-data-definition.md).
+
+## One-to-Many Cross-Application Data Sharing
+
+You can use **DataShare** to implement one-to-many data sharing across applications. Two implementation modes are provided, depending on whether the data provider is started in the cross-application data sharing.
+
+### Implementation
+
+The data provider can directly use **DataShare** to share data with other applications without complex encapsulation. The data consumer only needs to use a set of APIs because the **DataShare** access mode does not vary with the data provision mode. This greatly reduces the learning time and development difficulty.
+
+**DataShare** implements cross-application data sharing in either of the following ways:
+
+- [Using DataShareExtensionAbility](share-data-by-datashareextensionability.md)
+
+  You need to implement an ExtensionAbility with callbacks in the HAP. When the data consumer calls an API, the ExtensionAbility of the data provider will be automatically started to invoke the registered callback.
+
+  You can use **DataShareExtensionAbility** when the cross-application data access involves service operations other than mere addition, deletion, modification, and query of data in databases.
+
+- [Using Silent Access via the DatamgrService](share-data-by-silent-access.md)
+
+  You need to configure database access rules in the HAP. When the data consumer calls an API, the system ability automatically obtains the access rules in the HAP and returns data without starting the data provider.
+
+  You can use this mode when the cross-application data access involves only database operations (data addition, deletion, modification, and query) or data hosted to the DatamgrService.
+  
+If your application is signed with a system signature, you can use both methods. When data is created for the first time, use **DataShareExtensionAbility**. When data is accessed and modified later, use the **DatamgrService** to share data. That is, the data provider is started only when the data is accessed for the first time.
+
+### Restrictions
+
+- **DataShare** is subject to the limitations on the database used by the data provider. For example, the supported data models, length of the keys and values, and maximum number of databases that can be accessed at a time by each application vary with the database in use.
+
+- The payloads of **ValuesBucket**, **Predicates**, and **ResultSet** are restricted by IPC.
+
+- Currently, **dataShare** supports development based on the stage model only.
+
+## Many-to-Many Cross-Application Data Sharing
+
+In one-to-many cross-application data sharing, there is only one data provider. In many-to-many cross-application data sharing, you need to consider data definition, data exchange, and permission management. The UDMF provides a new data sharing and interaction mode to implement many-to-many cross-application data sharing.
+
+### Implementation
+
+[Sharing Data via Unified Data Channels](unified-data-channels.md)
+
+Applications can call the APIs provided by the UDMF to write data that complies with the unified data definition to different data sharing channels of the UDMF. The data in these channels can be read by other applications. The data written into the UDMF is managed based on the permissions of the application, permissions of the data channels, and the permission management logic of the UDMF. Lifecycle management is also performed on the data written into the channels in the same way. In this way, the data scattered in each application is aggregated via different channels of the UDMF, improving the development efficiency and data experience of users.

en/application-dev/database/share-data-by-datashareextensionability.md

@@ -16,8 +16,7 @@ There are two roles in **DataShare**:
 
 - Data consumer: accesses the data provided by the provider using [createDataShareHelper()](../reference/apis/js-apis-data-dataShare.md#datasharecreatedatasharehelper).
 
-**Figure 1** Data sharing mechanism
- 
+**Figure 1** Data sharing mechanism 
 ![dataShare](figures/dataShare.jpg)
 
 - The **DataShareExtensionAbility** module, as the data provider, implements services related to data sharing between applications.
@@ -32,7 +31,7 @@ There are two roles in **DataShare**:
 ## How to Develop
 
 
-### Data Provider Application Development (Only for System Applications)
+### Data Provider Application (Only for System Applications)
 
 [DataShareExtensionAbility](../reference/apis/js-apis-application-dataShareExtensionAbility.md) provides the following APIs. You can override these APIs as required.
 
@@ -146,7 +145,7 @@ override the service implementation as required. For example, if the data provid
        "icon": "$media:icon",
        "description": "$string:description_datashareextability",
        "type": "dataShare",
-       "uri": "datashare://com.samples.datasharetest.DataShare",
+       "uri": "datashareproxy://com.samples.datasharetest.DataShare",
        "exported": true,
        "metadata": [{"name": "ohos.extension.dataShare", "resource": "$profile:data_share_config"}]
      }
@@ -155,11 +154,11 @@ override the service implementation as required. For example, if the data provid
    
    **Table 2** Fields in the data_share_config.json file
 
-   | Field| Description                                                    | Mandatory|
-   | ------------ | ------------------------------------------------------------ | --- |
-   | tableConfig       | Label configuration.| Yes|
-   | uri               | Range for which the configuration takes effect. The URI supports the following formats in descending order by priority:<br> 1. *****: indicates all databases and tables.<br> 2. **datashare:///{*bundleName*}/{*moduleName*}/{*storeName*}**: specifies a database.<br> 3. **datashare:///{*bundleName*}/{*moduleName*}/{*storeName*}/{*tableName*}**: specifies a table.<br>If URIs of different formats are configured, only the URI with higher priority takes effect.  | Yes|
-   | crossUserMode     | Whether data is shared by multiple users. The value **1** means to share data between multiple users, and the value **2** means the opposite.               | Yes|
+   | Field         | Description                                    | Mandatory  |
+   | ------------- | ---------------------------------------- | ---- |
+   | tableConfig   | Label configuration.                                   | Yes   |
+   | uri           | Range for which the configuration takes effect. The URI supports the following formats in descending order by priority:<br> - *****: indicates all databases and tables.<br> - **datashareproxy://{bundleName}/{moduleName}/{storeName}**: specifies a database.<br>- **datashareproxy://{bundleName}/{moduleName}/{storeName}/{tableName}**: specifies a table. | Yes   |
+   | crossUserMode | Whether data is shared by multiple users.<br>The value **1** means to share data between multiple users, and the value **2** means the opposite. | Yes   |
 
    **data_share_config.json Example**
 
@@ -170,18 +169,18 @@ override the service implementation as required. For example, if the data provid
       "crossUserMode": 1
     },
     {
-      "uri": "datashare:///com.acts.datasharetest/entry/DB00",
+      "uri": "datashareproxy://com.acts.datasharetest/entry/DB00",
       "crossUserMode": 1
     },
     {
-      "uri": "datashare:///com.acts.datasharetest/entry/DB00/TBL00",
+      "uri": "datashareproxy://com.acts.datasharetest/entry/DB00/TBL00",
       "crossUserMode": 2
     }
    ]
    ```
 
 
-### Data Consumer Application Development
+### Data Consumer Application
 
 1. Import the dependencies.
    
@@ -195,7 +194,7 @@ override the service implementation as required. For example, if the data provid
    
    ```js
    // Different from the URI defined in the module.json5 file, the URI passed in the parameter has an extra slash (/), because there is a DeviceID parameter between the second and the third slash (/).
-   let dseUri = ('datashare:///com.samples.datasharetest.DataShare');
+   let dseUri = ('datashareproxy://com.samples.datasharetest.DataShare');
    ```
 
 3. Create a **DataShareHelper** instance.
@@ -239,3 +238,4 @@ override the service implementation as required. For example, if the data provid
      console.info(`dsHelper delete result:${data}`);
    });
    ```
+

en/application-dev/database/share-data-by-silent-access.md

-# Data Sharing Through Silent Access
+# Silent Access via the DatamgrService
 
 
 ## When to Use
 
-In a typical cross-application data access scenario, an application may be started multiple times.
+In a typical cross-application data access scenario, the data provider may be started multiple times.
 
-To reduce the number of application startup times and improve the access speed, OpenHarmony provides the silent access feature, which allows direct access to the database without starting the data provider.
+To reduce the number of startup times of the data provider and improve the access speed, OpenHarmony provides the silent access feature, which allows access to the database without starting the data provider.
 
-Silent access supports only basic database access. If service processing is required, implement service processing in the data consumer.
+In silent data access, the DatamgrService accesses and modifies data without starting the data provider.
 
-If the service processing is complex, use **DataShareExtensionAbility** to start the data provider.
+The DatamgrService supports basic database access or data hosting only. If service processing is required, the service processing needs to be encapsulated into APIs for the data consumer to call.
+
+If the service processing is too complex to be processed by the data consumer, use **DataShareExtensionAbility** to start the data provider.
 
 
 ## Working Principles
 
+The DatamgrService can serve as a proxy to access the following types of data:
+
+- Persistent data
+
+  Persistent data belongs to the database of the data provider. It is stored in the sandbox of the data provider and can be shared in declaration mode by the data provider. Persistent data is configured as data tables for access.
+
+
+- Process data 
+
+  The process data managed by the **DatamgrService** is stored in the DatamgrService sandbox in JSON or byte format. This type of data is automatically deleted 10 days after no subscription.
+
+
+| Type | Storage Location     | Data Format       | Validity Period         | Application Scenario                             |
+| ----- | --------- | ----------- | ------------ | --------------------------------- |
+| Persistent data| Sandbox of the data provider | Tables in the database   | Permanent storage        | RDB data applications, such as schedules and conferences.     |
+| Process data | DatamgrService sandbox| JSON or byte| Automatically deleted 10 days after no subscription| Applications featuring simple and time-sensitive data, such as step count, weather, and heart rate.|
+
+
+
 **Figure 1** Silent access
 
 ![silent_dataShare](figures/silent_dataShare.jpg)
@@ -21,26 +42,271 @@ If the service processing is complex, use **DataShareExtensionAbility** to start
 - In silent access, **DatamgrService** obtains the access rules configured by the data provider through directory mapping, performs preprocessing based on rules, and accesses the database.
 
 - To use silent access, the URIs must be in the following format:
-  datashare:///{bundleName}/{moduleName}/{storeName}/{tableName}?Proxy=true
+  
+datashareproxy://{bundleName}/{dataPath}
+  
+The **DatamgrService** obtains the data provider application based on **bundleName**, reads the configuration, verifies the permission, and accesses data.
+  
+  **dataPath** identifies the data. It can be customized and must be unique in the same data provider application.
+
 
-  "Proxy=true" means to access data without starting the data provider. If **Proxy** is not set to **true**, the data provider is started.
+## Constraints
 
-  The **DatamgrService** obtains the data provider application based on **bundleName**, reads the configuration, verifies the permission, and accesses data.
+- Currently, only the RDB stores support silent data access.
+- The system supports a maximum of 16 concurrent query operations. Excess query requests need to be queued for processing.
+- The proxy is not allowed to create a database for persistent data. To create a database, you must start the data provider.
+- If the data provider is an application with a normal signature, the data read/write permission must be system_basic or higher.
 
 
-## Constraints
+## Available APIs
 
-- Currently, only RDB stores support silent access.
+The following table lists the APIs for silent data access. Most of the APIs are executed asynchronously in callback or promise mode. In the following table, callback-based APIs are used as an example. For more information about the APIs, see [Data Sharing](../reference/apis/js-apis-data-dataShare.md).
 
-- The system supports a maximum of 16 concurrent query operations. Excess query requests need to be queued for processing.
+### Common API
+
+| API                                    | Description                  |
+| ---------------------------------------- | -------------------- |
+| createDataShareHelper(context: Context, uri: string, options: DataShareHelperOptions, callback: AsyncCallback<DataShareHelper>): void | Creates a **DataShareHelper** instance.|
+
+### APIs for Persistent Data
+
+| API                                    | Description                  |
+| ---------------------------------------- | -------------------- |
+| insert(uri: string, value: ValuesBucket, callback: AsyncCallback<number>): void | Inserts a row of data into a table.        |
+| delete(uri: string, predicates: dataSharePredicates.DataSharePredicates, callback: AsyncCallback<number>): void | Deletes one or more data records from the database.   |
+| query(uri: string, predicates: dataSharePredicates.DataSharePredicates, columns: Array<string>, callback: AsyncCallback<DataShareResultSet>): void | Queries data in the database.          |
+| update(uri: string, predicates: dataSharePredicates.DataSharePredicates, value: ValuesBucket, callback: AsyncCallback<number>): void | Updates data in the database.        |
+| addTemplate(uri: string, subscriberId: string, template: Template): void | Adds a data template with the specified subscriber.     |
+| on(type: 'rdbDataChange', uris: Array<string>, templateId: TemplateId, callback: AsyncCallback<RdbDataChangeNode>): Array<OperationResult | Subscribes to the changes of the data corresponding to the specified URI and template.|
+
+### APIs for Process Data
+
+| API                                    | Description                |
+| ---------------------------------------- | ------------------ |
+| publish(data: Array<PublishedItem>, bundleName: string, version: number, callback: AsyncCallback<Array<OperationResult>>): void | Publish data to the **DatamgrService**.|
+| on(type: 'publishedDataChange', uris: Array<string>, subscriberId: string, callback: AsyncCallback<PublishedDataChangeNode>): Array<OperationResult> | Subscribes to changes of the published data.   |
+
+
+
+## Implementation of the Persistence Data
+
+The following describes how to share an RDB store.
+
+### Data Provider Application
+
+1. In the **module.json5** file, set the ID, read/write permissions, and basic information of the table to be shared under **proxyDatas**.
+
+   **Table 1** Fields of proxyDatas in module.json5
+
+   | Field                   | Description                                    | Mandatory  |
+   | ----------------------- | ---------------------------------------- | ---- |
+   | uri                     | URI of the data, which is the unique identifier for cross-application data access.                 | Yes   |
+   | requiredReadPermission  | Permission required for reading data from the data proxy. If this parameter is not set, other applications are not allowed to access data. For details about the supported permissions, see [Application Permission List](../security/permission-list.md).           | No   |
+   | requiredWritePermission | Permission required for modifying data from the data proxy. If this parameter is not set, other applications are not allowed to modify the data. For details about the supported permissions, see [Application Permission List](../security/permission-list.md).         | No   |
+   | metadata                | Data source information, including the **name** and **resource** fields.<br> The **name** field identifies the configuration, which has a fixed value of **dataProperties**.<br> The value of **resource** is **$profile:{fileName}**, indicating that the name of the configuration file is **{fileName}.json**.| Yes   |
+
+   **module.json5 example**
+
+   ```json
+   "proxyDatas":[
+     {
+       "uri": "datashareproxy://com.acts.ohos.data.datasharetest/test",
+       "requiredReadPermission": "ohos.permission.GET_BUNDLE_INFO",
+       "requiredWritePermission": "ohos.permission.KEEP_BACKGROUND_RUNNING",
+       "metadata": {
+         "name": "dataProperties",
+         "resource": "$profile:my_config"
+       }
+     }
+   ]
+   ```
+   **Table 2** Fields in my_config.json
+
+   | Field | Description                                    | Mandatory  |
+   | ----- | ---------------------------------------- | ---- |
+   | path  | Data source path, in the **Database_name/Table_name** format. Currently, only RDB stores are supported.             | Yes   |
+   | type  | Database type. Currently, only **rdb** is supported.            | Yes   |
+   | scope | Scope of the database.<br>- **module** indicates that the database is located in this module.<br>- **application** indicates that the database is located in this application.| No   |
+
+   **my_config.json example**
+
+   ```json
+   {
+     "path": "DB00/TBL00",
+     "type": "rdb",
+     "scope": "application"
+   }
+   ```
+
+### Data Consumer Application
+
+
+1. Import dependencies.
+
+   ```js
+   import dataShare from '@ohos.data.dataShare';
+   import dataSharePredicates from '@ohos.data.dataSharePredicates';
+   ```
+
+2. Define the URI string for communicating with the data provider.
+
+   ```js
+   let dseUri = ('datashareproxy://com.acts.ohos.data.datasharetest/test');
+   ```
+
+3. Create a **DataShareHelper** instance.
+
+   ```js
+   let dsHelper;
+   let abilityContext;
+
+   export default class EntryAbility extends UIAbility {
+     onWindowStageCreate(windowStage) {
+       abilityContext = this.context;
+       dataShare.createDataShareHelper(abilityContext, "", {
+         isProxy: true
+       }, (err, data) => {
+         dsHelper = data;
+       });
+     }
+   }
+   ```
+
+4. Use the APIs provided by **DataShareHelper** to access the services provided by the provider, for example, adding, deleting, modifying, and querying data.
+
+   ```js
+   // Construct a piece of data.
+   let valuesBucket = {
+     'name': 'ZhangSan', 'age': 21, 'isStudent': false, 'Binary': new Uint8Array([1, 2, 3])
+   };
+   let updateBucket = {
+     'name': 'LiSi', 'age': 18, 'isStudent': true, 'Binary': new Uint8Array([1, 2, 3])
+   };
+   let predicates = new dataSharePredicates.DataSharePredicates();
+   let valArray = ['*'];
+   // Insert a piece of data.
+   dsHelper.insert(dseUri, valuesBucket, (err, data) => {
+     console.info(`dsHelper insert result:${data}`);
+   });
+   // Update data.
+   dsHelper.update(dseUri, predicates, updateBucket, (err, data) => {
+     console.info(`dsHelper update result:${data}`);
+   });
+   // Query data.
+   dsHelper.query(dseUri, predicates, valArray, (err, data) => {
+     console.info(`dsHelper query result:${data}`);
+   });
+   // Delete data.
+   dsHelper.delete(dseUri, predicates, (err, data) => {
+     console.info(`dsHelper delete result:${data}`);
+   });
+   ```
+
+5. Subscribe to the specified data.
+
+   ```js
+   function onCallback(err, node: dataShare.RdbDataChangeNode) {
+       console.info("uri " + JSON.stringify(node.uri));
+       console.info("templateId " + JSON.stringify(node.templateId));
+       console.info("data length " + node.data.length);
+       for (let i = 0; i < node.data.length; i++) {
+           console.info("data " + node.data[i]);
+       }
+   }
+
+   let template = {
+       predicates: {
+           "p1": "select * from TBL00",
+           "p2": "select name from TBL00",
+       },
+       scheduler: ""
+   }
+   dsProxyHelper.addTemplate(dseUri, "111", template);
+   let templateId: dataShare.TemplateId = {
+       subscriberId: "111",
+       bundleNameOfOwner: "com.acts.ohos.data.datasharetestclient"
+   }
+   // When the DatamgrService modifies data, onCallback is invoked to return the data queried based on the rules in the template.
+   let result: Array<dataShare.OperationResult> = dsProxyHelper.on("rdbDataChange", [dseUri], templateId, onCallback);
+   ```
+
+## Implementation of the Process Data
+
+The following describes how to host process data.
+
+### (Optional) Data Provider Application
+
+In the **module.json5** file of the data provider, set the process data ID, read/write permissions, and basic information under **proxyDatas**.
+
+> **NOTE**
+>
+> - This step is optional.
+> - If **proxyDatas** is not configured, the hosted data cannot be accessed by other applications.
+> - If **proxyDatas** is not configured, you do not need to use the full data path. For example, you can use **weather** instead of **datashareproxy://com.acts.ohos.data.datasharetest/weather** when publishing, subscribing to, and querying data.
+
+**Table 3** Fields of proxyDatas in module.json5
+
+| Field                   | Description                         | Mandatory  |
+| ----------------------- | ----------------------------- | ---- |
+| uri                     | URI of the data, which is the unique identifier for cross-application data access.      | Yes   |
+| requiredReadPermission  | Permission required for reading data from the data proxy. If this parameter is not set, other applications are not allowed to access data. For details about the supported permissions, see [Application Permission List](../security/permission-list.md).| No   |
+| requiredWritePermission | Permission required for modifying data from the data proxy. If this parameter is not set, other applications are not allowed to access data. For details about the supported permissions, see [Application Permission List](../security/permission-list.md).| No   |
+
+**module.json5 example**
+
+```json
+"proxyDatas": [
+  {
+    "uri": "datashareproxy://com.acts.ohos.data.datasharetest/weather",
+    "requiredReadPermission": "ohos.permission.GET_BUNDLE_INFO",
+    "requiredWritePermission": "ohos.permission.KEEP_BACKGROUND_RUNNING"
+  }
+]
+```
+
+### Data Consumer Application
+
+1. Import dependencies.
+
+   ```js
+   import dataShare from '@ohos.data.dataShare';
+   ```
+
+2. Create a **DataShareHelper** instance.
+
+   ```js
+   let dsHelper;
+   let abilityContext;
 
-- A proxy cannot be used to create a database. If a database needs to be created, the data provider must be started.
+   export default class EntryAbility extends UIAbility {
+     onWindowStageCreate(windowStage) {
+       abilityContext = this.context;
+       dataShare.createDataShareHelper(abilityContext, "", {isProxy : true}, (err, data) => {
+         dsHelper = data;
+       });
+     }
+   }
+   ```
 
+3. Use the APIs provided by **DataShareHelper** to access the services provided by the provider, for example, adding, deleting, modifying, and querying data.
 
-## How to Develop
+   ```js
+   // Construct two pieces of data. The first data is not configured with proxyDatas and cannot be accessed by other applications.
+   let data : Array<dataShare.PublishedItem> = [
+     {key:"city", subscriberId:"11", data:"xian"},
+     {key:"datashareproxy://com.acts.ohos.data.datasharetest/weather", subscriberId:"11", data:JSON.stringify("Qing")}];
+   // Publish data.
+    let result: Array<dataShare.OperationResult> = await dsProxyHelper.publish(data, "com.acts.ohos.data.datasharetestclient");
+   ```
 
-The URI must be in the following format:
+4. Subscribe to the specified data.
 
-datashare:///{bundleName}/{moduleName}/{storeName}/{tableName}?Proxy=true
+   ```js
+   function onPublishCallback(err, node:dataShare.PublishedDataChangeNode) {
+       console.info("onPublishCallback");
+   }
+   let uris:Array<string> = ["city", "datashareproxy://com.acts.ohos.data.datasharetest/weather"];
+   let result: Array<dataShare.OperationResult> = dsProxyHelper.on("publishedDataChange", uris, "11", onPublishCallback);
+   ```
 
-For details about the development procedure and implementation, see [Sharing Data Using DataShareExtensionAbility](share-data-by-datashareextensionability.md).
+   

en/application-dev/database/sync-app-data-across-devices-overview.md

@@ -7,7 +7,7 @@ The distributed application data synchronization allows the data of an applicati
 
 For example, when data is added, deleted, or modified for an application on a device, the same application on another device can obtain the updated data. You can use this feature in the distributed Gallery, Notepad, Contacts, and File Manager. 
 
-For details about how to subscribe to database change notifications between different applications, see [Sharing Application Data with Other Applications](share-device-data-across-apps-overview.md).
+For details about how to subscribe to database change notifications between different applications, see [Cross-Application Data Sharing](data-share-overview.md).
 
 The data storage modes vary depending on the lifecycle of data to be synchronized:
 
@@ -24,7 +24,7 @@ In a distributed scenario, cross-device collaboration demands consistent data be
 The data consistency can be classified into the following types:
 
 
-- Strong consistency: When data is inserted, deleted, or modified on a device, other devices in the same network can obtain the updates eventually, but may not immediately.
+- Strong consistency: When data is inserted, deleted, or modified on a device, other devices in the same network will obtain the latest data immediately. Once data is modified, the devices can read the updated data eventually, but may not read the updated data immediately.
 
 - Weak consistency: When data is added, deleted, or modified on a device, other devices in the same network may or may not obtain the updates. The data on these devices may be inconsistent after a certain period of time.
 

en/application-dev/database/unified-data-channels.md

+# Sharing Data via Unified Data Channels
+
+
+## When to Use
+
+In many-to-many data sharing across applications, a data channel needs to be provided to access data of different applications and share the data with other applications.
+
+The Unified Data Management Framework (UDMF) provides unified data channels and standard data access interfaces for different service scenarios of many-to-many cross-application data sharing.
+
+## Definition and Implementation of Unified Data Channels
+
+The unified data channel provides cross-application data access for various service scenarios. It can temporarily store the unified data objects to be shared by an application, and manage the access permissions and lifecycle of the data according to certain policies.
+
+The unified data channel is implemented by the system ability provided by the UDMF. When an application (data provider) needs to share data, it calls the **insert()** method provided by the UDMF to write the data to the UDMF data channel, and calls UDMF **update()** or **delete()** to update or delete the data. After passing the permission verification, the target application (data consumer) calls the UDMF **read()** to access the data. After the data is read, the UDMF performs lifecycle management of the data.
+
+The unified data object (**UnifiedData**) is uniquely identified by a URI in the UDMF data channel. The URI is in the **udmf://*intention*/*bundleName*/*groupId*** format, where:
+
++ **udmf**: protocol used to provide the data channel.
+
++ *intention*: an enum of the data channel types supported by the UDMF.
+
++ *bundleName*: bundle name of the data source application.
+
++ *groupId*: group ID used for batch data management.
+
+Currently, the UDMF provides the public data channel for cross-application data sharing.
+
+**Public data channel**: allows applications to write and read data. The corresponding **intention** is **DATA_HUB**.
+
+## Available APIs
+
+The following table lists the UDMF APIs. All of them are executed asynchronously in callback or promise mode. In the following table, callback-based APIs are used as an example. For more information about the APIs, see [UDMF](../reference/apis/js-apis-data-udmf.md).
+
+| API                                                                                   | Description                                         | 
+|-----------------------------------------------------------------------------------------|---------------------------------------------|
+| insertData(options: Options, data: UnifiedData, callback: AsyncCallback\<string>): void | Inserts data to the UDMF public data channel. A unique data identifier is returned.| 
+| updateData(options: Options, data: UnifiedData, callback: AsyncCallback\<void>): void   | Updates the data in the UDMF public data channel.          | 
+| queryData(options: Options, callback: AsyncCallback\<Array\<UnifiedData>>): void        | Queries data in the UDMF public data channel.              | 
+| deleteData(options: Options, callback: AsyncCallback\<Array\<UnifiedData>>): void       | Deletes data from the UDMF public data channel. The deleted data set is returned.|
+
+
+## How to Develop
+
+The following example describes how to implement many-to-many data sharing. The data provider writes data to the UMDF public data channel, and updates and deletes the data. The data consumer obtains the data shared by the data provider.
+
+### Data Provider
+
+1. Import the **@ohos.data.UDMF** module.
+
+   ```ts
+   import UDMF from '@ohos.data.UDMF';
+   ```
+2. Create a **UnifiedData** object and insert it into the UDMF public data channel.
+
+   ```ts
+   let plainText = new UDMF.PlainText();
+   plainText.textContent = 'hello world!';
+   let unifiedData = new UDMF.UnifiedData(plainText);
+   
+   // Specify the type of the data channel to which the data is to be inserted.
+   let options = {
+       intention: UDMF.Intention.DATA_HUB
+   }
+   try {
+       UDMF.insertData(options, unifiedData, (err, data) => {
+           if (err === undefined) {
+               console.info(`Succeeded in inserting data. key = ${data}`);
+           } else {
+               console.error(`Failed to insert data. code is ${err.code},message is ${err.message} `);
+           }
+       });
+   } catch(e) {
+       console.error(`Insert data throws an exception. code is ${e.code},message is ${e.message} `);
+   }
+   ```
+3. Update the **UnifiedData** object inserted.
+
+   ```ts
+   let plainText = new UDMF.PlainText();
+   plainText.textContent = 'How are you!';
+   let unifiedData = new UDMF.UnifiedData(plainText);
+   
+   // Specify the URI of the UnifiedData object to update.
+   let options = {
+       key: 'udmf://DataHub/com.ohos.test/0123456789'
+   };
+   
+   try {
+       UDMF.updateData(options, unifiedData, (err) => {
+           if (err === undefined) {
+               console.info('Succeeded in updating data.');
+           } else {
+               console.error(`Failed to update data. code is ${err.code},message is ${err.message} `);
+           }
+       });
+   } catch(e) {
+       console.error(`Update data throws an exception. code is ${e.code},message is ${e.message} `);
+   }
+   ```
+4. Delete the **UnifiedData** object from the UDMF public data channel.
+
+   ```ts
+   // Specify the type of the data channel whose data is to be deleted.
+   let options = {
+    intention: UDMF.Intention.DATA_HUB
+   };
+   
+   try {
+       UDMF.deleteData(options, (err, data) => {
+           if (err === undefined) {
+               console.info(`Succeeded in deleting data. size = ${data.length}`);
+               for (let i = 0; i < data.length; i++) {
+                   let records = data[i].getRecords();
+                   for (let j = 0; j < records.length; j++) {
+                       if (records[j].getType() === UDMF.UnifiedDataType.PLAIN_TEXT) {
+                           let text = <UDMF.PlainText>(records[j]);
+                           console.info(`${i + 1}.${text.textContent}`);
+                       }
+                   }
+               }
+           } else {
+               console.error(`Failed to delete data. code is ${err.code},message is ${err.message} `);
+           }
+       });
+   } catch(e) {
+       console.error(`Delete data throws an exception. code is ${e.code},message is ${e.message} `);
+   }
+   ```
+   
+### Data Consumer
+
+1. Import the **@ohos.data.UDMF** module.
+
+   ```ts
+   import UDMF from '@ohos.data.UDMF';
+   ```
+2. Query the **UnifiedData** object in the UDMF public data channel.
+
+   ```ts
+   // Specify the type of the data channel whose data is to be queried.
+   let options = {
+    intention: UDMF.Intention.DATA_HUB
+   };
+   
+   try {
+       UDMF.queryData(options, (err, data) => {
+           if (err === undefined) {
+               console.info(`Succeeded in querying data. size = ${data.length}`);
+               for (let i = 0; i < data.length; i++) {
+                   let records = data[i].getRecords();
+                   for (let j = 0; j < records.length; j++) {
+                       if (records[j].getType() === UDMF.UnifiedDataType.PLAIN_TEXT) {
+                           let text = <UDMF.PlainText>(records[j]);
+                           console.info(`${i + 1}.${text.textContent}`);
+                       }
+                   }
+               }
+           } else {
+               console.error(`Failed to query data. code is ${err.code},message is ${err.message} `);
+           }
+       });
+   } catch(e) {
+       console.error(`Query data throws an exception. code is ${e.code},message is ${e.message} `);
+   }
+   ```

en/application-dev/database/unified-data-definition.md

+# Unified Data Definition
+
+
+## When to Use
+
+To streamline cross-application data interaction of OpenHarmony and minimize the application/service data interaction costs, the Unified Data Management Framework (UDMF) provides standard data definitions to define common data types. Applications can use the APIs provided by the UDMF to create and use these data types.
+
+
+## Unified Data Types
+
+The UDMF provides the following unified data types:
+
+**Basic data types**<br>Basic data types include File and Text, which can be used for cross-application and cross-platform data interaction. Figure 1 and Figure 2 illustrate the basic data types.
+
+**Figure 1** UDMF File
+
+![UDMF_FILE](figures/udmf_type_File.png)
+
+Figure 2 UDMF Text
+
+![UDMF_TEXT](figures/udmf_type_Text.png)
+
+**System Defined Types (SDTs)**<br>The SDTs are specific to the platform or operating system, such as Form (UI card information), AppItem (app description information), and PixelMap (thumbnail). This type of data can be used for cross-application data interaction in a system or platform. Figure 3 illustrates the SDT data.
+
+**Figure 3** UDMF SDT data
+
+![UDMF_SDT](figures/udmf_type_SDT.png)
+
+**App Defined Type (ADT)**<br>The SDT data is application-specific. This type of data can be used for across-platform data interaction for an application. As shown in Figure 4, the MyFile file format can be defined for use in an application ecosystem.
+
+**Figure 4** UDMF ADT data
+
+![UDMF_ADT](figures/udmf_type_ADT.png)
+
+## Restrictions
+
+- The size of each data record in the UDMF cannot exceed 2 MB.
+- The UDMF supports data group management. The size of each group cannot exceed 4 MB.
+
+## Available APIs
+
+The UDMF provides the unified data object **UnifiedData** to encapsulate a group of data records **UnifiedRecord**. **UnifiedRecord** is an abstract definition of data content supported by the UDMF, for example, a text record or an image record. The data content type in a data record corresponds to **UnifiedDataType**.
+
+The following table describes common UDMF APIs. For more information, see [UDMF](../reference/apis/js-apis-data-udmf.md).
+
+| Class          | API          | Description                                                                                           | 
+|---------------|-------------------|-----------------------------------------------------------------------------------------------|
+| UnifiedRecord | getType(): string                      | Obtains the data type of this data record.|
+| UnifiedData   | constructor(record: UnifiedRecord)     | A constructor used to create a **UnifiedData** object with a data record.                                                    |
+| UnifiedData   | addRecord(record: UnifiedRecord): void | Adds a data record to this **UnifiedRecord** object.                                                     |
+| UnifiedData   | getRecords(): Array\<UnifiedRecord> | Obtains all data records from this **UnifiedData** object. The data obtained is of the **UnifiedRecord** type. You need to obtain the data type by using **getType** and convert the data type to a child class before using it.|
+
+
+## How to Develop
+
+The following describes how to create a **UnifiedData** object containing two data records: image and plain text.
+
+1. Import the **@ohos.data.UDMF** module.
+   
+   ```ts
+   import UDMF from '@ohos.data.UDMF';
+   ```
+2. Create an image data record and initialize the **UnifiedData** object with the image data record.
+   
+    (1) Create an image data record.
+   
+   ```ts
+   let image = new UDMF.Image();
+   ```
+   
+    (2) Modify object attributes.
+   
+   ```ts
+   // The Image object contains the imageUri attribute.
+   image.imageUri = '...';
+   ```
+   
+    (3) Access the object attributes.
+   
+   ```ts
+   console.info(`imageUri = ${image.imageUri}`);
+   ```
+   
+    (4) Create a **UnifiedData** instance.
+   
+   ```ts
+   let unifiedData = new UDMF.UnifiedData(image);
+   ```
+3. Create a plain text data record and add it to the **UnifiedData** instance created.
+   
+   ```ts
+   let plainText = new UDMF.PlainText();
+   plainText.textContent = 'this is textContent of plainText';
+   plainText.abstract = 'abstract of plainText';
+   plainText.details = {
+     plainKey1: 'plainValue1',
+     plainKey2: 'plainValue2',
+   };
+   unifiedData.addRecord(plainText);
+   ```
+4. Obtain all data records in this **UnifiedData** instance.
+   
+   ```ts
+   let records = unifiedData.getRecords();
+   ```
+5. Traverse each record, determine the data type of the record, and convert the record into a child class object to obtain the original data record.
+   
+   ```ts
+   for (let i = 0; i < records.length; i ++) {
+     // Read the type of the data record.
+     let type = records[i].getType();
+     switch (type) {
+       case UDMF.UnifiedDataType.IMAGE:
+         // Convert the data to obtain the original image data record.
+         let image = <UDMF.Image>(records[i]);
+         break;
+       case UDMF.UnifiedDataType.PLAIN_TEXT:
+         // Convert the data to obtain the original text record.
+         let plainText = <UDMF.PlainText>(records[i]);
+         break;
+       default:
+         break;
+     }
+   }
+   ```

en/application-dev/reference/apis/js-apis-data-udmf.md

@@ -180,7 +180,7 @@ Represents the text data. It is a child class of [UnifiedRecord](#unifiedrecord)
 
 | Name   | Type                     | Readable| Writable| Description                                                                                                                                                 |
 | ------- | ------------------------- | ---- | ---- |-----------------------------------------------------------------------------------------------------------------------------------------------------|
-| details | { [key: string]: string } | Yes  | Yes  | A dictionary type object, where both the key and value are of the string type and are used to describe the text content. For example, a data object with the following content can be created to describe a text file:<br>{<br>"title":"Title",<br>"content":"Content"<br>}<br>This parameter is optional. The default value is an empty dictionary object.|
+| details | { [key: string]: string } | Yes  | Yes  | A dictionary type object, where both the key and value are of the string type and are used to describe the text content. For example, a data object with the following content can be created to describe a text file:<br>{<br>"title":"Title",<br>"content":"Content"<br>}<br> This parameter is optional. The default value is an empty dictionary object.|
 
 **Example**
 
@@ -258,7 +258,7 @@ Represents the file data. It is a child class of [UnifiedRecord](#unifiedrecord)
 
 | Name     | Type                       | Readable| Writable| Description                                                                                                                                                  |
 |---------|---------------------------| ---- | ---- |------------------------------------------------------------------------------------------------------------------------------------------------------|
-| details | { [key: string]: string } | Yes  | Yes  | A dictionary type object, where both the key and value are of the string type and are used to describe file information. For example, a data object with the following content can be created to describe a file:<br>{<br>"name":"File name",<br>"type":"File type"<br>}<br>This parameter is optional. The default value is an empty dictionary object.|
+| details | { [key: string]: string } | Yes  | Yes  | A dictionary type object, where both the key and value are of the string type and are used to describe file information. For example, a data object with the following content can be created to describe a file:<br>{<br>"name":"File name",<br>"type":"File type"<br>}<br> This parameter is optional. The default value is an empty dictionary object.|
 | uri     | string                    | Yes  | Yes  | URI of the file data.                                                                                                                                            |
 
 **Example**
@@ -484,13 +484,13 @@ let unifiedData = new UDMF.UnifiedData(record);
 
 ## Intention
 
-Enumerates the types of the system abilities connected to the UDMF. It identifies the purpose of the data written by the user to the UDMF and the system abilities connected to the UDMF to implement data transmission between applications.
+Enumerates the data channel types supported by the UDMF. It is used to identify different service scenarios, to which the UDMF data channels apply.
 
 **System capability**: SystemCapability.DistributedDataManager.UDMF.Core
 
 | Name      | Value        | Description     |
 |----------|-----------|---------|
-| DATA_HUB | 'DataHub' | Public data hub.|
+| DATA_HUB | 'DataHub' | Public data channel.|
 
 ## Options
 
@@ -499,9 +499,9 @@ Defines the data operation performed by the UDMF. It includes two optional param
 **System capability**: SystemCapability.DistributedDataManager.UDMF.Core
 
 
-| Name      | Type                     | Readable| Writable| Mandatory| Description                                                                                                                                                                                       |
-|-----------|-------------------------|----|----|----|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| intention | [Intention](#intention) | Yes | Yes | No | Service tag related to the data operation.                                                                                                                                                                           |
+| Name      | Type                     | Readable| Writable| Mandatory| Description                                                                                                                                                                                                                               |
+|-----------|-------------------------|----|----|----|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| intention | [Intention](#intention) | Yes | Yes | No | Type of the data channel related to the data operation.                                                                                                                                                                                                                 |
 | key       | string                  | Yes | Yes | No | Unique identifier of a data object in the UDMF, which can be obtained from the return value of [insertData](#udmfinsertdata).<br>The key consists of **udmf:/**, **intention**, **bundleName**, and **groupId** with a (/) in between, for example, **udmf://DataHub/com.ohos.test/0123456789**.<br>**udmf:/** is fixed, **DataHub** is an enum of **intention**, **com.ohos.test** is the bundle name, and **0123456789** is a group ID randomly generated.|
 
 
@@ -510,7 +510,7 @@ Defines the data operation performed by the UDMF. It includes two optional param
 
 insertData(options: Options, data: UnifiedData, callback: AsyncCallback&lt;string&gt;): void
 
-Inserts data to the UDMF. This API uses an asynchronous callback to return the result.
+Inserts data to the UDMF public data channel. This API uses an asynchronous callback to return the unique identifier of the data inserted.
 
 **System capability**: SystemCapability.DistributedDataManager.UDMF.Core
 
@@ -552,7 +552,7 @@ try {
 
 insertData(options: Options, data: UnifiedData): Promise&lt;string&gt;
 
-Inserts data to the UDMF. This API uses a promise to return the result.
+Inserts data to the UDMF public data channel. This API uses a promise to return the unique identifier of the data inserted.
 
 **System capability**: SystemCapability.DistributedDataManager.UDMF.Core
 
@@ -596,7 +596,7 @@ try {
 
 updateData(options: Options, data: UnifiedData, callback: AsyncCallback&lt;void&gt;): void
 
-Updates data in the UDMF. This API uses an asynchronous callback to return the result.
+Updates the data in the UDMF public data channel. This API uses an asynchronous callback to return the result.
 
 **System capability**: SystemCapability.DistributedDataManager.UDMF.Core
 
@@ -626,7 +626,7 @@ try {
         if (err === undefined) {
             console.info('Succeeded in updating data.');
         } else {
-            console.error('Failed to update data. code is ${err.code},message is ${err.message} `);
+            console.error(`Failed to update data. code is ${err.code},message is ${err.message} `);
         }
     });
 } catch(e) {
@@ -638,7 +638,7 @@ try {
 
 updateData(options: Options, data: UnifiedData): Promise&lt;void&gt;
 
-Updates data in the UDMF. This API uses a promise to return the result.
+Updates the data in the UDMF public data channel. This API uses a promise to return the result.
 
 **System capability**: SystemCapability.DistributedDataManager.UDMF.Core
 
@@ -683,7 +683,7 @@ try {
 
 queryData(options: Options, callback: AsyncCallback&lt;Array&lt;UnifiedData&gt;&gt;): void
 
-Queries data in the UDMF. This API uses an asynchronous callback to return the result.
+Queries data in the UDMF public data channel. This API uses an asynchronous callback to return the result.
 
 **System capability**: SystemCapability.DistributedDataManager.UDMF.Core
 
@@ -729,7 +729,7 @@ try {
 
 queryData(options: Options): Promise&lt;Array&lt;UnifiedData&gt;&gt;
 
-Queries data in the UDMF. This API uses a promise to return the result.
+Queries data in the UDMF public data channel. This API uses a promise to return the result.
 
 **System capability**: SystemCapability.DistributedDataManager.UDMF.Core
 
@@ -778,7 +778,7 @@ try {
 
 deleteData(options: Options, callback: AsyncCallback&lt;Array&lt;UnifiedData&gt;&gt;): void
 
-Deletes data from the UDMF. This API uses an asynchronous callback to return the result.
+Deletes data from the UDMF public data channel. This API uses an asynchronous callback to return the result.
 
 **System capability**: SystemCapability.DistributedDataManager.UDMF.Core
 
@@ -824,7 +824,7 @@ try {
 
 deleteData(options: Options): Promise&lt;Array&lt;UnifiedData&gt;&gt;
 
-Deletes data in the UDMF. This API uses a promise to return the result.
+Deletes data from the UDMF public data channel. This API uses a promise to return the result.
 
 **System capability**: SystemCapability.DistributedDataManager.UDMF.Core