HarmonyOS 应用开发之多端协同

于 2024-08-27 15:58:38 发布
阅读量957 收藏 26
点赞数 30
分类专栏： 移动开发 鸿蒙开发 harmonyOS 文章标签： harmonyos 鸿蒙开发 openharmony 移动开发 交互 多端协同
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yhdmyby/article/details/141605163
版权
移动开发 同时被 3 个专栏收录
100 篇文章 0 订阅
订阅专栏
鸿蒙开发
100 篇文章 0 订阅
订阅专栏
harmonyOS
87 篇文章 0 订阅
订阅专栏

多端协同流程

多端协同流程如下图所示。

图1 多端协同流程图

约束限制

  • 由于“多端协同任务管理”能力尚未具备，开发者当前只能通过开发系统应用获取设备列表，不支持三方应用接入。

  • 多端协同需遵循 分布式跨设备组件启动规则。

  • 为了获得最佳体验，使用want传输的数据建议在100KB以下。

通过跨设备启动UIAbility和ServiceExtensionAbility组件实现多端协同（无返回数据）

在设备A上通过发起端应用提供的启动按钮，启动设备B上指定的UIAbility与ServiceExtensionAbility。

接口说明

表1 跨设备启动API接口功能介绍

接口名描述
startAbility(want: Want, callback: AsyncCallback): void;启动UIAbility和ServiceExtensionAbility（callback形式）。
stopServiceExtensionAbility(want: Want, callback: AsyncCallback): void;退出启动的ServiceExtensionAbility（callback形式）。
stopServiceExtensionAbility(want: Want): Promise;退出启动的ServiceExtensionAbility（Promise形式）。

开发步骤

  1. 需要申请ohos.permission.DISTRIBUTED_DATASYNC权限，配置方式请参见 声明权限 。

  2. 同时需要在应用首次启动时弹窗向用户申请授权，使用方式请参见 向用户申请授权 。

  3. 获取目标设备的设备ID。

import deviceManager from '@ohos.distributedDeviceManager';
import hilog from '@ohos.hilog';

const TAG: string = '[Page_CollaborateAbility]';
const DOMAIN_NUMBER: number = 0xFF00;

let dmClass: deviceManager.DeviceManager;

function initDmClass(): void {
  // 其中createDeviceManager接口为系统API
  try {
    dmClass = deviceManager.createDeviceManager('com.samples.stagemodelabilitydevelop');
    hilog.info(DOMAIN_NUMBER, TAG, JSON.stringify(dmClass) ?? '');
  } catch (err) {
    hilog.error(DOMAIN_NUMBER, TAG, 'createDeviceManager err: ' + JSON.stringify(err));
  };
}

function getRemoteDeviceId(): string | undefined {
  if (typeof dmClass === 'object' && dmClass !== null) {
    let list = dmClass.getAvailableDeviceListSync();
    hilog.info(DOMAIN_NUMBER, TAG, JSON.stringify(dmClass), JSON.stringify(list));
    if (typeof (list) === 'undefined' || typeof (list.length) === 'undefined') {
      hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: list is null');
      return;
    }
    if (list.length === 0) {
      hilog.info(DOMAIN_NUMBER, TAG, `getRemoteDeviceId err: list is empty`);
      return;
    }
    return list[0].networkId;
  } else {
    hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: dmClass is null');
    return;
  }
}
  1. 设置目标组件参数，调用 startAbility() 接口，启动UIAbility或ServiceExtensionAbility。
import { BusinessError } from '@ohos.base';
import hilog from '@ohos.hilog';
import Want from '@ohos.app.ability.Want';
import deviceManager from '@ohos.distributedDeviceManager';
import common from '@ohos.app.ability.common';

const TAG: string = '[Page_CollaborateAbility]';
const DOMAIN_NUMBER: number = 0xFF00;
let dmClass: deviceManager.DeviceManager;

function getRemoteDeviceId(): string | undefined {
  if (typeof dmClass === 'object' && dmClass !== null) {
    let list = dmClass.getAvailableDeviceListSync();
    hilog.info(DOMAIN_NUMBER, TAG, JSON.stringify(dmClass), JSON.stringify(list));
    if (typeof (list) === 'undefined' || typeof (list.length) === 'undefined') {
      hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: list is null');
      return;
    }
    if (list.length === 0) {
      hilog.info(DOMAIN_NUMBER, TAG, `getRemoteDeviceId err: list is empty`);
      return;
    }
    return list[0].networkId;
  } else {
    hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: dmClass is null');
    return;
  }
};

@Entry
@Component
struct Page_CollaborateAbility {
  private context = getContext(this) as common.UIAbilityContext;

  build() {
    // ...
    Button('startAbility')
      .onClick(() => {
        let want: Want = {
          deviceId: getRemoteDeviceId(),
          bundleName: 'com.samples.stagemodelabilityinteraction',
          abilityName: 'CollaborateAbility',
      moduleName: 'entry' // moduleName非必选
        }
	   // context为发起端UIAbility的AbilityContext
        this.context.startAbility(want).then(() => {
    		// ...
        }).catch((err: BusinessError) => {
    		// ...
          hilog.error(DOMAIN_NUMBER, TAG, `startAbility err: ` + JSON.stringify(err));
        });
      }
      )
  }
}
  1. 当设备A发起端应用不需要设备B上的ServiceExtensionAbility时，可调用 stopServiceExtensionAbility 接口退出。（该接口不支持UIAbility的退出，UIAbility由用户手动通过任务管理退出）
import Want from '@ohos.app.ability.Want';
import hilog from '@ohos.hilog';
import { BusinessError } from '@ohos.base';
import deviceManager from '@ohos.distributedDeviceManager';
import common from '@ohos.app.ability.common';

