import javax.usb.UsbEndpoint; //导入依赖的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.UsbEndpoint; //导入依赖的package包/类
/**
 * Sends an ADB Message.
 * 
 * @param message
 *            The message to send.
 * @throws UsbException
 *             When USB communication failed.
 */
public void sendMessage(Message message) throws UsbException
{
    UsbEndpoint outEndpoint =
        this.iface.getUsbEndpoint(this.outEndpoint);
    UsbPipe outPipe = outEndpoint.getUsbPipe();
    MessageHeader header = message.getHeader();
    outPipe.open();
    try
    {
        int sent = outPipe.syncSubmit(header.getBytes());
        if (sent != MessageHeader.SIZE)
            throw new InvalidMessageException(
                "Invalid ADB message header size sent: " + sent);
        sent = outPipe.syncSubmit(message.getData());
        if (sent != header.getDataLength())
            throw new InvalidMessageException(
                "Data size mismatch in sent ADB message. Should be "
                    + header.getDataLength() + " but is " + sent);
    }
    finally
    {
        outPipe.close();
    }
}
 

import javax.usb.UsbEndpoint; //导入依赖的package包/类
public static String getDeviceDetails( UsbDevice device ) 
	throws UsbException, UnsupportedEncodingException, UsbDisconnectedException
{
	StringBuilder sb = new StringBuilder();

	sb.append( device.getUsbDeviceDescriptor().toString() + "\n\n" );
	
	for( Object configObject: device.getUsbConfigurations() )
	{
		UsbConfiguration config = (UsbConfiguration)configObject;
		
		sb.append( config.getUsbConfigurationDescriptor().toString() + "\n\n" );
		
		for( Object interfaceObject: config.getUsbInterfaces() )
		{
			UsbInterface iface = (UsbInterface)interfaceObject;
			
			sb.append( iface.getUsbInterfaceDescriptor().toString() + "\n\n" );
			
			for( Object endpointObject: iface.getUsbEndpoints() )
			{
				UsbEndpoint endpoint = (UsbEndpoint)endpointObject;
				
				sb.append( endpoint.getUsbEndpointDescriptor().toString() + "\n\n" );
			}
		}
	}

	return sb.toString();
}
 

import javax.usb.UsbEndpoint; //导入依赖的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.UsbEndpoint; //导入依赖的package包/类
private void open() throws UsbException {
  UsbConfiguration configuration = device.getActiveUsbConfiguration();
  iface = configuration.getUsbInterface((byte) 0);
  // this allows us to steal the lock from the kernel
  iface.claim(usbInterface -> true);
  final List<UsbEndpoint> endpoints = iface.getUsbEndpoints();
  pipe = endpoints.get(0).getUsbPipe(); // there is only 1 endpoint
  pipe.addUsbPipeListener(this);
  pipe.open();
}
 

import javax.usb.UsbEndpoint; //导入依赖的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.UsbEndpoint; //导入依赖的package包/类
/**
 * Tests the {@link RootHubInterface#getUsbEndpoints()} method.
 */
@Test
public void testGetUsbEndpoints()
{
    final List<UsbEndpoint> endpoints = this.iface.getUsbEndpoints();
    assertEquals(0, endpoints.size());
}
 

import javax.usb.UsbEndpoint; //导入依赖的package包/类
/**
 * Receives an ADB message.
 * 
 * @return The received ADB message.
 * @throws UsbException
 *             When USB communication failed.
 */
public Message receiveMessage() throws UsbException
{
    UsbEndpoint inEndpoint =
        this.iface.getUsbEndpoint(this.inEndpoint);
    UsbPipe inPipe = inEndpoint.getUsbPipe();
    inPipe.open();
    try
    {
        byte[] headerBytes = new byte[MessageHeader.SIZE];
        int received = inPipe.syncSubmit(headerBytes);
        if (received != MessageHeader.SIZE)
            throw new InvalidMessageException(
                "Invalid ADB message header size: " + received);
        MessageHeader header = new MessageHeader(headerBytes);
        if (!header.isValid())
            throw new InvalidMessageException(
                "ADB message header checksum failure");
        byte[] data = new byte[header.getDataLength()];
        received = inPipe.syncSubmit(data);
        if (received != header.getDataLength())
            throw new InvalidMessageException(
                "ADB message data size mismatch. Should be "
                    + header.getDataLength() + " but is " + received);
        Message message = Message.create(header, data);
        if (!message.isValid())
            throw new InvalidMessageException(
                "ADB message data checksum failure");
        return message;
    }
    finally
    {
        inPipe.close();
    }
}
 

import javax.usb.UsbEndpoint; //导入依赖的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.UsbEndpoint; //导入依赖的package包/类
@Override
public List<UsbEndpoint> getUsbEndpoints()
{
    return this.endpoints;
}
 

import javax.usb.UsbEndpoint; //导入依赖的package包/类
@Override
public UsbEndpoint getUsbEndpoint(final byte address)
{
    return null;
}
 

import javax.usb.UsbEndpoint; //导入依赖的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);
    }
}
 

import javax.usb.UsbEndpoint; //导入依赖的package包/类
/**
 * Dumps the specified USB device to stdout.
 * 
 * @param device
 *            The USB device to dump.
 */
private static void dumpDevice(final UsbDevice device)
{
    // Dump information about the device itself
    System.out.println(device);
    final UsbPort port = device.getParentUsbPort();
    if (port != null)
    {
        System.out.println("Connected to port: " + port.getPortNumber());
        System.out.println("Parent: " + port.getUsbHub());
    }

    // Dump device descriptor
    System.out.println(device.getUsbDeviceDescriptor());

    // Process all configurations
    for (UsbConfiguration configuration: (List<UsbConfiguration>) device
        .getUsbConfigurations())
    {
        // Dump configuration descriptor
        System.out.println(configuration.getUsbConfigurationDescriptor());

        // Process all interfaces
        for (UsbInterface iface: (List<UsbInterface>) configuration
            .getUsbInterfaces())
        {
            // Dump the interface descriptor
            System.out.println(iface.getUsbInterfaceDescriptor());

            // Process all endpoints
            for (UsbEndpoint endpoint: (List<UsbEndpoint>) iface
                .getUsbEndpoints())
            {
                // Dump the endpoint descriptor
                System.out.println(endpoint.getUsbEndpointDescriptor());
            }
        }
    }

    System.out.println();

    // Dump child devices if device is a hub
    if (device.isUsbHub())
    {
        final UsbHub hub = (UsbHub) device;
        for (UsbDevice child: (List<UsbDevice>) hub.getAttachedUsbDevices())
        {
            dumpDevice(child);
        }
    }
}