HarmonyOS鸿蒙Next应用如何实现分布式协同应用开发？

HarmonyOS鸿蒙Next应用如何实现分布式协同应用开发？ 鸿蒙应用如何实现分布式协同应用开发？

3 回复

cke_150.png

一、结论

市面操作系统调研 1、市面上的操作系统，目前只有华为提出了分布式操作系统。 2、像苹果的操作系统，手机平板和电脑也是两套。 3、安卓只有移动端操作系统。没有涉及电脑。 4、微软的电脑操作系统，多年来才集成了安卓虚拟机。

分布式操作系统的特点 1、设备间的操作系统一致 2、拥有统一的交互语言 3、完整的生态

HarmonyOS超级终端能力基座： 1、分布式任务调度 2、分布式数据管理 3、分布式软总线 4、分布式设备虚拟化

HarmonyOS系统架构 HarmonyOS是在OpenHarmony的基础上演进的操作系统。系 统架构是一致，从下面OH的操作系统架构图。我们就可以发现鸿蒙操作分布式是如何实现：

cke_20197.png

二、代码实现和详细解释

1. 权限配置与申请

module.json5配置：

{
  "module": {
    "requestPermissions": [
      {
        "name": "ohos.permission.DISTRIBUTED_DATASYNC",
        "reason": "$string:permission_rationale",
        "usedScene": {
          "abilities": ["MainAbility"],
          "when": "inuse"
        }
      }
    ]
  }
}

动态权限申请代码：

import promptAction from '@ohos.promptAction';
import { abilityAccessCtrl, common } from '@kit.AbilityKit';

@Entry
@Component
struct DistributedDemo {

  aboutToAppear() {
    this.requestPermission();
  }

  // 用户申请权限
  private async reqPermissionsFromUser(): Promise<number[]> {
    let context = getContext() as common.UIAbilityContext;
    let atManager = abilityAccessCtrl.createAtManager();
    let grantStatus = await atManager.requestPermissionsFromUser(context, ["ohos.permission.DISTRIBUTED_DATASYNC"]);
    return grantStatus.authResults;
  }

  private async requestPermission() {
    let grantStatus = await this.reqPermissionsFromUser();
    for (let i = 0; i < grantStatus.length; i++) {
      if (grantStatus[i] === 0) {
        // 用户授权，可以继续访问目标操作
        this.initDeviceManager();
      }else{
        promptAction.showToast({ message: '请授予权限以使用分布式功能', duration: 2000 });
      }
    }
  }
}

2. 设备发现与组网

设备管理核心类：

import { distributedDeviceManager, BusinessError } from '@ohos.distributedDeviceManager';
import promptAction from '@ohos.promptAction';

class DeviceManager {
  private dmInstance: distributedDeviceManager.DeviceManager | null = null;
  @State discoveredDevices: Array<distributedDeviceManager.DeviceBasicInfo> = [];
  
  // 创建设备管理实例并注册回调
  initDeviceManager() {
    try {
      this.dmInstance = distributedDeviceManager.createDeviceManager('com.example.distributedDemo');
      
      // 注册设备发现回调
      this.dmInstance.on('discoverSuccess', (data) => {
        console.info(`发现设备: ${JSON.stringify(data)}`);
        this.discoveredDevices.push(data);
        // 更新UI显示设备列表
        this.updateDeviceList();
      });
      
      this.dmInstance.on('discoverFailure', (error) => {
        console.error(`设备发现失败: ${error.code}, ${error.message}`);
        promptAction.showToast({
          message: '设备发现失败，请检查网络或蓝牙',
          duration: 2000
        });
      });
      
      // 注册设备状态变化回调（上下线监听）
      this.dmInstance.on('deviceStateChange', (data) => {
        const action = data.action === 1 ? '上线' : '下线';
        console.info(`设备 ${data.device.deviceName} ${action}`);
        promptAction.showToast({
          message: `${data.device.deviceName} 已${action}`,
          duration: 1500
        });
      });
    } catch (error) {
      console.error(`创建设备管理器失败: ${(error as BusinessError).code}, ${(error as BusinessError).message}`);
    }
  }
  