const TAG: string = '[Page_CollaborateAbility]';
const DOMAIN_NUMBER: number = 0xFF00;
let dmClass: deviceManager.DeviceManager;

function getRemoteDeviceId(): string | undefined {
  if (typeof dmClass === 'object' && dmClass !== null) {
    let list = dmClass.getAvailableDeviceListSync();
    hilog.info(DOMAIN_NUMBER, TAG, JSON.stringify(dmClass), JSON.stringify(list));
    if (typeof (list) === 'undefined' || typeof (list.length) === 'undefined') {
      hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: list is null');
      return;
    }
    if (list.length === 0) {
      hilog.info(DOMAIN_NUMBER, TAG, `getRemoteDeviceId err: list is empty`);
      return;
    }
    return list[0].networkId;
  } else {
    hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: dmClass is null');
    return;
  }
};

@Entry
@Component
struct Page_CollaborateAbility {
  private context = getContext(this) as common.UIAbilityContext;

  build() {
    // ...
    Button('stopServiceExtensionAbility')
      .onClick(() => {
        let want: Want = {
          deviceId: getRemoteDeviceId(),
          bundleName: 'com.example.myapplication',
          abilityName: 'FuncAbility',
          moduleName: 'module1', // moduleName非必选
        }
        // 退出由startAbility接口启动的ServiceExtensionAbility
        this.context.stopServiceExtensionAbility(want).then(() => {
          console.info("stop service extension ability success")
        }).catch((err: BusinessError) => {
          console.info("stop service extension ability err is " + JSON.stringify(err))
        })
      })
  }
}

通过跨设备启动UIAbility组件实现多端协同（获取返回数据）

在设备A上通过应用提供的启动按钮，启动设备B上指定的UIAbility，当设备B上的UIAbility退出后，会将返回值发回设备A上的发起端应用。

接口说明

表2 跨设备启动，返回结果数据API接口功能描述

接口名描述
startAbilityForResult(want: Want, callback: AsyncCallback): void;启动UIAbility并在该Ability退出的时候返回执行结果（callback形式）。
terminateSelfWithResult(parameter: AbilityResult, callback: AsyncCallback): void;停止UIAbility，配合startAbilityForResult使用，返回给接口调用方AbilityResult信息（callback形式）。
terminateSelfWithResult(parameter: AbilityResult): Promise;停止UIAbility，配合startAbilityForResult使用，返回给接口调用方AbilityResult信息（promise形式）。

开发步骤

  1. 需要申请ohos.permission.DISTRIBUTED_DATASYNC权限，配置方式请参见 声明权限 。

  2. 同时需要在应用首次启动时弹窗向用户申请授权，使用方式请参见 向用户申请授权 。

  3. 在发起端设置目标组件参数，调用startAbilityForResult()接口启动目标端UIAbility，异步回调中的data用于接收目标端UIAbility停止自身后返回给调用方UIAbility的信息。getRemoteDeviceId方法参照 通过跨设备启动uiability和serviceextensionability组件实现多端协同无返回数据 。

import common from '@ohos.app.ability.common';
import hilog from '@ohos.hilog';
import { BusinessError } from '@ohos.base';
import Want from '@ohos.app.ability.Want';
import deviceManager from '@ohos.distributedDeviceManager';

const DOMAIN_NUMBER: number = 0xFF00;
const TAG: string = '[Page_CollaborateAbility]';
let dmClass: deviceManager.DeviceManager;

function getRemoteDeviceId(): string | undefined {
  if (typeof dmClass === 'object' && dmClass !== null) {
    let list = dmClass.getAvailableDeviceListSync();
    hilog.info(DOMAIN_NUMBER, TAG, JSON.stringify(dmClass), JSON.stringify(list));
    if (typeof (list) === 'undefined' || typeof (list.length) === 'undefined') {
      hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: list is null');
      return;
    }
    if (list.length === 0) {
      hilog.info(DOMAIN_NUMBER, TAG, `getRemoteDeviceId err: list is empty`);
      return;
    }
    return list[0].networkId;
  } else {
    hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: dmClass is null');
    return;
  }
};

@Entry
@Component
struct Page_CollaborateAbility {
  private context = getContext(this) as common.UIAbilityContext;

  build() {
    // ...
    Button('多端协同有返回数据')
      .onClick(()=>{
        let want: Want = {
          deviceId: getRemoteDeviceId(),
          bundleName: 'com.samples.stagemodelabilityinteraction',
          abilityName: 'CollaborateAbility',
          moduleName: 'entry' // moduleName非必选
        };
        // context为发起端UIAbility的AbilityContext
        this.context.startAbilityForResult(want).then((data) => {
          // ...
        }).catch((error: BusinessError) => {
          hilog.error(DOMAIN_NUMBER, TAG, `startAbilityForResult err: ` + JSON.stringify(error));
        })
      }
      )
  }
}
  1. 在目标端UIAbility任务完成后，调用terminateSelfWithResult()方法，将数据返回给发起端的UIAbility。
import common from '@ohos.app.ability.common';
import hilog from '@ohos.hilog';
import { BusinessError } from '@ohos.base';

const DOMAIN_NUMBER: number = 0xFF00;
const TAG: string = '[Page_CollaborateAbility]';

@Entry
@Component
struct PageName {
  
   private context = getContext(this) as common.UIAbilityContext;
  
