@react-native-ohos/react-native-ble-plx 3.5.1-rc.1

package/harmony/rn_bleplx/src/main/ets/BlePlxInterface.ts

@@ -0,0 +1,7 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a Apache-2.0 license that can be
+// found in the LICENSE file.
+
+export interface BlePlxInterface {
+  dispatchEvent(name: string, value: any);
+}

package/harmony/rn_bleplx/src/main/ets/BlePlxModule.ts

@@ -0,0 +1,226 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a Apache-2.0 license that can be
+// found in the LICENSE file.
+
+import { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { TM } from './generated/ts';
+import { BleClientManager } from './BleModule'
+import { BlePlxInterface } from './BlePlxInterface'
+import { ValueType } from '@kit.ArkData';
+import { PermissionHandler } from './common/PermissionHandler'
+
+export class BlePlxModule extends TurboModule implements TM.BlePlx.Spec, BlePlxInterface {
+  static NAME = 'BlePlx';
+
+  private manager: BleClientManager;
+
+  constructor(ctx: TurboModuleContext) {
+    super(ctx);
+
+    let permissionHandler = new PermissionHandler();
+    permissionHandler.checkPermission('ohos.permission.ACCESS_BLUETOOTH', ctx.uiAbilityContext);
+  }
+
+  public dispatchEvent(name: string, value: any) {
+    this.ctx.rnInstance.emitDeviceEvent(name, value);
+  }
+
+  addListener(eventName: string): void {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  removeListeners(count: number): void {
+    // Keep: Required for RN built in Event Emitter Calls.
+  }
+
+  createClient(restoreStateIdentifier?: string): void {
+    this.manager = new BleClientManager(restoreStateIdentifier);
+    this.manager.delegate = this;
+  }
+
+  destroyClient(): Promise<void> {
+    this.manager.invalidate();
+    this.manager = null;
+    return Promise.resolve();
+  }
+
+  cancelTransaction(transactionId: string): Promise<void> {
+    return this.manager.cancelTransaction(transactionId);
+  }
+
+  setLogLevel(logLevel: string): Promise<Object> {
+    return this.manager.setLogLevel(logLevel);
+  }
+
+  logLevel(): Promise<Object> {
+    return this.manager.getLogLevel();
+  }
+
+  enable(transactionId: string): Promise<void> {
+    return this.manager.enable(transactionId);
+  }
+
+  disable(transactionId: string): Promise<void> {
+    return this.manager.disable(transactionId);
+  }
+
+  state(): Promise<Object> {
+    return this.manager.state();
+  }
+
+  startDeviceScan(filteredUUIDs: string[], options: Object): Promise<void> {
+    return this.manager.startDeviceScan(filteredUUIDs, options);
+  }
+
+  stopDeviceScan(): Promise<void> {
+    return this.manager.stopDeviceScan();
+  }
+
+  requestConnectionPriorityForDevice(deviceId: string, connectionPriority: number,
+                                     transactionId: string): Promise<Object> {
+    return this.manager.requestConnectionPriorityForDevice(deviceId, connectionPriority, transactionId);
+  }
+
+  readRSSIForDevice(deviceId: string, transactionId: string): Promise<Object> {
+    return this.manager.readRSSIForDevice(deviceId, transactionId);
+  }
+
+  requestMTUForDevice(deviceId: string, mtu: number, transactionId: string): Promise<Object> {
+    return this.manager.requestMTUForDevice(deviceId, mtu, transactionId);
+  }
+
+  devices(deviceIdentifiers: string[]): Promise<Object[]> {
+    return this.manager.devices(deviceIdentifiers);
+  }
+
+  connectedDevices(serviceUUIDs: string[]): Promise<Object[]> {
+    return this.manager.getConnectedDevices(serviceUUIDs);
+  }
+
+  connectToDevice(deviceId: string, options?: Object): Promise<Object> {
+    return this.manager.connectToDevice(deviceId, options as Map<string, ValueType>);
+  }
+
+  cancelDeviceConnection(deviceId: string): Promise<Object> {
+    return this.manager.cancelDeviceConnection(deviceId);
+  }
+
+  isDeviceConnected(deviceId: string): Promise<boolean> {
+    return this.manager.isDeviceConnected(deviceId);
+  }
+
+  discoverAllServicesAndCharacteristicsForDevice(deviceId: string, transactionId: string): Promise<Object> {
+    return this.manager.discoverAllServicesAndCharacteristicsForDevice(deviceId, transactionId);
+  }
+
+  servicesForDevice(deviceId: string): Promise<Object[]> {
+    return this.manager.servicesForDevice(deviceId);
+  }
+
+  characteristicsForDevice(deviceId: string, serviceUUID: string): Promise<Object[]> {
+    return this.manager.characteristicsForDevice(deviceId, serviceUUID);
+  }
+
+  characteristicsForService(serviceIdentifier: number): Promise<Object[]> {
+    return this.manager.characteristicsForService(serviceIdentifier);
+  }
+
+  descriptorsForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string): Promise<Object[]> {
+    return this.manager.descriptorsForDevice(deviceId, serviceUUID, characteristicUUID);
+  }
+
+  descriptorsForService(serviceIdentifier: number, characteristicUUID: string): Promise<Object[]> {
+    return this.manager.descriptorsForService(serviceIdentifier, characteristicUUID);
+  }
+
+  descriptorsForCharacteristic(characteristicIdentifier: number): Promise<Object[]> {
+    return this.manager.descriptorsForCharacteristic(characteristicIdentifier);
+  }
+
+  readCharacteristicForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string,
+                              transactionId: string): Promise<Object> {
+    return this.manager.readCharacteristicForDevice(deviceId, serviceUUID, characteristicUUID, transactionId);
+  }
+
+  readCharacteristicForService(serviceIdentifier: number, characteristicUUID: string,
+                               transactionId: string): Promise<Object> {
+    return this.manager.readCharacteristicForService(serviceIdentifier, characteristicUUID, transactionId);
+  }
+
+  readCharacteristic(characteristicIdentifier: number, transactionId: string): Promise<Object> {
+    return this.manager.readCharacteristic(characteristicIdentifier, transactionId);
+  }
+
+  writeCharacteristicForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string, valueBase64: string,
+                               response: boolean, transactionId: string): Promise<Object> {
+    return this.manager.writeCharacteristicForDevice(deviceId, serviceUUID, characteristicUUID, valueBase64, response,
+      transactionId);
+  }
+
+  writeCharacteristicForService(serviceIdentifier: number, characteristicUUID: string, valueBase64: string,
+                                response: boolean, transactionId: string): Promise<Object> {
+    return this.manager.writeCharacteristicForService(serviceIdentifier, characteristicUUID, valueBase64, response,
+      transactionId);
+  }
+
+  writeCharacteristic(characteristicIdentifier: number, valueBase64: string, response: boolean,
+                      transactionId: string): Promise<Object> {
+    return this.manager.writeCharacteristic(characteristicIdentifier, valueBase64, response, transactionId);
+  }
+
+  monitorCharacteristicForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string,
+                                 transactionId: string, subscriptionType?: string): Promise<void> {
+    return this.manager.monitorCharacteristicForDevice(deviceId, serviceUUID, characteristicUUID, transactionId, subscriptionType);
+  }
+
+  monitorCharacteristicForService(serviceIdentifier: number, characteristicUUID: string,
+                                  transactionId: string, subscriptionType?: string): Promise<void> {
+    return this.manager.monitorCharacteristicForService(serviceIdentifier, characteristicUUID, transactionId, subscriptionType);
+  }
+
+  monitorCharacteristic(characteristicIdentifier: number, transactionId: string, subscriptionType?: string): Promise<void> {
+    return this.manager.monitorCharacteristic(characteristicIdentifier, transactionId, subscriptionType);
+  }
+
+  readDescriptorForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string,
+                          transactionId: string): Promise<Object> {
+    return this.manager.readDescriptorForDevice(deviceId, serviceUUID, characteristicUUID, descriptorUUID,
+      transactionId);
+  }
+
+  readDescriptorForService(serviceIdentifier: number, characteristicUUID: string, descriptorUUID: string,
+                           transactionId: string): Promise<Object> {
+    return this.manager.readDescriptorForService(serviceIdentifier, characteristicUUID, descriptorUUID, transactionId);
+  }
+
+  readDescriptorForCharacteristic(characteristicIdentifier: number, descriptorUUID: string,
+                                  transactionId: string): Promise<Object> {
+    return this.manager.readDescriptorForCharacteristic(characteristicIdentifier, descriptorUUID, transactionId);
+  }
+
+  readDescriptor(descriptorIdentifier: number, transactionId: string): Promise<Object> {
+    return this.manager.readDescriptor(descriptorIdentifier, transactionId);
+  }
+
+  writeDescriptorForDevice(deviceId: string, serviceUUID: string, characteristicUUID: string, descriptorUUID: string,
+                           valueBase64: string, transactionId: string): Promise<Object> {
+    return this.manager.writeDescriptorForDevice(deviceId, serviceUUID, characteristicUUID, descriptorUUID, valueBase64,
+      transactionId);
+  }
+
+  writeDescriptorForService(serviceIdentifier: number, characteristicUUID: string, descriptorUUID: string,
+                            valueBase64: string, transactionId: string): Promise<Object> {
+    return this.manager.writeDescriptorForService(serviceIdentifier, characteristicUUID, descriptorUUID, valueBase64,
+      transactionId);
+  }
+
+  writeDescriptorForCharacteristic(characteristicIdentifier: number, descriptorUUID: string, valueBase64: string,
+                                   transactionId: string): Promise<Object> {
+    return this.manager.writeDescriptorForCharacteristic(characteristicIdentifier, descriptorUUID, valueBase64,
+      transactionId);
+  }
+
+  writeDescriptor(descriptorIdentifier: number, valueBase64: string, transactionId: string): Promise<Object> {
+    return this.manager.writeDescriptor(descriptorIdentifier, valueBase64, transactionId);
+  }
+}