  // 开始发现周边设备
  startDiscovering() {
    if (!this.dmInstance) return;
    
    const discoverParam: Record<string, number> = {
      'discoverTargetType': 1  // 发现所有类型设备
    };
    
    const filterOptions: Record<string, number> = {
      'availableStatus': 0,     // 发现可用设备
      'discoverDistance': 0,    // 不限制距离
      'authenticationStatus': 0, // 发现未认证设备
      'authorizationType': 0    // 不限制授权类型
    };
    
    try {
      this.dmInstance.startDiscovering(discoverParam, filterOptions);
      console.info('开始发现设备...');
      promptAction.showToast({
        message: '正在搜索周边设备',
        duration: 2000
      });
    } catch (error) {
      console.error(`设备发现接口调用失败: ${(error as BusinessError).code}, ${(error as BusinessError).message}`);
    }
  }
}

3. 设备绑定与连接

设备绑定逻辑：

// 在DeviceManager类中添加绑定方法
bindDevice(deviceId: string) {
  if (!this.dmInstance) return;
  
  const bindParam: Record<string, string | number> = {
    'bindType': 1,                // 绑定类型（1: PIN码认证）
    'targetPkgName': 'com.example.targetDevice', // 目标设备包名
    'appName': '智能家居设备',
    'appOperation': '绑定操作',
    'customDescription': '分布式组网绑定'
  };
  
  this.dmInstance.bindTarget(deviceId, bindParam, (error, data) => {
    if (error) {
      console.error(`设备绑定失败: ${error.code}, ${error.message}`);
      promptAction.showToast({
        message: '设备绑定失败，请重试',
        duration: 2000
      });
      return;
    }
    
    console.info(`设备绑定成功: ${data.deviceId}`);
    promptAction.showToast({
      message: '设备绑定成功',
      duration: 2000
    });
  });
}

4. 设备信息查询与状态监听

查询可信设备列表：

// 在DeviceManager类中添加查询方法
getTrustedDevices() {
  if (!this.dmInstance) return [];
  
  try {
    const deviceList = this.dmInstance.getAvailableDeviceListSync();
    console.info(`查询到 ${deviceList.length} 个可信设备`);
    return deviceList;
  } catch (error) {
    console.error(`查询设备列表失败: ${(error as BusinessError).code}, ${(error as BusinessError).message}`);
    return [];
  }
}

5. 分布式数据交互示例

基于设备连接的数据传输：

import { distributedDataManager } from '@ohos.distributedDataManager';

class DataInteraction {
  private context: UIContext;
  private deviceId: string; // 目标设备ID
  
  constructor(context: UIContext, deviceId: string) {
    this.context = context;
    this.deviceId = deviceId;
  }
  
  // 向目标设备发送控制指令（如开灯）
  sendControlCommand(command: string) {
    const dataObject = {
      command: command,
      timestamp: new Date().getTime()
    };
    
    distributedDataManager.putData(
      this.context,
      'smartHomeControl', // 数据空间名称
      JSON.stringify(dataObject),
      { targetDeviceId: this.deviceId }
    ).then(() => {
      console.info(`指令发送成功: ${command}`);
    }).catch((error) => {
      console.error(`指令发送失败: ${error}`);
    });
  }
  
  // 订阅目标设备状态数据
  subscribeDeviceStatus() {
    distributedDataManager.subscribe(
      this.context,
      'smartHomeStatus', // 数据空间名称
      { targetDeviceId: this.deviceId },
      (data) => {
        console.info(`收到设备状态更新: ${data}`);
        // 解析数据并更新本地UI
        const status = JSON.parse(data);
        this.updateDeviceStatusUI(status);
      }
    ).then(() => {
      console.info('设备状态订阅成功');
    }).catch((error) => {
      console.error(`订阅失败: ${error}`);
    });
  }
}

三、源码DEMO分享

import promptAction from '@ohos.promptAction';
import { abilityAccessCtrl, common } from '@kit.AbilityKit';
import { distributedDeviceManager } from '@kit.DistributedServiceKit';
import { BusinessError } from '@kit.BasicServicesKit';

class Data {
  device: distributedDeviceManager.DeviceBasicInfo = {
    deviceId: '',
    deviceName: '',
    deviceType: '',
    networkId: ''
  };
}

