分布式多设备软总线一文直接用 distributedKVStore 数据库的封装 kvManager设备管理的封装原创精华

小卓爱喂猫

发布于 2025-8-22 16:44

浏览

0收藏

基本的流程就是
1. 用户分布式权限确认
2. 组网选择要飞屏的设备，获取设备的id
3. 唤醒对方设备应用
4. 同步kv数据库到对方设备

kv数据库的封装

kvUtil.ets

import { distributedKVStore } from '@kit.ArkData';

import { bundleManager } from '@kit.AbilityKit';
import { hilog } from '@kit.PerformanceAnalysisKit';
import { BusinessError } from '@kit.BasicServicesKit';

const TAG = "[sqlutil]"

export default class KVUtils {
  private kvManager: distributedKVStore.KVManager | undefined = undefined;
  private context = getContext(this);
  private kvStore: distributedKVStore.SingleKVStore | undefined = undefined;
  private bundleName: string = 'com.example.kv_dist_test';
  private isInitialized = false; // 新增初始化状态标识
  private initPromise: Promise<void>; // 初始化Promise

  constructor() {
    this.initPromise = new Promise((resolve) => {

      let bundleFlags = bundleManager.BundleFlag.GET_BUNDLE_INFO_DEFAULT;
    bundleManager.getBundleInfoForSelf(bundleFlags, (err, data) => {
      this.bundleName = data.name;
      const kvManagerConfig: distributedKVStore.KVManagerConfig = {
        context: this.context,
        bundleName: this.bundleName
      };
      this.kvManager = distributedKVStore.createKVManager(kvManagerConfig);
      const options: distributedKVStore.Options = {
        createIfMissing: true, //数据库文件不存在时是否创建数据库
        backup: false, //是否备份数据库文件
        autoSync: true, //是否自动同步
        kvStoreType: distributedKVStore.KVStoreType.SINGLE_VERSION, //数据库类型
        encrypt: true, //是否加密
        securityLevel: distributedKVStore.SecurityLevel.S1//安全等级
      };
      //获取kvStore实例
      this.kvManager.getKVStore<distributedKVStore.SingleKVStore>(`harmony_utils_store`, options,
        (err, store: distributedKVStore.SingleKVStore) => {
          if (err) {
            //获取失败
            return;
          }
          //获取成功
          this.kvStore = store;
          this.isInitialized = true; // 标记初始化完成
          resolve(); // 解析Promise

          console.log(TAG, 'KVStore is initialized');
        });
    })
    });






  }
  async ensureInitialized() {
    if (!this.isInitialized) {
      await this.initPromise;
    }
  }
  //向数据库中写入数据
  async put(key: string, value: string | number | boolean) {
    this.kvStore!.put(key, value, (err: BusinessError) => {
      if (err != undefined) {
        console.error(TAG, `Failed to put.code is ${err.code},message is ${err.message}`);
        return;
      }
      console.info(TAG, "Succeeded in putting");
    });
  }

  async get(key: string): Promise<boolean | string | number | Uint8Array | null> {
    try {
      const data = await this.kvStore!.get(key);
      console.info(TAG, `Succeeded in getting data.data=${data}`);
      return data;
    } catch (err) {
      const error = err as BusinessError;
      console.error(TAG, `Failed to get. code is ${error.code}, message is ${error.message}`);
      return null;
    }
  }

  //删除key对应的数据
  delete(key: string) {
    this.kvStore!.delete(key, (err) => {
      if (err !== undefined) {
        hilog.error(0x0000, 'KVUtils', `Failed to delete data. Code:${err.code},message:${err.message}`);
        return;
      }
      hilog.info(0x0000, 'KVUtils', 'Succeeded in deleting data.');
    });
  }

