mini_program_gizwits_sdk 3.0.2-beta → 3.0.7

package/src/utils.ts

@@ -0,0 +1,215 @@
+import { IProductInfo } from './sdk';
+
+export function ab2hex(buffer: ArrayBuffer) {
+  let hexArr = Array.prototype.map.call(new Uint8Array(buffer), function (bit) {
+    return ('00' + bit.toString(16)).slice(-2);
+  });
+  return hexArr.join('');
+}
+
+export function compareWXSDKVersion(v1: string, v2: string) {
+  const v1Arr = v1.split('.');
+  const v2Arr = v2.split('.');
+  const len = Math.max(v1.length, v2.length);
+
+  while (v1Arr.length < len) {
+    v1Arr.push('0');
+  }
+  while (v2Arr.length < len) {
+    v2Arr.push('0');
+  }
+
+  for (let i = 0; i < len; i++) {
+    const num1 = parseInt(v1[i]);
+    const num2 = parseInt(v2[i]);
+
+    if (num1 > num2) {
+      return 1;
+    } else if (num1 < num2) {
+      return -1;
+    }
+  }
+  return 0;
+}
+
+export const isError = (err: unknown): err is IError => {
+  return err != null && typeof (err as IError).errorCode === 'symbol';
+};
+
+export const wrapErrorInfo = (errorMessage: string) => ({
+  errorCode: errorMessage,
+  errorMessage,
+});
+
+export const unionBy = <T>(array: T[], key: string) => {
+  return array.reduce<T[]>((acc, item) => {
+    const keyValue = item[key];
+    if (!acc.some((i) => i[key] === keyValue)) {
+      acc.push(item);
+    }
+    return acc;
+  }, []);
+};
+
+interface IWXDevicesResult {
+  success: true;
+  bleDevices: WechatMiniprogram.BlueToothDevice[];
+}
+export function isWXDevicesResult(res: unknown): res is IWXDevicesResult {
+  return (
+    (res as IWXDevicesResult).success &&
+    Object.prototype.toString.call((res as IWXDevicesResult).bleDevices) ===
+      '[object Array]'
+  );
+}
+
+// hex转ArrayBuffer
+export function str2Buf(arr: string) {
+  var length = arr.length;
+  var buffer = new ArrayBuffer(length + 2);
+  var dataview = new DataView(buffer);
+  for (let i = 0; i < length; i++) {
+    dataview.setUint8(i, parseInt(arr[i], 16));
+  }
+  return buffer;
+}
+
+// 把协议导出的数据转换为可以发送给蓝牙的数据
+export const numberArray2Uint8Array = (numArr: number[]) => {
+  const buffer = new ArrayBuffer(numArr.length);
+  const uint8Array = new Uint8Array(buffer);
+  for (let i = 0; i < buffer.byteLength; i++) {
+    uint8Array[i] = numArr[i];
+  }
+  return uint8Array;
+};
+
+export const advertisData2PkAndMac = (
+  advertisData: ArrayBuffer,
+  pks: string[]
+) => {
+  let pkUintArray = advertisData.slice(advertisData.byteLength - 16);
+  let macUintArray = advertisData.slice(0, advertisData.byteLength - 16);
+  let productKey = ab2hex(pkUintArray);
+
+  if (pks.find((item) => item === productKey)) {
+    // 存在
+    const mac = ab2hex(macUintArray);
+    return { productKey, mac };
+  } else {
+    // 由于小程序安卓只接收ff type的广播数据，会乱序，所以这里需要做一次判断
+    pkUintArray = advertisData.slice(0, 16);
+    macUintArray = advertisData.slice(16);
+    productKey = ab2hex(pkUintArray);
+    const mac = ab2hex(macUintArray);
+    return { productKey, mac };
+  }
+};
+
+export const isSameDevice = (deviceA: IDevice, deviceB: IDevice) => {
+  return (
+    deviceA.mac === deviceB.mac && deviceA.productKey === deviceB.productKey
+  );
+};
+
+export const merageBleLocalDevices = (
+  mainDevice: IDevice[],
+  localDevice: IDevice[]
+) => {
+  localDevice.map((localD) => {
+    const target = mainDevice.find((device) => isSameDevice(device, localD));
+    if (!target) {
+      // 没有则插入这条本地设备
+      mainDevice.push(localD);
+    } else {
+      target.isBleOnline = true;
+      target.bleDeviceID = localD.bleDeviceID;
+    }
+  });
+  return mainDevice;
+};
+
+export const merageLanLocalDevices = (
+  mainDevice: IDevice[],
+  localDevice: IDevice[]
+) => {
+  localDevice.map((localD) => {
+    const target = mainDevice.find((device) => isSameDevice(device, localD));
+    if (!target) {
+      // 没有则插入这条本地设备
+      mainDevice.push(localD);
+    } else {
+      target.isLanOnline = true;
+    }
+  });
+  return mainDevice;
+};
+
+export const BTDevice2GDevice = (
+  BTDevice: WechatMiniprogram.BlueToothDevice,
+  pks: string[]
+) => {
+  const { productKey, mac } = advertisData2PkAndMac(BTDevice.advertisData, pks);
+  const device: IDevice = {
+    mac,
+    did: '',
+    connectType: 'NONE',
+    isBleOnline: true,
+    isLanOnline: false,
+    isOnline: false,
+    productKey,
+    name: BTDevice.name,
+    isBind: false,
+    bleDeviceID: BTDevice.deviceId,
+    ctime: new Date().getTime(),
+  };
+  return device;
+};
+
+// 如果都不存在 就去连接大循环
+export const getFirstConnectType = (
+  device: IDevice,
+  type?: TConnectType
+): TConnectType => {
+  if (!type) {
+    if (device.isLanOnline) return 'LAN';
+    if (device.isBleOnline) return 'BLE';
+    return 'WAN';
+  } else {
+    if (type === 'WAN') return 'WAN';
+
+    switch (type) {
+      case 'BLE': {
+        return device.isBleOnline ? 'BLE' : 'NONE';
+      }
+      case 'LAN': {
+        return device.isLanOnline ? 'LAN' : 'NONE';
+      }
+    }
+  }
+
+  return 'WAN';
+};
+
+export const getProductInfoThroughPK = (
+  pk: string,
+  productInfos: IProductInfo[]
+) => {
+  return productInfos.find((item) => item.productKey === pk);
+};
+
+export const mergeObject = (obj1: any, obj2: any) => {
+  for (let key in obj2) {
+    if (obj2[key] == null || obj2[key] === '') continue;
+    obj1[key] = obj2[key];
+  }
+  return obj1;
+};
+export function hex2ab(str) {
+  const res = [];
+  for (let i = 0; i < str.length; i += 2) {
+    var hex = str.slice(i, i + 2);
+    res.push(parseInt(hex, 16));
+  }
+  return new Uint8Array(res);
+}