   build() {
     // ...
     Button('关闭多设备协同界面并返回数据')
       .onClick(()=>{
       const RESULT_CODE: number = 1001;
       // context为目标端UIAbility的AbilityContext
       this.context.terminateSelfWithResult(
         {
           resultCode: RESULT_CODE,
           want: {
             bundleName: 'ohos.samples.stagemodelabilitydevelop',
             abilityName: 'CollaborateAbility',
             moduleName: 'entry',
             parameters: {
               info: '来自Page_CollaborateAbility页面'
             }
           }
         },
         (err: BusinessError) => {
           hilog.info(DOMAIN_NUMBER, TAG, `terminateSelfWithResult err: ` + JSON.stringify(err));
         });
     })
   }
}
  1. 发起端UIAbility接收到目标端UIAbility返回的信息，对其进行处理。
import common from '@ohos.app.ability.common';
import deviceManager from '@ohos.distributedDeviceManager';
import hilog from '@ohos.hilog';
import Want from '@ohos.app.ability.Want';
import { BusinessError } from '@ohos.base';

const TAG: string = '[Page_CollaborateAbility]';
const DOMAIN_NUMBER: number = 0xFF00;
let dmClass: deviceManager.DeviceManager;

function getRemoteDeviceId(): string | undefined {
  if (typeof dmClass === 'object' && dmClass !== null) {
    let list = dmClass.getAvailableDeviceListSync();
    hilog.info(DOMAIN_NUMBER, TAG, JSON.stringify(dmClass), JSON.stringify(list));
    if (typeof (list) === 'undefined' || typeof (list.length) === 'undefined') {
      hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: list is null');
      return;
    }
    if (list.length === 0) {
      hilog.info(DOMAIN_NUMBER, TAG, `getRemoteDeviceId err: list is empty`);
      return;
    }
    return list[0].networkId;
  } else {
    hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: dmClass is null');
    return;
  }
};

@Entry
@Component
struct PageName {
  private context = getContext(this) as common.UIAbilityContext;

  build() {
    // ...
    Button('多端协同有返回数据')
      .onClick(() => {
        let want: Want = {
          deviceId: getRemoteDeviceId(),
          bundleName: 'com.samples.stagemodelabilityinteraction',
          abilityName: 'CollaborateAbility',
          moduleName: 'entry' // 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) => {
          // ...
        })
      }
      )
  }
}

通过跨设备连接ServiceExtensionAbility组件实现多端协同

系统应用可以通过 connectServiceExtensionAbility() 跨设备连接一个服务，实现跨设备远程调用。比如：分布式游戏场景，平板作为遥控器，智慧屏作为显示器。

接口说明

表3 跨设备连接API接口功能介绍

接口名描述
connectServiceExtensionAbility(want: Want, options: ConnectOptions): number;连接ServiceExtensionAbility。
disconnectServiceExtensionAbility(connection: number, callback:AsyncCallback): void;断开连接（callback形式）。
disconnectServiceExtensionAbility(connection: number): Promise;断开连接（promise形式）。

开发步骤

  1. 需要申请ohos.permission.DISTRIBUTED_DATASYNC权限，配置方式请参见 声明权限。

  2. 同时需要在应用首次启动时弹窗向用户申请授权，使用方式请参见 向用户申请授权 。

  3. 如果已有后台服务，请直接进入下一步；如果没有，则 实现一个后台服务（仅对系统应用开放） 。

  4. 连接一个后台服务。

    • 实现IAbilityConnection接口。IAbilityConnection提供了以下方法供开发者实现：onConnect()是用来处理连接Service成功的回调，onDisconnect()是用来处理Service异常终止的回调，onFailed()是用来处理连接Service失败的回调。
    • 设置目标组件参数，包括目标设备ID、Bundle名称、Ability名称。
    • 调用connectServiceExtensionAbility发起连接。
    • 连接成功，收到目标设备返回的服务句柄。
    • 进行跨设备调用，获得目标端服务返回的结果。
import common from '@ohos.app.ability.common';
import deviceManager from '@ohos.distributedDeviceManager';
import hilog from '@ohos.hilog';
import rpc from '@ohos.rpc';
import Want from '@ohos.app.ability.Want';
import { BusinessError } from '@ohos.base';

const TAG: string = '[Page_CollaborateAbility]';
const DOMAIN_NUMBER: number = 0xFF00;
const REQUEST_CODE = 1;
let dmClass: deviceManager.DeviceManager;
let connectionId: number;
let options: common.ConnectOptions = {
  onConnect(elementName, remote) {
    hilog.info(DOMAIN_NUMBER, TAG, 'onConnect callback');
    if (remote === null) {
      hilog.info(DOMAIN_NUMBER, TAG, `onConnect remote is null`);
      return;
    }
    let option = new rpc.MessageOption();
    let data = new rpc.MessageSequence();
    let reply = new rpc.MessageSequence();
    data.writeInt(99); // 开发者可发送data到目标端应用进行相应操作
    // @param code 表示客户端发送的服务请求代码。
    // @param data 表示客户端发送的{@link MessageSequence}对象。
    // @param reply 表示远程服务发送的响应消息对象。
    // @param options 指示操作是同步的还是异步的。
    //
    // @return 如果操作成功返回{@code true}； 否则返回 {@code false}。
    remote.sendMessageRequest(REQUEST_CODE, data, reply, option).then((ret: rpc.RequestResult) => {
      let errCode = reply.readInt(); // 在成功连接的情况下，会收到来自目标端返回的信息（100）
      let msg: number = 0;
      if (errCode === 0) {
        msg = reply.readInt();
      }
  // 成功连接后台服务
      hilog.info(DOMAIN_NUMBER, TAG, `sendRequest msg:${msg}`);
    }).catch((error: BusinessError) => {
      hilog.info(DOMAIN_NUMBER, TAG, `sendRequest failed, ${JSON.stringify(error)}`);
    });
  },
  onDisconnect(elementName) {
    hilog.info(DOMAIN_NUMBER, TAG, 'onDisconnect callback');
  },
  onFailed(code) {
    hilog.info(DOMAIN_NUMBER, TAG, 'onFailed callback');
  }
};

