wxmini/devices/ble_manager.js

// 引入必要的微信小程序 API
// const wx = require('wx');
class bleManager {
  constructor() {
    var that = this;
    that.isAvailable = false;
    that.hasPermission = false;
    that.scanDevices = [];
    that.device = null;
  }

  // 初始化蓝牙适配器
  initBluetoothAdapter() {
    var that = this
    wx.openBluetoothAdapter({
      success: (res) => {
        that.isAvailable = true;
      },
      fail: (err) => {
        that.isAvailable = false;
      }
    });
    wx.onBluetoothAdapterStateChange(function (res) {
      that.isAvailable = res.available;
    })
  }

  // 获取蓝牙权限
  async getBluetoothPermission() {
    var that = this;
    console.log("gadsfasdfqwwerqewrqr");
    return new Promise((resolve, reject) => {
      wx.getSetting({
        success(res) {
          if (res.authSetting["scope.bluetooth"]) {
            that.hasPermission = true;
            getApp().globalData.scopeBluetooth = true;
            resolve(true);
          } else if (res.authSetting["scope.bluetooth"] === undefined) {
            that.hasPermission = false;
            getApp().globalData.scopeBluetooth = false;
            resolve(false);
            wx.authorize({
              scope: "scope.bluetooth",
              complete() {
                that.getBluetoothPermission()
              }
            });
          } else {
            that.hasPermission = false;
            that.globalData.scopeBluetooth = false;
            wx.showModal({
              title: '请打开系统蓝牙进行配网',
              content: '如已打开蓝牙仍然弹框，请尝试重启小程序',
              success(res) {
                if (res.confirm) {
                  console.log('用户点击确定')
                  wx.openSetting({
                    complete() {}
                  })
                } else if (res.cancel) {
                  console.log('用户点击取消')
                }
              }
            });
            resolve(false);
          };
        },
        fail(err) {
          resolve(false);
        }
      });
    });
  }

  ///获取定位权限
  async getLocalSetting() {
    var that = this;
    return new Promise((resolve, reject) => {
      wx.getSetting({
        success(res) {
          if (res.authSetting["scope.userLocation"]) {
            resolve(true);
          } else if (res.authSetting["scope.userLocation"] === undefined) {
            wx.authorize({
              scope: "scope.userLocation",
              success() {
                resolve(that.getLocalSetting());
              }
            });
          } else {
            wx.showModal({
              title: '请打开系统位置获取定位权限',
              success(res) {
                if (res.confirm) {
                  wx.openSetting({
                    complete() {}
                  })
                } else if (res.cancel) {}
              }
            })
            reject(false);
          }
        },
        fail(err) {
          reject(false);
        }
      });
    });
  }

  // 开始搜索蓝牙设备
  async startScan(callBack, boolean) {
    var that = this;
    if (!that.isAvailable) {
      wx.showToast({
        title: '请打开蓝牙',
        icon: 'none',
        duration: 2000
      });
      boolean(false);
      return;
    }

    var open = await that.getLocalSetting();
    if (!open) {
      wx.showToast({
        title: '请打开定位权限',
        icon: 'none',
        duration: 2000
      });
      boolean(false);
      return;
    }

    ///没有权限再获取
    if (!that.hasPermission) {
      var per = await that.getBluetoothPermission();
      if (!per) {
        wx.showToast({
          title: '请打开蓝牙权限',
          icon: 'none',
          duration: 2000
        });
        boolean(false);
        return;
      }
    }
    // services: ["ffc0", "ab00", "ffe5"],
    wx.startBluetoothDevicesDiscovery({
      allowDuplicatesKey: true,
      success: (res) => {
        if (res) {
          console.log("gadsfasdfqwerqwerdfasdfqr==000===");
          wx.onBluetoothDeviceFound((devicesRes) => {
            for (var i = 0; i < devicesRes.devices.length; i++) {
              if (devicesRes.devices[i].name != "") {
                if (devicesRes.devices[i].name === getApp().globalData.connectWillDevice.clientType) {
                  console.log("gadsfasdfqwerqwerdfasdfqr=====" + devicesRes.devices[i].name);
                  callBack(devicesRes.devices[i]);
                  break;
                }
              }
            }
          });
        }
      },
      fail: (err) => {
        if (err.errno == 1509008) {
          wx.showToast({
            title: '搜索蓝牙需要先开启定位权限',
            icon: 'none',
            duration: 2000
          });
        }
        boolean(false);
      }
    });
  }

