硬件互助，资源共享

【场景一：借摄像头】
你的手表要扫码，但摄像头只有 30 万像素。
→ 手表直接【调用手机的摄像头】，拍完传回来
→ 手表上的代码：camera.open()  —— 一行没改

【场景二：借屏幕】
你在手机上看到一半的视频，走到客厅。
→ 视频【流转到智慧屏】，手机变成遥控器
→ 视频进度不丢，因为状态也一起过去了

【场景三：借算力】
你的门锁需要跑一个人脸识别，但它只有 128KB 内存。
→ 门锁把图像传给手机，让【手机算】，只拿结果
→ 门锁依然只是个门锁，但有了 AI

【场景四：借传感器】
你的手机没有温湿度传感器。
→ 手机【直接读客厅那个开发板上的 SHT30】
→ 对手机上的 App 来说，这个传感器就像长在自己身上

【硬件总线（I2C）】              【软总线（分布式）】
  同一块 PCB 上                    同一个局域网 / 蓝牙范围内
  物理的 SDA/SCL 两根线             虚拟的"总线"
  靠 7 位地址区分设备                靠 deviceId 区分设备
  传几个字节                        传任意数据、传能力、传硬件

┌──────────────────────────────────────┐
│  应用 / 系统服务                        │
├──────────────────────────────────────┤
│  分布式软总线（统一 API）                │  ← 上层只看到"总线"
├──────────────────────────────────────┤
│  Wi-Fi P2P │ 蓝牙 BR/BLE │ 以太网     │  ← 底层自动选
└──────────────────────────────────────┘

   ① 发现        ② 连接        ③ 组网        ④ 传输
   发现谁在      建立信任      组成一个       在网内传数据
      │             │          超级终端          │
      ▼             ▼             ▼             ▼
   设备发现      设备认证       逻辑组网       数据传输
   （谁在附近）  （你是谁）    （我们是一伙的）（说正事）

     ┌─────────────────────────────────┐
     │         超级终端                  │
     │                                  │
     │   手机 ────┬──── 平板             │
     │            │                     │
     │   手表 ────┼──── 智慧屏           │
     │            │                     │
     │  开发板 ───┴──── 音箱             │
     │                                  │
     └─────────────────────────────────┘
     每个设备都知道：
       · 伙伴有哪些
       · 每个伙伴有什么能力（摄像头？传感器？屏幕？）
       · 自己怎么调用它们

     手机                              开发板
  ┌──────────┐                     ┌──────────┐
  │ 应用       │                     │  SHT30   │
  │           │                     │  传感器   │
  │ 调用       │                     └────┬─────┘
  │ 温湿度API │                          │
  └─────┬────┘                          │
        │                               │
        └──────── 软总线 ──────────────┘
              ↑
        分布式硬件虚拟化层

┌─────────────┐    ┌─────────────┐    ┌─────────────┐
│   Source    │    │  SoftBus    │    │    Sink     │
│  （提供硬件）│───►│  （软总线）  │───►│  （使用硬件）│
│  开发板      │    │             │    │  手机        │
└─────────────┘    └─────────────┘    └─────────────┘
  真实硬件在这          负责传输           虚拟硬件在这

import distributedDeviceManager from '@ohos.distributedDeviceManager';
import { BusinessError } from '@ohos.base';

class DeviceHelper {
  private dm: distributedDeviceManager.DeviceManager | null = null;

  // ---------- 创建设备管理器 ----------
  init(bundleName: string): void {
    try {
      this.dm = distributedDeviceManager.createDeviceManager(bundleName);

      // 监听设备状态变化（上线 / 下线 / 认证完成）
      this.dm.on('deviceStateChange', (data) => {
        console.info(`设备状态变化: ${JSON.stringify(data)}`);
        // data.action:
        //   0 = 上线(ONLINE)   1 = 就绪(READY)
        //   2 = 下线(OFFLINE)  3 = 状态变化(CHANGE)
      });

      // 监听发现到的设备
      this.dm.on('deviceFound', (data) => {
        console.info(`发现设备: ${JSON.stringify(data)}`);
      });

      // 监听认证结果
      this.dm.on('deviceAuthenticate', (data) => {
        console.info(`认证结果: ${JSON.stringify(data)}`);
      });

    } catch (err) {
      console.error(`创建失败: ${(err as BusinessError).message}`);
    }
  }

  // ---------- 获取已认证（可信）设备列表 ----------
  getTrustedDevices(): distributedDeviceManager.DeviceBasicInfo[] {
    if (!this.dm) return [];
    try {
      return this.dm.getAvailableDeviceListSync();   // 同步接口
    } catch (err) {
      console.error(`获取列表失败: ${(err as BusinessError).message}`);
      return [];
    }
  }

