@jiabaida/tools 1.0.0 → 1.0.2

package/src/core/BleApiManager.js

@@ -0,0 +1,487 @@
+import { eventBus, getOS, inArray } from './commonfun'; // 导入eventBus
+import { ab2decimalArr } from './BleDataProcess';
+import { ref, reactive } from 'vue';
+const serviceId = '0000FF00-0000-1000-8000-00805F9B34FB';
+const UUID_READ = '0000FF01-0000-1000-8000-00805F9B34FB';
+const UUID_WRITE = '0000FF02-0000-1000-8000-00805F9B34FB';
+
+const bluetoothAdapterState = ref({
+  available: false,
+  discovering: false,
+});
+// #region 处理广播的设备信息
+/**
+ * 处理广播的设备信息
+ * @param {*} device 
+ * @returns 处理后的设备信息
+ */
+const enhanceDevice = (device) => {
+  const adv = device?.advertisData;
+  if (!adv) return null;
+  if (adv) {
+    const advHex = Array.prototype.map
+      .call(new Uint8Array(adv), (o) => ('00' + o.toString(16)).slice(-2))
+      .join('')
+      .toUpperCase();
+
+    let macAddr = advHex.slice(0, 12).toUpperCase();
+    let arr = macAddr.match(/(.{2})/g);
+    const flag = macAddr.slice(-4);
+    if (flag == 'C1A4' || flag == 'C2A5' || flag == 'C2A8') arr.reverse();
+    macAddr = arr.join(':');
+    device['hasFound'] = true;
+    const moduleType = advHex.slice(12, 16);
+    const soc = advHex.slice(16, 18);
+    const productType = advHex.slice(18, 20);
+    const protocolVersion = advHex.slice(20, 22);
+    const appkeyStatus = advHex.slice(22, 24);
+    const broadcastLen = advHex.length / 2;
+    const isNewAppKey = advHex.length >= 24  //内容长度大于24位则是新appkey蓝牙设备
+    device = { ...device, macAddr, moduleType, soc, productType, advHex, protocolVersion, appkeyStatus, broadcastLen, isNewAppKey };
+  }
+  return device;
+}
+// #region 初始化蓝牙
+/** 初始化蓝牙 */
+export const initBle = async () => {
+  const checkBluetoothStatus = async () => {
+    return new Promise((resolve, reject) => {
+      uni.openBluetoothAdapter({
+        success: async (res) => {
+          console.log('openBluetoothAdapter success', res);
+          resolve(res);
+          try {
+            // await startDevicesDiscovery(false);
+            // stopBluetoothDevicesDiscovery();
+            onBluetoothDeviceFound();
+            onBLECharacteristicValueChange();
+            onBLEConnectionStateChange();
+            onBluetoothAdapterStateChange()
+          } catch (error) {
+            console.log('error: ', error);
+            reject(error);
+          }
+        },
+        fail: (err) => {
+          console.log('openBluetoothAdapter fail', err);
+          reject(err);
+        },
+      });
+    });
+  };
+  const checkLocationStatus = async () => {
+    // 创建超时Promise
+    const timeoutPromise = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject(new Error('网络信号差或连接异常，请检查网络情况'));
+      }, 10000); // 10秒超时
+    });
+    // 创建位置获取Promise
+    const locationPromise = new Promise((resolve, reject) => {
+      uni.getLocation({
+        type: 'wgs84',
+        success: (res) => {
+          console.log('位置信息-----------', res);
+          resolve(res);
+        },
+        fail: (err) => {
+          console.log('位置信息err', err);
+          reject(err);
+        },
+      });
+    });
+    // 使用Promise.race实现超时控制
+    Promise.race([locationPromise, timeoutPromise])
+      .then((res) => {
+        // 成功获取位置信息
+        checkBluetoothStatus();
+      })
+      .catch((err) => {
+        console.log('位置获取失败或超时:', err);
+        Promise.reject({
+          code: 1,
+          // message: '请检查手机位置是否开启',
+        });
+      });
+  };
+  try {
+    const { isAndroid } = getOS();
+    if (isAndroid) {
+      checkLocationStatus();
+    } else {
+      checkBluetoothStatus();
+    }
+  } catch (error) {
+    console.error('初始化蓝牙失败:', error);
+    Promise.reject({
+      code: error.code || error.errCode || -1,
+    });
+  }
+};
+// #region 获取蓝牙适配器状态
+/** 获取蓝牙适配器状态 */
+export const getBluetoothAdapterState = async () => {
+  return new Promise((resolve, reject) => {
+    uni.getBluetoothAdapterState({
+      success: (res) => {
+        console.log('getBluetoothAdapterState success', res);
+        resolve(res);
+      },
+      fail: (err) => {
+        console.log('getBluetoothAdapterState fail', err);
+        reject(err);
+      },
+    });
+  });
+};
+// #region 开始搜索蓝牙设备
+/** 开始搜索蓝牙设备
+ * @param {boolean} allowDuplicatesKey 是否允许重复设备
+ * @returns
+ */
+export const startDevicesDiscovery = async (allowDuplicatesKey = true) => {
+  return new Promise((resolve, reject) => {
+    // if (!bluetoothAdapterState.value.available) {
+    //   reject(new Error('蓝牙适配器未开启'));
+    //   return;
+    // }
+    if (bluetoothAdapterState.value.discovering) {
+      reject(new Error('蓝牙设备搜索已在进行中'));
+      return;
+    }
+    uni.startBluetoothDevicesDiscovery({
+      services: [serviceId],
+      allowDuplicatesKey,
+      success: async (res) => {
+        console.log('广播设备 success', res);
+        resolve(res);
+      },
+      fail: (err) => {
+        console.log('广播设备 fail', err);
+        reject(err);
+      },
+    });
+  });
+};
+// #region 停止搜索蓝牙设备
+/**停止搜索蓝牙设备 */
+export const stopBluetoothDevicesDiscovery = async () => {
+  return new Promise((resolve, reject) => {
+    uni.stopBluetoothDevicesDiscovery({
+      success: (res) => {
+        console.log('停止广播设备 success', res);
+        resolve(res);
+      },
+      fail: (err) => {
+        console.log('停止广播设备 fail', err);
+        reject(err);
+      },
+      complete: (res) => {
+        console.log('停止广播设备 取消订阅');
+        eventBus.off('setBluetoothDeviceFound');
+      },
+    });
+  });
+};
+// #region 监听搜索到的设备列表
+/**监听搜索到的设备 */
+export const onBluetoothDeviceFound = async () => {
+  uni.onBluetoothDeviceFound((characteristic) => {
+    console.log('setBluetoothDeviceFound', characteristic);
+    const device = enhanceDevice(characteristic.devices[0]);
+    if (!device) return;
+    // 触发事件总线事件
+    eventBus.emit('setBluetoothDeviceFound', device);
+  });
+};
+// #region 处理搜索到的设备并监听
+/** 处理搜索到的设备并监听 */
+export const onFoundDevice = (callback) => {
+  eventBus.on('setBluetoothDeviceFound', callback);
+};
+
+
+// #region 监听蓝牙适配器状态变化
+/** 监听蓝牙适配器状态变化*/
+export const onBluetoothAdapterStateChange = async () => {
+  uni.onBluetoothAdapterStateChange((res) => {
+    console.log('onBluetoothAdapterStateChange监听蓝牙适配器变化', res);
+    bluetoothAdapterState.value = res;
+  });
+};
+
+
+
+// #region 监听蓝牙设备特征值变化
+/** 监听蓝牙设备特征值变化*/
+export const onBLECharacteristicValueChange = async () => {
+  uni.onBLECharacteristicValueChange((characteristic) => {
+    const decimalArr = ab2decimalArr(characteristic.value);
+    console.warn('decimalArr: 监听到的回复-------------------', decimalArr);
+    // 触发事件总线事件
+    eventBus.emit('setBleChangedCharacteristicValue', characteristic);
+  });
+};
+// #region 监听蓝牙设备连接状态变化
+/** 监听蓝牙设备连接状态变化*/
+export const onBLEConnectionStateChange = async () => {
+  uni.onBLEConnectionStateChange((characteristic) => {
+    console.log('onBLEConnectionStateChange', characteristic);
+    // 触发事件总线事件
+    eventBus.emit('setBleChangedConnectionState', characteristic);
+  });
+};
+
+// #region 处理搜索到的设备并监听
+/** 处理搜索到的设备并监听 */
+export const onBleChangedConnectionState = (callback) => {
+  eventBus.on('setBleChangedConnectionState', callback);
+};
+
+
+// #region 连接蓝牙设备
+/** 连接蓝牙设备 */
+export const createBLEConnection = async (deviceId, timeout = 10000) => {
+  return new Promise((resolve, reject) => {
+    console.log(deviceId, '点击的设备信息');
+    // 连接蓝牙
+    uni.createBLEConnection({
+      deviceId: deviceId,
+      timeout,
+      success: (res) => {
+        console.log(res, '连接成功');
+        resolve(true);
+      },
+      fail: (err) => {
+        console.log(err, 'Connection');
+        let code = err.code || err.errCode;
+        if (code == -1) {
+          resolve(true);
+        } else {
+          // 错误信息提示
+          reject(err);
+        }
+      },
+    });
+  });
+};
+const withRetry = async (asyncOperation, maxRetries = 20, retryInterval = 100, type) => {
+  return new Promise((resolve, reject) => {
+    let retryCount = 0;
+    const attempt = async () => {
+      try {
+        const result = await asyncOperation();
+        resolve(result);
+      } catch (error) {
+        if (retryCount >= maxRetries) {
+          reject(new Error(`${type}失败，${error.message} (已重试${maxRetries}次)`));
+          return;
+        }
+        retryCount++;
+        console.warn(`${type}失败，第${retryCount}次重试:`, error.message);
+        setTimeout(attempt, retryInterval);
+      }
+    };
+    attempt();
+  });
+};
+// #region 获取蓝牙服务
+/** 获取蓝牙服务 */
+export const getBLEDeviceServices = (deviceId) => {
+  // 使用通用重试函数封装操作
+  return withRetry(
+    async () => {
+      const res = await new Promise((resolve, reject) => {
+        uni.getBLEDeviceServices({
+          deviceId,
+          success: resolve,
+          fail: reject,
+        });
+      });
+      console.log('获取蓝牙服务成功:', res);
+      if (res.services.length === 0) {
+        throw new Error('未找到蓝牙服务');
+      }
+      // 假设我们需要获取第一个serviceId
+      await getBLEDeviceCharacteristics(deviceId);
+      return res.services;
+    },
+    20, // 最大重试次数
+    100,
+    '获取蓝牙服务'
+  ); // 重试间隔
+};
+// #region 获取蓝牙特征值
+/** 获取蓝牙特征值 */
+export const getBLEDeviceCharacteristics = async (deviceId) => {
+  // 使用通用重试函数封装操作
+  return withRetry(
+    async () => {
+      const res = await new Promise((resolve, reject) => {
+        uni.getBLEDeviceCharacteristics({
+          deviceId,
+          serviceId: serviceId,
+          success: resolve,
+          fail: reject,
+        });
+      });
+
+      console.log('获取特征值成功:', res);
+      return res.characteristics;
+    },
+    20, // 最大重试次数
+    100,
+    '获取蓝牙特征值'
+  ); // 重试间隔
+};
+// #region 订阅特征值
+/** 订阅特征值 */
+export const notify = async (deviceId) => {
+  return new Promise((resolve, reject) => {
+    uni.notifyBLECharacteristicValueChange({
+      deviceId,
+      serviceId: serviceId,
+      characteristicId: UUID_READ,
+      state: true,
+      success: (res) => {
+        console.log('订阅===========', res);
+        resolve(res);
+      },
+      fail: reject,
+    });
+  });
+};
+// #region 断开蓝牙连接
+/** 断开蓝牙连接 */
+export const disConnect = (deviceId) => {
+  return new Promise((resolve, reject) => {
+    uni.closeBLEConnection({
+      deviceId,
+      success: (res) => {
+        resolve(res);
+        console.log(res, '断开连接成功');
+      },
+      fail: (err) => {
+        reject(err);
+        console.log(err, 'err 断开连接');
+      },
+    });
+  });
+};
+// #region 连接蓝牙并获取服务特征订阅
+/** 连接蓝牙设备
+ * 获取特征值并订阅
+ * @param {string} deviceId 设备id
+ * @returns
+ */
+export const connectAsync = async (deviceId, timeout = 10000) => {
+  return new Promise(async (resolve, reject) => {
+    try {
+      await createBLEConnection(deviceId, timeout);
+      await getBLEDeviceServices(deviceId);
+      await notify(deviceId);
+      resolve(true);
+    } catch (error) {
+      console.log('error: ', error);
+      reject(error);
+    }
+  });
+};
+
+// #region 安卓扫码直连，苹果广播5秒
+/**
+ * 安卓扫码直连，苹果广播5秒
+ */
+export const scanHandle = (historyConnectedList = [], connectFn = (device) => { }) => {
+  // 调起条码扫描
+  uni.scanCode({
+    scanType: ['barCode', 'qrCode'],
+    success: async ({ result }) => {
+      console.log('扫描内容: ' + result);
+      let searchKey = result;
+      try {
+        // MAC地址格式化工具函数
+        const formatMacAddress = (mac) => {
+          return mac
+            .replace(/(.{2})/g, '$1:')
+            .slice(0, -1)
+            .toUpperCase();
+        };
+        // // 判断result是否为mac地址;
+        let isMac = false;
+        if (result.includes('?qrCodeInfo=')) {
+          searchKey = result.split('?qrCodeInfo=')[1];
+          // this.searchKey = result;
+          if (searchKey.includes(':')) {
+            searchKey = searchKey.slice(-17).toUpperCase();
+            isMac = true;
+          } else {
+            // 截取最后12位，每两位加一个冒号，去掉最后一个冒号
+            searchKey = searchKey.slice(-12);
+            searchKey = formatMacAddress(searchKey);
+            isMac = true;
+          }
+        } else {
+          if (result.length === 17 && result.includes(':')) {
+            searchKey = result.toUpperCase();
+            isMac = true;
+          } else if (result.length === 12) {
+            searchKey = formatMacAddress(result);
+            isMac = true;
+          }
+        }
+
+        const { isAndroid } = getOS();
+        // 检查历史连接列表是否已包含该设备
+        const matchedHistoryDevice = historyConnectedList.find((item) => item.macAddr == searchKey);
+        if (matchedHistoryDevice) {
+          connectFn(matchedHistoryDevice);
+          return;
+        }
+        // 安卓机且扫码内容是mac地址直连，苹果机广播五秒连接
+        if (isAndroid && isMac) {
+          connectFn({
+            deviceId: searchKey,
+            macAddr: searchKey,
+            name: searchKey,
+          });
+        } else {
+          foundScanDevice(searchKey, connectFn);
+        }
+      } catch (error) {
+        console.log(error);
+      }
+    },
+  });
+};
+// #region 广播5秒
+export const foundScanDevice = async (result, connectFn) => {
+  const deviceList = [];
+  await startDevicesDiscovery();
+  onFoundDevice((device) => {
+    deviceList.push(device)
+    const findDevice = device.macAddr === result || device.name === result;
+    if (findDevice) {
+      if (scanTimeout) {
+        clearTimeout(scanTimeout);
+        scanTimeout = null;
+      }
+      uni.stopBluetoothDevicesDiscovery();
+      connectFn(findDevice);
+    } else {
+      console.log('未找到设备，继续搜索中...');
+    }
+  })
+  let scanTimeout = setTimeout(async () => {
+    try {
+      // 五秒后停止搜索且关闭轮询器
+      console.log('stopBluetoothDevicesDiscovery', deviceList);
+      clearInterval(scanTimer);
+      scanTimer = null;
+      uni.stopBluetoothDevicesDiscovery();
+      const findDevice = deviceList.find((device) => device.macAddr === result || device.name === result);
+      connectFn(findDevice);
+    } finally {
+    }
+  }, 5000);
+};