HarmonyOS开发中分布式场景设备管理与服务发现

DeviceManager是HarmonyOS分布式能力的"设备管家"，它负责设备的注册、发现、状态管理和服务发布。如果把分布式软总线比作"通信管道"，那DeviceManager就是管道上的"调度中心"，决定哪些设备可以接入、哪些服务可以被发现。这篇文章带你深入理解DeviceManager的核心机制。

一、背景与动机：为什么需要DeviceManager？

1.1 设备管理的复杂性

在分布式场景下，设备管理面临诸多挑战：

设备多样性：手机、平板、手表、电视、音箱、冰箱……不同设备的性能、能力、网络环境千差万别。如何统一管理这些"性格迥异"的设备？

服务碎片化：每个设备提供的服务各不相同——手机有摄像头、手表有心率传感器、电视有大屏幕。如何让这些服务被发现和调用？

状态动态性：设备随时可能上线、下线、休眠、唤醒。如何实时感知设备状态变化，保证服务可用性？

安全敏感性：不是所有设备都应该被信任，不是所有服务都应该被访问。如何实现细粒度的权限控制？

1.2 DeviceManager的定位

DeviceManager作为分布式设备管理的核心组件，承担以下职责：

核心能力矩阵：

二、核心原理：DeviceManager如何工作？

2.1 设备信息模型

DeviceManager维护了完整的设备信息模型，包括设备基础信息、能力信息、服务信息等。

2.1.1 设备信息结构

// 设备信息完整定义
interface DeviceInfo {
  // 基础信息
  deviceId: string;           // 设备唯一标识（64字符以内）
  deviceName: string;         // 设备名称
  deviceType: DeviceType;     // 设备类型
  networkId: string;          // 网络标识
  
  // 能力信息
  capability: string[];       // 设备能力列表
  capabilityRange: number;    // 能力范围
  
  // 认证信息
  authForm: AuthForm;         // 认证形式
  trustLevel: TrustLevel;     // 信任等级
  
  // 状态信息
  state: DeviceState;         // 设备状态
  lastOnlineTime: number;     // 最后在线时间
  
  // 扩展信息
  extraInfo: Map<string, string>;  // 自定义扩展信息
}

// 设备类型枚举
enum DeviceType {
  UNKNOWN = 0,        // 未知设备
  PHONE = 0x11,       // 手机
  TABLET = 0x12,      // 平板
  WATCH = 0x13,       // 手表
  TV = 0x14,          // 电视
  CAR = 0x15,         // 车机
  PC = 0x16,          // PC
  SPEAKER = 0x17,     // 音箱
  REFRIGERATOR = 0x18,// 冰箱
  AIR_CONDITIONER = 0x19  // 空调
}

// 设备状态枚举
enum DeviceState {
  OFFLINE = 0,        // 离线
  ONLINE = 1,         // 在线
  READY = 2           // 就绪（可提供服务）
}

// 认证形式枚举
enum AuthForm {
  INVALID_TYPE = 0,   // 无效
  ACROSS_ACCOUNT = 1, // 跨账号认证
  SAME_ACCOUNT = 2,   // 同账号认证
  NO_AUTH = 3         // 无需认证
}

// 信任等级枚举
enum TrustLevel {
  TRUST_LEVEL_INVALID = 0,   // 无效
  TRUST_LEVEL_LOW = 1,       // 低信任
  TRUST_LEVEL_MEDIUM = 2,    // 中信任
  TRUST_LEVEL_HIGH = 3       // 高信任
}

2.1.2 设备能力定义

设备能力采用位图方式定义，支持灵活组合：

// 设备能力定义
const DeviceCapability = {
  // 输入能力
  INPUT_KEYBOARD: 0x0001,      // 键盘
  INPUT_MOUSE: 0x0002,         // 鼠标
  INPUT_TOUCH: 0x0004,         // 触摸屏
  INPUT_VOICE: 0x0008,         // 语音输入
  
  // 输出能力
  OUTPUT_DISPLAY: 0x0010,      // 显示屏
  OUTPUT_SPEAKER: 0x0020,      // 扬声器
  OUTPUT_VIBRATE: 0x0040,      // 振动
  
  // 传感器能力
  SENSOR_CAMERA: 0x0100,       // 摄像头
  SENSOR_MICROPHONE: 0x0200,   // 麦克风
  SENSOR_GPS: 0x0400,          // GPS
  SENSOR_HEARTRATE: 0x0800,    // 心率传感器
  
  // 计算能力
  COMPUTE_STRONG: 0x1000,      // 强计算能力
  COMPUTE_WEAK: 0x2000,        // 弱计算能力
};

