一、前置思考

1.1 智能家居的痛点：设备会"单打独斗"

家里有 20 个智能设备：灯、空调、窗帘、门锁、摄像头、音箱……单看每个设备都能 App 控制，但体验的胜负手在"联动"：

❌ 现状1: 回家要手动点 5 个开关（灯、空调、窗帘、门锁、氛围灯）
❌ 现状2: 出门忘了关空调，App 里翻半天找不到
❌ 现状3: 设备间互相"不认识"，无法自动化
❌ 现状4: 断网后一切自动化全挂，智能变智障

真正的智能家居是：回家门锁一开，灯自动亮起、空调自动调温、窗帘自动拉开——全部本地自动化，断网也能跑。

1.2 鸿蒙智能家居的能力

HarmonyOS 智能家居方案以分布式软总线为核心，提供：

🔍 设备自动发现: 靠近即发现、免配对
📡 状态同步: 全屋设备状态单一数据源
🧩 场景引擎: "条件 → 动作" 规则组合
⚙️ 规则链自动化: 多条件多动作的复杂编排
🔄 多设备协作: 设备间直接通信，不依赖云端

1.3 本文价值

本文解析设备发现、状态同步、场景引擎、规则链、多设备编排的底层机制与完整实现，覆盖"从设备入网到自动化联动"的全链路。

二、核心原理

2.1 智能家居系统架构

┌─────────────────────────────────────────────┐
│          控制中枢 (手机 / 智慧屏)             │
│  ┌─────────┐  ┌─────────┐  ┌─────────┐     │
│  │ 设备发现 │  │ 场景引擎 │  │ 规则链   │     │
│  └─────────┘  └─────────┘  └─────────┘     │
├─────────────────────────────────────────────┤
│          分布式软总线 (设备互联)              │
│  设备发现 / 连接管理 / 消息路由 / 状态同步    │
├─────────────────────────────────────────────┤
│  ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐ ┌─────┐  │
│  │ 灯  │ │ 空调 │ │ 窗帘 │ │ 门锁 │ │ 音箱 │  │
│  └─────┘ └─────┘ └─────┘ └─────┘ └─────┘  │
└─────────────────────────────────────────────┘

2.2 设备自动发现机制

发现方式一: 靠近感知（BLE）
  → 手机靠近设备 1m 内，自动弹出"发现新设备"
  → 无需扫码/长按配对，靠近即发现

发现方式二: 组播发现（CoAP/UDP）
  → 控制中枢广播查询，设备组播响应
  → 适合全屋批量扫描

发现方式三: 云平台（跨网络）
  → 设备离线时通过云端桥接（弱网兜底）

2.3 场景引擎与规则链

场景 (Scenario): 一个"触发 → 动作"映射
  例: "回家" → { 开灯, 开空调 26°, 拉窗帘 }

规则链 (Rule Chain): 多条件多动作的自动化编排
  例: 温度 > 30° 且 人在家 且 白天
      → 开空调 + 关窗帘 + 播报"空调已开启"

规则链评估流程:
  事件进入 → 条件匹配（与/或组合）→ 动作执行（并发/顺序）→ 结果反馈

三、源码/API 深度解析

3.1 设备发现与连接

import { deviceManager } from '@kit.DistributedHardwareKit';

// 1. 发现设备
const discoverListener: deviceManager.IDeviceStateCallback = {
  onDeviceFound: (devices: deviceManager.DeviceInfo[]) => {
    for (const d of devices) {
      LoggerUtil.info(TAG, '发现设备: ' + d.deviceName + ' ' + d.deviceType);
      this.addDevice(d);
    }
  }
};
deviceManager.on('deviceFound', discoverListener);
deviceManager.startDeviceDiscovery({
  filterOptions: {
    availableStatus: 1,        // 只发现可用设备
    deviceType: [1, 4, 6]      // 灯/空调/窗帘等类型
  }
});

// 2. 订阅设备状态变化
deviceManager.on('deviceStateChange', (state: deviceManager.DeviceStateChange) => {
  // ONLINE / OFFLINE / CHANGE
  if (state.state === 0) { this.handleOffline(state.deviceInfo); }
});

3.2 状态同步（分布式数据对象）

