mini_program_gizwits_sdk 3.3.2 → 3.3.25-kuka

package/src/services/devices.ts

@@ -1,10 +1,10 @@
-import {  enc, AES, mode, pad } from 'crypto-js';
 import openApiRequest, { IServiceResult } from '../openApiRequest';
 import getRandomCodes from '../randomCode';
 import { IRandomCodesResult } from '../sdk';
 import { psKeySign } from './tool';
 // eslint-disable-next-line import/no-commonjs
 // const CryptoJS = require('crypto-js');
+import {  enc, AES, mode, pad } from 'crypto-js';
 
 export interface IOpenApiDevice {
   product_key: string;
@@ -26,59 +26,6 @@ interface IDeviceRes {
   devices: IOpenApiDevice[];
 }
 
-// 云端aes 特殊解码
-class Padding {
-  /**
-   * Pads data using the algorithm defined in PKCS #5/7.
-   *
-   * @param data The data to pad.
-   * @param blockSize The multiple that the data should be padded to.
-   *
-   * @example
-   *
-   *     CryptoJS.pad.Pkcs7.pad(wordArray, 4);
-   */
-  pad = (data, blockSize) => {
-  }
-  
-
-  /**
-   * Unpads data that had been padded using the algorithm defined in PKCS #5/7.
-   *
-   * @param data The data to unpad.
-   *
-   * @example
-   *
-   *     CryptoJS.pad.Pkcs7.unpad(wordArray);
-   */
-  unpad = (data) => {
-    const AES_BLOCK_LEN = 16;
-    const len = data.sigBytes;
-    let readed = 0;
-    let repeat = 1;
-    const stringData=  data.toString(enc.Utf8);
-    while(readed + AES_BLOCK_LEN <= len)
-    {
-        readed += AES_BLOCK_LEN;
-    }
-    for(let i = 0; i < (AES_BLOCK_LEN - 2) / 2; i++)
-    { 
-        const start = readed  - i * 2;
-        if(stringData.substring(start, start - 2) == stringData.substring(start - 2, start - 4))
-        {
-            repeat++;
-        }
-        else
-        {
-            readed -= repeat * 2;
-
-            break;
-        }
-    }
-    data.sigBytes = readed;
-  }
-}
-
 export const getBindingList = async (): Promise<IServiceResult<IDevice[]>> => {
   const data = await openApiRequest<IDeviceRes>(
     '/app/bindings?show_disabled=0&limit=1000&skip=0',
@@ -248,23 +195,12 @@ export async function safeRegister({
     false
   );
   if (data.success) {
-    const successDevices = unPackSafeRegisterRes({productSecret, iv, data: data.data});
-    const failedDevices = [];
-
-    const targetDevice = successDevices.find(item => item.mac === mac);
-    if (!targetDevice) {
-      // 不存在
-      failedDevices.push({
-        mac,
-      })
-    }
-    
-    // TODO 解码
+    // 解码
     return {
       success: true,
       data: {
-        successDevices,
-        failedDevices,
+        successDevices: [],
+        failedDevices: [],
       },
     };
   }
@@ -274,30 +210,6 @@ export async function safeRegister({
   };
 }
 
-const unPackSafeRegisterRes = ({productSecret, data, iv}: {productSecret: string, data: string, iv: any}) => {
-  const aesKey = enc.Hex.parse(productSecret)
-  const bodyHex = enc.Hex.parse(data)
-  let resEncrypted = AES.decrypt(enc.Base64.stringify(bodyHex), aesKey, { iv: iv, mode: mode.ECB, padding: new Padding() });
-  const resString = resEncrypted.toString(enc.Utf8);
-  const newData = [];
-  resString.split(',').map(item => {
-    const tmp = item.split('&');
-    const mac = tmp[0].replace('mac=', '');
-    const did = tmp[1].replace('did=', '');
-    newData.push({
-      mac, did
-    })
-  })
-  return newData;
-}
-
-// const unPackSafeRegister = unPackSafeRegisterRes({
-//   productSecret: 'aaa0840301e04748adaf9fcd160e7508',
-//   iv: enc.Hex.parse(''),
-//   data: '56ab36690dcb1e42bc3e69dab30c2e670c2188dfb76cb5a2f12986d18eb069f0f63d3c89ab069f3573ef81ca02936ad4'
-// })
-// console.log('unPackSafeRegisterunPackSafeRegister', unPackSafeRegister)
-
 interface IRenameProps {
   name?: string;
   did: string;

package/src/wifiConfig/ble.ts

@@ -31,8 +31,8 @@ const configAck = '0000000303000002';
 export function sendBLEConfigCmd({
   bleDeviceId,
   arrayBuffer,
-  serviceUUIDSuffix = 'abf0',
-  characteristicUUIDSuffix = 'abf7',
+  serviceUUIDSuffix = 'fe60',
+  characteristicUUIDSuffix = 'fe61',
   bleHandle
 }: IArgs) {
   let sendInterval = null;

package/src/wifiConfig/ble_ailCloud.ts

@@ -0,0 +1,562 @@
+import errorCode from "../errorCode";
+import { IResult } from "../sdk";
+import { ab2hex, advertisData2PkAndMac, isWXDevicesResult } from '../utils';
+
+import {
+  getBluetoothAdapterState,
+  startBluetoothDevicesDiscovery,
+  getBluetoothDevices,
+  notifyBLECharacteristicValueChange,
+  unpackWriteBLECharacteristicValue,
+  getBLEDeviceServices,
+  getBLEDeviceCharacteristics,
+  retryConnect,
+} from '../wechatApi';
+import sleep from "../sleep";
+import ConfigBase from "./ConfigBase";
+import WifiConfig from "../protocol/WifiConfig";
+import GizLog from "../GizLog";
+import { BleHandle } from "../handler/ble";
+import aepApiRequest from "../aepApi/aepApiRequest";
+
+const productKeyMap = {
+  'a57a49b9b265421ca337219cd66a6701': 'icgsfwJZDFX'
+};
+
+interface IVerifyOnlineResult {
+  data: {
+    mac: string;
+    onlineStatus: number;
+    lastOnlineTime: string;
+  }
+}
+
+interface IConfigResult {
+  mac: string;
+  productKey: string;
+}
+
+interface IArgs {
+  bleDeviceId: string;
+  arrayBuffer: ArrayBuffer;
+  serviceUUIDSuffix?: string;
+  characteristicUUIDSuffix?: string;
+  bleHandle: BleHandle;
+}
+
+const configAck = '0000000303000002';
+
+export function sendBLEConfigCmd({
+  bleDeviceId,
+  arrayBuffer,
+  serviceUUIDSuffix = 'fe60',
+  characteristicUUIDSuffix = 'fe61',
+  bleHandle
+}: IArgs) {
+  let sendInterval = null;
+  let closeTimeout = null;
+
+  const checkInterrupt = () => {
+    if (closeTimeout === null) {
+      sendInterval && clearInterval(sendInterval);
+      return true;
+    }
+    return false;
+  }
+
+  return new Promise<boolean>(async (resolve, reject) => {
+    try {
+      GizLog.debug(
+        'GIZ_SDK: ssid info: ', arrayBuffer
+      );
+      // 设置超时
+      closeTimeout = setTimeout(() => {
+        sendInterval && clearInterval(sendInterval);
+        // 发送超时 返回失败
+        closeTimeout = null;
+        resolve(false);
+      }, 5 * 1000)
+      GizLog.debug(
+        'GIZ_SDK: createBLEConnection start: ', bleDeviceId
+      );
+      await bleHandle.disableScan()
+
+      const connectData = await retryConnect(bleDeviceId, 10 * 1000);
+      bleHandle.enableScan();
+
+      GizLog.debug(
+        'GIZ_SDK: createBLEConnection end, res:', connectData
+      );
+      GizLog.debug(
+        'GIZ_SDK: getBLEDeviceServices start, res:', serviceUUIDSuffix,
+      );
+      const services = await getBLEDeviceServices(bleDeviceId);
+      GizLog.debug(
+        'GIZ_SDK: getBLEDeviceServices end, res:', services,
+
+      );
+      const service = services.find((s) =>
+        s.uuid.split('-')[0].toLowerCase().endsWith(serviceUUIDSuffix)
+      );
+      if (!service) {
+        // 获取蓝牙设备服务异常
+        GizLog.debug(
+          'GIZ_SDK: get ble device services fail',
+          bleDeviceId,
+          services
+        );
+        resolve(false);
+        return;
+      }
+
+      const characteristics = await getBLEDeviceCharacteristics(
+        bleDeviceId,
+        service.uuid
+      );
+      GizLog.debug(
+        'GIZ_SDK: getBLEDeviceCharacteristics end, res:', characteristics
+      );
+      const characteristic = characteristics.find((c) =>
+        c.uuid.split('-')[0].toLowerCase().endsWith(characteristicUUIDSuffix)
+      );
+      if (!characteristic) {
+        // 获取蓝牙设备特征值异常
+        GizLog.debug(
+          'GIZ_SDK: get ble device characteristics fail',
+          bleDeviceId,
+          characteristics
+        );
+        resolve(false);
+        return;
+      }
+
+      if (
+        !characteristic.properties.notify &&
+        !characteristic.properties.indicate
+      ) {
+        GizLog.debug(
+          'GIZ_SDK: the ble device characteristic not support notify or indicate',
+          bleDeviceId,
+          characteristic
+        );
+        // 该设备不支持 notify & indicate 操作
+        resolve(false);
+        return;
+      }
+
+      GizLog.debug(
+        'GIZ_SDK: check characteristic and  service success',
+      );
+
+      await notifyBLECharacteristicValueChange(
+        bleDeviceId,
+        service.uuid,
+        characteristic.uuid
+      );
+
+      // 这里有个问题，模组好像不一定每次都会回
+      const handleBLECharacteristicValueChange = (res: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult) => {
+        const hexString = ab2hex(res.value);
+        GizLog.debug('GIZ_SDK: 收到设备返回ack', hexString)
+        if (hexString === configAck) {
+          // 发送成功
+          bleHandle.removeEventListener("GizBleDeviceData", handleBLECharacteristicValueChange)
+          resolve(true);
+        }
+      };
+
+      bleHandle.addEventListener("GizBleDeviceData", handleBLECharacteristicValueChange)
+
+      // 订阅特征值变化
+      // wx.onBLECharacteristicValueChange(handleBLECharacteristicValueChange);
+
+      GizLog.debug(
+        'GIZ_SDK: on notifyBLECharacteristicValueChange success',
+      );
+
+      if (checkInterrupt()) return;
+
+      await unpackWriteBLECharacteristicValue(
+        bleDeviceId,
+        service.uuid,
+        characteristic.uuid,
+        arrayBuffer
+      );
+      sendInterval = setInterval(() => {
+        if (checkInterrupt()) return;
+        unpackWriteBLECharacteristicValue(
+          bleDeviceId,
+          service.uuid,
+          characteristic.uuid,
+          arrayBuffer
+        );
+      }, 2000)
+
+      // if (res.errCode === 0) {
+      //   resolve(true);
+      // } else{
+      //   resolve(false);
+      // }
+      GizLog.debug('GIZ_SDK: unpackWriteBLECharacteristicValue end');
+    } catch (error) {
+      reject(false);
+      GizLog.debug('GIZ_SDK: sendBLEConfigCmd error', error);
+    }
+  })
+    .catch((error) => {
+      GizLog.debug('GIZ_SDK: sendBLEConfigCmd error', error);
+    })
+    .finally(() => {
+      // 关闭连接
+      closeTimeout && clearTimeout(closeTimeout);
+      sendInterval && clearInterval(sendInterval);
+      wx.closeBLEConnection({ deviceId: bleDeviceId });
+    });
+}
+
+interface configBLEDeviceParams {
+  ssid: string;
+  password: string;
+  softAPSSIDPrefix?: string;
+  timeout: number;
+}
+
+
+interface ISetDeviceOnboardingDeployProps {
+  timeout: number;
+  isBind: boolean;
+  softAPSSIDPrefix: string;
+}
+
+interface IOnlieTimeMap {
+  [key: string]: string
+}
+
+
+
+// 阿里云 蓝牙配网
+class BLEAliCloudConfig extends ConfigBase {
+  bleHandle: BleHandle;
+  lastestOnlineTimeMap: IOnlieTimeMap = {};
+
+  constructor(ssid: string, password: string, specialProductKeys: string[], specialProductKeySecrets: string[], bleHandle: BleHandle) {
+    super(ssid, password, specialProductKeys, specialProductKeySecrets)
+    this.bleHandle = bleHandle;
+  }
+  destroy = () => {
+    this.cleanTimeout();
+  }
+  isValidBleDevice = (
+    bleDevice: WechatMiniprogram.BlueToothDevice,
+    softAPSSIDPrefix?: string
+  ) => {
+    if (!bleDevice || !bleDevice.advertisData) {
+      // 无效蓝牙设备或者蓝牙设备广播数据为空，返回失败
+      return false;
+    }
+
+    const { productKey, mac } = advertisData2PkAndMac(bleDevice.advertisData, this.specialProductKeys)
+
+
+    if (!this.specialProductKeys.includes(productKey)) {
+      // 不在PK列表
+      return false;
+    }
+    GizLog.debug(`GIZ_SDK: isValidBleDevice mac: ${mac} pk: ${productKey} name: ${bleDevice.name}`)
+    GizLog.debug(`GIZ_SDK: softAPSSIDPrefix: ${softAPSSIDPrefix} ismatch : ${bleDevice.name && bleDevice.name.startsWith(softAPSSIDPrefix)}`)
+    return (
+      !softAPSSIDPrefix ||
+      (bleDevice.name && bleDevice.name.startsWith(softAPSSIDPrefix))
+    );
+  };
+
+
+  enableBluetoothDevicesDescovery = async (): Promise<
+    { success: false; err: IError } | { success: true }
+  > => {
+    // try {
+    //   await closeBluetoothAdapter();
+    //   await openBluetoothAdapter();
+    // } catch (error) {
+
+    // }
+    const stateRes = await getBluetoothAdapterState();
+    if (!stateRes.available) {
+      return {
+        success: false,
+        err: {
+          errorCode: errorCode.GIZ_SDK_BLE_BLUETOOTH_FUNCTION_NOT_TURNED_ON.errorCode,
+          errorMessage: '蓝牙状态不可用',
+        },
+      };
+    }
+
+    await startBluetoothDevicesDiscovery();
+    return { success: true };
+  };
+
+
+  enableAndGetBluetoothDevices = async (
+    softAPSSIDPrefix?: string
+  ): Promise<
+    | { success: false; err: IError }
+    | { success: true; bleDevices?: WechatMiniprogram.BlueToothDevice[] }
+  > => {
+    const discoveryRes = await this.enableBluetoothDevicesDescovery();
+    if (!discoveryRes.success) {
+      return discoveryRes;
+    }
+    GizLog.debug('GIZ_SDK: start enableAndGetBluetoothDevices');
+
+    const bleDevices: WechatMiniprogram.BlueToothDevice[] = (
+      await getBluetoothDevices()
+    ).filter((d) => this.isValidBleDevice(d, softAPSSIDPrefix));
+    GizLog.debug('GIZ_SDK: getBluetoothDevices success', bleDevices);
+    return {
+      success: true,
+      bleDevices,
+    };
+  };
+
+  setDeviceOnboardingDeploy = ({
+    timeout,
+    isBind = true,
+    softAPSSIDPrefix,
+  }: ISetDeviceOnboardingDeployProps) => {
+    return new Promise<IResult<IDevice[]>>(async (res, rej) => {
+      const ssid = this.ssid;
+      const password = this.password;
+      this.destroy();
+      this.initDeviceOnboardingDeploy(res, rej);
+      this.startTimeoutTimer(timeout);
+
+      try {
+        const result = await this.configBLEDevice({
+          ssid,
+          password,
+          timeout: timeout * 1000,
+          softAPSSIDPrefix,
+        });
+
+        const newData: IDevice[] = [result.data as IDevice];
+        // const newData: IDevice[] = (result.data || []).map(item => {
+        //   return {
+        //     mac: item.mac,
+        //     productKey: item.product_key,
+        //     did: item.did,
+        //     name: '',
+        //     isBind: false,
+        //     connectType: 'NONE',
+        //     isBleOnline: false,
+        //     isLanOnline: false,
+        //     isOnline: false,
+        //   }
+        // })
+        if (isBind) {
+          res(await this.bindDevices(newData));
+        } else {
+          // 不需要绑定 直接返回成功
+          res({
+            success: true,
+            data: newData,
+          });
+        }
+      } catch (error) {
+        res({
+          success: false,
+          data: error
+        });
+      } finally {
+        this.destroy();
+      }
+    });
+  }
+
+  getDeviceLastestOnlineTime = async ({ productKey, mac }:
+    { productKey: string, mac: string }) => {
+    // lastOnlineTime
+    let realKey = productKeyMap[productKey];
+    if (!realKey) {
+      realKey = productKey;
+    }
+    GizLog.debug('GIZ_SDK: getDeviceLastestOnlineTime', realKey, mac);
+    const res = await aepApiRequest<IVerifyOnlineResult>(`app/device/deviceInfo/${realKey}/${(mac ?? '').toLocaleLowerCase()}`, { method: 'post' });
+    GizLog.debug('GIZ_SDK: 请求结果', res);
+    return res;
+  }
+
+  // 配网后确认设备是否上线
+  verifyDeviceOnline = ({ productKey, mac }: { productKey: string, mac: string }) => {
+    return new Promise<IResult<IVerifyOnlineResult>>((res, rej) => {
+      GizLog.debug('GIZ_SDK: 开始确认设备上线')
+      const query = async () => {
+
+        if (!this.hasTimeoutHandler()) {
+          return;
+        }
+
+        try {
+          const data = await this.getDeviceLastestOnlineTime({
+            productKey, mac
+          })
+          // if (data.err?.errorCode === errorCode.GIZ_OPENAPI_TOKEN_INVALID.errorCode) {
+          //   // token 失效
+          //   rej({
+          //     success: false,
+          //     err: errorCode.GIZ_OPENAPI_TOKEN_INVALID,
+          //   });
+          //   return;
+          // }
+          GizLog.debug('GIZ_SDK: 确认到设备是否在线', data.data.data.onlineStatus);
+          if (data.success && data.data && data.data.data && data.data.data.onlineStatus == 1) {
+            // 确认设备最后一次上线时间有更新
+            GizLog.debug('GIZ_SDK: 确认到设备是在线的', data);
+            res({
+              success: true,
+              data: data.data,
+            });
+          } else {
+            // 重新请求
+            GizLog.debug('GIZ_SDK: 未确认到设备是在线');
+            await sleep(1500);
+            !this.disableSearchDevice && query();
+          }
+
+          // if (data.err || data.data) {
+          //   // 重新请求
+          //   GizLog.debug('GIZ_SDK: 未确认到设备上线时间');
+          //   await sleep(1500);
+          //   !this.disableSearchDevice && query();
+          // } else {
+          //   // 搜索到设备
+          //   GizLog.debug('GIZ_SDK: 大循环搜索到设备', data);
+          //   res({
+          //     success: true,
+          //     data: data.data,
+          //   });
+          // }
+        } catch (error) {
+          // 重新请求
+          await sleep(3000);
+          !this.disableSearchDevice && query();
+          // GizLog.debug('GIZ_SDK: random codes error', error);
+        }
+      };
+      query();
+    });
+  };
+
+  /**
+   * 负责发蓝牙设备指令
+   */
+  configBLEDevice = ({
+    ssid,
+    password,
+    softAPSSIDPrefix,
+  }: configBLEDeviceParams) => {
+    return new Promise<IResult<IConfigResult>>(async (res, rej) => {
+      GizLog.debug('GIZ_SDK: start config ble device');
+      const enableAndGetRes = await this.enableAndGetBluetoothDevices(
+        softAPSSIDPrefix
+      ).catch((error) => {
+        return {
+          success: false,
+          err: {
+            errorCode: errorCode.WECHAT_ERROR.errorCode,
+            errorMessage: JSON.stringify(error),
+          },
+        };
+      });
+
+      if (!isWXDevicesResult(enableAndGetRes)) {
+        // 开启获取蓝牙失败
+        return rej(enableAndGetRes);
+      }
+
+      const { bleDevices } = enableAndGetRes;
+
+      GizLog.debug('GIZ_SDK: enableAndGetBluetoothDevices success, target devices: ', bleDevices);
+
+      const handleFoundDevices = async ({
+        devices,
+      }: {
+        devices: WechatMiniprogram.BlueToothDevice[];
+      }) => {
+        this.hasTimeoutHandler()
+          ? Array.prototype.push.apply(
+            bleDevices,
+            devices.filter((d) => this.isValidBleDevice(d, softAPSSIDPrefix))
+          )
+          : wx.offBluetoothDeviceFound(handleFoundDevices);
+      };
+
+      wx.onBluetoothDeviceFound(handleFoundDevices);
+
+      const uint8Array = WifiConfig.pack(ssid, password);
+
+      const bleDevice = bleDevices.shift();
+
+      const startConfigDevice = async (bleDevice) => {
+        GizLog.debug('GIZ_SDK: startConfigDevice');
+        if (!this.hasTimeoutHandler()) {
+          return;
+        }
+
+        if (bleDevice) {
+          GizLog.debug('GIZ_SDK: startConfigDevice, target device: ', bleDevice);
+        }
+
+        const success =
+          bleDevice &&
+          (await sendBLEConfigCmd({
+            bleDeviceId: bleDevice.deviceId,
+            arrayBuffer: uint8Array.buffer,
+            bleHandle: this.bleHandle
+          }));
+
+        if (!success) {
+          // 如果校验设备或者发送不成功，重试下一个设备
+          await sleep(500);
+          await startBluetoothDevicesDiscovery();
+          await startConfigDevice(bleDevice);
+          return;
+        }
+
+        // 如果有一个设备发送成功，则不再发现新设备
+        GizLog.debug("GIZ_SDK: offBluetoothDeviceFound ready search device")
+        wx.offBluetoothDeviceFound(handleFoundDevices);
+      };
+
+      // 开始大循环搜索
+
+      // try {
+      //   // const devicesReturn = await this.searchDevice({ ssid, password });
+      //   this.searchDevice({ ssid, password }).then(devicesReturn => {
+      //     res(devicesReturn);
+      //   })
+      // } catch (error) {
+      //   rej(error);
+      //   GizLog.error("GIZ_SDK: searchDevice error", new Error(JSON.stringify(error)))
+      // }
+      const { productKey, mac } = advertisData2PkAndMac(bleDevice.advertisData, this.specialProductKeys)
+      // const result = await this.getDeviceLastestOnlineTime({ productKey, mac });
+      // GizLog.log("GIZ_SDK: 初始设备上线时间 ", result);
+      // if (result.success && result.data && result.data.data) {
+      //   this.lastestOnlineTimeMap[`${productKey}${mac}`] = result.data.data.lastOnlineTime;
+      //   GizLog.log("GIZ_SDK: 初始设备上线时间 lastestOnlineTimeMap ", this.lastestOnlineTimeMap);
+      // }
+      await startConfigDevice(bleDevice);
+      try {
+        // const devicesReturn = await this.searchDevice({ ssid, password });
+        this.verifyDeviceOnline({ productKey, mac }).then(devicesReturn => {
+          res({ ...devicesReturn, data: { ...devicesReturn.data.data, productKey } });
+        });
+      } catch (error) {
+        rej(error);
+        GizLog.error("GIZ_SDK: searchDevice error", new Error(JSON.stringify(error)))
+      }
+    });
+  };
+}
+
+export default BLEAliCloudConfig;

package/dist/src/protocol/Reset.d.ts

@@ -1,8 +0,0 @@
-import ProtocolBase from "./ProtocolBase";
-declare type IStatus = 0 | 1;
-declare class Reset extends ProtocolBase {
-    status: IStatus;
-    constructor(data: number[]);
-    static pack: () => number[];
-}
-export default Reset;