  // ---------- 开始发现周边设备 ----------
  startDiscover(): void {
    if (!this.dm) return;
    let discoverParam: Record<string, number> = {
      'discoverTargetType': 1      // 1 = 发现所有类型
    };
    let filterOptions: Record<string, number> = {
      'availableStatus': 1,        // 只要在线的
      'discoverDistance': 0,       // 0 = 近距离
      'authenticationStatus': 0    // 0 = 未认证（一起发现）
    };
    try {
      this.dm.startDiscovering(discoverParam, filterOptions);
    } catch (err) {
      console.error(`发现失败: ${(err as BusinessError).message}`);
    }
  }

  stopDiscover(): void {
    this.dm?.stopDiscovering();
  }

  // ---------- 认证一个设备（PIN 码方式） ----------
  authenticate(deviceId: string, onPin: (pin: string) => void): void {
    if (!this.dm) return;
    let extraInfo: Record<string, string> = {
      'targetPkgName': 'com.example.myapp',
      'appName': '温湿度监控',
      'appDescription': '需要连接你的传感器设备',
      'business': '0'
    };
    let authParam: Record<string, number | string> = {
      'authType': 1,               // 1 = PIN 码认证
      'extraInfo': JSON.stringify(extraInfo)
    };

    try {
      this.dm.authenticateDevice(deviceId, authParam, (err, data) => {
        if (err) {
          console.error(`认证失败: ${JSON.stringify(err)}`);
          return;
        }
        // 对方设备上会显示一个 PIN 码，这里拿到了要展示给用户
        let pin = data?.pin as string;
        if (pin) { onPin(pin); }
      });
    } catch (err) {
      console.error(`认证异常: ${(err as BusinessError).message}`);
    }
  }

  destroy(): void {
    if (this.dm) {
      this.dm.off('deviceStateChange');
      this.dm.off('deviceFound');
      this.dm.off('deviceAuthenticate');
      this.dm = null;
    }
  }
}

1. createDeviceManager 要传 bundleName
2. 监听有三个：deviceStateChange / deviceFound / deviceAuthenticate
3. getAvailableDeviceListSync() 拿【已认证】的设备
4. startDiscovering() 发现【未认证】的周边设备
5. authenticateDevice() 发起认证，回调里拿到 PIN 码
6. 用完 destroy()，注销监听

import common from '@ohos.app.ability.common';
import Want from '@ohos.app.ability.Want';

async startRemoteAbility(context: common.UIAbilityContext,
                        deviceId: string): Promise<void> {
  let want: Want = {
    deviceId:    deviceId,                    // ← 关键：指定目标设备！
    bundleName:  'com.example.myapp',
    abilityName: 'SensorAbility',
    parameters:  {
      action: 'start_collect',
      interval: 5000
    }
  };

  try {
    await context.startAbility(want);
    console.info('远端 Ability 已启动');
  } catch (err) {
    console.error(`启动失败: ${(err as BusinessError).code}`);
  }
}

  手机上看到一半
        │
        │  用户在"任务中心"选择"流转到平板"
        ▼
  手机：onContinue() 保存状态  ──►  软总线  ──►  平板：onCreate()/onNewWant() 恢复状态
        │                                              │
        └── 手机上的页面关闭 ───────────────────────────└── 平板上的页面打开，进度一致

import UIAbility from '@ohos.app.ability.UIAbility';
import type Want from '@ohos.app.ability.Want';
import type AbilityConstant from '@ohos.app.ability.AbilityConstant';

export default class EntryAbility extends UIAbility {
  // ===== 源端：我要被迁移走了，保存状态 =====
  onContinue(wantParam: Record<string, Object>): AbilityConstant.OnContinueResult {
    console.info('onContinue: 保存迁移状态');

    // 把要带过去的数据塞进 wantParam
    wantParam['currentPage']  = 'DetailPage';
    wantParam['deviceId']     = 'dev_001';
    wantParam['scrollOffset'] = AppStorage.Get<number>('scrollOffset') ?? 0;
    wantParam['draftText']    = AppStorage.Get<string>('draftText') ?? '';

    // 返回 AGREE 表示同意迁移；REJECT 表示拒绝
    return AbilityConstant.OnContinueResult.AGREE;
  }

  // ===== 目标端：我接手了，恢复状态 =====
  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
    console.info('onCreate: 恢复迁移状态');

    // launchParam.launchReason 会告诉你这是不是一次迁移
    if (launchParam.launchReason === AbilityConstant.LaunchReason.CONTINUATION) {
      let page  = want.parameters?.['currentPage'] as string;
      let devId = want.parameters?.['deviceId'] as string;
      let off   = want.parameters?.['scrollOffset'] as number;

      AppStorage.SetOrCreate('restoredPage', page);
      AppStorage.SetOrCreate('deviceId', devId);
      AppStorage.SetOrCreate('scrollOffset', off);
    }
  }

  // 如果目标端已经有这个 Ability 在跑，会走 onNewWant
  onNewWant(want: Want, launchParam: AbilityConstant.LaunchParam): void {
    console.info('onNewWant: 接收新的迁移请求');
    // 同样恢复状态
  }
}

