devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

HarmonyOS学习路之开发篇—流转（多端协同 二）_abilitycontinuation接口

作者：知新_RL | 2024-02-21 14:57:53

赞

踩

abilitycontinuation接口

开发步骤

 完成 环境搭建，在DevEco Studio中，选择手机设备，Empty Feature Ability(Java)模板创建项目，在项目自动创建的MainAbility中实现IAbilityContinuation接口。

  1. public class MainAbility extends Ability implements IAbilityContinuation {
  2.     private static final int DOMAIN_ID = 0xD001100;   
  3.     private static final HiLogLabel LABEL_LOG = new HiLogLabel(3, DOMAIN_ID, "MainAbility");
  4.  
  5.     @Override
  6.     public void onStart(Intent intent) {
  7.         super.onStart(intent);
  8.         super.setMainRoute(MainAbilitySlice.class.getName());
  9.     }
  10.  
  11.     // 为了方便演示，不在Ability实现流转逻辑，具体逻辑在AbilitySlice中实现
  12.     @Override
  13.     public boolean onStartContinuation() {
  14.         HiLog.info(LABEL_LOG, "onStartContinuation called");
  15.         return true;
  16.     }
  17.  
  18.     @Override
  19.     public boolean onSaveData(IntentParams saveData) {
  20.         HiLog.info(LABEL_LOG, "onSaveData called");
  21.         return true;
  22.     }
  23.  
  24.     @Override
  25.     public boolean onRestoreData(IntentParams restoreData) {
  26.         HiLog.info(LABEL_LOG, "onRestoreData called");
  27.         return true;
  28.     }
  29.  
  30.     @Override
  31.     public void onCompleteContinuation(int result) {
  32.         HiLog.info(LABEL_LOG, "onCompleteContinuation called");
  33.     }
  34. }

在AbilitySlice中实现一个用于控制基础功能的页面，以下演示代码逻辑都将在AbilitySlice中实现，代码示例如下：

  1. public class MainAbilitySlice extends AbilitySlice {
  2.     private static final int DOMAIN_ID = 0xD000F00;   
  3.     private static final HiLogLabel LABEL_LOG = new HiLogLabel(3, DOMAIN_ID, "MainAbilitySlice");
  4.  
  5.     @Override
  6.     public void onStart(Intent intent) {
  7.         super.onStart(intent);
  8.         // 开发者可以自行进行界面设计
  9.         // 为按钮设置统一的背景色
  10.         // 例如通过PositionLayout可以实现简单界面
  11.         PositionLayout layout = new PositionLayout(this);
  12.         LayoutConfig config = new LayoutConfig(LayoutConfig.MATCH_PARENT, LayoutConfig.MATCH_PARENT);
  13.         layout.setLayoutConfig(config);
  14.         ShapeElement buttonBg = new ShapeElement();
  15.         buttonBg.setRgbColor(new RgbColor(0, 125, 255));
  16.         super.setUIContent(layout);
  17.     }
  18.  
  19.     @Override
  20.     public void onInactive() {
  21.         super.onInactive();
  22.     }
  23.  
  24.     @Override
  25.     public void onActive() {
  26.         super.onActive();
  27.     }
  28.  
  29.     @Override
  30.     public void onBackground() {
  31.         super.onBackground();
  32.     }
  33.  
  34.     @Override
  35.     public void onForeground(Intent intent) {
  36.         super.onForeground(intent);
  37.     }
  38.  
  39.     @Override
  40.     public void onStop() {
  41.         super.onStop();
  42.     }
  43. }

在FA对应的config.json中声明多设备协同访问的权限：ohos.permission.DISTRIBUTED_DATASYNC。在config.json中的配置如下：

  1. {
  2.     "module": {
  3.         "reqPermissions": [
  4.             {
  5.                 "name": "ohos.permission.DISTRIBUTED_DATASYNC",
  6.                 "reason": "need",
  7.                 "usedScene": {
  8.                     "ability": [
  9.                         "MainAbility"
  10.                     ],
  11.                     "when": "inuse"
  12.                 }
  13.             }
  14.         ],
  15.         ...
  16.     }
  17.     ...
  18. }