// 能力判断函数
function hasCapability(device: DeviceInfo, capability: number): boolean {
  return (device.capabilityRange & capability) === capability;
}

// 示例：判断设备是否有摄像头
const hasCamera = hasCapability(device, DeviceCapability.SENSOR_CAMERA);

2.2 设备发现机制

DeviceManager提供多层次的设备发现能力。

2.2.1 发现流程

sequenceDiagram
    participant App as 应用
    participant DM as DeviceManager
    participant Local as 本地设备缓存
    participant Network as 网络发现服务
    participant Remote as 远程设备
    
    Note over App: 1. 发起设备发现请求
    App->>DM: startDeviceDiscovery(filter)
    
    Note over DM: 2. 查询本地缓存
    DM->>Local: queryCachedDevices()
    Local-->>DM: cachedDevices[]
    DM-->>App: onDeviceFound(cachedDevices)
    
    Note over DM: 3. 启动网络发现
    DM->>Network: startNetworkDiscovery()
    Network->>Remote: 广播发现请求
    
    Note over Remote: 4. 远程设备响应
    Remote-->>Network: 发送设备信息
    Network-->>DM: onDeviceDiscovered()
    
    Note over DM: 5. 更新缓存并通知
    DM->>Local: updateCache(newDevice)
    DM-->>App: onDeviceFound(newDevice)
    
    Note over App: 6. 停止发现
    App->>DM: stopDeviceDiscovery()
    DM->>Network: stopNetworkDiscovery()
    
    classDef primary fill:#4A90E2,stroke:#2E5C8A,stroke-width:2px,color:#fff
    classDef warning fill:#F5A623,stroke:#C17A00,stroke-width:2px,color:#fff
    classDef info fill:#7ED321,stroke:#5BA315,stroke-width:2px,color:#fff
    
    class App,DM primary
    class Local,Network warning
    class Remote info

2.2.2 发现过滤器

DeviceManager支持丰富的过滤条件，精准发现目标设备：

// 设备发现过滤器
interface DiscoveryFilter {
  // 设备类型过滤
  deviceTypes?: DeviceType[];
  
  // 能力过滤
  capabilities?: number[];
  
  // 认证形式过滤
  authForms?: AuthForm[];
  
  // 信任等级过滤
  trustLevel?: TrustLevel;
  
  // 自定义过滤函数
  customFilter?: (device: DeviceInfo) => boolean;
}

// 示例：发现所有有摄像头的设备
const cameraFilter: DiscoveryFilter = {
  capabilities: [DeviceCapability.SENSOR_CAMERA],
  trustLevel: TrustLevel.TRUST_LEVEL_MEDIUM
};

2.3 服务发布与发现

除了设备发现，DeviceManager还支持服务级别的发现。

2.3.1 服务信息模型

// 服务信息定义
interface ServiceInfo {
  serviceId: string;          // 服务唯一标识
  serviceName: string;        // 服务名称
  serviceType: string;        // 服务类型
  deviceId: string;           // 提供服务的设备ID
  
  // 服务属性
  properties: Map<string, string | number | boolean>;
  
  // 服务能力
  capabilities: string[];
  
  // 服务状态
  state: ServiceState;
}

// 服务状态枚举
enum ServiceState {
  UNAVAILABLE = 0,   // 不可用
  AVAILABLE = 1,     // 可用
  BUSY = 2           // 繁忙
}

2.3.2 服务发布流程

graph LR
    A[服务实现] --> B[创建服务信息]
    B --> C[发布服务]
    C --> D[服务注册]
    D --> E[广播通知]
    E --> F[服务可被发现]
    
    classDef primary fill:#4A90E2,stroke:#2E5C8A,stroke-width:2px,color:#fff
    classDef success fill:#7ED321,stroke:#5BA315,stroke-width:2px,color:#fff
    
    class A,B,C,D primary
    class E,F success

三、代码实战：DeviceManager使用

3.1 设备发现实战

