请添加图片描述

文章目录

前言

鸿蒙的分布式软总线是整个 HarmonyOS 全场景战略的基石。它让数据和服务能够跨越物理设备边界，实现"一台设备的能力，多设备共享"的体验。然而，很多开发者在面对分布式 KV 存储、应用接续（Continuation）、设备组网等概念时，往往只停留在 API 调用层面，缺乏对底层架构和工程化实践的深入理解。

本文将结合一个完整的实战 Demo，从软总线分层架构、分布式 KV 数据同步、应用接续全生命周期到跨设备状态恢复，为你系统性地拆解分布式软总线的工程化落地方案。

一、 分布式软总线分层架构：从设备发现到 UI 恢复

在深入代码之前，我们必须先理解分布式软总线的五层架构。Demo 中的 ArchitectureSection 清晰地展示了这一分层模型：

1.1 发现层（Discovery Layer）

负责设备发现与可信认证。同一华为账号下的设备，在开启 Wi-Fi 和蓝牙后，会被自动发现并加入可信设备列表。开发者可通过 distributedDevice.createDeviceManager() 获取设备管理器，并监听 deviceStateChange 事件来感知设备的上线与离线。

1.2 传输层（Transport Layer）

基于 DSoftBus 通道实现加密数据传输。在 HarmonyOS 6.0+ 中，系统优先使用星闪（NearLink）协议进行连接，若设备不支持则自动降级为分布式软总线协议。 传输层对开发者是透明的，开发者只需关注上层的 KV 存储和应用接续接口。

1.3 数据层（Data Layer）

核心是 distributedKVStore，提供跨设备的键值型数据同步能力。支持 autoSync（自动同步）和手动 sync()（PUSH_PULL 模式）两种方式。 数据层还支持通过 dataChange 事件订阅远端数据变更通知，实现实时 UI 刷新。

1.4 接续层（Continuation Layer）

基于 onContinue / CONTINUATION 机制，通过 WantParams 在源设备和目标设备之间传递上下文数据。接续层是应用接续的核心，它决定了"任务从哪来、带什么数据、如何恢复"。

1.5 UI 层（Presentation Layer）

通过 AppStorage 实现跨组件的状态共享与恢复。当接续完成后，UI 层从 AppStorage 中读取恢复的数据（如草稿标题、内容、阅读进度），实现页面状态的无缝接续。

二、 分布式 KV 存储：跨设备数据同步的核心引擎

Demo 中的 DistributedKvService 封装了分布式 KV 存储的核心逻辑。要正确使用它，需要理解以下几个关键机制。

2.1 KVManager 与 KVStore 的创建

分布式 KV 存储的使用遵循"先创建管理器，再获取数据库实例"的模式：

const kvManager = distributedKVStore.createKVManager({
  context: context,
  bundleName: 'com.example.distributedapp'
});

const kvStore = await kvManager.getKVStore<distributedKVStore.SingleKVStore>('user_settings', {
  createIfMissing: true,
  autoSync: true,
  kvStoreType: distributedKVStore.KVStoreType.SINGLE_VERSION,
  securityLevel: distributedKVStore.SecurityLevel.S1
});

这里有几个关键配置需要注意：

  • createIfMissing: true：如果指定名称的 KVStore 不存在，则自动创建。在分布式场景下，这个配置确保每台设备都能自动初始化本地数据库。
  • autoSync: true：开启自动同步后，本地数据的增删改操作会自动触发向同一组网环境内处于"多端协同"状态下的设备进行跨设备数据同步。需要注意的是，从 HarmonyOS NEXT Developer Beta5 开始，autoSync 仅在跨设备协同场景下生效，非协同场景下即使配置为 true 也不会触发同步。
  • securityLevel: S1：数据安全等级，S1 表示数据允许向安全等级不低于本设备的对端设备同步。

2.2 数据写入与同步触发

Demo 中的 saveDraft() 方法展示了数据写入的标准流程：

private async saveDraft(): Promise<void> {
  await DistributedKvService.saveDraft(this.draftTitle, this.draftContent, this.draftProgress)
  this.statusText = '草稿已写入分布式 KV，软总线负责跨设备同步'
}

底层实现中，saveDraft 会将标题、内容和进度序列化为 JSON 字符串，通过 kvStore.put(key, value) 写入分布式数据库。如果开启了 autoSync，写入操作会自动触发同步；如果使用手动同步模式，则需要显式调用 kvStore.sync(deviceIds, SyncMode.PUSH_PULL) 来触发。