package/src/wechatApi.ts

@@ -0,0 +1,179 @@
+import sleep from "./sleep";
+
+interface IBluetoothAdapterStateResult {
+  discovering: boolean;
+  available: boolean;
+}
+
+interface IWechatResult {
+  errMsg: string;
+  errCode: number;
+}
+
+export function openBluetoothAdapter() {
+  return new Promise<IWechatResult>((res, rej) => {
+    wx.openBluetoothAdapter({
+      success: res,
+      fail: rej,
+    })
+  })
+}
+
+export function closeBluetoothAdapter() {
+  return new Promise<IWechatResult>((res, rej) => {
+    wx.closeBluetoothAdapter({
+      success: res,
+      fail: rej,
+    })
+  })
+}
+
+export function getBluetoothAdapterState() {
+  return new Promise<IBluetoothAdapterStateResult>((res, rej) => {
+    wx.getBluetoothAdapterState({
+      success: res,
+      fail: rej,
+    })
+  })
+}
+
+export function startBluetoothDevicesDiscovery() {
+  return new Promise<IWechatResult>((res, rej) => {
+    wx.startBluetoothDevicesDiscovery({
+      success: res,
+      fail: rej,
+      interval: 100
+    })
+  })
+}
+
+export function getBluetoothDevices() {
+  return new Promise<WechatMiniprogram.BlueToothDevice[]>((res, rej) => {
+    wx.getBluetoothDevices({
+      success: (({ devices }) => res(devices)),
+      fail: rej,
+    })
+  })
+}
+
+export function createBLEConnection(deviceId: string, timeout: number) {
+  return new Promise<IWechatResult>((res, rej) => {
+    wx.createBLEConnection({
+      deviceId,
+      timeout,
+      success: (r => res(r as IWechatResult)),
+      fail: ((err) => {
+        if (err.errCode === -1) {
+          res(err);
+        } else {
+          rej(err);
+        }
+      }),
+    })
+  })
+}
+
+interface IBLEService {
+  uuid: string;
+  isPrimary: boolean;
+}
+
+export function getBLEDeviceServices(deviceId: string) {
+  return new Promise<IBLEService[]>((res, rej) => {
+    wx.getBLEDeviceServices({
+      deviceId,
+      success: (({ services }) => res(services)),
+      fail: rej,
+    })
+  })
+}
+
+interface IBLECharacteristic {
+  uuid: string;
+  properties: {
+    read: boolean;
+    write: boolean;
+    notify: boolean;
+    indicate: boolean;
+  }
+}
+
+export function getBLEDeviceCharacteristics(deviceId: string, serviceId: string) {
+  return new Promise<IBLECharacteristic[]>((res, rej) => {
+    wx.getBLEDeviceCharacteristics({
+      deviceId,
+      serviceId,
+      success: (({ characteristics }) => res(characteristics)),
+      fail: rej,
+    })
+  })
+}
+
+export function notifyBLECharacteristicValueChange(
+  deviceId: string,
+  serviceId: string,
+  characteristicId: string,
+  state: boolean = true
+) {
+  return new Promise<IWechatResult>((res, rej) => {
+    wx.notifyBLECharacteristicValueChange({
+      deviceId,
+      serviceId,
+      characteristicId,
+      state,
+      success: res,
+      fail: rej,
+    })
+  })
+}
+
+export function writeBLECharacteristicValue(
+  deviceId: string,
+  serviceId: string,
+  characteristicId: string,
+  value: ArrayBuffer,
+) {
+  return new Promise<IWechatResult>((res) => {
+    console.log('writeBLECharacteristicValue')
+    wx.writeBLECharacteristicValue({
+      deviceId,
+      serviceId,
+      characteristicId,
+      value,
+      complete: res,
+    })
+  })
+}
+
+export function unpackWriteBLECharacteristicValue(
+  deviceId: string,
+  serviceId: string,
+  characteristicId: string,
+  value: ArrayBuffer,
+) {
+  if (value.byteLength === 0) {
+    throw new Error('value is not empty');
+  }
+  return new Promise<IWechatResult>(async (res, rej) => {
+    let pos = 0;
+    let bytes = value.byteLength;
+    let writeRes;
+    while (bytes > 0) {
+      await sleep(30);
+      const tmpBuffer = value.slice(pos, pos + 20);
+      pos += 20;
+      bytes -= 20;
+      writeRes = await writeBLECharacteristicValue(
+        deviceId,
+        serviceId,
+        characteristicId,
+        tmpBuffer,
+      );
+      console.log('unpackWriteBLECharacteristicValue', pos / 20, writeRes);
+      if (writeRes.errCode !== 0) {
+        break;
+      }
+    }
+    writeRes.errCode !== 0 ? rej(writeRes) : res(writeRes);
+  })
+}