import { distributedDataObject } from '@kit.ArkData';
import { common } from '@kit.AbilityKit';

// 全屋设备状态: 一个分布式对象，多设备共享
const options: distributedDataObject.CreateOptions = {
  sessionId: 'HOME_DEVICES'
};
const context: common.UIAbilityContext = getContext(this) as common.UIAbilityContext;
const obj = distributedDataObject.create(context, options);

obj.genSessionId();
const sessionId = obj.getSessionId();
obj.setSessionId(sessionId);

// 订阅其他设备对状态的修改
obj.on('change', (sessionId: string, changeData: distributedDataObject.ChangeData) => {
  if (changeData.type === 0) {  // 属性变更
    for (const k of changeData.attributes) {
      LoggerUtil.info(TAG, '设备状态变化: ' + k + ' = ' + obj[k]);
      this.refreshDevice(k);
    }
  }
});

// 修改状态（自动同步到所有设备）
obj['living_room_light'] = 'on';
obj['air_cond_temp'] = 26;

3.3 场景引擎实现

interface SceneRule {
  id: string;
  name: string;         // 场景名: 回家/离家/睡眠
  icon: string;
  triggers: Trigger[];  // 触发条件
  actions: Action[];    // 执行动作
  enabled: boolean;
}

// 场景执行
function executeScene(scene: SceneRule): void {
  if (!isTriggered(scene.triggers)) { return; }
  // 并发执行所有动作（设备间无依赖）
  for (const act of scene.actions) {
    sendDeviceCommand(act.device, act.command, act.param);
  }
  ToastUtil.success('场景已执行: ' + scene.name);
}

// 触发条件评估
function isTriggered(triggers: Trigger[]): boolean {
  // 条件组合: AND / OR
  let result = triggers.length > 0;
  for (const t of triggers) {
    const match = matchTrigger(t);
    result = t.logic === 'AND' ? (result && match) : (result || match);
  }
  return result;
}

3.4 规则链自动化（多条件编排）

interface RuleChain {
  id: string;
  name: string;
  // 条件组: 任意条件满足且非禁用时进入
  conditions: { sensor: string; op: string; value: number }[];
  // 动作组: 按顺序执行
  actions: { device: string; cmd: string; delay?: number }[];
  timeRange?: string;  // 生效时段
}

function evaluateRuleChain(chain: RuleChain, event: SensorEvent): boolean {
  // 时段过滤
  if (chain.timeRange && !inTimeRange(chain.timeRange)) { return false; }
  // 条件评估: 温度 > 30
  let pass = true;
  for (const c of chain.conditions) {
    const current = getSensorValue(c.sensor);
    if (!compare(current, c.op, c.value)) { pass = false; break; }
  }
  if (!pass) { return false; }
  // 顺序执行动作（可带延迟）
  for (const a of chain.actions) {
    if (a.delay) {
      setTimeout(() => sendDeviceCommand(a.device, a.cmd), a.delay);
    } else {
      sendDeviceCommand(a.device, a.cmd);
    }
  }
  return true;
}

四、企业级实战落地

4.1 智能家居开发清单

阶段	动作	验收
设备接入	设备发现 + 状态同步	设备秒级入网
场景配置	回家/离家/睡眠场景	一键触发正确
规则链	多条件自动化编排	条件触发准确
本地化	断网场景联动可用	断网 100% 可用
安全	设备认证 + 数据加密	未认证设备无法控制

4.2 完整示例：回家场景联动

@Entry
@ComponentV2
struct SmartHomeDemo {
  @Local devices: DeviceItem[] = [
    { name: '客厅灯', type: '灯', status: 'off', icon: '💡' },
    { name: '空调', type: '空调', status: 'off', icon: '❄️' },
    { name: '窗帘', type: '窗帘', status: 'closed', icon: '🪟' },
    { name: '智能门锁', type: '门锁', status: 'locked', icon: '🔒' }
  ];
  @Local sceneExecuted: string = '';

  // 回家场景: 门锁开 → 灯亮 + 空调 26° + 窗帘开
  private executeHomeScene(): void {
    this.setDevice('智能门锁', 'unlocked');
    this.setDevice('客厅灯', 'on');
    this.setDevice('空调', '26°');
    this.setDevice('窗帘', 'open');
    this.sceneExecuted = '🏠 回家场景已执行: 灯亮 · 空调26° · 窗帘开';
    LoggerUtil.info(TAG, '回家场景执行完成');
  }