function getRemoteDeviceId(): string | undefined {
  if (typeof dmClass === 'object' && dmClass !== null) {
    let list = dmClass.getAvailableDeviceListSync();
    hilog.info(DOMAIN_NUMBER, TAG, JSON.stringify(dmClass), JSON.stringify(list));
    if (typeof (list) === 'undefined' || typeof (list.length) === 'undefined') {
      hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: list is null');
      return;
    }
    if (list.length === 0) {
      hilog.info(DOMAIN_NUMBER, TAG, `getRemoteDeviceId err: list is empty`);
      return;
    }
    return list[0].networkId;
  } else {
    hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: dmClass is null');
    return;
  }
}

@Entry
@Component
struct PageName {
  private context = getContext(this) as common.UIAbilityContext;
  build() {
    // ...
    Button('connectServiceExtensionAbility')
      .onClick(()=>{
        let want: Want = {
          'deviceId': getRemoteDeviceId(),
          'bundleName': 'com.samples.stagemodelabilityinteraction',
          'abilityName': 'ServiceExtAbility'
        };
        // 建立连接后返回的Id需要保存下来，在解绑服务时需要作为参数传入
        connectionId = this.context.connectServiceExtensionAbility(want, options);
      })
  }
}

getRemoteDeviceId方法参照 通过跨设备启动uiability和serviceextensionability组件实现多端协同无返回数据 。

  1. 断开连接。调用disconnectServiceExtensionAbility()断开与后台服务的连接。
import common from '@ohos.app.ability.common';
import { BusinessError } from '@ohos.base';
import hilog from '@ohos.hilog';
import Want from '@ohos.app.ability.Want';
import rpc from '@ohos.rpc';
import IdlServiceExtProxy from '../IdlServiceExt/idl_service_ext_proxy';

let connectionId: number;
const TAG: string = '[Page_ServiceExtensionAbility]';
const DOMAIN_NUMBER: number = 0xFF00;
let want: Want = {
  deviceId: '',
  bundleName: 'com.samples.stagemodelabilitydevelop',
  abilityName: 'ServiceExtAbility'
};

let options: common.ConnectOptions = {
  onConnect(elementName, remote: rpc.IRemoteObject): void {
    hilog.info(DOMAIN_NUMBER, TAG, 'onConnect callback');
    if (remote === null) {
      hilog.info(DOMAIN_NUMBER, TAG, 'onConnect remote is null');
      return;
    }
    let serviceExtProxy: IdlServiceExtProxy = new IdlServiceExtProxy(remote);
    // 通过接口调用的方式进行通信，屏蔽了RPC通信的细节，简洁明了
    serviceExtProxy.processData(1, (errorCode: number, retVal: number) => {
      hilog.info(DOMAIN_NUMBER, TAG, `processData, errorCode: ${errorCode}, retVal: ${retVal}`);
    });
    serviceExtProxy.insertDataToMap('theKey', 1, (errorCode: number) => {
      hilog.info(DOMAIN_NUMBER, TAG, `insertDataToMap, errorCode: ${errorCode}`);
    })
  },
  onDisconnect(elementName): void {
    hilog.info(DOMAIN_NUMBER, TAG, 'onDisconnect callback');
  },
  onFailed(code: number): void {
    hilog.info(DOMAIN_NUMBER, TAG, 'onFailed callback', JSON.stringify(code));
  }
};

@Entry
@Component
struct PageName {
  private context = getContext(this) as common.UIAbilityContext;

  build() {
    // ...
    Button('disconnectServiceExtensionAbility')
      .onClick(() => {
        this.context.disconnectServiceExtensionAbility(connectionId).then(() => {
          connectionId = this.context.connectServiceExtensionAbility(want, options);
          hilog.info(DOMAIN_NUMBER, TAG, 'disconnectServiceExtensionAbility success');
          // 成功断连后台服务
        }).catch((error: BusinessError) => {
          hilog.error(DOMAIN_NUMBER, TAG, 'disconnectServiceExtensionAbility failed');
        })
      })
  }
}

通过跨设备Call调用实现多端协同

跨设备Call调用的基本原理与设备内Call调用相同，请参见通过Call调用实现UIAbility交互（仅对系统应用开放） 。

下面介绍跨设备Call调用实现多端协同的方法。

接口说明

表4 Call API接口功能介绍

接口名描述
startAbilityByCall(want: Want): Promise;启动指定UIAbility至前台或后台，同时获取其Caller通信接口，调用方可使用Caller与被启动的Ability进行通信。
on(method: string, callback: CalleeCallBack): void通用组件Callee注册method对应的callback方法。
off(method: string): void通用组件Callee解注册method的callback方法。
call(method: string, data: rpc.Parcelable): Promise向通用组件Callee发送约定序列化数据。
callWithResult(method: string, data: rpc.Parcelable): Promise<rpc.MessageSequence>向通用组件Callee发送约定序列化数据, 并将Callee返回的约定序列化数据带回。
release(): void释放通用组件的Caller通信接口。
on(type: “release”, callback: OnReleaseCallback): void注册通用组件通信断开监听通知。

开发步骤

  1. 需要申请ohos.permission.DISTRIBUTED_DATASYNC权限，配置方式请参见 声明权限 。

  2. 同时需要在应用首次启动时弹窗向用户申请授权，使用方式请参见 向用户申请授权 。

  3. 创建被调用端UIAbility。 被调用端UIAbility需要实现指定方法的数据接收回调函数、数据的序列化及反序列化方法。在需要接收数据期间，通过on接口注册监听，无需接收数据时通过off接口解除监听。

  4. 配置UIAbility的启动模式。 配置module.json5，将CalleeAbility配置为单实例"singleton"。