  async  registerDataChangeListener(
    key: string,
    callback: (newValue: string | number | boolean | Uint8Array) => void
  ){


    try {

      await this.ensureInitialized(); // 等待初始化完成
      if (this.kvStore == undefined) {
        console.error(TAG, 'KVStore not initialized');
        // while (this.kvStore == undefined){
        //   console.error(TAG, 'KVStore not initialized');
        //
        // }
      }
      //订阅
        this.kvStore!.on('dataChange', distributedKVStore.SubscribeType.SUBSCRIBE_TYPE_ALL, (data) => {
          console.info(TAG, `dataChange callback call data: ${data}`);
          const changedEntry = data.updateEntries.find(e => e.key === key)?.value.value.toString();

          console.info(TAG, `dataChange callback call data: ${changedEntry}`);
//这里是为了获取改变后的值
          if (changedEntry) {
            callback(changedEntry+''); // 直接传递新值
          }



      })

    } catch (e) {
      let error = e as BusinessError;
      console.error(TAG, `An unexpected error occurred. code:${error.code},message:${error.message}`);
    }
  }

  async syncDevice(deviceIds:  string[]) {
    try {
      // 1000表示最大延迟时间为1000ms
      this.kvStore?.sync(deviceIds, distributedKVStore.SyncMode.PUSH_ONLY);
      console.log(`An unexpected error occurred.1111111111`);

    } catch (e) {
      let error = e as BusinessError;
      console.error(`An unexpected error occurred. Code:${error.code},message:${error.message}`);
    }

  }



}

export let kvUtil = new KVUtils()

设备组网的封装

DataObject.ets


import common from '@ohos.app.ability.common';
import distributedDataObject from '@ohos.data.distributedDataObject';
import distributedDeviceManager from '@ohos.distributedDeviceManager';
import fs from '@ohos.file.fs';
import Want from '@ohos.app.ability.Want';
import { BusinessError } from '@ohos.base';
import { Caller } from '@ohos.app.ability.UIAbility';
import { Logger } from '../common/Logger';

const TAG: string = 'DataObjectModel';
let caller: Caller;

class DataObject {
  public distributedObject: distributedDataObject.DataObject | undefined = undefined;
  private sessionId: string = '';

  createDataObject(context: common.UIAbilityContext, sessionId?: string) {
    if (this.distributedObject) {
      Logger.error(TAG, 'create dataObject already');
      return;
    }

    // 创建分布式数据对象实例
    this.distributedObject = distributedDataObject.create(context, {
      from: '',
      localFileUriList: [],
      disFileUriList: [],
      disFileList: []
    });

    // 设置数据变更监听
    this.distributedObject.on('change', (sessionId: string, fields: Array<string>) => {
      Logger.info(TAG, `change, sessionId: ${sessionId}, fields: ${JSON.stringify(fields)}`);
      fields.forEach((field) => {
        Logger.info(TAG, `${field}: ${this.distributedObject![field]}`);
      });
    });
    // 设置同步sessionId加入组网
    if (sessionId) {
      this.sessionId = sessionId;
    }
    this.distributedObject.setSessionId(this.sessionId);
  }

  // 调用端调用startAbilityByCall接口拉起对端Ability
  callRemote(context: common.UIAbilityContext) {
    if (caller) {
      Logger.error(TAG, 'call remote already');
      return;
    }

    // 调用genSessionId接口创建一个sessionId、获取对端设备networkId
    if (!this.sessionId) {
      this.sessionId = distributedDataObject.genSessionId();
    }
    Logger.info(TAG, `gen sessionId: ${this.sessionId}`);
    let deviceId = getRemoteDeviceId();
    if (deviceId == '') {
      Logger.error(TAG, 'no remote device');
      return;
    }
    Logger.info(TAG, `get remote deviceId: ${deviceId}`);

    let want: Want = {
      bundleName: 'com.samples.distributedfilemanager',
      abilityName: 'EntryAbility',
      deviceId: deviceId,
      parameters: {
        'ohos.aafwk.param.callAbilityToForeground': true,
        'distributedSessionId': this.sessionId
      }
    }
    try {
      context.startAbilityByCall(want).then((res) => {
        if (!res) {
          Logger.error(TAG, 'startAbilityByCall failed');
        }
        Logger.info(TAG, 'startAbilityByCall success');
        caller = res;
      })
    } catch (e) {
      let err = e as BusinessError;
      Logger.error(TAG, `get remote deviceId error, error code: ${err.code}, error message: ${err.message}`);
    }
  }