class ErrorData {
  reason: number = 0;
}

@Entry
@Component
struct DistributedPage {

  private dmInstance: distributedDeviceManager.DeviceManager | null = null;
  @State discoveredDevices: Array<distributedDeviceManager.DeviceBasicInfo> = [];
  @State trustedDevices: Array<distributedDeviceManager.DeviceBasicInfo> = [];

  aboutToAppear() {
    this.requestPermission();
  }

  // 用户申请权限
  private async reqPermissionsFromUser(): Promise<number[]> {
    let context = getContext() as common.UIAbilityContext;
    let atManager = abilityAccessCtrl.createAtManager();
    let grantStatus = await atManager.requestPermissionsFromUser(context, ["ohos.permission.DISTRIBUTED_DATASYNC"]);
    return grantStatus.authResults;
  }

  private async requestPermission() {
    let grantStatus = await this.reqPermissionsFromUser();
    for (let i = 0; i < grantStatus.length; i++) {
      if (grantStatus[i] === 0) {
        // 用户授权，可以继续访问目标操作
        this.initDeviceManager();
      }else{
        promptAction.showToast({ message: '请授予权限以使用分布式功能', duration: 2000 });
      }
    }
  }


  // 初始化设备管理器
  initDeviceManager() {
    try {
      this.dmInstance = distributedDeviceManager.createDeviceManager('com.example.distributedDemo');

      // 注册设备发现回调
      this.dmInstance.on('discoverSuccess', (data: Data) => {
        this.discoveredDevices.push(data?.device);
      });

      this.dmInstance.on('discoverFailure', (error: ErrorData) => {
        console.error(`发现失败: ${error.reason}`);
        promptAction.showToast({ message: '设备发现失败', duration: 2000 });
      });

      // 注册设备状态变化回调
      this.dmInstance.on('deviceStateChange', (data) => {
        const action = data.action === 1 ? '上线' : '下线';
        promptAction.showToast({ message: `${data.device.deviceName} ${action}`, duration: 1500 });
        this.queryTrustedDevices();
      });

      // 开始发现设备
      this.startDiscovering();
    } catch (error) {
      console.error(`创建设备管理器失败: ${(error as BusinessError).code}, ${(error as BusinessError).message}`);
    }
  }

  // 开始发现设备
  startDiscovering() {
    const discoverParam: Record<string, number> = { 'discoverTargetType': 1 };
    const filterOptions: Record<string, number> = { 'availableStatus': 0 };

    try {
      this.dmInstance?.startDiscovering(discoverParam, filterOptions);
      promptAction.showToast({ message: '正在搜索设备...', duration: 2000 });
    } catch (error) {
      console.error(`发现接口调用失败: ${(error as BusinessError).code}, ${(error as BusinessError).message}`);
    }
  }

  // 绑定设备
  bindDevice(deviceId: string) {
    const bindParam: Record<string, string | number> = {
      'bindType': 1,
      'targetPkgName': 'com.example.device',
      'appName': '智能家居',
      'appOperation': '绑定',
      'customDescription': '分布式组网'
    };

    this.dmInstance?.bindTarget(deviceId, bindParam, (error, data) => {
      if (error) {
        console.error(`绑定失败: ${error.code}, ${error.message}`);
        promptAction.showToast({ message: '绑定失败，请重试', duration: 2000 });
        return;
      }

      promptAction.showToast({ message: '设备绑定成功', duration: 2000 });
      this.queryTrustedDevices();
    });
  }

  // 查询可信设备
  queryTrustedDevices() {
    try {
      this.trustedDevices = this.dmInstance?.getAvailableDeviceListSync() ?? [];
    } catch (error) {
      console.error(`查询失败: ${(error as BusinessError).code}, ${(error as BusinessError).message}`);
    }
  }


  // 数据交互示例：向目标设备发送指令
  sendDataToDevice(deviceId: string) {
    // 实际项目中可集成distributedDataManager或remoteService等接口
    promptAction.showToast({ message: `向 ${deviceId} 发送控制指令`, duration: 1500 });
    console.info(`模拟向设备 ${deviceId} 发送数据`);
  }

