@jiabaida/tools 1.0.0 → 1.0.2

package/src/core/Transfer.js

@@ -0,0 +1,516 @@
+import { getOS } from './commonfun';
+
+const zhHansReg = /[\u4E00-\u9FA5]/;
+
+export const Transfer = {
+  // 十六进制字符串转二进制
+  hexStringToBinary(hexString) {
+    const decimalNumber = parseInt(hexString, 16);
+    const binaryString = decimalNumber.toString(2);
+    return binaryString;
+  },
+  // 循环遍历给定的数组 arr 中的每一项，并且检查该项中是否有一个键 key 的值等于给定的值 val。如果找到了这样的项，则返回该项在数组中的索引 i，否则返回 -1。去重
+  inArray(arr, key, val) {
+    for (let i = 0; i < arr.length; i++) {
+      if (arr[i][key] === val) {
+        return i;
+      }
+    }
+    return -1;
+  },
+  // 十进制转十六进制
+  decimalToHex(decimal, padding = 2) {
+    const hexDigits = [];
+    const hexMap = {
+      10: 'A',
+      11: 'B',
+      12: 'C',
+      13: 'D',
+      14: 'E',
+      15: 'F',
+    };
+
+    while (decimal > 0) {
+      const remainder = decimal % 16;
+      if (remainder >= 10) {
+        hexDigits.unshift(hexMap[remainder]);
+      } else {
+        hexDigits.unshift(`${remainder}`);
+      }
+      decimal = Math.floor(decimal / 16);
+    }
+
+    const hex = hexDigits.join('').padStart(padding, '0');
+    return hex;
+  },
+  decimalToHexArray(decimal, padding = 2) {
+    const inputHex = this.decimalToHex(decimal, padding);
+    const data = [('0' + inputHex.slice(-4, -2)).slice(-2), ('0' + inputHex.slice(-2)).slice(-2)].map((o) => `0x${o}`);
+    return data;
+  },
+  // 十六进制转十进制
+  hexToDecimal(hex) {
+    let decimal = 0;
+    const hexMap = {
+      A: 10,
+      B: 11,
+      C: 12,
+      D: 13,
+      E: 14,
+      F: 15,
+    };
+
+    for (let i = 0; i < hex.length; i++) {
+      const currentDigit = hex[i];
+      if (hexMap.hasOwnProperty(currentDigit)) {
+        decimal = decimal * 16 + hexMap[currentDigit];
+      } else {
+        decimal = decimal * 16 + parseFloat(currentDigit, 16);
+      }
+    }
+
+    return decimal;
+  },
+  // ArrayBuffer转16进制字符串
+  arrayBufferToHex(arrayBuffer) {
+    return this.arrayBufferToHexArray(arrayBuffer, false).join('');
+  },
+  // ArrayBuffer转16进制数组
+  arrayBufferToHexArray(arrayBuffer, withPrefix = true) {
+    return Array.prototype.map.call(new Uint8Array(arrayBuffer), (x) => {
+      let hex = ('00' + x.toString(16)).slice(-2);
+      return withPrefix ? `0x${hex}` : hex;
+    });
+  },
+  // 判断数组数据是否重复
+  areArraysEqual(arr1, arr2) {
+    if (arr1.length !== arr2.length) {
+      return false;
+    }
+    return arr1.every((value, index) => value === arr2[index]);
+  },
+  // 取ascii码转十六进制
+  convertASCIItoHex(asciiVal) {
+    let asciiCode = asciiVal.charCodeAt(0);
+    let hexValue = this.decimalToHex(asciiCode);
+    return hexValue;
+  },
+  // 获取参数指令校验位 为数据段内容+长度字节+状态码字节的校验和然后在取反加1
+  getParamCheck(content) {
+    // 命令码+数据长度
+    // let sum = (content[0] & 0x0ff) + (content[1] & 0x0ff);
+    let sum = 0;
+    for (let i = 0; i < content.length; i++) {
+      sum = sum + (content[i] & 0x0ff);
+    }
+    sum = sum ^ 0xffff;
+    // 此为十进制数据
+    sum = sum + 1;
+    // 转为十六进制 并拆分为两个字节
+    sum = this.decimalToHex(sum);
+    let check1 = sum.substr(0, 2);
+    let check2 = sum.substr(2, 2);
+
+    return { check1: '0x' + check1, check2: '0x' + check2 };
+  },
+  // 将一个数字分隔为数组，每个元素表示两位的十六进制数
+  splitNumberToHexArray(decimalNumber) {
+    // 转换为十六进制并转为字符串
+    let hexString = decimalNumber.toString(16);
+    // 补零至偶数长度
+    hexString = hexString.length % 2 === 0 ? hexString : '0' + hexString;
+    // 分隔为两位一组的数组
+    let hexArray = hexString.match(/.{1,2}/g);
+    // 补零，确保结果数组有两个元素
+    while (hexArray.length < 2) {
+      hexArray.unshift('00');
+    }
+    // 添加 '0x' 前缀
+    return hexArray.map((hex) => '0x' + hex);
+  },
+  /**
+   *
+   * @param {string} base64
+   * @param {bool} withPrefix If ture returns a 0x prefix. Default as True.
+   * @returns {Array} Hex array
+   */
+  base64ToHexArray(base64, withPrefix = true) {
+    const arrayBuffer = uni.base64ToArrayBuffer(base64);
+    return this.arrayBufferToHexArray(arrayBuffer, withPrefix);
+  },
+  // 十进制数字转2byte的十六进制数组
+  decimalToTwoByteHexArray(decimal) {
+    let f = `00${decimal >> 8}`.slice(-2);
+    let e = `00${(decimal & 0xff).toString(16)}`.slice(-2);
+    return [`0x${f}`, `0x${e}`];
+  },
+  // 字符串转换为十六进制数组
+  stringToHexArray(str) {
+    const hexArray = [];
+    for (let i = 0; i < str.length; i++) {
+      let charCode = str.charCodeAt(i).toString(16);
+      charCode = charCode.length === 1 ? '0' + charCode : charCode;
+      hexArray.push(charCode);
+    }
+    return hexArray;
+  },
+  // 获取校验位的值
+  getAtValueCheck(cmdCode, lengthCode, hexArray) {
+    // 将十六进制转为十进制取和
+    let sum = 0;
+    hexArray.forEach((hexValue) => {
+      sum += parseInt(hexValue, 16);
+    });
+    let codeHex = this.getCheck(cmdCode, lengthCode, sum);
+    return codeHex;
+  },
+  // 获取at指令的check值
+  getCheck(cmdCode, lengthCode, sum) {
+    // 转为十进制 取和
+    let checkSum = this.hexToDecimal(cmdCode) + this.hexToDecimal(lengthCode) + sum;
+    // 转为带0x的十六进制
+    let codeHex = '0x' + this.decimalToHex(checkSum);
+    // 取低8位
+    codeHex = codeHex & 0xff;
+    // 转为十六进制 即为check值
+    return '0x' + this.decimalToHex(codeHex);
+  },
+  // 将HexArray转成Module指定格式的ArrayBuffer
+  hexArrayToModuleArrayBuffer(fields, hexArray, withCheck = true, withPrefix = true) {
+    const fieldsLength = fields.length; //e.g [0xff, 0xaa, 0x80]: 包头(2Byte)  指令码(1Byte)
+    let offset = fieldsLength + 1; // +1 for data length
+    if (withCheck) offset++; // check
+
+    let bufferLength = hexArray.length + offset;
+    const buffer = new ArrayBuffer(bufferLength);
+    const dataView = new DataView(buffer);
+    const lengthCode = this.decimalToHex(hexArray.length);
+
+    // 包头&指令码
+    fields.forEach((field, i) => {
+      dataView.setUint8(i, field);
+    });
+    // 数据位长度
+    dataView.setUint8(fieldsLength, '0x' + lengthCode);
+    // 数据位
+    let indexNum = fieldsLength + 1;
+    hexArray.forEach((el, index) => {
+      dataView.setUint8(indexNum, withPrefix ? '0x' + el : el);
+      indexNum += 1;
+    });
+    // 校验位
+    if (withCheck) {
+      const code = fields[2].toString(16); //
+      let check = this.getAtValueCheck(code, lengthCode, hexArray);
+      dataView.setUint8(bufferLength - 1, check);
+    }
+    return buffer;
+  },
+ 
+};
+function runPromiseInSequence(arr, input) {
+  return arr.reduce((promiseChain, currentFunction) => promiseChain.then(currentFunction), Promise.resolve(input));
+}
+const TAG = '[BLE_OTA]';
+const DELAY = 25;
+function myWrite({ deviceId, value, index }, succeed, fail) {
+  console.log(TAG, `即将${DELAY}毫秒后写入第 ${index} 个小包...`);
+  uni.writeBLECharacteristicValue({
+    deviceId,
+    serviceId: '0000FF00-0000-1000-8000-00805F9B34FB',
+    characteristicId: '0000FF02-0000-1000-8000-00805F9B34FB',
+    value,
+    writeType: 'writeNoResponse',
+    success: (res) => {
+      console.log(TAG, `写入第 ${index} 个小包 成功`);
+      succeed?.(JSON.stringify(res));
+    },
+    fail: (res) => {
+      console.log(TAG, `Error-写入第 ${index} 个小包 失败`, res);
+      fail?.(JSON.stringify(res));
+    },
+  });
+}
+function myWriteDelay(params) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      myWrite(
+        params,
+        (msg) => {
+          resolve({ succeed: true, msg });
+        },
+        (msg) => {
+          resolve({ succeed: false, msg });
+        }
+      );
+    }, DELAY);
+  });
+}
+export const BLE = {
+  serviceId: '0000FF00-0000-1000-8000-00805F9B34FB', //蓝牙特征值对应服务的 uuid
+  writeUUID: '0000FF02-0000-1000-8000-00805F9B34FB', //蓝牙特征值的 uuid
+  readUUID: '0000FF01-0000-1000-8000-00805F9B34FB',
+  TAG: '[BLE_OTA]',
+  WRITE_DELAY: 25,
+  PACKAGE_MAX_LENGTH: 240,
+  // 分包发送
+  sendMsgToKey(buffer, deviceId, fail) {
+    const { isAndroid, isIOS } = getOS();
+    // const writeType = isAndroid ? 'writeNoResponse' : 'write';
+    const writeType = 'writeNoResponse'; // 因IOS在小程序用write时会失败，统一使用无响应方式写入
+    console.log(TAG, `大包数据: Len=${buffer.byteLength} writeType=${writeType}`);
+    console.log(TAG, `写入中...`);
+    uni.writeBLECharacteristicValue({
+      deviceId,
+      serviceId: '0000FF00-0000-1000-8000-00805F9B34FB',
+      characteristicId: '0000FF02-0000-1000-8000-00805F9B34FB',
+      value: buffer,
+      writeType,
+      success: () => {
+        console.log(TAG, `写入成功`);
+      },
+      fail: (res) => {
+        console.log(TAG, `Error-写入失败`);
+        fail?.(JSON.stringify(res));
+      },
+    });
+    // if (isAndroid) {
+    //   console.log(TAG, `[Android] 写入中...`);
+    //   let promiseArr = [];
+    //   const offset = 255;
+    //   let bytes = buffer.byteLength;
+    //   const times = Math.ceil(bytes / offset);
+    //   for (let i = 1; i <= times; i++) {
+    //     (function (index) {
+    //       promiseArr.push(
+    //         ({ succeed, msg }) =>
+    //           new Promise(async (resolve, reject) => {
+    //             if (succeed) {
+    //               const value = buffer.slice((index - 1) * offset, index * offset);
+    //               console.log(TAG, '排队中...', index, `Len: ${value.byteLength}`);
+    //               const result = await myWriteDelay({ deviceId, value, index });
+    //               resolve(result);
+    //             } else {
+    //               resolve({ succeed, msg });
+    //             }
+    //           })
+    //       );
+    //     })(i);
+    //   }
+    //   console.log(TAG, '大包数据Promise: ', promiseArr.length);
+
+    //   runPromiseInSequence(promiseArr, { succeed: true, msg: 'init_value' }).then(({ succeed, msg }) => {
+    //     console.log(TAG, '--------队列执行结果: ', succeed);
+    //     if (succeed) {
+    //       console.log(TAG, '大包数据顺序发送 成功 ');
+    //     } else {
+    //       console.log(TAG, 'Error-大包数据顺序发送 失败 ', msg);
+    //       fail?.(msg);
+    //     }
+    //   });
+    // } else if (isIOS) {
+    //   console.log(TAG, `[IOS] 写入中...`);
+    //   uni.writeBLECharacteristicValue({
+    //     deviceId,
+    //     serviceId: '0000FF00-0000-1000-8000-00805F9B34FB',
+    //     characteristicId: '0000FF02-0000-1000-8000-00805F9B34FB',
+    //     value: buffer,
+    //     writeType: 'write',
+    //     success: () => {
+    //       console.log(TAG, `[IOS] 写入成功`);
+    //     },
+    //     fail: (res) => {
+    //       console.log(TAG, `[IOS] Error-写入失败`);
+    //       fail?.(JSON.stringify(res));
+    //     },
+    //   });
+    // }
+
+    // let _this = this;
+    // const offset = 20;
+    // let bytes = buffer.byteLength;
+    // let pos = 0;
+    // while (bytes > 0) {
+    //   let endPos = bytes > offset ? pos + offset : pos + bytes;
+    //   const tempBuffer = buffer.slice(pos, endPos);
+    //   pos += offset;
+    //   bytes -= offset;
+    //   // add delay to resolve 10007 error.
+    //   await _this.sendDelay(_this.WRITE_DELAY, tempBuffer).then((buffer) => {
+    //     _this.sendMsg(deviceId, buffer, fail);
+    //   });
+    // }
+  },
+  sendDelay(delay, buffer) {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => resolve(buffer), delay);
+    });
+  },
+  sendMsg(deviceId, value, fail) {
+    uni.writeBLECharacteristicValue({
+      deviceId,
+      serviceId: this.serviceId,
+      characteristicId: this.writeUUID,
+      value,
+      writeType: 'writeNoResponse',
+      success: (res) => {
+        console.log('[OTA] sendMsg succeed');
+      },
+      fail: (res) => {
+        console.error('[OTA] sendMsg failed', JSON.stringify(res));
+        fail?.(JSON.stringify(res));
+        // setTimeout(() => {
+        //   _this.sendMsg(_deviceId, _value);
+        // }, 15);
+      },
+    });
+  },
+  sendMsgDelay(delay, deviceId, value, fail) {
+    return new Promise((resolve, reject) => {
+      setTimeout(() => {
+        uni.writeBLECharacteristicValue({
+          deviceId,
+          serviceId: this.serviceId,
+          characteristicId: this.writeUUID,
+          value,
+          writeType: 'writeNoResponse',
+          success: (res) => {
+            // console.log('[OTA] sendMsg succeed');
+            resolve(true);
+          },
+          fail: (res) => {
+            console.error('[OTA] sendMsg failed', JSON.stringify(res));
+            resolve(false);
+          },
+        });
+      }, delay);
+    });
+  },
+  //
+  retryWarpper(asyncFunc, defaultRetryTime = 2, retryInterval = 20) {
+    let retryTime = defaultRetryTime;
+    const retryCallback = async function (...args) {
+      try {
+        return await asyncFunc(...args);
+      } catch (e) {
+        if (retryTime <= 0) throw e;
+        console.log(`写入失败，将在 ${retryInterval} 毫秒后重试，剩余重试次数 ${retryTime}`);
+        retryTime -= 1;
+        await new Promise((reslove) => setTimeout(reslove, retryInterval));
+        return await retryCallback(...args);
+      }
+    };
+    return retryCallback;
+  },
+  write(buffer, deviceId, delay = 20) {
+    console.log('write', deviceId, buffer.byteLength);
+    return new Promise((resolve, reject) =>
+      setTimeout(() => {
+        uni.writeBLECharacteristicValue({
+          deviceId,
+          serviceId: this.serviceId,
+          characteristicId: this.writeUUID,
+          value: buffer,
+          writeType: 'writeNoResponse',
+          success: (res) => {
+            resolve('ok');
+          },
+          fail: (res) => {
+            reject(JSON.stringify(res));
+          },
+        });
+      }, delay)
+    );
+  },
+  async loopSendMsg(buffer, deviceId, fail) {
+    console.log('loopSendMsg', deviceId, buffer.byteLength);
+    let _this = this;
+
+    const fetchDataWithRetry = _this.retryWarpper(_this.write);
+
+    const offset = 20;
+    let bytes = buffer.byteLength;
+    let pos = 0;
+    while (bytes > 0) {
+      let endPos = bytes > offset ? pos + offset : pos + bytes;
+      const tempBuffer = buffer.slice(pos, endPos);
+      pos += offset;
+      bytes -= offset;
+      // add delay to resolve 10007 error.
+      const res = await fetchDataWithRetry(tempBuffer, deviceId, _this.WRITE_DELAY).catch((e) => fail?.(e));
+      if (!res) {
+        break;
+      }
+    }
+  },
+  writeATCmd(atValue, deviceId, fail) {
+    const hexArray = Transfer.stringToHexArray(atValue + '\r\n');
+    let ab = Transfer.hexArrayToModuleArrayBuffer([0xff, 0xaa, 0x80], hexArray, true, true);
+    this.sendMsgToKey(ab, deviceId, fail);
+  },
+  transferFirmwareFileCmd(deviceId, hexArray, isEnd = false, fail) {
+    let ab = Transfer.hexArrayToModuleArrayBuffer([0xff, 0xaa, isEnd ? 0x51 : 0x50], hexArray, true, false);
+    this.sendMsgToKey(ab, deviceId, fail);
+  },
+  formatOTAContent(content) {
+    if (content != '') {
+      const [_otaInfo, otaStart, otaReStart] = content.split(';');
+      const [p1, p2, p3, filePath] = _otaInfo.split(',');
+      const otaInfo = _otaInfo.replace(filePath, 'local');
+      return { filePath, otaInfo, otaStart, otaReStart };
+    }
+    return null;
+  },
+};
+export class Observer {
+  constructor(exec) {
+    this.listeners = new Set();
+    exec({
+      next: (value) => this.listeners.forEach(({ next }) => next && next(value)),
+      error: (err) => this.listeners.forEach(({ error }) => error && error(err)),
+      complete: (value) => this.listeners.forEach(({ complete }) => complete && complete(value)),
+    });
+  }
+  subscribe(listeners) {
+    this.listeners.add(listeners);
+    return {
+      unsubscribe: () => this.listeners.delete(listeners),
+    };
+  }
+}
+
+export class Logger {
+  key;
+  temp;
+  constructor(key) {
+    this.key = key;
+    this.temp = {};
+  }
+  log(...args) {
+    console.log(this.key, '[OTA] ', ...args);
+  }
+  error(...args) {
+    console.error(this.key, '[OTA] ', ...args);
+  }
+  time(key) {
+    const obj = this.temp;
+    if (obj.hasOwnProperty(key)) {
+      this.error(`Timer '${key}' already exists`);
+    }
+    obj[key] = new Date().getTime();
+  }
+  timeEnd(key) {
+    const obj = this.temp;
+    if (!obj.hasOwnProperty(key)) {
+      this.error(`Timer '${key}' does not exist`);
+      return;
+    }
+    let s = obj[key];
+    let e = new Date().getTime();
+    this.log(`${key}: ${e - s}ms`);
+    delete obj[key];
+    return e - s;
+  }
+}
+
+export default Transfer;

