wxmini/utils/blue_ble/manager.js

class Manager {
  constructor() {
    var that = this;
    ///正在连接中的设备
    that.connectWillDevice = null;
    ///正在连接的设备，成功后返回的数据
    that.callBackConnect = null;
    ///搜索过快会失败，给的一定的缓冲时间
    that.requestBlueTime = 0;
    ///蓝牙是否已打开，是否可用
    that.isAvailable = false;
    ///蓝牙正在搜索中，则不允许继续搜索
    that.doStartScaning = false;
    ///蓝牙设备搜索的所有在线设备，用来和现有设备比较
    that.compareList = [];
    ///离线的所有设备，也可以用来比较
    that.dissmissDevice = [];

    ///当前蓝牙ble连接设备的相关属性
    that.writeCharaterId = "";
    that.writeServiceId = "";
    that.readCharaterId = "";
    that.readServiceId = "";
  }

  ///获取比较的数据
  getCompareList() {
    var that = this;
    return that.compareList;
  }

  setCompareList(compareList) {
    var that = this;
    that.compareList = compareList;
  }

  getDissmissDevice() {
    var that = this;
    return that.dissmissDevice;
  }

  setConnectWillDevice(connectWillDevice) {
    var that = this;
    that.connectWillDevice = connectWillDevice;
  }

  getCallBackConnect() {
    var that = this;
    return that.callBackConnect;
  }

  setCallBackConnect(callBackConnect) {
    this.callBackConnect = callBackConnect;
  }

  /// 监控蓝牙打开状态
  initBlueAdapter() {
    var that = this;
    wx.onBluetoothAdapterStateChange(function (res) {
      that.isAvailable = res.available;
      if (!that.isAvailable) {
        that.compareList = [];
        that.dissmissDevice = [];
        getCurrentPages()[0].closeBlueResetOffline(false, true);
      }
    })
  }

  ///监听搜索设备列表
  listenBlueDevices() {
    var that = this;
    const hex_util = require('./../../utils/hex_util');
    wx.onBluetoothDeviceFound(function (res) {
      ///第一种情况
      if (res.deviceId) {
        if (that.callBackConnect != null) {
          if (that.connectWillDevice != null && res.name == that.connectWillDevice.clientType) {
            res.mac = res.advertisData ? hex_util.buf2hex(res.advertisData) : '';
            if (that.callBackConnect != null) {
              that.callBackConnect(res);
            }
          }
        } else {
          if (res.name != "") {
            if (that.compareList.length > 0) {
              var has = false;
              for (var i = 0; i < that.compareList.length; i++) {
                if (res.deviceId == that.compareList[i].deviceId) {
                  has = true;
                  break;
                }
              }
              if (!has) {
                that.compareList.push(res);
              }
            } else {
              that.compareList.push(res);
            }
          }
        }
      }
      ///第二种情况
      else if (res.devices) {
        if (that.callBackConnect != null) {
          for (var i = 0; i < res.devices.length; i++) {
            var temp = res.devices[i];
            if (that.connectWillDevice != null && temp.name == that.connectWillDevice.clientType) {
              temp.mac = temp.advertisData ? hex_util.buf2hex(temp.advertisData) : '';
              temp.mac2 = that.ab2hex(temp.advertisData ?? "")
              if (that.callBackConnect != null) {
                that.callBackConnect(temp);
              }
              break;
            }
          }
        } else {
          for (var i = 0; i < res.devices.length; i++) {
            if (that.compareList.length > 0) {
              var has = false;
              for (var j = 0; j < that.compareList.length; j++) {
                if (res.devices[i].name != "") {
                  if (res.devices[i].deviceId == that.compareList[j].deviceId) {
                    has = true;
                    break;
                  }
                }
              }
              if (!has) {
                that.compareList.push(res.devices[i]);
              }
            } else {
              that.compareList.push(res.devices[i]);
            }
          }
        }
      }
      ///第三种情况
      else if (res[0]) {
        if (that.callBackConnect != null) {
          if (that.connectWillDevice != null && res[0].name == that.connectWillDevice.clientType) {
            res[0].mac = res[0].advertisData ? hex_util.buf2hex(res[0].advertisData) : '';
            if (that.callBackConnect != null) {
              that.callBackConnect(res[0]);
            }
          }
        } else {
          if (res[0].name != "") {
            if (that.compareList.length > 0) {
              var has = false;
              for (var i = 0; i < that.compareList.length; i++) {
                if (res[0].deviceId == that.compareList[i].deviceId) {
                  has = true;
                  break;
                }
              }
              if (!has) {
                that.compareList.push(res[0]);
              }
            } else {
              that.compareList.push(res[0]);
            }
          }
        }
      }
    });

    ///监听  离线和连接成功设备导入
    // {"deviceId":"E4:9F:80:09:40:EC","connected":false}
    wx.onBLEConnectionStateChange((result) => {
      if (result.connected) {
        for (var i = 0; i < that.dissmissDevice.length; i++) {
          if (result.deviceId == that.dissmissDevice[i].deviceId) {
            that.dissmissDevice.splice(i, 1);
            break;
          }
        }
      } else {
        var has = false;
        for (var i = 0; i < that.dissmissDevice.length; i++) {
          if (result.deviceId == that.dissmissDevice[i].deviceId) {
            has = true;
            break;
          }
        }
        if (!has) {
          that.dissmissDevice.push(result);
        }
      }
    });
  }