  update(from: string, localFileUriList: string[], disFileUriList: string[], disFileList: string[]) {
    Logger.info(TAG, `doUpdate,${from},${localFileUriList},${disFileUriList},${disFileList}`)
    this.distributedObject!['from'] = from;
    this.distributedObject!['localFileUriList'] = localFileUriList;
    this.distributedObject!['disFileUriList'] = disFileUriList;
    this.distributedObject!['disFileList'] = disFileList;
  }

  clear() {
    try{
      let disFileArray: Array<string> = this.distributedObject!["disFileList"];
      disFileArray.forEach( item  => {
        //判断uri前缀是否有“file+”，如果有则为文件
        if(item.includes("file+")){
          item = item.substring(5, item.length);
          fs.unlinkSync(item);
        } else {
          fs.rmdirSync(item);
        }
      })
    } catch (err) {
      Logger.error(TAG, `delete failed, code is ${err.code}, message is ${err.message}`);
    }
    this.distributedObject!['from'] = '';
    this.distributedObject!['localFileUriList'] = [];
    this.distributedObject!['disFileUriList'] = [];
    this.distributedObject!['disFileList'] = [];
  }
}

// 获取可信组网中的设备
function getRemoteDeviceId() {
  let deviceId = '';
  try {
    let deviceManager = distributedDeviceManager.createDeviceManager('com.samples.distributedfilemanager');
    let devices = deviceManager.getAvailableDeviceListSync();
    for (let device of devices) {
      if (device.networkId) {
        deviceId = device.networkId;
      }
    }
  } catch (e) {
    let err = e as BusinessError;
    Logger.error(TAG, `get remote deviceId error, error code: ${err.code}, error message: ${err.message}`);
  }
  return deviceId;
}

export default new DataObject();

- RemoteDeviceModel.ets


import deviceManager from '@ohos.distributedDeviceManager';
import { BusinessError } from '@ohos.base';
import { Callback } from '@ohos.base';
import { Logger } from '../common/Logger';

let SUBSCRIBE_ID = 100;
const TAG: string = '[RemoteDeviceModel]';

export class RemoteDeviceModel {
  public deviceList: deviceManager.DeviceBasicInfo[] = [];
  public discoverList: deviceManager.DeviceBasicInfo[] = [];
  private callback: () => void = () => {};
  private authCallback: () => void = () => {};
  private deviceManager?: deviceManager.DeviceManager = undefined;

  constructor() {}

  registerDeviceListCallback(callback: Callback<void>) {
    if (typeof (this.deviceManager) !== 'undefined') {
      this.registerDeviceListCallbackImplement(callback);
      return;
    }
    Logger.info(TAG, `deviceManager.createDeviceManager begin`);
    let self = this;
    try {
      let dmInstance = deviceManager.createDeviceManager('com.example.kv_dist_test');
      Logger.info(TAG, `dmInstance= ${JSON.stringify(dmInstance)}`);
      self.deviceManager = dmInstance;
      self.registerDeviceListCallbackImplement(callback);
      Logger.info(TAG, `createDeviceManager callback returned, value= ${JSON.stringify(this.deviceManager)}`);
    } catch (error) {
      Logger.error(TAG, `createDeviceManager throw error, code: ${(error as BusinessError).code}
      message: ${(error as BusinessError).message}`);
    }
    Logger.info(TAG, `deviceManager.createDeviceManager end`);
  }

  deviceStateChangeActionOnline(device: deviceManager.DeviceBasicInfo) {
    this.deviceList[this.deviceList.length] = device;
    Logger.info(TAG, `online, device list=${JSON.stringify(this.deviceList)}`);
    this.callback();
    if (this.authCallback !== null) {
      this.authCallback();
      this.authCallback = () => {};
    }
  }

  deviceStateChangeActionReady(device: deviceManager.DeviceBasicInfo) {
    if (this.deviceList.length <= 0) {
      this.callback();
      return;
    }
    let list: deviceManager.DeviceBasicInfo[] = new Array();
    for (let i = 0; i < this.deviceList.length; i++) {
      if (this.deviceList[i].deviceId !== device.deviceId) {
        list[i] = device;
      }
    }
    this.deviceList = list;
    Logger.info(TAG, `ready, device list=${JSON.stringify(device)}`);
    this.callback();
  }

