arkts 指导文档示例代码规范化整改

issue: https://gitee.com/openharmony/docs/issues/I7WV06Signed-off-by: Nhunili <lihucheng2@huawei.com>

zh-cn/application-dev/application-models/hop-cross-device-migration.md

 # 跨端迁移
 
-
 ## 功能描述
 
 跨端迁移的主要工作是实现将应用当前任务（包括页面控件状态变量等）迁移到目标设备，能在目标设备上接续。主要功能包括：
 
 - 支持用户自定义数据存储及恢复。
-
 - 支持页面路由信息和页面控件状态数据的存储及恢复。
-
 - 支持应用兼容性检测。
-
-- 支持应用根据实际使用场景动态设置迁移状态（默认迁移状态为ACTIVE激活状态）。如编辑类应用在编辑文本的页面下才需要迁移，其他页面不需要迁移，则可以通过[setMissionContinueState](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextsetmissioncontinuestate10)进行控制。
-
+- 支持应用根据实际使用场景动态设置迁移状态（默认迁移状态为 **ACTIVE** 激活状态）。如编辑类应用在编辑文本的页面下才需要迁移，其他页面不需要迁移，则可以通过[setMissionContinueState](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextsetmissioncontinuestate10)进行控制。
 - 支持应用动态选择是否进行页面栈恢复（默认进行页面栈信息恢复）。如应用希望自定义迁移到其他设备后显示的页面，则可以通过[SUPPORT_CONTINUE_PAGE_STACK_KEY](../reference/apis/js-apis-app-ability-wantConstant.md#wantconstantparams)进行控制。
-
-- 支持应用动态选择流转成功后是否退出迁移发起端应用（默认流转成功后退出迁移发起端应用）。则可以通过[SUPPORT_CONTINUE_SOURCE_EXIT_KEY](../reference/apis/js-apis-app-ability-wantConstant.md#wantconstantparams)进行控制。
+- 支持应用动态选择迁移成功后是否退出迁移发起端应用（默认迁移成功后退出迁移发起端应用）。则可以通过[SUPPORT_CONTINUE_SOURCE_EXIT_KEY](../reference/apis/js-apis-app-ability-wantConstant.md#wantconstantparams)进行控制。
 
 
 ## 跨端迁移流程
@@ -28,14 +22,9 @@
 
 ## 约束限制
 
-- 由于“跨端迁移任务管理”能力尚未具备，开发者当前只能开发具备跨端迁移能力的应用，但不能发起迁移。
-
+- 应用迁移的发起依赖系统应用控制，系统应用开发者可以参考[验证指导中的demo示例](#验证指导)实现相关的控制能力。
 - 跨端迁移要求在同UIAbility之间进行，也就是需要相同的bundleName、abilityName和签名。
-
-
-## 最佳实践
-
-为了获得最佳体验，使用wantParam传输的数据建议在100KB以下。
+- 为了获得最佳体验，使用wantParam传输的数据建议在100KB以下。
 
 
 ## 接口说明
@@ -46,31 +35,35 @@
 
 | **接口名** | **描述** |
 | -------- | -------- |
-| onContinue(wantParam&nbsp;:&nbsp;{[key:&nbsp;string]:&nbsp;Object}):&nbsp;OnContinueResult | 迁移发起端在该回调中保存迁移所需要的数据，同时返回是否同意迁移：<br/>-&nbsp;AGREE：表示同意。<br/>-&nbsp;REJECT：表示拒绝：如应用在onContinue中异常可以直接REJECT。<br/>-&nbsp;MISMATCH：表示版本不匹配：迁移发起端应用可以在onContinue中获取到迁移接收端应用的版本号，进行协商后，如果版本不匹配导致无法迁移，可以返回该错误。 |
-| onCreate(want:&nbsp;Want,&nbsp;launchParam:&nbsp;AbilityConstant.LaunchParam):&nbsp;void; | 应用迁移接收端为冷启动或多实例应用热启动时，在该回调中完成数据恢复，并触发页面恢复。详见[应用组件启动模式](uiability-launch-type.md) |
-| onNewWant(want:&nbsp;Want,&nbsp;launchParam:&nbsp;AbilityConstant.LaunchParam):&nbsp;void; | 迁移接收端为单实例应用热启动时，在该回调中完成数据恢复，并触发页面恢复。详见[应用组件启动模式](uiability-launch-type.md) |
+| onContinue(wantParam&nbsp;:&nbsp;{[key:&nbsp;string]:&nbsp;Object}):&nbsp;OnContinueResult | 迁移发起端在该回调中保存迁移所需要的数据，同时返回是否同意迁移：<br/>-&nbsp;AGREE：表示同意。<br/>-&nbsp;REJECT：表示拒绝：如应用在onContinue中异常会导致钱以后数据恢复时显示异常，则可以建议REJECT。<br/>-&nbsp;MISMATCH：表示版本不匹配：迁移发起端应用可以在onContinue中获取到迁移目标端应用的版本号，进行协商后，如果版本不匹配导致无法迁移，可以返回该错误。 |
+| onCreate(want:&nbsp;Want,&nbsp;launchParam:&nbsp;AbilityConstant.LaunchParam):&nbsp;void; | 应用迁移目标端为冷启动或多实例应用热启动时，在该回调中完成数据恢复，并触发页面恢复。详见[应用组件启动模式](uiability-launch-type.md) |
+| onNewWant(want:&nbsp;Want,&nbsp;launchParam:&nbsp;AbilityConstant.LaunchParam):&nbsp;void; | 迁移目标端为单实例应用热启动时，在该回调中完成数据恢复，并触发页面恢复。详见[应用组件启动模式](uiability-launch-type.md) |
 
 
 
 ## 开发步骤
 
-1. 需要申请`ohos.permission.DISTRIBUTED_DATASYNC`权限，配置方式请参见[配置文件权限声明](../security/accesstoken-guidelines.md#配置文件权限声明)。
+1.需要申请`ohos.permission.DISTRIBUTED_DATASYNC`权限
 
-2. 同时需要在应用首次启动时弹窗向用户申请授权，使用方式请参见[向用户申请授权](../security/accesstoken-guidelines.md#向用户申请授权)。
+配置方式请参见[配置文件权限声明](../security/accesstoken-guidelines.md#配置文件权限声明)。
 
-3. 在配置文件中配置跨端迁移相关标签字段。
+2.同时需要在应用首次启动时弹窗向用户申请授权
 
-   配置应用支持迁移
-   在module.json5中配置continuable标签：true表示支持迁移，false表示不支持，默认为false。配置为false的UIAbility将被系统识别为无法迁移。
+使用方式请参见[向用户申请授权](../security/accesstoken-guidelines.md#向用户申请授权)。
+
+3.在配置文件中配置跨端迁移相关标签字段。
+
+配置应用支持迁移
+在module.json5中配置continuable标签：true表示支持迁移，false表示不支持，默认为false。配置为false的UIAbility将被系统识别为无法迁移。
 
 
    ```json
    {
      "module": {
-       ...
+       // ...
        "abilities": [
          {
-           ...
+           // ...
            "continuable": true,
          }
        ]
@@ -80,131 +73,325 @@
 
    根据需要配置应用启动模式类型，配置详情请参照[UIAbility组件启动模式](uiability-launch-type.md)。
 
-4. 在发起端UIAbility中实现[onContinue()](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncontinue)接口。
-   当应用触发迁移时，[onContinue()](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncontinue)接口在发起端被调用，开发者可以在该接口中保存迁移数据，实现应用兼容性检测，决定是否支持此次迁移。
-   - 保存迁移数据：开发者可以将要迁移的数据通过键值对的方式保存在wantParam中。
+4.在发起端UIAbility中实现[onContinue](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncontinue)接口。
+
+当应用触发迁移时，[onContinue](../reference/apis/js-apis-app-ability-uiAbility.md#abilityoncontinue)接口在发起端被调用，开发者可以在该接口中保存迁移数据，实现应用兼容性检测，决定是否支持此次迁移。
+
+- 保存迁移数据：开发者可以将要迁移的数据通过键值对的方式保存在wantParam中。
+
+- 应用兼容性检测：开发者可以通过从wantParam中获取目标应用的版本号与本应用版本号做兼容性校验。开发者可以在触发迁移时从`onContinue`接口中`wantParam.version`获取到迁移目标端应用的版本号与迁移发起端应用版本号做兼容校验。
+
+- 迁移决策：开发者可以通过onContinue接口的返回值决定是否支持此次迁移，返回值信息见[接口说明](#接口说明)。
+
+  示例如下：
+
+  ```ts
+  import UIAbility from '@ohos.app.ability.UIAbility';
+  import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+
+  export default class EntryAbility extends UIAbility {
+    onContinue(wantParam: Record<string, Object>) {
+      console.info(`onContinue version = ${wantParam.version}, targetDevice: ${wantParam.targetDevice}`) // 准备迁移数据
+      let continueInput = '迁移的数据';
+      if (continueInput) {
+        // 将要迁移的数据保存在wantParam的自定义字段（如：data）中;
+        wantParam["data"] = continueInput;
+      }
+      console.info(`onContinue input = ${wantParam["data"]}`);
+      return AbilityConstant.OnContinueResult.AGREE;
+    }
+  }
+  ```
+
+5.在Stage模型中，应用在不同启动模式下将调用不同的接口，以恢复数据、加载界面。
+
+不同情况下的函数调用如下图所示：
+
+![hop-cross-device-migration](figures/hop-cross-device-migration1.png)
+
+在目标端设备UIAbility中实现onCreate与onNewWant接口，恢复迁移数据。
+
+- onCreate实现示例
+   - 目标端设备上，在onCreate中根据launchReason判断该次启动是否为迁移LaunchReason.CONTINUATION。
+   - 开发者可以从want中获取保存的迁移数据。
+   - 完成数据恢复后，开发者需要调用restoreWindowStage来触发页面恢复：包括页面栈信息。
+     
+      ```ts
+      import UIAbility from '@ohos.app.ability.UIAbility';
+      import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+      import Want from '@ohos.app.ability.Want';
+
+      export default class EntryAbility extends UIAbility {
+        storage : LocalStorage = new LocalStorage();
+        onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
+          console.info(`EntryAbility onCreate ${AbilityConstant.LaunchReason.CONTINUATION}`)
+          if (launchParam.launchReason == AbilityConstant.LaunchReason.CONTINUATION) {
+            // 将上述的保存的数据取出恢复
+            let continueInput = '';
+            if (want.parameters != undefined) {
+              continueInput = JSON.stringify(want.parameters.data);
+              console.info(`continue input ${continueInput}`)
+            }
+            // 将数据显示当前页面
+            this.context.restoreWindowStage(this.storage);
+          }
+        }
+      }
+      ```
+- 如果是单实例应用，需要额外实现onNewWant接口，实现方式与onCreate的实现相同。
+   - 在onNewWant中判断迁移场景，恢复数据，并触发页面恢复
+
+    ```ts  
+    import UIAbility from '@ohos.app.ability.UIAbility';
+    import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+    import Want from '@ohos.app.ability.Want';
+
+    export default class EntryAbility extends UIAbility {
+      storage : LocalStorage = new LocalStorage();
+      onNewWant(want: Want, launchParam: AbilityConstant.LaunchParam): void {
+        console.info(`EntryAbility onNewWant ${AbilityConstant.LaunchReason.CONTINUATION}`)
+        if (launchParam.launchReason == AbilityConstant.LaunchReason.CONTINUATION) {
+          // get user data from want params
+          let continueInput = '';
+          if (want.parameters != undefined) {
+            continueInput = JSON.stringify(want.parameters.data);
+            console.info(`continue input ${continueInput}`);
+          }
+          this.context.restoreWindowStage(this.storage);
+        }
+      }
+    }
+    ```
+
+
+
+## 迁移功能可选配置
+
+### 1.动态配置迁移能力
+
+从API 10 起，提供了支持动态配置迁移能力的功能。即应用可以根据实际使用场景，在需要迁移功能时，设置开启应用迁移能力；在业务不需要迁移时，则可以关闭迁移能力。开发者可以通过调用[setMissionContinueState](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextsetmissioncontinuestate10)接口对迁移能力进行设置。默认状态下，可迁移应用的迁移能力为**ACTIVE**状态，即迁移能力开启，可以迁移。
+
+| 接口状态值                             | 含义                   |
+| :------------------------------------- | ---------------------- |
+| AbilityConstant.ContinueState.ACTIVE   | 应用当前可迁移能力开启 |
+| AbilityConstant.ContinueState.INACTIVE | 应用当前可迁移能力关闭 |
+
+**设置迁移能力的时机**
+
+迁移能力的改变可以根据实际业务需求和代码实现，发生在应用生命周期的绝大多数时机。本文介绍常用的几种配置方式。
+
+在ability的onCreate函数中调用接口，可以在应用创建时设置应用的迁移状态。
+
+```ts
+// EntryAbility.ets
+import UIAbility from '@ohos.app.ability.UIAbility';
+import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+import Want from '@ohos.app.ability.Want';
+export default class EntryAbility extends UIAbility {
+  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
+    // ...
+    this.context.setMissionContinueState(AbilityConstant.ContinueState.INACTIVE, (result) => {
+      console.info(`setMissionContinueState: ${JSON.stringify(result)}`);
+    });
+    // ...
+  }
+}
+```
+
+在页面的onPageShow函数中调用接口，可以设置单个页面出现时应用的迁移状态。
+
+```ts
+// PageName.ets
+import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+import common from '@ohos.app.ability.common'
+@Entry
+@Component
+struct PageName {
+  private context = getContext(this) as common.UIAbilityContext;
+  build() {
+    // ...
+  }
+  // ...
+  onPageShow(){
+  // 进入该页面时，将应用设置为可迁移状态
+    this.context.setMissionContinueState(AbilityConstant.ContinueState.ACTIVE, (result) => {
+      console.info('setMissionContinueState ACTIVE result: ', JSON.stringify(result));
+    });
+  }
+}
+```
+
+在某个组件的触发事件中设置应用迁移能力。如下例中，使用 **Button** 组件的 **onClick** 事件，触发迁移能力的改变。
+
+```ts
+// PageName.ets
+import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+import common from '@ohos.app.ability.common'
+@Entry
+@Component
+struct PageName {
+  private context = getContext(this) as common.UIAbilityContext;
+  build() {
+    // ...
+    Button() {
+      //...
+    }.onClick(()=>{
+    //点击该按钮时，将应用设置为可迁移状态
+      this.context.setMissionContinueState(AbilityConstant.ContinueState.ACTIVE, (result) => {
+        console.info('setMissionContinueState ACTIVE result: ', JSON.stringify(result));
+      });
+    })
+  }
+}
+```
+
+**保证迁移连续性**
+
+由于迁移加载时，目标端拉起的应用可能执行过自己的迁移状态设置命令（如：冷启动时目标端在onCreate中设置了 **INACTIVE** ；热启动时对端已打开了不可迁移的页面，迁移状态为 **INACTIVE** 等情况）。为了保证迁移过后的应用依然具有可以迁移回发起端的能力，应在 onCreate和onNewWant的迁移调用判断中，将迁移状态设置为 **ACTIVE** 。
+
+```ts
+// EntryAbility.ets
+import UIAbility from '@ohos.app.ability.UIAbility';
+import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+import Want from '@ohos.app.ability.Want';
+export default class EntryAbility extends UIAbility {
+  // ...
+  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
+    // ...
+    // 调用原因为迁移时，设置状态为可迁移，应对冷启动情况
+    this.context.setMissionContinueState(AbilityConstant.ContinueState.INACTIVE, (result) => {
+      console.info(`setMissionContinueState: ${JSON.stringify(result)}`);
+    });
+  }
+  onNewWant(want: Want, launchParam: AbilityConstant.LaunchParam): void {
+    // ...
+    // 调用原因为迁移时，设置状态为可迁移，应对热启动情况
+    if (launchParam.launchReason == AbilityConstant.LaunchReason.CONTINUATION) {
+      this.context.setMissionContinueState(AbilityConstant.ContinueState.ACTIVE, (result) => {
+        console.info('setMissionContinueState ACTIVE result: ', JSON.stringify(result));
+      });
+    }
+  }
+  // ...
+}
+```
+
+
+
+### 2.按需迁移页面栈
+
+支持应用动态选择是否进行页面栈恢复（默认进行页面栈信息恢复）。如果应用不想使用系统默认恢复的页面栈，则可以设置不进行页面栈迁移，而需要在`onWindowStageRestore`设置迁移后进入的页面，参数定义见[SUPPORT_CONTINUE_PAGE_STACK_KEY](../reference/apis/js-apis-app-ability-wantConstant.md#wantconstantparams)。
+
+应用在发起端的页面栈中存在Index和Second路由，而在目标端恢复时不需要按照发起端页面栈进行恢复，需要恢复到指定页面。
+
+- 示例：应用迁移不需要自动迁移页面栈信息
+
+    ```ts
+    // EntryAbility.ets
+    import UIAbility from '@ohos.app.ability.UIAbility';
+    import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+    import wantConstant from '@ohos.app.ability.wantConstant';
+    import window from '@ohos.window';
+    export default class EntryAbility extends UIAbility {
+      // ...
+      onContinue(wantParam: Record<string, Object>) {
+        console.info(`onContinue version = ${wantParam.version}, targetDevice: ${wantParam.targetDevice}`);
+        wantParam[wantConstant.Params.SUPPORT_CONTINUE_PAGE_STACK_KEY] = false;
+        return AbilityConstant.OnContinueResult.AGREE;
+      }
+      // ...
+      onWindowStageRestore(windowStage: window.WindowStage) {
+          // 若不需要自动迁移页面栈信息，则需要在此处设置应用迁移后进入的页面
+        windowStage.loadContent('pages/Index', (err, data) => {
+          if (err.code) {
+            console.info('Failed to load the content. Cause: %{public}s', JSON.stringify(err) ?? '');
+            return;
+          }
+          console.info('Succeeded in loading the content. Data: %{public}s', JSON.stringify(data) ?? '');
+        });
+      }
+    }
+    ```
 
-   - 应用兼容性检测：开发者可以通过从wantParam中获取目标应用的版本号与本应用版本号做兼容性校验。开发者可以在触发迁移时从`onContinue`接口中`wantParam.version`获取到迁移接收端应用的版本号与迁移发起端应用版本号做兼容校验。
+### 3.按需退出
 
-   - 迁移决策：开发者可以通过onContinue接口的返回值决定是否支持此次迁移，返回值信息见[接口说明](#接口说明)。
+支持应用动态选择迁移成功后是否退出迁移发起端应用（默认迁移成功后退出迁移发起端应用）。如果应用不想让系统自动退出迁移发起端应用，则可以设置不退出，参数定义见[SUPPORT_CONTINUE_SOURCE_EXIT_KEY](../reference/apis/js-apis-app-ability-wantConstant.md#wantconstantparams)。
 
-     示例如下：
+- 示例：应用迁移设置不需要迁移成功后退出迁移发起端应用
 
-   ```ts
-   import UIAbility from '@ohos.app.ability.UIAbility';
-   import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+    ```ts
+    import UIAbility from '@ohos.app.ability.UIAbility';
+    import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+    import wantConstant from '@ohos.app.ability.wantConstant';
+    export default class EntryAbility extends UIAbility {
+      // ...
+      onContinue(wantParam: Record<string, Object>) {
+        console.info(`onContinue version = ${wantParam.version}, targetDevice: ${wantParam.targetDevice}`);
+        wantParam[wantConstant.Params.SUPPORT_CONTINUE_SOURCE_EXIT_KEY] = false;
+        return AbilityConstant.OnContinueResult.AGREE;
+      }
+      // ...
+    }
+    ```
 
-   onContinue(wantParam : {[key: string]: any}) {
-       console.info(`onContinue version = ${wantParam.version}, targetDevice: ${wantParam.targetDevice}`)
-       let workInput = AppStorage.Get<string>('ContinueWork');
-       // set user input data into want params
-       wantParam["work"] = workInput // set user input data into want params
-       console.info(`onContinue input = ${wantParam["input"]}`);
-       return AbilityConstant.OnContinueResult.AGREE
-   }
-   ```
+## 验证指导
 
-5. 在目标端设备UIAbility中实现onCreate()与onNewWant()接口，恢复迁移数据。
-   - onCreate实现示例
-      - 目标端设备上，在onCreate中根据launchReason判断该次启动是否为迁移LaunchReason.CONTINUATION。
-      - 开发者可以从want中获取保存的迁移数据。
-      - 完成数据恢复后，开发者需要调用restoreWindowStage来触发页面恢复：包括页面栈信息。
-
-         ```ts
-         import UIAbility from '@ohos.app.ability.UIAbility';
-         import AbilityConstant from '@ohos.app.ability.AbilityConstant';
-         import distributedObject from '@ohos.data.distributedDataObject';
-
-         export default class EntryAbility extends UIAbility {
-             storage : LocalStorage;
-             onCreate(want, launchParam) {
-                 console.info(`EntryAbility onCreate ${AbilityConstant.LaunchReason.CONTINUATION}`)
-                 if (launchParam.launchReason == AbilityConstant.LaunchReason.CONTINUATION) {
-                     // get user data from want params
-                     let workInput = want.parameters.work
-                     console.info(`work input ${workInput}`)
-                     AppStorage.SetOrCreate<string>('ContinueWork', workInput)
-                     this.storage = new LocalStorage();
-                     this.context.restoreWindowStage(this.storage);
-                 }
-             }
-         }
-         ```
-   - 如果是单实例应用，需要额外实现onNewWant()接口，实现方式与onCreate()的实现相同。
-      - 在onNewWant()中判断迁移场景，恢复数据，并触发页面恢复
-
-         ```ts
-         export default class EntryAbility extends UIAbility {
-             storage : LocalStorage;
-             onNewWant(want, launchParam) {
-                 console.info(`EntryAbility onNewWant ${AbilityConstant.LaunchReason.CONTINUATION}`)
-                 if (launchParam.launchReason == AbilityConstant.LaunchReason.CONTINUATION) {
-                     // get user data from want params
-                     let workInput = want.parameters.work
-                     console.info(`work input ${workInput}`)
-                     AppStorage.SetOrCreate<string>('ContinueWork', workInput)
-                     this.storage = new LocalStorage();
-                     this.context.restoreWindowStage(this.storage);
-                 }
-             }
-         }
+为方便开发者验证已开发的可迁移应用，当前OpenHarmony提供了一个全局任务中心demo作为迁移的入口。下面介绍通过安装全局任务中心来验证迁移的方式。
 
-6. **可选配置：** 在应用支持迁移特性时，默认开启应用迁移状态开关，根据应用当前任务获取焦点/失去焦点通知周边的可信设备当前任务可流转/取消流转。若应用需要在特定场景下才通知周边设备可流转，则需要在应用打开时设置迁移状态为INACTIVE，在后续的业务流程中需要迁移时再设置迁移状态为ACTIVE。接口见[setMissionContinueState](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextsetmissioncontinuestate10)。
+### 1. 编译安装全局任务中心
 
-    - 示例：应用启动不需要流转
+#### **配置环境**
 
-        ```ts
-        import UIAbility from '@ohos.app.ability.UIAbility';
-        import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+public-SDK不支持开发者使用所有的系统API，例如：全局任务中心使用的[**@ohos.distributedDeviceManager**](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/reference/apis/js-apis-distributedDeviceManager.md)不包括在public_SDK中。因此为了正确编译安装全局任务中心，开发者需要替换full-SDK，具体操作可参见[替换指南](https://gitee.com/openharmony/docs/blob/master/zh-cn/application-dev/faqs/full-sdk-switch-guide.md)。
 
-        onCreate(want, launchParam) {
-          this.context.setMissionContinueState(AbilityConstant.ContinueState.INACTIVE, (result) => {
-            console.info(`setMissionContinueState: ${JSON.stringify(result)}`);
-          });
-        }
-        ```
-    - 示例：应用在后续的业务流程中需要流转了
+**说明**：本文中的截图仅为参考，具体的显示界面请以实际使用的DevEco Studio和SDK的版本为准。
 
-        ```ts
-        import UIAbility from '@ohos.app.ability.UIAbility';
-        import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+#### **下载MissionCenter_Demo[示例代码](https://gitee.com/openharmony/ability_dmsfwk/tree/master/services/dtbschedmgr/test/missionCenterDemo/dmsDemo/entry/src/main)**
 
-        this.context.setMissionContinueState(AbilityConstant.ContinueState.ACTIVE, (result) => {
-          console.info(`setMissionContinueState: ${JSON.stringify(result)}`);
-        });
-        ```
+#### **编译工程文件**
 
-7. **可选配置：** 支持应用动态选择是否进行页面栈恢复（默认进行页面栈信息恢复）。如果应用不想使用系统默认恢复的页面栈，则可以设置不进行页面栈迁移，而需要在`onWindowStageRestore`设置流转后进入的页面，参数定义见[SUPPORT_CONTINUE_PAGE_STACK_KEY](../reference/apis/js-apis-app-ability-wantConstant.md#wantconstantparams)。
+**新建OpenHarmony 空的工程，找到对应的文件夹替换下载文件**
 
-    - 示例：应用迁移不需要自动流转页面栈信息
+![hop-cross-device-migration](figures/hop-cross-device-migration2.png)
 
-        ```ts
-        import UIAbility from '@ohos.app.ability.UIAbility';
-        import wantConstant from '@ohos.app.ability.wantConstant.d.ts';
+**自动签名，编译安装。**
 
-        onContinue(wantParam : {[key: string]: any}) {
-            console.info(`onContinue version = ${wantParam.version}, targetDevice: ${wantParam.targetDevice}`)
-            wantParam[wantConstant.Params.SUPPORT_CONTINUE_PAGE_STACK_KEY] = false;
-            return AbilityConstant.OnContinueResult.AGREE;
-        }
+​		DevEco的自动签名模板默认签名权限为normal级。而本应用设计到ohos.permission.MANAGE_MISSIONS权限为system_core级别。自动生成的签名无法获得足够的权限，所以需要将权限升级为system_core级别，然后签名。
 
-        onWindowStageRestore(windowStage) {
-            // 若不需要自动流转页面栈信息，则需要在此处设置应用流转后进入的页面
-            windowStage.setUIContent(this.contex, "pages/index", null);
-        }
-        ```
+**系统权限设置**(以api10目录为例): 将Sdk目录下的openharmony\api版本(如：10)\toolchains\lib\UnsgnedReleasedProfileTemplate.json文件中的"apl":"normal_core"改为"apl":"system_core"。
 
-8. **可选配置：** 支持应用动态选择迁移成功后是否退出迁移发起端应用（默认流转成功后退出迁移发起端应用）。如果应用不想让系统自动退出迁移发起端应用，则可以设置不退出，参数定义见参数定义见[SUPPORT_CONTINUE_SOURCE_EXIT_KEY](../reference/apis/js-apis-app-ability-wantConstant.md#wantconstantparams)。
+①点击file->Project Structrue
 
-    - 示例：应用迁移设置不需要迁移成功后退出迁移发起端应用
+![hop-cross-device-migration](figures/hop-cross-device-migration3.png)
 
-        ```ts
-        import UIAbility from '@ohos.app.ability.UIAbility';
-        import wantConstant from '@ohos.app.ability.wantConstant.d.ts';
+②点击Signing Configs  点击OK
 
-        onContinue(wantParam : {[key: string]: any}) {
-            console.info(`onContinue version = ${wantParam.version}, targetDevice: ${wantParam.targetDevice}`)
-            wantParam[wantConstant.Params.SUPPORT_CONTINUE_SOURCE_EXIT_KEY] = false;
-            return AbilityConstant.OnContinueResult.AGREE;
-        }
-        ```
+![hop-cross-device-migration](figures/hop-cross-device-migration4.png)
+
+③连接开发板运行生成demo。
+
+### 2.设备组网
+
\ No newline at end of file
+①打开A，B两设备的计算器
+
+②点击右上角箭头选择B设备
+
+③在B设备选择信任设备，弹出PIN码
+
+④在A设备输入PIN码
+
+⑤已组网成功，验证方法：在A设备输入数字，B设备同步出现则证明组网成功
+
+### 3.发起迁移
+
+1.在B设备打开多设备协同权限的应用，A设备打开全局任务中心demo，A设备出现A设备名称(即：本机:OpenHarmony 3.2)和B设备名称(OpenHarmony 3.2)。
+
+![hop-cross-device-migration](figures/hop-cross-device-migration5.png)
+
+2.点击B设备名称，然后出现B设备的应用。
+
+![hop-cross-device-migration](figures/hop-cross-device-migration6.png)
+
+3.最后将应用拖拽到A设备名称处，A设备应用被拉起，B设备应用退出。
+
+![hop-cross-device-migration](figures/hop-cross-device-migration7.png)

zh-cn/application-dev/application-models/hop-multi-device-collaboration.md

-# 多端协同（仅对系统应用开放）
+# 多端协同
 
 
 ## 功能描述
@@ -56,29 +56,32 @@
 3. 获取目标设备的设备ID。
 
    ```ts
-   import deviceManager from '@ohos.distributedHardware.deviceManager';
-   
-   let dmClass;
+   import deviceManager from '@ohos.distributedDeviceManager';
+
+   let dmClass: deviceManager.DeviceManager;
    function initDmClass() {
-       // 其中createDeviceManager接口为系统API
-       deviceManager.createDeviceManager('ohos.samples.demo', (err, dm) => {
-           if (err) {
-               ...
-               return
-           }
-           dmClass = dm
-       })
+        // 其中createDeviceManager接口为系统API
+        try{
+            dmClass = deviceManager.createDeviceManager('ohos.samples.demo');
+        } catch(err) {
+            console.error("createDeviceManager err: " + JSON.stringify(err));
+        }
    }
    function getRemoteDeviceId() {
        if (typeof dmClass === 'object' && dmClass !== null) {
-           let list = dmClass.getTrustedDeviceListSync()
+           let list = dmClass.getAvailableDeviceListSync();
            if (typeof (list) === 'undefined' || typeof (list.length) === 'undefined') {
-               console.info('EntryAbility onButtonClick getRemoteDeviceId err: list is null')
+                console.info('getRemoteDeviceId err: list is null');
+                return;
+           }
+           if (list.length === 0) {
+               console.info("getRemoteDeviceId err: list is empty");
                return;
            }
-           return list[0].deviceId
+       	return list[0].networkId;
        } else {
-           console.info('EntryAbility onButtonClick getRemoteDeviceId err: dmClass is null')
+           console.info('getRemoteDeviceId err: dmClass is null');
+           return;
        }
    }
    ```
@@ -86,24 +89,29 @@
 4. 设置目标组件参数，调用[`startAbility()`](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstartability)接口，启动UIAbility或ServiceExtensionAbility。
 
    ```ts
-   let want = {
-       deviceId: getRemoteDeviceId(), 
+   import { BusinessError } from '@ohos.base';
+   import Want from '@ohos.app.ability.Want';
+   let want: Want = {
+       deviceId: getRemoteDeviceId(),
        bundleName: 'com.example.myapplication',
-       abilityName: 'FuncAbility',
-       moduleName: 'module1', // moduleName非必选
+       abilityName: 'EntryAbility',
+       moduleName: 'entry', // moduleName非必选
    }
    // context为发起端UIAbility的AbilityContext
    this.context.startAbility(want).then(() => {
-       ...
-   }).catch((err) => {
-       ...
+       // ...
+   }).catch((err: BusinessError) => {
+       // ...
+       console.error("startAbility err: " + JSON.stringify(err));
    })
    ```
 
-5. 当设备A发起端应用不需要设备B上的ServiceExtensionAbility时，可调用stopServiceExtensionAbility(../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstopserviceextensionability)接口退出。（该接口不支持UIAbility的退出，UIAbility由用户手动通过任务管理退出）
+5. 当设备A发起端应用不需要设备B上的ServiceExtensionAbility时，可调用[stopServiceExtensionAbility](../reference/apis/js-apis-inner-application-uiAbilityContext.md#uiabilitycontextstopserviceextensionability)接口退出。（该接口不支持UIAbility的退出，UIAbility由用户手动通过任务管理退出）
 
    ```ts
-   let want = {
+   import Want from '@ohos.app.ability.Want';
+   import { BusinessError } from '@ohos.base';
+   let want: Want = {
        deviceId: getRemoteDeviceId(),
        bundleName: 'com.example.myapplication',
        abilityName: 'FuncAbility',
@@ -112,7 +120,7 @@
    // 退出由startAbility接口启动的ServiceExtensionAbility
    this.context.stopServiceExtensionAbility(want).then(() => {
        console.info("stop service extension ability success")
-   }).catch((err) => {
+   }).catch((err: BusinessError) => {
        console.info("stop service extension ability err is " + JSON.stringify(err))
    })
    ```
@@ -142,55 +150,107 @@
 3. 在发起端设置目标组件参数，调用startAbilityForResult()接口启动目标端UIAbility，异步回调中的data用于接收目标端UIAbility停止自身后返回给调用方UIAbility的信息。getRemoteDeviceId方法参照[通过跨设备启动uiability和serviceextensionability组件实现多端协同无返回数据](#通过跨设备启动uiability和serviceextensionability组件实现多端协同无返回数据)。
 
    ```ts
-   let want = {
-       deviceId: getRemoteDeviceId(), 
-       bundleName: 'com.example.myapplication',
-       abilityName: 'FuncAbility',
-       moduleName: 'module1', // moduleName非必选
+   import AbilityConstant from '@ohos.app.ability.AbilityConstant';
+   import common from '@ohos.app.ability.common';
+   import { BusinessError } from '@ohos.base';
+   import Want from '@ohos.app.ability.Want';
+   @Entry
+   @Component
+   struct PageName {
+      private context = getContext(this) as common.UIAbilityContext;
+      build() {
+        // ...
+        Button('StartAbilityForResult')
+          .onClick(()=>{
+           let want: Want = {
+               deviceId: getRemoteDeviceId(),
+               bundleName: 'com.example.myapplication',
+               abilityName: 'FuncAbility',
+               moduleName: 'module1', // moduleName非必选
+           }
+           // context为发起端UIAbility的AbilityContext
+           this.context.startAbilityForResult(want).then((data) => {
+               // ...
+           }).catch((error: BusinessError) => {
+               console.info("startAbilityForResult err: " + JSON.stringify(error));
+           })
+          }
+        )
+      }
    }
-   // context为发起端UIAbility的AbilityContext
-   this.context.startAbilityForResult(want).then((data) => {
-       ...
-   }).catch((err) => {
-       ...
-   })
    ```
 
 4. 在目标端UIAbility任务完成后，调用terminateSelfWithResult()方法，将数据返回给发起端的UIAbility。
 
    ```ts
-   const RESULT_CODE: number = 1001;
-   let abilityResult = {
-       resultCode: RESULT_CODE,
-       want: {
-           bundleName: 'com.example.myapplication',
-           abilityName: 'FuncAbility',
-           moduleName: 'module1',
-       },
+   import { BusinessError } from '@ohos.base';
+   import common from '@ohos.app.ability.common';
+   @Entry
+   @Component
+   struct PageName {
+      private context = getContext(this) as common.UIAbilityContext;
+      build() {
+        // ...
+        Button('terminateSelfWithResult')
+          .onClick(()=>{
+               const RESULT_CODE: number = 1001;
+               // context为目标端UIAbility的AbilityContext
+               this.context.terminateSelfWithResult(
+                {
+                   resultCode: RESULT_CODE,
+                   want: {
+                       bundleName: 'com.example.myapplication',
+                       abilityName: 'FuncAbility',
+                       moduleName: 'module1',
+                   },
+               },
+               (err: BusinessError) => {
+                   // ...
+                   console.info("terminateSelfWithResult err: " + JSON.stringify(err));
+               });
+          }
+        // ...
+        )
+      }
    }
-   // context为目标端UIAbility的AbilityContext
-   this.context.terminateSelfWithResult(abilityResult, (err) => {
-       ...
-   });
    ```
 
 5. 发起端UIAbility接收到目标端UIAbility返回的信息，对其进行处理。
 
    ```ts
-   const RESULT_CODE: number = 1001;
-   
-   ...
-   
-   // context为调用方UIAbility的UIAbilityContext
-   this.context.startAbilityForResult(want).then((data) => {
-       if (data?.resultCode === RESULT_CODE) {
-           // 解析目标端UIAbility返回的信息
-           let info = data.want?.parameters?.info
-           ...
-       }
-   }).catch((err) => {
-       ...
-   })
+   import common from '@ohos.app.ability.common';
+   import { BusinessError } from '@ohos.base';
+   import Want from '@ohos.app.ability.Want';
+   @Entry
+   @Component
+   struct PageName {
+      private context = getContext(this) as common.UIAbilityContext;
+      build() {
+        // ...
+        Button('StartAbilityForResult')
+          .onClick(()=>{
+            let want: Want = {
+                deviceId: getRemoteDeviceId(),
+                bundleName: 'com.example.myapplication',
+                abilityName: 'FuncAbility',
+                moduleName: 'module1', // moduleName非必选
+            }
+            const RESULT_CODE: number = 1001;
+            // ...
+            // context为调用方UIAbility的UIAbilityContext
+            this.context.startAbilityForResult(want).then((data) => {
+                if (data?.resultCode === RESULT_CODE) {
+                    // 解析目标端UIAbility返回的信息
+                    let info = data.want?.parameters?.info;
+                    // ...
+                }
+            }).catch((error: BusinessError) => {
+                // ...
+            })
+          }
+        )
+      }
+   }
    ```
 
 
@@ -216,7 +276,7 @@
 
 2. 同时需要在应用首次启动时弹窗向用户申请授权，使用方式请参见[向用户申请授权](../security/accesstoken-guidelines.md#向用户申请授权)。
 
-3. 如果已有后台服务，请直接进入下一步；如果没有，则[实现一个后台服务](serviceextensionability.md#实现一个后台服务仅对系统应用开放)。
+3. 如果已有后台服务，请直接进入下一步；如果没有，则[实现一个后台服务](serviceextensionability.md#实现一个后台服务（仅对系统应用开放）)。
 
 4. 连接一个后台服务。
    - 实现IAbilityConnection接口。IAbilityConnection提供了以下方法供开发者实现：onConnect()是用来处理连接Service成功的回调，onDisconnect()是用来处理Service异常终止的回调，onFailed()是用来处理连接Service失败的回调。
@@ -227,48 +287,60 @@
      
       ```ts
       import rpc from '@ohos.rpc';
-      
-      const REQUEST_CODE = 99;
-      let want = {
-          "deviceId": getRemoteDeviceId(), 
-          "bundleName": "com.example.myapplication",
-          "abilityName": "ServiceExtAbility"
-      };
-      let options = {
-          onConnect(elementName, remote) {
-              console.info('onConnect callback');
-              if (remote === null) {
-                  console.info(`onConnect remote is null`);
-                  return;
-              }
-              let option = new rpc.MessageOption();
-              let data = new rpc.MessageParcel();
-              let reply = new rpc.MessageParcel();
-              data.writeInt(1);
-              data.writeInt(99);  // 开发者可发送data到目标端应用进行相应操作
-      
-              // @param code 表示客户端发送的服务请求代码。
-              // @param data 表示客户端发送的{@link MessageParcel}对象。
-              // @param reply 表示远程服务发送的响应消息对象。
-              // @param options 指示操作是同步的还是异步的。
-              // 
-              // @return 如果操作成功返回{@code true}； 否则返回 {@code false}。
-              remote.sendRequest(REQUEST_CODE, data, reply, option).then((ret) => {
-                  let msg = reply.readInt();   // 在成功连接的情况下，会收到来自目标端返回的信息（100）
-                  console.info(`sendRequest ret:${ret} msg:${msg}`);
-              }).catch((error) => {
-                  console.info('sendRequest failed');
-              });
-          },
-          onDisconnect(elementName) {
-              console.info('onDisconnect callback');
-          },
-          onFailed(code) {
-              console.info('onFailed callback');
+      import Want from '@ohos.app.ability.Want';
+      import common from '@ohos.app.ability.common';
+      import { BusinessError } from '@ohos.base';
+      @Entry
+      @Component
+      struct PageName {
+          private context = getContext(this) as common.UIAbilityContext;
+          build() {
+            // ...
+            Button('connectServiceExtensionAbility')
+              .onClick(()=>{
+                const REQUEST_CODE = 99;
+                let want: Want = {
+                    "deviceId": getRemoteDeviceId(),
+                    "bundleName": "com.example.myapplication",
+                    "abilityName": "ServiceExtAbility"
+                };
+                // 建立连接后返回的Id需要保存下来，在解绑服务时需要作为参数传入
+                let connectionId = this.context.connectServiceExtensionAbility(want,
+                {
+                    onConnect(elementName, remote) {
+                        console.info('onConnect callback');
+                        if (remote === null) {
+                            console.info(`onConnect remote is null`);
+                            return;
+                        }
+                        let option = new rpc.MessageOption();
+                        let data = new rpc.MessageParcel();
+                        let reply = new rpc.MessageParcel();
+                        data.writeInt(1);
+                        data.writeInt(99);  // 开发者可发送data到目标端应用进行相应操作
+                        // @param code 表示客户端发送的服务请求代码。
+                        // @param data 表示客户端发送的{@link MessageParcel}对象。
+                        // @param reply 表示远程服务发送的响应消息对象。
+                        // @param options 指示操作是同步的还是异步的。
+                        //
+                        // @return 如果操作成功返回{@code true}； 否则返回 {@code false}。
+                        remote.sendRequest(REQUEST_CODE, data, reply, option).then((ret: rpc.SendRequestResult) => {
+                            let msg = reply.readInt();   // 在成功连接的情况下，会收到来自目标端返回的信息（100）
+                            console.info(`sendRequest ret:${ret} msg:${msg}`);
+                        }).catch((error: BusinessError) => {
+                            console.info('sendRequest failed');
+                        });
+                    },
+                    onDisconnect(elementName) {
+                        console.info('onDisconnect callback');
+                    },
+                    onFailed(code) {
+                        console.info('onFailed callback');
+                    }
+                });
+              })
           }
       }
-      // 建立连接后返回的Id需要保存下来，在解绑服务时需要作为参数传入
-      let connectionId = this.context.connectServiceExtensionAbility(want, options);
       ```
 
       getRemoteDeviceId方法参照[通过跨设备启动uiability和serviceextensionability组件实现多端协同无返回数据](#通过跨设备启动uiability和serviceextensionability组件实现多端协同无返回数据)。
@@ -276,12 +348,25 @@
 5. 断开连接。调用disconnectServiceExtensionAbility()断开与后台服务的连接。
 
    ```ts
-   let connectionId = 1 // 在通过connectServiceExtensionAbility绑定服务时返回的Id
-   this.context.disconnectServiceExtensionAbility(connectionId).then((data) => {
-       console.info('disconnectServiceExtensionAbility success');
-   }).catch((error) => {
-       console.error('disconnectServiceExtensionAbility failed');
-   })
+   import common from '@ohos.app.ability.common';
+   import { BusinessError } from '@ohos.base';
+   @Entry
+   @Component
+   struct PageName {
+       private context = getContext(this) as common.UIAbilityContext;
+       build() {
+         // ...
+         Button('disconnectServiceExtensionAbility')
+           .onClick(()=>{
+                let connectionId: number = 1 // 在通过connectServiceExtensionAbility绑定服务时返回的Id
+                this.context.disconnectServiceExtensionAbility(connectionId).then(() => {
+                    console.info('disconnectServiceExtensionAbility success');
+                }).catch((error: BusinessError) => {
+                    console.error('disconnectServiceExtensionAbility failed');
+                })
+           })
+       }
+   }
    ```
 
 
@@ -340,29 +425,30 @@
      2. 导入UIAbility模块。
         
          ```ts
-         import Ability from '@ohos.app.ability.UIAbility';
+         import UIAbility from '@ohos.app.ability.UIAbility';
          ```
      3. 定义约定的序列化数据。
          调用端及被调用端发送接收的数据格式需协商一致，如下示例约定数据由number和string组成。
 
          
          ```ts
+         import rpc from '@ohos.rpc'
          export default class MyParcelable {
              num: number = 0;
              str: string = "";
          
-             constructor(num, string) {
+             constructor(num: number, string: string) {
                  this.num = num;
                  this.str = string;
              }
          
-             marshalling(messageSequence) {
+             marshalling(messageSequence: rpc.MessageParcel) {
                  messageSequence.writeInt(this.num);
                  messageSequence.writeString(this.str);
                  return true;
              }
          
-             unmarshalling(messageSequence) {
+             unmarshalling(messageSequence: rpc.MessageParcel) {
                  this.num = messageSequence.readInt();
                  this.str = messageSequence.readString();
                  return true;
@@ -373,24 +459,28 @@
            如下示例在Ability的onCreate注册MSG_SEND_METHOD监听，在onDestroy取消监听，收到序列化数据后作相应处理并返回。应用开发者根据实际业务需要做相应处理。
            
          ```ts
+         import rpc from '@ohos.rpc';
+         import Want from '@ohos.app.ability.Want';
+         import UIAbility from '@ohos.app.ability.UIAbility';
+         import AbilityConstant from '@ohos.app.ability.AbilityConstant';
          const TAG: string = '[CalleeAbility]';
          const MSG_SEND_METHOD: string = 'CallSendMsg';
          
-         function sendMsgCallback(data) {
+         function sendMsgCallback(data: rpc.MessageSequence): MyParcelable {
              console.info('CalleeSortFunc called');
          
              // 获取Caller发送的序列化数据
-             let receivedData = new MyParcelable(0, '');
+             let receivedData: MyParcelable = new MyParcelable(0, '');
              data.readParcelable(receivedData);
              console.info(`receiveData[${receivedData.num}, ${receivedData.str}]`);
          
              // 作相应处理
              // 返回序列化数据result给Caller
-             return new MyParcelable(receivedData.num + 1, `send ${receivedData.str} succeed`);
+             return new MyParcelable(Number(receivedData.num) + 1, `send ${receivedData.str} succeed`);
          }
          
-         export default class CalleeAbility extends Ability {
-             onCreate(want, launchParam) {
+         export default class CalleeAbility extends UIAbility {
+             onCreate(want: Want, launchParam: AbilityConstant.LaunchParam) {
                  try {
                      this.callee.on(MSG_SEND_METHOD, sendMsgCallback);
                  } catch (error) {
@@ -412,42 +502,48 @@
    1. 导入UIAbility模块。
       
        ```ts
-       import Ability from '@ohos.app.ability.UIAbility';
+       import UIAbility from '@ohos.app.ability.UIAbility';
        ```
    2. 获取Caller通信接口。
        Ability的context属性实现了startAbilityByCall方法，用于获取指定通用组件的Caller通信接口。如下示例通过this.context获取Ability实例的context属性，使用startAbilityByCall拉起Callee被调用端并获取Caller通信接口，注册Caller的onRelease和onRemoteStateChange监听。应用开发者根据实际业务需要做相应处理。
 
        
        ```ts
-       async onButtonGetRemoteCaller() {
-           var caller = undefined;
-           var context = this.context;
-       
-           context.startAbilityByCall({
-               deviceId: getRemoteDeviceId(),
-               bundleName: 'com.samples.CallApplication',
-               abilityName: 'CalleeAbility'
-           }).then((data) => {
-               if (data != null) {
-                   caller = data;
-                   console.info('get remote caller success');
-                   // 注册caller的release监听
-                   caller.onRelease((msg) => {
-                       console.info(`remote caller onRelease is called ${msg}`);
-                   })
-                   console.info('remote caller register OnRelease succeed');
-                   // 注册caller的协同场景下跨设备组件状态变化监听通知
-                   try {
-                        caller.onRemoteStateChange((str) => {
-                            console.info('Remote state changed ' + str);
-                        });
-                    } catch (error) {
-                        console.info('Caller.onRemoteStateChange catch error, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
+       import UIAbility, { Caller } from '@ohos.app.ability.UIAbility';
+       import { BusinessError } from '@ohos.base';
+       export default class EntryAbility extends UIAbility {
+            // ...
+            async onButtonGetRemoteCaller() {
+                let caller: Caller | undefined;
+                let context = this.context;
+
+                context.startAbilityByCall({
+                    deviceId: getRemoteDeviceId(),
+                    bundleName: 'com.samples.CallApplication',
+                    abilityName: 'CalleeAbility'
+                }).then((data) => {
+                    if (data != null) {
+                        caller = data;
+                        console.info('get remote caller success');
+                        // 注册caller的release监听
+                        caller.onRelease((msg) => {
+                            console.info(`remote caller onRelease is called ${msg}`);
+                        })
+                        console.info('remote caller register OnRelease succeed');
+                        // 注册caller的协同场景下跨设备组件状态变化监听通知
+                        try {
+                                caller.onRemoteStateChange((str) => {
+                                    console.info('Remote state changed ' + str);
+                                });
+                            } catch (error) {
+                                console.info('Caller.onRemoteStateChange catch error, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}');
+                            }
                     }
-               }
-           }).catch((error) => {
-               console.error(`get remote caller failed with ${error}`);
-           })
+                }).catch((error: BusinessError) => {
+                    console.error(`get remote caller failed with ${error}`);
+                })
+            }
+            // ...
        }
        ```
 
@@ -457,49 +553,72 @@
    1. 向被调用端发送Parcelable数据有两种方式，一种是不带返回值，一种是获取被调用端返回的数据，method以及序列化数据需要与被调用端协商一致。如下示例调用Call接口，向Callee被调用端发送数据。
       
        ```ts
+       import UIAbility, { Caller } from '@ohos.app.ability.UIAbility';
+       import { BusinessError } from '@ohos.base';
        const MSG_SEND_METHOD: string = 'CallSendMsg';
-       async onButtonCall() {
-           try {
-               let msg = new MyParcelable(1, 'origin_Msg');
-               await this.caller.call(MSG_SEND_METHOD, msg);
-           } catch (error) {
-               console.info(`caller call failed with ${error}`);
-           }
+       export default class EntryAbility extends UIAbility {
+        // ...
+        caller: Caller | undefined;
+        async onButtonCall() {
+            try {
+                let msg: MyParcelable = new MyParcelable(1, 'origin_Msg');
+                if (this.caller) {
+                    await this.caller.call(MSG_SEND_METHOD, msg);
+                }
+            } catch (error) {
+                console.info(`caller call failed with ${error}`);
+            }
+        }
+        // ...
        }
        ```
    2. 如下示例调用CallWithResult接口，向Callee被调用端发送待处理的数据originMsg，并将’CallSendMsg’方法处理完毕的数据赋值给backMsg。
       
-       ```ts
-       const MSG_SEND_METHOD: string = 'CallSendMsg';
-       originMsg: string = '';
-       backMsg: string = '';
-       async onButtonCallWithResult(originMsg, backMsg) {
-           try {
-               let msg = new MyParcelable(1, originMsg);
-               const data = await this.caller.callWithResult(MSG_SEND_METHOD, msg);
-               console.info('caller callWithResult succeed');
-       
-               let result = new MyParcelable(0, '');
-               data.readParcelable(result);
-               backMsg(result.str);
-               console.info(`caller result is [${result.num}, ${result.str}]`);
-           } catch (error) {
-               console.info(`caller callWithResult failed with ${error}`);
-           }
-       }
-       ```
+        ```ts
+        import UIAbility, { Caller } from '@ohos.app.ability.UIAbility';
+        import rpc from '@ohos.rpc';
+        const MSG_SEND_METHOD: string = 'CallSendMsg';
+        let originMsg: string = '';
+        let backMsg: string = '';
+        export default class EntryAbility extends UIAbility {
+            // ...
+            caller: Caller | undefined;
+            async onButtonCallWithResult(originMsg: string, backMsg: string) {
+                try {
+                    let msg: MyParcelable = new MyParcelable(1, originMsg);
+                    if (this.caller) {
+                        const data = await this.caller.callWithResult(MSG_SEND_METHOD, msg);
+                        console.info('caller callWithResult succeed');
+                        let result: MyParcelable = new MyParcelable(0, '');
+                        data.readParcelable(result);
+                        backMsg = result.str;
+                        console.info(`caller result is [${result.num}, ${result.str}]`);
+                    }
+                } catch (error) {
+                    console.info(`caller callWithResult failed with ${error}`);
+                }
+            }
+            // ...
+        }
+        ```
 
 6. 释放Caller通信接口。
    Caller不再使用后，应用开发者可以通过release接口释放Caller。
 
    ```ts
-   releaseCall() {
-       try {
-           this.caller.release();
-           this.caller = undefined
-           console.info('caller release succeed');
-       } catch (error) {
-           console.info(`caller release failed with ${error}`);
-       }
+   import UIAbility, { Caller } from '@ohos.app.ability.UIAbility';
+   export default class EntryAbility extends UIAbility {
+    caller: Caller | undefined;
+    releaseCall() {
+        try {
+            if (this.caller) {
+                this.caller.release();
+                this.caller = undefined;
+            }
+            console.info('caller release succeed');
+        } catch (error) {
+            console.info(`caller release failed with ${error}`);
+        }
+    }
    }
    ```

zh-cn/application-dev/reference/apis/js-apis-continuation-continuationManager.md

@@ -43,7 +43,8 @@ register(callback: AsyncCallback\<number>): void;
 **示例：**
 
   ```ts
-  let token = -1;
+  import continuationManager from '@ohos.continuation.continuationManager'
+  let token: number = -1;
   continuationManager.register((err, data) => {
     if (err.code != 0) {
       console.error('register failed, cause: ' + JSON.stringify(err));
@@ -85,17 +86,19 @@ register(options: ContinuationExtraParams, callback: AsyncCallback\<number>): vo
 **示例：**
 
   ```ts
-  let token = -1;
-  let continuationExtraParams = {
-    deviceType: ["00E"]
-  };
-  continuationManager.register(continuationExtraParams, (err, data) => {
-    if (err.code != 0) {
-      console.error('register failed, cause: ' + JSON.stringify(err));
-      return;
-    }
-    console.info('register finished, ' + JSON.stringify(data));
-    token = data;
+  import continuationManager from '@ohos.continuation.continuationManager'
+  let token: number = -1;
+  continuationManager.register(
+    {
+      deviceType: ["00E"]
+    },
+    (err, data) => {
+      if (err.code != 0) {
+        console.error('register failed, cause: ' + JSON.stringify(err));
+        return;
+      }
+      console.info('register finished, ' + JSON.stringify(data));
+      token = data;
   });
   ```
 
@@ -135,18 +138,16 @@ register(options?: ContinuationExtraParams): Promise\<number>;
 **示例：**
 
   ```ts
-  let token = -1;
-  let continuationExtraParams = {
-    deviceType: ["00E"]
-  };
-  continuationManager.register(continuationExtraParams)
-    .then((data) => {
+  import continuationManager from '@ohos.continuation.continuationManager'
+  import { BusinessError } from '@ohos.base';
+  let token: number = -1;
+  continuationManager.register(
+    { deviceType: ["00E"] }).then((data) => {
       console.info('register finished, ' + JSON.stringify(data));
       token = data;
-    })
-    .catch((err) => {
+    }).catch((err: BusinessError) => {
       console.error('register failed, cause: ' + JSON.stringify(err));
-    });
+  });
   ```
 
 ## continuationManager.registerContinuation<sup>9+</sup>
@@ -177,7 +178,8 @@ registerContinuation(callback: AsyncCallback\<number>): void;
 **示例：**
 
   ```ts
-  let token = -1;
+  import continuationManager from '@ohos.continuation.continuationManager'
+  let token: number = -1;
   try {
     continuationManager.registerContinuation((err, data) => {
       if (err.code != 0) {
@@ -221,18 +223,20 @@ registerContinuation(options: ContinuationExtraParams, callback: AsyncCallback\<
 **示例：**
 
   ```ts
-  let token = -1;
-  let continuationExtraParams = {
-    deviceType: ["00E"]
-  };
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = -1;
   try {
-    continuationManager.registerContinuation(continuationExtraParams, (err, data) => {
-      if (err.code != 0) {
-        console.error('registerContinuation failed, cause: ' + JSON.stringify(err));
-        return;
-      }
-      console.info('registerContinuation finished, ' + JSON.stringify(data));
-      token = data;
+    continuationManager.registerContinuation(
+      {
+        deviceType: ["00E"]
+      },
+      (err, data) => {
+        if (err.code != 0) {
+          console.error('registerContinuation failed, cause: ' + JSON.stringify(err));
+          return;
+        }
+        console.info('registerContinuation finished, ' + JSON.stringify(data));
+        token = data;
     });
   } catch (err) {
     console.error('registerContinuation failed, cause: ' + JSON.stringify(err));
@@ -273,19 +277,19 @@ registerContinuation(options?: ContinuationExtraParams): Promise\<number>;
 **示例：**
 
   ```ts
-  let token = -1;
-  let continuationExtraParams = {
-    deviceType: ["00E"]
-  };
+  import continuationManager from '@ohos.continuation.continuationManager';
+  import { BusinessError } from '@ohos.base';
+  let token: number = -1;
   try {
-    continuationManager.register(continuationExtraParams)
-      .then((data) => {
+    continuationManager.register(
+      {
+        deviceType: ["00E"]
+      }).then((data) => {
         console.info('registerContinuation finished, ' + JSON.stringify(data));
         token = data;
-      })
-      .catch((err) => {
+      }).catch((err: BusinessError) => {
         console.error('registerContinuation failed, cause: ' + JSON.stringify(err));
-      });
+    });
   } catch (err) {
     console.error('registerContinuation failed, cause: ' + JSON.stringify(err));
   }
@@ -324,6 +328,7 @@ on(type: "deviceConnect", callback: Callback\<ContinuationResult>): void;
 **示例：**
 
   ```ts
+  import continuationManager from '@ohos.continuation.continuationManager';
   continuationManager.on("deviceConnect", (data) => {
     console.info('onDeviceConnect deviceId: ' + JSON.stringify(data.id));
     console.info('onDeviceConnect deviceType: ' + JSON.stringify(data.type));
@@ -363,6 +368,7 @@ on(type: "deviceDisconnect", callback: Callback\<string>): void;
 **示例：**
 
   ```ts
+  import continuationManager from '@ohos.continuation.continuationManager';
   continuationManager.on("deviceDisconnect", (data) => {
     console.info('onDeviceDisconnect deviceId: ' + JSON.stringify(data));
   });
@@ -400,6 +406,7 @@ off(type: "deviceConnect", callback?: Callback\<ContinuationResult>): void;
 **示例：**
 
   ```ts
+  import continuationManager from '@ohos.continuation.continuationManager';
   continuationManager.off("deviceConnect", (data) => {
     console.info('onDeviceConnect deviceId: ' + JSON.stringify(data.id));
     console.info('onDeviceConnect deviceType: ' + JSON.stringify(data.type));
@@ -439,6 +446,7 @@ off(type: "deviceDisconnect", callback?: Callback\<string>): void;
 **示例：**
 
   ```ts
+  import continuationManager from '@ohos.continuation.continuationManager';
   continuationManager.off("deviceDisconnect", (data) => {
     console.info('onDeviceDisconnect deviceId: ' + JSON.stringify(data));
   });
@@ -475,7 +483,8 @@ on(type: "deviceSelected", token: number, callback: Callback\<Array\<Continuatio
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = 1;
   try {
     continuationManager.on("deviceSelected", token, (data) => {
       console.info('onDeviceSelected len: ' + data.length);
@@ -521,7 +530,8 @@ on(type: "deviceUnselected", token: number, callback: Callback\<Array\<Continuat
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = 1;
   try {
     continuationManager.on("deviceUnselected", token, (data) => {
       console.info('onDeviceUnselected len: ' + data.length);
@@ -567,7 +577,8 @@ off(type: "deviceSelected", token: number): void;
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = 1;
   try {
     continuationManager.off("deviceSelected", token);
   } catch (err) {
@@ -605,7 +616,8 @@ off(type: "deviceUnselected", token: number): void;
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = 1;
   try {
     continuationManager.off("deviceUnselected", token);
   } catch (err) {
@@ -646,7 +658,8 @@ startDeviceManager(token: number, callback: AsyncCallback\<void>): void;
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = 1;
   continuationManager.startDeviceManager(token, (err, data) => {
     if (err.code != 0) {
       console.error('startDeviceManager failed, cause: ' + JSON.stringify(err));
@@ -690,16 +703,19 @@ startDeviceManager(token: number, options: ContinuationExtraParams, callback: As
 **示例：**
 
   ```ts
-  let token = 1;
-  let continuationExtraParams = {
-    deviceType: ["00E"]
-  };
-  continuationManager.startDeviceManager(token, continuationExtraParams, (err, data) => {
-    if (err.code != 0) {
-      console.error('startDeviceManager failed, cause: ' + JSON.stringify(err));
-      return;
-    }
-    console.info('startDeviceManager finished, ' + JSON.stringify(data));
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = 1;
+  continuationManager.startDeviceManager(
+    token,
+    {
+      deviceType: ["00E"]
+    },
+    (err, data) => {
+      if (err.code != 0) {
+        console.error('startDeviceManager failed, cause: ' + JSON.stringify(err));
+        return;
+      }
+      console.info('startDeviceManager finished, ' + JSON.stringify(data));
   });
   ```
 
@@ -742,17 +758,18 @@ startDeviceManager(token: number, options?: ContinuationExtraParams): Promise\<v
 **示例：**
 
   ```ts
-  let token = 1;
-  let continuationExtraParams = {
-    deviceType: ["00E"]
-  };
-  continuationManager.startDeviceManager(token, continuationExtraParams)
-    .then((data) => {
+  import continuationManager from '@ohos.continuation.continuationManager';
+  import { BusinessError } from '@ohos.base';
+  let token: number = -1;
+  continuationManager.startDeviceManager(
+    token,
+    {
+      deviceType: ["00E"]
+    }).then((data) => {
       console.info('startDeviceManager finished, ' + JSON.stringify(data));
-    })
-    .catch((err) => {
+    }).catch((err: BusinessError) => {
       console.error('startDeviceManager failed, cause: ' + JSON.stringify(err));
-    });
+  });
   ```
 
 ## continuationManager.startContinuationDeviceManager<sup>9+</sup>
@@ -784,7 +801,8 @@ startContinuationDeviceManager(token: number, callback: AsyncCallback\<void>): v
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = -1;
   try {
     continuationManager.startContinuationDeviceManager(token, (err, data) => {
       if (err.code != 0) {
@@ -828,17 +846,20 @@ startContinuationDeviceManager(token: number, options: ContinuationExtraParams,
 **示例：**
 
   ```ts
-  let token = 1;
-  let continuationExtraParams = {
-    deviceType: ["00E"]
-  };
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = -1;
   try {
-    continuationManager.startContinuationDeviceManager(token, continuationExtraParams, (err, data) => {
-      if (err.code != 0) {
-        console.error('startContinuationDeviceManager failed, cause: ' + JSON.stringify(err));
-        return;
-      }
-      console.info('startContinuationDeviceManager finished, ' + JSON.stringify(data));
+    continuationManager.startContinuationDeviceManager(
+      token,
+      {
+        deviceType: ["00E"]
+      },
+      (err, data) => {
+        if (err.code != 0) {
+          console.error('startContinuationDeviceManager failed, cause: ' + JSON.stringify(err));
+          return;
+        }
+        console.info('startContinuationDeviceManager finished, ' + JSON.stringify(data));
     });
   } catch (err) {
     console.error('startContinuationDeviceManager failed, cause: ' + JSON.stringify(err));
@@ -880,16 +901,17 @@ startContinuationDeviceManager(token: number, options?: ContinuationExtraParams)
 **示例：**
 
   ```ts
-  let token = 1;
-  let continuationExtraParams = {
-    deviceType: ["00E"]
-  };
+  import continuationManager from '@ohos.continuation.continuationManager';
+  import { BusinessError } from '@ohos.base';
+  let token: number = -1;
   try {
-    continuationManager.startContinuationDeviceManager(token, continuationExtraParams)
-      .then((data) => {
+    continuationManager.startContinuationDeviceManager(
+      token,
+      {
+        deviceType: ["00E"]
+      }).then((data) => {
         console.info('startContinuationDeviceManager finished, ' + JSON.stringify(data));
-      })
-      .catch((err) => {
+      }).catch((err: BusinessError) => {
         console.error('startContinuationDeviceManager failed, cause: ' + JSON.stringify(err));
       });
   } catch (err) {
@@ -932,7 +954,8 @@ updateConnectStatus(token: number, deviceId: string, status: DeviceConnectState,
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = -1;
   let deviceId: string = "test deviceId";
   continuationManager.updateConnectStatus(token, deviceId, continuationManager.DeviceConnectState.CONNECTED, (err, data) => {
     if (err.code != 0) {
@@ -983,15 +1006,17 @@ updateConnectStatus(token: number, deviceId: string, status: DeviceConnectState)
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  import { BusinessError } from '@ohos.base';
+  let token: number = 1;
   let deviceId: string = "test deviceId";
   continuationManager.updateConnectStatus(token, deviceId, continuationManager.DeviceConnectState.CONNECTED)
     .then((data) => {
       console.info('updateConnectStatus finished, ' + JSON.stringify(data));
     })
-    .catch((err) => {
+    .catch((err: BusinessError) => {
       console.error('updateConnectStatus failed, cause: ' + JSON.stringify(err));
-    });
+  });
   ```
 
 ## continuationManager.updateContinuationState<sup>9+</sup>
@@ -1025,7 +1050,8 @@ updateContinuationState(token: number, deviceId: string, status: DeviceConnectSt
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = 1;
   let deviceId: string = "test deviceId";
   try {
     continuationManager.updateContinuationState(token, deviceId, continuationManager.DeviceConnectState.CONNECTED, (err, data) => {
@@ -1076,14 +1102,16 @@ updateContinuationState(token: number, deviceId: string, status: DeviceConnectSt
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  import { BusinessError } from '@ohos.base';
+  let token: number = 1;
   let deviceId: string = "test deviceId";
   try {
     continuationManager.updateContinuationState(token, deviceId, continuationManager.DeviceConnectState.CONNECTED)
       .then((data) => {
         console.info('updateContinuationState finished, ' + JSON.stringify(data));
       })
-      .catch((err) => {
+      .catch((err: BusinessError) => {
         console.error('updateContinuationState failed, cause: ' + JSON.stringify(err));
       });
   } catch (err) {
@@ -1122,7 +1150,8 @@ unregister(token: number, callback: AsyncCallback\<void>): void;
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  let token: number = 1;
   continuationManager.unregister(token, (err, data) => {
     if (err.code != 0) {
       console.error('unregister failed, cause: ' + JSON.stringify(err));
@@ -1167,14 +1196,15 @@ unregister(token: number): Promise\<void>;
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  import { BusinessError } from '@ohos.base';
+  let token: number = 1;
   continuationManager.unregister(token)
     .then((data) => {
       console.info('unregister finished, ' + JSON.stringify(data));
-    })
-    .catch((err) => {
+    }).catch((err: BusinessError) => {
       console.error('unregister failed, cause: ' + JSON.stringify(err));
-    });
+  });
   ```
 
 ## continuationManager.unregisterContinuation<sup>9+</sup>
@@ -1206,7 +1236,9 @@ unregisterContinuation(token: number, callback: AsyncCallback\<void>): void;
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  import { BusinessError } from '@ohos.base';
+  let token: number = 1;
   try {
     continuationManager.unregisterContinuation(token, (err, data) => {
       if (err.code != 0) {
@@ -1254,15 +1286,15 @@ unregisterContinuation(token: number): Promise\<void>;
 **示例：**
 
   ```ts
-  let token = 1;
+  import continuationManager from '@ohos.continuation.continuationManager';
+  import { BusinessError } from '@ohos.base';
+  let token: number = -1;
   try {
-    continuationManager.unregisterContinuation(token)
-      .then((data) => {
+    continuationManager.unregisterContinuation(token).then((data) => {
         console.info('unregisterContinuation finished, ' + JSON.stringify(data));
-      })
-      .catch((err) => {
+      }).catch((err: BusinessError) => {
         console.error('unregisterContinuation failed, cause: ' + JSON.stringify(err));
-      });
+    });
   } catch (err) {
     console.error('unregisterContinuation failed, cause: ' + JSON.stringify(err));
   }

zh-cn/application-dev/reference/apis/js-apis-distributedMissionManager.md

@@ -35,34 +35,35 @@ registerMissionListener(parameter: MissionDeviceInfo, options: MissionCallback,
 **示例：**
 
   ```ts
-  function NotifyMissionsChanged(deviceId) {
-      console.log('NotifyMissionsChanged deviceId ' + JSON.stringify(deviceId));
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
+  function NotifyMissionsChanged(deviceId: string): void {
+    console.log('NotifyMissionsChanged deviceId ' + JSON.stringify(deviceId));
   }
-  function NotifySnapshot(deviceId, missionId) {
-      console.log('NotifySnapshot deviceId ' + JSON.stringify(deviceId));
-      console.log('NotifySnapshot missionId ' + JSON.stringify(missionId));
+  function NotifySnapshot(deviceId: string, missionId: number): void {
+    console.log('NotifySnapshot deviceId ' + JSON.stringify(deviceId));
+    console.log('NotifySnapshot missionId ' + JSON.stringify(missionId));
   }
-  function NotifyNetDisconnect(deviceId, state) {
-      console.log('NotifyNetDisconnect deviceId ' + JSON.stringify(deviceId));
-      console.log('NotifyNetDisconnect state ' + JSON.stringify(state));
-  }
-  var parameter =  {
-      deviceId: ""
-  };
-  var options = {
-      notifyMissionsChanged: NotifyMissionsChanged,
-      notifySnapshot: NotifySnapshot,
-      notifyNetDisconnect: NotifyNetDisconnect
+  function NotifyNetDisconnect(deviceId: string, state: number): void {
+    console.log('NotifyNetDisconnect deviceId ' + JSON.stringify(deviceId));
+    console.log('NotifyNetDisconnect state ' + JSON.stringify(state));
   }
   try {
-      distributedMissionManager.registerMissionListener(parameter, options, (error) => {
-          if (error.code != 0) {
-              console.error('registerMissionListener failed, cause: ' + JSON.stringify(error))
-          }
-          console.info('registerMissionListener finished')
-      })
+    distributedMissionManager.registerMissionListener(
+      { deviceId: "" },
+      {
+        notifyMissionsChanged: NotifyMissionsChanged,
+        notifySnapshot: NotifySnapshot,
+        notifyNetDisconnect: NotifyNetDisconnect
+      },
+      (error: BusinessError) => {
+        if (error.code != 0) {
+          console.error('registerMissionListener failed, cause: ' + JSON.stringify(error))
+        }
+        console.info('registerMissionListener finished')
+      });
   } catch (error) {
-      console.error('registerMissionListener failed, cause: ' + JSON.stringify(error))
+    console.error('registerMissionListener failed, cause: ' + JSON.stringify(error))
   }
   ```
 ## distributedMissionManager.registerMissionListener
@@ -91,30 +92,29 @@ registerMissionListener(parameter: MissionDeviceInfo, options: MissionCallback):
 **示例：**
 
   ```ts
-  function NotifyMissionsChanged(deviceId) {
-      console.log('NotifyMissionsChanged deviceId ' + JSON.stringify(deviceId));
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
+  function NotifyMissionsChanged(deviceId: string): void {
+    console.log('NotifyMissionsChanged deviceId ' + JSON.stringify(deviceId));
   }
-  function NotifySnapshot(deviceId, missionId) {
-      console.log('NotifySnapshot deviceId ' + JSON.stringify(deviceId));
-      console.log('NotifySnapshot missionId ' + JSON.stringify(missionId));
+  function NotifySnapshot(deviceId: string, missionId: number): void {
+    console.log('NotifySnapshot deviceId ' + JSON.stringify(deviceId));
+    console.log('NotifySnapshot missionId ' + JSON.stringify(missionId));
   }
-  function NotifyNetDisconnect(deviceId, state) {
-      console.log('NotifyNetDisconnect deviceId ' + JSON.stringify(deviceId));
-      console.log('NotifyNetDisconnect state ' + JSON.stringify(state));
-  }
-  var parameter =  {
-      deviceId: ""
-  };
-  var options = {
-      notifyMissionsChanged: NotifyMissionsChanged,
-      notifySnapshot: NotifySnapshot,
-      notifyNetDisconnect: NotifyNetDisconnect
+  function NotifyNetDisconnect(deviceId: string, state: number): void {
+    console.log('NotifyNetDisconnect deviceId ' + JSON.stringify(deviceId));
+    console.log('NotifyNetDisconnect state ' + JSON.stringify(state));
   }
   try {
-      distributedMissionManager.registerMissionListener(parameter, options)
-      .then(data => {
+      distributedMissionManager.registerMissionListener(
+        { deviceId: "" },
+        {
+          notifyMissionsChanged: NotifyMissionsChanged,
+          notifySnapshot: NotifySnapshot,
+          notifyNetDisconnect: NotifyNetDisconnect
+        }).then((data: void) => {
           console.info('registerMissionListener finished, ' + JSON.stringify(data));
-      }).catch(error => {
+      }).catch((error: BusinessError) => {
           console.error('registerMissionListener failed, cause: ' + JSON.stringify(error));
       })
   } catch (error) {
@@ -142,16 +142,17 @@ unRegisterMissionListener(parameter: MissionDeviceInfo, callback: AsyncCallback&
 **示例：**
 
   ```ts
-  var parameter =  {
-      deviceId: ""
-  };
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
   try {
-      distributedMissionManager.unRegisterMissionListener(parameter, (error) => {
-          if (error.code != 0) {
-              console.error('unRegisterMissionListener failed, cause: ' + JSON.stringify(error))
-          }
-          console.info('unRegisterMissionListener finished')
-      })
+    distributedMissionManager.unRegisterMissionListener(
+      { deviceId: "" },
+      (error: BusinessError) => {
+        if (error.code != 0) {
+            console.error('unRegisterMissionListener failed, cause: ' + JSON.stringify(error))
+        }
+        console.info('unRegisterMissionListener finished')
+    })
   } catch (error) {
       console.error('unRegisterMissionListener failed, cause: ' + JSON.stringify(error))
   }
@@ -182,16 +183,14 @@ unRegisterMissionListener(parameter: MissionDeviceInfo): Promise<void>
 **示例：**
 
   ```ts
-  var parameter =  {
-      deviceId: ""
-  };
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
   try {
-      distributedMissionManager.unRegisterMissionListener(parameter)
-      .then(data => {
-          console.info('unRegisterMissionListener finished, ' + JSON.stringify(data));
-      }).catch(error => {
-          console.error('unRegisterMissionListener failed, cause: ' + JSON.stringify(error));
-      })
+    distributedMissionManager.unRegisterMissionListener({deviceId: ""}).then(() => {
+      console.info('unRegisterMissionListener finished successfully');
+    }).catch((error: BusinessError) => {
+        console.error('unRegisterMissionListener failed, cause: ' + JSON.stringify(error));
+    })
   } catch (error) {
       console.error('unRegisterMissionListener failed, cause: ' + JSON.stringify(error))
   }
@@ -217,20 +216,23 @@ startSyncRemoteMissions(parameter: MissionParameter, callback: AsyncCallback<
 **示例：**
 
   ```ts
-  var parameter =  {
-      deviceId: "",
-      fixConflict: false, 
-      tag: 0
-  };
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
   try {
-      distributedMissionManager.startSyncRemoteMissions(parameter, (error) => {
-          if (error.code != 0) {
-              console.error('startSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
-          }
-          console.info('startSyncRemoteMissions finished')
-      })
+    distributedMissionManager.startSyncRemoteMissions(
+      {
+        deviceId: "",
+        fixConflict: false,
+        tag: 0
+      },
+      (error: BusinessError) => {
+        if (error.code != 0) {
+          console.error('startSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
+        }
+        console.info('startSyncRemoteMissions finished')}
+    )
   } catch (error) {
-      console.error('startSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
+    console.error('startSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
   }
   ```
 
@@ -259,20 +261,22 @@ startSyncRemoteMissions(parameter: MissionParameter): Promise<void>
 **示例：**
 
   ```ts
-  var parameter =  {
-      deviceId: "",
-      fixConflict: false, 
-      tag: 0
-  };
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
   try {
-      distributedMissionManager.startSyncRemoteMissions(parameter)
-      .then(data => {
-          console.info('startSyncRemoteMissions finished, ' + JSON.stringify(data));
-      }).catch(error => {
-          console.error('startSyncRemoteMissions failed, cause: ' + JSON.stringify(error));
-      })
+    distributedMissionManager.startSyncRemoteMissions(
+      {
+        deviceId: "",
+        fixConflict: false,
+        tag: 0
+      }
+    ).then(() => {
+        console.info('startSyncRemoteMissions finished successfully');
+      }).catch((error: BusinessError) => {
+      console.error('startSyncRemoteMissions failed, cause: ' + JSON.stringify(error));
+    })
   } catch (error) {
-      console.error('startSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
+    console.error('startSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
   }
   ```
 
@@ -296,18 +300,21 @@ stopSyncRemoteMissions(parameter: MissionDeviceInfo, callback: AsyncCallback<
 **示例：**
 
   ```ts
-  var parameter =  {
-      deviceId: ""
-  };
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
   try {
-      distributedMissionManager.stopSyncRemoteMissions(parameter, (error) => {
-          if (error.code != 0) {
-              console.error('stopSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
-          }
-          console.info('stopSyncRemoteMissions finished')
-      })
+    distributedMissionManager.stopSyncRemoteMissions(
+      {
+        deviceId: ""
+      },
+      (error: BusinessError) => {
+        if (error.code != 0) {
+          console.error('stopSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
+        }
+        console.info('stopSyncRemoteMissions finished')}
+    )
   } catch (error) {
-      console.error('stopSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
+    console.error('stopSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
   }
   ```
 
@@ -336,18 +343,19 @@ stopSyncRemoteMissions(parameter: MissionDeviceInfo): Promise<void>
 **示例：**
 
   ```ts
-  var parameter =  {
-      deviceId: ""
-  };
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
   try {
-      distributedMissionManager.stopSyncRemoteMissions(parameter)
-      .then(data => {
-          console.info('stopSyncRemoteMissions finished, ' + JSON.stringify(data));
-      }).catch(error => {
-          console.error('stopSyncRemoteMissions failed, cause: ' + JSON.stringify(error));
-      })
+    distributedMissionManager.stopSyncRemoteMissions(
+      {
+        deviceId: ""
+      }).then((data: void) => {
+        console.info('stopSyncRemoteMissions finished successfully');
+      }).catch((error: BusinessError) => {
+      console.error('stopSyncRemoteMissions failed, cause: ' + JSON.stringify(error));
+    })
   } catch (error) {
-      console.error('stopSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
+    console.error('stopSyncRemoteMissions failed, cause: ' + JSON.stringify(error))
   }
   ```
 
@@ -385,27 +393,28 @@ continueMission(parameter: ContinueDeviceInfo, options: ContinueCallback, callba
 **示例：**
 
   ```ts
-  var parameter =  {
-      srcDeviceId: "",
-      dstDeviceId: "",
-      missionId: 1,
-      wantParam: {"key": "value"}
-  };
-  function onContinueDone(resultCode) {
-      console.log('onContinueDone resultCode: ' + JSON.stringify(resultCode));
-  };
-  var options = {
-      onContinueDone: onContinueDone
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
+  function onContinueDone(resultCode: number): void {
+    console.log('onContinueDone resultCode: ' + JSON.stringify(resultCode));
   };
   try {
-      distributedMissionManager.continueMission(parameter, options, (error) => {
-          if (error.code != 0) {
-              console.error('continueMission failed, cause: ' + JSON.stringify(error))
-          }
-          console.info('continueMission finished')
-      })
+    distributedMissionManager.continueMission(
+      {
+        srcDeviceId: "",
+        dstDeviceId: "",
+        missionId: 1,
+        wantParam: {"key": "value"}
+      },
+      { onContinueDone: onContinueDone },
+      (error: BusinessError) => {
+        if (error.code != 0) {
+          console.error('continueMission failed, cause: ' + JSON.stringify(error))
+        }
+        console.info('continueMission finished')
+    })
   } catch (error) {
-      console.error('continueMission failed, cause: ' + JSON.stringify(error))
+    console.error('continueMission failed, cause: ' + JSON.stringify(error))
   }
   ```
 
@@ -448,27 +457,26 @@ continueMission(parameter: ContinueDeviceInfo, options: ContinueCallback): Promi
 **示例：**
 
   ```ts
-  var parameter =  {
-      srcDeviceId: "",
-      dstDeviceId: "",
-      missionId: 1,
-      wantParam: {"key": "value"}
-  };
-  function onContinueDone(resultCode) {
-      console.log('onContinueDone resultCode: ' + JSON.stringify(resultCode));
-  };
-  var options = {
-      onContinueDone: onContinueDone
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
+  function onContinueDone(resultCode: number): void {
+    console.log('onContinueDone resultCode: ' + JSON.stringify(resultCode));
   };
   try {
-      distributedMissionManager.continueMission(parameter, options)
-      .then(data => {
-          console.info('continueMission finished, ' + JSON.stringify(data));
-      }).catch(error => {
-          console.error('continueMission failed, cause: ' + JSON.stringify(error));
-      })
+    distributedMissionManager.continueMission(
+      {
+        srcDeviceId: "",
+        dstDeviceId: "",
+        missionId: 1,
+        wantParam: {"key": "value"}
+      },
+      { onContinueDone: onContinueDone }).then(() => {
+        console.info('continueMission finished successfully');
+      }).catch((error: BusinessError) => {
+      console.error('continueMission failed, cause: ' + JSON.stringify(error));
+    })
   } catch (error) {
-      console.error('continueMission failed, cause: ' + JSON.stringify(error))
+    console.error('continueMission failed, cause: ' + JSON.stringify(error))
   }
   ```
 
@@ -505,21 +513,24 @@ continueMission(parameter: ContinueMissionInfo, callback: AsyncCallback<void&
 **示例：**
 
   ```ts
-  var parameter =  {
-      srcDeviceId: "",
-      dstDeviceId: "",
-      bundleName: "ohos.test.continueapp",
-      wantParam: {"key": "value"}
-  };
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
   try {
-      distributedMissionManager.continueMission(parameter, (error) => {
-          if (error.code != 0) {
-              console.error('continueMission failed, cause: ' + JSON.stringify(error))
-          }
-          console.info('continueMission finished')
-      })
+    distributedMissionManager.continueMission(
+      {
+        srcDeviceId: "",
+        dstDeviceId: "",
+        bundleName: "ohos.test.continueapp",
+        wantParam: {"key": "value"}
+      },
+      (error: BusinessError) => {
+        if (error.code != 0) {
+          console.error('continueMission failed, cause: ' + JSON.stringify(error))
+        }
+        console.info('continueMission finished')
+    })
   } catch (error) {
-      console.error('continueMission failed, cause: ' + JSON.stringify(error))
+    console.error('continueMission failed, cause: ' + JSON.stringify(error))
   }
   ```
 
@@ -561,17 +572,19 @@ continueMission(parameter: ContinueMissionInfo): Promise<void>
 **示例：**
 
   ```ts
-  var parameter =  {
-      srcDeviceId: "",
-      dstDeviceId: "",
-      bundleName: "ohos.test.continueapp",
-      wantParam: {"key": "value"}
-  };
+  import distributedMissionManager from '@ohos.distributedMissionManager'
+  import { BusinessError } from '@ohos.base';
   try {
-      distributedMissionManager.continueMission(parameter)
-      .then(data => {
-          console.info('continueMission finished, ' + JSON.stringify(data));
-      }).catch(error => {
+      distributedMissionManager.continueMission(
+        {
+          srcDeviceId: "",
+          dstDeviceId: "",
+          bundleName: "ohos.test.continueapp",
+          wantParam: {"key": "value"}
+        }
+      ).then(() => {
+          console.info('continueMission finished successfully');
+      }).catch((error: BusinessError) => {
           console.error('continueMission failed, cause: ' + JSON.stringify(error));
       })
   } catch (error) {
@@ -599,12 +612,13 @@ on(type: 'continueStateChange',  callback: Callback<{ state: ContinueState, i
 **示例：**
 
 ```js
+  import distributedMissionManager from '@ohos.distributedMissionManager'
   try {
     distributedMissionManager.on('continueStateChange', (data) => {
       console.info("continueStateChange on:" + JSON.stringify(data));
     });
-  } catch (err) {
-    console.error("continueStateChange errCode:" + err.code + ",errMessage:" + err.message);
+  } catch (error) {
+    console.error("continueStateChange err: " + JSON.stringify(error));
   }
   ```
 
@@ -628,12 +642,13 @@ off(type: 'continueStateChange',  callback?: Callback<{ state: ContinueState,
 **示例：**
 
 ```js
+  import distributedMissionManager from '@ohos.distributedMissionManager'
   try {
     distributedMissionManager.off('continueStateChange', (data) => {
-      console.info("continueStateChange on:" + JSON.stringify(data));
+      console.info("continueStateChange off:" + JSON.stringify(data));
     });
   } catch (err) {
-    console.error("continueStateChange errCode:" + err.code + ",errMessage:" + err.message);
+    console.error("continueStateChange err: " + JSON.stringify(error));
   }
   ```
 

zh-cn/application-dev/reference/apis/js-apis-inner-application-continuableInfo.md

@@ -25,13 +25,13 @@ import distributedMissionManager from '@ohos.distributedMissionManager';
 **示例：**
 
 ```js
-  import distributedMissionManager from '@ohos.distributedMissionManager';
-
-  try {
-    distributedMissionManager.on('continueStateChange', (data) => {
-      console.info("continueStateChange on:" + JSON.stringify(data));
-    });
-  } catch (err) {
-    console.error("continueStateChange errCode:" + err.code + ",errMessage:" + err.message);
-  }
-  ```
+import distributedMissionManager from '@ohos.distributedMissionManager';
+
+try {
+  distributedMissionManager.on('continueStateChange', (data) => {
+    console.info("continueStateChange on:" + JSON.stringify(data));
+  });
+} catch (err) {
+  console.error("continueStateChange err: " + JSON.stringify(err));
+}
+```
\ No newline at end of file

zh-cn/application-dev/reference/apis/js-apis-inner-application-continueCallback.md

@@ -26,26 +26,25 @@ Mission迁移完成后调用，返回迁移结果。
 
   ```ts
   import distributedMissionManager from '@ohos.distributedMissionManager';
+  import { BusinessError } from '@ohos.base';
 
-  let continueDeviceInfo = {
+  distributedMissionManager.continueMission(
+    {
       srcDeviceId: '123',
       dstDeviceId: '456',
       missionId: 123,
       wantParam: {
           'key':'value'
       }
-  };
-
-  let continueCallback = {
+    },
+    {
       onContinueDone(result) {
           console.log('onContinueDone, result: ${JSON.stringify(result)}');
       }
-  };
-
-  distributedMissionManager.continueMission(continueDeviceInfo, continueCallback, (error) => {
+    }, (error: BusinessError) => {
       if (error && error.code) {
           console.error('continueMission failed, error.code: ${error.code}, error.message: ${error.message}');
       }
       console.log('continueMission finished');
-  });
+    });
   ```

zh-cn/application-dev/reference/apis/js-apis-inner-application-continueDeviceInfo.md

@@ -24,22 +24,20 @@
   ```ts
   import distributedMissionManager from '@ohos.distributedMissionManager';
 
-  let continueDeviceInfo = {
+  distributedMissionManager.continueMission(
+    {
       srcDeviceId: '123',
       dstDeviceId: '456',
       missionId: 123,
       wantParam: {
           'key':'value'
       }
-  };
-
-  let continueCallback = {
-      onContinueDone(result) {
+    },
+    {
+      onContinueDone(result): void {
           console.log('onContinueDone, result: ${JSON.stringify(result)}');
       }
-  };
-
-  distributedMissionManager.continueMission(continueDeviceInfo, continueCallback, (error) => {
+    }, (error) => {
       if (error && error.code) {
           console.error('continueMission failed, error.code: ${error.code}, error.message: ${error.message}');
       }

zh-cn/application-dev/reference/apis/js-apis-inner-application-continueMissionInfo.md

@@ -28,15 +28,16 @@ import distributedMissionManager from '@ohos.distributedMissionManager';
 
   ```ts
   import distributedMissionManager from '@ohos.distributedMissionManager';
+  import { BusinessError } from '@ohos.base';
 
-  var parameter =  {
-      srcDeviceId: "",
-      dstDeviceId: "",
-      bundleName: "ohos.test.continueapp",
-      wantParam: {"key": "value"}
-  };
   try {
-      distributedMissionManager.continueMission(parameter, (error) => {
+      distributedMissionManager.continueMission(
+        {
+            srcDeviceId: "",
+            dstDeviceId: "",
+            bundleName: "ohos.test.continueapp",
+            wantParam: {"key": "value"}
+        }, (error: BusinessError) => {
           if (error.code != 0) {
               console.error('continueMission failed, cause: ' + JSON.stringify(error))
           }