package com.cvte.udi.utils;

import android.app.PendingIntent;
import android.content.Context;
import android.content.Intent;
import android.hardware.usb.UsbDevice;
import android.hardware.usb.UsbDeviceConnection;
import android.hardware.usb.UsbEndpoint;
import android.hardware.usb.UsbInterface;
import android.hardware.usb.UsbManager;
import android.util.Log;
import java.util.ArrayList;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public class UsbUtils {
    private static final String ACTION_USB_PERMISSION = "com.android.usb.USB_PERMISSION";
    private static final String TAG = "UsbUtils";
    private static final int TIME_OUT = 2000;

    public static class UsbDeviceWrapper {
        private UsbDeviceConnection mConnection;
        private UsbDevice mDevice;
        private UsbEndpoint mInPoint;
        private UsbInterface mInterface;
        private UsbEndpoint mOutPoint;

        public UsbDeviceWrapper(UsbDevice usbDevice) {
            this.mDevice = usbDevice;
        }

        public byte[] bulkTransfer(byte[] bArr) {
            UsbUtils.sendData(this.mConnection, this.mOutPoint, bArr, bArr.length);
            return UsbUtils.receiveData(this.mConnection, this.mInPoint, bArr.length);
        }

        public void connect(Context context) {
            if (!UsbUtils.hasDevicePermission(context, this.mDevice)) {
                UsbUtils.requestDevicePermission(context, this.mDevice);
                return;
            }
            UsbInterface hidInterface = UsbUtils.getHidInterface(this.mDevice);
            this.mInterface = hidInterface;
            this.mOutPoint = UsbUtils.getOutEndPoint(hidInterface);
            this.mInPoint = UsbUtils.getInEndPoint(this.mInterface);
            UsbDeviceConnection usbDeviceConnectionOpenDevice = UsbUtils.openDevice(context, this.mDevice);
            this.mConnection = usbDeviceConnectionOpenDevice;
            UsbUtils.lockInterface(usbDeviceConnectionOpenDevice, this.mInterface);
        }

        public void disconnect() {
            UsbUtils.unLockInterface(this.mConnection, this.mInterface);
            UsbUtils.closeDevice(this.mConnection);
            this.mConnection = null;
            this.mInterface = null;
            this.mInPoint = null;
            this.mOutPoint = null;
        }

        public boolean isConnect() {
            return this.mConnection != null;
        }
    }

    public static void closeDevice(UsbDeviceConnection usbDeviceConnection) {
        if (usbDeviceConnection != null) {
            usbDeviceConnection.close();
        }
    }

    public static List<UsbDevice> getDevices(Context context) {
        UsbManager usbManager = (UsbManager) context.getSystemService("usb");
        return usbManager == null ? new ArrayList() : new ArrayList(usbManager.getDeviceList().values());
    }

    public static UsbEndpoint getEndPoint(UsbInterface usbInterface, int i2) {
        if (usbInterface == null) {
            return null;
        }
        for (int i3 = 0; i3 < usbInterface.getEndpointCount(); i3++) {
            UsbEndpoint endpoint = usbInterface.getEndpoint(i3);
            if (endpoint.getType() == 3 && endpoint.getDirection() == i2) {
                return endpoint;
            }
        }
        return null;
    }

    public static UsbInterface getHidInterface(UsbDevice usbDevice) {
        if (usbDevice == null) {
            return null;
        }
        for (int i2 = 0; i2 < usbDevice.getInterfaceCount(); i2++) {
            UsbInterface usbInterface = usbDevice.getInterface(i2);
            if (usbInterface.getInterfaceClass() == 3) {
                return usbInterface;
            }
        }
        return null;
    }

    public static UsbEndpoint getInEndPoint(UsbInterface usbInterface) {
        return getEndPoint(usbInterface, 128);
    }

    public static UsbEndpoint getOutEndPoint(UsbInterface usbInterface) {
        return getEndPoint(usbInterface, 0);
    }

    public static boolean hasDevicePermission(Context context, UsbDevice usbDevice) {
        UsbManager usbManager = (UsbManager) context.getSystemService("usb");
        return (usbManager == null || usbDevice == null || !usbManager.hasPermission(usbDevice)) ? false : true;
    }

    public static boolean isTargetDevice(UsbDevice usbDevice, int i2, int i3) {
        return usbDevice != null && usbDevice.getVendorId() == i2 && usbDevice.getProductId() == i3;
    }

    public static boolean lockInterface(UsbDeviceConnection usbDeviceConnection, UsbInterface usbInterface) {
        return (usbDeviceConnection == null || usbInterface == null || !usbDeviceConnection.claimInterface(usbInterface, true)) ? false : true;
    }

    public static UsbDeviceConnection openDevice(Context context, UsbDevice usbDevice) {
        UsbManager usbManager = (UsbManager) context.getSystemService("usb");
        if (usbManager == null || usbDevice == null || !usbManager.hasPermission(usbDevice)) {
            return null;
        }
        return usbManager.openDevice(usbDevice);
    }

    public static byte[] receiveData(UsbDeviceConnection usbDeviceConnection, UsbEndpoint usbEndpoint, int i2) {
        if (usbEndpoint.getDirection() != 128) {
            return null;
        }
        byte[] bArr = new byte[i2];
        if (usbDeviceConnection.bulkTransfer(usbEndpoint, bArr, i2, TIME_OUT) > 0) {
            return bArr;
        }
        return null;
    }

    public static void requestDevicePermission(Context context, UsbDevice usbDevice) {
        UsbManager usbManager = (UsbManager) context.getSystemService("usb");
        if (usbManager == null) {
            return;
        }
        usbManager.requestPermission(usbDevice, PendingIntent.getBroadcast(context, 0, new Intent(ACTION_USB_PERMISSION), 0));
    }

    public static int sendData(UsbDeviceConnection usbDeviceConnection, UsbEndpoint usbEndpoint, byte[] bArr, int i2) {
        if (usbEndpoint == null || usbEndpoint.getDirection() != 0) {
            return -1;
        }
        int iBulkTransfer = usbDeviceConnection.bulkTransfer(usbEndpoint, bArr, i2, TIME_OUT);
        if (iBulkTransfer <= 0) {
            Log.e(TAG, "send data error");
        }
        return iBulkTransfer;
    }

    public static boolean unLockInterface(UsbDeviceConnection usbDeviceConnection, UsbInterface usbInterface) {
        return (usbDeviceConnection == null || usbInterface == null || !usbDeviceConnection.releaseInterface(usbInterface)) ? false : true;
    }
}