Demo 中的 triggerSync() 方法正是手动同步的入口：

private async triggerSync(): Promise<void> {
  await DistributedKvService.triggerSync()
  this.statusText = '已触发 PUSH_PULL 同步（需可信设备组网）'
}

PUSH_PULL 模式意味着同时推送本地变更到远端，并拉取远端的最新变更，是双向同步的标准模式。

2.3 数据变更订阅：实时感知远端更新

跨设备同步的核心价值在于"实时感知"。当设备 A 修改了数据并同步到设备 B 后，设备 B 需要能够自动感知并刷新 UI。这通过 dataChange 事件实现：

kvStore.on('dataChange', distributedKVStore.SubscribeType.SUBSCRIBE_TYPE_ALL, (data) => {
  if (data.insertEntries.length > 0) {
    // 处理新增数据
  }
  if (data.updateEntries.length > 0) {
    // 处理更新数据
  }
  if (data.deleteEntries.length > 0) {
    // 处理删除数据
  }
});

SubscribeType.SUBSCRIBE_TYPE_ALL 表示订阅所有类型的数据变更，包括本设备修改和其他设备同步过来的数据。

2.4 冲突解决策略

当两台设备几乎同时修改同一条记录时，就会发生数据冲突。鸿蒙分布式数据库默认采用"最后写入胜出"（Last-Write-Wins）策略，即保留 updateTime 最新的版本。

但在实际业务中，更稳妥的做法是：

  • 拆分同步单元：将数据按条目粒度同步，而非整份覆盖。例如，草稿列表按每条草稿独立同步，避免"整篇文档覆盖"导致的冲突。
  • 携带版本号：每条记录附带 updatedAt 时间戳或版本号，在业务层自行实现合并逻辑。
  • 设备优先级：为不同设备类型设定优先级（如手机 > 平板 > 手表），高优先级设备的修改覆盖低优先级设备。

三、 应用接续（Continuation）：任务跨设备无缝流转

应用接续是分布式软总线最具"感知度"的能力——用户在手机上看了一半的文章，点击平板 Dock 栏的应用图标，即可在平板上从断点继续阅读。Demo 中的 ContinuationSection 和 enableContinuation() 方法展示了接续的核心实现。

3.1 接续的前提条件

在编码之前，必须确保满足以下前提：

  • 双端设备登录同一华为账号
  • 双端设备在"设置 > 多设备协调 > 接续"中打开接续功能
  • 在 module.json5 中将 continuable 标签配置为 true
  • 双端设备都安装了该应用
// module.json5
{
  "module": {
    "abilities": [{
      "continuable": true
    }]
  }
}

3.2 源设备：启用接续与数据保存

接续的第一步是在源设备上标记当前页面为"可接续"状态。Demo 中的 enableContinuation() 方法正是这样做的：

private enableContinuation(): void {
  this.context.setMissionContinueState(AbilityConstant.ContinueState.ACTIVE, () => {
    ContinuationBridge.appendLog('接续层', 'setMissionContinueState → ACTIVE')
  })
}

setMissionContinueState 是接续的"开关"。设置为 ACTIVE 后，系统会在 Dock 栏或任务管理器中显示该应用可被接续的标识。该方法在 aboutToAppear() 和 onPageShow() 中都被调用，确保页面每次可见时都处于可接续状态。

当用户在源设备上触发接续（如通过系统流转菜单选择目标设备）时，系统会调用 UIAbility 的 onContinue() 生命周期方法。开发者需要在此方法中将待迁移的数据存入 wantParam：

onContinue(wantParam: Record<string, Object>) {
  wantParam['draftTitle'] = this.draftTitle
  wantParam['draftContent'] = this.draftContent
  wantParam['draftProgress'] = this.draftProgress
  return AbilityConstant.OnContinueResult.AGREE
}

wantParam 是源设备与目标设备之间的数据桥梁，它通过分布式软总线传输到目标设备。

3.3 目标设备：数据恢复与状态重建

接续数据到达目标设备后，系统会拉起目标设备上的应用，并触发 onCreate()（冷启动）或 onNewWant()（热启动）生命周期。Demo 中的 StatusSection 展示了接续恢复后的状态展示：

if (this.isContinuationLaunch && this.continuationPayload !== null) {
  Text(`接续来源: ${this.continuationPayload.sourceDevice} · ${this.continuationPayload.updatedAt}`)
    .fontSize(12)
    .fontColor('#34D399')
    .width('100%')
}