import deviceManager from '@ohos.distributedHardware.deviceManager';

/**
 * DeviceManager设备发现封装
 * 提供便捷的设备发现能力
 */
export class DeviceDiscoveryService {
  private dmInstance: deviceManager.DeviceManager | null = null;
  private subscribeId: string = '';
  private deviceList: DeviceInfo[] = [];
  private listeners: Set<(devices: DeviceInfo[]) => void> = new Set();
  
  /**
   * 初始化DeviceManager
   */
  async initialize(bundleName: string): Promise<void> {
    try {
      // 创建DeviceManager实例
      this.dmInstance = deviceManager.createDeviceManager(bundleName);
      
      // 注册设备状态变化监听
      this.dmInstance.on('deviceStateChange', (data) => {
        this.handleDeviceStateChange(data);
      });
      
      console.info('[DeviceManager] 初始化成功');
    } catch (error) {
      console.error(`[DeviceManager] 初始化失败: ${JSON.stringify(error)}`);
      throw error;
    }
  }
  
  /**
   * 开始设备发现
   * @param filter 发现过滤器
   */
  async startDiscovery(filter?: DiscoveryFilter): Promise<void> {
    if (!this.dmInstance) {
      throw new Error('DeviceManager未初始化');
    }
    
    // 生成订阅ID
    this.subscribeId = Math.random().toString(36).substring(2, 10);
    
    // 构建发现参数
    const discoverParam: deviceManager.SubscribeDiscoverInfo = {
      subscribeId: this.subscribeId,
      mode: deviceManager.DISCOVER_MODE_ACTIVE,
      medium: deviceManager.DISCOVER_MEDIUM_AUTO,
      freq: deviceManager.DISCOVER_FREQ_MID,
      isSameAccount: false,
      isWakeRemote: true,
      capability: filter?.capabilities?.join(',') || ''
    };
    
    // 构建过滤参数
    const filterParam: deviceManager.DiscoverFilter = {
      subscribeId: this.subscribeId,
      mode: deviceManager.DISCOVER_MODE_ACTIVE,
      medium: deviceManager.DISCOVER_MEDIUM_AUTO,
      freq: deviceManager.DISCOVER_FREQ_MID,
      isSameAccount: false,
      isWakeRemote: true
    };
    
    // 注册设备发现回调
    this.dmInstance.on('deviceFound', (data) => {
      if (data.subscribeId === this.subscribeId) {
        this.handleDeviceFound(data.device);
      }
    });
    
    // 注册设备丢失回调
    this.dmInstance.on('deviceLost', (data) => {
      if (data.subscribeId === this.subscribeId) {
        this.handleDeviceLost(data.deviceId);
      }
    });
    
    // 开始发现
    await this.dmInstance.startDeviceDiscovery(discoverParam);
    console.info(`[DeviceManager] 开始设备发现，订阅ID: ${this.subscribeId}`);
  }
  
  /**
   * 停止设备发现
   */
  async stopDiscovery(): Promise<void> {
    if (!this.dmInstance || !this.subscribeId) {
      return;
    }
    
    try {
      await this.dmInstance.stopDeviceDiscovery(this.subscribeId);
      this.dmInstance.off('deviceFound');
      this.dmInstance.off('deviceLost');
      console.info('[DeviceManager] 停止设备发现');
    } catch (error) {
      console.error(`[DeviceManager] 停止发现失败: ${JSON.stringify(error)}`);
    }
  }
  
  /**
   * 处理设备发现
   */
  private handleDeviceFound(device: DeviceInfo): void {
    // 检查是否已存在
    const index = this.deviceList.findIndex(d => d.deviceId === device.deviceId);
    
    if (index >= 0) {
      // 更新设备信息
      this.deviceList[index] = device;
    } else {
      // 添加新设备
      this.deviceList.push(device);
    }
    
    // 通知监听器
    this.notifyListeners();
    
    console.info(`[DeviceManager] 发现设备: ${device.deviceName} (${device.deviceId})`);
  }
  
  /**
   * 处理设备丢失
   */
  private handleDeviceLost(deviceId: string): void {
    const index = this.deviceList.findIndex(d => d.deviceId === deviceId);
    
    if (index >= 0) {
      this.deviceList.splice(index, 1);
      this.notifyListeners();
      console.info(`[DeviceManager] 设备离线: ${deviceId}`);
    }
  }
  