  // 开始搜索蓝牙设备
  async startScan(connectWillDevice, boolean, callBackConnect) {
    var that = this;
    ///限制搜索没有打开蓝牙一直询问打开蓝牙
    if (!that.isAvailable) {
      if (callBackConnect == null) {
        return;
      }

      ///做搜索蓝牙适配器权限
      const permission_util = require('../utils/permission_util');
      var available = await permission_util.openBluetoothAdapter();
      that.isAvailable = available;
      if (!available) {
        that.doStartScaning = false;
        that.requestBlueTime = that.getCurrentMills();
        if (boolean != null) {
          boolean(false);
        }
        return;
      }
    }

    const route_util = require('../utils/route_util');
    const route_constant = require('../utils/route_constant');
    const indexRoot = route_constant.indexRoot;
    const connectBleRoot = route_constant.connectBleRoot;
    var lastPageRoute = route_util.getLastPageRoute();
    if (lastPageRoute != indexRoot && lastPageRoute != connectBleRoot) {
      return;
    }

    ///蓝牙连接 做限制
    if (lastPageRoute == indexRoot) {
      if (that.doStartScaning == true) {
        return;
      }
    }

    const time_util = require('./../../utils/time_util');
    that.doStartScaning = true;
    var currentMill = time_util.getCurrentMills();
    var waitMills = 0;
    var reduce = currentMill - that.requestBlueTime;
    const dMills = 6 * 1000;
    if (reduce > 0 && reduce < dMills) {
      waitMills = dMills - reduce;
    }

    if (waitMills > 0) {
      await time_util.delayMills(waitMills);
    }

    if (callBackConnect == null && lastPageRoute == connectBleRoot) {
      that.doStartScaning = false;
      return;
    }

    wx.stopBluetoothDevicesDiscovery({
      success: (res) => {
        that.search(connectWillDevice, boolean, callBackConnect);
      },
      fail: (err) => {
        that.doStartScaning = false;
        that.requestBlueTime = time_util.getCurrentMills();
        if (boolean != null) {
          boolean(false);
        }
      }
    });
  }

  ///搜索设备
  search(connectWillDevice, boolean, callBackConnect) {
    var that = this;
    const time_util = require('./../../utils/time_util');
    wx.startBluetoothDevicesDiscovery({
      allowDuplicatesKey: true,
      success: function (res) {
        // that.getConnectedDevices();
        that.doStartScaning = false;
        that.requestBlueTime = time_util.getCurrentMills();
        if (boolean != null) {
          boolean(true);
        }
        that.setConnectWillDevice(connectWillDevice);
        that.setCallBackConnect(callBackConnect);
        that.compareList = [];
      },
      fail(err) {
        that.doStartScaning = false;
        that.requestBlueTime = time_util.getCurrentMills();
        if (boolean != null) {
          boolean(false);
        }
      },
    });
  }

  // 停止搜索
  stopScan() {
    var that = this;
    that.setCallBackConnect(null);
    that.setConnectWillDevice(null);
    return new Promise((resolve, reject) => {
      wx.stopBluetoothDevicesDiscovery({
        success: (res) => {
          resolve(res);
        },
        fail: (err) => {
          reject('停止搜索失败');
        }
      });
    });
  }

  ///开始连接设备
  startConnect(device) {
    var deviceId = device.deviceId;
    console.log("gadsfasdfadfaf===mmm==" + deviceId);
    return new Promise((resolve, reject) => {
      console.log("gadsfasdfadfaf===oooo==" + deviceId);
      wx.createBLEConnection({
        deviceId: deviceId,
        success: function (res) {
          console.log("gadsfasdfadfaf===qqqq==" + JSON.stringify(res));
          resolve(true);
        },
        fail: function (res) {
          console.log("gadsfasdfadfaf===ppp==" + JSON.stringify(res));
          var errCode = res.errCode;
          var errMsg = res.errMsg;
          if (errCode == -1 && errMsg == "createBLEConnection:fail:already connect") {
            resolve(true);
          } else {
            resolve(false);
          }
        }
      });
    });
  }

