基于分布式数据对象的跨设备数据同步

场景

传统跨设备数据同步，需开发者完成：建立通信链接、消息收发处理、错误重试、数据冲突解决等一系列消息处理逻辑，工作量大且复杂。

设备之间的数据都是"变量"，分布式数据对象即实现了对“变量”的“全局”访问。为开发者在分布式应用场景下提供简单易用的JS接口，轻松实现多设备间同应用的数据协同，同时设备间可以监听对象的状态和数据变更。

方案介绍

使用分布式数据对象进行跨设备数据同步时，需要申请ohos.permission.DISTRIBUTED\_DATASYNC权限，允许不同设备间的数据交换，该权限为user\_grant，需要向用户弹窗申请授权。

随后创建分布式数据对象并加入可信组网（进行跨设备数据同步的设备需要登录相同的华为账号，同一网络，并开启蓝牙）。

注：一个分布式对象加入组网时，如果它的数据与组网中的数据不同，它会刷新组网中的数据。若希望加入组网时不刷新组网中的数据，并且得到组网中的数据，可以将属性设置为undefined。（例如下文中的Message对象设置为：new Message(undefined,undefined) ）。

实现效果

A、B两台设备分别点击创建分布式数据对象，并开启数据变更监听，此时在A设备输入数据，B设备即可自动同步。

开发步骤

一、申请权限

使用分布式数据对象进行跨设备数据同步时，需要申请ohos.permission.DISTRIBUTED\_DATASYNC权限，该权限为user\_grant，需要向用户弹窗申请授权。用户若拒绝授权，需要引导用户到设置--隐私和安全--多设备协同中授权，调用分布式数据对象相关能力时，建议先判断用户是否已授权。申请权限可参考：

//EntryAbility.ets
function reqPermissionsFromUser(permissions: Array<Permissions>,context:common.UIAbilityContext): void {
  let atManager = abilityAccessCtrl.createAtManager();
  // requestPermissionsFromUser会判断权限的授权状态来决定是否唤起弹窗
  atManager.requestPermissionsFromUser(context, permissions).then((data) => {
    let grantStatus: Array<number> = data.authResults;
    let length: number = grantStatus.length;
    for (let i = 0; i < length; i++) {
      if (grantStatus[i] === 0) {
        // 用户授权，可以继续访问目标操作
        console.info(`User authorization succeeded.`)
      }
      else {
        // 用户拒绝授权，提示用户必须授权才能访问当前页面的功能，并引导用户到系统设置中打开相应的权限
        console.error("user did not grant!")
        openPermissionsInSystemSettings(context)；
      }
    }
    // 授权成功
  }).catch((err: String) => {
  })
}

function openPermissionsInSystemSettings(context: common.UIAbilityContext): void {
  let wantInfo: Want = {
    bundleName: 'com.huawei.hmos.settings',
    abilityName: 'com.huawei.hmos.settings.MainAbility',
    uri: 'application_info_entry',
    parameters: {
      pushParams: 'com.example.distributeddata' // 打开指定应用的详情页面
    }
  }
  context.startAbility(wantInfo).then(() => {
    // ...
  }).catch((err: BusinessError) => {
    // ...
  })
}

onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
  const permissions: Array<Permissions> = ['ohos.permission.DISTRIBUTED_DATASYNC'];
  reqPermissionsFromUser(permissions,this.context)
  hilog.info(0x0000, 'testTag', '%{public}s', 'Ability onCreate');
}

二、创建分布式对象并加入组网

实现方案：

封装DistributedDataModel 类，创建实例时根据传入的source:Object对象（本文传入一个Message对象，包含createTime，message两个属性），通过distributedDataObject.create方法创建对应的分布式数据对象并通过setSessionId方法设置其sessionId。

封装单例类GlobalThis用于存储mesaage，并通过Observed装饰，当message变化时刷新到TextArea中。

注：同一个设备只能有一个分布式对象加入相同的sessionId，A对象已经加入sessionId后，B对象在加入同一sessionId会失败。

核心代码：

import distributedDataObject from '@ohos.data.distributedDataObject';
import common from '@ohos.app.ability.common';
import { BusinessError } from '@kit.BasicServicesKit';
import { ShowData } from '../utils/ShowData'

let localObject: distributedDataObject.DataObject;

