mini_program_gizwits_sdk 3.0.1 → 3.0.6

package/src/ble.ts

@@ -0,0 +1,566 @@
+import {
+  ab2hex,
+  BTDevice2GDevice,
+  numberArray2Uint8Array,
+  wrapErrorInfo,
+} from './utils';
+import { unpackWriteBLECharacteristicValue } from './wechatApi';
+import Bind from './protocol/Bind';
+import { hexStrint2byte } from './protocol/tool';
+import ProtocolBase from './protocol/ProtocolBase';
+import Login from './protocol/Login';
+import GetDeviceStatus from './protocol/GetDeviceStatus';
+import sleep from './sleep';
+import Sdk from './Sdk';
+
+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>;
+
+type OnScanDevice = (scanList: IDevice[]) => void;
+interface ConnectDevice {
+  deviceId?: string;
+  serviceId?: string;
+  characteristicId?: string;
+  errMsg?: string;
+}
+
+interface ConstructorParams {
+  pks: string[];
+  bleHandleParams?: BleHandleParams;
+  globalListenerMap: object;
+  gizSdk: Sdk;
+  offlineThreshold?: number;
+}
+
+export class BleHandle {
+  private serviceUUIDSuffix: string;
+  // private characteristicUUIDSuffix: string;
+  public connectedList: ConnectDevice[] = [];
+  private pks: string[] = [];
+
+  private tmpBleData = ''; // 接收分包数据用
+  private tmpDataNum = 0; // 剩余字节数
+
+  private listenerMap = {};
+  private globalListenerMap = {};
+  public scanList: IDevice[] = [];
+  private gizSdk: Sdk;
+  constructor({
+    pks = [],
+    bleHandleParams = {
+      serviceUUIDSuffix: 'abf0',
+      characteristicUUIDSuffix: 'abf7',
+    },
+    globalListenerMap,
+    gizSdk,
+    offlineThreshold,
+  }: ConstructorParams) {
+    const { serviceUUIDSuffix } = bleHandleParams;
+    this.serviceUUIDSuffix = serviceUUIDSuffix;
+    this.pks = pks;
+    this.globalListenerMap = globalListenerMap;
+    this.gizSdk = gizSdk;
+
+    this.listenDevOffline(offlineThreshold ?? 10000);
+  }
+
+  private listenDevOffline = (offlineThreshold: number) => {
+    // 定时检查设备列表，移除超时设备
+    const timer = setInterval(() => {
+      const now = new Date().getTime();
+      const newDeviceList = this.scanList.filter((d) => {
+        return now - d.ctime < offlineThreshold;
+      });
+      if (newDeviceList.length !== this.scanList.length) {
+        this.scanList = newDeviceList;
+        this.gizSdk.bleDevices = newDeviceList;
+      }
+    }, 500);
+  };
+
+  private openBluetoothAdapter = () => {
+    return new Promise((resolve, reject) => {
+      wx.openBluetoothAdapter({
+        success: () => {
+          console.log('openBluetoothAdapter success');
+          resolve({ success: true });
+          wx.onBLECharacteristicValueChange(
+            this.handleOnBLECharacteristicValueChange
+          );
+        },
+        fail: (err) => {
+          console.log('openBluetoothAdapter fail', err);
+          this.notifyError({ errMsg: err.errMsg, errCode: -1 });
+          reject(err);
+        },
+      });
+    });
+  };
+
+  private handleOnBLECharacteristicValueChange = (
+    curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult
+  ) => {
+    const hexString = ab2hex(curDevice.value);
+    try {
+      const data = new ProtocolBase(hexStrint2byte(hexString));
+      console.log('ProtocolBase', data.len, curDevice.value.byteLength,data);
+      // 能解析包头，覆盖数据
+      this.tmpBleData = hexString;
+      this.tmpDataNum =
+        data.len -
+        curDevice.value.byteLength +
+        4 +
+        Math.ceil(data.len.toString(2).length / 8);
+    } catch (error) {
+      // 无法解析包头
+      if (this.tmpBleData) {
+        // 有没有接收完的数据
+        this.tmpBleData += hexString;
+        this.tmpDataNum -= curDevice.value.byteLength;
+      }
+    }
+
+    if (this.tmpDataNum > 0 || !this.tmpBleData) {
+      // 没有接收完数据 或者没有有效数据
+      return;
+    }
+    console.log('ProtocolBase141', this.tmpBleData, this.tmpDataNum);
+
+    if (this.listenerMap[curDevice.deviceId]) {
+      this.listenerMap[curDevice.deviceId].map((item) => {
+        item(curDevice, this.tmpBleData);
+      });
+    }
+    if (this.listenerMap['ALL']) {
+      console.log('ProtocolBase1');
+      this.listenerMap['ALL'].map((item) => {
+        console.log('ProtocolBase2');
+        item(curDevice, this.tmpBleData);
+      });
+    }
+
+    this.tmpBleData = '';
+    this.tmpDataNum = 0;
+  };
+
+  private notifyError = (err: { errCode: number; errMsg: string }) => {
+    // TODO 具体是哪台设备的错误信息
+    this.globalListenerMap['onBleHandleError']?.map((notifyFn) => {
+      notifyFn(err);
+    });
+  };
+
+  private listenConnection = (deviceId: string) => {
+    wx.onBLEConnectionStateChange((res) => {
+      const isInConnectedList = this.connectedList
+        .map((d) => d.deviceId)
+        .includes(deviceId);
+
+      const shouldReConnect =
+        isInConnectedList &&
+        res.deviceId === deviceId &&
+        res.connected === false;
+      console.log('蓝牙状态变化', {
+        connectedList: this.connectedList,
+        res,
+        deviceId,
+      });
+
+      if (shouldReConnect) {
+        this.connectDevice(deviceId);
+      }
+    });
+  };
+
+  public checkPermission = async () => {
+    const settings = await wx.getSetting();
+    const hasBlePermission = settings.authSetting['scope.bluetooth'];
+
+    if (!hasBlePermission) {
+      try {
+        await wx.authorize({ scope: 'scope.bluetooth' });
+        await this.openBluetoothAdapter();
+        const res = await this.getBluetoothAdapterState();
+        return res;
+      } catch (err) {
+        console.log('授权失败', err);
+        // remove me in the future
+        this.openBluetoothAdapter();
+        this.notifyError({ errMsg: err.errMsg, errCode: -1 });
+      }
+    } else {
+      await this.openBluetoothAdapter();
+      const res = await this.getBluetoothAdapterState();
+      return res;
+    }
+  };
+
+  private getBluetoothAdapterState = async () => {
+    const { errMsg, available, ...adaptState } =
+      await wx.getBluetoothAdapterState();
+    return {
+      data: {
+        ...adaptState,
+      },
+      err: wrapErrorInfo(errMsg),
+      success: available,
+    };
+  };
+
+  getDeviceStatus = async (
+    deviceId: string,
+    productKey: string,
+    gwDid?: string,
+    attrNames?: string[]
+  ) => {
+    const value = await GetDeviceStatus.pack(productKey, gwDid, attrNames);
+    if (value) {
+      return await this.write(deviceId, numberArray2Uint8Array(value).buffer);
+    }
+    return {
+      success: false,
+    };
+  };
+
+  private handleBluetoothDeviceFound = (
+    resData: WechatMiniprogram.OnBluetoothDeviceFoundCallbackResult,
+    onScanDevice: OnScanDevice
+  ) => {
+    const list = resData.devices.filter((device) => {
+      const { advertisData, deviceId, name, localName } = device;
+      const advertisDataStr = ab2hex(advertisData);
+
+      const targetBleDev = this.scanList.find(
+        (d) => d.bleDeviceID === deviceId
+      );
+      if (targetBleDev) {
+        // 有这台设备，无需重复添加，更新时间戳
+        this.gizSdk.setDeviceMeta(targetBleDev, 'ctime', Date.now());
+        return false;
+      } else {
+        // 添加这台设备需要校验广播包
+        const isValidDevice = this.pks.some((pk) =>
+          advertisDataStr.includes(pk)
+        );
+        return isValidDevice;
+      }
+    });
+
+    if (list.length > 0) {
+      const gDevice = list.map((item) => BTDevice2GDevice(item, this.pks));
+      this.scanList.push(...gDevice);
+      onScanDevice(this.scanList);
+    }
+  };
+
+  public startScan = async (
+    onScanDevice: OnScanDevice,
+    delay: number = 5000
+  ) => {
+    return new Promise<IStartScanResult>(async (res) => {
+      wx.onBluetoothDeviceFound((resData) => {
+        this.handleBluetoothDeviceFound(resData, onScanDevice);
+      });
+
+      await wx.startBluetoothDevicesDiscovery({
+        powerLevel: 'high',
+        allowDuplicatesKey: true,
+      });
+
+      setTimeout(() => {
+        this.stopScan();
+        res({
+          scanList: this.scanList,
+        });
+      }, delay);
+    });
+  };
+
+  public stopScan = async () => {
+    const { errMsg, errCode } = await wx.stopBluetoothDevicesDiscovery();
+    return { errMsg, errCode };
+  };
+
+  public connectDevice = async (deviceId: string) => {
+    const connectRes = (await wx
+      .createBLEConnection({
+        deviceId,
+      })
+      .catch((err) => {
+        this.removeDevById(deviceId);
+        this.notifyError(err);
+      })) as any;
+
+    if (connectRes.errMsg === 'createBLEConnection:ok') {
+      this.listenConnection(deviceId);
+    } else {
+      return { success: false, message: connectRes?.errMsg };
+    }
+
+    const getServicesRes = (await wx
+      .getBLEDeviceServices({ deviceId })
+      .catch((err) => this.notifyError(err))) as any;
+
+    const serviceId = getServicesRes?.services.find(
+      (service) =>
+        service.isPrimary &&
+        service.uuid.toLowerCase().includes(this.serviceUUIDSuffix)
+    )?.uuid;
+    if (!serviceId)
+      return {
+        message: 'can not find valid serviceId',
+        success: false,
+      };
+
+    const getCharRes = (await wx
+      .getBLEDeviceCharacteristics({
+        deviceId,
+        serviceId,
+      })
+      .catch((err) => this.notifyError(err))) as any;
+
+    console.log({ getCharRes });
+
+    const characteristicId = getCharRes?.characteristics[0].uuid!;
+    const isNewDevice = this.connectedList.every(
+      (device) => device.deviceId !== deviceId
+    );
+    isNewDevice &&
+      this.connectedList.push({ deviceId, serviceId, characteristicId });
+
+    // 连接成功以后默认监听设备
+    const getNotifyRes = await wx
+      .notifyBLECharacteristicValueChange({
+        deviceId,
+        serviceId,
+        characteristicId,
+        state: true,
+        type: 'notification',
+      })
+      .catch((err) => this.notifyError(err));
+
+    this.write(deviceId, numberArray2Uint8Array(Bind.pack()).buffer);
+    const data = await this.handleBindReq(deviceId);
+    console.log('handleBindReq', data);
+
+    if (data.success) {
+      this.write(
+        deviceId,
+        numberArray2Uint8Array(Login.pack({ passcode: data.data })).buffer
+      );
+      const loginData = (await this.handleLoginReq(deviceId).catch((err) =>
+        this.notifyError(err)
+      )) as any;
+      console.log('loginData', loginData);
+      if (loginData?.success) {
+        return {
+          success: true,
+          message: 'ok',
+        };
+      }
+    }
+
+    return {
+      success: false,
+      message: 'ok',
+    };
+  };
+
+  private handleBindReq = (deviceId: string) => {
+    // 处理设备回复绑定消息
+    return new Promise<IDeviceReq<string>>((res) => {
+      console.log('handleBindReq');
+      const onListener = (
+        _curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult,
+        hexString: string
+      ) => {
+        //TODO 销毁监听
+        console.log('监听蓝牙特征值发生变化');
+        const bindData = new Bind(hexStrint2byte(hexString));
+        this.removeDeviceListener(deviceId, onListener);
+        if (bindData.passcode) {
+          // 存在passcode
+          res({
+            success: true,
+            data: bindData.passcode,
+          });
+        } else {
+          res({
+            success: false,
+            data: '',
+          });
+        }
+      };
+
+      this.addDeviceListener(deviceId, onListener);
+    });
+  };
+
+  private handleLoginReq = (deviceId) => {
+    return new Promise<IDeviceReq<String>>((res) => {
+      const onListener = (
+        _curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult,
+        hexString: string
+      ) => {
+        //TODO 销毁监听
+        console.log('设备回复LoginReq', hexString);
+
+        const loginData = new Login(hexStrint2byte(hexString));
+        this.removeDeviceListener(deviceId, onListener);
+        if (loginData.result === true) {
+          res({
+            success: true,
+            data: loginData.did,
+          });
+        } else {
+          res({
+            success: false,
+            data: '',
+          });
+        }
+      };
+      this.addDeviceListener(deviceId, onListener);
+    });
+  };
+
+  public removeDeviceListener = (
+    deviceId: string,
+    onDeviceStatusChange: any
+  ) => {
+    if (this.listenerMap[deviceId]) {
+      const index = this.listenerMap[deviceId].indexOf(onDeviceStatusChange);
+      if (index !== -1) {
+        // 删除数组中的这一行
+        this.listenerMap[deviceId].splice(index, 1);
+        return {
+          message: 'ok',
+          success: true,
+        };
+      }
+    }
+
+    return {
+      message: 'invalid function',
+      success: false,
+    };
+  };
+
+  public addDeviceListener = async (
+    deviceId,
+    onDeviceStatusChange: (
+      curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult,
+      hexString: string
+    ) => void
+  ) => {
+    // 可以挂载全局监听
+    if (deviceId === 'ALL') {
+      if (!this.listenerMap['ALL']) this.listenerMap['ALL'] = [];
+      this.listenerMap['ALL'].push(onDeviceStatusChange);
+    }
+
+    const { serviceId, characteristicId, errMsg } =
+      this.getTargetDevice(deviceId);
+    if (errMsg) return { success: false, message: errMsg };
+
+    if (!this.listenerMap[deviceId]) {
+      // 创建一个新的
+      this.listenerMap[deviceId] = [];
+    }
+
+    if (this.listenerMap[deviceId].indexOf(onDeviceStatusChange) === -1) {
+      this.listenerMap[deviceId].push(onDeviceStatusChange);
+    }
+
+    await wx
+      .notifyBLECharacteristicValueChange({
+        deviceId,
+        serviceId: serviceId!,
+        characteristicId: characteristicId!,
+        state: true,
+        type: 'notification',
+      })
+      .catch((err) => this.notifyError(err));
+
+    console.log(`监听设备 ${deviceId} 成功！`);
+
+    return {
+      message: 'ok',
+      success: true,
+    };
+  };
+
+  public write = async (deviceId: string, value: ArrayBuffer) => {
+    console.log('app => dev:', ab2hex(value));
+
+    const { serviceId, characteristicId } = this.getTargetDevice(deviceId);
+    if (serviceId && characteristicId) {
+      const unpackRes = await unpackWriteBLECharacteristicValue(
+        deviceId,
+        serviceId,
+        characteristicId,
+        value
+      );
+
+      return unpackRes;
+    }
+    return {
+      success: false,
+      message: 'serviceId or characteristicId is unvalid!',
+      errbody: { serviceId, characteristicId },
+    };
+  };
+
+  /**
+   * @description 断开设备连接
+   */
+  public disConnectDevice = async (deviceId: string) => {
+    this.removeDevById(deviceId);
+    const { errMsg } = await wx.closeBLEConnection({
+      deviceId,
+    });
+
+    if (errMsg === 'closeBLEConnection:ok') {
+      return {
+        err: errMsg,
+        success: true,
+      };
+    }
+    return {
+      err: errMsg,
+      success: false,
+    };
+  };
+
+  private removeDevById = (deviceId: string) => {
+    const targetIdx = this.connectedList.findIndex(
+      (connectedDev) => connectedDev.deviceId === deviceId
+    );
+    this.connectedList.splice(targetIdx, 1);
+  };
+
+  private getTargetDevice = (deviceId: string) => {
+    const targetDevice = this.connectedList.find(
+      (device) => deviceId === device.deviceId
+    );
+    if (!targetDevice)
+      return {
+        errMsg: 'Unable get this device,maybe you forgot to connect it.',
+      };
+
+    return targetDevice;
+  };
+}