package/harmony/rn_bleplx/src/main/ets/BlePlxPackage.ts

@@ -0,0 +1,26 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a Apache-2.0 license that can be
+// found in the LICENSE file.
+
+import { RNPackage, TurboModulesFactory } from '@rnoh/react-native-openharmony/ts';
+import type { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { BlePlxModule } from './BlePlxModule';
+
+class BlePlxModulesFactory extends TurboModulesFactory {
+  createTurboModule(name: string): TurboModule | null {
+    if (name == 'BlePlx') {
+      return new BlePlxModule(this.ctx);
+    }
+    return null;
+  }
+
+  hasTurboModule(name: string): boolean {
+    return name == 'BlePlx';
+  }
+}
+
+export class BlePlxPackage extends RNPackage {
+  createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
+    return new BlePlxModulesFactory(ctx);
+  }
+}

package/harmony/rn_bleplx/src/main/ets/Characteristic.ts

@@ -0,0 +1,159 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a Apache-2.0 license that can be
+// found in the LICENSE file.
+
+import ble from '@ohos.bluetooth.ble';
+import Logger from './common/Logger';
+import { Service } from './Service';
+import { arrayBufferToBase64 } from './common/BleUtils'
+import { Descriptor } from './Descriptor'
+import { IdGenerator } from './common/IdGenerator';
+import { IdGeneratorKey } from './common/IdGeneratorKey';
+import { ValuesBucket } from '@kit.ArkData';
+import { InstanceIdGenerator } from './common/InstanceIdGenerator';
+
+export class Characteristic {
+  private id: number;
+  private serviceID: number;
+  private serviceUUID: string;
+  private deviceID: string;
+  private value: ArrayBuffer;
+  public gattCharacteristic: ble.BLECharacteristic;
+
+  public writeType: ble.GattWriteType;
+
+  public setValue(value: ArrayBuffer) {
+    this.value = value;
+  }
+
+  constructor(id: number, deviceID: string, serviceID: number, serviceUUID: string,
+              gattCharacteristic: ble.BLECharacteristic) {
+    this.id = id;
+    this.deviceID = deviceID;
+    this.serviceUUID = serviceUUID;
+    this.serviceID = serviceID;
+    this.gattCharacteristic = gattCharacteristic;
+  }
+
+  static constructorWithId(id: number, service: Service, gattCharacteristic: ble.BLECharacteristic): Characteristic {
+    return new Characteristic(id, service.getDeviceID(), service.getId(), service.getUuid(), gattCharacteristic);
+  }
+
+  static constructorWithNative(service: Service, gattCharacteristic: ble.BLECharacteristic): Characteristic {
+    let id: number =
+      IdGenerator.getIdForKey(new IdGeneratorKey(service.getDeviceID(), gattCharacteristic.characteristicUuid,
+        InstanceIdGenerator.generateInstanceId(gattCharacteristic.characteristicUuid)))
+    return new Characteristic(id, service.getDeviceID(), service.getId(), service.getUuid(), gattCharacteristic);
+  }
+
+  static constructorWithOther(other: Characteristic): Characteristic {
+    return new Characteristic(other.id, other.deviceID, other.serviceID, other.serviceUUID, other.gattCharacteristic);
+  }
+
+  public getId(): number {
+    return this.id;
+  }
+
+  public getUuid(): string {
+    return this.gattCharacteristic.characteristicUuid;
+  }
+
+  public getServiceID(): number {
+    return this.serviceID;
+  }
+
+  public getServiceUUID(): string {
+    return this.serviceUUID;
+  }
+
+  public getDeviceId(): string {
+    return this.deviceID;
+  }
+
+  public getInstanceId(): number {
+    return InstanceIdGenerator.generateInstanceId(this.gattCharacteristic.characteristicUuid);
+  }
+
+  public getGattDescriptor(uuid: string): ble.BLEDescriptor | null {
+    let descriptor: ble.BLEDescriptor = null;
+    this.gattCharacteristic.descriptors.forEach(value => {
+      if (value.descriptorUuid == uuid) {
+        descriptor = value;
+      }
+    })
+
+    return descriptor;
+  }
+
+  public setWriteType(writeType: number) {
+    this.writeType = writeType;
+  }
+
+  public isReadable(): boolean {
+    return this.gattCharacteristic.properties.read ?? false;
+  }
+
+  public isWritableWithResponse(): boolean {
+    return this.gattCharacteristic.properties.write ?? false;
+  }
+
+  public isWritableWithoutResponse(): boolean {
+    return this.gattCharacteristic.properties.writeNoResponse ?? false;
+  }
+
+  public isNotifiable(): boolean {
+    return this.gattCharacteristic.properties.notify ?? false;
+  }
+
+  public getDescriptors(): Descriptor[] {
+    var descriptors: Descriptor[] = []
+    this.gattCharacteristic.descriptors.forEach(value => {
+      let obj = Descriptor.constructorWithNative(this, value);
+      descriptors.push(obj);
+    });
+    return descriptors;
+  }
+
+  public isNotifying(): boolean {
+    return false;
+  }
+
+  public isIndicatable(): boolean {
+    return this.gattCharacteristic.properties.indicate;
+  }
+
+  public getValue(): ArrayBuffer {
+    return this.value;
+  }
+
+  public getDescriptorByUUID(uuid: string): Descriptor {
+    let descriptor: Descriptor = null;
+    this.gattCharacteristic.descriptors.forEach(value => {
+      if (value.descriptorUuid == uuid) {
+        descriptor = Descriptor.constructorWithNative(this, value);
+      }
+    })
+    return descriptor;
+  }
+
+  public logValue(message: string, value: ArrayBuffer) {
+    Logger.debug(message);
+  }
+
+  public asJSObject(): ValuesBucket {
+    return {
+      "id": this.getId(),
+      "uuid": this.getUuid(),
+      "deviceID": this.getDeviceId(),
+      "serviceID": this.getServiceID(),
+      "serviceUUID": this.getServiceUUID(),
+      "isReadable": this.isReadable(),
+      "isWritableWithResponse": this.isWritableWithResponse(),
+      "isWritableWithoutResponse": this.isWritableWithoutResponse(),
+      "isNotifiable": this.isNotifiable(),
+      "isNotifying": this.isNotifying(),
+      "isIndicatable": this.isIndicatable(),
+      "value": arrayBufferToBase64(this.value),
+    };
+  }
+}