  deviceStateChangeActionOffline(device: deviceManager.DeviceBasicInfo) {
    if (this.deviceList.length <= 0) {
      this.callback();
      return;
    }
    for (let j = 0; j < this.deviceList.length; j++) {
      if (this.deviceList[j].deviceId === device.deviceId) {
        this.deviceList[j] = device;
        break;
      }
    }
    Logger.info(TAG, `offline, device list=${JSON.stringify(this.deviceList)}`);
    this.callback();
  }

  registerDeviceListCallbackImplement(callback: Callback<void>) {
    Logger.info(TAG, `registerDeviceListCallback`);
    this.callback = callback;
    if (this.deviceManager === undefined) {
      Logger.error(TAG, `deviceManager has not initialized`);
      this.callback();
      return;
    }
    Logger.info(TAG, `getAvailableDeviceListSync begin`);
    try {
      let list = this.deviceManager.getAvailableDeviceListSync();
      Logger.info(TAG, `getAvailableDeviceListSync end, deviceList=${JSON.stringify(list)}`);
      if (typeof (list) !== 'undefined' && typeof (list.length) !== 'undefined') {
        this.deviceList = list;
      }
    } catch (error) {
      Logger.error(TAG, `getAvailableDeviceListSync throw error, code: ${(error as BusinessError).code}
      message: ${(error as BusinessError).message}`);
    }
    this.callback();
    Logger.info(TAG, `callback finished`);
    let self = this;
    try {
      this.deviceManager.on('deviceStateChange', (data) => {
        if (data == null) {
          return;
        }
        Logger.info(TAG, `deviceStateChange data=${JSON.stringify(data)}`);
        switch (data.action) {
          case deviceManager.DeviceStateChange.UNKNOWN:
            self.deviceStateChangeActionOnline(data.device);
            break;
          case deviceManager.DeviceStateChange.AVAILABLE:
            self.deviceStateChangeActionReady(data.device);
            break;
          case deviceManager.DeviceStateChange.UNAVAILABLE:
            self.deviceStateChangeActionOffline(data.device);
            break;
          default:
            break;
        }
      });
      this.deviceManager.on('discoverSuccess', (data) => {
        if (data === null) {
          return;
        }
        Logger.info(TAG, `discoverSuccess data=${JSON.stringify(data)}`);
        self.deviceFound(data.device);
      });
      this.deviceManager.on('discoverFailure', (data) => {
        Logger.info(TAG, `discoverFailure data= ${JSON.stringify(data)}`);
      });
      this.deviceManager.on('serviceDie', () => {
        Logger.error(TAG, `serviceDie`);
      });
    } catch (error) {
      Logger.error(TAG, `on throw error, code: ${(error as BusinessError).code}
      message: ${(error as BusinessError).message}`);
    }
    this.startDeviceDiscovery();
  }

  deviceFound(data: deviceManager.DeviceBasicInfo) {
    for (let i = 0; i < this.discoverList.length; i++) {
      if (data.deviceId && this.discoverList[i].deviceId === data.deviceId) {
        Logger.info(TAG, `device founded ignored`);
        return;
      }
    }
    this.discoverList[this.discoverList.length] = data;
    Logger.info(TAG, `deviceFound self.discoverList= ${this.discoverList}`);
    this.callback();
  }

  startDeviceDiscovery() {
    let discoverParam: Record<string, number> = {
      'discoverTargetType': 1
    };
    let filterOptions: Record<string, number> = {
      'availableStatus': 0
    };
    Logger.info(TAG, `startDeviceDiscovery${SUBSCRIBE_ID}`);
    try {
      if (this.deviceManager !== undefined) {
        this.deviceManager.startDiscovering(discoverParam, filterOptions);
      }
    } catch (error) {
      Logger.error(TAG, `startDeviceDiscovery throw error, code: ${(error as BusinessError).code}
      message: ${(error as BusinessError).message}`);
    }
  }