在 Ability 层，需要从 launchParam 中提取接续数据并恢复到 AppStorage：

onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
  if (launchParam.launchReason === AbilityConstant.LaunchReason.CONTINUATION) {
    // 从 want.parameters 中提取接续数据
    const title = want.parameters?.['draftTitle'] as string
    const content = want.parameters?.['draftContent'] as string
    const progress = want.parameters?.['draftProgress'] as number
    
    // 写入 AppStorage，UI 层自动响应
    AppStorage.setOrCreate('draftTitle', title)
    AppStorage.setOrCreate('draftContent', content)
    AppStorage.setOrCreate('draftProgress', progress)
    AppStorage.setOrCreate('isContinuationLaunch', true)
  }
  
  // 恢复接续能力，确保可以再次接续到其他设备
  this.context.setMissionContinueState(AbilityConstant.ContinueState.ACTIVE, () => {})
}

这里有一个容易被忽略的细节：接续后的应用必须重新设置 ContinueState.ACTIVE。否则，接续到目标设备后，应用将无法再次接续到第三台设备，接续链路就此断裂。

3.4 模拟接续恢复

在开发调试阶段，由于可能没有多台真机，Demo 提供了模拟接续恢复的能力：

Button('模拟接续恢复')
  .onClick(() => {
    ContinuationBridge.simulateContinuation()
    this.statusText = '已模拟目标设备接续恢复（真机用系统流转菜单）'
  })

ContinuationBridge.simulateContinuation() 会在本地构造一个模拟的 ContinuationPayload，写入 AppStorage，从而在不依赖真机组网的情况下验证 UI 恢复逻辑。这在日常开发中非常实用。

3.5 接续的高级配置

快速迁移（Quick Start）

默认情况下，发起迁移后系统会等待数据从源端传输到对端后才拉起应用。如果希望用户发起接续后立即拉起目标应用（减少等待时间），可以在 module.json5 的 continueType 中添加 _ContinueQuickStart 后缀。

按需退出源端应用

默认情况下，迁移成功后源端应用会自动退出。如果希望源端应用保持运行（例如用户只是想"复制"任务到另一台设备），可以在 onContinue() 中设置：

wantParam[wantConstant.Params.SUPPORT_CONTINUE_SOURCE_EXIT_KEY] = false
按需控制页面栈恢复

默认情况下，系统会自动恢复源端的页面栈。如果应用使用 Navigation 路由（目前暂不支持自动恢复页面栈），或者希望自定义恢复逻辑，可以设置：

wantParam[wantConstant.Params.SUPPORT_CONTINUE_PAGE_STACK_KEY] = false

然后在 onWindowStageRestore() 中手动加载目标页面。

四、 AppStorage 状态管理：跨组件数据流的核心

Demo 中大量使用了 @StorageLink 装饰器来实现跨组件的状态共享：

@StorageLink('draftTitle') draftTitle: string = ''
@StorageLink('draftContent') draftContent: string = ''
@StorageLink('draftProgress') draftProgress: number = 0
@StorageLink('isContinuationLaunch') isContinuationLaunch: boolean = false
@StorageLink('continuationPayload') continuationPayload: ContinuationPayload | null = null
@StorageLink('distributedSyncLogs') syncLogs: SyncLogItem[] = []
@StorageLink('distributedKvStatus') kvStatus: string = ''
@StorageLink('localDeviceLabel') localDeviceLabel: string = '本机'

@StorageLink 是 AppStorage 的双向绑定装饰器。当 Ability 层在接续恢复时通过 AppStorage.setOrCreate() 写入数据后，所有使用 @StorageLink 绑定的组件会自动感知到数据变化并触发 UI 刷新。这种设计实现了"数据驱动 UI"的响应式架构，避免了手动刷新页面的繁琐操作。

在分布式场景下，AppStorage 充当了三个角色的桥梁：

  • KV 同步层：远端数据通过 dataChange 回调写入 AppStorage
  • 接续恢复层：目标设备从 want.parameters 提取数据写入 AppStorage
  • UI 展示层：组件通过 @StorageLink 自动读取并展示最新状态

五、 同步日志系统：可观测性的工程实践

Demo 中的 LogSection 实现了一个轻量级的同步日志系统，用于记录分布式操作的全链路日志：

