zhywpt-sp/static/etc/kcBle/kcDataDecode.js

"use strict";
import { findVarint } from './protoBuffer.js';
var iPackageLen, _kcUtils = require("./kcUtils.js"), _kcUtils2 = _interopRequireDefault(_kcUtils);
function _interopRequireDefault(t) {
  return t && t.__esModule ? t : {
    default: t
  }
}
var bleCount, rxCount = 0, strTemData = "", strRxBuffer = "", isPagFinish = true;
function decode_GB(t) {
  var e = 0
    , a = {}
    , t = _kcUtils2.default.byteArray2hexStr(t)
    , r = (_kcUtils2.default.showLog("kc当前接受包的数据:", t),
      _kcUtils2.default.hexStr2byteArray(t));
  if (1 < r.byteLength && 80 == r[0] && 1 == isPagFinish ? (isPagFinish = !1,
    iPackageLen = r[3],
    strTemData = t) : strTemData += t,
    strTemData.length / 2 >= iPackageLen + 5) {
    rxCount += 1,
      isPagFinish = !0;
    var s = _kcUtils2.default.hexStr2byteArray(strTemData);
    _kcUtils2.default.showLog("接受完第", rxCount, "包数据，内容 ", strTemData);
    for (var i = 0; i < iPackageLen + 4; i++)
      e ^= s[i];
    if (s[strTemData.length / 2 - 1] != e)
      return _kcUtils2.default.showError("kc第", rxCount, " 包校验bcc:Error!"),
        a.serviceCode = -1,
        a.serviceInfo = "校验错误。。。",
        a;
    128 == (128 & s[1]) && (bleCount = ((127 & s[1]) << 8) + s[2],
      _kcUtils2.default.showLog("总共:", bleCount, "大包")),
      _kcUtils2.default.showLog("kc第", rxCount, " 包校验bcc:ok!"),
      strRxBuffer += strTemData.substring(8, strTemData.length - 2)
  }
  return bleCount <= rxCount ? (a.serviceCode = 0,
    a.serviceInfo = "数据接收完成！",
    a.serviceData = {},
    a.serviceData.strData = strRxBuffer) : (a.serviceCode = 1,
      a.serviceInfo = "数据接收中。。。"),
    a
}

function decode_WX(inputData) {
  // 初始化变量
  var checksum = 0; // 校验变量
  var result = {}; // 返回的结果对象
  var hexString = _kcUtils2.default.byteArray2hexStr(inputData); // 将输入数据转换为16进制字符串
  var byteArray = _kcUtils2.default.hexStr2byteArray(hexString); // 转换为字节数组

  // 打印接收到的数据
  _kcUtils2.default.showLog("kc当前接受包的数据:", hexString);

  // 判断是否是大包开始
  if (
    byteArray.byteLength > 1 &&
    byteArray[0] === 254 && // 包头标识
    byteArray[1] === 1 &&  // 版本号
    isPagFinish === true   // 是否为分页结束
  ) {
    isPagFinish = false; // 标记分页未完成
    iPackageLen = ((255 & byteArray[2]) << 8) + (255 & byteArray[3]); // 计算大包总长度
    strTemData = hexString; // 保存当前数据
  } else {
    // 如果是数据的续传部分
    strTemData += hexString; // 累加数据
  }

  // 如果接收的数据长度已达到或超过大包长度
  if (strTemData.length / 2 >= iPackageLen) {
    console.log("大包长度：", iPackageLen, strTemData.length);
    isPagFinish = true; // 标记分页完成
    rxCount += 1; // 接收到的包计数+1

    // 解析接收到的完整数据
    const completeData = _kcUtils2.default.hexStr2byteArray(strTemData);

    // 初始化解析对象
    let parsedData = {};
    let index = 0;
    // 解析固定头部
    const headFields = [
      // 魔数
      { key: "MagicNumber", size: 1 },
      // 版本号
      { key: "Ver", size: 1 },
      // 长度
      { key: "Len", size: 2 },
      // 命令ID
      { key: "CmdId", size: 2 },
      // 序列号
      { key: "Seq", size: 2 }
    ];
    // 解析固定头部
    parsedData.FixHead = {};
    headFields.forEach(field => {
      if (field.size === 1) {
        parsedData.FixHead[field.key] = completeData[index];
        index += 1;
      } else {
        parsedData.FixHead[field.key] = (completeData[index] << 8) + completeData[index + 1];
        index += 2;
      }
    });

    // 解析 ProtoBuf 数据
    parsedData.ProtoBuf = {};
    parsedData.ProtoBuf.BaseRequest = {};
    parsedData.ProtoBuf.BaseRequest.Mark = strTemData.substr(2 * index, 2); // BaseRequest标记
    index++;

    // 解码 BaseRequest 数据长度
    var length = 0, shift = 0;
    while ((128 & completeData[index]) === 128) {
      length += (127 & completeData[index]) << (7 * shift);
      index++;
      shift++;
    }
    length += (127 & completeData[index]) << (7 * shift);
    index++;

    // 提取 BaseRequest 数据
    parsedData.ProtoBuf.BaseRequest.Data = strTemData.substr(2 * index, 2 * length);
    index += length;

    // 解析 Data 部分
    parsedData.ProtoBuf.Data = {};
    parsedData.ProtoBuf.Data.Mark = strTemData.substr(2 * index, 2); // Data标记
    index++;

    // 解码 Data 数据长度
    length = 0;
    shift = 0;
    const veLength = findVarint(completeData.slice(index, completeData.length));
    let tempLength = decodeVarint(veLength.varint);
    console.log("解码 Data 前：", completeData[index]);
    console.log("解码 Data index 前：", index);
    // 检查 length 是否超出范围
    if (index + tempLength > completeData.length) {
      veLength.endPos -= 1;
      veLength.varint = veLength.varint.slice(0, veLength.endPos);
      let tempVarint = encodeVarint(veLength.varint);
      length = decodeVarint(tempVarint);
      index += veLength.endPos;
    } else {
      while ((128 & completeData[index]) === 128) {
        length += (127 & completeData[index]) << (7 * shift);
        index++;
        shift++;
      }
      length += (127 & completeData[index]) << (7 * shift);
      index++;
    }
    console.log("解码 Data 后：", completeData[index]);
    console.log("解码 Data index 后：", index);

    // 提取 Data 数据
    parsedData.ProtoBuf.Data.Data = strTemData.substr(2 * index, 2 * length);
    index += length;

    // 解析 DataType 部分
    parsedData.ProtoBuf.DataType = {};
    parsedData.ProtoBuf.DataType.Mark = strTemData.substr(2 * index, 2); // DataType标记
    index++;

    // 解码 DataType 数据长度
    length = 0;
    shift = 0;
    while ((128 & completeData[index]) === 128) {
      length += (127 & completeData[index]) << (7 * shift);
      index++;
      shift++;
    }
    length += (127 & completeData[index]) << (7 * shift);
    index++;

    // 提取 Varint 数据
    parsedData.ProtoBuf.DataType.Varint = length;

    // 校验数据完整性
    var dataContent = _kcUtils2.default.hexStr2byteArray(parsedData.ProtoBuf.Data.Data);
    for (var i = 1; i < dataContent.byteLength - 1; i++) {
      checksum ^= dataContent[i]; // 计算校验和
    }

    if (dataContent[dataContent.byteLength - 1] !== checksum) {
      // 如果校验失败
      _kcUtils2.default.showError("kc第", rxCount, " 包校验bcc:Error!");
      result.serviceCode = -1;
      result.serviceInfo = "bcc 校验错误。。。";
      return result;
    }

    // 如果校验成功，解析大包信息
    if ((128 & dataContent[2]) === 128) {
      bleCount = 1 + (127 & dataContent[2]); // 总包数
      _kcUtils2.default.showLog("总共:", bleCount, "大包");
    }

    // 累加接收到的有效数据
    strRxBuffer += parsedData.ProtoBuf.Data.Data.substr(8, 2 * dataContent[3]);
    console.log("kc第", rxCount, " 包校验bcc:ok!");
    _kcUtils2.default.showLog("接受完第", rxCount, "大包数据，内容 ", strTemData);
  }

  // 判断是否所有包接收完成
  if (bleCount <= rxCount) {
    result.serviceCode = 0; // 数据接收完成
    result.serviceInfo = "数据接收完成！";
    result.serviceData = { strData: strRxBuffer }; // 返回接收的数据
  } else {
    result.serviceCode = 1; // 数据接收中
    result.serviceInfo = "数据接收中。。。";
  }

  return result;
}

