wearEngine（穿戴设备能力开放）

导入模块

import { wearEngine } from '@kit.WearEngine';

wearEngine.getAuthClient

getAuthClient(context: common.Context): AuthClient

用于获取权限管理的客户端。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';

let authClient: wearEngine.AuthClient = wearEngine.getAuthClient(this.getUIContext().getHostContext());
console.info(`Succeeded in getting auth client`);

AuthClient

权限管理客户端类，由wearEngine.getAuthClient返回得到。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

requestAuthorization

requestAuthorization(request: AuthorizationRequest): Promise<AuthorizationResponse>

向手机用户申请需要授权的权限，返回申请的权限中用户已授权的权限，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中无法使用该能力。

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let authClient: wearEngine.AuthClient = wearEngine.getAuthClient(this.getUIContext().getHostContext());

let request: wearEngine.AuthorizationRequest = {
  permissions: [wearEngine.Permission.USER_STATUS]
}

// 向手机用户申请需要授权的权限，返回申请的权限中用户已授权的权限，使用Promise异步回调。
authClient.requestAuthorization(request).then(result => {
  console.info(`Succeeded in requesting authorize, authorized permissions is ${result.permissions}`);
}).catch((error: BusinessError) => {
  console.error(`Failed to request authorize. Code is ${error.code}, message is ${error.message}`);
})

getAuthorization

getAuthorization(): Promise<AuthorizationResponse>

获取用户已授权的权限，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中无法使用该能力。

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let authClient: wearEngine.AuthClient = wearEngine.getAuthClient(this.getUIContext().getHostContext());

// 获取用户已授权的权限，使用Promise异步回调。
authClient.getAuthorization().then(result => {
  console.info(`Succeeded in getting authorized permissions, authorized permissions is ${result.permissions}`);
}).catch((error: BusinessError) => {
  console.error(`Failed to get authorized permissions. Code is ${error.code}, message is ${error.message}`);
})

AuthorizationBase

权限控制模块输入输出的基类。

系统能力： SystemCapability.Health.WearEngine

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

Permission

权限枚举类型。

系统能力： SystemCapability.Health.WearEngine

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

AuthorizationRequest

权限请求类，继承自AuthorizationBase。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

AuthorizationResponse

权限响应类，继承自AuthorizationBase。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

wearEngine.getDeviceClient

getDeviceClient(context: common.Context): DeviceClient

用于获取Device模块的客户端。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码。

示例：

import { wearEngine } from '@kit.WearEngine';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
console.info(`Succeeded in getting device client.`);

DeviceClient

Device客户端类。由接口wearEngine.getDeviceClient返回得到。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

getConnectedDevices

getConnectedDevices(): Promise<Device[]>

获取当前已连接且支持wearEngine能力集的设备，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
deviceClient.getConnectedDevices().then((devices) => {
  console.info(`Succeeded in getting devices, devices number is ${devices.length}.`);
}).catch((error: BusinessError) => {
  console.error(`Failed to get devices. Code is ${error.code}, message is ${error.message}.`);
})

Device

穿戴设备信息类。由接口getConnectedDevices返回。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

属性

isWearEngineCapabilitySupported

isWearEngineCapabilitySupported(capability: WearEngineCapability): Promise<boolean>