  /**
   * 处理设备状态变化
   */
  private handleDeviceStateChange(data: deviceManager.DeviceStateChangeInfo): void {
    const { deviceId, state } = data;
    const device = this.deviceList.find(d => d.deviceId === deviceId);
    
    if (device) {
      device.state = state;
      this.notifyListeners();
      console.info(`[DeviceManager] 设备状态变化: ${deviceId} -> ${state}`);
    }
  }
  
  /**
   * 添加设备列表监听器
   */
  addListener(listener: (devices: DeviceInfo[]) => void): void {
    this.listeners.add(listener);
    // 立即通知当前设备列表
    listener(this.deviceList);
  }
  
  /**
   * 移除设备列表监听器
   */
  removeListener(listener: (devices: DeviceInfo[]) => void): void {
    this.listeners.delete(listener);
  }
  
  /**
   * 通知所有监听器
   */
  private notifyListeners(): void {
    this.listeners.forEach(listener => {
      listener([...this.deviceList]);
    });
  }
  
  /**
   * 获取设备列表
   */
  getDeviceList(): DeviceInfo[] {
    return [...this.deviceList];
  }
  
  /**
   * 根据ID获取设备
   */
  getDeviceById(deviceId: string): DeviceInfo | undefined {
    return this.deviceList.find(d => d.deviceId === deviceId);
  }
  
  /**
   * 根据类型获取设备列表
   */
  getDevicesByType(deviceType: DeviceType): DeviceInfo[] {
    return this.deviceList.filter(d => d.deviceType === deviceType);
  }
  
  /**
   * 释放资源
   */
  release(): void {
    this.stopDiscovery();
    if (this.dmInstance) {
      this.dmInstance.off('deviceStateChange');
      this.dmInstance = null;
    }
    this.deviceList = [];
    this.listeners.clear();
  }
}

3.2 服务发布与发现实战

import deviceManager from '@ohos.distributedHardware.deviceManager';

/**
 * 服务发布管理器
 * 管理本地服务的发布与发现
 */
export class ServicePublishManager {
  private dmInstance: deviceManager.DeviceManager | null = null;
  private publishedServices: Map<string, ServiceInfo> = new Map();
  
  /**
   * 初始化
   */
  async initialize(bundleName: string): Promise<void> {
    this.dmInstance = deviceManager.createDeviceManager(bundleName);
    console.info('[ServicePublish] 初始化成功');
  }
  
  /**
   * 发布服务
   * @param serviceInfo 服务信息
   */
  async publishService(serviceInfo: ServiceInfo): Promise<void> {
    if (!this.dmInstance) {
      throw new Error('DeviceManager未初始化');
    }
    
    try {
      // 发布服务到DeviceManager
      await this.dmInstance.publishService({
        serviceId: serviceInfo.serviceId,
        serviceName: serviceInfo.serviceName,
        serviceType: serviceInfo.serviceType,
        properties: Object.fromEntries(serviceInfo.properties),
        capabilities: serviceInfo.capabilities
      });
      
      // 保存已发布的服务
      this.publishedServices.set(serviceInfo.serviceId, serviceInfo);
      
      console.info(`[ServicePublish] 服务发布成功: ${serviceInfo.serviceName}`);
    } catch (error) {
      console.error(`[ServicePublish] 服务发布失败: ${JSON.stringify(error)}`);
      throw error;
    }
  }
  
  /**
   * 取消发布服务
   */
  async unpublishService(serviceId: string): Promise<void> {
    if (!this.dmInstance) {
      return;
    }
    
    try {
      await this.dmInstance.unpublishService(serviceId);
      this.publishedServices.delete(serviceId);
      console.info(`[ServicePublish] 服务已取消发布: ${serviceId}`);
    } catch (error) {
      console.error(`[ServicePublish] 取消发布失败: ${JSON.stringify(error)}`);
    }
  }
  