Json字段字段说明
“launchType”Ability的启动模式，设置为"singleton"类型。

UIAbility配置标签示例如下：

"abilities":[{
    "name": ".CalleeAbility",
    "srcEntry": "./ets/CalleeAbility/CalleeAbility.ts",
    "launchType": "singleton",
    "description": "$string:CalleeAbility_desc",
    "icon": "$media:icon",
    "label": "$string:CalleeAbility_label",
    "exported": true
}]
  1. 导入UIAbility模块。
import UIAbility from '@ohos.app.ability.UIAbility';
  1. 定义约定的序列化数据。 调用端及被调用端发送接收的数据格式需协商一致，如下示例约定数据由number和string组成。
import rpc from '@ohos.rpc'
class MyParcelable {
  num: number = 0;
  str: string = '';

  constructor(num: number, string: string) {
    this.num = num;
    this.str = string;
  }

  mySequenceable(num: number, string: string): void {
    this.num = num;
    this.str = string;
  }

  marshalling(messageSequence: rpc.MessageSequence): boolean {
    messageSequence.writeInt(this.num);
    messageSequence.writeString(this.str);
    return true;
  };

  unmarshalling(messageSequence: rpc.MessageSequence): boolean {
    this.num = messageSequence.readInt();
    this.str = messageSequence.readString();
    return true;
  };
};
  1. 实现Callee.on监听及Callee.off解除监听。 如下示例在Ability的onCreate注册MSG_SEND_METHOD监听，在onDestroy取消监听，收到序列化数据后作相应处理并返回。应用开发者根据实际业务需要做相应处理。
import type AbilityConstant from '@ohos.app.ability.AbilityConstant';
import UIAbility from '@ohos.app.ability.UIAbility';
import type Want from '@ohos.app.ability.Want';
import hilog from '@ohos.hilog';
import type rpc from '@ohos.rpc';
import type { Caller } from '@ohos.app.ability.UIAbility';

const TAG: string = '[CalleeAbility]';
const MSG_SEND_METHOD: string = 'CallSendMsg';
const DOMAIN_NUMBER: number = 0xFF00;

class MyParcelable {
  num: number = 0;
  str: string = '';

  constructor(num: number, string: string) {
    this.num = num;
    this.str = string;
  };

  mySequenceable(num: number, string: string): void {
    this.num = num;
    this.str = string;
  };

  marshalling(messageSequence: rpc.MessageSequence): boolean {
    messageSequence.writeInt(this.num);
    messageSequence.writeString(this.str);
    return true;
  };

  unmarshalling(messageSequence: rpc.MessageSequence): boolean {
    this.num = messageSequence.readInt();
    this.str = messageSequence.readString();
    return true;
  };
};

function sendMsgCallback(data: rpc.MessageSequence): rpc.Parcelable {
  hilog.info(DOMAIN_NUMBER, TAG, '%{public}s', 'CalleeSortFunc called');

  // 获取Caller发送的序列化数据
  let receivedData: MyParcelable = new MyParcelable(0, '');
  data.readParcelable(receivedData);
  hilog.info(DOMAIN_NUMBER, TAG, '%{public}s', `receiveData[${receivedData.num}, ${receivedData.str}]`);
  let num: number = receivedData.num;

  // 作相应处理
  // 返回序列化数据result给Caller
  return new MyParcelable(num + 1, `send ${receivedData.str} succeed`) as rpc.Parcelable;
}

export default class CalleeAbility extends UIAbility {
  caller: Caller | undefined;

  onCreate(want: Want, launchParam: AbilityConstant.LaunchParam): void {
    try {
      this.callee.on(MSG_SEND_METHOD, sendMsgCallback);
    } catch (error) {
      hilog.error(DOMAIN_NUMBER, TAG, '%{public}s', `Failed to register. Error is ${error}`)
    };
  }

  onDestroy(): void {
    try {
      this.callee.off(MSG_SEND_METHOD);
      hilog.info(DOMAIN_NUMBER, TAG, '%{public}s', 'Callee OnDestroy');
      this.releaseCall();
    } catch (error) {
      hilog.error(DOMAIN_NUMBER, TAG, '%{public}s', `Failed to register. Error is ${error}`)
    };
  }
}
  1. 获取Caller接口，访问被调用端UIAbility。

1.导入UIAbility模块。

import UIAbility from '@ohos.app.ability.UIAbility';

2.获取Caller通信接口。 Ability的context属性实现了startAbilityByCall方法，用于获取指定通用组件的Caller通信接口。如下示例通过this.context获取Ability实例的context属性，使用startAbilityByCall拉起Callee被调用端并获取Caller通信接口，注册Caller的onRelease和onRemoteStateChange监听。应用开发者根据实际业务需要做相应处理。

import { Caller } from '@ohos.app.ability.UIAbility';
import { BusinessError } from '@ohos.base';
import common from '@ohos.app.ability.common';
import deviceManager from '@ohos.distributedDeviceManager';
import hilog from '@ohos.hilog';

const TAG: string = '[Page_CollaborateAbility]';
const DOMAIN_NUMBER: number = 0xFF00;
let caller: Caller | undefined;
let dmClass: deviceManager.DeviceManager;

function getRemoteDeviceId(): string | undefined {
  if (typeof dmClass === 'object' && dmClass !== null) {
    let list = dmClass.getAvailableDeviceListSync();
    hilog.info(DOMAIN_NUMBER, TAG, JSON.stringify(dmClass), JSON.stringify(list));
    if (typeof (list) === 'undefined' || typeof (list.length) === 'undefined') {
      hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: list is null');
      return;
    }
    if (list.length === 0) {
      hilog.info(DOMAIN_NUMBER, TAG, `getRemoteDeviceId err: list is empty`);
      return;
    }
    return list[0].networkId;
  } else {
    hilog.info(DOMAIN_NUMBER, TAG, 'getRemoteDeviceId err: dmClass is null');
    return;
  }
}

