refactor(nfc): 重构 NFC 读写助手类并优化相关功能

zuoxiao

5 天以前 548dce0bcff06ee7a1795defe8e7789b9d7aad94

 baselibrary/src/main/java/com/dayu/baselibrary/tools/HexUtil.java

@@ -3,6 +3,7 @@
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
@@ -29,8 +30,56 @@
        hexString = HighLowHex(hexString);
        return hexString;
    }


    /**
     * 16进制转10进制并且低位在前高位在后
     *
     * @param data
     * @return
     */
    public static int get16To10LowHightByBytes(byte[] data) {
        List<Byte> byteList = new ArrayList<>();
        for (byte b : data) {
            byteList.add(b);
        }
        Collections.reverse(byteList);
        byte[] byteArray = new byte[byteList.size()];
        for (int i = 0; i < byteList.size(); i++) {
            byteArray[i] = byteList.get(i);
        }
        String hex = bytesToHex(byteArray);
        return Integer.parseInt(hex, 16);
    }



    public static int getBcdToInt(byte data) {
        return ((data & 0xF0) >> 4) * 10 + ((data & 0x0F));
    }


    public static byte[] getIntToBCD(int number) {
        // 获取整数的字符串表示形式
        String numberStr = Integer.toString(number);

        // 创建一个字节数组以存储BCD表示
        int len = numberStr.length();
        byte[] bcd = new byte[(len + 1) / 2];

        int j = 0;
        // 如果数字的长度是奇数，需要在前面添加一个0
        if (len % 2 != 0) {
            numberStr = "0" + numberStr; // 先添加前导零
            len++;
        }

        // 将每一对数字转换为一个字节
        for (int i = 0; i < len; i += 2) {
            bcd[j++] = (byte) (((numberStr.charAt(i) - '0') << 4) | (numberStr.charAt(i + 1) - '0'));
        }

        return bcd;
    }
    /**
     * short10进制转16进制 低位在前高位在后
@@ -47,7 +96,6 @@
        while (hexString.length() < 4) {
            hexString = "0" + hexString;
        }

        hexString = spaceHex(hexString);
        hexString = HighLowHex(hexString);
        return hexString;
@@ -55,7 +103,7 @@

    /**
     * 将byte数组转换为带符号的32位浮点数
     *
     * <p>
     * 低位在前高位在后
     *
     * @param value
@@ -65,23 +113,9 @@
        ByteBuffer bufferLittleEndian = ByteBuffer.wrap(value);
        bufferLittleEndian.order(ByteOrder.LITTLE_ENDIAN);
        return bufferLittleEndian.getFloat();

    }

    /**
     * 将带符号的32位浮点数装换byte数组
     * 低位在前高位在后
     *
     * @param value
     * @return
     */
    public static byte[] folatToByte(Float value) {
        ByteBuffer buffer = ByteBuffer.allocate(4); // 4个字节
        buffer.order(ByteOrder.LITTLE_ENDIAN);
        buffer.putFloat(value);
        byte[] byteArray = buffer.array();
        return byteArray;
    }

    /**
     * hex字符串转byte数组
     *
@@ -152,37 +186,6 @@
        return sb.toString();
    }

    public static String byteArrayToHexString(byte[] byteArray) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : byteArray) {
            // 将字节转换为无符号整数
            int unsignedInt = b & 0xff;
            // 将无符号整数转换为16进制字符串
            String hex = Integer.toHexString(unsignedInt);
            // 如果字符串长度小于2，在前面补0
            if (hex.length() < 2) {
                hex = "0" + hex;
            }
            hexString.append(hex);
        }
        return hexString.toString();
    }

    /**
     * 字节数组转16进制 不在末尾添加0
     *
     * @param bytes 需要转换的byte数组
     * @return 转换后的Hex字符串
     */
    public static String bytesToHexNoAddZero(byte[] bytes) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(bytes[i] & 0xFF);
            sb.append(hex);
        }
        return sb.toString();
    }


    /**
     * 将 4字节的16进制字符串，转换为32位带符号的十进制浮点型
@@ -202,6 +205,37 @@
     */
    public static String folatToHexString(Float value) {
        return Integer.toHexString(Float.floatToIntBits(value));
    }


    /**
     * float转Hex低位在前高位在后
     *
     * @param value
     * @return
     */
    public static String floatToHexLowHigh(Float value) {
        String hexString = Integer.toHexString(Float.floatToIntBits(value));
        hexString = spaceHex(hexString);
        hexString = HighLowHex(hexString);
        return hexString;
    }


    public static float hexToFloatLowHigh(byte[] data) {
        List<Byte> byteList = new ArrayList<>();
        for (byte b : data) {
            byteList.add(b);
        }
        Collections.reverse(byteList);
        byte[] byteArray = new byte[byteList.size()];
        for (int i = 0; i < byteList.size(); i++) {
            byteArray[i] = byteList.get(i);
        }
        String hex = bytesToHex(byteArray);
        int intValue = Integer.parseInt(hex, 16); // 将十六进制字符串转换为整数表示
        float floatValue = Float.intBitsToFloat(intValue); // 将整数表示转换为浮点数
        return floatValue;
    }

    /**
@@ -250,23 +284,6 @@
        return str;
    }

    /**
     * 16进制转10进制高低位转换
     * @param hex
     * @return
     */
    public static int get16to10LowHigh(String hex) {
        try {
            String str = "";
            str = spaceHex(hex);
            str = HighLowHex(str);
            return Integer.parseInt(str, 16);
        } catch (NumberFormatException e) {
            e.printStackTrace();
        }
        return 0;
    }


    /**
     * 返回特定长度的16进制字符串
@@ -290,6 +307,10 @@
     * @return
     */
    public static String spaceHex(String str) {
        if (str.length() % 2 != 0) {
            //奇数时前面加0补齐称为偶数
            str = "0" + str;
        }
        char[] array = str.toCharArray();
        if (str.length() <= 2) return str;
        StringBuffer bufferHex = new StringBuffer();
@@ -310,7 +331,7 @@
     * @param str
     * @return
     */
    private static String HighLowHex(String str) {
    public static String HighLowHex(String str) {
        if (str.trim().length() <= 2) return str;
        List<String> list = Arrays.asList(str.split(" "));
        Collections.reverse(list);