sony-ble/utils/mjs_wxble.js

import {handle} from "./mjs_handle";
import {buf2hex, hex2ab} from "./mjs_buffer";
class BLE{
  // 白名单设备id列表
  whiteList = [];
  nameList = [];
  useWhiteList = false;
  listenHandle = null;
  constructor(whiteList = [], nameList = []){
    // this代表实例对象
    this.isInit= false;
    whiteList = whiteList?whiteList:[];
    nameList = nameList?nameList:[];
    this.whiteList = whiteList;
    this.nameList = nameList;
    this.useWhiteList = whiteList.length > 0 || nameList.length > 0;
　}
  
  
  async initBle(option){
    let [err,ok] = await handle(wx.openBluetoothAdapter(option));
    if(err){
      throw err;
    }
    return 0
  }
  search(onSearchCallback){
    // wx.onBluetoothDeviceFound((res) => {
    //   res.devices.forEach((device) => {
    //     // 这里可以做一些过滤
    //     console.log('Device Found', device)
    //   })
    //   // 找到要搜索的设备后，及时停止扫描
    //   wx.stopBluetoothDevicesDiscovery()
    // })
    console.log("搜索蓝牙中：");
     setTimeout(() => {
      console.log("test");
    }, 2500);
    wx.onBluetoothDeviceFound((res)=> {
        let bleArray = res.devices;
        let advertisData = "",
          deviceId = "";
        let isAdd = false;
        //这里会收到周边搜索到的蓝牙
        console.log("\n\nfind devices ----");
        // console.log(res);
        console.log(res.devices);
        // 对
        for (let index = 0; index < bleArray.length; index++) {
          let ble = bleArray[index];
          isAdd = false;
          deviceId = buf2hex(ble.deviceId);
          // 特征值
          if(ble.advertisData) advertisData = ble.advertisData;
          // 判断是否有白名单
          if (this.useWhiteList  ){
            // 特征值检测
            isAdd = !!this.whiteList.find( codeStr => advertisData.startsWith(codeStr));
            // 设备名检测
            isAdd = !!this.nameList.find( codeStr => ble.name.startsWith(codeStr)) 
          }else{
            // 没有白名单,全部返回
            isAdd = true;
          }

          if(isAdd){
            console.log(`设备名:${ble.name} 设备id:${deviceId} 特征值:${advertisData}`);
            onSearchCallback({
              ...ble,
              hexAdvertisData: advertisData
            });
          }
          
        }
        // 防止检索漏掉设备
        // wx.getBluetoothDevices({complete:(res, err)=> {
        //   for (let i = 0; i < res.devices.length; i++) {
        //     let ble = res.devices[i];
        //     isAdd = false;
        //     if(ble.advertisData){
        //       advertisData = ble.advertisData;
        //     }
        //     if(this.useWhiteList){
        //       isAdd = !!this.nameList.find(nameStr=>ble.name.startsWith(nameStr));
        //       isAdd = !!this.whiteList.find(codeStr=>advertisData.startsWith(codeStr));
        //     }else{
        //       isAdd = true;
        //     }

        //     if(isAdd){
        //       console.log(`设备名:${ble.name} 设备id:${deviceId} 特征值:${advertisData}`);
        //       onSearchCallback({
        //         ...ble,
        //         hexAdvertisData: advertisData
        //       })
        //     }
        //   }
        // }});
    });
    wx.startBluetoothDevicesDiscovery({
      success(res) {
        console.log("开始搜索蓝牙：", res)
      },
      fail(res) {
        console.log(res)
      }
    })
  }
  onSearch(){
    console.log('on serarch');
  }
  async stopSearch(){
    let [err,res] = await handle(wx.stopBluetoothDevicesDiscovery());
    if(err){
      throw err;
    }
    return res;
  }
  connectDev(deviceId){
    return new Promise((resolve,reject)=>{
      console.log(`连接到:${deviceId}`);
      wx.createBLEConnection({
        deviceId:deviceId,
        success:function(res){
          resolve(res);
        },
        fail:function(err){
            console.error(err);
            reject(err);
        }
      })
    })
  }
  // 获取蓝牙服务
  getBleServices(devId){
    let self = this;
    console.log(`获取蓝牙[ ${devId} ]的服务`);
    return new Promise((resolve,reject)=>{

      wx.getBLEDeviceServices({
        //蓝牙设备ID
        deviceId: devId,
        success: async function (res) {
          let services = res.services;
          console.log(services)
          for (let i = 0; i < services.length; i++) {
            console.log(services[i].uuid);
            let [err,res] = await handle(self.getServerCharacteristics(devId,services[i].uuid));
            if(err){
              console.log(`获取服务特征值失败 服务id:${services[i].uuid}`);
              return reject(err);
            }
            services[i].characteristics = res;
          }
          console.log('--------');
          resolve(services);
         //获取蓝牙设备服务UUID成功
        },
        fail(res) {
          //获取蓝牙设备服务失败
          reject(res);
        }
    })
    
    })
  }