  /**
   * 发现服务
   * @param serviceType 服务类型
   * @param callback 发现回调
   */
  async discoverServices(
    serviceType: string,
    callback: (services: ServiceInfo[]) => void
  ): Promise<string> {
    if (!this.dmInstance) {
      throw new Error('DeviceManager未初始化');
    }
    
    const subscribeId = Math.random().toString(36).substring(2, 10);
    
    // 注册服务发现回调
    this.dmInstance.on('serviceDiscover', (data) => {
      if (data.serviceType === serviceType) {
        callback(data.services);
      }
    });
    
    // 开始服务发现
    await this.dmInstance.discoverService({
      subscribeId: subscribeId,
      serviceType: serviceType
    });
    
    console.info(`[ServicePublish] 开始发现服务: ${serviceType}`);
    return subscribeId;
  }
  
  /**
   * 停止服务发现
   */
  async stopDiscoverServices(subscribeId: string): Promise<void> {
    if (!this.dmInstance) {
      return;
    }
    
    await this.dmInstance.stopDiscoverService(subscribeId);
    this.dmInstance.off('serviceDiscover');
    console.info('[ServicePublish] 停止服务发现');
  }
  
  /**
   * 获取已发布的服务列表
   */
  getPublishedServices(): ServiceInfo[] {
    return Array.from(this.publishedServices.values());
  }
  
  /**
   * 释放资源
   */
  release(): void {
    // 取消所有已发布的服务
    this.publishedServices.forEach((_, serviceId) => {
      this.unpublishService(serviceId);
    });
    
    if (this.dmInstance) {
      this.dmInstance.off('serviceDiscover');
      this.dmInstance = null;
    }
  }
}

3.3 设备能力查询实战

import deviceManager from '@ohos.distributedHardware.deviceManager';

/**
 * 设备能力查询器
 * 提供设备能力检查与匹配能力
 */
export class DeviceCapabilityChecker {
  private dmInstance: deviceManager.DeviceManager | null = null;
  
  /**
   * 初始化
   */
  async initialize(bundleName: string): Promise<void> {
    this.dmInstance = deviceManager.createDeviceManager(bundleName);
  }
  
  /**
   * 检查设备是否有指定能力
   * @param deviceId 设备ID
   * @param capability 能力标识
   */
  async hasCapability(deviceId: string, capability: number): Promise<boolean> {
    if (!this.dmInstance) {
      return false;
    }
    
    try {
      // 获取设备能力范围
      const device = await this.dmInstance.getDeviceInfo(deviceId);
      return (device.capabilityRange & capability) === capability;
    } catch (error) {
      console.error(`[CapabilityCheck] 查询失败: ${JSON.stringify(error)}`);
      return false;
    }
  }
  
  /**
   * 获取设备所有能力
   */
  async getCapabilities(deviceId: string): Promise<string[]> {
    if (!this.dmInstance) {
      return [];
    }
    
    try {
      const device = await this.dmInstance.getDeviceInfo(deviceId);
      const capabilities: string[] = [];
      
      // 解析能力位图
      const capabilityMap = {
        [DeviceCapability.INPUT_KEYBOARD]: '键盘输入',
        [DeviceCapability.INPUT_MOUSE]: '鼠标输入',
        [DeviceCapability.INPUT_TOUCH]: '触摸输入',
        [DeviceCapability.INPUT_VOICE]: '语音输入',
        [DeviceCapability.OUTPUT_DISPLAY]: '显示输出',
        [DeviceCapability.OUTPUT_SPEAKER]: '音频输出',
        [DeviceCapability.SENSOR_CAMERA]: '摄像头',
        [DeviceCapability.SENSOR_MICROPHONE]: '麦克风',
        [DeviceCapability.SENSOR_GPS]: 'GPS定位',
        [DeviceCapability.SENSOR_HEARTRATE]: '心率传感器'
      };
      
      for (const [cap, name] of Object.entries(capabilityMap)) {
        if ((device.capabilityRange & parseInt(cap)) === parseInt(cap)) {
          capabilities.push(name);
        }
      }
      
      return capabilities;
    } catch (error) {
      console.error(`[CapabilityCheck] 获取能力失败: ${JSON.stringify(error)}`);
      return [];
    }
  }
  
  /**
   * 查找具有指定能力的设备
   */
  async findDevicesWithCapability(capability: number): Promise<DeviceInfo[]> {
    if (!this.dmInstance) {
      return [];
    }
    
    try {
      // 获取所有在线设备
      const devices = await this.dmInstance.getTrustedDeviceList(true);
      
      // 过滤出具有指定能力的设备
      return devices.filter(device => 
        (device.capabilityRange & capability) === capability
      );
    } catch (error) {
      console.error(`[CapabilityCheck] 查找设备失败: ${JSON.stringify(error)}`);
      return [];
    }
  }
  