package/harmony/rn_bleplx/src/main/ets/CommonConstants.ts

@@ -0,0 +1,10 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a Apache-2.0 license that can be
+// found in the LICENSE file.
+
+export default class CommonConstants {
+  /**
+   * Log tag.
+   */
+  static readonly TAG = '[RNOH] BlePlx';
+}

package/harmony/rn_bleplx/src/main/ets/Descriptor.ts

@@ -0,0 +1,123 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a Apache-2.0 license that can be
+// found in the LICENSE file.
+
+import ble from '@ohos.bluetooth.ble';
+import Logger from './common/Logger'
+import { Characteristic } from './Characteristic';
+import { IdGenerator } from './common/IdGenerator';
+import { IdGeneratorKey } from './common/IdGeneratorKey';
+import { arrayBufferToBase64 } from './common/BleUtils';
+import { ValuesBucket } from '@kit.ArkData';
+
+export class Descriptor {
+  private characteristicId: number;
+  private serviceId: number;
+  private characteristicUuid: string;
+  private serviceUuid: string;
+  private deviceId: string;
+  private descriptor: ble.BLEDescriptor;
+  private id: number;
+  private uuid: string;
+  private value: ArrayBuffer;
+
+  constructor(id: number,
+              uuid: string,
+              value: ArrayBuffer,
+              deviceId: string,
+              serviceId: number,
+              serviceUuid: string,
+              characteristicId: number,
+              characteristicUuid: string,
+              descriptor: ble.BLEDescriptor) {
+    this.id = id;
+    this.uuid = uuid;
+    this.value = value;
+    this.deviceId = deviceId;
+    this.serviceId = serviceId;
+    this.serviceUuid = serviceUuid;
+    this.characteristicId = characteristicId;
+    this.characteristicUuid = characteristicUuid;
+    this.descriptor = descriptor;
+  }
+
+  static constructorWithNative(characteristic: Characteristic, gattDescriptor: ble.BLEDescriptor) {
+    let id = IdGenerator.getIdForKey(new IdGeneratorKey(characteristic.getDeviceId(), gattDescriptor.descriptorUuid,
+      characteristic.getId()));
+    return new Descriptor(id, gattDescriptor.descriptorUuid, gattDescriptor.descriptorValue,
+      characteristic.getDeviceId(), characteristic.getServiceID(), characteristic.getServiceUUID(),
+      characteristic.getId(), characteristic.getUuid(), gattDescriptor)
+  }
+
+  static constructorWithId(characteristicId: number, serviceId: number, characteristicUuid: string, serviceUuid: string,
+                           deviceId: string, descriptor: ble.BLEDescriptor, id: number, uuid: string) {
+    return new Descriptor(id, uuid, descriptor.descriptorValue, deviceId, serviceId, serviceUuid, characteristicId,
+      characteristicUuid, descriptor)
+  }
+
+  static constructorWithOther(other: Descriptor) {
+    return new Descriptor(other.id, other.uuid, other.value, other.deviceId, other.serviceId, other.serviceUuid,
+      other.characteristicId, other.characteristicUuid, other.descriptor)
+  }
+
+  public getId(): number {
+    return this.id;
+  }
+
+  public getDeviceId(): string {
+    return this.deviceId;
+  }
+
+  public getCharacteristicId(): number {
+    return this.characteristicId;
+  }
+
+  public getServiceId(): number {
+    return this.serviceId;
+  }
+
+  public getCharacteristicUuid(): string {
+    return this.characteristicUuid;
+  }
+
+  public getServiceUuid(): string {
+    return this.serviceUuid;
+  }
+
+  public getUuid(): string {
+    return this.uuid;
+  }
+
+  public getValue(): ArrayBuffer {
+    return this.value;
+  }
+
+  public setValue(value: ArrayBuffer) {
+    this.value = value;
+  }
+
+  public setValueFromCache() {
+    this.value = this.descriptor.descriptorValue;
+  }
+
+  public getNativeDescriptor(): ble.BLEDescriptor {
+    return this.descriptor;
+  }
+
+  public logValue(message: string, value: ArrayBuffer) {
+    Logger.debug(message);
+  }
+
+  public asJSObject(): ValuesBucket {
+    return {
+      "id": this.getId(),
+      "uuid": this.getUuid(),
+      "deviceID": this.getDeviceId(),
+      "serviceID": this.getServiceId(),
+      "serviceUUID": this.getServiceUuid(),
+      "characteristicUUID": this.getCharacteristicUuid(),
+      "characteristicID": this.getCharacteristicId(),
+      "value": arrayBufferToBase64(this.value),
+    };
+  }
+}

