mini_program_gizwits_sdk 3.6.1 → 3.6.3

package/dist/src/types/index.d.ts

@@ -0,0 +1,360 @@
+import { TCPHandler } from "../handler/lan";
+import DiscoverUDP from "../protocol/DiscoverUDP";
+import { wrapErrorInfo } from "../utils";
+export type TUtf8 = {
+    toBytes: (data: any) => any;
+};
+export type TUtils = {
+    utf8: TUtf8;
+};
+export interface ecb {
+    new (data: any): any;
+}
+export type TModeOfOperation = {
+    ecb: ecb;
+};
+export interface IError {
+    errorCode: number;
+    errorMessage?: string;
+}
+export interface ICommonObj {
+    [key: string]: any;
+}
+export interface IDeviceStatusChangedProps {
+    did: string;
+    attrs: ICommonObj;
+}
+export interface IDeviceRawStatusChangedProps {
+    did: string;
+    raw: Uint8Array;
+}
+export interface IOnDeviceStatusChanged {
+    (data: IDeviceStatusChangedProps | IDeviceRawStatusChangedProps): void;
+}
+export interface IOnSocketStatusChanged {
+    (dids: string[], enabled: boolean): void;
+}
+export interface IEmptyFn {
+    (): void;
+}
+export interface IDevice {
+    mac: string;
+    productKey: string;
+    did: string;
+    bleWorkStatus?: number;
+    name: string;
+    isBind: boolean;
+    rootDeviceId?: string;
+    bleDeviceID?: string;
+    remark?: string;
+    passcode?: string;
+    connectType: TConnectType;
+    isOnline: boolean;
+    isLanOnline: boolean;
+    isBleOnline: boolean;
+    host?: string;
+    wss_port?: number;
+    ctime?: number;
+}
+export type TConnectType = 'BLE' | 'BLE_BROADCAST' | 'LAN' | 'WAN' | 'NONE';
+export interface IBluetoothAdapterStateResult {
+    discovering: boolean;
+    available: boolean;
+}
+export interface IWechatResult {
+    errMsg: string;
+    errCode: number;
+}
+export interface IWXDevicesResult {
+    success: true;
+    bleDevices: WechatMiniprogram.BlueToothDevice[];
+}
+export interface SyncCallBackParams {
+    event: TSyncEvnet;
+    currentNum?: number;
+    totalNum?: number;
+    message?: string;
+}
+export type TSyncEvnet = 'SYNC_START' | 'SYNC_END' | 'SYNC_FAIL' | 'SYNC_CANCEL' | 'SYNC_PROGRESS';
+export type SyncCallBack = (data: SyncCallBackParams) => void;
+export type IOTAType = 'MCU' | 'MODULE';
+export interface ISDKResult<T> {
+    data?: T;
+    err?: IError;
+    message?: string;
+    success: boolean;
+}
+export interface ISetCommonDeviceOnboardingDeployProps {
+    ssid: string;
+    bssid?: string;
+    password: string;
+    timeout: number;
+    isBind?: boolean;
+    mode?: 0 | 3 | 5;
+    softAPSSIDPrefix?: string;
+}
+export interface ISetDeviceOnboardingDeployProps extends ISetCommonDeviceOnboardingDeployProps {
+    softAPSSIDPrefix: string;
+    eventCallBack: (event: ConfigEventData) => void;
+}
+export interface IRandomCodesResult {
+    random_code: string;
+    product_key: string;
+    mac: string;
+    did: string;
+    user_id: string;
+    timestamp: number;
+    type: string;
+    wifi_soft_ver: string;
+    lan_proto_ver: string;
+}
+export interface IBindRemoteDeviceParams {
+    productKey: string;
+    mac: string;
+    beOwner?: boolean;
+    alias?: string;
+}
+export interface IDeviceStatusNoti {
+    device: IDevice;
+    connectType: TConnectType;
+}
+export interface IDeviceAttrsNoti {
+    device: IDevice;
+    data: object;
+}
+export interface TListenerType {
+    GizDeviceListNotifications: TDeviceListNotifications;
+    GizDeviceStatusNotifications: TDeviceStatusNotifications;
+    GizDeviceAttrsNotifications: TDeviceAttrsNotifications;
+    onScanListChange: OnScanListChange;
+    onBleHandleError: OnBleHandleError;
+}
+export type TDeviceListNotifications = (devices: IDevice[]) => void;
+export type TDeviceStatusNotifications = (data: IDeviceStatusNoti) => void;
+export type TDeviceAttrsNotifications = (data: IDeviceAttrsNoti) => void;
+export type OnScanListChange = (devices: IDevice[]) => void;
+export type OnBleHandleError = (error: IError) => void;
+export interface IDeviceSafetyRegisterParams {
+    mac: string;
+    productKey: string;
+}
+export interface IDeviceSafetyParams extends IDeviceSafetyRegisterParams {
+    isReset: boolean;
+}
+export interface IResult<T> {
+    success: boolean;
+    data?: T;
+    err?: IError;
+}
+export interface ICloudServiceInfo {
+    openAPIInfo: string;
+}
+export type TimeoutHandle = ReturnType<typeof setTimeout> | null;
+export type IntervalHandle = ReturnType<typeof setInterval> | null;
+export interface IProductInfo {
+    productKey: string;
+    productSecret: string;
+}
+export interface GizwitsSdkOption {
+    appID: string;
+    appSecret: string;
+    productInfo: IProductInfo[];
+    cloudServiceInfo?: ICloudServiceInfo;
+    token?: string;
+    uid?: string;
+    offlineThreshold?: number;
+}
+export interface IRejectCallback {
+    (result: IResult<unknown>): void;
+}
+export type TConfigEvent = 'GIZ_CONFIG_START' | 'GIZ_DISCOVER_SUCCESS' | 'GIZ_CONNECT_SUCCESS' | 'GIZ_CONFIG_SEND_SUCCESS' | 'GIZ_CONFIG_RECV_SUCCESS' | 'GIZ_CONFIG_SUCCESS';
+export interface ConfigEventData {
+    event: TConfigEvent;
+    deviceID?: string;
+}
+export interface IOpenApiDevice {
+    product_key: string;
+    did: string;
+    mac: string;
+    passcode: string;
+    is_online: boolean;
+    host: string;
+    port: string;
+    port_s: string;
+    ws_port: number;
+    wss_port: number;
+    dev_alias: string;
+    remark: string;
+    type: 'normal' | 'center_control' | 'sub_dev';
+}
+export interface IDeviceRes {
+    devices: IOpenApiDevice[];
+}
+export interface IErrorCode {
+    [key: string]: IError;
+}
+export interface IWechatApiResult<T> {
+    data: T;
+    errMsg: string;
+    statusCode: number;
+}
+export interface IServiceResult<T> {
+    success: boolean;
+    data?: T;
+    err?: IError;
+}
+export interface IGetRandomCodes {
+    SSID: string;
+    password: string;
+    pks: string[];
+}
+export interface IGetRandomCode {
+    SSID: string;
+    password: string;
+    pk: string;
+}
+export interface IProductConfigData {
+    [key: string]: IDataPointConfig;
+}
+export interface IDataPointConfig {
+    name: string;
+    protocolType: 'var_len' | 'standard';
+    entities: IDataPointEntitie[];
+}
+export interface IDataPointEntitie {
+    display_name: string;
+    attrs: IDataPointAttr[];
+}
+export interface IDataPointPosition {
+    byte_offset: number;
+    unit: 'bit' | 'byte';
+    len: number;
+    bit_offset: number;
+}
+export type TDataType = 'bool' | 'uint8' | 'uint16' | 'uint32' | 'binary' | 'enum' | 'number';
+export interface IUnitSpec {
+    addition: number;
+    max: number;
+    ratio: number;
+    min: number;
+}
+export type TDataOptionType = 'status_writable' | 'status_readonly' | 'alert' | 'fault' | 'ALL';
+export interface IDataPointAttr {
+    display_name: string;
+    uint_spec: IUnitSpec;
+    name: string;
+    data_type: TDataType;
+    position: IDataPointPosition;
+    type: TDataOptionType;
+    id: number;
+    enum: string[];
+    desc: string;
+}
+export type GizBleDeviceListotifications = (devices: IDevice[]) => void;
+export type GizBleDeviceDataNotifications = (curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult, hexString: string) => void;
+export type GizBleErrorNotifications = (err: {
+    errCode: number;
+    errMsg: string;
+}) => void;
+export type TBleDataListener<T> = (_curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult, hexString: string) => T | null | undefined;
+export interface CheckOTAParams {
+    device: IDevice;
+    type: IOTAType;
+}
+export type OTAEventCode = 'GizOTAEventPretreatment' | 'GizOTAEventDownload' | 'GizOTAEventTransmit' | 'GizOTAEventReboot' | 'GizOTAEventFinish';
+export interface OTAEvent {
+    code: OTAEventCode;
+}
+export interface OTAProgressEvent {
+    firmwareSize: number;
+    packageMaxLen: number;
+    currentNumber: number;
+    currentProgress: number;
+}
+export type OTAProgressEventCallback = (event: OTAProgressEvent) => void;
+export type OTAEventCallback = (event: OTAEvent) => void;
+export interface StartUpgradeParams extends CheckOTAParams {
+    onProgress: OTAProgressEventCallback;
+    onEvent: OTAEventCallback;
+    productKey: string;
+}
+export interface TBleHandleEvent {
+    GizBleDeviceData: GizBleDeviceDataNotifications;
+    GizBleDeviceList: GizBleDeviceListotifications;
+    GizBleError: GizBleErrorNotifications;
+}
+export interface GizwitsWxBlueToothDevice extends WechatMiniprogram.BlueToothDevice {
+    communicationType: 'BLE_BROADCAST' | 'BLE';
+}
+export interface BleHandleParams {
+    serviceUUIDSuffix: string;
+    characteristicUUIDSuffix: string;
+}
+export interface IStartScanResult {
+    scanList: IDevice[];
+    err?: ReturnType<typeof wrapErrorInfo>;
+}
+export interface IDeviceReq<T> {
+    success: boolean;
+    data: T;
+}
+export type OnScanDevice = (scanList: IDevice[]) => void;
+export interface BleConnectDevice {
+    deviceId?: string;
+    serviceId?: string;
+    characteristicId?: string;
+    errMsg?: string;
+}
+export interface BleConstructorParams {
+    pks: string[];
+    bleHandleParams?: BleHandleParams;
+    offlineThreshold?: number;
+}
+export interface LanConnectDevice {
+    mac: string;
+    productKey: string;
+    socketHandle: TCPHandler;
+}
+export interface ILanDevice extends IDevice {
+    expandData: DiscoverUDP;
+    ip: string;
+}
+export type GizLanDeviceListNotifications = (devices: IDevice[]) => void;
+export type GizLanDeviceDataNotifications = (mac: string, data: string) => void;
+export interface TLanHandleEvent {
+    GizLanDeviceList: GizLanDeviceListNotifications;
+    GizLanDeviceData: GizLanDeviceDataNotifications;
+}
+export interface IBLEService {
+    uuid: string;
+    isPrimary: boolean;
+}
+export interface IBLECharacteristic {
+    uuid: string;
+    properties: {
+        read: boolean;
+        write: boolean;
+        notify: boolean;
+        indicate: boolean;
+    };
+}
+export interface ILoginRes {
+    expire_at: number;
+    token: string;
+    uid: string;
+}
+export interface OTARes {
+    download_url: string;
+    soft_ver: string;
+}
+export interface configDeviceParams {
+    ssid: string;
+    password: string;
+    softAPSSIDPrefix: string;
+}
+export interface configBLEDeviceParams {
+    ssid: string;
+    password: string;
+    softAPSSIDPrefix?: string;
+    timeout: number;
+}