package/src/core/array.js

@@ -0,0 +1,10 @@
+// 导出独立函数而非默认导出
+export const chunk = (array, size) => {
+  const chunks = [];
+  for (let i = 0; i < array.length; i += size) {
+    chunks.push(array.slice(i, i + size));
+  }
+  return chunks;
+};
+
+export const unique = (array) => [...new Set(array)];

package/src/core/commonfun.js

@@ -0,0 +1,87 @@
+
+export function isEmpty(v) {
+  return v === null || v === undefined || v === '';
+}
+export function isNotEmpty(v) {
+  return !isEmpty(v);
+}
+
+/**
+ * 检查数组中是否存在指定键值对
+ * @param {Array} arr - 要检查的数组
+ * @param {string} key - 要检查的键名
+ * @param {*} val - 要检查的键值
+ * @returns {number} - 如果找到匹配项，返回其索引；否则返回 -1
+ */
+export function inArray(arr, key, val) {
+  for (let i = 0; i < arr.length; i++) {
+    if (arr[i][key] === val) {
+      return i
+    }
+  }
+  return -1
+}
+export function formatTimeHHmm(hours) {
+  const hour = Math.floor(hours);
+  const minute = Math.floor((hours - hour) * 60);
+  // #ifdef H5
+  console.log('H5环境')
+  // #endif
+  return `${hour}H:${minute}m`;
+}
+
+export function getOS() {
+  const os = uni.getSystemInfoSync()?.osName;
+  return {
+    isIOS: os == 'ios',
+    isAndroid: os == 'android',
+  };
+}
+export function getPlatform() {
+  return uni.getSystemInfoSync()?.uniPlatform || '';
+}
+// #region 事件总线
+// 添加事件总线
+export const eventBus = {
+  events: {},
+  /**
+   * 订阅事件
+   * @param {string} event - 事件名称
+   * @param {function} callback - 回调函数
+   */
+  on(event, callback) {
+    if (!this.events[event]) {
+      this.events[event] = [];
+    }
+    this.events[event].push(callback);
+  },
+  /**
+   * 取消订阅
+   * @param {string} event - 事件名称
+   * @param {Function} [callback] - 可选，指定要移除的回调
+   */
+  off(event, callback) {
+    if (!this.events[event]) return;
+    if (!callback) {
+      // 移除事件所有订阅
+      delete this.events[event];
+      return;
+    }
+    // 只移除指定回调
+    this.events[event] = this.events[event].filter(cb => cb !== callback);
+    // 清空时删除事件
+    if (this.events[event].length === 0) {
+      delete this.events[event];
+    }
+  },
+  /**
+   * 触发事件
+   * @param {string} event - 事件名称
+   * @param {...any} args - 事件参数
+   */
+  emit(event, ...args) {
+    if (!this.events[event]) return;
+    this.events[event].forEach(callback => callback(...args));
+  }
+};
+