一、前置思考

应用流转（Continuation）是鸿蒙分布式体验的"临门一脚"——用户在手机上编辑到一半的文档，只需在超级终端中点击平板图标，文档就能无缝衔接到平板上继续编辑。这不仅仅是"打开同一个页面"，而是页面状态（滚动位置、表单内容、光标位置）完全一致的体验。

本文聚焦：

• onContinue/onRestore的完整生命周期与最佳实践
• WantParams传递的序列化限制与突破方案
• 流转异常恢复的容错设计
• 多端同时编辑的状态一致性问题

真实痛点场景：

1. 状态不完整：流转后滚动条回到顶部，表单数据丢失了一部分
2. 流转中断：网络抖动导致流转到一半失败，两边都处在"半死不活"状态
3. 重复流转：用户在手机上点了两次流转，平板上弹出两个确认框
4. 类型丢失：WantParams中的数字在目标设备上变成了字符串

二、核心原理

2.1 流转完整生命周期

源端(Source) 目标端(Target) │ │ ┌─────────────────┼──────────────────────────────┼─────────────────┐ │ 1.触发阶段 │ │ │ │ ├── startContinuation() │ │ │ │ 弹出设备选择器 │ │ └─────────────────┼──────────────────────────────┼─────────────────┘ │ │ ┌─────────────────┼──────────────────────────────┼─────────────────┐ │ 2.序列化阶段 │ │ │ │ ├── onContinue(wantParams) │ │ │ │ 打包所有需要传递的状态 │ │ │ │ 返回true → 允许流转 │ │ │ │ 返回false → 拒绝流转 │ │ └─────────────────┼──────────────────────────────┼─────────────────┘ │ │ ┌─────────────────┼──────────────────────────────┼─────────────────┐ │ 3.传输阶段 │ │ │ │ ├── WantParams通过软总线传输──→│ │ │ │ 加密传输+完整性校验 │ │ └─────────────────┼──────────────────────────────┼─────────────────┘ │ │ ┌─────────────────┼──────────────────────────────┼─────────────────┐ │ 4.恢复阶段 │ │ │ │ │ ┌────┤ onRestore() │ │ │ │ │ 反序列化状态 │ │ │ │ │ 重建UI │ └─────────────────┼──────────────────────────┼────┼─────────────────┘ │ │ ┌─────────────────┼─────────────────────────┼─────────────────────┐ │ 5.清理阶段 │ │ │ │ ├── onStop() │ │ │ ├── onDestroy() │ │ │ │ 释放资源 │ 发送ACK确认 │ └─────────────────┼─────────────────────────┼─────────────────────┘ │ │ ▼ ▼ 流转完成，源端冻结/销毁 目标端正常运行

2.2 WantParams序列化机制深度解析

WantParams是流转的数据载体，但它有明显的限制：

// WantParams支持的数据类型typeWantParamsValue=string|number|boolean|object|undefined|null|WantParamsValue[];// ❌ 不支持的类型// - Function / Arrow Function → 不可序列化// - Date → 需要传时间戳，目标端new Date(timestamp)// - Map / Set → 需转为Array// - ArrayBuffer → 需Base64编码为string// - 自定义类实例 → 需提供toJSON()方法// ✅ 推荐序列化方案classContinuationSerializer{// 包装不可序列化的数据staticserializeState(state:EditorState):Record<string,Object>{constparams:Record<string,Object>={};// 基本类型直接赋值params['scrollY']=state.scrollY;params['documentId']=state.documentId;// Date → 时间戳params['lastEditTime']=state.lastEditTime.getTime();// 复杂对象 → JSON字符串params['formData']=JSON.stringify(state.formData);// ArrayBuffer → Base64params['thumbnailData']=this.arrayBufferToBase64(state.thumbnail);// 回调 → 标记类型（目标端重新绑定）params['callbackTypes']=state.callbackNames;returnparams;}// 目标端反序列化staticrestoreState(params:Record<string,Object>):EditorState{conststate:EditorState=newEditorState();state.scrollY=params['scrollY']asnumber;state.documentId=params['documentId']asstring;state.lastEditTime=newDate(params['lastEditTime']asnumber);state.formData=JSON.parse(params['formData']asstring);state.thumbnail=this.base64ToArrayBuffer(params['thumbnailData']asstring);returnstate;}privatestaticarrayBufferToBase64(buffer:ArrayBuffer):string{constbytes:Uint8Array=newUint8Array(buffer);letbinary:string='';for(leti:number=0;i<bytes.byteLength;i++){binary+=String.fromCharCode(bytes[i]);}returnbtoa(binary);}privatestaticbase64ToArrayBuffer(base64:string):ArrayBuffer{constbinary:string=atob(base64);constbytes:Uint8Array=newUint8Array(binary.length);for(leti:number=0;i<binary.length;i++){bytes[i]=binary.charCodeAt(i);}returnbytes.bufferasArrayBuffer;}}

2.3 大数据量流转方案

WantParams有200KB限制，大数据场景需要分块方案：