  ///初始化 接收数据 获取特征值
  getNotifyServices(device) {
    var deviceId = device.deviceId;
    console.log("gadsfasdfadfaf===nnn==" + deviceId);
    return new Promise((resolve, reject) => {
      console.log("gadsfasdfadfaf===ppp==" + deviceId);
      wx.getBLEDeviceServices({
        deviceId: deviceId,
        success: function (res) {
          console.log("gadsfasdfadfaf===xxxx==" + JSON.stringify(res));
          resolve(res.services);
        },
        fail: function (res) {
          console.log("gadsfasdfadfaf===yyy==" + JSON.stringify(res));
          resolve(null);
        }
      });
    });
  }

  ///获取设备真正的属性特征值
  getCharacteristics(device, services, index, notify, write, read, succeed, fail) {
    var that = this;
    var deviceId = device.deviceId;
    wx.getBLEDeviceCharacteristics({
      deviceId: deviceId,
      serviceId: services[index].uuid,
      success: function (res) {
        var notifyCharaterId = "";
        var notifyServiceId = "";
        for (var i = 0; i < res.characteristics.length; i++) {
          var properties = res.characteristics[i].properties;
          var charaterId = res.characteristics[i].uuid;

          if (!notify) {
            if (properties.notify) {
              notifyCharaterId = charaterId;
              notifyServiceId = services[index].uuid;
              notify = true;
            }
          }
          if (!write) {
            if (properties.write) {
              that.writeCharaterId = charaterId;
              that.writeServiceId = services[index].uuid;
              write = true;
            }
          }

          if (!read) {
            if (properties.read) {
              that.readCharaterId = charaterId;
              that.readServiceId = services[index].uuid;
              read = true;
            }
          }
        }

        if (!notify) {
          index++
          if (index == services.length) {
            fail();
          } else {
            that.getCharacteristics(device, services, index, notify, write, read, succeed, fail);
          }
        } else {
          succeed(notifyServiceId, notifyCharaterId);
        }
      }
    })
  }

  // 监听发送的数据
  monitorCharacteristicValueChange(device, notifyServiceId, notifyCharaterId) {
    return new Promise((resolve, reject) => {
      var deviceId = device.deviceId;
      wx.notifyBLECharacteristicValueChange({
        state: true,
        deviceId: deviceId,
        serviceId: notifyServiceId,
        characteristicId: notifyCharaterId,
        success: function (res) {
          resolve(true);
        },
        fail: function (res) {
          resolve(false);
        }
      });
    });
  }

  ///收取到的数据转换为文字
  onBLECharacteristicValueChange(callback) {
    wx.onBLECharacteristicValueChange(function (r) {
      callback(r.value);
    });
  }

  // 断开设备的连接
  disconnect(device) {
    return new Promise((resolve, reject) => {
      var deviceId = device.deviceId;
      wx.closeBLEConnection({
        deviceId: deviceId,
        success: (res) => {
          resolve(true);
        },
        fail: (err) => {
          resolve(false);
        }
      });
    });
  }

  ///发送数据
  sendData(device, text) {
    return new Promise((resolve, reject) => {
      var that = this;
      var deviceId = device.deviceId;
      var buffer = new ArrayBuffer(text.length)
      var dataView = new Uint8Array(buffer)
      for (var i = 0; i < text.length; i++) {
        dataView[i] = text.charCodeAt(i)
      }
      wx.writeBLECharacteristicValue({
        deviceId: deviceId,
        serviceId: that.writeServiceId,
        characteristicId: that.writeCharaterId,
        value: buffer,
        success: function (res) {
          resolve(true);
        },
        fail(err) {
          resolve(false);
        }
      });
    });
  }
}

module.exports = Manager;

///获取 所有搜索过的蓝牙设备
// getConnectedDevices() {
//   var that = this;
//   const hex_util = require('./../../utils/hex_util');
//   wx.getBluetoothDevices({
//     success: (res) => {
//       if (that.callBackConnect != null) {
//         for (var i = 0; i < res.devices.length; i++) {
//           var temp = res.devices[i];
//           if (that.connectWillDevice != null && temp.name == that.connectWillDevice.clientType) {
//             temp.mac = temp.advertisData ? hex_util.buf2hex(temp.advertisData) : '';
//             if (that.callBackConnect != null) {
//               that.callBackConnect(temp);
//             }
//             break;
//           }
//         }
//       } else {
//         for (var i = 0; i < res.devices.length; i++) {
//           if (that.compareList.length > 0) {
//             var has = false;
//             for (var j = 0; j < that.compareList.length; j++) {
//               if (res.devices[i].name != "") {
//                 if (res.devices[i].deviceId == that.compareList[j].deviceId) {
//                   has = true;
//                   break;
//                 }
//               }
//             }
//             if (!has) {
//               that.compareList.push(res.devices[i]);
//             }
//           } else {
//             that.compareList.push(res.devices[i]);
//           }
//         }
//       }
//     },
//     fail: (err) => {
//       console.error('获取蓝牙设备列表失败', err);
//     }
//   });
// }