mini_program_gizwits_sdk 3.7.0-kuka → 3.7.0

package/src/handler/ble.ts

@@ -1,1485 +0,0 @@
-import {
-  ab2hex,
-  ab2numbers,
-  arrayBufferToWordArray,
-  BTDevice2GDevice,
-  convertToServiceUuids,
-  isSameDevice,
-  numberArray2Uint8Array,
-  parseBroadcastData,
-  unionBy,
-  wrapErrorInfo,
-} from '../utils';
-import { downloadFile, retryConnect, unpackWriteBLECharacteristicValue } from '../wechatApi';
-import Bind from '../protocol/Bind';
-import { hexStrint2byte } from '../protocol/tool';
-import ProtocolBase from '../protocol/ProtocolBase';
-import YunZhiMianBleProtocolBase from '../protocol/thirdProtocol/YunZhiMianBleProtocolBase';
-import Login from '../protocol/Login';
-import GetDeviceStatus from '../protocol/GetDeviceStatus';
-import { padBoradcastData } from '../protocol/DataPoint';
-import GizLog from '../GizLog';
-import EventListener from './EventListener';
-import sleep from '../sleep';
-import Reset from '../protocol/Reset';
-import DeviceInfo from '../protocol/DeviceInfo';
-import { CheckOTAParams, StartUpgradeParams, TBleDataListener } from '../types';
-import { IResult } from '../sdk';
-import errorCode from '../errorCode';
-import { checkUpdate } from '../services/ota';
-import CheckCanOTA from '../protocol/OTA/CheckCanOTA';
-import PreOTA from '../protocol/OTA/PreOTA';
-import AwaitNoti from '../protocol/OTA/AwaitNoti';
-import { MD5 } from 'crypto-js';
-import { crc32 } from '../crc';
-import ResetPosition from '../protocol/OTA/ResetPosition';
-import OTAPackPackage from '../protocol/OTA/OTAPackPackage';
-import OtaComplete from '../protocol/OTA/OtaComplete';
-
-type GizBleDeviceListotifications = (devices: IDevice[]) => void;
-type GizBleDeviceDataNotifications = (
-  curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult,
-  hexString: string
-) => void;
-type GizBleErrorNotifications = (err: { errCode: number; errMsg: string }) => void;
-
-export interface TBleHandleEvent {
-  GizBleDeviceData: GizBleDeviceDataNotifications;
-  GizBleDeviceList: GizBleDeviceListotifications;
-  GizBleError: GizBleErrorNotifications;
-}
-
-export interface GizwitsWxBlueToothDevice extends WechatMiniprogram.BlueToothDevice {
-  communicationType: 'BLE_BROADCAST' | 'BLE';
-  RSSI: number;
-}
-
-interface BleHandleParams {
-  serviceUUIDSuffix: string;
-  serviceUUIDSuffix2: 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;
-}
-
-interface IOtaSession {
-  cancelled: boolean;
-  cancelHandlers: Set<() => void>;
-}
-
-export class BleHandle extends EventListener<TBleHandleEvent> {
-  private serviceUUIDSuffix: string;
-  private serviceUUIDSuffix2: string;
-  // private characteristicUUIDSuffix: string;
-  public connectedList: ConnectDevice[] = [];
-  private connectingDevId: string | null = null;
-  private pks: string[] = [];
-  private listenDevOfflineTimer: any = null;
-  private listenBluetoothDeviceFoundNoneTimer: any = null;
-  private MAX_BLE_SCAN_INVERTER = 1000 * 60 * 5 - 1;
-  private startScanParams: any = null;
-  // 是否正在执行扫描
-  private isScanning = false;
-
-  private boradcastTimer: any;
-  private boradcastDataCache: any = {};
-  private baseServices: string[] = [];
-
-  private tmpBleData = ''; // 接收分包数据用
-  private tmpDataNum = 0; // 剩余字节数
-  private disableScanFlag = false;
-
-  private peripheralServer: WechatMiniprogram.BLEPeripheralServer | null = null;
-
-  private isActive = true; // 小程序是否活跃
-
-  private otaSessionMap: Record<string, IOtaSession> = {};
-
-  // private globalListenerMap = {};
-  public scanList: IDevice[] = [];
-  constructor({
-    pks = [],
-    bleHandleParams = {
-      serviceUUIDSuffix: 'fe60',
-      serviceUUIDSuffix2: 'abf0',
-      characteristicUUIDSuffix: 'fe61',
-    },
-    offlineThreshold,
-  }: ConstructorParams) {
-    super();
-    const { serviceUUIDSuffix, serviceUUIDSuffix2 } = bleHandleParams;
-    this.serviceUUIDSuffix = serviceUUIDSuffix;
-    this.serviceUUIDSuffix2 = serviceUUIDSuffix2;
-    this.pks = pks;
-    // TODO
-    // 不要直接使用 globalListenerMap
-    // addDeviceDataListener addDeviceListListener addBleErrorListener
-    // 或 addEventListener 参数 deviceData deviceList error
-    // this.globalListenerMap = globalListenerMap;
-
-    this.listenDevOffline(offlineThreshold ?? 10000);
-    this.listenConnection();
-    this.listenBluetoothDeviceFoundNone();
-
-    wx.onAppShow(this.onAppShow);
-    wx.onAppHide(this.onAppHide);
-
-    wx.onBluetoothAdapterStateChange(this.onBluetoothAdapterStateChange);
-  }
-
-  private onBluetoothAdapterStateChange = (res: WechatMiniprogram.OnBluetoothAdapterStateChangeCallbackResult) => {
-    GizLog.debug('onBluetoothAdapterStateChange', res);
-    if (res.available) {
-      // this.startScan(() => {}, 4000);
-    } else {
-      // 不可用状态
-      this.scanList = [];
-      this.notifyDevices();
-    }
-  };
-
-  private onAppShow = () => {
-    // 更新所有蓝牙设备的Ctime
-    this.isActive = true;
-    this.scanList.map(item => {
-      item.ctime = Date.now();
-    });
-  };
-
-  private onAppHide = () => {
-    this.isActive = false;
-  };
-
-  private listenDevOffline = (offlineThreshold: number) => {
-    // 定时检查设备列表，移除超时设备
-    this.listenDevOfflineTimer = setInterval(() => {
-      // 非激活状态不处理
-      if (!this.isActive) return;
-      const now = new Date().getTime();
-      const newDeviceList = this.scanList.filter(d => {
-        const isConnected = this.connectedList.find(item => d.bleDeviceID == item.deviceId);
-        const isConnecting = this.connectingDevId === d.bleDeviceID;
-        // 已经连接不删除
-        if (isConnected || isConnecting) {
-          return true;
-        }
-        // 广播类型的设备由于性能问题，双倍的时间才触发离线
-        if (d.connectType === 'BLE_BROADCAST') {
-          return now - d.ctime < offlineThreshold * 2;
-        }
-        return now - d.ctime < offlineThreshold;
-      });
-      if (newDeviceList.length !== this.scanList.length) {
-        const lossDevices = this.scanList.filter(d => !newDeviceList.find(newD => isSameDevice(newD, d)));
-        GizLog.warn('timestamp:', now, '\n', 'BLE devices offline:', lossDevices);
-        this.scanList = newDeviceList;
-        // TODO 不要直接修改保护的对象
-        // this.gizSdk.bleDevices = newDeviceList;
-        this.notifyDevices();
-      }
-    }, 500);
-  };
-
-  private openBluetoothAdapter = (mode: 'central' | 'peripheral' = 'central') => {
-    return new Promise((resolve, reject) => {
-      wx.openBluetoothAdapter({
-        mode,
-        success: () => {
-          resolve({ success: true });
-          wx.onBLECharacteristicValueChange(this.handleOnBLECharacteristicValueChange);
-        },
-        fail: err => {
-          GizLog.error('openBluetoothAdapter fail', new Error(JSON.stringify(err)));
-          this.notifyError({ errMsg: err.errMsg, errCode: -1 });
-          reject({ success: false, err });
-        },
-      });
-    });
-  };
-
-  private getProtocolBase = ({
-    device,
-    hexString,
-    curDeviceValue,
-  }: {
-    device: IDevice;
-    hexString: any;
-    curDeviceValue: ArrayBuffer;
-  }) => {
-    const hexData = hexStrint2byte(hexString);
-    if (
-      device.productKey === '67a95f560e464453be079c5723a4a85c' ||
-      device.productKey === '0b58c73f12064eb897aa005cf43d6a1b' ||
-      device.productKey === '4b286229884f4711bcdbaefdfb5f76b9'
-    ) {
-      const data = new YunZhiMianBleProtocolBase(hexData);
-      return {
-        data,
-        needWaitLen: data.len - curDeviceValue.byteLength,
-      };
-    }
-    const data = new ProtocolBase(hexData);
-    return {
-      data,
-      needWaitLen: data.len - curDeviceValue.byteLength + 4 + Math.ceil(data.len.toString(2).length / 8), // 还需要等待接收的数据长度
-    };
-  };
-
-  private handleOnBLECharacteristicValueChange = async (
-    curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult
-  ) => {
-    // 不存在数据
-    if (!curDevice.value) {
-      return;
-    }
-
-    const tagrgetDevice = this.scanList.find(i => i.bleDeviceID === curDevice.deviceId);
-    if (tagrgetDevice) {
-      const hexString = ab2hex(curDevice.value);
-      try {
-        const { needWaitLen } = this.getProtocolBase({
-          device: tagrgetDevice,
-          hexString,
-          curDeviceValue: curDevice.value,
-        });
-        // console.log('需要等待的包的长度', needWaitLen);
-        // 能解析包头，覆盖数据
-        this.tmpBleData = hexString;
-        this.tmpDataNum = needWaitLen;
-      } catch (error) {
-        // 无法解析包头
-        if (this.tmpBleData) {
-          // 有没有接收完的数据
-          this.tmpBleData += hexString;
-          this.tmpDataNum -= curDevice.value.byteLength;
-        }
-      }
-
-      if (this.tmpDataNum > 0 || !this.tmpBleData) {
-        // 没有接收完数据 或者没有有效数据
-        return;
-      }
-
-      this.notiDeviceDataToSdk(curDevice, this.tmpBleData);
-
-      this.tmpBleData = '';
-      this.tmpDataNum = 0;
-    } else {
-      GizLog.info('GIZ_SDK: 没有找到设备', curDevice);
-    }
-  };
-
-  private notiDeviceDataToSdk = (
-    curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult,
-    data: string
-  ) => {
-    if (this.listenerMap['GizBleDeviceData']) {
-      this.listenerMap['GizBleDeviceData'].map(item => {
-        item(curDevice, data);
-      });
-    }
-  };
-
-  private notifyError = (err: { errCode: number; errMsg: string }) => {
-    // TODO 具体是哪台设备的错误信息
-    // this.globalListenerMap['onBleHandleError']?.map((notifyFn) => {
-    //   notifyFn(err);
-    // });
-    if (this.listenerMap['GizBleError']) {
-      this.listenerMap['GizBleError'].map(item => {
-        item(err);
-      });
-    }
-  };
-
-  private notifyDevices = () => {
-    if (this.listenerMap['GizBleDeviceList']) {
-      this.listenerMap['GizBleDeviceList'].map(item => {
-        item(this.scanList);
-      });
-    }
-  };
-
-  private listenConnection = () => {
-    /**
-     * 之前的写法会导致每订阅一个设备都会创建一次监听
-     * 监听也不会销毁
-     * 但是这里其实sdk来做重连也有一定的歧义
-     * 比如说设备被重置之后，假设有逻辑做了解除连接，但是可能会被这里救起来
-     * 另一个角度来分析，蓝牙连接上之后，没有那么容易断开
-     */
-    wx.onBLEConnectionStateChange(res => {
-      if (res.connected === false) {
-        const index = this.connectedList.findIndex(item => item.deviceId === res.deviceId);
-        if (index !== -1) {
-          this.connectedList.splice(index, 1);
-          this.notifyDevices();
-        }
-      }
-    });
-  };
-
-  private init = async () => {
-    const { platform } = wx.getSystemInfoSync();
-    await this.openBluetoothAdapter();
-    if (platform === 'ios') {
-      // ios 需要打开两次
-      await this.openBluetoothAdapter('peripheral');
-    }
-    let BLEPeripheralServerRes = true;
-    // 初始化广播
-    try {
-      this.peripheralServer = (await wx.createBLEPeripheralServer()).server;
-      GizLog.info('GIZ_SDK: 广播初始化成功', this.peripheralServer);
-    } catch (error) {
-      GizLog.error('GIZ_SDK: 广播初始化失败', new Error(JSON.stringify(error)));
-      BLEPeripheralServerRes = false;
-    }
-    if (platform === 'android' && BLEPeripheralServerRes === false) {
-      /**
-       * 安卓 微信拿不到发现附近设备的授权(android version >= 12)
-       * init方法的返回值改为false 交给应用层处理
-       * 避免安卓无附近设备授权时 蓝牙初始化依旧是成功的(按道理是失败)
-       */
-      return { success: false, message: '安卓设备：GIZ_SDK初始化蓝牙广播失败' };
-    }
-    const res = await this.getBluetoothAdapterState();
-    return res;
-  };
-
-  public checkPermission = async () => {
-    const settings = await wx.getSetting();
-    const hasBlePermission = settings.authSetting['scope.bluetooth'];
-
-    if (!hasBlePermission) {
-      try {
-        await wx.authorize({ scope: 'scope.bluetooth' });
-        return await this.init();
-      } catch (err) {
-        GizLog.log('授权失败', err);
-        // remove me in the future
-        this.openBluetoothAdapter();
-        this.notifyError({ errMsg: err.errMsg, errCode: -1 });
-      }
-    } else {
-      return await this.init();
-    }
-  };
-
-  private getBluetoothAdapterState = async () => {
-    GizLog.log('getBluetoothAdapterState', await wx.getBluetoothAdapterState());
-    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 updateDevice = (device: IDevice) => {
-    // 更新蓝牙设备到scanlist
-    const id = device.bleDeviceID;
-    const index = this.scanList.findIndex(item => id == item.bleDeviceID);
-    if (index !== -1) {
-      this.scanList[index] = device;
-    }
-  };
-
-  private updateCtime = (device: WechatMiniprogram.BlueToothDevice) => {
-    const id = device.deviceId;
-    const index = this.scanList.findIndex(item => id == item.bleDeviceID);
-    if (index !== -1) {
-      this.scanList[index].ctime = Date.now();
-    }
-  };
-
-  private checkDeviceIsChange = (a: IDevice, b: IDevice) => {
-    //检查设备是否发生变更
-
-    if (
-      a.bleWorkStatus !== b.bleWorkStatus ||
-      a.name !== b.name ||
-      a.isBleOnline !== b.isBleOnline ||
-      a.isOnline !== b.isOnline
-    ) {
-      return true;
-    }
-    return false;
-  };
-
-  private handleBluetoothDeviceFound = (
-    resData: WechatMiniprogram.OnBluetoothDeviceFoundCallbackResult,
-    onScanDevice: OnScanDevice
-  ) => {
-    /**
-     * TODO
-     * 流程可以优化
-     * 这里多次解析了设备的广播内容
-     */
-    (unionBy(resData.devices, 'deviceId') as GizwitsWxBlueToothDevice[]).map(device => {
-      const { advertisData, deviceId, name, localName } = device;
-
-      const advertisDataStr = ab2hex(advertisData);
-
-      // 从服务uuid里面扫描广播类的设备
-      let broadcastCmdData: any = null;
-      try {
-        broadcastCmdData = parseBroadcastData(ab2numbers(advertisData));
-      } catch (error) { }
-
-      const targetBleDev = this.scanList.find(d => d.bleDeviceID === deviceId);
-      // 先检查是否是广播设备的业务指令，如果是就更新数据，不往下判断
-      if (broadcastCmdData && broadcastCmdData.cmd === 0x94) {
-        // 业务指令
-        const advertisDataString = ab2hex(advertisData);
-        if (this.boradcastDataCache[deviceId] && this.boradcastDataCache[deviceId] === advertisDataString) {
-          // 广播包数据相同，已经处理过了，不再处理
-          return false;
-        }
-        if (!targetBleDev) {
-          // 目标设备不存在
-          return false;
-        }
-        this.boradcastDataCache[deviceId] = ab2hex(advertisData);
-        const fullData = padBoradcastData(broadcastCmdData.data.map(item => parseInt(item, 16)));
-
-        this.updateCtime(device);
-        this.notiDeviceDataToSdk(device as any, fullData);
-        return;
-      }
-
-      // 是广播设备，并且是发现包的命令
-      if (broadcastCmdData && broadcastCmdData.cmd === 0x19) {
-        const target = this.pks.find(item => item === broadcastCmdData.data.join(''));
-
-        if (target) {
-          // 更新通讯方式
-          device.communicationType = 'BLE_BROADCAST';
-        }
-      }
-
-      // 开始解析普通设备
-      if (targetBleDev) {
-        // 存在设备，更新ctime 并更新属性
-        const newDevice = BTDevice2GDevice(device, this.pks);
-
-        if (newDevice.productKey && newDevice.mac) {
-          // 广播设备没有 bleWorkStatus
-          const isChange = this.checkDeviceIsChange(newDevice, targetBleDev);
-          // 更新设备（保留RSSI，因为BTDevice2GDevice会覆盖）
-          newDevice.ctime = Date.now();
-          // RSSI单独更新，不触发回调
-          targetBleDev.RSSI = newDevice.RSSI;
-          this.updateDevice(newDevice);
-          // GizLog.debug("GIZ_SDK: same device", newDevice, isChange);
-          if (isChange) {
-            onScanDevice(this.scanList);
-          }
-        }
-      } else {
-        // 新增设备
-        let isValidDevice = this.pks.some(pk => advertisDataStr.includes(pk));
-        if (isValidDevice) {
-          // device.communicationType = 'BLE';
-          const newDevice = BTDevice2GDevice(device, this.pks);
-          GizLog.debug('insert ble device', newDevice);
-          if (newDevice.productKey && newDevice.mac) {
-            this.scanList.push(newDevice);
-            onScanDevice(this.scanList);
-          }
-        }
-      }
-    });
-  };
-
-  private listenBluetoothDeviceFoundNone = () => {
-    this.listenBluetoothDeviceFoundNoneTimer = setInterval(() => {
-      const now = new Date().getTime();
-      if (!this.startScanParams || !this.startScanParams.lastStartScanTimestamp || !this.isScanning) return;
-      const tooLongScanning = now - this.startScanParams.lastStartScanTimestamp > this.MAX_BLE_SCAN_INVERTER;
-      if (tooLongScanning && !this.disableScanFlag) {
-        this.stopScan();
-        this.startScanParams.lastStartScanTimestamp = now;
-        GizLog.warn('SDK RESTART SCAN BLE', '\n', 'timestamp:', now);
-        sleep(1000).then(() => {
-          this.startScan(
-            this.startScanParams.onScanDevice,
-            this.startScanParams.delay,
-            this.startScanParams.services || null
-          );
-        });
-      }
-    }, 3000);
-  };
-
-  public startScan = async (onScanDevice: OnScanDevice, delay: number = 5000, services?: string[]) => {
-    if (this.disableScanFlag) {
-      return {
-        scanList: [],
-      };
-    }
-    if (!this.startScanParams) {
-      const params = { onScanDevice, delay, services, lastStartScanTimestamp: new Date().getTime() };
-      this.startScanParams = params;
-    }
-    this.isScanning = true;
-    return new Promise<IStartScanResult>(async res => {
-      wx.onBluetoothDeviceFound(resData => {
-        this.handleBluetoothDeviceFound(resData, onScanDevice);
-      });
-
-      GizLog.debug('GIZ_SDK: start scan', delay);
-      await wx.startBluetoothDevicesDiscovery({
-        // 如果有传的话，就按传入的方式来搜索
-        services: services || this.baseServices,
-        powerLevel: 'high',
-        allowDuplicatesKey: true,
-        interval: 200,
-      });
-
-      if (delay > 0) {
-        setTimeout(() => {
-          this.stopScan();
-          res({
-            scanList: this.scanList,
-          });
-        }, delay);
-      }
-    });
-  };
-
-  public stopScan = async () => {
-    try {
-      this.isScanning = false;
-      return await wx.stopBluetoothDevicesDiscovery();
-    } catch (error) {
-      return error;
-    }
-  };
-
-  public disableScan = async () => {
-    this.disableScanFlag = true;
-    const data = await wx.stopBluetoothDevicesDiscovery();
-    // 等系统通知停止扫描
-    await sleep(200);
-    return data;
-  };
-
-  public enableScan = () => {
-    this.disableScanFlag = false;
-  };
-
-  public connectDevice = async (deviceId: string) => {
-    // 先锁定这个设备 防止被剔除
-    try {
-      this.connectingDevId = deviceId;
-      try {
-        // 连接前 先停止搜索
-        await this.disableScan();
-        const connectRes = await retryConnect(deviceId);
-        this.enableScan();
-        GizLog.debug('connect res', connectRes);
-        GizLog.debug('===蓝牙连接成功===', new Date().getTime());
-
-        // if (connectRes && connectRes.errCode == 0 && connectRes.errMsg === 'createBLEConnection:ok') {
-        //   this.listenConnection(deviceId);
-        // }
-      } catch (error) {
-        // 已经连接，继续往下走登录流程
-        GizLog.error('GIZ_SDK: createBLEConnection error', new Error(JSON.stringify(error)));
-        if (error?.errMsg !== 'createBLEConnection:fail:already connect') {
-          this.notifyError(error);
-          return { success: false, message: error?.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) ||
-            service.uuid.toLowerCase().includes(this.serviceUUIDSuffix2))
-      )?.uuid;
-      if (!serviceId) {
-        return {
-          message: 'can not find valid serviceId',
-          success: false,
-        };
-      }
-      const serviceUUIDIsGizwits = getServicesRes?.services.find(
-        service => service.isPrimary && service.uuid.toLowerCase().includes(this.serviceUUIDSuffix2)
-      );
-
-      const getCharRes = (await wx
-        .getBLEDeviceCharacteristics({
-          deviceId,
-          serviceId,
-        })
-        .catch(err => this.notifyError(err))) as any;
-
-      const characteristicId = getCharRes?.characteristics[0].uuid!;
-
-      // 登录成功 把设备插入 connectedList
-      const isNewDevice = this.connectedList.every(device => device.deviceId !== deviceId);
-      isNewDevice && this.connectedList.push({ deviceId, serviceId, characteristicId });
-
-      // 连接成功以后默认监听设备
-      await wx
-        .notifyBLECharacteristicValueChange({
-          deviceId,
-          serviceId,
-          characteristicId,
-          state: true,
-          type: 'notification',
-        })
-        .catch(err => this.notifyError(err));
-
-      if (serviceUUIDIsGizwits) {
-        this.write(deviceId, numberArray2Uint8Array(Bind.pack()).buffer);
-        const data = await this.handleBindReq(deviceId);
-        GizLog.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;
-          if (loginData?.success) {
-            // 登录成功后查询一下 重置状态
-            // 不主动下发，等设备回复
-            // this.write(deviceId, numberArray2Uint8Array(Reset.pack()).buffer);
-            return {
-              success: true,
-              message: 'ok',
-            };
-          }
-        }
-
-        // 绑定失败，异常退出断开蓝牙
-        await wx.closeBLEConnection({
-          deviceId,
-        });
-
-        return {
-          success: false,
-          message: 'ok',
-        };
-      }
-
-      return {
-        success: true,
-        message: 'ok',
-      };
-    } finally {
-      this.connectingDevId = null;
-    }
-  };
-
-  /**
-   *
-   * @param deviceId
-   * @param filter
-   * @returns
-   * 监听指定设备的原始数据
-   * 3s超时，用来处理和设备一来一回的交互
-   */
-  private handleWatchBleData = async <T>(
-    deviceId: string,
-    filter: TBleDataListener<T>,
-    timeout = 3000,
-    session?: IOtaSession
-  ): Promise<IResult<T>> => {
-    return new Promise(res => {
-      let resolved = false;
-      let timeoutId: ReturnType<typeof setTimeout> | null = null;
-      let watchWapper: GizBleDeviceDataNotifications | null = null;
-
-      const finish = (result: IResult<T>) => {
-        if (resolved) {
-          return;
-        }
-        resolved = true;
-        if (timeoutId) {
-          clearTimeout(timeoutId);
-          timeoutId = null;
-        }
-        if (watchWapper) {
-          this.removeEventListener('GizBleDeviceData', watchWapper);
-          watchWapper = null;
-        }
-        if (session) {
-          session.cancelHandlers.delete(onSessionCancel);
-        }
-        res(result);
-      };
-
-      const onSessionCancel = () => {
-        finish({
-          success: false,
-          err: errorCode.GIZ_SDK_OTA_DEVICE_BUSY_IN_UPGRADE,
-        });
-      };
-
-      if (session) {
-        if (session.cancelled) {
-          onSessionCancel();
-          return;
-        }
-        session.cancelHandlers.add(onSessionCancel);
-      }
-
-      watchWapper = (_curDevice, hexString) => {
-        if (session?.cancelled) {
-          onSessionCancel();
-          return;
-        }
-        if (deviceId !== _curDevice.deviceId) {
-          return;
-        }
-        const resData = filter(_curDevice, hexString);
-        if (resData) {
-          finish({
-            success: true,
-            data: resData,
-          });
-        }
-      };
-      this.addEventListener('GizBleDeviceData', watchWapper);
-
-      timeoutId = setTimeout(() => {
-        finish({
-          success: false,
-          err: errorCode.GIZ_SDK_DEVICE_NO_RESPONSE,
-        });
-      }, timeout);
-    });
-  };
-
-  private handleBindReq = (deviceId: string) => {
-    // 处理设备回复绑定消息
-    return new Promise<IDeviceReq<string>>(res => {
-      const onListener = (
-        _curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult,
-        hexString: string
-      ) => {
-        if (_curDevice.deviceId !== deviceId) {
-          return;
-        }
-        GizLog.log('监听蓝牙特征值发生变化');
-        const bindData = new Bind(hexStrint2byte(hexString));
-        this.removeEventListener('GizBleDeviceData', onListener);
-        if (bindData.passcode) {
-          // 存在passcode
-          res({
-            success: true,
-            data: bindData.passcode,
-          });
-        } else {
-          res({
-            success: false,
-            data: '',
-          });
-        }
-      };
-
-      this.watchBleDevice(deviceId, onListener);
-    });
-  };
-
-  private createOtaSession(deviceId: string): IOtaSession {
-    this.cancelOtaSession(deviceId);
-    const session: IOtaSession = {
-      cancelled: false,
-      cancelHandlers: new Set(),
-    };
-    this.otaSessionMap[deviceId] = session;
-    return session;
-  }
-
-  private cancelOtaSession(deviceId: string) {
-    const session = this.otaSessionMap[deviceId];
-    if (!session) {
-      return;
-    }
-    session.cancelled = true;
-    session.cancelHandlers.forEach(handler => handler());
-    session.cancelHandlers.clear();
-    delete this.otaSessionMap[deviceId];
-  }
-
-  private releaseOtaSession(deviceId: string, session: IOtaSession) {
-    const current = this.otaSessionMap[deviceId];
-    if (current === session) {
-      session.cancelHandlers.clear();
-      delete this.otaSessionMap[deviceId];
-    }
-  }
-
-  private handleLoginReq = deviceId => {
-    return new Promise<IDeviceReq<String>>(res => {
-      const onListener = (
-        _curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeCallbackResult,
-        hexString: string
-      ) => {
-        //TODO 销毁监听
-        if (_curDevice.deviceId !== deviceId) {
-          return;
-        }
-        GizLog.log('设备回复LoginReq', hexString);
-        const loginData = new Login(hexStrint2byte(hexString));
-        this.removeEventListener('GizBleDeviceData', onListener);
-        if (loginData.result === true) {
-          res({
-            success: true,
-            data: loginData.did,
-          });
-        } else {
-          res({
-            success: false,
-            data: '',
-          });
-        }
-      };
-      this.watchBleDevice(deviceId, onListener);
-    });
-  };
-
-  public startUpgrade = async ({ device, type, onEvent, onProgress, productKey }: StartUpgradeParams) => {
-    // 上报开始
-    onEvent({ code: 'GizOTAEventPretreatment' });
-    const res = await this.checkUpdate({ device, type });
-    GizLog.warn('检查设备是否有新固件', res);
-    const deviceId = device.bleDeviceID;
-    const otaSession = this.createOtaSession(deviceId);
-
-    const buildBusyResult = () => ({
-      success: false,
-      err: errorCode.GIZ_SDK_OTA_DEVICE_BUSY_IN_UPGRADE,
-    });
-
-    try {
-      if (!res.success) {
-        return res;
-      }
-
-      const url = (res.data as any).download_url;
-      const softVer = (res.data as any).soft_ver;
-      // 开始下载
-      onEvent({ code: 'GizOTAEventDownload' });
-      let fileUrl = '';
-      try {
-        const downloadRes = await downloadFile({
-          url,
-        });
-        fileUrl = (downloadRes as any).tempFilePath;
-      } catch (error) {
-        GizLog.error('固件下载失败', error);
-
-        return {
-          success: false,
-          err: errorCode.GIZ_SDK_OTA_FIRMWARE_DOWNLOAD_FAILED,
-        };
-      }
-      GizLog.warn('下载固件成功', fileUrl);
-
-      if (otaSession.cancelled) {
-        GizLog.warn('检测到 OTA 会话被抢占，停止继续处理');
-        return buildBusyResult();
-      }
-
-      // 开始传输
-      onEvent({ code: 'GizOTAEventTransmit' });
-
-      /**
-       * 询问设备是否可以升级
-       */
-      const filterCanUpdateFunc = (_, hexString) => {
-        const bleBytesData = hexStrint2byte(hexString);
-        const parseData = new ProtocolBase(bleBytesData);
-        switch (parseData.cmd) {
-          case '0042': {
-            const data = new CheckCanOTA(bleBytesData);
-            return data;
-          }
-        }
-        return null;
-      };
-      /**
-       * 监听预升级设备回复
-       */
-      const filterPreUpdateFunc = (_, hexString) => {
-        const bleBytesData = hexStrint2byte(hexString);
-        const parseData = new ProtocolBase(bleBytesData);
-        switch (parseData.cmd) {
-          case '0044': {
-            const data = new PreOTA(bleBytesData);
-            return data;
-          }
-        }
-        return null;
-      };
-      /**
-       * 等待设备通知可以继续ota
-       */
-      const filterAwaitOtaContinueFunc = (_, hexString) => {
-        const bleBytesData = hexStrint2byte(hexString);
-        const parseData = new ProtocolBase(bleBytesData);
-        switch (parseData.cmd) {
-          case '0052': {
-            const data = new AwaitNoti(bleBytesData);
-            return data;
-          }
-        }
-        return null;
-      };
-      GizLog.warn('查询设备是否可以OTA');
-
-      if (otaSession.cancelled) {
-        return buildBusyResult();
-      }
-      const canUpdataData = CheckCanOTA.pack(type);
-      await this.write(deviceId, numberArray2Uint8Array(canUpdataData).buffer);
-      if (otaSession.cancelled) {
-        return buildBusyResult();
-      }
-      const canUpdateRes = await this.handleWatchBleData<CheckCanOTA>(deviceId, filterCanUpdateFunc, 3000, otaSession);
-
-      GizLog.warn('设备回复是否可以OTA', canUpdateRes);
-
-      if (!canUpdateRes.success) {
-        return canUpdateRes;
-      }
-
-      if (canUpdateRes.data.type !== type) {
-        // 类型不匹配
-        GizLog.error(null, new Error('OTA类型不匹配'));
-
-        return {
-          success: false,
-          err: errorCode.GIZ_SDK_OTA_FIRMWARE_TYPE_NOT_MATCH,
-        };
-      }
-
-      if (canUpdateRes.data.state !== 0) {
-        return buildBusyResult();
-      }
-
-      // 允许更新 发送预升级请求
-      // 获取文件 计算md5 和 crc
-      const fs = wx.getFileSystemManager();
-      let fileData: any = [];
-      try {
-        fileData = await fs.readFileSync(fileUrl, 'hex', 0);
-      } catch (error) {
-        GizLog.error('读取固件失败', error);
-        return {
-          success: false,
-          err: errorCode.GIZ_SDK_OTA_FIRMWARE_DOWNLOAD_FAILED,
-        };
-      }
-
-      if (otaSession.cancelled) {
-        return buildBusyResult();
-      }
-
-      const byteArray = fileData.match(/.{1,2}/g).map(function (byte) {
-        return parseInt(byte, 16);
-      });
-      const wordArray = arrayBufferToWordArray(byteArray);
-      const md5 = MD5(wordArray).toString();
-
-      const crc32Data = crc32(byteArray);
-
-      const preOtaData = PreOTA.pack(productKey, softVer, md5, byteArray.length, crc32Data);
-
-      await this.write(deviceId, numberArray2Uint8Array(preOtaData).buffer);
-      if (otaSession.cancelled) {
-        return buildBusyResult();
-      }
-      const preOtaRes = await this.handleWatchBleData<PreOTA>(deviceId, filterPreUpdateFunc, 5 * 1000, otaSession);
-
-      GizLog.warn('设备回复ota 预请求', preOtaRes);
-
-      if (!preOtaRes.success) {
-        return preOtaRes;
-      }
-
-      if (preOtaRes.data.state !== 0) {
-        // pre ota 失败，提示错误
-        return {
-          success: false,
-        };
-      }
-
-      // 开始位置
-      let startPoint = 0;
-
-      if (preOtaRes.data.processedLen > 0) {
-        // 校对已接收的crc32 和当前文件相同部分的crc32 是否相同
-        const currentProcessedCrc32 = crc32(byteArray.slice(0, preOtaRes.data.processedLen)).toString(16);
-        if (currentProcessedCrc32 === preOtaRes.data.processedCrc32) {
-          //如果相同
-          startPoint = preOtaRes.data.processedLen;
-          GizLog.warn(`断点续传，从 ${startPoint} 开始`);
-        } else {
-          GizLog.warn(`从位置0开始OTA`);
-
-          // 如果不相同，包可能发生了问题，通知设备从0 开始
-          await this.write(deviceId, numberArray2Uint8Array(ResetPosition.pack(0)).buffer);
-          await sleep(100);
-        }
-      }
-
-      /**
-       * 开始发送数据包
-       */
-      // 总固件长度
-      const fileLen = byteArray.length;
-      // 最大包长度
-      const maxPackageLen = preOtaRes.data.packageMaxLen;
-      // 当前包号
-      let packageIndex = Math.ceil(startPoint / maxPackageLen);
-
-      let repeatNum = 0; // 当前重试次数
-
-      while (startPoint < fileLen) {
-        if (otaSession.cancelled) {
-          GizLog.warn('OTA 会话被新的请求打断，终止数据发送');
-          return buildBusyResult();
-        }
-        const packageData = byteArray.slice(startPoint, startPoint + maxPackageLen);
-
-        // 组包
-        const otaPackage = OTAPackPackage.pack(packageData, packageIndex);
-        // 发送
-        await this.write(deviceId, numberArray2Uint8Array(otaPackage).buffer);
-        if (otaSession.cancelled) {
-          GizLog.warn('OTA 会话被新的请求打断，终止等待反馈');
-          return buildBusyResult();
-        }
-        const filterOtaProgressFunc = (_, hexString) => {
-          const bleBytesData = hexStrint2byte(hexString);
-          const parseData = new ProtocolBase(bleBytesData);
-          switch (parseData.cmd) {
-            case '0048': {
-              const data = new OTAPackPackage(bleBytesData);
-              if (data.packageNum === packageIndex) {
-                // 返回包号相同的数据
-                return data;
-              }
-              return null;
-            }
-          }
-          return null;
-        };
-        // 监听回复
-        const otaRes = await this.handleWatchBleData<OTAPackPackage>(
-          deviceId,
-          filterOtaProgressFunc,
-          5 * 1000,
-          otaSession
-        );
-        let hasError = false;
-        if (otaRes.success === false) {
-          if (otaRes.err === errorCode.GIZ_SDK_OTA_DEVICE_BUSY_IN_UPGRADE) {
-            return otaRes;
-          }
-          hasError = true;
-        }
-
-        if (otaRes.success && otaRes.data.state !== 0 && otaRes.data.state !== 4) hasError = true;
-        if (hasError) {
-          repeatNum += 1;
-          GizLog.warn(`发送OTA包失败，重试次数 ${repeatNum}`, otaRes);
-
-          // 错误计数加1 重试
-          if (repeatNum > 3) {
-            // ota 失败，断开连接，返回错误
-            GizLog.warn(`发送OTA包失败次数超过限制`);
-            return {
-              success: false,
-            };
-          }
-          continue;
-        }
-
-        GizLog.warn('设备接收ota子包成功', otaRes);
-
-        // 发送成功，重新计数
-        repeatNum = 0;
-
-        // 回复成功移动指针
-        startPoint += maxPackageLen;
-        packageIndex += 1;
-
-        let currentProgress = parseInt(`${((packageIndex * maxPackageLen) / fileLen) * 100}`);
-        if (currentProgress > 100) currentProgress = 100;
-        onProgress({
-          firmwareSize: fileLen,
-          packageMaxLen: maxPackageLen,
-          currentNumber: packageIndex,
-          currentProgress,
-        });
-
-        // 等100ms
-        await sleep(100);
-
-        if (otaSession.cancelled) {
-          GizLog.warn('OTA 会话被新的请求打断，停止后续传输');
-          return buildBusyResult();
-        }
-
-        // 这里还需要做个判断，如果进入等待发送状态，需要等设备通知之后再继续发送
-        if (otaRes.data.state === 4) {
-          GizLog.warn(`设备请求等待OTA`);
-
-          const awaitContinueRes = await this.handleWatchBleData<AwaitNoti>(
-            deviceId,
-            filterAwaitOtaContinueFunc,
-            60 * 1000,
-            otaSession
-          );
-          GizLog.warn(`设备回复等待结果`, awaitContinueRes);
-
-          if (!awaitContinueRes.success) {
-            if (awaitContinueRes.err === errorCode.GIZ_SDK_OTA_DEVICE_BUSY_IN_UPGRADE) {
-              return awaitContinueRes;
-            }
-            return {
-              success: false,
-            };
-          }
-
-          if (awaitContinueRes.data.state === 1) {
-            return {
-              success: false,
-            };
-          }
-        }
-      }
-
-      if (otaSession.cancelled) {
-        return buildBusyResult();
-      }
-
-      // 发送完所有数据包， 等待监听
-      GizLog.warn('发送完所有数据包，等待设备回复');
-
-      const filterOtaResFunc = (_, hexString) => {
-        const bleBytesData = hexStrint2byte(hexString);
-        const parseData = new ProtocolBase(bleBytesData);
-        switch (parseData.cmd) {
-          case '0050': {
-            const data = new OtaComplete(bleBytesData);
-            return data;
-          }
-        }
-        return null;
-      };
-      const otaCompleteRes = await this.handleWatchBleData<OtaComplete>(
-        deviceId,
-        filterOtaResFunc,
-        10 * 1000,
-        otaSession
-      );
-
-      if (!otaCompleteRes.success) {
-        return otaCompleteRes;
-      }
-
-      if (otaCompleteRes.data.state === 0) {
-        GizLog.warn('设备回复收到固件，准备重启设备');
-        onEvent({ code: 'GizOTAEventReboot' });
-        // 等待10s后去尝试连接设备
-        this.disConnectDevice(deviceId);
-        await sleep(10 * 1000);
-
-        if (otaSession.cancelled) {
-          return buildBusyResult();
-        }
-
-        const connectRes = await this.connectDevice(deviceId);
-        console.log('connectRes', connectRes);
-        if (!connectRes.success) {
-          GizLog.warn('设备重启后，无法连接');
-
-          return {
-            success: false,
-          };
-        }
-
-        // 查询设备版本号
-        const versionRes = await this.getDeviceInfo({ deviceId });
-        if (!versionRes.success) {
-          GizLog.warn('获取设备版本号失败');
-          return {
-            success: false,
-          };
-        }
-        let newSoftVersion = '';
-        if (type === 'MCU') {
-          newSoftVersion = versionRes.data.mcuSoftVersion;
-        } else {
-          newSoftVersion = versionRes.data.moduleSoftVersion;
-        }
-
-        onEvent({ code: 'GizOTAEventFinish' });
-
-        if (newSoftVersion === softVer) {
-          // 版本是正确的
-          return {
-            success: true,
-          };
-        }
-
-        GizLog.warn('设备上报版本号与更新的固件版本号不匹配，更新失败');
-        // 版本对不上
-        return {
-          success: false,
-        };
-      }
-
-      // 错误
-      return {
-        success: false,
-      };
-    } finally {
-      this.releaseOtaSession(deviceId, otaSession);
-    }
-  };
-
-  public getDeviceInfo = async ({ deviceId }: { deviceId: string }) => {
-    // 发送查询指令
-    const value = DeviceInfo.pack();
-    GizLog.debug('DeviceInfo.pack', value);
-
-    await this.write(deviceId, numberArray2Uint8Array(value).buffer);
-
-    const filterFunc = (_, hexString) => {
-      const bleBytesData = hexStrint2byte(hexString);
-      const parseData = new ProtocolBase(bleBytesData);
-      switch (parseData.cmd) {
-        case '0014': {
-          try {
-            const deviceInfoData = new DeviceInfo(bleBytesData);
-            GizLog.debug('parse DeviceInfo', deviceInfoData);
-
-            return deviceInfoData;
-          } catch (error) {
-            GizLog.debug('parse DeviceInfo error', error);
-          }
-        }
-      }
-      return null;
-    };
-
-    const versionRes = await this.handleWatchBleData<DeviceInfo>(deviceId, filterFunc);
-    return versionRes;
-  };
-
-  public checkUpdate = async ({ device, type }: CheckOTAParams) => {
-    /**
-     * 获取设备硬件版本号
-     * 查询云端接口
-     */
-
-    const versionRes = await this.getDeviceInfo({ deviceId: device.bleDeviceID });
-
-    if (versionRes.success) {
-      let softVersion = '';
-      let hardVersion = '';
-      if (type === 'MCU') {
-        softVersion = versionRes.data.mcuSoftVersion;
-        hardVersion = versionRes.data.mcuHardVersion;
-      } else {
-        softVersion = versionRes.data.moduleSoftVersion;
-        hardVersion = versionRes.data.moduleHardVersion;
-      }
-      const updateRes = await checkUpdate({ did: device.did, type, softVersion, hardVersion });
-      return updateRes;
-    }
-    return {
-      success: false,
-      err: versionRes.err,
-    };
-  };
-
-  public watchBleDevice = async (deviceId, func) => {
-    const { serviceId, characteristicId, errMsg } = this.getTargetDevice(deviceId);
-    if (errMsg) return { success: false, message: errMsg };
-    await wx
-      .notifyBLECharacteristicValueChange({
-        deviceId,
-        serviceId: serviceId!,
-        characteristicId: characteristicId!,
-        state: true,
-        type: 'notification',
-      })
-      .catch(err => this.notifyError(err));
-
-    GizLog.log(`监听设备 ${deviceId} 成功！`);
-    this.addEventListener('GizBleDeviceData', func);
-    return {
-      message: 'ok',
-      success: true,
-    };
-  };
-
-  public writeBoradcast = async (bleDeviceID: string, value: number[]) => {
-    const scanDevice = this.scanList.find(item => item.bleDeviceID === bleDeviceID);
-    if (!scanDevice) {
-      return {
-        success: false,
-        message: 'not found device',
-      };
-    }
-
-    if (this.boradcastTimer) {
-      clearTimeout(this.boradcastTimer);
-    }
-    try {
-      this.peripheralServer.stopAdvertising({});
-      const serviceUuids = convertToServiceUuids({
-        mac: scanDevice.mac,
-        index: 0,
-        data: value,
-        len: value.length,
-      });
-      this.peripheralServer.startAdvertising({
-        advertiseRequest: {
-          connectable: true,
-          serviceUuids,
-        },
-        powerLevel: 'high',
-        success: data => {
-          GizLog.debug('GIZ_SDK: startAdvertising success', data);
-        },
-        fail: err => {
-          GizLog.error('GIZ_SDK: startAdvertising error', new Error(JSON.stringify(err)));
-        },
-      });
-      GizLog.debug('GIZ_SDK: start adv', serviceUuids);
-
-      this.boradcastTimer = setTimeout(() => {
-        this.peripheralServer.stopAdvertising({});
-        this.boradcastTimer = null;
-      }, 1000);
-      return {
-        success: true,
-      };
-    } catch (error) {
-      GizLog.log('GIZ_SDK:', error);
-      clearTimeout(this.boradcastTimer);
-      return {
-        success: false,
-        message: 'send cmd error',
-      };
-    }
-  };
-
-  public write = async (bleDeviceID: string, value: ArrayBuffer) => {
-    GizLog.warn('app => dev:', ab2hex(value), new Date().getTime());
-    console.log('ble write', ab2hex(value));
-    const targetDevice = this.getTargetDevice(bleDeviceID);
-    if (targetDevice.serviceId && targetDevice.characteristicId) {
-      const unpackRes = await unpackWriteBLECharacteristicValue(
-        bleDeviceID,
-        targetDevice.serviceId,
-        targetDevice.characteristicId,
-        value
-      );
-      return unpackRes;
-    }
-    return {
-      success: false,
-      message: 'send cmd error',
-    };
-  };
-
-  /**
-   * @description 断开设备连接
-   */
-  public disConnectDevice = async (deviceId: string) => {
-    this.removeDevById(deviceId);
-    const { errMsg } = await wx.closeBLEConnection({
-      deviceId,
-    });
-
-    const target = this.scanList.find(item => item.bleDeviceID === deviceId);
-    if (target) {
-      target.ctime = Date.now();
-      this.updateDevice(target);
-    }
-
-    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);
-    if (targetIdx !== -1) {
-      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;
-  };
-
-  public destory = () => {
-    this.listenDevOfflineTimer && clearInterval(this.listenDevOfflineTimer);
-    this.listenBluetoothDeviceFoundNoneTimer && clearInterval(this.listenBluetoothDeviceFoundNoneTimer);
-    wx.offAppShow(this.onAppShow);
-    wx.offAppHide(this.onAppHide);
-    wx.offBluetoothAdapterStateChange(this.onBluetoothAdapterStateChange);
-  };
-}