// 方案一：distributedKVStore（适用于频繁读写）asyncfunctiontransferViaKVStore(kvStore:distributedKVStore.SingleKVStore,key:string,data:string):Promise<void>{awaitkvStore.put(key,data);// WantParams只传key，目标端通过key从KVStore读取wantParams['dataKey']=key;wantParams['dataSize']=data.length;}// 方案二：distributedObject（适用于实时同步对象）constdistObj:distributedObject.DistributedObject=distributedObject.createDistributedObject();distObj.setSessionId(sessionId);distObj['documentData']=largeDataJson;// 目标端通过监听对象变化获取数据// 方案三：分块传输（适用于超大文件）constCHUNK_SIZE:number=150*1024;// 150KB per chunkasyncfunctiontransferLargeFile(filePath:string,targetDeviceId:string):Promise<void>{consttotalSize:number=getFileSize(filePath);consttotalChunks:number=Math.ceil(totalSize/CHUNK_SIZE);// WantParams传递元数据wantParams['fileTransferId']=this.generateTransferId();wantParams['totalChunks']=totalChunks;wantParams['fileName']=getFileName(filePath);// 分块通过Session传输for(leti:number=0;i<totalChunks;i++){constchunk:ArrayBuffer=readFileChunk(filePath,i*CHUNK_SIZE,CHUNK_SIZE);awaitsession.send(chunk);}}

三、异常恢复完整方案

3.1 流转超时处理

classContinuationTimeoutGuard{privatestaticreadonlyTIMEOUT_MS:number=30000;// 30秒超时privatetimerId:number=-1;asyncstartWithTimeout(continuationPromise:Promise<void>,onTimeout:()=>void):Promise<void>{returnnewPromise<void>((resolve,reject)=>{this.timerId=setTimeout(()=>{onTimeout();reject(newError('流转超时'));},ContinuationTimeoutGuard.TIMEOUT_MS);continuationPromise.then(()=>{clearTimeout(this.timerId);resolve();}).catch((err:Error)=>{clearTimeout(this.timerId);reject(err);});});}}

3.2 事务型流转

保证流转的原子性——要么完全成功，要么完全回滚：

classTransactionalContinuation{privatestateBackup:Record<string,Object>|null=null;// 源端：备份+流转asyncmigrateState(wantParams:Record<string,Object>,targetDeviceId:string):Promise<boolean>{// 1. 备份当前状态this.stateBackup={...wantParams};try{// 2. 执行流转awaitcontinuationManager.startContinuation({wantParams});// 3. 等待目标端ACK（最多10秒）constack:boolean=awaitthis.waitForAck(10000);if(!ack){thrownewError('目标端未确认');}// 4. 成功 → 清理源端状态this.onMigrationSuccess();returntrue;}catch(e){// 5. 失败 → 回滚this.onMigrationFailure();returnfalse;}}privateonMigrationSuccess():void{this.stateBackup=null;// 清理源端资源// 可选：销毁源端页面}privateonMigrationFailure():void{// 恢复备份状态if(this.stateBackup!==null){// 将备份的状态恢复到UIthis.restoreBackup();}}privateasyncwaitForAck(timeoutMs:number):Promise<boolean>{returnnewPromise<boolean>((resolve)=>{consttimer:number=setTimeout(()=>{resolve(false);},timeoutMs);// 实际场景中通过软总线监听ACK事件// softbus.on('ack', () => { clearTimeout(timer); resolve(true); });});}}

3.3 多端状态一致性

当两端同时编辑时，需要处理冲突：

// 使用分布式对象实现多端协作classCollaborativeEditor{privatedistObj:distributedObject.DistributedObject|null=null;initCollaboration(sessionId:number):void{this.distObj=distributedObject.createDistributedObject();this.distObj.setSessionId(sessionId);this.distObj['content']='';this.distObj['cursorPosition']=0;this.distObj['version']=0;// 监听远端修改this.distObj.on('status',(session:string,networkId:string,status:string)=>{if(status==='changed'){this.onRemoteChange();}});}// CRDT风格的冲突解决privateonRemoteChange():void{if(this.distObj===null)return;constremoteVersion:number=this.distObj['version']asnumber;constlocalVersion:number=this.localVersion;if(remoteVersion>localVersion){// 远端更新 → 应用远端内容this.documentContent=this.distObj['content']asstring;this.localVersion=remoteVersion;}else{// 本地更新 → 推送到远端this.distObj['content']=this.documentContent;this.distObj['version']=this.localVersion+1;}}}

四、完整代码架构

Demo中的流转模拟架构：

Layer 1: 源端管理 ├── 状态快照（表单数据/滚动位置/选中项） ├── WantParams序列化引擎 └── 流转触发&设备选择 Layer 2: 传输层 ├── 数据大小检测（<200KB直接WantParams） ├── 大文件分块策略 └── 传输进度追踪 Layer 3: 目标端恢复 ├── WantParams反序列化 ├── UI状态重建 ├── 回调重新绑定 └── 资源重新初始化 Layer 4: 异常处理 ├── 超时回滚 ├── 网络重试 └── 状态一致性校验

五、避坑速查

六、总结

应用流转的本质是状态迁移，不是页面迁移：

1. onContinue = 打包：把当前所有有意义的状态打包进WantParams，返回false可以拒绝流转
2. WantParams = 信封：200KB限制，复杂数据要JSON.stringify，二进制要Base64
3. onRestore = 拆包：反序列化→重建UI→重新绑定回调→重新初始化连接
4. 异常处理 = 安全网：超时回滚、事务保证、空值兜底

一个高质量的流转实现，应该让用户感知不到"迁移"这个过程——就像页面从未离开过。