package/src/wifiConfig/ConfigBase.ts

@@ -0,0 +1,183 @@
+import { IRandomCodesResult, IResult, TimeoutHandle } from "../sdk";
+import sleep from "../sleep";
+import errorCode from "../errorCode";
+import { bindMac, checkDeviceRegister } from '../services/devices';
+
+interface IRejectCallback {
+  (result: IResult<unknown>): void;
+}
+class ConfigBase {
+  ssid = '';
+  password = '';
+  specialProductKeys: string[] = [];
+  disableSearchDevice = false;
+  specialProductKeySecrets: string[] = []
+  private timeoutHandler: TimeoutHandle = null;
+  private setDeviceOnboardingDeployRej?: (value: unknown) => void = () => {}; // 保存promise的rej，用于临时中断
+  // private setDeviceOnboardingDeployRes?: (value: unknown) => void = () => {}; // 保存promise的res，用于临时中断
+
+  constructor(ssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[]) {
+    this.ssid = ssid;
+    this.password = password;
+    this.specialProductKeys = specialProductKeys;
+    this.specialProductKeySecrets = specialProductKeySecrets;
+  }
+
+  public cleanTimeout = () => {
+    this.disableSearchDevice = true;
+    this.timeoutHandler && clearTimeout(this.timeoutHandler);
+    this.timeoutHandler = null;
+    console.log("this.timeoutHandler", this.timeoutHandler)
+  }
+
+  stopDeviceOnboardingDeploy = (): void => {
+    if (this.setDeviceOnboardingDeployRej) {
+      this.setDeviceOnboardingDeployRej({
+        success: false,
+        err: errorCode.GIZ_SDK_ONBOARDING_STOPPED,
+      });
+    }
+    this.cleanTimeout();
+  };
+
+  hasTimeoutHandler = (cb?: IRejectCallback) => {
+    if (this.timeoutHandler) {
+      // 方法还在执行中
+      cb &&
+        cb({
+          success: false,
+          err: errorCode.GIZ_SDK_DEVICE_CONFIG_IS_RUNNING,
+        });
+      return true;
+    }
+    return false;
+  };
+
+  handleTimeout = () => {
+    if (this.setDeviceOnboardingDeployRej) {
+      this.setDeviceOnboardingDeployRej({
+        success: false,
+        err: {
+          errorCode: errorCode.CONFIG_TIME_OUT,
+          errorMessage: 'time out',
+        },
+      });
+    }
+    this.timeoutHandler = null;
+  }
+
+  /**
+   * 大循环确认
+   */
+  protected searchDevice = ({ ssid, password }: { ssid: string; password: string }) => {
+    return new Promise<IResult<IRandomCodesResult[]>>((res, rej) => {
+      console.debug('GIZ_SDK: 开始大循环搜索设备')
+      const query = async () => {
+
+        if (!this.hasTimeoutHandler()) {
+          return;
+        }
+
+        try {
+          const data = await checkDeviceRegister({
+            SSID: ssid,
+            password,
+            productKeys: this.specialProductKeys,
+          })
+
+          // console.debug('GIZ_SDK: try get device random codes', data);
+          if (data.err?.errorCode === errorCode.GIZ_OPENAPI_TOKEN_INVALID.errorCode) {
+            // token 失效
+            rej({
+              success: false,
+              err: errorCode.GIZ_OPENAPI_TOKEN_INVALID,
+            });
+            return;
+          }
+
+          if (data.err || (data.data as IRandomCodesResult[]).length === 0) {
+            // 重新请求
+            console.debug('GIZ_SDK: 大循环没有发现设备');
+            await sleep(1500);
+            !this.disableSearchDevice && query();
+          } else {
+            // 搜索到设备
+            console.debug('GIZ_SDK: 大循环搜索到设备', data);
+            res({
+              success: true,
+              data: data.data,
+            });
+          }
+        } catch (error) {
+          // 重新请求
+          await sleep(3000);
+          !this.disableSearchDevice && query();
+          // console.debug('GIZ_SDK: random codes error', error);
+        }
+      };
+      query();
+    });
+  };
+
+  initDeviceOnboardingDeploy = (_res, rej) => {
+    // this.setDeviceOnboardingDeployRes = res;
+    this.setDeviceOnboardingDeployRej = rej;
+    this.disableSearchDevice = false;
+  };
+
+  protected startTimeoutTimer = (timeout: number) => {
+    /**
+     * 设置超时时间
+     */
+    this.timeoutHandler = setTimeout(this.handleTimeout, timeout * 1000);
+  };
+
+  /**
+   * 绑定多个设备
+   */
+   protected bindDevices = (devices: IDevice[]) => {
+    console.log('GIZ_SDK: start bind device');
+    return new Promise<IResult<IDevice[]>>(async (res, rej) => {
+      const promises = devices.map((item) => {
+        const index = this.specialProductKeys.findIndex(
+          (pk) => item.productKey === pk
+        );
+        if (index === -1) return;
+        const ps = this.specialProductKeySecrets[index];
+
+        return bindMac({
+          mac: item.mac,
+          productKey: item.productKey,
+          productSecret: ps,
+        })
+      });
+
+      try {
+        const data = await Promise.all(promises);
+        const successDevices = devices.filter((_, index) => {
+          const item = data[index];
+          return item && item.success;
+        });
+        if (successDevices.length > 0) {
+          console.log('GIZ_SDK: bind device success', successDevices);
+          // 绑定成功，重新初始化socket
+          res({
+            success: true,
+            data: successDevices,
+          });
+        } else {
+          console.log('GIZ_SDK: bind device error', data);
+          rej({
+            success: false,
+            data: devices,
+            err: errorCode.GIZ_SDK_BIND_DEVICE_FAILED,
+          });
+        }
+      } catch (error) {
+        rej(error);
+      }
+    });
+  };
+}
+
+export default ConfigBase;