  unregisterDeviceListCallback() {
    Logger.info(TAG, `stopDeviceDiscovery ${SUBSCRIBE_ID}`);
    if (this.deviceManager === undefined) {
      return;
    }
    if (this.deviceManager !== undefined) {
      try {
        Logger.info(TAG, `stopDiscovering`);
        this.deviceManager.stopDiscovering();
      } catch (error) {
        Logger.error(TAG, `stopDeviceDiscovery throw error, code: ${(error as BusinessError).code}
        message: ${(error as BusinessError).message}`);
      }
      try {
        this.deviceManager.off('deviceStateChange');
        this.deviceManager.off('discoverSuccess');
        this.deviceManager.off('discoverFailure');
        this.deviceManager.off('serviceDie');
      } catch (error) {
        Logger.error(TAG, `off throw error, code: ${(error as BusinessError).code}
        message: ${(error as BusinessError).message}`);
      }
    }
    this.deviceList = [];
    this.discoverList = [];
  }

  authenticateDevice(device: deviceManager.DeviceBasicInfo, callBack: Callback<void>) {
    Logger.info(TAG, `authenticateDevice ${JSON.stringify(device)}`)
    for (let i = 0; i < this.discoverList.length; i++) {
      if (device.deviceId && this.discoverList[i].deviceId !== device.deviceId) {
        continue;
      }
      if (this.deviceManager === undefined) {
        return;
      }
      try {
        if (this.deviceManager !== null) {
          this.deviceManager.bindTarget(device.deviceId, {
            bindLevel: 3,
            bindType: 1,
            targetPkgName: 'com.example.kv_dist_test',
            appName: 'Distributedfilemanager',
          }, (err, data) => {
            if (err) {
              Logger.error(TAG, `authenticateDevice error: ${JSON.stringify(err)}`);
              this.authCallback = () => {
              }
              return;
            }
            Logger.info(TAG, `authenticateDevice succeed: ${JSON.stringify(data)}`);
            this.authCallback = callBack;
          })
        }
      } catch (error) {
        Logger.error(TAG, `authenticateDevice throw error, code: ${(error as BusinessError).code}
        message: ${(error as BusinessError).message}`);
      }
    }
  }
}

- DeviceDataModel.ets
export class DeviceDataModel {
  deviceId: string;
  deviceName: string;
  deviceType: string;
  checked: boolean;
  networkId: string;
  range: number;

  constructor(deviceId: string, deviceName: string, deviceType: string, checked: boolean, networkId: string, range: number) {
    this.deviceId = deviceId;
    this.deviceName = deviceName;
    this.deviceType = deviceType;
    this.checked = checked;
    this.networkId = networkId;
    this.range = range;
  }
}

DeviceDialog.ets


import { Logger } from '../common/Logger';
import { DeviceDataModel } from '../model/DeviceDataModel';

@CustomDialog
export struct DeviceDialog {
  controller: CustomDialogController;
  private deviceList: DeviceDataModel[] = [];
  private selectedIndex: number = 0;
  private handleSelectDevice: (selectedIndex: number) => void = (selectedIndex: number) => {};

  build() {
    Column() {
      Text('选择设备')
        .fontSize(20)
        .width('100%')
        .textAlign(TextAlign.Center)
        .fontColor(Color.Black)
        .fontWeight(FontWeight.Bold)
      List() {
        ForEach(this.deviceList, (item: DeviceDataModel, index: number) => {
          ListItem() {
            Row() {
              Text(item.deviceName)
                .fontSize(20)
                .width('90%')
                .fontColor(Color.Black)
              if (this.deviceList.indexOf(item) === this.selectedIndex) {
                Image($r('app.media.checked'))
                  .width('8%')
                  .objectFit(ImageFit.Contain)
              } else {
                Image($r('app.media.uncheck'))
                  .width('8%')
                  .objectFit(ImageFit.Contain)
              }
            }
            .height(55)
            .onClick(() => {
              this.handleSelectDevice(index);
              Logger.info('handleSelectDevice',index+'')
            })
          }
        }, (item: DeviceDataModel) => item.deviceName)
      }
      .layoutWeight(1)

      Button() {
        Text('取消')
          .fontColor('#0D9FFB')
          .width('90%')
          .textAlign(TextAlign.Center)
          .fontSize(20)
      }
      .id('cancel')
      .type(ButtonType.Capsule)
      .backgroundColor(Color.White)
      .onClick(() => {
        this.controller.close();
      })
    }
    .backgroundColor(Color.White)
    .border({ color: Color.White, radius: 20 })
    .padding(10)
  }
}