@Entry
@Component
struct Page_CollaborateAbility {
  private context = getContext(this) as common.UIAbilityContext;

  build() {
    // ...
    Button('多端协同有返回数据')
      .onClick(() => {
        this.context.startAbilityByCall({
          deviceId: getRemoteDeviceId(),
          bundleName: 'com.samples.stagemodelabilityinteraction',
          abilityName: 'CalleeAbility'
        }).then((data) => {
          if (data !== null) {
            caller = data;
            hilog.info(DOMAIN_NUMBER, TAG, 'get remote caller success');
            // 注册caller的release监听
            caller.onRelease((msg) => {
              hilog.info(DOMAIN_NUMBER, TAG, `remote caller onRelease is called ${msg}`);
            })
            hilog.info(DOMAIN_NUMBER, TAG, 'remote caller register OnRelease succeed');
            // 注册caller的协同场景下跨设备组件状态变化监听通知
            try {
              caller.onRemoteStateChange((str) => {
                hilog.info(DOMAIN_NUMBER, TAG, 'Remote state changed ' + str);
              });
            } catch (error) {
              hilog.info(DOMAIN_NUMBER, TAG, `Caller.onRemoteStateChange catch error, error.code: ${JSON.stringify(error.code)}, error.message: ${JSON.stringify(error.message)}`);
            };
          }
        }).catch((error: BusinessError) => {
          hilog.error(DOMAIN_NUMBER, TAG, `get remote caller failed with ${error}`);
        });
      }
      )
  }
}

getRemoteDeviceId方法参照 通过跨设备启动uiability和serviceextensionability组件实现多端协同无返回数据 。

  1. 向被调用端UIAbility发送约定序列化数据。
    1. 向被调用端发送Parcelable数据有两种方式，一种是不带返回值，一种是获取被调用端返回的数据，method以及序列化数据需要与被调用端协商一致。如下示例调用Call接口，向Callee被调用端发送数据。
import UIAbility, { Caller } from '@ohos.app.ability.UIAbility';
import type rpc from '@ohos.rpc';

const MSG_SEND_METHOD: string = 'CallSendMsg';
class MyParcelable {
  num: number = 0;
  str: string = '';

  constructor(num: number, string: string) {
    this.num = num;
    this.str = string;
  };

  mySequenceable(num: number, string: string): void {
    this.num = num;
    this.str = string;
  };

  marshalling(messageSequence: rpc.MessageSequence): boolean {
    messageSequence.writeInt(this.num);
    messageSequence.writeString(this.str);
    return true;
  };

  unmarshalling(messageSequence: rpc.MessageSequence): boolean {
    this.num = messageSequence.readInt();
    this.str = messageSequence.readString();
    return true;
  };
};

export default class EntryAbility extends UIAbility {
  // ...
  caller: Caller | undefined;
  async onButtonCall(): Promise<void> {
    try {
      let msg: MyParcelable = new MyParcelable(1, 'origin_Msg');
      if (this.caller) {
        await this.caller.call(MSG_SEND_METHOD, msg);
      }
    } catch (error) {
      hilog.info(DOMAIN_NUMBER, TAG, `caller call failed with ${error}`);
    };
  }
  // ...
}
  1. 如下示例调用CallWithResult接口，向Callee被调用端发送待处理的数据originMsg，并将’CallSendMsg’方法处理完毕的数据赋值给backMsg。
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 = '';

class MyParcelable {
  num: number = 0;
  str: string = '';

  constructor(num: number, string: string) {
    this.num = num;
    this.str = string;
  };

  mySequenceable(num: number, string: string): void {
    this.num = num;
    this.str = string;
  };

  marshalling(messageSequence: rpc.MessageSequence): boolean {
    messageSequence.writeInt(this.num);
    messageSequence.writeString(this.str);
    return true;
  };

  unmarshalling(messageSequence: rpc.MessageSequence): boolean {
    this.num = messageSequence.readInt();
    this.str = messageSequence.readString();
    return true;
  };
};

export default class EntryAbility extends UIAbility {
  // ...
  caller: Caller | undefined;
  async onButtonCallWithResult(originMsg: string, backMsg: string): Promise<void> {
    try {
      let msg: MyParcelable = new MyParcelable(1, originMsg);
      if (this.caller) {
        const data = await this.caller.callWithResult(MSG_SEND_METHOD, msg);
        hilog.info(DOMAIN_NUMBER, TAG, 'caller callWithResult succeed');
        let result: MyParcelable = new MyParcelable(0, '');
        data.readParcelable(result);
        backMsg = result.str;
        hilog.info(DOMAIN_NUMBER, TAG, `caller result is [${result.num}, ${result.str}]`);
      }
    } catch (error) {
      hilog.info(DOMAIN_NUMBER, TAG, `caller callWithResult failed with ${error}`);
    };
  }
  // ...
}
  1. 释放Caller通信接口。 Caller不再使用后，应用开发者可以通过release接口释放Caller。
import UIAbility, { Caller } from '@ohos.app.ability.UIAbility';

export default class EntryAbility extends UIAbility {
  caller: Caller | undefined;
  releaseCall(): void {
    try {
      if (this.caller) {
        this.caller.release();
        this.caller = undefined;
      }
      hilog.info(DOMAIN_NUMBER, TAG, 'caller release succeed');
    } catch (error) {
      hilog.info(DOMAIN_NUMBER, TAG, `caller release failed with ${error}`);
    };
  }
}