  // 停止搜索
  stopSearch() {
    return new Promise((resolve, reject) => {
      wx.stopBluetoothDevicesDiscovery({
        success: (res) => {
          console.log('停止搜索成功:', res);
          resolve(res);
        },
        fail: (err) => {
          console.error('停止搜索失败:', err);
          reject(new Error('停止搜索失败'));
        }
      });
    });
  }

  ///获取已经连接过手机的设备
  async getAllOnlineDevices(callBack) {
    var that = this;
    if (!that.isAvailable) {
      setTimeout(() => {
        that.getAllOnlineDevices(callBack);
      }, 3 * 1000);
      return;
    }

    if (!that.hasPermission) {
      var per = await that.getBluetoothPermission();
      if (!per) {
        setTimeout(() => {
          that.getAllOnlineDevices(callBack);
        }, 3 * 1000);
        return;
      }
    }

    that.getConnectedDevices();
    wx.getBluetoothDevices({
      success: (res) => {
        // && res.devices.length > 0
        if (res) {
          callBack(res.devices);
        }
        setTimeout(() => {
          that.getAllOnlineDevices(callBack);
        }, 3 * 1000);
      },
      fail: (err) => {
        setTimeout(() => {
          that.getAllOnlineDevices();
        }, 3 * 1000);
      }
    });
  }

  // 获取已连接的蓝牙设备
  getConnectedDevices() {
    var that = this;
    if (!that.isAvailable && !that.hasPermission) {
      return [];
    }

    return new Promise((resolve, reject) => {
      wx.getConnectedBluetoothDevices({
        // services: ["FFC0", "ffc0", "FFC1", "FFC2", "ffc1", "ffc2", "AB00", "ab00", "AB01", "AB02", "FFF1", "fff1", "FFE2", "FFE5",],
        // services: ["ab00", "ffe5", "1111", "FFC0", "FFC1", "FFF1", ],
        // services: [],
        // services: [
        //     "0000ab00-0000-1000-8000-00805f9b34fb",
        //     "0000ffc0-0000-1000-8000-00805f9b34fb",
        //     "0000FFF0-0000-1000-8000-00805F9B34FB",
        //     "0000FFF1-0000-1000-8000-00805F9B34FB",
        //     "0000FFE5-0000-1000-8000-00805F9B34FB",
        // ],
        success: (res) => {
          console.log('已连接的蓝牙设备==11==:', newDevices);
          let newDevices = that.fiterDevice(res)
          console.log('已连接的蓝牙设备==22==:', newDevices);
          resolve(newDevices);
        },
        fail: (err) => {
          console.error('获取已连接的蓝牙设备失败:', err);
          reject([]);
        }
      });
    });
  }

  // 获取获取在蓝牙模块生效期间所有搜索到的蓝牙设备。包括已经和本机处于连接状态的设备。
  getAllConnectedDevices() {
    var that = this;
    if (!that.isAvailable && !that.hasPermission) {
      return [];
    }

    return new Promise((resolve, reject) => {
      wx.getBluetoothDevices({
        success: (res) => {
          let newDevices = that.fiterDevice(res)
          resolve(newDevices);
        },
        fail: (err) => {
          console.error('已扫描过的蓝牙设备失败:', err);
          reject([]);
        }
      });
    });
  }

  closeBle() {
    console.log('关闭蓝牙了')
    wx.closeBluetoothAdapter();
  }

  // 断开与指定设备的连接
  disconnect() {
    var that = this;
    let device = that.device ?? {};
    let deviceId = device.deviceId ?? ""
    if (deviceId.length === 0) {
      return;
    }
    return new Promise((resolve, reject) => {
      wx.closeBLEConnection({
        deviceId: that.device.deviceId ?? "",
        success: (res) => {
          that.device = null;
          console.log('断开连接成功:', res);
          resolve(res);
        },
        fail: (err) => {
          console.error('断开连接失败:', err);
          reject(new Error('断开连接失败'));
        }
      });
    });
  }