  /**
   * 获取设备能力评分（用于设备选择）
   */
  async getCapabilityScore(deviceId: string, requiredCapabilities: number[]): Promise<number> {
    if (!this.dmInstance) {
      return 0;
    }
    
    try {
      const device = await this.dmInstance.getDeviceInfo(deviceId);
      let score = 0;
      
      for (const cap of requiredCapabilities) {
        if ((device.capabilityRange & cap) === cap) {
          score += 1;
        }
      }
      
      // 归一化评分
      return score / requiredCapabilities.length;
    } catch (error) {
      console.error(`[CapabilityCheck] 计算评分失败: ${JSON.stringify(error)}`);
      return 0;
    }
  }
  
  /**
   * 选择最佳设备（基于能力匹配）
   */
  async selectBestDevice(requiredCapabilities: number[]): Promise<DeviceInfo | null> {
    if (!this.dmInstance) {
      return null;
    }
    
    try {
      const devices = await this.dmInstance.getTrustedDeviceList(true);
      
      // 计算每个设备的评分
      const scoredDevices = await Promise.all(
        devices.map(async device => ({
          device,
          score: await this.getCapabilityScore(device.deviceId, requiredCapabilities)
        }))
      );
      
      // 按评分排序
      scoredDevices.sort((a, b) => b.score - a.score);
      
      // 返回评分最高的设备
      return scoredDevices[0]?.device || null;
    } catch (error) {
      console.error(`[CapabilityCheck] 选择设备失败: ${JSON.stringify(error)}`);
      return null;
    }
  }
}

四、踩坑与注意事项

4.1 初始化相关

坑1：重复初始化

// ❌ 错误做法：多次创建DeviceManager实例
const dm1 = deviceManager.createDeviceManager('com.example.app');
const dm2 = deviceManager.createDeviceManager('com.example.app');  // 可能导致资源冲突

// ✅ 正确做法：单例模式管理
class DeviceManagerSingleton {
  private static instance: deviceManager.DeviceManager | null = null;
  
  static getInstance(bundleName: string): deviceManager.DeviceManager {
    if (!this.instance) {
      this.instance = deviceManager.createDeviceManager(bundleName);
    }
    return this.instance;
  }
}

坑2：权限缺失

// 在module.json5中必须声明以下权限
{
  "requestPermissions": [
    {
      "name": "ohos.permission.DISTRIBUTED_DATASYNC",
      "reason": "需要访问分布式设备"
    },
    {
      "name": "ohos.permission.ACCESS_BLUETOOTH",
      "reason": "需要使用蓝牙发现设备"
    },
    {
      "name": "ohos.permission.LOCATION",
      "reason": "需要位置权限用于Wi-Fi发现"
    }
  ]
}

4.2 设备发现相关

坑3：忘记停止发现

设备发现是耗电操作，忘记停止会导致电量消耗。

// ✅ 正确做法：在合适的时机停止发现
@Component
struct DeviceListPage {
  private discoveryService: DeviceDiscoveryService = new DeviceDiscoveryService();
  
  aboutToAppear(): void {
    this.discoveryService.startDiscovery();
  }
  
  aboutToDisappear(): void {
    // 页面销毁时停止发现
    this.discoveryService.stopDiscovery();
  }
}

坑4：设备信息过期

设备信息可能过期，需要定期刷新。

// ✅ 正确做法：定期刷新设备信息
async refreshDeviceInfo(deviceId: string): Promise<DeviceInfo> {
  // 从DeviceManager获取最新信息
  const latestInfo = await this.dmInstance.getDeviceInfo(deviceId);
  
  // 更新本地缓存
  this.updateLocalCache(latestInfo);
  
  return latestInfo;
}

4.3 服务发布相关

坑5：服务ID冲突

不同应用发布的服务ID可能冲突。

// ✅ 正确做法：使用应用包名作为服务ID前缀
const serviceId = `${bundleName}.${serviceName}`;
// 例如：com.example.app.camera-service

坑6：服务未取消发布

应用退出时未取消发布的服务会残留。

