import javax.usb.UsbConst; //导入依赖的package包/类
protected void initialize() throws SecurityException, UsbException {
	UsbServices services = UsbHostManager.getUsbServices();
	UsbHub usbHub = services.getRootUsbHub();

	UsbDevice theDevice = findDevice(usbHub, targetVendor, targetProduct);

	if (theDevice == null) {
		logger.warn("Could not find the device. The driver is not operable.");
		return;
	}
	
	for (Object i : theDevice.getActiveUsbConfiguration().getUsbInterfaces()) {
		UsbInterface intf = (UsbInterface) i;
		for (Object e : intf.getUsbEndpoints()) {
			UsbEndpoint endp = (UsbEndpoint) e;
			if (endp.getDirection() == UsbConst.ENDPOINT_DIRECTION_IN) {
				this.pipe = endp.getUsbPipe();
			}
		}
	}
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
/**
 * Transfers data from or to the device.
 * 
 * @param handle
 *            The device handle.
 * @param descriptor
 *            The endpoint descriptor.
 * @param type
 *            The endpoint type.
 * @param buffer
 *            The data buffer.
 * @return The number of transferred bytes.
 * @throws UsbException
 *             When data transfer fails.
 */
private int transfer(final DeviceHandle handle,
    final UsbEndpointDescriptor descriptor, final int type,
    final ByteBuffer buffer) throws UsbException
{
    final byte address = descriptor.bEndpointAddress();
    final boolean in = this.pipe.getUsbEndpoint().getDirection() ==
        UsbConst.ENDPOINT_DIRECTION_IN;
    if (type == UsbConst.ENDPOINT_TYPE_BULK)
    {
        return transferBulk(handle, address, in, buffer);
    }
    else if (type == UsbConst.ENDPOINT_TYPE_INTERRUPT)
    {
        return transferInterrupt(handle, address, in, buffer);
    }
    else
    {
        throw new UsbException("Unsupported endpoint type: " + type);
    }
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
/**
 * Tests the {@link RootHubInterface#getUsbInterfaceDescriptor()} method.
 */
@Test
public void testGetUsbInterfaceDescriptor()
{
    final UsbInterfaceDescriptor desc =
        this.iface.getUsbInterfaceDescriptor();
    assertEquals(UsbConst.DESCRIPTOR_MIN_LENGTH_INTERFACE, desc.bLength());
    assertEquals(UsbConst.DESCRIPTOR_TYPE_INTERFACE,
        desc.bDescriptorType());
    assertEquals(0, desc.bInterfaceNumber());
    assertEquals(0, desc.bAlternateSetting());
    assertEquals(0, desc.bNumEndpoints());
    assertEquals(UsbConst.HUB_CLASSCODE, desc.bInterfaceClass());
    assertEquals(0, desc.bInterfaceSubClass());
    assertEquals(0, desc.bInterfaceProtocol());
    assertEquals(0, desc.iInterface());
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
/**
 * Sends a message to the missile launcher.
 * 
 * @param device
 *            The USB device handle.
 * @param message
 *            The message to send.
 * @throws UsbException
 *             When sending the message failed.
 */
public static void sendMessage(UsbDevice device, byte[] message)
    throws UsbException
{
    UsbControlIrp irp = device.createUsbControlIrp(
        (byte) (UsbConst.REQUESTTYPE_TYPE_CLASS |
        UsbConst.REQUESTTYPE_RECIPIENT_INTERFACE), (byte) 0x09,
        (short) 2, (short) 1);
    irp.setData(message);
    device.syncSubmit(irp);
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
private int sendBulkTransfer(UsbEndpoint usbEndpoint, byte[] data) throws UsbException{
        int returnCode = -1;

        if(UsbConst.ENDPOINT_DIRECTION_OUT == usbEndpoint.getDirection()){
            mLogger.debug("sendBulkTransfer - direction: OUT,  byteString: {}", getByteString(data));
        }

        UsbPipe usbPipe = usbEndpoint.getUsbPipe();
        if (usbPipe != null) {
            if(!usbPipe.isOpen()){
                usbPipe.open();
            }
            if (usbPipe.isOpen()) {
                UsbIrp usbIrp = usbPipe.createUsbIrp();
                usbIrp.setData(data);
                //TODO: data length does not need to be set explicitly
//                int dataLength = (data == null) ? 0 : data.length;
//                usbIrp.setLength(dataLength);
                usbPipe.syncSubmit(usbIrp);
                if (!usbIrp.isUsbException()) {
                    returnCode = usbIrp.getActualLength();
                } else {
                    // throw usbControlIrp.getUsbException();
                    usbIrp.getUsbException().printStackTrace();
                }
            } else {
            	mLogger.error("usbPipe open ERROR");
            }
        } else {
        	mLogger.error("usbPipe is NULL");
        }

        if(UsbConst.ENDPOINT_DIRECTION_IN == usbEndpoint.getDirection()){
        	//TODO: show type of packet in debug log
            mLogger.debug("sendBulkTransfer - direction: IN,  byteString: {}", getByteString(data));
        }

        return returnCode;
    }
 

import javax.usb.UsbConst; //导入依赖的package包/类
protected UsbControlIrp controlRequest() {
	final byte requestType = UsbConst.REQUESTTYPE_TYPE_VENDOR;
	final byte request = UsbConst.REQUEST_GET_DESCRIPTOR;
	final short value = 0x100;
	final short index = 0;
	return device.createUsbControlIrp(requestType, request, value, index);
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
private void init()
{
    this.usbDevice.addUsbDeviceListener(this);

    this.resetStates();

    // Set up the control pipe.
    this.irp = usbDevice.createUsbControlIrp(
            (byte) UsbConst.CONFIGURATION_SELF_POWERED,
            (byte) UsbConst.REQUEST_GET_DESCRIPTOR,
            (short) 0x100,
            (short) 0
    );
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
@Override
public final Object getSpeed()
{
    switch (this.speed)
    {
        case LibUsb.SPEED_FULL:
            return UsbConst.DEVICE_SPEED_FULL;
        case LibUsb.SPEED_LOW:
            return UsbConst.DEVICE_SPEED_LOW;
        default:
            return UsbConst.DEVICE_SPEED_UNKNOWN;
    }
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
@Override
protected void processIrp(final UsbIrp irp) throws UsbException
{
    final UsbEndpoint endpoint = this.pipe.getUsbEndpoint();
    final byte direction = endpoint.getDirection();
    final byte type = endpoint.getType();
    if (type == UsbConst.ENDPOINT_TYPE_CONTROL)
    {
        processControlIrp((UsbControlIrp) irp);
        return;
    }

    switch (direction)
    {
        case UsbConst.ENDPOINT_DIRECTION_OUT:
            irp.setActualLength(write(irp.getData(), irp.getOffset(),
                irp.getLength()));
            if (irp.getActualLength() < irp.getLength()
                && !irp.getAcceptShortPacket())
            {
                throw new UsbShortPacketException();
            }
            break;

        case UsbConst.ENDPOINT_DIRECTION_IN:
            irp.setActualLength(read(irp.getData(), irp.getOffset(),
                irp.getLength()));
            if (irp.getActualLength() < irp.getLength()
                && !irp.getAcceptShortPacket())
            {
                throw new UsbShortPacketException();
            }
            break;

        default:
            throw new UsbException("Invalid direction: "
                + direction);
    }
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
protected UsbEndpoint findInterruptInEndpoint(List<?> usbEndpoints) {
	for (int i = 0; i < usbEndpoints.size(); i++) {
		UsbEndpoint usbEndpoint = (UsbEndpoint) usbEndpoints.get(i);

		if (UsbConst.ENDPOINT_TYPE_INTERRUPT == usbEndpoint.getType()
				&& UsbConst.ENDPOINT_DIRECTION_IN == usbEndpoint
						.getDirection()) {
			return usbEndpoint;
		}
	}

	return null;
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
@Override
public Object getSpeed()
{
    return UsbConst.DEVICE_SPEED_UNKNOWN;
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
@Override
public byte getDirection()
{
    final byte address = this.descriptor.bEndpointAddress();
    return (byte) (address & UsbConst.ENDPOINT_DIRECTION_MASK);
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
@Override
public byte getType()
{
    final byte attribs = this.descriptor.bmAttributes();
    return (byte) (attribs & UsbConst.ENDPOINT_TYPE_MASK);
}
 

import javax.usb.UsbConst; //导入依赖的package包/类
/**
 * Checks if the specified USB device is a ADB device and adds it to the
 * list if it is.
 * 
 * @param usbDevice
 *            The USB device to check.
 * @param adbDevices
 *            The list of ADB devices to add the USB device to when it is an
 *            ADB device.
 */
private static void checkDevice(UsbDevice usbDevice,
    List<AdbDevice> adbDevices)
{
    UsbDeviceDescriptor deviceDesc = usbDevice.getUsbDeviceDescriptor();

    // Ignore devices from Non-ADB vendors
    if (!isAdbVendor(deviceDesc.idVendor())) return;

    // Check interfaces of device
    UsbConfiguration config = usbDevice.getActiveUsbConfiguration();
    for (UsbInterface iface: (List<UsbInterface>) config.getUsbInterfaces())
    {
        List<UsbEndpoint> endpoints = iface.getUsbEndpoints();

        // Ignore interface if it does not have two endpoints
        if (endpoints.size() != 2) continue;

        // Ignore interface if it does not match the ADB specs
        if (!isAdbInterface(iface)) continue;

        UsbEndpointDescriptor ed1 =
            endpoints.get(0).getUsbEndpointDescriptor();
        UsbEndpointDescriptor ed2 =
            endpoints.get(1).getUsbEndpointDescriptor();

        // Ignore interface if endpoints are not bulk endpoints
        if (((ed1.bmAttributes() & UsbConst.ENDPOINT_TYPE_BULK) == 0) ||
            ((ed2.bmAttributes() & UsbConst.ENDPOINT_TYPE_BULK) == 0))
            continue;
        
        // Determine which endpoint is in and which is out. If both
        // endpoints are in or out then ignore the interface
        byte a1 = ed1.bEndpointAddress();
        byte a2 = ed2.bEndpointAddress();
        byte in, out;
        if (((a1 & UsbConst.ENDPOINT_DIRECTION_IN) != 0) &&
            ((a2 & UsbConst.ENDPOINT_DIRECTION_IN) == 0))
        {
            in = a1;
            out = a2;
        }
        else if (((a2 & UsbConst.ENDPOINT_DIRECTION_IN) != 0) &&
            ((a1 & UsbConst.ENDPOINT_DIRECTION_IN) == 0))
        {
            out = a1;
            in = a2;
        }
        else continue;                
        
        // Create ADB device and add it to the list
        AdbDevice adbDevice = new AdbDevice(iface, in, out);
        adbDevices.add(adbDevice);
    }
}