  // 发送数据到指定设备
  async sendData(data) {
    var that = this
    return new Promise((resolve, reject) => {
      var buffer = null;
      // todo 判断是否是buffer
      // if (Buffer.isBuffer(data)) {
      //     buffer = data;
      // } else {
      buffer = new ArrayBuffer(data.length);
      // 下面是赋值，不能删
      const dataView = new DataView(buffer);
      data.forEach((value, index) => {
        dataView.setUint8(index, value); // 将每个16进制数值写入到 buffer 中
      });
      // }

      console.log('开始发送数据:', data, buffer);
      wx.writeBLECharacteristicValue({
        deviceId: that.device.deviceId,
        serviceId: that.device.serviceId,
        characteristicId: that.device.characteristicId,
        value: buffer,
        success: (res) => {
          // console.log('数据发送成功:');
          resolve(res);
        },
        fail: (err) => {
          console.error('数据发送失败:', err);
          reject(new Error('数据发送失败'));
        }
      });
    });
  }

  // 监听发现新设备的事件
  onBluetoothDeviceFound(callback) {
    var that = this;
    wx.onBluetoothDeviceFound((res) => {
      let newDevices = that.fiterDevice(res)
      // that.devices.push(...devices);
      if (newDevices.length > 0) {
        // console.log('发现设备1:', res);
      }
      if (callback) {
        callback(newDevices);
      }
    });
  }
  getMac() {

  }
  ab2hex(buffer) {
    var hexArr = Array.prototype.map.call(
      new Uint8Array(buffer),
      function (bit) {
        return ('00' + bit.toString(16)).slice(-2)
      }
    )
    return hexArr.join(':');
  }
  fiterDevice(res) {
    var that = this;
    var devices = res.devices.filter(device => {
      const name = device.name || '';
      const localName = device.localName || '';
      let isNot = that.isNotEmpty(name) || that.isNotEmpty(localName);
      if (isNot) {
        // console.log('是猫王设备名称:', device.advertisData, device.serviceData)
        let mac = that.ab2hex(device.advertisData)
        // console.log(mac)
        device.mac = mac
      }
      return isNot
    });

    let newDevices = devices.map((device) => {
      let uuid = device.advertisServiceUUIDs[0] ?? ""
      return {
        deviceId: device.deviceId,
        name: device.name,
        localName: device.localName,
        uuid: uuid,
        mac: device.mac,
        connectable: device.connectable
      }
    });
    return newDevices
  }

  isNotEmpty(name) {
    let isNot = (name !== '' &&
      (name.startsWith("MW_") ||
        name.startsWith("MW-") ||
        // name.startsWith("猫王") ||
        // name.startsWith("妙播") ||
        // name.startsWith("AirSmart") ||
        name === "le")
    )
    // if (!isNot && name !== '') {
    //     console.log('不是猫王设备名称:', name)
    // }
    return isNot;
  }
  // 连接到指定设备
  async connectToDevice(device) {
    var that = this;
    return new Promise((resolve, reject) => {
      console.log("开始连接蓝牙：", device.deviceId)
      wx.createBLEConnection({
        deviceId: device.deviceId,
        success: (res) => {
          that.device = device
          console.log('连接成功:', res);
          resolve(true);
        },
        fail: (err) => {
          that.device = null
          console.error('连接失败:', err);
          resolve(false);
        }
      });
    });
  }

  // 发现服务
  discoverServices(deviceId) {
    var that = this;
    console.log('发现服务:', deviceId);
    return new Promise((resolve, reject) => {
      wx.getBLEDeviceServices({
        deviceId: deviceId,
        success: (res) => {
          // that.device.services = res.services;
          let service_id = "";
          for (let i = 0; i < res.services.length; i++) {
            if (res.services[i].uuid.toUpperCase().indexOf("AB00") != -1 ||
              res.services[i].uuid.toUpperCase().indexOf("FFC0") != -1
              // res.services[i].uuid.toUpperCase().indexOf("ae800") != -1
            ) {
              service_id = res.services[i].uuid;
              break;
            }
            console.log('发现服务1:', service_id);
            service_id = res.services[i].uuid;

          }
          that.device.serviceId = service_id;
          console.log('发现服务2:', service_id);

          resolve(service_id);
          // resolve(res.services);
        },
        fail: (err) => {
          that.device.serviceId = null;

          console.error('发现服务失败:', err);
          reject([]);
        }
      });
    });
  }