// ✅ 正确做法：在应用退出时取消所有服务
aboutToDisappear(): void {
  this.publishedServices.forEach((_, serviceId) => {
    this.dmInstance.unpublishService(serviceId);
  });
}

五、HarmonyOS 6适配指南

5.1 API变更

DeviceManager创建方式变更：

// HarmonyOS 5.0
import deviceManager from '@ohos.distributedHardware.deviceManager';
const dm = deviceManager.createDeviceManager('bundleName');

// HarmonyOS 6.0
import { DeviceManager } from '@ohos.distributedHardware.deviceManager';
const dm = DeviceManager.getInstance();

设备发现API变更：

// HarmonyOS 5.0
dm.startDeviceDiscovery({
  subscribeId: '123',
  mode: deviceManager.DISCOVER_MODE_ACTIVE
});

// HarmonyOS 6.0
import { DiscoveryOption, DiscoveryMode } from '@ohos.distributedHardware.deviceManager';
await dm.startDiscovery({
  option: DiscoveryOption.ACTIVE,
  filter: {
    deviceTypes: [DeviceType.PHONE, DeviceType.TABLET]
  }
});

5.2 行为变更

变更1：设备状态通知增强

HarmonyOS 6新增了更细粒度的设备状态通知。

// HarmonyOS 6新增状态类型
dm.on('deviceStateChange', (info) => {
  switch (info.state) {
    case DeviceState.OFFLINE:
      // 设备离线
      break;
    case DeviceState.ONLINE:
      // 设备在线
      break;
    case DeviceState.READY:
      // 设备就绪（可提供服务）
      break;
    case DeviceState.SLEEP:  // HarmonyOS 6新增
      // 设备休眠
      break;
    case DeviceState.AWAKE:  // HarmonyOS 6新增
      // 设备唤醒
      break;
  }
});

变更2：服务发现支持异步查询

// HarmonyOS 6新增异步查询接口
const services = await dm.queryServices({
  serviceType: 'camera',
  state: ServiceState.AVAILABLE
});

变更3：设备能力查询增强

// HarmonyOS 6新增能力查询接口
const capabilities = await dm.queryDeviceCapabilities(deviceId);
// 返回详细的能力信息，包括能力状态、能力参数等

5.3 兼容性适配代码

/**
 * DeviceManager兼容层
 */
export class DeviceManagerCompat {
  private instance: any = null;
  private apiLevel: number = 6;
  
  async initialize(): Promise<void> {
    this.apiLevel = this.detectApiLevel();
    
    if (this.apiLevel >= 6) {
      const { DeviceManager } = require('@ohos.distributedHardware.deviceManager');
      this.instance = DeviceManager.getInstance();
    } else {
      const deviceManager = require('@ohos.distributedHardware.deviceManager');
      this.instance = deviceManager.createDeviceManager('bundleName');
    }
  }
  
  async startDiscovery(filter?: any): Promise<string> {
    if (this.apiLevel >= 6) {
      return await this.instance.startDiscovery({
        option: 'ACTIVE',
        filter: filter
      });
    } else {
      const subscribeId = Math.random().toString(36).substring(2, 10);
      await this.instance.startDeviceDiscovery({
        subscribeId: subscribeId,
        mode: 'DISCOVER_MODE_ACTIVE'
      });
      return subscribeId;
    }
  }
  
  private detectApiLevel(): number {
    try {
      require('@ohos.distributedHardware.deviceManager').DeviceManager;
      return 6;
    } catch {
      return 5;
    }
  }
}

六、总结

DeviceManager是HarmonyOS分布式能力的核心组件，它将设备管理、服务发现、能力查询等能力统一封装，为上层应用提供简洁易用的API。

核心要点回顾：

1. 设备信息模型：完整的设备信息结构，包括基础信息、能力信息、认证信息
2. 设备发现机制：多层次发现能力，支持丰富的过滤条件
3. 服务发布发现：服务级别的发现与调用能力
4. 能力查询：基于位图的能力定义，支持灵活组合

最佳实践建议：

• 使用单例模式管理DeviceManager实例
• 在合适的时机停止设备发现，节省电量
• 定期刷新设备信息，避免使用过期数据
• 使用应用包名作为服务ID前缀，避免冲突
• 应用退出时取消所有已发布的服务
• 使用兼容层适配多版本API

DeviceManager让设备管理变得简单而强大，是构建分布式应用的基础设施。