  // 获取蓝牙服务特征值
  getServerCharacteristics(devId,bleServiceUUID){
    let self = this;
    return new Promise((resolve,reject)=>{
      wx.getBLEDeviceCharacteristics({
        //蓝牙设备ID
        deviceId: devId,
        //蓝牙服务ID
        serviceId: bleServiceUUID,
        success: function (res) {
          console.log(res);
          res.characteristics.forEach(async c=>{
            // console.log(c);
            if(c.properties.notify){
              console.log(`监听${bleServiceUUID}的${c.uuid.substr(0,8)}`);
              let [err,res] = await handle(self.listenData(devId,bleServiceUUID,c.uuid));
              if(err){
                console.error(err);
                console.log(`添加监听${bleServiceUUID}的${c.uuid.substr(0,8)}失败`);
              }
              console.log(res);
            }
          })
          resolve(res.characteristics);
        },
        fail(err){
          reject(err);
        }
      });
    });
  }

  // 向指定特征发送数据
  sendData(devId, serviceId,characteristicId, hexStr){
    console.log(`向${devId}的${serviceId}的${characteristicId}发送数据`);
    console.log(hexStr);
    hexStr = hex2ab(hexStr);
    console.log(hexStr);
    return new Promise((resolve,reject)=>{
      wx.writeBLECharacteristicValue({
          //蓝牙设备ID
          deviceId: devId,
          //蓝牙服务ID
          serviceId: serviceId,
          //写特征值ID
          characteristicId: characteristicId,
          //数据ArrayBuffer
          value: hexStr,
          success(res) {
            //发送蓝牙数据成功
            resolve(res);
          },
          fail(res) {
            //发送蓝牙数据失败
            reject(res);
          }
      })
    })
    
  }
  // 监听数据
  listenData(devId,serviceId,uuid){
    return new Promise((resolve,reject)=>{
      wx.notifyBLECharacteristicValueChange({
        state: true,
        //蓝牙设备ID
        deviceId: devId,
        //蓝牙服务ID
        serviceId: serviceId,
        //特征值ID
        characteristicId: uuid,
        success: (res) => {
          //开启通知成功
          wx.onBLECharacteristicValueChange((_res)=> {
            //这里坐等数据过来,res.value
            console.log('got data ');
            console.log(_res);
            console.log(buf2hex(_res.value));
            console.log('got data ');
            if(listenHandle){
              listenHandle(buf2hex(_res.value));
            }
          })
          resolve(res);
        },
        fail: function (res) {
          //开启通知失败
          reject(res);
        }
      });
    })
  }
  registerListenerHandle(cb){
    listenHandle = cb;
  }
  // 断开与设备的连接
  disconnectDev(devId){
    return new Promise((resolve,reject)=>{
      wx.closeBLEConnection({
        deviceId: devId,
        success(res) {
          resolve(res);
        },
        fail(err){
          reject(err);
        }
      })
    })
  }
}

export default BLE;