总是有很多小伙伴反馈说：鸿蒙开发不知道学习哪些技术？不知道需要重点掌握哪些鸿蒙应用开发知识点？ 为了解决大家这些学习烦恼。在这准备了一份很实用的鸿蒙（HarmonyOS NEXT）学习路线与学习文档给大家用来跟着学习。

针对一些列因素，整理了一套纯血版鸿蒙（HarmonyOS Next）全栈开发技术的学习路线，包含了鸿蒙开发必掌握的核心知识要点，内容有（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、WebGL、元服务、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、OpenHarmony驱动开发、系统定制移植等等）鸿蒙（HarmonyOS NEXT）技术知识点。

《鸿蒙 (Harmony OS)开发学习手册》（共计892页）:https://gitcode.com/HarmonyOS_MN

如何快速入门？

1.基本概念
2.构建第一个ArkTS应用
3.……


在这里插入图片描述

开发基础知识

1.应用基础知识
2.配置文件
3.应用数据管理
4.应用安全管理
5.应用隐私保护
6.三方应用调用管控机制
7.资源分类与访问
8.学习ArkTS语言
9.……

基于ArkTS 开发

1.Ability开发
2.UI开发
3.公共事件与通知
4.窗口管理
5.媒体
6.安全
7.网络与链接
8.电话服务
9.数据管理
10.后台任务(Background Task)管理
11.设备管理
12.设备使用信息统计
13.DFX
14.国际化开发
15.折叠屏系列
16.……

鸿蒙开发面试真题（含参考答案）:https://gitcode.com/HarmonyOS_MN

OpenHarmony 开发环境搭建:https://gitcode.com/HarmonyOS_MN


在这里插入图片描述

《OpenHarmony源码解析》:https://gitcode.com/HarmonyOS_MN

搭建开发环境
系统架构分析

  • 构建子系统
  • 启动流程
  • 子系统
  • 分布式任务调度子系统
  • 分布式通信子系统
  • 驱动子系统
  • ……

OpenHarmony 设备开发学习手册:https://gitcode.com/HarmonyOS_MN

在这里插入图片描述