export default class DistributedDataModel {
  showData: ShowData = ShowData.getInstance()

  constructor(context: common.Context, source: Object) {
    if (localObject == null || undefined) {
      localObject = distributedDataObject.create(context, source);
      localObject.setSessionId('123456')
      console.info('setSessionId end');
    } else {
      console.log('请勿重复创建分布式数据对象并加入同一sessionID')
    }
  }

  //设置message
  setMessage(message: string) {
    if (localObject != null || undefined) {
      localObject['message'] = message;
    } else {
      console.log('localObject is null or undefined')
    }
  }
}

// 构造单例对象
@Observed
export class ShowData {
  private static instance: ShowData;
  public message: string;

  constructor(message: string) {
    this.message = message
  }

  public static getInstance(): ShowData {
    if (!ShowData.instance) {
      ShowData.instance = new ShowData('');
    }
    return ShowData.instance;
  }

  getMessage(): string {
    return this.message;
  }

  setMessage(value: string): void {
    this.message = value;
  }
}

import DistributedDataModel from '../DistributedData/DistributedDataModel'
import { ShowData } from '../utils/ShowData'

class Message {
  createTime?: Date
  message?: string
  constructor(createTime?: Date, message?: string) {
    this.createTime = createTime
    this.message = message
  }
}

let now = Date.now()
let distributedDataA: DistributedDataModel;

@Entry
@Component
struct Index {
  @State messages: Message = new Message(new Date(now), '这是初始数据');
  @State showData: ShowData = ShowData.getInstance()
  controller: TextAreaController = new TextAreaController()

  build() {
    Row() {
      Column() {
        TextArea({
          text: this.showData.message,
          placeholder: 'The text area can hold an unlimited amount of text. input your word...',
          controller: this.controller
        })
          .placeholderFont({ size: 16, weight: 400 })
          .width(336)
          .height(56)
          .margin(20)
          .fontSize(16)
          .fontColor('#182431')
          .backgroundColor('#FFFFFF')
          .onChange((value: string) => {

            distributedDataA.setMessage(value)
          })
        Button('创建分布式数据对象')
          .fontSize(20)
          .fontWeight(FontWeight.Bold)
          .onClick(() => {
            distributedDataA = new DistributedDataModel(getContext(), this.messages);
            //如果设备加入组网时不希望刷新组网中已有的数据，注意将该分布式数据对象的属性设置为undefined，即messages的属性设置为undefined
            // distributedDataA= new DistributedDataModel(getContext(),new Message(undefined,undefined));
          })
          .margin(10)
      }
      .height('100%')
      .width('100%')
    }
  }
}

三、操作分布式数据对象

（1）监听数据变更。

A、B两条设备组网后，A设备开启监听后（on("change")），B设备修改数据，随后A设备读取数据，此时读取到的是B设备修改后的数据。

随后A删除监听(off("change"))，B设备再次修改数据，随后A设备读取数据，此时读取到的是B设备修改前的数据。

import { ShowData } from '../utils/ShowData'

showData: ShowData = ShowData.getInstance()

//获取message
getMessage(): string {
  if (localObject != null || undefined) {
    console.log('获取组网内最新数据 createTime is ' + localObject['createTime'])
    console.log('获取组网内最新数据  message is ' + localObject['message'])
    return localObject['message']
  } else {
    console.log('localObject is null or undefined')
    return ''
  }
}

//设置message
setMessage(message: string) {
  if (localObject != null || undefined) {
    localObject['message'] = message;
  } else {
    console.log('localObject is null or undefined')
  }
}

//监听对象数据变更。可监听对端数据的变更，以callback作为变更回调实例。
onChange() {
  localObject.on('change', (sessionId: string, fields: Array<string>) => {
    console.info('change' + sessionId);
    if (fields != null && fields != undefined) {
      for (let index: number = 0; index < fields.length; index++) {
        this.showData.setMessage(localObject[fields[index]])
        console.info(`message is ${this.showData.getMessage()}`)
        console.info(`The element ${localObject[fields[index]]} changed.`);
      }
    }
  });
}