package/dist/src/utils.d.ts

@@ -1,7 +1,6 @@
 /// <reference types="crypto-js" />
 import { lib } from "crypto-js/core";
-import { IProductInfo } from './sdk';
-import { GizwitsWxBlueToothDevice } from './handler/ble';
+import { IDevice, IError, IWXDevicesResult, TConnectType, IProductInfo, GizwitsWxBlueToothDevice } from "./types";
 export declare function ab2hex(buffer: ArrayBuffer): any;
 export declare function compareWXSDKVersion(v1: string, v2: string): 0 | 1 | -1;
 export declare const isError: (err: unknown) => err is IError;
@@ -10,10 +9,6 @@ export declare const wrapErrorInfo: (errorMessage: string) => {
     errorMessage: string;
 };
 export declare const unionBy: <T>(array: T[], key: string) => T[];
-interface IWXDevicesResult {
-    success: true;
-    bleDevices: WechatMiniprogram.BlueToothDevice[];
-}
 export declare function isWXDevicesResult(res: unknown): res is IWXDevicesResult;
 export declare function str2Buf(arr: string): ArrayBuffer;
 export declare const numberArray2Uint8Array: (numArr: number[]) => Uint8Array;

package/dist/src/wechatApi.d.ts

@@ -1,11 +1,4 @@
-interface IBluetoothAdapterStateResult {
-    discovering: boolean;
-    available: boolean;
-}
-export interface IWechatResult {
-    errMsg: string;
-    errCode: number;
-}
+import { IBluetoothAdapterStateResult, IWechatResult, IBLEService, IBLECharacteristic } from "./types";
 export declare function retryConnect(deviceId: string, timeout?: number): Promise<IWechatResult | {
     success: boolean;
 }>;