DistributedButton.ets


import { DeviceDialog } from './Dialog';
import { DeviceDataModel } from '../model/DeviceDataModel';
import { RemoteDeviceModel } from '../model/RemoteDeviceModel';
import common from '@ohos.app.ability.common';
import { Logger } from '../common/Logger';
import {  kvUtil } from '../common/distkv';

const TAG: string = '[DistributedButton]';
const DEVICE_DISCOVERY_RANGE: number = 1000;

@Component
export struct DistributedButton {
  private selectedIndex: number = 0;
  private remoteDeviceModel: RemoteDeviceModel | null = null;
  private dialogController: CustomDialogController | null = null;
  @State deviceList: DeviceDataModel[] = [];
  @Link isDistributed: boolean;
  @State dialogShow: boolean = false;

  clearSelectState() {
    this.deviceList = [];
    this.dialogShow = false;
    this.dialogController!.close();
  }

  selectDevice() {
    Logger.info(TAG, 'start ability ......');
    this.isDistributed = true;
    if (this.remoteDeviceModel === null || this.remoteDeviceModel.discoverList.length <= 0) {
      Logger.info(TAG, `continue unauthed device:${JSON.stringify(this.deviceList)}`);
      this.startAbility(this.deviceList[this.selectedIndex].networkId);
      this.clearSelectState();
      return;
    }
    Logger.info(TAG, 'start ability1, needAuth：');
    this.remoteDeviceModel.authenticateDevice(this.deviceList[this.selectedIndex], () => {
      Logger.info(TAG, 'auth and online finished');
      for (let i = 0; i < this.remoteDeviceModel!.deviceList.length; i++) {
        if (this.remoteDeviceModel!.deviceList[i].deviceName ===
        this.deviceList[this.selectedIndex].deviceName) {
          this.startAbility(this.remoteDeviceModel!.deviceList[i].networkId as string);
        }
      }
    })
    Logger.info(TAG, 'start ability2 ......');
    this.clearSelectState();
  }

  handleSelectDevice = (index: number) => {
    Logger.info(TAG, 'selectedIndexChange');
    this.selectedIndex = index;
    if (this.selectedIndex === 0) {
      Logger.info(TAG, 'stop ability');
      this.dialogController!.close();
      this.isDistributed = false;
      this.deviceList = [];
      this.dialogShow = false;
      return;
    }
    this.selectDevice();
  }

  startAbility(deviceId: string) {
    Logger.info(TAG, `startAbility deviceId:${deviceId}`);
    let context = getContext(this) as common.UIAbilityContext;
    const devices: string[] = this.deviceList.map((item:DeviceDataModel ) => item.networkId);
    Logger.info(TAG, `devices:${JSON.stringify(devices)}`);
    context.startAbility({
      bundleName: 'com.example.kv_dist_test',
      abilityName: 'EntryAbility',
      deviceId: deviceId,
      parameters: {
        isStage: 'Stage'
      }
    }).then((data) => {
      kvUtil.syncDevice(devices)

      Logger.info(TAG, `start ability finished:${JSON.stringify(data)}`);
    });
  }