通过getConnectedDevices接口获取到已连接的穿戴设备后，查询设备是否支持指定的WearEngineCapability，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备且第一位即为目标设备）
    let device: wearEngine.Device = devices[0];

    device.isWearEngineCapabilitySupported(wearEngine.WearEngineCapability.P2P_COMMUNICATION)
      .then((isSupportP2P) => {
        console.info(`Succeeded in checking p2p capability, result is ${isSupportP2P}`);
      }).catch((error: BusinessError) => {
      console.error(`Failed to check p2p capability. Code is ${error.code}, message is${error.message}`);
    })
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is${error.message}`);
}

isDeviceCapabilitySupported

isDeviceCapabilitySupported(capability: DeviceCapability): Promise<boolean>

通过getConnectedDevices接口获取到已连接的穿戴设备后，查询设备是否支持指定的DeviceCapability，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();
  
  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备且第一位即为目标设备）
    let device: wearEngine.Device = devices[0];

    device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.CBT_I).then((isSupportCBTI) => {
      console.info(`Succeeded in checking CBTI capability, result is ${isSupportCBTI}`);
    }).catch((error: BusinessError) => {
      console.error(`Failed to check CBTI capability. Code is ${error.code}, message is ${error.message}`);
    })
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

getSerialNumber

getSerialNumber(): Promise<string>

通过getConnectedDevices接口获取到已连接的穿戴设备后，查询设备的SN，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备且第一位即为目标设备）
    let device: wearEngine.Device = devices[0];

    device.getSerialNumber().then((sn) => {
      console.info(`Succeeded in getting device SN, result is ${sn}`);
    }).catch((error: BusinessError) => {
      console.error(`Failed to get device SN. Code is ${error.code}, message is ${error.message}`);
    })
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

WearEngineCapability

WearEngine能力集枚举类型。

系统能力： SystemCapability.Health.WearEngine

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

DeviceCapability

Device能力集枚举类型。

系统能力： SystemCapability.Health.WearEngine

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

DeviceCategory

设备类型枚举类。

系统能力： SystemCapability.Health.WearEngine

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

OsCategory

设备的操作系统类型枚举类。

系统能力： SystemCapability.Health.WearEngine

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.1.0(18)

wearEngine.getMonitorClient

getMonitorClient(context: common.Context): MonitorClient

用于获取Monitor模块的客户端。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 对于6.0.2(22)及之前版本，该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。对于6.1.0(23)及之后版本，该接口在Phone、Tablet、Wearable中可正常调用。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';

let monitorClient: wearEngine.MonitorClient = wearEngine.getMonitorClient(this.getUIContext().getHostContext());
console.info(`Succeeded in getting monitor client.`);

MonitorClient

Monitor客户端类。由接口wearEngine.getMonitorClient返回得到。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

queryStatus

queryStatus(deviceRandomId: string, item: MonitorItem): Promise<MonitorData>

查询指定设备的指定状态，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 对于6.0.2(22)及之前版本，该接口在Phone、Tablet中可正常调用，在其他设备类型中无法使用该能力。对于6.1.0(23)及之后版本，该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let monitorClient: wearEngine.MonitorClient = wearEngine.getMonitorClient(this.getUIContext().getHostContext());
try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备且第一位即为目标设备）
    let device: wearEngine.Device = devices[0];

    monitorClient.queryStatus(device.randomId, wearEngine.MonitorItem.WEAR_STATUS).then((result) => {
      console.info(`Succeeded in querying wear status, result is ${result.code}.`);
    }).catch((error: BusinessError) => {
      console.error(`Failed to query wear status. Code is ${error.code}, message is ${error.message}.`);
    })
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

subscribeEvent

subscribeEvent(deviceRandomId: string, type: MonitorEvent, callback: Callback<MonitorEventData>): Promise<void>

监听指定设备的指定状态变化事件，当状态发生变化时，使用callback异步回调，订阅成功与否，使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 对于6.0.2(22)及之前版本，该接口在Phone、Tablet中可正常调用，在其他设备类型中无法使用该能力。对于6.1.0(23)及之后版本，该接口在Phone、Tablet中可正常调用，在Wearable中可以订阅设备连接状态变化事件，订阅其他事件返回801错误码。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let monitorClient: wearEngine.MonitorClient = wearEngine.getMonitorClient(this.getUIContext().getHostContext());

try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备且第一位即为目标设备）
    let device: wearEngine.Device = devices[0];

    let callback = (monitorEventData: wearEngine.MonitorEventData) => {
      console.info(`Succeeded in listening change of ${monitorEventData.event}, the new status is ${monitorEventData.data}.`);
    }
    monitorClient.subscribeEvent(device.randomId, wearEngine.MonitorEvent.EVENT_WEAR_STATUS_CHANGED, callback)
      .then(() => {
        console.info(`Succeeded in subscribing wear status.`);
      })
      .catch((error: BusinessError) => {
        console.error(`Failed to subscribe wear status. Code is ${error.code}, message is ${error.message}.`);
      })
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

unsubscribeEvent

unsubscribeEvent(deviceRandomId: string, type: MonitorEvent, callback: Callback<MonitorEventData>): Promise<void>

取消订阅监听指定设备的指定状态变化事件，取消订阅成功与否使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 对于6.0.2(22)及之前版本，该接口在Phone、Tablet中可正常调用，在其他设备类型中无法使用该能力。对于6.1.0(23)及之后版本，该接口在Phone、Tablet中可正常调用，在Wearable中可以取消订阅设备连接状态变化事件，取消订阅其他事件返回801错误码。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let monitorClient: wearEngine.MonitorClient = wearEngine.getMonitorClient(this.getUIContext().getHostContext());

try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备且第一位即为目标设备）
    let device: wearEngine.Device = devices[0];

    // 解注册时回调函数需要保证和注册时为同一个对象
    let callback = (monitorEventData: wearEngine.MonitorEventData) => {
      console.info(`Succeeded in listening change of ${monitorEventData.event}, the new status is ${monitorEventData.data}.`);
    }

    // 创建待删除的订阅任务
    monitorClient.subscribeEvent(device.randomId, wearEngine.MonitorEvent.EVENT_WEAR_STATUS_CHANGED, callback)
      .then(() => {
        console.info(`Succeeded in subscribing wear status`);

        // 删除之前创建的订阅任务
        monitorClient.unsubscribeEvent(device.randomId, wearEngine.MonitorEvent.EVENT_WEAR_STATUS_CHANGED, callback)
          .then(() => {
            console.info(`Succeeded in unsubscribing wear status`);
          })
          .catch((error: BusinessError) => {
            console.error(`Failed to unsubscribe wear status. Code is ${error.code}, message is ${error.message}.`);
          })
      })
      .catch((error: BusinessError) => {
        console.error(`Failed to subscribe wear status. Code is ${error.code}, message is ${error.message}.`);
      })
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is${error.message}`);
}