ForEach(this.syncLogs, (item: SyncLogItem) => {
  Column({ space: 2 }) {
    Text(`[${item.time}] ${item.layer}`)
      .fontSize(11)
      .fontColor('#F472B6')
    Text(item.message)
      .fontSize(11)
      .fontColor('#CBD5E1')
  }
})

每条日志包含时间戳、所属层级（如"接续层"、“数据层”）和具体消息。ContinuationBridge.appendLog() 方法负责向日志数组追加记录。这种设计在开发和调试阶段非常有价值——当跨设备同步出现问题时，开发者可以通过日志快速定位问题发生在哪一层、哪个环节。

在正式产品中，建议将日志系统升级为结构化日志（如接入 HiLog），并按层级分类过滤，方便在大量日志中快速检索关键信息。

六、 同步边界划分：工程化的最佳实践

分布式软总线的能力虽然强大，但并非所有数据都适合同一条链路同步。根据实际工程经验，合理的同步边界划分是项目成功的关键：

6.1 轻量状态 → 分布式数据对象

对于 UI 状态（如当前选中项、展开/折叠状态等），适合使用分布式数据对象（distributedDataObject）。它的优势在于支持字段级变更通知，适合频繁更新的小数据。

6.2 结构化记录 → KVStore

对于结构化的业务数据（如草稿列表、用户设置、任务记录），KVStore 是更稳妥的选择。它的同步触发点更明确，开发者可以精确控制哪些写操作走自动同步、哪些时机手动触发同步。

6.3 大文件资产 → 文件路径传递

对于图片、视频等大文件，不应通过 KVStore 传输（单条 Value 限制为 4MB）。正确的做法是将文件存储到分布式文件系统中，仅在 KVStore 中同步文件路径引用。

6.4 敏感数据 → 加密传输

对于涉及用户隐私的数据，应在写入 KVStore 前进行加密处理，并设置合适的 securityLevel，确保数据不会同步到安全等级不足的设备。

七、 常见踩坑与排查指南

7.1 autoSync 不生效

从 HarmonyOS NEXT Developer Beta5 开始，autoSync 仅在"多端协同"场景下生效。如果设备未进入协同状态，即使配置了 autoSync: true，也不会触发跨设备同步。此时需要手动调用 sync() 方法。

7.2 接续后页面白屏

通常是因为目标设备在 onCreate() 或 onNewWant() 中未正确提取 want.parameters 中的数据，导致 UI 层拿到的状态为空。建议在 Ability 层增加日志打印，确认数据是否成功传递。

7.3 接续链路断裂

接续到目标设备后，如果忘记重新调用 setMissionContinueState(ACTIVE)，应用将无法再次接续到第三台设备。这是一个高频踩坑点。

7.4 数据冲突导致 UI 异常

当两台设备同时编辑同一条草稿时，默认的"最后写入胜出"策略可能导致一台设备的修改被静默覆盖。建议在业务层增加冲突检测和用户提示机制。

7.5 设备组网失败

确保双端设备登录同一华为账号、开启 Wi-Fi 和蓝牙、并在系统设置中打开接续功能。建议双端接入同一局域网以提升传输速度。

完整代码

import { AbilityConstant, common } from '@kit.AbilityKit'
import { ContinuationBridge } from '../distributed/ContinuationBridge'
import { DistributedKvService } from '../distributed/DistributedKvService'
import { ContinuationPayload, SyncLogItem } from '../distributed/DistributedTypes'

@Entry
@Component
struct DistributedSoftBusDemo {
  @StorageLink('draftTitle') draftTitle: string = ''
  @StorageLink('draftContent') draftContent: string = ''
  @StorageLink('draftProgress') draftProgress: number = 0
  @StorageLink('isContinuationLaunch') isContinuationLaunch: boolean = false
  @StorageLink('continuationPayload') continuationPayload: ContinuationPayload | null = null
  @StorageLink('distributedSyncLogs') syncLogs: SyncLogItem[] = []
  @StorageLink('distributedKvStatus') kvStatus: string = ''
  @StorageLink('localDeviceLabel') localDeviceLabel: string = '本机'
  @State statusText: string = '软总线：设备发现 → 可信认证 → 数据传输 → 应用接续'
  private context = this.getUIContext().getHostContext() as common.UIAbilityContext

  aboutToAppear(): void {
    this.enableContinuation()
  }

  onPageShow(): void {
    this.enableContinuation()
  }

