鸿蒙超级终端多设备协同开发指南

2. 分布式数据管理应用

// entry/src/main/ets/services/SearchService.ets（修改）

import { DistributedDataManager } from '../utils/DistributedDataManager';

// 搜索服务
export class SearchService {
    // ...

    // 保存搜索记录
    async saveSearchHistory(keyword: string): Promise<void> {
        const history = await this.getSearchHistory();
        const index = history.findIndex(item => item === keyword);
        if (index !== -1) {
            history.splice(index, 1);
        }
        history.unshift(keyword);
        if (history.length > 10) {
            history.splice(10);
        }
        await DistributedDataManager.getInstance().saveData('searchHistory', history);
    }

    // 获取搜索记录
    async getSearchHistory(): Promise<Array<string>> {
        const history = await DistributedDataManager.getInstance().getData('searchHistory');
        return history || [];
    }

    // 删除搜索记录
    async deleteSearchHistory(keyword: string): Promise<void> {
        const history = await this.getSearchHistory();
        const index = history.findIndex(item => item === keyword);
        if (index !== -1) {
            history.splice(index, 1);
            await DistributedDataManager.getInstance().saveData('searchHistory', history);
        }
    }

    // 清空搜索记录
    async clearSearchHistory(): Promise<void> {
        await DistributedDataManager.getInstance().deleteData('searchHistory');
    }
}

// entry/src/main/ets/services/CartService.ets（修改）

import { DistributedDataManager } from '../utils/DistributedDataManager';

// 购物车服务
export class CartService {
    // ...

    // 添加商品到购物车
    async addToCart(productId: number, count: number): Promise<void> {
        const cartItems = await this.getCartItems();
        const index = cartItems.findIndex(item => item.productId === productId);
        if (index !== -1) {
            cartItems[index].count += count;
        } else {
            const product = goodsData.find(item => item.id === productId);
            if (product) {
                cartItems.push({ id: productId, productId, name: product.name, imageUrl: product.imageUrl, price: product.price, count, isChecked: false });
            }
        }
        await this.saveCartItems(cartItems);
        // 同步到分布式数据管理
        await DistributedDataManager.getInstance().saveData('cartItems', cartItems);
    }

    // 获取购物车商品
    async getCartItems(): Promise<Array<CartItemModel>> {
        // 先从分布式数据管理获取
        const remoteData = await DistributedDataManager.getInstance().getData('cartItems');
        if (remoteData) {
            return remoteData;
        }
        // 分布式数据管理无数据，从本地数据库获取
        const localData = await this.getCartItemsFromLocal();
        return localData;
    }

    // 删除购物车商品
    async deleteCartItem(id: number): Promise<void> {
        const cartItems = await this.getCartItems();
        const index = cartItems.findIndex(item => item.id === id);
        if (index !== -1) {
            cartItems.splice(index, 1);
            await this.saveCartItems(cartItems);
            // 同步到分布式数据管理
            await DistributedDataManager.getInstance().saveData('cartItems', cartItems);
        }
    }

    // 清空购物车
    async clearCart(): Promise<void> {
        await this.saveCartItems([]);
        // 同步到分布式数据管理
        await DistributedDataManager.getInstance().saveData('cartItems', []);
    }
}

2.4 分布式通信实现

1. 分布式通信工具类

// entry/src/main/ets/utils/DistributedCommunicationManager.ets

import communication from '@ohos.comm';
import { UIAbilityContext } from '@ohos.abilityAccessCtrl';

// 分布式通信工具类
export class DistributedCommunicationManager {
    private static instance: DistributedCommunicationManager | null = null;
    private communicationHelper: communication.CommunicationHelper | null = null;

    // 单例模式
    static getInstance(): DistributedCommunicationManager {
        if (!DistributedCommunicationManager.instance) {
            DistributedCommunicationManager.instance = new DistributedCommunicationManager();
        }
        return DistributedCommunicationManager.instance;
    }

    // 初始化分布式通信
    async init(context: UIAbilityContext): Promise<void> {
        if (!this.communicationHelper) {
            this.communicationHelper = communication.createCommunicationHelper(context);
        }
    }

    // 发现设备
    onDeviceFound(callback: (device: communication.DeviceInfo) => void): void {
        if (!this.communicationHelper) {
            return;
        }
        this.communicationHelper.on('deviceFound', (device: communication.DeviceInfo) => {
            callback(device);
        });
    }

    // 取消发现设备
    offDeviceFound(callback: (device: communication.DeviceInfo) => void): void {
        if (!this.communicationHelper) {
            return;
        }
        this.communicationHelper.off('deviceFound', callback);
    }

    // 连接设备
    async connectDevice(deviceId: string): Promise<boolean> {
        if (!this.communicationHelper) {
            return false;
        }
        const result = await this.communicationHelper.connect(deviceId);
        return result === communication.ConnectResult.SUCCESS;
    }