import distributedKVStore from '@ohos.data.distributedKVStore';

class DistributedData {
  private kvManager: distributedKVStore.KVManager | null = null;
  private kvStore: distributedKVStore.SingleKVStore | null = null;

  // ---------- 初始化 ----------
  async init(bundleName: string, context: common.Context): Promise<void> {
    const kvManagerConfig: distributedKVStore.KVManagerConfig = {
      context: context,
      bundleName: bundleName
    };
    this.kvManager = distributedKVStore.createKVManager(kvManagerConfig);

    const options: distributedKVStore.Options = {
      createIfMissing: true,                        // 不存在就创建
      encrypt: true,                                // 加密存储
      backup: false,
      autoSync: true,                               // ← 自动同步！
      kvStoreType: distributedKVStore.KVStoreType.SINGLE_VERSION,
      securityLevel: distributedKVStore.SecurityLevel.S2
    };

    this.kvStore = await this.kvManager.getKVStore<distributedKVStore.SingleKVStore>(
      'sensor_store', options
    );

    // 监听数据变化（别的设备改了，这边会收到）
    this.kvStore.on('dataChange',
      distributedKVStore.SubscribeType.SUBSCRIBE_TYPE_REMOTE,
      (data) => {
        console.info(`数据变化: ${JSON.stringify(data)}`);
        // data.insertEntries / updateEntries / deleteEntries
        // data.deviceId —— 哪个设备改的
      }
    );
  }

  // ---------- 写数据 ----------
  async put(key: string, value: string | number | boolean | Uint8Array): Promise<void> {
    await this.kvStore?.put(key, value);
  }

  // ---------- 读数据 ----------
  async get(key: string): Promise<distributedKVStore.ValueType | undefined> {
    return await this.kvStore?.get(key);
  }

  // ---------- 手动同步到指定设备 ----------
  sync(deviceIds: string[], mode: distributedKVStore.SyncMode): void {
    if (!this.kvStore) return;

    this.kvStore.sync(deviceIds, mode, 1000);   // 超时 1000ms
    // SyncMode:
    //   PUSH_ONLY  只推（我改了，发给你们）
    //   PULL_ONLY  只拉（你们改了，我要过来）
    //   PUSH_PULL  又推又拉（最常用）
  }

  // ---------- 清理 ----------
  destroy(): void {
    this.kvStore?.off('dataChange');
    this.kvManager?.closeKVStore('sensor_store');
  }
}

// ===== 使用 =====
let dd = new DistributedData();
await dd.init('com.example.myapp', getContext(this));

// 本机写入，会自动同步到组网内的其他设备
await dd.put('livingroom_temp', 26.5);
await dd.put('livingroom_humi', 61);

// 也可以手动触发同步
dd.sync(['device_id_1', 'device_id_2'], distributedKVStore.SyncMode.PUSH_PULL);

冲突解决策略：
1. 时间戳 —— 后写的覆盖先写的（默认）
2. 设备优先级 —— 某些设备优先级更高
3. 业务自定义 —— 你自己实现合并逻辑

┌─────────────────────────────────────────────┐
│  分布式任务调度                                │
├─────────────────────────────────────────────┤
│  · 查询网内各设备的能力（CPU/内存/屏幕/传感器）   │
│  · 根据任务需求，挑最合适的设备执行               │
│  · 支持远程启动、远程迁移、远程停止               │
└─────────────────────────────────────────────┘

风险一：假冒设备 —— 一个恶意设备伪装成你的传感器
风险二：窃听     —— 通信被中间人截获
风险三：越权     —— 别的应用读到你的分布式数据

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

1. 每次调用前检查对端是否在线
2. 所有跨设备调用都要有超时
3. 所有跨设备调用都要有失败降级
4. 不要假设对端的应用版本和你一样
5. 敏感数据不要放在未加密的分布式存储里

【软总线四步】
发现（谁在附近）→ 认证（你是谁）→ 组网（超级终端）→ 传输（说正事）

【关键 API】
distributedDeviceManager.createDeviceManager()     创建管理器
  .getAvailableDeviceListSync()                    已认证设备
  .startDiscovering()                              发现周边
  .authenticateDevice()                            认证（拿 PIN）

startAbility({ deviceId, bundleName, abilityName })  跨设备启动
onContinue() / onCreate(launchReason=CONTINUATION)   跨端迁移
distributedKVStore + autoSync                        数据自动同步

【设备虚拟化】
Source（提供硬件）→ 软总线 → Sink（虚拟硬件）
分布式相机 / 麦克风 / 屏幕 / 传感器 / 存储 / 算力

【权限】
ohos.permission.DISTRIBUTED_DATASYNC（user_grant，要弹窗）

【铁律】
假设网络会断、设备会离线、对端是旧版本
跨设备调用：必查在线 + 必设超时 + 必有降级