  build() {
    Scroll() {
      Column({ space: 16 }) {
        this.HeaderSection()
        this.StatusSection()
        this.EditorSection()
        this.ActionSection()
        this.ContinuationSection()
        this.ArchitectureSection()
        this.LogSection()
      }
      .width('100%')
      .padding({ top: 36, left: 16, right: 16, bottom: 24 })
    }
    .width('100%')
    .height('100%')
    .backgroundColor('#0B1220')
    .scrollBar(BarState.Off)
  }

  @Builder HeaderSection() {
    Column({ space: 6 }) {
      Text('分布式软总线')
        .fontSize(28)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
      Text('数据跨越设备边界 · 无缝接续')
        .fontSize(14)
        .fontColor('#94A3B8')
    }
    .width('100%')
    .alignItems(HorizontalAlign.Start)
  }

  @Builder StatusSection() {
    Column({ space: 8 }) {
      Row() {
        Text('KV 状态')
          .fontSize(13)
          .fontColor('#E2E8F0')
        Blank()
        Text(this.kvStatus)
          .fontSize(12)
          .fontColor('#38BDF8')
      }
      .width('100%')

      Text(this.statusText)
        .fontSize(12)
        .fontColor('#64748B')
        .width('100%')

      if (this.isContinuationLaunch && this.continuationPayload !== null) {
        Text(`接续来源: ${this.continuationPayload.sourceDevice} · ${this.continuationPayload.updatedAt}`)
          .fontSize(12)
          .fontColor('#34D399')
          .width('100%')
      }
    }
    .width('100%')
    .padding(14)
    .backgroundColor('rgba(56,189,248,0.1)')
    .borderRadius(14)
  }

  @Builder EditorSection() {
    Column({ space: 10 }) {
      Text('跨设备草稿编辑')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .width('100%')

      TextInput({ text: this.draftTitle, placeholder: '标题' })
        .height(44)
        .fontSize(14)
        .backgroundColor('rgba(255,255,255,0.08)')
        .onChange((v: string) => this.draftTitle = v)

      TextArea({ text: this.draftContent, placeholder: '编辑内容…' })
        .height(120)
        .fontSize(13)
        .backgroundColor('rgba(255,255,255,0.08)')
        .onChange((v: string) => this.draftContent = v)

      Row() {
        Text(`阅读进度 ${this.draftProgress}%`)
          .fontSize(12)
          .fontColor('#94A3B8')
        Blank()
      }
      .width('100%')

      Slider({
        value: this.draftProgress,
        min: 0,
        max: 100,
        step: 1
      })
        .trackColor('rgba(255,255,255,0.15)')
        .selectedColor('#6366F1')
        .onChange((v: number) => this.draftProgress = Math.round(v))
    }
    .width('100%')
    .padding(14)
    .backgroundColor('rgba(255,255,255,0.05)')
    .borderRadius(14)
    .alignItems(HorizontalAlign.Start)
  }

  @Builder ActionSection() {
    Row({ space: 8 }) {
      Button('保存到 KV')
        .layoutWeight(1)
        .height(42)
        .fontSize(12)
        .backgroundColor('#6366F1')
        .onClick(() => this.saveDraft())

      Button('触发同步')
        .layoutWeight(1)
        .height(42)
        .fontSize(12)
        .backgroundColor('#0EA5E9')
        .onClick(() => this.triggerSync())
    }
    .width('100%')
  }

  @Builder ContinuationSection() {
    Column({ space: 10 }) {
      Text('应用接续 (Continuation)')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .width('100%')

      Text('源设备 onContinue → WantParams · 目标设备 onCreate/onNewWant 恢复')
        .fontSize(12)
        .fontColor('#94A3B8')
        .width('100%')

      Button('模拟接续恢复')
        .width('100%')
        .height(42)
        .fontSize(13)
        .backgroundColor('#8B5CF6')
        .onClick(() => {
          ContinuationBridge.simulateContinuation()
          this.statusText = '已模拟目标设备接续恢复（真机用系统流转菜单）'
        })
    }
    .width('100%')
    .padding(14)
    .backgroundColor('rgba(139,92,246,0.12)')
    .borderRadius(14)
    .alignItems(HorizontalAlign.Start)
  }