    // 断开设备连接
    async disconnectDevice(deviceId: string): Promise<boolean> {
        if (!this.communicationHelper) {
            return false;
        }
        const result = await this.communicationHelper.disconnect(deviceId);
        return result === communication.DisconnectResult.SUCCESS;
    }

    // 发送消息
    async sendMessage(deviceId: string, message: string): Promise<boolean> {
        if (!this.communicationHelper) {
            return false;
        }
        const result = await this.communicationHelper.sendMessage(deviceId, message);
        return result === communication.SendResult.SUCCESS;
    }

    // 接收消息
    onMessageReceived(callback: (deviceId: string, message: string) => void): void {
        if (!this.communicationHelper) {
            return;
        }
        this.communicationHelper.on('messageReceived', (deviceId: string, message: string) => {
            callback(deviceId, message);
        });
    }

    // 取消接收消息
    offMessageReceived(callback: (deviceId: string, message: string) => void): void {
        if (!this.communicationHelper) {
            return;
        }
        this.communicationHelper.off('messageReceived', callback);
    }
}

2. 分布式通信应用

// entry/src/main/ets/components/DeviceListComponent.ets

import { DistributedCommunicationManager } from '../utils/DistributedCommunicationManager';
import { communication } from '@ohos.comm';

@Component
export struct DeviceListComponent {
    @State deviceList: Array<communication.DeviceInfo> = [];
    @State connectedDeviceId: string = '';

    build() {
        Column({ space: 16 }) {
            Text('已连接设备').fontSize(18).fontWeight(FontWeight.Bold).textColor('#000000');
            List({ space: 16 }) {
                ForEach(this.deviceList, (device: communication.DeviceInfo) => {
                    ListItem() {
                        Row({ space: 16 }) {
                            Image(device.icon).width(40).height(40).objectFit(ImageFit.Contain);
                            Column({ space: 8 }) {
                                Text(device.name).fontSize(14).fontWeight(FontWeight.Bold).textColor('#000000');
                                Text(device.type).fontSize(14).textColor('#666666');
                            }.layoutWeight(1);
                            if (device.id === this.connectedDeviceId) {
                                Text('已连接').fontSize(14).textColor('#007DFF');
                            } else {
                                Button('连接').width(80).height(40).backgroundColor('#007DFF').onClick(async () => {
                                    const result = await DistributedCommunicationManager.getInstance().connectDevice(device.id);
                                    if (result) {
                                        this.connectedDeviceId = device.id;
                                    }
                                });
                            }
                        }.width('100%').height('auto').padding(16).backgroundColor('#FFFFFF').borderRadius(12);
                    }.width('100%').height('auto');
                }, (device: communication.DeviceInfo) => device.id);
            }.width('100%').height('auto').padding(16);
            Text('可连接设备').fontSize(18).fontWeight(FontWeight.Bold).textColor('#000000');
            List({ space: 16 }) {
                // 可连接设备列表
            }.width('100%').height('auto').padding(16);
        }.width('100%').height('100%').backgroundColor('#F5F5F5');
    }

    aboutToAppear() {
        // 监听设备发现
        DistributedCommunicationManager.getInstance().onDeviceFound((device: communication.DeviceInfo) => {
            this.deviceList.push(device);
        });
    }
}

三、项目配置与部署

3.1 配置文件修改

1. module.json5 修改

在 entry/src/main/module.json5 中添加分布式能力配置：

{
  "module": {
    "requestPermissions": [
      { "name": "ohos.permission.DISTRIBUTED_DATASYNC" },
      { "name": "ohos.permission.DISTRIBUTED_COMMUNICATION" },
      { "name": "ohos.permission.GET_NETWORK_INFO" },
      { "name": "ohos.permission.READ_EXTERNAL_STORAGE" },
      { "name": "ohos.permission.WRITE_EXTERNAL_STORAGE" }
    ],
    "abilities": [],
    "widgets": [],
    "pages": []
  }
}

3.2 项目部署

1. 编译项目

在 DevEco Studio 中点击 Build → Build HAP，编译项目。

2. 部署到设备

将编译后的 HAP 文件部署到鸿蒙设备上。

3. 测试多设备协同

• 在手机上打开应用，搜索商品，查看商品详情；
• 在平板上打开应用，查看购物车商品；
• 在智慧屏上打开应用，查看购物车商品。

四、项目运行与效果验证

4.1 效果验证

• 多设备协同：手机上搜索商品，平板上查看商品详情；
• 数据同步：购物车数据在多设备间同步；
• 设备发现：自动发现附近的鸿蒙设备；
• 设备连接：手动连接附近的鸿蒙设备。

五、总结与后续规划

5.1 总结

本文完成了：

• 超级终端多设备协同的定义与架构；
• 商品搜索与购物车两个核心业务场景的多设备协同实现；
• 分布式数据管理与分布式通信的原理与实现方式；
• 多设备协同的设备发现与连接。

5.2 后续学习路径

• 服务联邦跨服务无缝打通；
• 安全加固与组件化架构；
• AI 原生与用户增长；
• 性能优化与 Next 原生合规；
• 运维监控与生态运营。