function init() {
  rxCount = iPackageLen = 0,
    isPagFinish = !(strRxBuffer = strTemData = "")

}

/**
 * 对单个数值进行 Varint 编码
 * @param {number} val - 要编码的值
 * @returns {number[]} - 编码后的字节数组
 */
function encodeSingleValue(val) {
  const bytes = [];
  while (val >= 0x80) {
    // 提取低 7 位，加上最高位 1
    bytes.push((val & 0x7F) | 0x80);
    val >>= 7; // 右移 7 位
  }
  // 添加最后一个字节，最高位为 0
  bytes.push(val & 0x7F);
  return bytes;
}

/**
* 对单个值或 Uint8Array 进行 Varint 编码
* @param {number|Uint8Array} value - 要编码的值，可以是单个数值或 Uint8Array
* @returns {Uint8Array} - 编码后的字节流
*/
function encodeVarint(value) {
  // 如果是 Uint8Array 类型
  if (value instanceof Uint8Array) {
    const result = [];
    for (const v of value) {
      result.push(...encodeSingleValue(v)); // 对每个字节进行编码
    }
    return new Uint8Array(result); // 返回 Uint8Array 类型的结果
  }

  // 如果是单个值，直接编码
  if (typeof value === 'number') {
    return new Uint8Array(encodeSingleValue(value));
  }

  // 其他类型不支持，抛出错误
  throw new TypeError("Input must be a number or a Uint8Array.");
}

function encodeVarint1(value) {
  const bytes = [];
  while (value >= 0x80) {
    // 提取低 7 位，加上最高位 1
    bytes.push((value & 0x7F) | 0x80);
    value >>= 7; // 右移 7 位
  }
  // 添加最后一个字节，最高位为 0
  bytes.push(value & 0x7F);
  return bytes;
}

function decodeVarint(bytes) {
  let result = 0;
  let shift = 0;
  for (let i = 0; i < bytes.length; i++) {
    const byte = bytes[i];
    // 提取低 7 位并合成结果
    result |= (byte & 0x7F) << shift;
    // 如果最高位是 0，结束解码
    if ((byte & 0x80) === 0) {
      break;
    }
    shift += 7;
  }
  return result;
}

module.exports = {
  decode_GB: decode_GB,
  decode_WX: decode_WX,
  init: init
};