  // 发现特征值 read / write
  discoverCharacteristics(deviceId, serviceId) {
    var that = this;
    console.log('发现特征值:' + deviceId + " ,  " + serviceId);
    // if (deviceId !== that.device.deviceId) {
    //     console.log('设备id不匹配')
    //     return false
    // }
    return new Promise((resolve, reject) => {
      wx.getBLEDeviceCharacteristics({
        deviceId: deviceId,
        serviceId: serviceId,
        success: (res) => {
          // that.characteristics[serviceId] = res.characteristics;
          console.log('发现特征值2:', res);
          // that.device.characteristics = res.characteristics;
          resolve(res.characteristics);
        },
        fail: (err) => {
          that.device.characteristics = null;
          console.error('发现特征值失败:', err);
          reject("");
        }
      });
    });
  }

  // 读取特征值
  readCharacteristicValue(characteristicId) {
    var that = ths;
    console.log('开始读取特征值', characteristicId)
    return new Promise((resolve, reject) => {
      wx.readBLECharacteristicValue({
        deviceId: that.device.deviceId,
        serviceId: that.device.serviceId,
        characteristicId: characteristicId,
        success: (res) => {
          const name = that.parseBLEValue(res.value); // 解析读取到的值
          console.log('读取特征值成功:', name, res);
          resolve(res);
        },
        fail: (err) => {
          console.error('读取特征值失败:', err);
          reject("");
        }
      });
    });
  }
  // 解析读取到的设备名称
  parseBLEValue(buffer) {
    return String.fromCharCode.apply(null, new Uint8Array(buffer));
  }
  // 监听特征值变化
  notifyCharacteristicValueChange(characteristicId, callback) {
    var that = this;
    console.log('监听特征值变化:', characteristicId, that.device.deviceId, that.device.serviceId);
    wx.notifyBLECharacteristicValueChange({
      deviceId: that.device.deviceId, //设备mac   IOS和安卓系统不一样
      serviceId: that.device.serviceId, //服务通道，这里主要是notify
      characteristicId: characteristicId, //notify uuid
      state: true,
      success: function (res) {
        console.log("开启notify 成功")
        //TODO  onBLECharacteristicValueChange  监听特征值 设备的数据在这里获取到
        wx.onBLECharacteristicValueChange(function (characteristic) {
          let buffer = characteristic.value
          let dataView = new DataView(buffer)
          let dataResult = []
          for (let i = 0; i < dataView.byteLength; i++) {
            // console.log("0x" + dataView.getUint8(i).toString(16))
            // dataResult.push("0x" + dataView.getUint8(i).toString(16))
            dataResult.push(dataView.getUint8(i))
          }
          const result = dataResult
          console.log("拿到的数据：", result)

          if (callback) {
            callback(result)
          }
        })
      },
      fail: function (res) {
        console.log("订阅特征失败：", res)
      }
    })
  }

  setWrite(wirte, characteristicId) {
    var that = this;
    console.log('写入特征值:', characteristicId)
    // that.device.wirte = wirte
    that.device.characteristicId = characteristicId;
  }
}
// const ble = new bleManager();

// 导出 bleManager 类
module.exports = bleManager;

// wx.getSetting({
//   success(res) {
//     if (res.authSetting["scope.userFuzzyLocation"]) {
//       // 成功
//       // that.getBluetoothStatus();
//       console.log("有定位权限")
//       resolve(true);
//     } else if (res.authSetting["scope.userFuzzyLocation"] === undefined) {
//       wx.authorize({
//         scope: "scope.userFuzzyLocation",
//         success() {
//           console.log("再次获取定位权限")
//           resolve(that.getSetting());
//         }
//       });
//     } else {
//       wx.showModal({
//         title: '请打开系统位置获取定位权限',
//         success(res) {
//           if (res.confirm) {
//             console.log('用户点击确定')
//             wx.openSetting({
//               complete() {
//                 // that.getSetting();
//                 // resolve(that.getSetting());
//               }
//             })
//           } else if (res.cancel) {
//             console.log('用户点击取消');
//           }
//         }
//       })
//       console.log("没有有定位权限")
//       reject(false);
//     }
//   }
// })