  build() {
    Column() {
      Text('分布式设备管理DEMO').fontSize(24).fontWeight(FontWeight.Bold).margin({ top: 20 });

      // 操作按钮
      Row() {
        Button('开始发现设备').onClick(() => this.startDiscovering())
        Button('查询可信设备').onClick(() => this.queryTrustedDevices())
      }.margin({ top: 20, bottom: 10 })

      // 发现的设备列表
      Text('发现的设备:').fontSize(18).margin({ top: 10, bottom: 5 })
      List({ space: 5 }) {
        ForEach(this.discoveredDevices, (device: distributedDeviceManager.DeviceBasicInfo) => {
          ListItem() {
            Row() {
              Text(device.deviceName).fontSize(16)
              Text(device.deviceId.substr(0, 8) + '...').fontSize(14).margin({ left: 10 })
              Button('绑定').onClick(() => this.bindDevice(device.deviceId))
                .margin({ left: 'auto' }).width(80)
            }.padding(10).backgroundColor('#F0F0F0')
          }
        })
      }

      // 可信设备列表
      Text('可信设备:').fontSize(18).margin({ top: 20, bottom: 5 })
      List({ space: 5 }) {
        ForEach(this.trustedDevices, (device: distributedDeviceManager.DeviceBasicInfo) => {
          ListItem() {
            Row() {
              Text(device.deviceName).fontSize(16)
              Text(device.deviceId.substr(0, 8) + '...').fontSize(14).margin({ left: 10 })
              Button('控制').onClick(() => this.sendDataToDevice(device.deviceId))
                .margin({ left: 'auto' }).width(80)
            }.padding(10).backgroundColor('#E0F0FF')
          }
        })
      }
    }.padding(20).width('100%')
  }
}

记得配置分布式同步权限

 "requestPermissions": [
      {
        "name": "ohos.permission.DISTRIBUTED_DATASYNC",
        "reason": "$string:app_name",
        "usedScene": {
          "abilities": [
            "EntryAbility"
          ],
          "when":"inuse"
        }
      }
    ]

更多关于HarmonyOS鸿蒙Next应用如何实现分布式协同应用开发？的实战系列教程也可以访问 https://www.itying.com/category-93-b0.html


鸿蒙Next分布式协同开发基于分布式软总线、数据管理和任务调度框架实现。应用通过Ability组件跨设备迁移，使用分布式数据对象实现数据同步，依托分布式任务调度统一管理跨设备任务流。开发时需声明分布式权限，调用对应API实现设备发现、连接和数据交换。

HarmonyOS Next分布式协同应用开发

HarmonyOS Next的分布式协同应用开发主要基于其核心的分布式技术，通过以下几个关键机制实现：

1. 分布式软总线

为设备间提供统一的通信基座，实现自动发现、高速直连和低时延数据传输，屏蔽了物理硬件的差异。

2. 分布式数据管理

通过分布式数据库和分布式文件系统，允许应用直接访问跨设备数据，如同操作本地数据，数据一致性由系统自动同步保障。

3. 分布式设备虚拟化

将多个设备的硬件能力（如摄像头、屏幕、传感器）虚拟化为一个“超级设备”的资源池，应用可像调用本地能力一样调用远端设备能力。

实现流程通常包括：

  • 能力开放与发现：在应用配置文件中声明所需或可提供的分布式能力（如服务、数据、硬件能力）。
  • 设备协同匹配：系统基于设备状态、网络和用户意图，自动发现并推荐可协同的设备。
  • 建立安全连接：通过分布式软总线建立设备间安全通道，进行身份验证与加密通信。
  • 业务逻辑分发与执行：将应用任务或界面组件拆分，在合适的设备上执行（如手机计算、平板显示、手表感应）。
  • 状态同步：通过分布式数据管理保持多设备间应用状态的一致性。

开发关键API与框架涉及：

  • DistributedDeviceManager：用于设备发现、连接与管理。
  • DistributedData 相关API：用于跨设备数据访问与同步。
  • RPC（远程过程调用）机制：用于跨设备服务调用。
  • Ability 的分布式迁移能力：支持Ability（应用组件）在设备间无缝迁移与接续。

通过以上技术，开发者可以构建一次开发、多端部署，并能灵活组合多设备硬件能力的协同应用。

回到顶部