package/harmony/rn_bleplx/src/main/ets/Service.ts

@@ -0,0 +1,65 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a Apache-2.0 license that can be
+// found in the LICENSE file.
+
+import ble from '@ohos.bluetooth.ble';
+import Logger from './common/Logger';
+import { Characteristic } from './Characteristic';
+import { ValuesBucket } from '@kit.ArkData';
+
+export class Service {
+  private id: number;
+  private deviceID: string;
+  private btGattService: ble.GattService;
+
+  constructor(id: number, deviceID: string, btGattService: ble.GattService) {
+    this.id = id;
+    this.deviceID = deviceID;
+    this.btGattService = btGattService;
+  }
+
+  public getId(): number {
+    return this.id;
+  }
+
+  public getUuid(): string {
+    return this.btGattService.serviceUuid;
+  }
+
+  public getDeviceID(): string {
+    return this.deviceID;
+  }
+
+  public isPrimary(): boolean {
+    return this.btGattService.isPrimary;
+  }
+
+  public getCharacteristicByUUID(uuid: string): Characteristic | null {
+    var characteristic: Characteristic = null;
+    this.btGattService.characteristics.forEach(value => {
+      if (value.characteristicUuid == uuid) {
+        characteristic = Characteristic.constructorWithNative(this, value);
+      }
+    })
+
+    return characteristic;
+  }
+
+  public getCharacteristics(): Characteristic[] {
+    var characteristics: Characteristic[] = []
+    this.btGattService.characteristics.forEach(value => {
+      let obj = Characteristic.constructorWithNative(this, value);
+      characteristics.push(obj);
+    });
+    return characteristics;
+  }
+
+  public asJSObject(): ValuesBucket {
+    return {
+      "id": this.getId(),
+      "uuid": this.getUuid(),
+      "deviceID": this.getDeviceID(),
+      "isPrimary": this.isPrimary(),
+    };
+  }
+}

