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

平方厘米

发布于 2024-8-1 16:34

浏览

0收藏

场景

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

设备之间的数据都是"变量"，分布式数据对象即实现了对“变量”的“全局”访问。为开发者在分布式应用场景下提供简单易用的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 (分布式数据对象)

分类

其他

标签

分布式数据

数据同步

已于2024-8-1 16:37:08修改