The Art of Data Synchronization in HarmonyOS Next: The Use of Distributed Databases and Data Protection

This article aims to deeply explore the technical details of the Huawei HarmonyOS Next system (up to API 12 as of now), and is summarized based on actual development practices. It mainly serves as a carrier for technical sharing and communication. Mistakes and omissions are inevitable. Colleagues are welcome to put forward valuable opinions and questions so that we can make progress together. This article is original content, and any form of reprint must indicate the source and the original author.

Overview

In the Huawei HarmonyOS Next system, ArkTS (ArkUI Type Script) is a front-end development framework used for developing HarmonyOS applications. It supports declarative syntax, enabling developers to build user interfaces more efficiently. The distributed database is an important feature in the HarmonyOS Next system, allowing data to be synchronized seamlessly between multiple devices. This section will introduce how to use ArkTS to utilize the distributed database in the HarmonyOS Next system and discuss the related data protection mechanisms.

Main Content

Creation of Distributed Data Tables and Cross-Device Synchronization

In the HarmonyOS Next system, the distributed data table is a data storage solution that supports cross-device synchronization. The following are the steps to create a distributed data table using ArkTS and achieve cross-device synchronization:

1. Define the Distributed Data Table

import distributedData from '@ohos.data.distributedData';
// Define the distributed database configuration
const databaseConfig = {
    bundleName: 'com.example.app',
    tableName: 'MyDistributedTable'
};
// Create the distributed data table
const distributedTable = distributedData.createDistributedTable(databaseConfig);

1. Cross-Device Synchronization of Data

// Insert data into the distributed data table
async function insertData(item: any) {
    try {
        await distributedTable.insert(item);
        console.log('Data inserted successfully.');
    } catch (error) {
        console.error('Failed to insert data:', error);
    }
}
// Synchronize data to other devices
async function syncData() {
    try {
        await distributedTable.sync();
        console.log('Data synchronized successfully.');
    } catch (error) {
        console.error('Failed to synchronize data:', error);
    }
}

Data Security Labels and Device Security Levels

To protect data security, the HarmonyOS Next system introduces the concepts of data security labels and device security levels. The following are examples of how to set and use these features in ArkTS:

1. Set the Data Security Label

// Set the data security label
function setDataSecurityLabel(item: any, label: string) {
    item.securityLabel = label;
    insertData(item);
}
// Example: Set a security label for a data item
setDataSecurityLabel({ id: 1, value: 'Sensitive Data' }, 'HIGH');

1. Check the Device Security Level

import device from '@ohos.device';
// Get the device security level
async function getDeviceSecurityLevel() {
    try {
        const securityLevel = await device.getDeviceSecurityLevel();
        console.log('Device security level:', securityLevel);
        return securityLevel;
    } catch (error) {
        console.error('Failed to get device security level:', error);
    }
}

Example

The following is a complete example of how to set up a distributed table and synchronization mechanism in a project:

// Import the distributed database module
import distributedData from '@ohos.data.distributedData';
// Define the distributed database configuration
const databaseConfig = {
    bundleName: 'com.example.app',
    tableName: 'MyDistributedTable'
};
// Create the distributed data table
const distributedTable = distributedData.createDistributedTable(databaseConfig);
// Insert data into the distributed data table
async function insertData(item: any) {
    try {
        await distributedTable.insert(item);
        console.log('Data inserted successfully.');
    } catch (error) {
        console.error('Failed to insert data:', error);
    }
}
// Synchronize data to other devices
async function syncData() {
    try {
        await distributedTable.sync();
        console.log('Data synchronized successfully.');
    } catch (error) {
        console.error('Failed to synchronize data:', error);
    }
}
// Set the data security label
function setDataSecurityLabel(item: any, label: string) {
    item.securityLabel = label;
    insertData(item);
}
// Get the device security level and synchronize data
async function setupAndSyncData() {
    const securityLevel = await getDeviceSecurityLevel();
    if (.securityLevel === 'TRUSTED') {
        // Only synchronize data when the device security level is trusted
        syncData();
    }
}
// Example: Set a security label for a data item and initiate synchronization
setDataSecurityLabel({ id: 1, value: 'Sensitive Data' }, 'HIGH');
setupAndSyncData();

In the above example, we first created a distributed data table and defined methods for inserting data and synchronizing data. Then, we set security labels for data items and decided whether to synchronize data based on the trust level of the device. In this way, we not only achieved cross-device synchronization of data but also ensured the security of the data.