mini_program_gizwits_sdk 3.6.4 → 3.6.6

package/src/handler/ble.ts

@@ -1,1369 +0,0 @@
-import GizLog from '../GizLog';
-import Bind from '../protocol/Bind';
-import { padBoradcastData } from '../protocol/dataPoint';
-import GetDeviceStatus from '../protocol/GetDeviceStatus';
-import Login from '../protocol/Login';
-import ProtocolBase from '../protocol/ProtocolBase';
-import { hexStrint2byte } from '../protocol/tool';
-import { reportEvent } from '../services/monitor';
-import sleep from '../sleep';
-import {MD5} from 'crypto-js';
-import {crc32} from '../crc'
-import {
-  ab2hex,
-  ab2numbers,
-  arrayBufferToWordArray,
-  BTDevice2GDevice,
-  convertToServiceUuids,
-  numberArray2Uint8Array,
-  parseBroadcastData,
-  unionBy,
-  wrapErrorInfo
-} from '../utils';
-import { downloadFile, retryConnect, unpackWriteBLECharacteristicValue } from '../wechatApi';
-import EventListener from './EventListener';
-import { checkUpdate } from '../services/ota';
-import errorCode from '../errorCode';
-import DeviceInfo from '../protocol/DeviceInfo';
-import CheckCanOTA from '../protocol/OTA/CheckCanOTA';
-import PreOTA from '../protocol/OTA/PreOTA';
-import ResetPosition from '../protocol/OTA/ResetPosition';
-import OTAPackPackage from '../protocol/OTA/OTAPackPackage';
-import AwaitNoti from '../protocol/OTA/AwaitNoti';
-import OtaComplete from '../protocol/OTA/OtaComplete';
-import { BleConnectDevice, IDevice, IOTAType, IResult, TBleHandleEvent, BleConstructorParams, GizwitsWxBlueToothDevice, IStartScanResult, TBleDataListener, IDeviceReq, StartUpgradeParams, CheckOTAParams } from '../types';
-
-
-function createUUID32() {
-  let dt = new Date().getTime();
-  let uuid = "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(
-    /[xy]/g,
-    function (c) {
-      let r = (dt + Math.random() * 16) % 16 | 0;
-      dt = Math.floor(dt / 16);
-      return (c == "x" ? r : (r & 0x3) | 0x8).toString(16);
-    }
-  );
-  return uuid;
-}
-
-function reportConnectingEvent(eventType: "BleDeviceConnectEnd" | "BleDeviceConnectBind" | "BleDeviceConnectLogin") {
-  return function (
-    target: any,
-    propertyName: string,
-    descriptor: TypedPropertyDescriptor<any>
-
-  ) {
-    const { value: method } = descriptor;
-    descriptor.value = function (...args: any[]) {
-      const ret = method!.apply(this, args);
-      return ret.then(({ _failureType_, ...res }) => {
-        reportEvent({
-          device: args[0] as IDevice,
-          eventID: (this as unknown as any).__event_id__,
-          eventType,
-          success: res.success,
-        });
-        return {
-          ...res,
-          _failureType_: eventType,
-        };
-      })
-    };
-  }
-}
-
-function reportConnectEvent(
-  target: any,
-  propertyName: string,
-  descriptor: TypedPropertyDescriptor<any>
-) {
-  const { value: method } = descriptor;
-  descriptor.value = function (...args: any[]) {
-    const that = Object.create(this);
-    that.__event_id__ = createUUID32();
-    reportEvent({
-      device: args[0] as IDevice,
-      eventID: that.__event_id__,
-      eventType: 'BleDeviceConnectStart',
-      success: true,
-    });
-    const ret = method!.apply(that, args);
-    return ret.then(({ _failureType_, ...res }) => {
-      reportEvent({
-        device: args[0] as IDevice,
-        eventID: that.__event_id__,
-        eventType: 'BleDeviceConnectFinish',
-        success: res.success,
-        ...(res.success ? {} : { failureType: _failureType_ })
-      });
-      return res;
-    })
-  };
-}
-
-export class BleHandle extends EventListener<TBleHandleEvent> {
-  private serviceUUIDSuffix: string;
-  // private characteristicUUIDSuffix: string;
-  public connectedList: BleConnectDevice[] = [];
-  private connectingDevId: string | null = null;
-  public pks: string[] = [];
-  private listenDevOfflineTimer: any = null;
-
-  private methodQueue: any = Promise.resolve();  // 发送指令的队列
-  private boradcastTimer: any;
-  private boradcastDataCache: any = {}
-  private baseServices: string[] = ['ABF8', 'ABF0', 'F0AB', 'F8AB'];
-
-  private tmpBleData = ''; // 接收分包数据用
-  private tmpDataNum = 0; // 剩余字节数
-  private disableScanFlag = false;
-
-  private peripheralServer: WechatMiniprogram.BLEPeripheralServer | null = null;
-
-  private isActive = true; // 小程序是否活跃
-  private isInitSuccess = false;
-  private isRunInit = false;
-
-  private _offlineThreshold = null;
-  public set offlineThreshold(value) {
-    this._offlineThreshold = value;
-  }
-
-  public get offlineThreshold() {
-    return this._offlineThreshold || 10000;
-  }
-
-
-  // private globalListenerMap = {};
-  public scanList: IDevice[] = [];
-  constructor({
-    pks = [],
-    bleHandleParams = {
-      serviceUUIDSuffix: 'abf0',
-      characteristicUUIDSuffix: 'abf7',
-    },
-    offlineThreshold,
-  }: BleConstructorParams) {
-    super();
-    const { serviceUUIDSuffix } = bleHandleParams;
-    this.serviceUUIDSuffix = serviceUUIDSuffix;
-    this.pks = pks;
-    // TODO
-    // 不要直接使用 globalListenerMap
-    // addDeviceDataListener addDeviceListListener addBleErrorListener
-    // 或 addEventListener 参数 deviceData deviceList error
-    // this.globalListenerMap = globalListenerMap;
-
-    /**
-     * 重新初始化蓝牙的时候，把连接中的设备都断开
-     */
-
-    this.offlineThreshold = offlineThreshold;
-    this.listenDevOffline();
-    this.listenConnection();
-
-    wx.onAppShow(this.onAppShow);
-    wx.onAppHide(this.onAppHide);
-
-    wx.onBluetoothAdapterStateChange(this.onBluetoothAdapterStateChange)
-  }
-
-  private onBluetoothAdapterStateChange = (res: WechatMiniprogram.OnBluetoothAdapterStateChangeListenerResult) => {
-    GizLog.debug("onBluetoothAdapterStateChange", res, this.isRunInit, this.isInitSuccess)
-    if (res.available) {
-      if (this.isRunInit && this.isInitSuccess === false) {
-        // 重新初始化蓝牙
-        this.init();
-      }
-    } 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 = () => {
-    // 定时检查设备列表，移除超时设备
-    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 < this.offlineThreshold * 2;
-        }
-        return now - d.ctime < this.offlineThreshold;
-      });
-      if (newDeviceList.length !== this.scanList.length) {
-        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 handleOnBLECharacteristicValueChange = async (
-    curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult
-  ) => {
-    // 不存在数据
-    if (!curDevice.value) {
-      return;
-    }
-    const hexString = ab2hex(curDevice.value);
-    try {
-      const data = new ProtocolBase(hexStrint2byte(hexString));
-      // 能解析包头，覆盖数据
-      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;
-    }
-
-    this.notiDeviceDataToSdk(curDevice, this.tmpBleData);
-
-    this.tmpBleData = '';
-    this.tmpDataNum = 0;
-  };
-
-  private notiDeviceDataToSdk = (curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult, 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 () => {
-    this.isRunInit = true;
-    const { platform } = wx.getSystemInfoSync();
-    await this.openBluetoothAdapter();
-    if (platform === 'ios') {
-      // ios 需要打开两次
-      await this.openBluetoothAdapter('peripheral');
-    }
-    // 初始化广播
-    try {
-      this.peripheralServer = (await wx.createBLEPeripheralServer()).server;
-      GizLog.info('GIZ_SDK: 广播初始化成功', this.peripheralServer)
-    } catch (error) {
-      GizLog.error('GIZ_SDK: 广播初始化失败', new Error(JSON.stringify(error)))
-    }
-    const res = await this.getBluetoothAdapterState();
-    this.isInitSuccess = true
-
-    wx.onBluetoothDeviceFound((resData) => {
-      this.handleBluetoothDeviceFound(resData);
-    });
-    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 });
-        return {success: false,}
-      }
-    } 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.OnBluetoothDeviceFoundListenerResult,
-  ) => {
-    /**
-     * 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);
-          // 更新设备
-          newDevice.ctime = Date.now();
-          this.updateDevice(newDevice);
-          // GizLog.debug("GIZ_SDK: same device", newDevice, isChange);
-          if (isChange) {
-            this.notifyDevices();
-          }
-        }
-      } else {
-        // 新增设备
-       
-        let isValidDevice = this.pks.some((pk) =>
-          advertisDataStr.includes(pk)
-        );
-        if (isValidDevice) {
-          // device.communicationType = 'BLE';
-          const newDevice = BTDevice2GDevice(device, this.pks);
-          if (newDevice.productKey && newDevice.mac) {
-            this.scanList.push(newDevice);
-            this.notifyDevices();
-          }
-        }
-      }
-    });
-  };
-
-  public startScan = async (
-    delay: number = 5000,
-    services?: string[]
-  ) => {
-    if (this.disableScanFlag) {
-      return {
-        scanList: []
-      }
-    }
-    return new Promise<IStartScanResult>(async (res) => {
-      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 {
-      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;
-  }
-
-  @reportConnectingEvent('BleDeviceConnectEnd')
-  private async connectDeviceBle(device: IDevice) {
-    try {
-      // 连接前 先停止搜索
-      await this.disableScan();
-      const connectRes = await retryConnect(device.bleDeviceID)
-      this.enableScan();
-      GizLog.debug("connect res", connectRes)
-
-      // 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: device.bleDeviceID })
-      .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: device.bleDeviceID,
-        serviceId,
-      })
-      .catch((err) => this.notifyError(err))) as any;
-
-    const characteristicId = getCharRes?.characteristics[0].uuid!;
-
-    return {
-      success: true,
-      data: {
-        serviceId,
-        characteristicId,
-      }
-    }
-  }
-
-  @reportConnectingEvent('BleDeviceConnectBind')
-  private async connectDeviceBindRequest(device: IDevice) {
-    this.write(device.bleDeviceID, numberArray2Uint8Array(Bind.pack()).buffer);
-    const data = await this.handleBindReq(device.bleDeviceID);
-    GizLog.log('handleBindReq', data);
-    if (!data.success) {
-      // 绑定失败，异常退出断开蓝牙
-      await wx.closeBLEConnection({
-        deviceId: device.bleDeviceID,
-      });
-    }
-    return data;
-  }
-
-  @reportConnectingEvent('BleDeviceConnectLogin')
-  private async connectDeviceLoginRequest(device: IDevice, passcode: string) {
-    this.write(
-      device.bleDeviceID,
-      numberArray2Uint8Array(Login.pack({ passcode })).buffer
-    );
-    const loginData = (await this.handleLoginReq(device.bleDeviceID).catch((err) =>
-      this.notifyError(err)
-    )) as any;
-    return {
-      success: !!loginData?.success,
-      message: 'ok',
-    };
-  }
-
-  @reportConnectEvent
-  private async _connectDevice(device: IDevice) {
-    const connectRet = await this.connectDeviceBle(device);
-    if (!connectRet.success) {
-      return connectRet;
-    }
-
-    const { serviceId, characteristicId } = connectRet.data;
-
-    // 登录成功 把设备插入 connectedList
-    const isNewDevice = this.connectedList.every(
-      (d) => d.deviceId !== device.bleDeviceID
-    );
-    isNewDevice &&
-      this.connectedList.push({ deviceId: device.bleDeviceID, serviceId, characteristicId });
-
-    // 连接成功以后默认监听设备
-    await wx
-      .notifyBLECharacteristicValueChange({
-        deviceId: device.bleDeviceID,
-        serviceId,
-        characteristicId,
-        state: true,
-        type: 'notification',
-      })
-      .catch((err) => this.notifyError(err));
-
-    const bindRet = await this.connectDeviceBindRequest(device);
-
-    if (!bindRet.success) {
-      return bindRet;
-    }
-
-    const loginRet = await this.connectDeviceLoginRequest(device, bindRet.data);
-    return loginRet;
-  }
-
-
-  public connectDevice = async (device: IDevice) => {
-    // 先锁定这个设备 防止被剔除
-    try {
-      this.connectingDevId = device.bleDeviceID;
-      return await this._connectDevice(device);
-    } finally {
-      this.connectingDevId = null;
-    }
-  };
-
-  /**
-   * 
-   * @param deviceId 
-   * @param filter 
-   * @returns 
-   * 监听指定设备的原始数据
-   * 3s超时，用来处理和设备一来一回的交互
-   */
-  private handleWatchBleData = async <T>(deviceId: string, filter: TBleDataListener<T>, timeout = 3000): Promise<IResult<T>> => {
-    return new Promise((res) => {
-      let watchWapper = (
-        _curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult,
-          hexString: string
-      ) => {
-        // 不是这里关心的数据
-        if (deviceId !== _curDevice.deviceId) {
-          return;
-        }
-        const resData = filter(_curDevice, hexString);
-        if (resData) {
-          // 结束监听
-          res({
-            success: true,
-            data: resData
-          });
-          this.removeEventListener('GizBleDeviceData', watchWapper);
-        }
-      }
-      this.addEventListener('GizBleDeviceData', watchWapper);
-
-      // 设置超时时间
-      setTimeout(() => {
-        if (watchWapper) {
-          this.removeEventListener('GizBleDeviceData', watchWapper);
-          res({
-            success: false,
-            err: errorCode.GIZ_SDK_DEVICE_NO_RESPONSE
-          });
-        }
-      }, timeout)
-    })
-  }
-
-  private handleBindReq = (deviceId: string) => {
-    // 处理设备回复绑定消息
-    return new Promise<IDeviceReq<string>>((res) => {
-      const timer = setTimeout(() => {
-        GizLog.debug('绑定协议执行超时');
-        res({
-          success: false,
-          data: ''
-        })
-      }, 5* 1000)
-      const onListener = (
-        _curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult,
-        hexString: string
-      ) => {
-        if (_curDevice.deviceId !== deviceId) {
-          return;
-        }
-        timer && clearTimeout(timer)
-        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 handleLoginReq = (deviceId) => {
-    return new Promise<IDeviceReq<String>>((res) => {
-      const timer = setTimeout(() => {
-        GizLog.debug('登录协议执行超时');
-        res({
-          success: false,
-          data: ''
-        })
-      }, 5* 1000)
-      const onListener = (
-        _curDevice: WechatMiniprogram.OnBLECharacteristicValueChangeListenerResult,
-        hexString: string
-      ) => {
-        //TODO 销毁监听
-        if (_curDevice.deviceId !== deviceId) {
-          return;
-        }
-        timer && clearTimeout(timer)
-        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.debug("检查设备是否有新固件", res)
-    const deviceId = device.bleDeviceID;
-
-    if (res.success) {
-      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: url,
-        })
-        fileUrl = (downloadRes as any).tempFilePath
-      } catch (error) {
-        GizLog.error("固件下载失败", error)
-
-        return {
-          success: false,
-          err: errorCode.GIZ_SDK_OTA_FIRMWARE_DOWNLOAD_FAILED
-        }
-      }
-      GizLog.debug("下载固件成功", fileUrl)
-
-      // 开始传输
-      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.debug("查询设备是否可以OTA")
-
-      const canUpdataData = CheckCanOTA.pack(type);
-      await this.write(deviceId, numberArray2Uint8Array(canUpdataData).buffer);
-      const canUpdateRes = await this.handleWatchBleData<CheckCanOTA>(deviceId, filterCanUpdateFunc);
-
-      GizLog.debug("设备回复是否可以OTA", canUpdateRes)
-
-      if (canUpdateRes.success && canUpdateRes.data.type !== type) {
-        // 类型不匹配
-        GizLog.error(null, new Error("OTA类型不匹配"))
-
-        return {
-          success: false,
-          err: errorCode.GIZ_SDK_OTA_FIRMWARE_TYPE_NOT_MATCH
-        }
-      }
-
-      // 发送预更新指令
-      if (canUpdateRes.success && canUpdateRes.data.state ===0) {
-        // 允许更新 发送预升级请求
-        // 获取文件 计算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
-          }
-        }
-
-        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);
-        const preOtaRes = await this.handleWatchBleData<PreOTA>(deviceId, filterPreUpdateFunc, 5 * 1000);
-
-        GizLog.debug("设备回复ota 预请求", preOtaRes)
-
-        if (preOtaRes.success && preOtaRes.data.state === 0) {
-          // 开始位置
-          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.debug(`断点续传，从 ${startPoint} 开始`)
-
-            } else {
-              GizLog.debug(`从位置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) {
-
-            const packageData = byteArray.slice(startPoint, startPoint + maxPackageLen);
-
-            // 组包
-            const otaPackage = OTAPackPackage.pack(packageData, packageIndex)
-            // 发送
-            await this.write(deviceId, numberArray2Uint8Array(otaPackage).buffer);
-            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);
-            let hasError = false;
-            if (otaRes.success === false) hasError = true
-
-            if (otaRes.success && otaRes.data.state !== 0 && otaRes.data.state !== 4) hasError= true
-            if (hasError) {
-              repeatNum += 1;
-              GizLog.debug(`发送OTA包失败，重试次数 ${repeatNum}`, otaRes)
-
-              // 错误计数加1 重试
-              if (repeatNum > 3) {
-                // ota 失败，断开连接，返回错误
-                GizLog.debug(`发送OTA包失败次数超过限制`)
-                return {
-                  success: false,
-                }
-              }
-              continue;
-            }
-
-            GizLog.debug("设备接收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 (otaRes.data.state === 4) {
-              GizLog.debug(`设备请求等待OTA`)
-
-              const awaitRes = await this.handleWatchBleData<AwaitNoti>(deviceId, filterAwaitOtaContinueFunc, 60 * 1000);
-              GizLog.debug(`设备回复等待结果`, awaitRes)
-
-              if (awaitRes.data.state === 1) {
-                return {
-                  success: false,
-                }
-              }
-            }
-          }
-
-          // 发送完所有数据包， 等待监听
-          GizLog.debug("发送完所有数据包，等待设备回复")
-          
-          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 awaitRes = await this.handleWatchBleData<OtaComplete>(deviceId, filterOtaResFunc, 10 * 1000);
-
-          if (awaitRes.success && awaitRes.data.state === 0) {
-            GizLog.debug("设备回复收到固件，准备重启设备")
-            onEvent({
-              code: "GizOTAEventReboot"
-            })
-            // 等待5s后去尝试连接设备
-            this.disConnectDevice(deviceId)
-            await sleep(10 * 1000)
-            const connectRes = await this.connectDevice(device)
-            console.log('connectRes', connectRes)
-            if (!connectRes.success) {
-              GizLog.debug("设备重启后，无法连接")
-
-              return {
-                success: false,
-              }
-            }
-
-            // 查询设备版本号
-            const versionRes = await this.getDeviceInfo({deviceId});
-            if (!versionRes.success) {
-              GizLog.debug("获取设备版本号失败")
-              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.debug("设备上报版本号与更新的固件版本号不匹配，更新失败")
-            // 版本对不上
-            return {
-              success: false,
-            }
-
-          } else {
-            // 错误
-            return {
-              success: false,
-            }
-          }
-          
-
-        } else {
-          // pre ota 失败，提示错误
-          return {
-            success: false,
-          }
-        }
-      }
-
-      // 设备拒绝更新
-      return {
-        success: false,
-        err: errorCode.GIZ_SDK_OTA_DEVICE_BUSY_IN_UPGRADE,
-      }
-    }
-    return res;
-  }
-
-  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',
-      };
-    }
-
-
-
-  }
-
-  write = async (bleDeviceID, value) => {
-    const writeMethod = async () => {
-      GizLog.log('app => dev:', 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',
-      };
-    };
-
-    // 将当前方法添加到方法队列中，并等待前一个方法执行完成后再执行
-    this.methodQueue = this.methodQueue.then(writeMethod);
-
-    return this.methodQueue;
-  };
-
-
-  /**
-   * @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);
-    wx.offAppShow(this.onAppShow);
-    wx.offAppHide(this.onAppHide);
-    wx.offBluetoothAdapterStateChange(this.onBluetoothAdapterStateChange)
-  }
-}