MonitorItem

设备状态的枚举类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

MonitorEvent

设备状态变化事件的枚举类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

MonitorData

作为queryStatus接口的返回值与subscribeEvent接口回调函数的入参，返回设备的状态信息。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

MonitorEventData

作为subscribeEvent接口的返回值，当订阅监听的事件触发时，作为入参将设备对应状态变化后的信息传递给回调函数。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

wearEngine.getP2pClient

getP2pClient(context: common.Context): P2pClient

用于获取P2p模块的客户端。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';

let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());
console.info(`Succeeded in getting p2p client.`);

P2pClient

P2p客户端类。由接口wearEngine.getP2pClient返回得到。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

isRemoteAppInstalled

isRemoteAppInstalled(deviceRandomId: string, remoteBundleName: string): Promise<boolean>

判断穿戴设备是否已安装指定的应用，使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 将设备侧应用包名定义为remoteBundleName
        let remoteBundleName: string = '';

        p2pClient.isRemoteAppInstalled(device.randomId, remoteBundleName).then((isInstall) => {
          console.info(`Succeeded in checking remote app install, result is ${isInstall}.`);
        }).catch((error: BusinessError) => {
          console.error(`Failed to check remote app install. Code is ${error.code}, message is ${error.message}.`);
        })
      }
    } catch (error) {
      console.error(`Failed to check device capability. Code is ${error.code}, message is ${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

getRemoteAppVersion

getRemoteAppVersion(deviceRandomId: string, remoteBundleName: string): Promise<number>

获取穿戴设备指定应用的版本号，使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 对于6.1.0(23)及之前版本，该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。 对于6.1.1(24)及之后版本，该接口在Phone、Tablet、Wearable中可正常调用。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 将设备侧应用包名定义为remoteBundleName
        let remoteBundleName: string = '';

        p2pClient.getRemoteAppVersion(device.randomId, remoteBundleName).then((version) => {
          console.info(`Succeeded in getting remote app version, version is ${version}.`);
        }).catch((error: BusinessError) => {
          console.error(`Failed to check get remote app version. Code is ${error.code}, message is${error.message}.`);
        })
      }
    } catch (error) {
      console.error(`Failed to check device capability. Code is ${error.code}, message is${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is${error.message}`);
}

startRemoteApp

startRemoteApp(deviceRandomId: string, remoteBundleName: string, transformLocalBundleName?: boolean): Promise<P2pResult>

拉起穿戴设备的指定应用，使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 将设备侧应用包名定义为remoteBundleName
        let remoteBundleName: string = '';

        // transformLocalBundleName不传入参数时，默认为false
        p2pClient.startRemoteApp(device.randomId, remoteBundleName).then((p2pResult) => {
          console.info(`Succeeded in starting remote app, result is ${p2pResult.code}.`);
        }).catch((error: BusinessError) => {
          console.error(`Failed to start remote app. Code is ${error.code}, message is${error.message}.`);
        })
      }
    } catch (error) {
      console.error(`Failed to check device capability. Code is ${error.code}, message is${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is${error.message}`);
}

startRemoteApp

startRemoteApp(deviceRandomId: string, remoteApp: AppInfo, startConfig: StartConfig): Promise<P2pResult>

拉起对端设备的指定应用，使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 在wearable中可正常调用，支持拉起Phone和Tablet设备中分布式组件或前台组件。HarmonyOS 6.1及以上版本，支持拉起DISTRIBUTED_SERVICE组件；HarmonyOS 5.0之前版本（如HarmonyOS 2.x/3.x/4.x），支持拉起SERVICE组件；Android系统，支持拉起SERVICE组件。在其他系统和设备中不支持拉起。

起始版本： 6.1.1(24)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备，第一位即为目标设备且具备相关能力）
    let device: wearEngine.Device = devices[0];
    // 设置设备侧应用的应用信息：包名与指纹
    let remoteApp: wearEngine.AppInfo = {
      bundleName: 'example_bundleName',
      fingerprint: 'example_fingerprint'
    };

    // 设置拉起对端设备侧应用的组件类型
    let startConfig: wearEngine.StartConfig = {
      entryType: wearEngine.EntryType.DISTRIBUTED_SERVICE,
      entryName: 'example_entryName'
    };

    p2pClient.startRemoteApp(device.randomId, remoteApp, startConfig).then((p2pResult) => {
      console.info(`Succeeded in starting remote app, result is ${p2pResult.code}.`);
    }).catch((error: BusinessError) => {
      console.error(`Failed to start remote app. Code is ${error.code}, message is${error.message}.`);
    })
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is${error.message}`);
}

sendMessage

sendMessage(deviceRandomId: string, appParam: P2pAppParam, message: P2pMessage): Promise<P2pResult>

向对端设备的指定应用发送消息，使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';
import { util } from '@kit.ArkTS';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 设置设备侧应用的应用信息：包名与指纹
        // 包名与指纹，可在华为开发者联盟获取
        let appInfo: wearEngine.AppInfo = {
          bundleName: '',
          fingerprint: ''
        }
        // 将设备侧应用参数类定义为appParam
        let appParam: wearEngine.P2pAppParam = {
          remoteApp: appInfo
          // transformLocalAppInfo默认为false，不转换包名指纹
        }
        // 设置需要发送的消息内容
        let messageContent: string = 'this is message';
        let textEncoder: util.TextEncoder = new util.TextEncoder;
        let message: wearEngine.P2pMessage = {
          content: textEncoder.encodeInto(messageContent)
        }

        p2pClient.sendMessage(device.randomId, appParam, message).then((p2pResult) => {
          console.info(`Succeeded in sending message, result is ${p2pResult.code}.`);
        }).catch((error: BusinessError) => {
          console.error(`Failed to send message. Code is ${error.code}, message is ${error.message}.`);
        })
      }
    } catch (error) {
      console.error(`Failed to check device capability. Code is ${error.code}, message is ${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

transferFile

transferFile(deviceRandomId: string, appParam: P2pAppParam, file: P2pFile, callback: AsyncCallback<P2pResult>): void

向对端设备的指定应用发送文件，使用callback异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';
import { fileIo } from '@kit.CoreFileKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 设置设备侧应用的应用信息：包名与指纹
        // 包名与指纹，可在华为开发者联盟获取
        let appInfo: wearEngine.AppInfo = {
          bundleName: '',
          fingerprint: ''
        }
        // 将设备侧应用参数类定义为appParam
        let appParam: wearEngine.P2pAppParam = {
          remoteApp: appInfo
          // transformLocalAppInfo默认为false，不转换包名指纹
        }
        let file: fileIo.File | null = null;
        try {
          // 设置需要发送的文件
          file = fileIo.openSync('');
          let p2pFile: wearEngine.P2pFile = {
            file: file
          }
          const closeFile = () => {
            try {
              if (file) {
                fileIo.closeSync(file);
                console.info('File closed successfully.');
              }
            } catch (closeErr) {
              console.error(`Failed to close file. Code is ${closeErr.code}, message is${closeErr.message}.`);
            }
          };

          p2pClient.transferFile(device.randomId, appParam, p2pFile,
            (error: BusinessError, p2pResult: wearEngine.P2pResult) => {
              // callback处理逻辑
              if (error) {
                console.error(`Failed to transfer file. Code is ${error.code}, message is ${error.message}.`);
                closeFile();
                return;
              }
              if (p2pResult.code) {
                if (p2pResult.code === wearEngine.P2pResultCode.COMMUNICATION_SUCCESS) {
                  console.info(`Succeeded in transferring file, the result is ${p2pResult.code}.`);
                } else {
                  console.error(`Failed to transfer file, the error code is ${p2pResult.code}.`);
                }
                closeFile();
              }
              if (p2pResult.progress) {
                console.info(`Succeeded in transferring file, the progress is ${p2pResult.progress}.`);
              }
            });
          } catch (fileErr) {
            console.error(`Failed to open file. Code is ${fileErr.code}, message is${fileErr.message}`);
            if (file) fileIo.closeSync(file);
          }
        }
      } catch (error) {
        console.error(`Failed to check device capability. Code is ${error.code}, message is ${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

cancelFileTransfer

cancelFileTransfer(deviceRandomId: string, appParam: P2pAppParam, file: P2pFile): Promise<P2pResult>

取消向对端设备的指定应用发送文件，使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';
import { fileIo } from '@kit.CoreFileKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 设置设备侧应用的应用信息：包名与指纹
        // 包名与指纹，可在华为开发者联盟获取
        let appInfo: wearEngine.AppInfo = {
          bundleName: '',
          fingerprint: ''
        }
        // 将设备侧应用参数类定义为appParam
        let appParam: wearEngine.P2pAppParam = {
          remoteApp: appInfo
          // transformLocalAppInfo默认为false，不转换包名指纹
        }
        // 设置需要发送的文件信息
        let p2pFile: wearEngine.P2pFile = {
          file: fileIo.openSync('')
        }

        p2pClient.transferFile(device.randomId, appParam, p2pFile, () => {
          // 回调函数执行逻辑
        })

        p2pClient.cancelFileTransfer(device.randomId, appParam, p2pFile).then((p2pResult) => {
          if (p2pResult.code === wearEngine.P2pResultCode.COMMUNICATION_SUCCESS) {
            console.info(`Succeeded in cancelling transfer file, the result is ${p2pResult.code}.`);
          }
        }).catch((error: BusinessError) => {
          console.error(`Failed to cancel transfer file. Code is ${error.code}, message is ${error.message}.`);
        })
        fileIo.close(p2pFile.file);
      }
    } catch (error) {
      console.error(`Failed to check device capability. Code is ${error.code}, message is ${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

registerMessageReceiver

registerMessageReceiver(deviceRandomId: string, appParam: P2pAppParam, callback: Callback<P2pMessage>): Promise<void>

订阅对端设备应用向本端设备发送消息的事件，接收到对端应用发送的消息时使用callback异步回调，订阅成功与否使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 设置设备侧应用的应用信息：包名与指纹
        // 包名与指纹，可在华为开发者联盟获取
        let appInfo: wearEngine.AppInfo = {
          bundleName: '',
          fingerprint: ''
        }
        // 将设备侧应用参数类定义为appParam
        let appParam: wearEngine.P2pAppParam = {
          remoteApp: appInfo
          // transformLocalAppInfo默认为false，不转换包名
        }
        // 设置需要发送的消息
        let callback = (p2pMessage: wearEngine.P2pMessage) => {
          console.info(`Succeeded in receiving message, the message is ${p2pMessage.content}.`);
        }

        p2pClient.registerMessageReceiver(device.randomId, appParam, callback).then(() => {
          console.info(`Succeeded in registering message receiver.`);
        }).catch((error: BusinessError) => {
          console.error(`Failed to register message receiver. Code is ${error.code}, message is ${error.message}.`);
        })
      }
    } catch (error) {
      console.error(`Failed to check device capability. Code is ${error.code}, message is ${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

registerFileReceiver

registerFileReceiver(deviceRandomId: string, appParam: P2pAppParam, callback: Callback<P2pFile>): Promise<void>

订阅对端设备向本端设备发送文件的事件，接收到对端设备发送的文件时使用callback异步回调，订阅成功与否使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 设置设备侧应用的应用信息：包名与指纹
        // 包名与指纹，可在华为开发者联盟获取
        let appInfo: wearEngine.AppInfo = {
          bundleName: '',
          fingerprint: ''
        }
        // 将设备侧应用参数类定义为appParam
        let appParam: wearEngine.P2pAppParam = {
          remoteApp: appInfo
          // transformLocalAppInfo默认为false，不转换包名指纹
        }
        // 设置需要发送的文件信息
        let callback = (p2pMessage: wearEngine.P2pFile) => {
          console.info(`Succeeded in receiving file.`);
        }

        p2pClient.registerFileReceiver(device.randomId, appParam, callback).then(() => {
          console.info(`Succeeded in registering file receiver.`);
        }).catch((error: BusinessError) => {
          console.error(`Failed to register file receiver. Code is ${error.code}, message is ${error.message}.`);
        })
      }
    } catch (error) {
      console.error(`Failed to check device capability. Code is ${error.code}, message is ${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

registerFileReceiverWithProgress

registerFileReceiverWithProgress(deviceRandomId: string, appParam: P2pAppParam, callback: Callback<P2pFile>): Promise<void>

订阅对端设备向本端设备发送文件和文件传输进度的事件，接收到对端设备发送的文件和文件传输进度时使用callback异步回调，订阅成功与否使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 对于6.1.1(24)及之前版本，本接口实际支持的设备类型范围(Phone、Tablet）小于其所属系统能力支持的设备类型范围（Phone、Tablet、Wearable)。因硬件能力限制，该接口在Wearable设备中无法使用该能力。 对于26.0.0及之后版本，本接口实际支持的设备类型范围与其所属系统能力支持的设备类型范围一致（Phone、Tablet、Wearable)。

起始版本： 6.1.1(24)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 设置设备侧应用的应用信息：包名与指纹
        // 包名与指纹，可在华为开发者联盟获取
        let appInfo: wearEngine.AppInfo = {
          bundleName: '',
          fingerprint: ''
        }
        // 将设备侧应用参数类定义为appParam
        let appParam: wearEngine.P2pAppParam = {
          remoteApp: appInfo
          // transformLocalAppInfo默认为false，不转换包名指纹
        }
        // 设置需要发送的文件信息和传输进度
        let callback = (p2pMessage: wearEngine.P2pFile) => {
          if (!p2pMessage.file) {
            console.info(`progress is ${p2pMessage.progress}`);
          } else {
            console.info(`Succeeded in receiving file.`);
          }
        }

        p2pClient.registerFileReceiverWithProgress(device.randomId, appParam, callback).then(() => {
          console.info(`Succeeded in registering file receiver.`);
        }).catch((error: BusinessError) => {
          console.error(`Failed to register file receiver. Code is ${error.code}, message is ${error.message}.`);
        })
      }
    } catch (error) {
      console.error(`Failed to check device capability. Code is ${error.code}, message is ${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

unregisterMessageReceiver

unregisterMessageReceiver(deviceRandomId: string, appParam: P2pAppParam, callback: Callback<P2pMessage>): Promise<void>

取消订阅对端应用向本端应用发送消息的事件，取消订阅成功与否使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 设置设备侧应用的应用信息：包名与指纹
        // 包名与指纹，可在华为开发者联盟获取
        let appInfo: wearEngine.AppInfo = {
          bundleName: '',
          fingerprint: ''
        }
        // 将设备侧应用参数类定义为appParam
        let appParam: wearEngine.P2pAppParam = {
          remoteApp: appInfo
          // transformLocalAppInfo默认为false，不转换包名指纹
        }
        // 设置需要发送的消息
        let callback = (p2pMessage: wearEngine.P2pMessage) => {
          console.info(`Succeeded in receiving message, the message is ${p2pMessage.content}.`);
        }

        p2pClient.registerMessageReceiver(device.randomId, appParam, callback).then(() => {
          console.info(`Succeeded in registering message receiver.`);

          p2pClient.unregisterMessageReceiver(device.randomId, appParam, callback).then(() => {
            console.info(`Succeeded in unregistering message receiver.`);
          }).catch((error: BusinessError) => {
            console.error(`Failed to unregister message receiver. Code is ${error.code}, message is ${error.message}.`);
          })
        }).catch((error: BusinessError) => {
          console.error(`Failed to register message receiver. Code is ${error.code}, message is ${error.message}.`);
        })
      }
    } catch (error) {
      console.error(`Failed to check device capability. Code is ${error.code}, message is ${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

unregisterFileReceiver

unregisterFileReceiver(deviceRandomId: string, appParam: P2pAppParam, callback: Callback<P2pFile>): Promise<void>

取消订阅对端应用向本端应用发送文件的事件，取消订阅成功与否使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());
let p2pClient: wearEngine.P2pClient = wearEngine.getP2pClient(this.getUIContext().getHostContext());

try {
  let deviceList: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  deviceList.forEach(async (device, idx) => {
    try {
      // 挑选支持应用安装的设备
      if (await device.isDeviceCapabilitySupported(wearEngine.DeviceCapability.APP_INSTALLATION)) {
        // 设置设备侧应用的应用信息：包名与指纹
        // 包名与指纹，可在华为开发者联盟获取
        let appInfo: wearEngine.AppInfo = {
          bundleName: '',
          fingerprint: ''
        }
        // 将设备侧应用参数类定义为appParam
        let appParam: wearEngine.P2pAppParam = {
          remoteApp: appInfo
          // transformLocalAppInfo默认为false，不转换包名指纹
        }
        // 设置需要发送的文件信息
        let callback = (p2pMessage: wearEngine.P2pFile) => {
          console.info(`Succeeded in receiving file.`);
        }

        p2pClient.registerFileReceiver(device.randomId, appParam, callback).then(() => {
          console.info(`Succeeded in registering file receiver.`);

          p2pClient.unregisterFileReceiver(device.randomId, appParam, callback).then(() => {
            console.info(`Succeeded in unregistering file receiver.`);
          }).catch((error: BusinessError) => {
            console.error(`Failed to unregister file receiver. Code is ${error.code}, message is ${error.message}.`);
          })
        }).catch((error: BusinessError) => {
          console.error(`Failed to register file receiver. Code is ${error.code}, message is ${error.message}.`);
        })
      }
    } catch (error) {
      console.error(`Failed to check device capability. Code is ${error.code}, message is ${error.message}.`);
    }

    if (idx === deviceList.length - 1) {
      // 若不存在目标设备则抛出错误
      throw new Error('cannot find target device');
    }
  })
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

AppInfo

设备侧应用信息类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

P2pResultCode

存储P2p通信的返回值枚举类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

P2pResult

存储P2p通信的结果。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

P2pMessage

本端设备应用向对端设备应用发送的消息类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

P2pFile

本端设备应用向对端设备应用发送的文件类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

P2pAppParam

P2p通信过程中可用的设备侧应用参数类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

StartConfig

待拉起的对端设备应用的配置参数。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 6.1.1(24)

EntryType

待拉起的对端设备应用的组件类型。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 6.1.1(24)

wearEngine.getNotifyClient

getNotifyClient(context: common.Context): NotifyClient

用于获取Notify模块的客户端。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';

let notifyClient: wearEngine.NotifyClient = wearEngine.getNotifyClient(this.getUIContext().getHostContext());
console.info(`Succeeded in getting notify client`);

NotifyClient

Notify客户端类，由wearEngine.getNotifyClient返回得到。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

notify

notify(deviceRandomId: string, options: NotificationOptions): Promise<void>

向穿戴设备发送模板化通知，返回是否发送成功，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中无法使用该能力。

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let notifyClient: wearEngine.NotifyClient = wearEngine.getNotifyClient(this.getUIContext().getHostContext());
let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());

try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备且第一位即为目标设备）
    let device: wearEngine.Device = devices[0];

    let button1: wearEngine.NotificationButton = {
      buttonId: wearEngine.ButtonId.FIRST_BUTTON,
      content: 'button_1'
    }
    let type1Notification: wearEngine.Notification = {
      type: wearEngine.NotificationType.NOTIFICATION_WITH_ONE_BUTTON,
      bundleName: 'bundleName',
      title: 'title',
      text: 'text',
      buttons: [button1]
    }
    let options: wearEngine.NotificationOptions = {
      notification: type1Notification,
      onAction: (feedback: wearEngine.NotificationFeedback) => {
        console.info(`one button notify get feedback is ${feedback.action ? feedback.action : feedback.errorCode}`);
      }
    }

    notifyClient.notify(device.randomId, options).then(result => {
      console.info(`Succeeded in sending notification.`);
    }).catch((error: BusinessError) => {
      console.error(`Failed to send notification. Code is ${error.code}, message is ${error.message}`);
    })
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

NotificationOptions

模板化通知的配置参数类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

属性

onAction

onAction(feedback: NotificationFeedback): void

设备侧对应用发出的通知做相关操作后执行的回调函数。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中无法使用该能力。

起始版本： 5.0.0(12)

参数：

Notification

模板化通知的通知体参数类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

NotificationType

模板化通知的模板类型枚举类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

NotificationButton

通知按钮信息类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

ButtonId

模板化通知的按钮Id枚举类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

NotificationFeedback

设备侧操作通知的反馈类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

NotificationAction

设备侧对通知的操作反馈枚举类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

NotificationErrorCode

通知在设备侧发生错误的反馈枚举类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

wearEngine.getSensorClient

getSensorClient(context: common.Context): SensorClient

用于获取Sensor模块的客户端。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中返回801错误码。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';

let sensorClient: wearEngine.SensorClient = wearEngine.getSensorClient(this.getUIContext().getHostContext());
console.info(`Succeeded in getting sensor client`);

SensorClient

Sensor客户端类。由接口wearEngine.getSensorClient返回得到。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

getSensorList

getSensorList(deviceRandomId: string): Promise<Sensor[]>

获取设备侧可用的传感器列表，返回对应的传感器列表，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中无法使用该能力。

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let sensorClient: wearEngine.SensorClient = wearEngine.getSensorClient(this.getUIContext().getHostContext());
let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());

try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备且第一位即为目标设备）
    let device: wearEngine.Device = devices[0];

    sensorClient.getSensorList(device.randomId).then((sensorList) => {
      console.info(`Succeeded in getting sensor list, result is ${sensorList}`);
    }).catch((error: BusinessError) => {
      console.error(`Failed to get sensor list. Code is ${error.code}, message is ${error.message}`);
    })
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

subscribeSensor

subscribeSensor(deviceRandomId: string, type: SensorType, callback: Callback<SensorResult>): Promise<void>

订阅指定的传感器数据上报，返回是否订阅成功，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中无法使用该能力。

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let sensorClient: wearEngine.SensorClient = wearEngine.getSensorClient(this.getUIContext().getHostContext());
let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());

try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备，第一位即为目标设备且具备相关能力）
    let device: wearEngine.Device = devices[0];
    try {
      let sensorList: wearEngine.Sensor[] = await sensorClient.getSensorList(device.randomId);
      sensorList.forEach((sensor) => {
        if (sensor.type === wearEngine.SensorType.ACCELEROMETER) {
          let callback = (sensorResult: wearEngine.SensorResult) => {
            console.info(`Succeeded in getting sensor result, result is ${sensorResult}`);
          }
          // 订阅加速度传感器数据上报
          sensorClient.subscribeSensor(device.randomId, wearEngine.SensorType.ACCELEROMETER, callback).then(() => {
            console.info(`Succeeded in subscribing sensor data.`);
          }).catch((error: BusinessError) => {
            console.error(`Failed to subscribe sensor data. Code is ${error.code}, message is ${error.message}`);
          })
        }
      })
    } catch (error) {
      console.error(`Failed to get sensor list. Code is ${error.code}, message is ${error.message}`);
    }
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

unsubscribeSensor

unsubscribeSensor(deviceRandomId: string, type: SensorType, callback: Callback<SensorResult>): Promise<void>

取消订阅指定的传感器数据上报，返回是否取消成功，使用Promise异步回调。

系统能力： SystemCapability.Health.WearEngine

设备行为差异： 该接口在Phone、Tablet中可正常调用，在其他设备类型中无法使用该能力。

模型约束： 此接口仅可在Stage模型下使用。

起始版本： 5.0.0(12)

参数：

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let sensorClient: wearEngine.SensorClient = wearEngine.getSensorClient(this.getUIContext().getHostContext());
let deviceClient: wearEngine.DeviceClient = wearEngine.getDeviceClient(this.getUIContext().getHostContext());

try {
  let devices: wearEngine.Device[] = await deviceClient.getConnectedDevices();

  if (devices.length > 0) {
    // 从得到的设备列表中选取目标设备，并定义为device（假设数组中存在已连接设备，第一位即为目标设备且具备相关能力）
    let device: wearEngine.Device = devices[0];
    try {
      let sensorList: wearEngine.Sensor[] = await sensorClient.getSensorList(device.randomId);
      sensorList.forEach((sensor) => {
        if (sensor.type === wearEngine.SensorType.ACCELEROMETER) {
          let callback = (sensorResult: wearEngine.SensorResult) => {
            console.info(`Succeeded in getting sensor result, result is ${sensorResult}`);
          }
          // 订阅加速度传感器数据上报
          sensorClient.subscribeSensor(device.randomId, wearEngine.SensorType.ACCELEROMETER, callback)
            .then(() => {
              console.info(`Succeeded in subscribing sensor data.`);

              // 取消加速度传感器数据上报，注意传入的回调函数需与订阅时为同一对象
              sensorClient.unsubscribeSensor(device.randomId, wearEngine.SensorType.ACCELEROMETER, callback)
                .then(() => {
                  console.info(`Succeeded in unsubscribing sensor data.`);
                })
                .catch((error: BusinessError) => {
                  console.error(`Failed to unsubscribe sensor data. Code is ${error.code}, message is ${error.message}`);
                })
            })
            .catch((error: BusinessError) => {
              console.error(`Failed to subscribe sensor data. Code is ${error.code}, message is ${error.message}`);
            })
        }
      })
    } catch (error) {
      console.error(`Failed to get sensor list. Code is ${error.code}, message is ${error.message}`);
    }
  }
} catch (error) {
  console.error(`Failed to get connected devices. Code is ${error.code}, message is ${error.message}`);
}

SensorType

传感器类型。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

Sensor

传感器信息类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

SensorData

传感器上报数据类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

SensorErrorCode

传感器上报在设备侧发生错误的反馈枚举类。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

SensorResult

传感器上报结果。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

on/off订阅事件

wearEngine.on

on(type: 'serviceDie', callback: Callback<void>): void

订阅服务端消亡事件。使用callback异步回调。调用wearEngine.destroy接口主动发起的消亡事件不会触发执行回调函数。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let callback = () => {
  console.info(`The service destruction event`);
}
try {
  wearEngine.on('serviceDie', callback);
  console.info(`Succeeded in subscribing the service destruction event.`);
} catch (error) {
  const err: BusinessError = error as BusinessError;
  console.error(`Failed to subscribe the service destruction event. Code is ${err.code}, message is ${err.message}.`);
}

wearEngine.off

off(type: 'serviceDie', callback?: Callback<void>): void

取消订阅服务端消亡事件。使用callback异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

参数：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码和通用错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

let callback = () => {
  console.info(`The service destruction event`);
}
wearEngine.on('serviceDie', callback);

try {
  wearEngine.off('serviceDie', callback);
  console.info(`Succeeded in unsubscribing the service destruction event.`);
} catch (error) {
  const err: BusinessError = error as BusinessError;
  console.error(`Failed to unsubscribe the service destruction event. Code is ${err.code}, message is ${err.message}.`);
}

wearEngine.destroy

destroy(): Promise<void>

主动销毁服务端，使用Promise异步回调。

模型约束： 此接口仅可在Stage模型下使用。

系统能力： SystemCapability.Health.WearEngine

起始版本： 5.0.0(12)

返回值：

错误码：

以下错误码的详细介绍请参见Wear Engine ArkTS API错误码。

示例：

import { wearEngine } from '@kit.WearEngine';
import { BusinessError } from '@kit.BasicServicesKit';

wearEngine.destroy().then(() => {
  console.info(`Succeeded in destroying wear engine channel.`);
}).catch((error: BusinessError) => {
  console.error(`Failed to destroy wear engine channel. Code is ${error.code}, message is ${error.message}.`);
})