package/src/errorCode.ts

@@ -0,0 +1,60 @@
+interface IErrorCode {
+  [key: string]: IError;
+}
+
+const errorCode: IErrorCode = {
+  GIZ_OPENAPI_DEVICE_NOT_BOUND: {
+    errorCode: 9017,
+    errorMessage: 'not bind'
+  },
+  GIZ_SDK_HTTP_REQUEST_FAILED: {
+    errorCode: 8099,
+    errorMessage: '网络请求失败'
+  },
+  GIZ_SDK_SDK_NOT_INITIALIZED: {
+    errorCode: 8300,
+    errorMessage: 'not init'
+  },
+  CONFIG_TIME_OUT: {
+    errorCode: 8023,
+    errorMessage: 'Config Timeout'
+  },
+  WECHAT_ERROR: {
+    errorCode: 10000,
+    errorMessage: 'wechat error'
+  },
+  GIZ_SDK_ONBOARDING_STOPPED: {
+    errorCode: 8318,
+    errorMessage: '配网中断'
+  },
+  GIZ_SDK_DEVICE_CONFIG_IS_RUNNING: {
+    errorCode: 8022,
+    errorMessage: '配置正在进行中'
+  },
+  GIZ_OPENAPI_TOKEN_INVALID: {
+    errorCode: 9004,
+    errorMessage: 'token 失效'
+  },
+  GIZ_SDK_BIND_DEVICE_FAILED: {
+    errorCode: 8039,
+    errorMessage: '设备绑定失败'
+  },
+  GIZ_SDK_BLE_BLUETOOTH_FUNCTION_NOT_TURNED_ON: {
+    errorCode: 8281,
+    errorMessage: "蓝牙未启用"
+  },
+  GIZ_SDK_OTHERWISE: {
+    errorCode: 8100,
+    errorMessage: ''
+  },
+  GIZ_SDK_DEVICE_NOT_SUBSCRIBED: {
+    errorCode: 8029,
+    errorMessage: '设备还未订阅'
+  },
+  GIZ_SDK_PRODUCTKEY_NOT_IN_SPECIFY: {
+    errorCode: 8250,
+    errorMessage: '产品类型不在指定范围内',
+  },
+};
+
+export default errorCode;