@@ -15,20 +8,7 @@ export declare function getBluetoothAdapterState(): Promise<IBluetoothAdapterSta
 export declare function startBluetoothDevicesDiscovery(allowDuplicatesKey?: boolean): Promise<IWechatResult>;
 export declare function getBluetoothDevices(): Promise<WechatMiniprogram.BlueToothDevice[]>;
 export declare function createBLEConnection(deviceId: string, timeout: number): Promise<IWechatResult>;
-interface IBLEService {
-    uuid: string;
-    isPrimary: boolean;
-}
 export declare function getBLEDeviceServices(deviceId: string): Promise<IBLEService[]>;
-interface IBLECharacteristic {
-    uuid: string;
-    properties: {
-        read: boolean;
-        write: boolean;
-        notify: boolean;
-        indicate: boolean;
-    };
-}
 export declare function getBLEDeviceCharacteristics(deviceId: string, serviceId: string): Promise<IBLECharacteristic[]>;
 export declare function notifyBLECharacteristicValueChange(deviceId: string, serviceId: string, characteristicId: string, state?: boolean): Promise<IWechatResult>;
 export declare function writeBLECharacteristicValue(deviceId: string, serviceId: string, characteristicId: string, value: ArrayBuffer): Promise<IWechatResult>;
@@ -37,4 +17,3 @@ export declare function downloadFile({ url }: {
     url: any;
 }): Promise<unknown>;
 export declare function setMtu(mtu: number, deviceId: string): Promise<unknown>;