// 删除数据变更监听 当不再进行数据变更监听时，使用此接口删除对象的变更监听
deleteChange() {
  if (localObject != null || undefined) {
    // 删除数据变更回调changeCallback
    localObject.off('change', (sessionId: string, fields: Array<string>) => {
      console.info('change' + sessionId);
      if (fields != null && fields != undefined) {
        for (let index: number = 0; index < fields.length; index++) {
          console.info('changed !' + fields[index] + ' ' + localObject[fields[index]]);
        }
      }
    });
    // 删除所有的数据变更回调
    localObject.off('change');
  } else {
    console.log('localObject is null or undefined')
  }
}

（2）监听组网内分布式数据对象的上下线及移除监听。

通过on（"status"）监听分布式对象的上下线,当对端设备上下线时即可触发业务回调，当不在需要监听时可通过 off("status")移除监听。

//监听分布式设备上下线
onStatus() {
  if (localObject != null || undefined) {
    localObject.on('status', (sessionId: string, networkId: string, status: 'online' | 'offline') => {
      console.info('status changed'  + sessionId + ' '+ status + ' ' + networkId);
    });
  } else {
    console.log('localObject is null or undefined')
  }
}

//  删除设备上下线监听 当不再进行对象上下线监听时，使用此接口删除对象的上下线监听。
deleteStatus() {
  if (localObject != null || undefined) {
    // 删除上下线回调changeCallback
    /*localObject.off('status', (sessionId: string, networkId: string, status: 'online' | 'offline') => {
      console.info('status changed ' + sessionId + ' ' + status + ' ' + networkId);
    });*/
    // 删除所有的上下线回调
    localObject.off('status');
  } else {
    console.log('localObject is null or undefined')
  }
}

（3）保存分布式数据对象及撤回保存的分布式数据对象。

save(deviceId: string)，保存分布式数据对象。deviceId表示保存数据的设备号，标识需要保存对象的设备，默认为"local"，代表保存在本地。

通过save("local")将对象数据保存成功后，当应用存在时不会释放对象数据，当应用退出后，重新进入应用时，恢复保存在设备上的数据。

通过revokeSave()撤回保存的分布式数据对象，如果对象保存在本地设备，那么将删除所有受信任设备上所保存的数据。如果对象保存在其他设备，那么将删除本地设备上的数据。

注意：revokesave是撤销还没有被恢复的数据。若A设备将数据save到B设备，B设备创建分布式对象时会自动恢复数据，此时A设备revokesave无法撤销B设备已回复的数据。

deviceId获取方式：

1、on('status')的时候可以获得标识对象设备的networkId（使用该networkId即可）。

2、在接续场景中，可以重wantParam里获取targetDevice，参考链接：应用接续。

// 保存分布式数据对象
saveData() {
  if (localObject != null || undefined) {
    // 保存数据对象，如果应用退出后组网内设备需要恢复对象数据时调用
    localObject.save('local').then((result: distributedDataObject.SaveSuccessResponse) => {
      console.info(`Succeeded in saving. SessionId:${result.sessionId},
        version:${result.version},deviceId:${result.deviceId}`);
    }).catch((err: BusinessError) => {
      console.error(`Failed to save. Code:${err.code},message:${err.message}`);
    });
  } else {
    console.log('localObject is null or undefined')
  }
}

// 撤回保存的分布式数据对象
revokeSaveData() {
  if (localObject != null || undefined) {
    // 撤回保存的数据对象
    localObject.revokeSave().then((result: distributedDataObject.RevokeSaveSuccessResponse) => {
      console.info(`Succeeded in revokeSaving. Session:${result.sessionId}`);
    }).catch((err: BusinessError) => {
      console.error(`Failed to revokeSave. Code:${err.code},message:${err.message}`);
    });
  } else {
    console.log('localObject is null or undefined')
  }
}

参考文档

分布式数据对象跨设备数据同步

API参考：@ohos.data.distributedDataObject (分布式数据对象)

基于分布式数据对象的跨设备数据同步

HarmonyOS码上奇行

引用和评论

首款开发鸿蒙原生应用的AI辅助编程工具正式上线了

“一起学 HarmonyOS”第二弹来啦！

HarmonyOS Next 应用实战案例—“马背上的家乡”元服务

API接口设计的未来趋势：探索技术方向与实践方案

HarmonyOS 如何获取设备信息（系统、版本、网络连接状态）

构建安全护盾：HarmonyOS 应用的数据安全审计与日志管理实战

如何构建安全可靠的 HarmonyOS 应用