package/src/global.d.ts

@@ -0,0 +1,42 @@
+interface IError {
+  errorCode: number;
+  errorMessage?: string;
+}
+
+interface ICommonObj {
+  [key: string]: any
+}
+
+interface IDeviceStatusChangedProps {
+  did: string;
+  attrs: ICommonObj;
+}
+
+interface IDeviceRawStatusChangedProps {
+  did: string;
+  raw: Uint8Array;
+}
+
+interface IOnDeviceStatusChanged {
+  (data: IDeviceStatusChangedProps | IDeviceRawStatusChangedProps): void;
+}
+
+interface IDevice {
+  mac: string;
+  productKey: string;
+  did: string;
+  name: string;
+  isBind: boolean;
+  rootDeviceId?: string;
+  bleDeviceID?: string;
+  remark?: string;
+  connectType: TConnectType;
+  isOnline: boolean; // 代表大循环在线
+  isLanOnline: boolean; // 代表小循环在线
+  isBleOnline: boolean; // 代表蓝牙在线
+  host?: string;
+  wss_port?: number;
+  ctime?: number;
+}
+
+type TConnectType = 'BLE' | 'LAN' | 'WAN' | 'NONE';

package/src/globalData.ts

@@ -0,0 +1,9 @@
+const globalData: any = {};
+
+export function setGlobalData(key: any, value: any) {
+  globalData[key] = value;
+}
+
+export function getGlobalData(key: any) {
+  return globalData[key];
+}