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

"use strict";
var _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (e) {
  return typeof e
}
  : function (e) {
    return e && "function" == typeof Symbol && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e
  }
  , _kcService = require("./kcService.js")
  , _kcService2 = _interopRequireDefault(_kcService)
  , _kcUtils = require("./kcUtils.js")
  , _kcUtils2 = _interopRequireDefault(_kcUtils)
  , _kcDataDecode = require("./kcDataDecode.js")
  , _kcDataDecode2 = _interopRequireDefault(_kcDataDecode);
function _interopRequireDefault(e) {
  return e && e.__esModule ? e : {
    default: e
  }
}
var TAG_FUNCTION = "function"
  , sendCallback = void 0
  , TimerID = null;
function _StartSendData(o, e) {
  var s = {}
    , u = 0
    , c = 0;
  null != TimerID && (clearTimeout(TimerID),
    TimerID = null),
    _kcDataDecode2.default.init(),
    TimerID = setTimeout(pro_timeout, 10000),
    console.log(TimerID, "开启时钟"),
    sendCallback = e,
    _kcService2.default._SetDataListenerCallBack(!0, datacallback),
    function t() {
      var e = "";
      40 * c >= o[u].length && (u++,
        c = 0);
      u < o.length && (e = o[u].length >= 40 * (c + 1) ? o[u].substring(40 * c, 40 * (c + 1)) : o[u].substring(40 * c, o[u].length));
      if ("" == e)
        console.log("数据发送完毕！");
      else {
        for (var a = _kcUtils2.default.hexStr2byteArray(e), l = new ArrayBuffer(a.byteLength), r = new DataView(l), i = 0; i < a.byteLength; i++)
          r.setUint8(i, a[i]);
        console.log("发送数据：", e),
          _kcService2.default._writeBLECharacteristicValue(l, function (e) {
            0 == e.serviceCode ? (c++,
              t()) : (console.error(TimerID, "数据发送失败，取消时钟"),
                null != TimerID && (clearTimeout(TimerID),
                  TimerID = null),
                _kcService2.default._SetDataListenerCallBack(!1),
                s.serviceCode = -2,
                s.serviceInfo = "数据发送失败",
                (void 0 === sendCallback ? "undefined" : _typeof(sendCallback)) == TAG_FUNCTION && sendCallback(s))
          })
      }
    }()
}
function datacallback(e) {
  _kcService2.default._SetDataListenerCallBack(!0, datacallback),
    _ReceiveData(e)
}
function pro_timeout() {
  var e = {};
  console.error(TimerID, "数据接收超时，取消时钟"),
    null != TimerID && (clearTimeout(TimerID),
      TimerID = null),
    _kcService2.default._SetDataListenerCallBack(!1),
    e.serviceCode = -3,
    e.serviceInfo = "数据接收超时",
    (void 0 === sendCallback ? "undefined" : _typeof(sendCallback)) == TAG_FUNCTION && sendCallback(e)
}
function _ReceiveData(receivedData) {
  // 获取协议类型并解码数据
  const protocolType = _kcUtils2.default.getProtocolType();
  let decodedData = {};
  // 根据协议类型解码数据
  if (protocolType === 0) {
    decodedData = _kcDataDecode2.default.decode_GB(receivedData); // 国标协议解码
  } else if (protocolType === 1) {
    decodedData = _kcDataDecode2.default.decode_WX(receivedData); // 微信协议解码
  }
  // 处理解码结果
  if (decodedData.serviceCode === 0) {
    try {
      // 解析业务数据并处理
      const parsedData = PackageDecode(decodedData.serviceData.strData);
      // 统一清理资源
      cleanupResources();
      // 构造标准响应格式
      const response = {
        serviceCode: parsedData.serviceCode,
        serviceInfo: parsedData.serviceInfo,
        serviceData: parsedData.serviceData
      };
      // 触发回调
      triggerCallback(response);
    } catch (error) {
      handleParseError(error);
    }
  }
}
// 辅助函数：资源清理
function cleanupResources() {
  if (TimerID) {
    clearTimeout(TimerID);
    TimerID = null;
  }
  _kcService2.default._SetDataListenerCallBack(false);
}
// 辅助函数：触发回调
function triggerCallback(response) {
  if (typeof sendCallback === "function") {
    sendCallback(response);
  }
}
// 辅助函数：处理解析异常
function handleParseError(error) {
  console.error("PackageDecode 异常:", error);
  const errorResponse = {
    serviceCode: -99,
    serviceInfo: "业务数据解析异常",
    serviceData: {}
  };
  cleanupResources();
  triggerCallback(errorResponse);
}
function PackageDecode(hexData) {
  let responseData = {
    serviceCode: 0,
    serviceInfo: "数据接收成功",
    serviceData: {}
  };
  try {
    const byteArray = _kcUtils2.default.hexStr2byteArray(hexData);
    const operationType = byteArray[0];
    console.log("kcPackageDecode：", hexData);
    console.log("操作类型", operationType);
    // 根据操作类型分发处理
    switch (operationType) {
      case 0xB3:
      case 0xBC:
        handleB3BCCommand(byteArray, responseData);
        break;
      case 0xB5:
        // 处理 181 类型 优化后的双字节小端解析方案
        handleB5Command(byteArray, responseData);
        break;
      case 0xBE:
        // 处理 190 类型
        responseData.serviceData.dataBuff = hexData.slice(-2);
        break;
      case 0xF7:
        handleF7Command(byteArray, responseData);
        break;
      case 0x92:
      case 0xB0:
      case 0xB4:
        handleCommonCommands(byteArray, responseData);
        break;
      case 0x90:
      case 0x91:
      case 0x94:
        // 处理 145, 148, 144 类型
        let dataLength = (255 & byteArray[3]) << 8;
        dataLength += byteArray[2];
        responseData.serviceData.dataBuff = extractData(byteArray, 4, dataLength);
        console.log("有效数据长度：", dataLength, response.serviceData.dataBuff);
        break;
      default:
        throw new Error(`未知操作类型: 0x${operationType.toString(16)}`);
    }
    return responseData;
  } catch (error) {
    console.error("PackageDecode 核心异常:", error);
    return {
      serviceCode: -99,
      serviceInfo: "业务数据解析异常",
      serviceData: {}
    };
  }
}
function handleCommonCommands(byteArray, response) {
  const resultCode = byteArray[1];
  if (resultCode !== 0) {
    console.error(`结果码异常: 0x${resultCode.toString(16)}`);
    throw new Error(`结果码异常: 0x${resultCode.toString(16)}`);
  }
  parseVariableLengthData(byteArray, response);
}
// 子处理器：通用指令（0xB3/0xBC）
function handleB3BCCommand(byteArray, response) {
  const resultCode = byteArray[1];
  if (resultCode !== 0) {
    response.serviceCode = -5;  // 按照黔通的要求，这个返回值有特殊含义。
    console.warn(`结果码错误: 0x${resultCode.toString(16)}`);
    if (byteArray.length <= 5) {
      response.serviceCode = -6;  // 按照黔通的要求，这个返回值有特殊含义。
      console.error("kc指令响应报文长度异常");
      throw new Error(`指令响应报文长度异常: ${byteArray.length}`);
    }
  }
  parseVariableLengthData(byteArray, response);
}
// 子处理器：双字节长度指令（0xB5）
function handleB5Command(byteArray, response) {
  try {
    const lengthOffset = 2;
    const hasEnoughBytes = byteArray.length >= lengthOffset + 2;
    if (!hasEnoughBytes) {
      throw new Error("数据长度不足，无法读取双字节指令长度");
    }
    // 小端法解析（低字节在前）
    const lowByte = byteArray[lengthOffset] & 0xFF;     // 低字节
    const highByte = byteArray[lengthOffset + 1] & 0xFF; // 高字节
    let instructionLength = (highByte << 8) | lowByte;
    // 长度有效性验证
    if (instructionLength > byteArray.length - lengthOffset - 2) {
      console.warn("双字节指令长度超出数据范围，回退单字节模式");
      throw new RangeError("指令长度溢出");
    }
    // 正常处理流程
    const dataSlice = byteArray.slice(lengthOffset + 2, lengthOffset + 2 + instructionLength);
    console.log("kc有效数据长度（双字节）：", instructionLength);
    response.serviceData.dataBuff = _kcUtils2.default.byteArray2hexStr(dataSlice);
  } catch (error) {
    if (error instanceof RangeError) {
      // 回退到单字节模式
      const singleByteLength = byteArray[2] & 0xFF;
      const fallbackData = byteArray.slice(3, 3 + singleByteLength);
      console.log("kc有效数据长度（单字节）：", singleByteLength);
      response.serviceData.dataBuff = _kcUtils2.default.byteArray2hexStr(fallbackData);
    } else {
      // 重新抛出非RangeError异常
      throw error;
    }
  }
}
// 子处理器：F7类型指令
function handleF7Command(byteArray, response) {
  const status = byteArray[1];
  if (status !== 0) {
    throw new Error(`F7指令状态错误: ${status}`);
  }
  const length = byteArray[2];
  const dataSlice = byteArray.slice(3, 3 + length);
  response.serviceData.dataBuff = _kcUtils2.default.byteArray2hexStr(dataSlice);
}
// 通用可变长度数据解析
function parseVariableLengthData(byteArray, response) {
  const dataType = _kcUtils2.default.getDATA_TYPE();
  if (dataType === 0) {
    // GB协议解析逻辑
    parseGBProtocol(byteArray, response);
  } else if (dataType === 1) {
    // WX协议解析逻辑
    parseWXProtocol(byteArray, response);
  } else {
    throw new Error(`未知DATA_TYPE: ${dataType}`);
  }
}
// 统一数据提取逻辑
function extractData(byteArray, start, length) {
  const end = start + length;
  return _kcUtils2.default.byteArray2hexStr(byteArray.slice(start, end));
}
// 子处理器：GB协议解析
function parseGBProtocol(byteArray, response) {
  // 初始偏移量为 7
  let dataStart = 7;
  let dataLength = 0;
  // 根据字节数组特定位置的值，计算有效数据长度 l
  if (129 == byteArray[5]) {
    if (129 == byteArray[6]) {
      dataLength = 255 & byteArray[7];
      dataStart += 1;
    } else if (130 == byteArray[6]) {
      dataLength = byteArray[7] << 8;
      dataLength += 255 & byteArray[8];
      dataStart += 2;
    } else {
      dataLength = 255 & byteArray[6];
    }
  }
  // 从字节数组中提取有效数据
  const dataEnd = dataStart + dataLength;
  response.serviceData.dataBuff = _kcUtils2.default.byteArray2hexStr(byteArray.slice(dataStart, dataEnd));
}
// 子处理器：WX协议解析
function parseWXProtocol(byteArray, response) {
  const apduData = byteArray.slice(5);
  const tpduData = _kcUtils2.default.APDU2TPDU(
    _kcUtils2.default.byteArray2hexStr(apduData)
  );
  response.serviceData.dataBuff = tpduData;
}
module.exports = {
  _StartSendData: _StartSendData,
  _ReceiveData: _ReceiveData
};