-export {};

package/dist/src/wifiConfig/ConfigBase.d.ts

@@ -1,12 +1,5 @@
-import { IRandomCodesResult, IResult, TimeoutHandle } from "../sdk";
-interface IRejectCallback {
-    (result: IResult<unknown>): void;
-}
-export type TConfigEvent = 'GIZ_CONFIG_START' | 'GIZ_DISCOVER_SUCCESS' | 'GIZ_CONNECT_SUCCESS' | 'GIZ_CONFIG_SEND_SUCCESS' | 'GIZ_CONFIG_RECV_SUCCESS' | 'GIZ_CONFIG_SUCCESS';
-export interface ConfigEventData {
-    event: TConfigEvent;
-    deviceID?: string;
-}
+import { IRandomCodesResult, IRejectCallback, IResult, TimeoutHandle } from "../types";
+import { ConfigEventData, IDevice } from "../types";
 declare class ConfigBase {
     ssid: string;
     bssid: string;

package/dist/src/wifiConfig/ap.d.ts

@@ -1,15 +1,5 @@
-import { IRandomCodesResult, IResult } from "../sdk";
+import { IDevice, IRandomCodesResult, IResult, configDeviceParams, ISetDeviceOnboardingDeployProps } from "../types";
 import ConfigBase from "./ConfigBase";
-interface configDeviceParams {
-    ssid: string;
-    password: string;
-    softAPSSIDPrefix: string;
-}
-interface ISetDeviceOnboardingDeployProps {
-    timeout: number;
-    isBind: boolean;
-    softAPSSIDPrefix: string;
-}
 declare class ApConfig extends ConfigBase {
     disableSendUDP: boolean;
     private sendMessageInterval;

package/dist/src/wifiConfig/ble.d.ts

@@ -1,6 +1,6 @@
-import { IRandomCodesResult, IResult } from "../sdk";
 import { BleHandle } from "../handler/ble";
-import ConfigBase, { ConfigEventData } from "./ConfigBase";
+import ConfigBase from "./ConfigBase";
+import { IDevice, IError, ConfigEventData, IRandomCodesResult, IResult, configBLEDeviceParams } from "../types";
 type EnableAndGetBluetoothDevicesRes = Promise<{
     success: false;
     err: IError;
@@ -16,12 +16,6 @@ interface IArgs {
     bleHandle: BleHandle;
     eventCallBack: (event: ConfigEventData) => void;
 }
-interface configBLEDeviceParams {
-    ssid: string;
-    password: string;
-    softAPSSIDPrefix?: string;
-    timeout: number;
-}
 interface ISetDeviceOnboardingDeployProps {
     timeout: number;
     isBind: boolean;

package/dist/src/wifiConfig/nfc/index.d.ts

@@ -1,5 +1,5 @@
-import { IRandomCodesResult, IResult } from "../../sdk";
 import ConfigBase from "../ConfigBase";
+import { IDevice, IResult } from '../../types';
 interface configDeviceParams {
     ssid: string;
     password: string;
@@ -16,7 +16,7 @@ declare class NFCConfig extends ConfigBase {
     address: string;
     constructor(ssid: string, bssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[], address: string);
     destroy: () => void;
-    configDevice: ({ ssid, password, bssid, address }: configDeviceParams) => Promise<IResult<IRandomCodesResult[]>>;
+    configDevice: ({ ssid, password, bssid, address }: configDeviceParams) => Promise<IResult<import("../../types").IRandomCodesResult[]>>;
     setDeviceOnboardingDeploy: ({ timeout, isBind, }: ISetDeviceOnboardingDeployProps) => Promise<IResult<IDevice[]>>;
 }
 export default NFCConfig;

package/global.d.ts

@@ -6,23 +6,7 @@ declare namespace md5 {
 
 declare function md5(data: any): any;
 
-type TUtf8 = {
-  toBytes: (data: any) => any
-}
-
-type TUtils = {
-  utf8: TUtf8;
-}
-
-interface ecb {
-  new(data: any): any;
-}
-
-type TModeOfOperation = {
-  ecb: ecb;
-}
-
 declare namespace aesjs {
-  const utils: TUtils;
-  const ModeOfOperation: TModeOfOperation;
-}
+  const utils: any;
+  const ModeOfOperation: any;
+}

package/index.ts

@@ -4,4 +4,5 @@ import errorCode from './src/errorCode';
 import { BleHandle } from './src/handler/ble';
 
 export { errorCode, BleHandle };
-export default gizwitsSdk;
+export default gizwitsSdk;
+export * from './src/types';

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mini_program_gizwits_sdk",
-  "version": "3.6.1",
-  "description": "更新文档",
+  "version": "3.6.3",
+  "description": "更新类型",
   "main": "./dist/index.js",
   "scripts": {
     "test": "node_modules/mocha/bin/_mocha -r ts-node/register tests/**/*.spec.ts -file ./tests/setup-wx.js -timeout 60s",

package/src/errorCode.ts

@@ -1,6 +1,6 @@
-interface IErrorCode {
-  [key: string]: IError;
-}
+import { IError, IErrorCode } from "./types";
+
+
 const errorCode: IErrorCode = {
   GIZ_OPENAPI_DEVICE_NOT_BOUND: {
     errorCode: 9017,

package/src/handler/ble.ts

@@ -1,6 +1,6 @@
 import GizLog from '../GizLog';
 import Bind from '../protocol/Bind';
-import { padBoradcastData } from '../protocol/DataPoint';
+import { padBoradcastData } from '../protocol/dataPoint';
 import GetDeviceStatus from '../protocol/GetDeviceStatus';
 import Login from '../protocol/Login';
 import ProtocolBase from '../protocol/ProtocolBase';
@@ -22,7 +22,6 @@ import {
 } from '../utils';
 import { downloadFile, retryConnect, unpackWriteBLECharacteristicValue } from '../wechatApi';
 import EventListener from './EventListener';
-import { IOTAType, IResult } from '../sdk';
 import { checkUpdate } from '../services/ota';
 import errorCode from '../errorCode';
 import DeviceInfo from '../protocol/DeviceInfo';
@@ -32,82 +31,8 @@ import ResetPosition from '../protocol/OTA/ResetPosition';
 import OTAPackPackage from '../protocol/OTA/OTAPackPackage';
 import AwaitNoti from '../protocol/OTA/AwaitNoti';
 import OtaComplete from '../protocol/OTA/OtaComplete';
+import { BleConnectDevice, IDevice, IOTAType, IResult, TBleHandleEvent, BleConstructorParams, GizwitsWxBlueToothDevice, IStartScanResult, TBleDataListener, IDeviceReq, StartUpgradeParams, CheckOTAParams } from '../types';
 
-type GizBleDeviceListotifications = (devices: IDevice[]) => void;
-type GizBleDeviceDataNotifications = (
-  curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult,
-  hexString: string
-) => void;
-type GizBleErrorNotifications = (err: { errCode: number; errMsg: string }) => void;
-// 返回true 代表放弃监听
-type TBleDataListener<T> = (_curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult,
-  hexString: string) => T | null | undefined;
-
-interface CheckOTAParams {
-  device: IDevice;
-  type: IOTAType;
-}
-
-type OTAEventCode = 'GizOTAEventPretreatment' | 'GizOTAEventDownload' | 'GizOTAEventTransmit' | 'GizOTAEventReboot' | 'GizOTAEventFinish'
-interface OTAEvent {
-  code: OTAEventCode; //
-};
-interface OTAProgressEvent {
-  firmwareSize: number;
-  packageMaxLen: number;
-  currentNumber: number;
-  currentProgress: number; // 0 ~ 100
-}
-
-export type OTAProgressEventCallback = (event: OTAProgressEvent) => void;
-export type OTAEventCallback = (event: OTAEvent) => void;
-interface StartUpgradeParams extends CheckOTAParams {
-  onProgress: OTAProgressEventCallback
-  onEvent: OTAEventCallback
-  productKey: string
-}
-
-
-export interface TBleHandleEvent {
-  GizBleDeviceData: GizBleDeviceDataNotifications;
-  GizBleDeviceList: GizBleDeviceListotifications;
-  GizBleError: GizBleErrorNotifications;
-}
-
-export interface GizwitsWxBlueToothDevice extends WechatMiniprogram.BlueToothDevice {
-  communicationType: 'BLE_BROADCAST' | 'BLE';
-}
-
-interface BleHandleParams {
-  serviceUUIDSuffix: string;
-  characteristicUUIDSuffix: string;
-}
-
-export interface IStartScanResult {
-  scanList: IDevice[];
-  err?: ReturnType<typeof wrapErrorInfo>;
-}
-
-interface IDeviceReq<T> {
-  success: boolean;
-  data: T;
-}
-
-// export type BleHandle = ReturnType<typeof createBleHandle>;
-
-export type OnScanDevice = (scanList: IDevice[]) => void;
-interface ConnectDevice {
-  deviceId?: string;
-  serviceId?: string;
-  characteristicId?: string;
-  errMsg?: string;
-}
-
-interface ConstructorParams {
-  pks: string[];
-  bleHandleParams?: BleHandleParams;
-  offlineThreshold?: number;
-}
 
 function createUUID32() {
   let dt = new Date().getTime();
@@ -180,7 +105,7 @@ function reportConnectEvent(
 export class BleHandle extends EventListener<TBleHandleEvent> {
   private serviceUUIDSuffix: string;
   // private characteristicUUIDSuffix: string;
-  public connectedList: ConnectDevice[] = [];
+  public connectedList: BleConnectDevice[] = [];
   private connectingDevId: string | null = null;
   public pks: string[] = [];
   private listenDevOfflineTimer: any = null;
@@ -219,7 +144,7 @@ export class BleHandle extends EventListener<TBleHandleEvent> {
       characteristicUUIDSuffix: 'abf7',
     },
     offlineThreshold,
-  }: ConstructorParams) {
+  }: BleConstructorParams) {
     super();
     const { serviceUUIDSuffix } = bleHandleParams;
     this.serviceUUIDSuffix = serviceUUIDSuffix;