mtl-js-sdk/lib/platforms/yyzone/rfid/index.js

ynf-fw-mtl-api

import { invokeSuccess, invokeFail } from '../callback'
import { handleMessage } from '../message'
import { requestPermission } from '../permission';
import { execUpesnBridgeify, canExecUpesnBridge } from '../bridge/index'

let isRunning = false;

export function rfidConnect(param = {}) {
  if (window.api?.systemType === 'ios') {
    return;
  }
  requestPermission({
    list: ['ble-scan', 'ble-ad', 'ble-connect'],
    success: function() {
      let { moduleName } = param;
      if (!moduleName) {
        moduleName = getModuleName();
      }
      const obj = window.api?.require(moduleName);
      if (!obj) {
        if (canExecUpesnBridge()) {
          execUpesnBridgeify('rfidConnect', {
            ...param
          });
          return;
        }
        invokeFail(param, { msg: `module ${moduleName} not added` });
        return;
      }
      if (moduleName === 'mtlUnis') {
        const name = window.api.getSystemInfoSync() || {}
        if (name.brand === 'alps') {

          obj.alpsRfidConnect();

          window?.api.addEventListener({
            name: 'resume'
          }, () => {
            obj.alpsRfidConnect();
          });

          window?.api.addEventListener({
            name: 'pause'
          }, () => {
            obj.alpsRfidDisconnect();
          });

          window?.api.addEventListener({
            name: 'keypress'
          }, (ret, err) => {
            if (ret && (ret.keyCode == 292 || ret.keyCode == 131)) {
              // 判断扳机状态
              if (ret.action == "up") {
                // 判断运行状态
                if (!isRunning) {
                  isRunning = true;
                  // 连接rfid
                  obj.startInventory((alpsRes) => {
                    if (alpsRes && alpsRes.status) {
                      let tags;
                      const { result } = alpsRes;
                      if (result) {
                        tags = [];
                        result.forEach((item) => {
                          tags.push(item.tagID);
                        });
                      }
                      const { callback } = param;
                      callback && handleMessage(callback, { tags });
                    } else {
                      invokeFail(param, { message: ret.message });
                    }
                  });
                } else {
                  isRunning = false;
                  obj.stopInventory();
                }
              }
            } else {
              isRunning = false;
              console.log('alpsRfidConnect err = ', err);
            }
          });
        } else {
          window?.api.addEventListener({
            name: 'keypress'
          }, (ret, err) => {
            if (ret && ret.keyCode === 288) { // 紫光rfid手柄按键
              if (ret.action === "down") {
                registerReaderCall(param, obj)
              } else if (ret.action === "up") {
                rfidDisconnect({ removeListener: false })
              }
            }
          });
        }
      } else {
        registerReaderCall(param, obj)
      }
    },
    fail: param.fail
  });
}

export function rfidDisconnect(param = {}) {
  if (window.api?.systemType === 'ios') {
    return;
  }

  let { moduleName } = param;
  if (!moduleName) {
    moduleName = getModuleName();
  }
  const obj = window.api?.require(moduleName);
  if (!obj) {
    if (canExecUpesnBridge()) {
      execUpesnBridgeify('rfidDisconnect', param);
      return;
    }
    invokeFail(param, { msg: `module ${moduleName} not added` });
    return;
  }
  obj.rfidDisconnect(param, (ret) => {
    if (ret) {
      invokeSuccess(param, {});
    } else {
      invokeFail(param, {});
    }
  });
  const { removeListener = true } = param
  if (removeListener && moduleName === 'mtlUnis') {
    window.api.removeEventListener({
      name: 'keypress'
    });
  }
}

export function startPDAScan(param = {}) {
  execPadScan('startPDAScan', {
    ...param, success: function(ret) {
      if (ret && ret.status) {
        const { callback } = param;
        callback && handleMessage(callback, ret, (res) => { });
      } else {
        invokeSuccess(param, ret)
      }
    }
  })
}

export function stopPDAScan(param = {}) {
  execPadScan('stopPDAScan', param, false)
  invokeSuccess(param, {});
}

function execPadScan(method, param, isFunction = true) {
  let { moduleName } = param;
  if (!moduleName) {
    moduleName = getModuleName(true);
  }
  const mtlPDA = window.api.require(moduleName);
  if (!mtlPDA) {
    if (window.api[method]) {
      window.api[method](param);
      return;
    }
    invokeFail(param, {
      msg: `module ${moduleName} not added`
    });
    return;
  }
  if (!isFunction) {
    mtlPDA[method]()
  } else {
    mtlPDA[method](param, (ret, err) => {
      if (ret) {
        invokeSuccess(param, ret)
      } else {
        invokeFail(param, err)
      }
    })
  }
}

function registerReaderCall(param = {}, obj) {
  obj.rfidConnect(param, (ret) => {
    if (ret && ret.status) {
      let tags;
      const { result } = ret;
      if (result) {
        tags = [];
        result.forEach((item) => {
          tags.push(item.tagID);
        });
      }
      const { callback } = param;
      callback && handleMessage(callback, { tags });
    } else {
      invokeFail(param, { message: ret.message });
    }
  });
}

function getModuleName(isPda = false) {
  const name = window.api.getSystemInfoSync() || {}
  if (name.brand === 'SUNMI' || name.brand === 'UNIS' || name.brand === 'alps') {
    const moduleName = 'mtlUnis';
    const mtlPDA = window.api.require(moduleName);
    if (mtlPDA) {
      return moduleName
    }
  }
  return isPda ? 'mtlPDA' : 'zebraRFID'
}