  @Builder ArchitectureSection() {
    Column({ space: 8 }) {
      Text('软总线分层架构')
        .fontSize(16)
        .fontWeight(FontWeight.Bold)
        .fontColor('#FFFFFF')
        .width('100%')

      this.LayerRow('发现层', '设备管理 · 可信设备列表 · 同一华为账号')
      this.LayerRow('传输层', 'DSoftBus 通道 · KV sync · 加密传输')
      this.LayerRow('数据层', 'distributedKVStore · autoSync · dataChange 订阅')
      this.LayerRow('接续层', 'onContinue / CONTINUATION · WantParams 上下文')
      this.LayerRow('UI 层', 'AppStorage 恢复 · 页面状态 · 进度接续')
    }
    .width('100%')
    .padding(14)
    .backgroundColor('rgba(255,255,255,0.05)')
    .borderRadius(14)
    .alignItems(HorizontalAlign.Start)
  }

  @Builder LogSection() {
    Column({ space: 8 }) {
      Row() {
        Text('同步日志')
          .fontSize(16)
          .fontWeight(FontWeight.Bold)
          .fontColor('#FFFFFF')
        Blank()
        Text(`${this.syncLogs.length} 条`)
          .fontSize(12)
          .fontColor('#38BDF8')
      }
      .width('100%')

      if (this.syncLogs.length === 0) {
        Text('等待操作…')
          .fontSize(12)
          .fontColor('#64748B')
      } else {
        ForEach(this.syncLogs, (item: SyncLogItem) => {
          Column({ space: 2 }) {
            Text(`[${item.time}] ${item.layer}`)
              .fontSize(11)
              .fontColor('#F472B6')
            Text(item.message)
              .fontSize(11)
              .fontColor('#CBD5E1')
          }
          .width('100%')
          .alignItems(HorizontalAlign.Start)
        }, (item: SyncLogItem) => item.id)
      }
    }
    .width('100%')
    .padding(14)
    .backgroundColor('rgba(255,255,255,0.05)')
    .borderRadius(14)
    .alignItems(HorizontalAlign.Start)
  }

  @Builder LayerRow(title: string, detail: string) {
    Row({ space: 10 }) {
      Text(title)
        .fontSize(12)
        .fontColor('#38BDF8')
        .width(52)
      Text(detail)
        .fontSize(12)
        .fontColor('#94A3B8')
        .layoutWeight(1)
    }
    .width('100%')
  }

  private enableContinuation(): void {
    this.context.setMissionContinueState(AbilityConstant.ContinueState.ACTIVE, () => {
      ContinuationBridge.appendLog('接续层', 'setMissionContinueState → ACTIVE')
    })
  }

  private async saveDraft(): Promise<void> {
    await DistributedKvService.saveDraft(this.draftTitle, this.draftContent, this.draftProgress)
    this.statusText = '草稿已写入分布式 KV，软总线负责跨设备同步'
  }

  private async triggerSync(): Promise<void> {
    await DistributedKvService.triggerSync()
    this.statusText = '已触发 PUSH_PULL 同步（需可信设备组网）'
  }
}

在这里插入图片描述
在这里插入图片描述

总结

分布式软总线是鸿蒙全场景体验的核心基础设施。通过本文的实战分析，我们可以总结出以下工程化要点：

  • 分层架构清晰：发现层、传输层、数据层、接续层、UI 层各司其职，开发者主要关注数据层和接续层的业务逻辑。
  • KVStore 是数据同步的主力：结构化数据用 KVStore，轻量状态用分布式数据对象，大文件走文件路径引用。
  • 应用接续是完整的生命周期：从 setMissionContinueState(ACTIVE) 到 onContinue() 再到 onCreate/onNewWant() 恢复，每一步都不能遗漏。
  • AppStorage 是状态中枢：它连接了 KV 同步层、接续恢复层和 UI 展示层，是跨组件数据流的核心。
  • 同步边界要提前规划：不要把所有同步问题丢给同一条链路，按数据类型和场景选择合适的同步策略。

掌握这些核心概念和工程实践，你就能在鸿蒙应用中构建出流畅、可靠的跨设备体验。

# harmonyos # 分布式 # 华为
Logo
人工智能6S服务平台

作为“人工智能6S店”的官方数字引擎，为AI开发者与企业提供一个覆盖软硬件全栈、一站式门户。

更多推荐

cover

鸿蒙 ArkTS 近场通信实战：NearLink（星闪）服务发现与 SSAP 握手

avatar 人工智能6S服务平台
cover

鸿蒙 ArkTS 跨端拖拽实战：UDMF 统一数据通道与跨设备键鼠穿越

avatar 人工智能6S服务平台
cover

鸿蒙HarmonyOS ArkTS首帧布局优化：减少首帧布局计算量深度解析

avatar 人工智能6S服务平台