「已注销」
关注
专栏目录
一文看懂什么是OpenHarmony流转架构
1
03-26 1472
随着全场景多设备的生活方式不断深入，用户拥有的设备越来越多，不同设备都能在适合的场景下提供良好的体验，例如手表可以提供及时的信息查看能力，电视可以带来沉浸的观影体验。但是，每个设备也有使用场景的局限，例如在电视上输入文本相对移动设备来说是非常糟糕的体验。当多个设备通过分布式操作系统能够相互感知、进而整合成一个超级终端时，设备与设备之间就可以取长补短、相互帮助，为用户提供更加自然流畅的分布式体验。在OpenHarmony中，将跨多设备的分布式操作统称为；
HarmonyOS新能力让数据多端协同更便捷，数据跨端迁移更高效
HarmonyOSDev的博客
01-11 3659
作者：yijian，终端OS分布式文件系统专家；gongashi，终端OS分布式数据管理专家 HarmonyOS作为分布式操作系统，其分布式数据管理能力非常重要。我们也一直围绕持续为开发者带来全局“一份”数据的开发体验的目标，在不断增强和提升HarmonyOS的分布式数据管理能力。本期我们就来为大家详细介绍分布式数据管理的新能力。 目录 一、分布式数据管理平台面临的挑战 二、分布式数据管理平台 三、变量的全局访问 四、文件的全局访问和分享 五、结束语 一、分布式数据管理平台面临的挑战
鸿蒙HarmonyOS 开发如果实现多端协同？
maniuT的博客
03-26 1164
在发起端设置目标组件参数，调用startAbilityForResult()接口启动目标端UIAbility，异步回调中的data用于接收目标端UIAbility停止自身后返回给调用方UIAbility的信息。在设备A上通过应用提供的启动按钮，启动设备B上指定的UIAbility，当设备B上的UIAbility退出后，会将返回值发回设备A上的发起端应用。在设备A上通过发起端应用提供的启动按钮，启动设备B上指定的UIAbility与ServiceExtensionAbility。
HarmonyOS学习路之开发篇—流转（多端协同 一）
爱吃土豆丝的打工人的博客
07-12 1452
开发者在应用FA中通过调用流转任务管理服务、分布式任务调度的接口，实现多端协同。
鸿蒙系统多屏协同,官方铁证！鸿蒙 2.0 手机来了，EMUI 11 多屏协同支持鸿蒙手机...
weixin_39550486的博客
05-27 944
官方铁证！鸿蒙 2.0 手机来了，EMUI 11 多屏协同支持鸿蒙手机2020-09-14 11:05:500点赞0收藏0评论9月13日消息，华为日前正式发布了大家期待已久的鸿蒙 2.0 操作系统，并正式公布了搭载鸿蒙 2.0 系统的手机上市日程，官方表示将于 12 月份进入手机领域，明年华为智能手机将全面支持鸿蒙 OS 2.0 系统。撰文 | XL科技说官方铁证！鸿蒙 2.0 手机来了，EMUI...
鸿蒙跨终端协同,华为发布全场景分布式操作系统鸿蒙，可实现跨终端无缝协同...
weixin_34518801的博客
05-29 614
原标题：华为发布全场景分布式操作系统鸿蒙，可实现跨终端无缝协同 【猎云网北京】8月9日报道今日，在华为开发者大会上，华为正式全场景分布式操作系统：鸿蒙。 余承东表示，未来5～10年，华为消费者业务的长期战略是全场景智慧生活战略。并再次提到了华为消费者业务的”1+8+N“战略：1就是手机是主入口，8就是4个大屏的入口：PC、平板、智慧大屏、车载屏幕，而非现在发布的有耳机、音箱、手表，眼镜。N则是泛I...
HarmonyOS应用开发者高级认证题库（覆盖99%考题）
04-26
### HarmonyOS应用开发者高级认证题库解析 #### 一、判断题解析 1. **云函数打包完成后，需要到 AppGallery Connect 创建对应函数的触发器才可以在端侧中调用**（错误） - **解析**：云函数的调用并不一定需要在...
[练习题+答案]Harmony OS应用开发者高级认证
06-01
实际上，HarmonyOS提供了一套统一的API和开发框架，简化了多端应用的开发流程。 - **知识点7**：关于`Column`和`Row`容器组件中的布局属性描述存在误解。在这些容器中，`alignItems`通常用于控制子组件在交叉轴方向...
harmonyos 应用开发者高级介绍文档
07-06
HarmonyOS 应用开发主要依托于其独特的分布式架构。这种架构允许开发者充分利用 HarmonyOS 的特性，例如设备间的数据共享和协同工作。具体而言： - **基于微内核的分布式架构**：这使得开发者可以轻松地将应用部署...
Harmony OS物联网应用开发实战
10-02
4. **应用开发基础**：涵盖HarmonyOS应用的基本元素，如组件、服务、页面布局等，以及用Java或JS进行应用编程的基础知识。 5. **分布式能力实战**：介绍如何利用分布式任务调度、分布式数据管理、分布式UI等特性，...
HarmonyOS 应用组件跨设备交互（流转），2024年最新看这篇足矣了
2401_83947353的博客
04-09 1274
随着全场景多设备的生活方式不断深入，用户拥有的设备越来越多，不同设备都能在适合的场景下提供良好的体验，例如手表可以提供及时的信息查看能力，电视可以带来沉浸的观影体验。但是，每个设备也有使用场景的局限，例如在电视上输入文本相对移动设备来说是非常糟糕的体验。当多个设备通过分布式操作系统能够相互感知、进而整合成一个超级终端时，设备与设备之间就可以取长补短、相互帮助，为用户提供更加自然流畅的分布式体验。跨多设备的分布式操作可以统称为流转；根据使用场景的不同，流转又分为 跨端迁移 两种具体场景。
HarmonyOS多端协同开发代码演示
Selma003的博客
12-14 802
HarmonyOS的多端协同开发代码展示。
鸿蒙HarmonyOS开发实战—流转（多端协同 一）_鸿蒙开发 流转
2401_84184567的博客
04-16 741
void unregister(int token, RequestCallback requestCallback) 从流转任务管理服务解注册，传入注册时获取的token进行解注册。void updateConnectStatus(int token, String deviceId, int status, RequestCallback requestCallback) 通知流转任务管理服务更新当前用户程序的连接状态，并在流转任务管理服务界面展示给用户。如果有错误，需要上报errorCode。
2024年鸿蒙最全鸿蒙HarmonyOS应用开发之Node-API常见问题(1)，2024年最新最新精心整理HarmonyOS鸿蒙面试题
2401_84857523的博客
05-10 538
4.鸿蒙开发系统底层方向。1.项目开发必备面试题。5.鸿蒙音视频开发方向。6.鸿蒙车载开发方向。7.鸿蒙南向开发方向。
【鸿蒙实战开发】组件间的数据传递
最新发布
HarmonyOS_002的博客
07-09 1903
这份鸿蒙（HarmonyOS NEXT）资料包含了鸿蒙开发必掌握的核心知识要点，内容包含了（ArkTS、ArkUI开发组件、Stage模型、多端部署、分布式应用开发、音频、视频、WebGL、OpenHarmony多媒体技术、Napi组件、OpenHarmony内核、Harmony南向开发、鸿蒙项目实战等等）鸿蒙（HarmonyOS NEXT）技术知识点。
鸿蒙系统多屏协同,EMUI11说明确认，鸿蒙2.0系统支持多屏协同
weixin_32200729的博客
05-27 4587
华为已经在开发者大会上正式发布EMUI11系统与华为鸿蒙2.0新系统，而且令人开心的是华为鸿蒙2.0系统将会使用在华为智能手机上。根据华为官方表示华为鸿蒙2.0系统将会在12月推出手机版，明年华为智能手机将全面支持华为鸿蒙系统。华为EMUI11系统升级更新了多屏协同功能，EMUI11系统的多屏协同功能将支持 PC 平板之间的多屏协同根据爆料称华为EMUI11系统的多屏协同功能增加了支持鸿蒙 2.0...
两个系统交互方式有几种_鸿蒙系统+鸿鹄芯片，国产之光荣耀智慧屏来了
weixin_39977776的博客
11-25 440
差一点我们就擦肩而过了有趣有用有态度李嘉诚曾说过：“企业的发展，需要有长远的目光，不能光顾眼前的利益，这就是所谓的大格局”。早在中兴事件之前，华为已经明显感到了危机四伏，想摆脱别人的控制，是时候启动“备胎计划”了。果不其然，在2019年，美国将华为列入实体清单，限制华为设出口，除此之外还限制芯片的使用。不过，美国有政策，华为有对策，海思麒麟芯片应运而生，终成独当一面的国“芯”。2dAzM...
鸿蒙跨终端协同,华为鸿蒙OS四大特性曝光 跨终端无缝协同体验
weixin_29091105的博客
05-29 479
中关村在线消息：今日下午，华为在东莞召开了开发者大会，并且为我们带来了全新自研系统鸿蒙HarmonyOS。此外，华为消费者业务CEO 华为常务董事余承东更是为我们讲解了这款全新系统的四大特性，我们来一探究竟。首先，华为鸿蒙OS是一款基于微内核的全场景分布式OS，余承东称安卓目前拥有超过1亿行代码，内核就超过2000万行，不过一般用户使用或者了解到的代码也就不到8%，是一种臃肿的系统，在未来根本没有...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值