package/harmony/rn_bleplx/src/main/ets/common/BleError.ts

@@ -0,0 +1,70 @@
+// Copyright (c) 2025 Huawei Device Co., Ltd. All rights reserved
+// Use of this source code is governed by a Apache-2.0 license that can be
+// found in the LICENSE file.
+
+export const BleErrorCode = {
+  UnknownError: 0,
+  BluetoothManagerDestroyed: 1,
+  OperationCancelled: 2,
+  OperationTimedOut: 3,
+  OperationStartFailed: 4,
+  InvalidIdentifiers: 5,
+  BluetoothUnsupported: 100,
+  BluetoothUnauthorized: 101,
+  BluetoothPoweredOff: 102,
+  BluetoothInUnknownState: 103,
+  BluetoothResetting: 104,
+  BluetoothStateChangeFailed: 105,
+  DeviceConnectionFailed: 200,
+  DeviceDisconnected: 201,
+  DeviceRSSIReadFailed: 202,
+  DeviceAlreadyConnected: 203,
+  DeviceNotFound: 204,
+  DeviceNotConnected: 205,
+  DeviceMTUChangeFailed: 206,
+  ServicesDiscoveryFailed: 300,
+  IncludedServicesDiscoveryFailed: 301,
+  ServiceNotFound: 302,
+  ServicesNotDiscovered: 303,
+  CharacteristicsDiscoveryFailed: 400,
+  CharacteristicWriteFailed: 401,
+  CharacteristicReadFailed: 402,
+  CharacteristicNotifyChangeFailed: 403,
+  CharacteristicNotFound: 404,
+  CharacteristicsNotDiscovered: 405,
+  CharacteristicInvalidDataFormat: 406,
+  DescriptorsDiscoveryFailed: 500,
+  DescriptorWriteFailed: 501,
+  DescriptorReadFailed: 502,
+  DescriptorNotFound: 503,
+  DescriptorsNotDiscovered: 504,
+  DescriptorInvalidDataFormat: 505,
+  DescriptorWriteNotAllowed: 506,
+  ScanStartFailed: 600,
+  LocationServicesDisabled: 601,
+};
+
+export class BleError extends Error {
+  public errorCode: number;
+  public harmonyCode?: number;
+  public reason: string;
+  public deviceID?: string;
+  public serviceUUID?: string;
+  public characteristicUUID?: string;
+  public descriptorUUID?: string;
+  public internalMessage?: string;
+
+  constructor(errorCode: number, reason: string, harmonyCode?: number) {
+    super(`Error code: ${errorCode}, harmony code: ${harmonyCode}, reason: ${reason}`);
+    this.errorCode = errorCode;
+    this.reason = reason;
+    this.harmonyCode = harmonyCode;
+  }
+
+  getMessage(): string {
+    return `Error code: ${this.errorCode}, harmony code: ${this.harmonyCode}, reason: ${this.reason}, ` +
+      `deviceId: ${this.deviceID}, serviceUuid: ${this.serviceUUID}, ` +
+      `characteristicUuid: ${this.characteristicUUID}, descriptorUuid: ${this.descriptorUUID}, ` +
+      `internalMessage: ${this.internalMessage}`;
+  }
+}