  showDialog() {
    this.dialogShow = true;
    this.remoteDeviceModel!.registerDeviceListCallback(() => {
      this.deviceList = [];
      Logger.info(TAG, 'registerDeviceListCallback, callback entered');
      this.deviceList.push(new DeviceDataModel('0', 'Local device', '0', false, '', DEVICE_DISCOVERY_RANGE));
      let deviceTempList = this.remoteDeviceModel!.discoverList.length > 0 ? this.remoteDeviceModel!.discoverList :
      this.remoteDeviceModel!.deviceList;
      for (let i = 0; i < deviceTempList.length; i++) {
        Logger.info(TAG, `device ${i}/${deviceTempList.length} deviceId=${deviceTempList[i].deviceId}
        deviceName=${deviceTempList[i].deviceName} deviceType=${deviceTempList[i].deviceType}`);
        this.deviceList.push(new DeviceDataModel(deviceTempList[i].deviceId, deviceTempList[i].deviceName,
          deviceTempList[i].deviceType, (this.selectedIndex === i), deviceTempList[i].networkId as string,
          DEVICE_DISCOVERY_RANGE));
      }
      if (this.dialogShow) {
        this.dialogController!.close();
        this.dialogController = new CustomDialogController({
          builder: DeviceDialog({
            deviceList: this.deviceList,
            selectedIndex: this.selectedIndex,
            handleSelectDevice: this.handleSelectDevice
          }),
          autoCancel: true
        });
        this.dialogController.open();
      }
    })
    if (this.dialogController === null) {
      this.dialogController = new CustomDialogController({
        builder: DeviceDialog({
          deviceList: this.deviceList,
          selectedIndex: this.selectedIndex,
          handleSelectDevice: this.handleSelectDevice
        }),
        autoCancel: true
      });
      this.dialogController.open();
    }
  }

  build() {
    Row() {
      Image($r('app.media.ic_hop_normal'))
        .width(24)
        .height(24)
        .objectFit(ImageFit.Contain)
        .onClick(() => {
          Logger.info(TAG, 'showDialog start');
          this.showDialog();
        })
    }
    .constraintSize({ minHeight: 70 })
    .padding({ left: 15, right: 15 })
  }
}

测试使用的demo、


import {  kvUtil } from '../common/distkv';
import { Logger } from '../common/Logger';
import { DistributedButton } from '../components/DistributedButton';
import { RemoteDeviceModel } from '../model/RemoteDeviceModel';
import { common } from '@kit.AbilityKit';

@Entry
@Component
struct Index {
  @State message: string = '';
  private remoteDeviceModel: RemoteDeviceModel = new RemoteDeviceModel();
  @State isDistributed: boolean = false;
  // 添加辅助状态变量触发深度更新
  @State updateFlag: boolean = false;
  async   aboutToAppear(){

  await  kvUtil.registerDataChangeListener("name1",(data)=>{

    console.log("name1changeData:", data)
this.message = data+""

  });
    let data = await kvUtil.get("name1")
    // console.log("name1:", data)
    this.message = `${data}`
  }


  build() {
    Column() {
      Text(this.message)
      Button('put')
        .onClick(
          async () => {
            await kvUtil.put("name1", "xiaopacai")
            let data = await kvUtil.get("name1")
            console.log("name1:", data)
            // this.message = `${data}`

          }
        )
      Button('delect')
        .onClick(
          async () => {
            await kvUtil.delete("name1")
            let data = await kvUtil.get("name1")
            console.log("name1:", data)
            // this.message = `${data}`

            // let context = getContext(this) as common.UIAbilityContext;
            // context.startAbility({
            //   bundleName: 'com.example.kv_dist_test',
            //   abilityName: 'EntryAbility',
            //   deviceId: 'e928a92b114b400e',
            //   parameters: {
            //     isStage: 'Stage'
            //   }
            // }).then((data) => {
            //   Logger.info( `start ability finished:${JSON.stringify(data)}`);
            // });
          }
        )
      Button('查')
        .onClick(
          async () => {
            let data = await kvUtil.get("name1")
            // console.log("name1:", data)
            this.message = `${data}`

            // let context = getContext(this) as common.UIAbilityContext;
            // context.startAbility({
            //   bundleName: 'com.example.kv_dist_test',
            //   abilityName: 'EntryAbility',
            //   deviceId: 'e928a92b114b400e',
            //   parameters: {
            //     isStage: 'Stage'
            //   }
            // }).then((data) => {
            //   Logger.info( `start ability finished:${JSON.stringify(data)}`);
            // });
          }
        )
      DistributedButton({
        remoteDeviceModel: this.remoteDeviceModel,
        isDistributed: $isDistributed
      })
    }



    .height('100%')
    .width('100%')
  }
}