此外，还需要在FA的onStart()中，调用requestPermissionsFromUser()方法向用户申请权限，代码示例如下：

  1. public class MainAbility extends Ability implements IAbilityContinuation {
  2.     @Override
  3.     public void onStart(Intent intent) {
  4.         super.onStart(intent); 
  5.         // 开发者显示声明需要使用的权限
  6.         requestPermissionsFromUser(new String[]{"ohos.permission.DISTRIBUTED_DATASYNC"}, 0);
  7.         ...
  8.     }
  9.     ...
  10. }

设置流转任务管理服务回调函数，注册流转任务管理服务，管理流转的目标设备，同时需要在流转结束时解注册流转任务管理服务。

  1. public class MainAbilitySlice extends AbilitySlice {
  2.     // 当前应用包名
  3.     private String BUNDLE_NAME = "XXX.XXX.XXX"; 
  4.     // 流转应用包名
  5.     private String REMOTE_BUNDLE_NAME = "XXX.XXX.XXX"; 
  6.     // 流转FA名称
  7.     private String REMOTE_FA_NAME = "XXX.XXX.XXX.XXXAbility"; 
  8.     // 流转PA名称
  9.     private String REMOTE_PA_NAME = "XXX.XXX.XXX.XXXAbility"; 
  10.     // 注册流转任务管理服务后返回的Ability token
  11.     private int abilityToken; 
  12.     // 用户在设备列表中选择设备后返回的设备ID
  13.     private String selectDeviceId;
  14.     // 用户是否已发起可拉回流转流程
  15.     private boolean isReversibly = false;
  16.     // 获取流转任务管理服务管理类
  17.     private IContinuationRegisterManager continuationRegisterManager;
  18.     // 设置初始化分布式环境的回调
  19.     private IInitCallback iInitCallback = new IInitCallback() {
  20.         @Override
  21.         public void onInitSuccess(String deviceId) {
  22.             HiLog.info(LABEL_LOG, "device id success: " + deviceId);
  23.         }
  24.  
  25.         @Override
  26.         public void onInitFailure(String deviceId, int errorCode) {
  27.             HiLog.info(LABEL_LOG, "device id failed: " + deviceId + "errorCode: " + errorCode);
  28.         }
  29.     };
  30.     // 设置流转任务管理服务设备状态变更的回调
  31.     private IContinuationDeviceCallback callback = new IContinuationDeviceCallback() {
  32.         @Override
  33.         public void onConnected(ContinuationDeviceInfo deviceInfo) {
  34.             // 在用户选择设备后设置设备ID
  35.             selectDeviceId = deviceInfo.getDeviceId();
  36.             try {
  37.                 // 初始化分布式环境
  38.                 DeviceManager.initDistributedEnvironment(selectDeviceId, iInitCallback);
  39.             } catch (RemoteException e) {
  40.                 HiLog.info(LABEL_LOG, "initDistributedEnvironment failed");
  41.             }
  42.             //更新选择设备后的流转状态
  43.             continuationRegisterManager.updateConnectStatus(abilityToken, selectDeviceId, DeviceConnectState.CONNECTED.getState(), null);
  44.         }
  45.  
  46.         @Override
  47.         public void onDisconnected(String deviceId) {
  48.         }
  49.     };
  50.     // 设置注册流转任务管理服务回调
  51.     private RequestCallback requestCallback = new RequestCallback() {
  52.         @Override
  53.         public void onResult(int result) {
  54.             abilityToken = result;
  55.         }
  56.     };
  57.     ...
  58.  
  59.     @Override
  60.     public void onStart(Intent intent) {
  61.         ...
  62.         continuationRegisterManager = getContinuationRegisterManager();
  63.     }
  64.  
  65.     @Override
  66.     public void onStop() {
  67.         super.onStop();
  68.         // 解注册流转任务管理服务
  69.         continuationRegisterManager.unregister(abilityToken, null);
  70.         // 断开流转任务管理服务连接
  71.         continuationRegisterManager.disconnect();
  72.     }

为不同功能设置相应的控制按钮。

  1. // 建议开发者按照自己的界面进行按钮设计,示例代码仅供参考
  2. private static final int OFFSET_X = 100;
  3. private static final int OFFSET_Y = 100;
  4. private static final int ADD_OFFSET_Y = 150;
  5. private static final int BUTTON_WIDTH = 800;
  6. private static final int BUTTON_HEIGHT = 100;
  7. private static final int TEXT_SIZE = 50;
  8. private int offsetY = 0;
  9.  
  10. private Button btnShowDeviceList;
  11. private Button btnStartRemote;
  12. private Button btnStopRemote;
  13. private Button btnConnectRemotePA;
  14. private Button btnControlRemotePA;
  15. private Button btnDisconnectRemotePA;
  16.  
  17. private Button createButton(String text, ShapeElement buttonBg) {
  18.     Button button = new Button(this);
  19.     button.setContentPosition(OFFSET_X, OFFSET_Y + offsetY);
  20.     offsetY += ADD_OFFSET_Y;
  21.     button.setWidth(BUTTON_WIDTH);
  22.     button.setHeight(BUTTON_HEIGHT);
  23.     button.setTextSize(TEXT_SIZE);
  24.     button.setTextColor(Color.YELLOW);
  25.     button.setText(text);
  26.     button.setBackground(buttonBg);
  27.     return button;
  28. }
  29.  
  30. // 按照顺序在PositionLayout中依次添加按钮的示例
  31. private void addComponents(PositionLayout linear, ShapeElement buttonBg) {
  32.     // 构建显示注册流转任务管理服务的按钮
  33.     Button btnRegister = createButton("register", buttonBg);
  34.     btnRegister.setClickedListener(mRegisterListener);
  35.     linear.addComponent(btnRegister);
  36.  
  37.     // 构建显示设备列表的按钮
  38.     btnShowDeviceList = createButton("ShowDeviceList", buttonBg);
  39.     btnShowDeviceList.setClickedListener(mShowDeviceListListener);
  40.     linear.addComponent(btnShowDeviceList);
  41.  
  42.     // 构建远程启动FA/PA的按钮
  43.     btnStartRemote = createButton("StartRemote", buttonBg);
  44.     btnStartRemote.setClickedListener(mStartRemoteListener);
  45.     linear.addComponent(btnStartRemote);
  46.  
  47.     // 构建远程关闭PA的按钮
  48.     btnStopRemote = createButton("StopRemote", buttonBg);
  49.     btnStopRemote.setClickedListener(mStopRemoteListener);
  50.     linear.addComponent(btnStopRemote);
  51.  
  52.     // 构建连接远程PA的按钮
  53.     btnConnectRemotePA = createButton("ConnectRemotePA", buttonBg);
  54.     btnConnectRemotePA.setClickedListener(mConnectRemotePAListener);
  55.     linear.addComponent(btnConnectRemotePA);
  56.  
  57.     // 构建控制连接PA的按钮
  58.     btnControlRemotePA = createButton("ControlRemotePA", buttonBg);
  59.     btnControlRemotePA.setClickedListener(mControlPAListener);
  60.     linear.addComponent(btnControlRemotePA);
  61.  
  62.     // 构建与远程PA断开连接的按钮
  63.     btnDisconnectRemotePA = createButton("DisconnectRemotePA", buttonBg);
  64.     btnDisconnectRemotePA.setClickedListener(mDisconnectRemotePAListener);
  65.     linear.addComponent(btnDisconnectRemotePA);
  66. }
  67.  
  68. @Override
  69. public void onStart(Intent intent) {
  70.     ...
  71.     //添加功能按钮布局
  72.     addComponents(layout, buttonBg);
  73.     super.setUIContent(layout);
  74. }

注册流转任务管理服务。

  1. // 注册流转任务管理服务
  2. private Component.ClickedListener mRegisterListener = new Component.ClickedListener() {
  3.     @Override
  4.     public void onClick(Component arg0) {
  5.         HiLog.info(LABEL_LOG, "register call.");
  6.         //增加过滤条件
  7.         ExtraParams params = new ExtraParams();
  8.         String[] devTypes = new String[]{ExtraParams.DEVICETYPE_SMART_PAD, ExtraParams.DEVICETYPE_SMART_PHONE};
  9.         params.setDevType(devTypes);
  10.         String jsonParams = "{'filter':{'commonFilter':{'system':{'harmonyVersion':'2.0.0'},'groupType':'1|256','curComType': 0x00030004,'faFilter':'{\"localVersionCode\":1,\"localMinCompatibleVersionCode\":2,\"targetBundleName\": \"com.xxx.yyy\"}'}},'transferScene':0,'remoteAuthenticationDescription': '拉起HiVision扫描弹框描述','remoteAuthenticationPicture':''}";
  11.         params.setJsonParams(jsonParams);
  12.         continuationRegisterManager.register(BUNDLE_NAME, params, callback, requestCallback);
  13.     }
  14. };

通过流转任务管理服务提供的showDeviceList()接口获取选择设备列表，用户选择设备后在IContinuationDeviceCallback回调中获取设备ID。

  1. // 显示设备列表，获取设备信息
  2. private ClickedListener mShowDeviceListListener = new ClickedListener() {
  3.     @Override
  4.     public void onClick(Component arg0) {
  5.         // 设置过滤设备类型
  6.         ExtraParams params = new ExtraParams();
  7.         String[] devTypes = new String[]{ExtraParams.DEVICETYPE_SMART_PAD, ExtraParams.DEVICETYPE_SMART_PHONE};
  8.         params.setDevType(devTypes);
  9.         String jsonParams = "{'filter':{'commonFilter':{'system':{'harmonyVersion':'2.0.0'},'groupType':'1|256','curComType': 0x00030004,'faFilter':'{\"localVersionCode\":1,\"localMinCompatibleVersionCode\":2,\"targetBundleName\": \"com.xxx.yyy\"}'}},'transferScene':0,'remoteAuthenticationDescription': '拉起HiVision扫描弹框描述','remoteAuthenticationPicture':''}";
  10.         params.setJsonParams(jsonParams);
  11.         // 显示选择设备列表
  12.         continuationRegisterManager.showDeviceList(abilityToken, params, null);
  13.     }
  14. };

为启动远程FA/PA的按钮设置点击回调，实现启动FA/PA和关闭远程PA的能力。

  1. // 启动远程FA/PA
  2. private ClickedListener mStartRemoteListener = new ClickedListener() {
  3.     @Override
  4.     public void onClick(Component arg0) {
  5.         if (selectDeviceId != null) {
  6.             // 通过showDeviceList获取指定目标设备deviceId
  7.             // 指定待启动FA/PA的bundleName和abilityName
  8.             // 设置分布式标记，表明当前涉及分布式能力
  9.             Operation operation = new Intent.OperationBuilder()
  10.                     .withDeviceId(selectDeviceId)
  11.                     .withBundleName(REMOTE_BUNDLE_NAME)
  12.                     .withAbilityName(REMOTE_FA_NAME)
  13.                     .withFlags(Intent.FLAG_ABILITYSLICE_MULTI_DEVICE)
  14.                     .build();
  15.             Intent startIntent = new Intent();
  16.             startIntent.setOperation(operation);
  17.             // 通过AbilitySlice包含的startAbility接口实现跨设备启动FA/PA
  18.             startAbility(startIntent);
  19.         } else {
  20.             btnStartRemote.setText("StartRemote selectDeviceId is null");
  21.         }
  22.     }
  23. };
  24.  
  25. // 关闭远程PA
  26. private ClickedListener mStopRemoteListener = new ClickedListener() {
  27.     @Override
  28.     public void onClick(Component arg0) {
  29.         if (selectDeviceId != null) {
  30.             // 通过showDeviceList获取指定目标设备deviceId
  31.             // 指定待关闭PA的bundleName和abilityName
  32.             // 设置分布式标记，表明当前涉及分布式能力
  33.             Operation operation = new Intent.OperationBuilder()
  34.                     .withDeviceId(selectDeviceId)
  35.                     .withBundleName(REMOTE_BUNDLE_NAME)
  36.                     .withAbilityName(REMOTE_PA_NAME)
  37.                     .withFlags(Intent.FLAG_ABILITYSLICE_MULTI_DEVICE)
  38.                     .build();
  39.             Intent stopIntent = new Intent();
  40.             stopIntent.setOperation(operation);
  41.             // 通过AbilitySlice包含的stopAbility接口实现跨设备关闭PA
  42.             stopAbility(stopIntent);
  43.         } else {
  44.             btnStopRemote.setText("StopRemote selectDeviceId is null");
  45.         }
  46.     }
  47. };

需要注意，目标FA/PA需要在config.json中设置“visible”为true。visible标签表示Ability是否可以被其他应用调用，默认为false，即只允许同应用（同appid）访问；如需被其他应用访问，需要将其设置为true，同时建议在目标FA/PA中添加自定义权限，控制访问范围，防止被其他应用随意访问。

在config.json中的配置如下：

  1. {
  2.     "module": {
  3.         "abilities": [
  4.             {
  5.                 ...
  6.                 "visible": true
  7.                 ...
  8.             }
  9.         ]
  10.         ...
  11.     }
  12.     ...
  13. }

设备A连接设备B侧的PA，利用连接关系调用该PA执行特定任务，以及断开连接。

  1. // 当连接完成时，用来提供管理已连接PA的能力
  2. private MyRemoteProxy mProxy = null;
  3. // 用于管理连接关系
  4. private IAbilityConnection mConn = new IAbilityConnection() {
  5.     @Override
  6.     public void onAbilityConnectDone(ElementName element, IRemoteObject remote, int resultCode) {
  7.         // 跨设备PA连接完成后，会返回一个序列化的IRemoteObject对象
  8.         // 通过该对象得到控制远端服务的代理
  9.         mProxy = new MyRemoteProxy(remote);
  10.         btnConnectRemotePA.setText("connectRemoteAbility done");
  11.     }
  12.  
  13.     @Override
  14.     public void onAbilityDisconnectDone(ElementName element, int resultCode) {
  15.         // 当已连接的远端PA异常关闭时，会触发该回调
  16.         // 支持开发者按照返回的错误信息进行PA生命周期管理
  17.         disconnectAbility(mConn);
  18.     }
  19. };

仅通过启动/关闭两种方式对PA进行调度无法应对需长期交互的场景，因此，系统向开发者提供了跨设备PA连接及断开连接的能力。为了对已连接PA进行管理，开发者需要实现一个满足IAbilityConnection接口的连接状态检测实例，通过该实例可以对连接及断开连接完成时设置具体的处理逻辑，例如：获取控制对端PA的代理等。进一步为了使用该代理跨设备调度PA，开发者需要在本地及对端分别实现对外接口一致的代理。一个具备加法能力的代理示例如下：

  1. // 以连接提供加法计算能力的PA为例。为了提供跨设备连接能力，需要在本地发起连接侧和对端被连接侧分别实现代理
  2. // 发起连接侧的代理示例如下：
  3. public class MyRemoteProxy implements IRemoteBroker {
  4.     private static final int ERR_OK = 0;
  5.     private static final int COMMAND_PLUS = IRemoteObject.MIN_TRANSACTION_ID;
  6.     private static final String DESCRIPTOR = "com.XXX.DESCRIPTOR";
  7.     private final IRemoteObject remote;
  8.  
  9.     public MyRemoteProxy(IRemoteObject remote) {
  10.         this.remote = remote;
  11.     }
  12.  
  13.     @Override
  14.     public IRemoteObject asObject() {
  15.         return remote;
  16.     }
  17.  
  18.     public int plus(int a, int b) throws RemoteException {
  19.         MessageParcel data = MessageParcel.obtain();
  20.         MessageParcel reply = MessageParcel.obtain();
  21.         // option不同的取值，决定采用同步或异步方式跨设备控制PA
  22.         // 本例需要同步获取对端PA执行加法的结果，因此采用同步的方式，即MessageOption.TF_SYNC
  23.         // 具体MessageOption的设置，可参考相关API文档
  24.         MessageOption option = new MessageOption(MessageOption.TF_SYNC);
  25.         data.writeInterfaceToken(DESCRIPTOR);
  26.         data.writeInt(a);
  27.         data.writeInt(b);
  28.  
  29.         try {
  30.             remote.sendRequest(COMMAND_PLUS, data, reply, option);
  31.             int errCode = reply.readInt();
  32.             if (errCode != ERR_OK) {
  33.                 throw new RemoteException();
  34.             }
  35.             int result = reply.readInt();
  36.             return result;
  37.         } finally {
  38.             data.reclaim();
  39.             reply.reclaim();
  40.         }
  41.     }
  42. }

此外，对端待连接的PA需要实现对应的客户端，代码示例如下所示：

  1. // 以计算加法为例，对端实现的客户端如下
  2. public class MyRemote extends RemoteObject implements IRemoteBroker{
  3.     private static final int ERR_OK = 0;
  4.     private static final int ERROR = -1;
  5.     private static final int COMMAND_PLUS = IRemoteObject.MIN_TRANSACTION_ID;
  6.     private static final String DESCRIPTOR = "com.XXX.DESCRIPTOR";
  7.  
  8.     public MyRemote() {
  9.         super("MyService_Remote");
  10.     }
  11.  
  12.     @Override
  13.     public IRemoteObject asObject() {
  14.         return this;
  15.     }
  16.  
  17.     @Override
  18.     public boolean onRemoteRequest(int code, MessageParcel data, MessageParcel reply, MessageOption option) {
  19.         String token = data.readInterfaceToken();
  20.         if (!DESCRIPTOR.equals(token)) {
  21.             reply.writeInt(ERROR);
  22.             return false;
  23.         }
  24.  
  25.         if (code != COMMAND_PLUS) {
  26.             reply.writeInt(ERROR);
  27.             return false;
  28.         }
  29.         
  30.         int value1 = data.readInt();
  31.         int value2 = data.readInt();
  32.         int sum = value1 + value2;
  33.         reply.writeInt(ERR_OK);
  34.         reply.writeInt(sum);
  35.         return true;
  36.     }
  37. }

对端除了要实现如上所述的客户端外，待连接的PA还需要作如下修改：

  1. // 为了返回给连接方可调用的代理，需要在该PA中实例化客户端，例如作为该PA的成员变量
  2. private MyRemote remote = new MyRemote();
  3. // 当该PA接收到连接请求时，即将该客户端转化为代理返回给连接发起侧
  4. @Override
  5. protected IRemoteObject onConnect(Intent intent) {
  6.     super.onConnect(intent);
  7.     return remote.asObject();
  8. }

创建远程连接目标PA的步骤可参考创建Service。需要注意，目标PA需要在config.json中设置“visible”为true。visible标签表示Ability是否可以被其他应用调用，默认为false，即只允许同应用（同appid）访问；如需被其他应用访问，需要将其设置为true，同时建议在目标PA中添加自定义权限，控制访问范围，防止被其他应用随意访问。

在config.json中的配置如下：

  1. {
  2.     "module": {
  3.         "abilities": [
  4.             {
  5.                 ...
  6.                 "visible": true
  7.                 ...
  8.             }
  9.         ]
  10.         ...
  11.     }
  12.     ...
  13. }

完成上述步骤后，可以通过点击事件实现连接、利用连接关系控制PA以及断开连接等行为，代码示例如下：

  1. // 连接远程PA
  2. private ClickedListener mConnectRemotePAListener = new ClickedListener() {
  3.     @Override
  4.     public void onClick(Component arg0) {
  5.         if (selectDeviceId != null) {
  6.             // 指定待连接PA的bundleName和abilityName
  7.             // 设置分布式标记，表明当前涉及分布式能力
  8.             Operation operation = new Intent.OperationBuilder()
  9.                     .withDeviceId(selectDeviceId)
  10.                     .withBundleName(REMOTE_BUNDLE_NAME)
  11.                     .withAbilityName(REMOTE_PA_NAME)
  12.                     .withFlags(Intent.FLAG_ABILITYSLICE_MULTI_DEVICE)
  13.                     .build();
  14.             Intent connectPAIntent = new Intent();
  15.             connectPAIntent.setOperation(operation);
  16.             // 通过AbilitySlice包含的connectAbility接口实现跨设备连接PA
  17.             connectAbility(connectPAIntent, mConn);
  18.         }
  19.     }
  20. };
  21.  
  22. // 控制已连接PA执行加法
  23. private ClickedListener mControlPAListener = new ClickedListener() {
  24.     @Override
  25.     public void onClick(Component arg0) {
  26.         if (mProxy != null) {
  27.             int ret = -1;
  28.             try {
  29.                 ret = mProxy.plus(10, 20);
  30.             } catch (RemoteException e) {
  31.                 HiLog.error(LABEL_LOG, "ControlRemotePA error");
  32.             }
  33.             btnControlRemotePA.setText("ControlRemotePA result = " + ret);
  34.         }
  35.     }
  36. };
  37.  
  38. // 与远程PA断开连接
  39. private ClickedListener mDisconnectRemotePAListener = new ClickedListener() {
  40.     @Override
  41.     public void onClick(Component arg0) {
  42.         // 按钮复位
  43.         btnConnectRemotePA.setText("ConnectRemotePA");
  44.         btnControlRemotePA.setText("ControlRemotePA");
  45.         disconnectAbility(mConn);
  46.     }
  47. };

说明

通过连接/断开连接远程PA，与跨设备PA建立长期的管理关系。例如在本例中，通过连接关系得到远程PA的控制代理后，实现跨设备计算加法并将结果返回到本地显示。在实际开发中，开发者可以根据需要实现多种分布式场景，例如：跨设备位置/电量等信息的采集、跨设备计算资源互助等。

声明：本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号