  private setDevice(name: string, status: string): void {
    for (let i = 0; i < this.devices.length; i++) {
      if (this.devices[i].name === name) {
        const d = this.devices[i];
        this.devices[i] = { name: d.name, type: d.type, status: status, icon: d.icon };
        break;
      }
    }
  }

  build() {
    Column({ space: 12 }) {
      Text('🏠 智能家居联动').fontSize(20).fontWeight(FontWeight.Bold)

      // 设备状态卡片
      Grid() {
        ForEach(this.devices, (d: DeviceItem) => {
          GridItem() {
            Column({ space: 4 }) {
              Text(d.icon).fontSize(26)
              Text(d.name).fontSize(12).fontWeight(FontWeight.Bold)
              Text(d.status).fontSize(11)
                .fontColor(d.status === 'off' || d.status === 'locked' || d.status === 'closed'
                  ? 'rgba(255,255,255,0.4)' : '#69F0AE')
            }
            .width('100%').padding(12)
            .backgroundColor('rgba(255,255,255,0.06)').borderRadius(12)
          }
        }, (d: DeviceItem) => d.name)
      }
      .columnsTemplate('1fr 1fr').columnsGap(10).rowsGap(10)

      // 场景按钮
      Button('🏠 回家场景（门锁开 → 灯/空调/窗帘联动）')
        .width('100%').height(48).backgroundColor('#4FC3F7')
        .onClick(() => this.executeHomeScene())
      Button('🌙 睡眠场景（全屋熄灯 + 空调睡眠模式）')
        .width('100%').height(48).backgroundColor('#7E57C2')
        .onClick(() => this.executeSleepScene())
      Button('🚪 离家场景（全屋关闭 + 门锁上锁）')
        .width('100%').height(48).backgroundColor('#EF5350')
        .onClick(() => this.executeLeaveScene())

      if (this.sceneExecuted !== '') {
        Text(this.sceneExecuted).fontSize(12).fontColor('#69F0AE')
      }
    }
    .width('100%').height('100%').padding(16)
    .backgroundColor('#0D1B2A')
  }
}

4.3 设备拓扑与离线策略

控制中枢 (手机) ←—— 软总线 ——→ 全屋设备
        │
        ├── 在线设备: 直接命令 (延迟 < 50ms)
        ├── 离线设备: 记录命令到本地队列
        └── 设备上线: 自动补发队列中的命令

断网兜底:
  → 所有场景规则缓存到每个设备本地
  → 门锁/音箱等边缘设备可独立执行场景
  → 恢复联网后自动同步状态

五、问题排查与性能优化

问题	原因	解决
设备发现慢	全量扫描 + 云端兜底	靠近感知 + 组播并行
场景触发不灵	条件写死，状态未同步	分布式对象实时同步
断网联动失效	规则只在云端	规则缓存到设备本地
设备状态不同步	各设备各自存储	单一数据源（分布式对象）
动作并发乱序	未编排动作顺序	规则链带 delay 顺序执行
误触发	条件过于宽松	加时间窗 + 多条件 AND

5.1 联动性能优化

1. 状态同步用分布式数据对象（增量同步，非全量）
2. 场景动作并发执行（无依赖动作同时下发）
3. 规则评估 O(n) 预编译 → 事件到达直接查表
4. 设备命令走软总线直连，不经云端中转

六、高阶总结与最佳实践

1. 本地优先：一切联动默认走本地软总线，云端只做桥接——断网可用是智能家居的底线。
2. 单一数据源：全屋设备状态收敛到一个分布式对象，避免多端状态打架。
3. 场景化思维：用户要的是"回家/离家/睡眠"的场景，不是 20 个独立开关。
4. 规则可编排：场景引擎 + 规则链让用户自定义自动化，而不是开发硬编码。
5. 安全不妥协：设备认证 + 指令加密，防止外人控制你的家。

一句话记住：智能家居的体验 = 设备发现（秒级入网）+ 状态同步（单一数据源）+ 场景引擎（一键联动）+ 规则链（自动编排）——而这一切断网也要能用。