import javax.usb.UsbInterface; //导入依赖的package包/类
private LedStripe() throws UsbException {

		device = find(UsbHostManager.getUsbServices().getRootUsbHub(), VENDOR_ID, PRODUCT_ID);
		if (device == null) {
			throw new UsbException("Device not found.");
		}

		// Claim the interface
		UsbConfiguration configuration = device.getUsbConfiguration((byte) 1);
		UsbInterface iface = configuration.getUsbInterface((byte) 0);
		iface.claim(new UsbInterfacePolicy() {
			public boolean forceClaim(UsbInterface usbInterface) {
				return true;
			}
		});

		
	}
 

import javax.usb.UsbInterface; //导入依赖的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.UsbInterface; //导入依赖的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.UsbInterface; //导入依赖的package包/类
@Override
public boolean isActive()
{
    final UsbInterface iface = this.endpoint.getUsbInterface();
    final UsbConfiguration config = iface.getUsbConfiguration();
    return iface.isActive() && config.isActive();
}
 

import javax.usb.UsbInterface; //导入依赖的package包/类
/**
 * Tests the {@link RootHubConfiguration#getUsbInterfaces()} method.
 */
@Test
public void testGetUsbInterfaces()
{
    final List<UsbInterface> ifaces = this.config.getUsbInterfaces();
    assertEquals(1, ifaces.size());
    assertNotNull(ifaces.get(0));
}
 

import javax.usb.UsbInterface; //导入依赖的package包/类
/**
 * Tests the {@link RootHubInterface#getSettings()} method.
 */
@Test
public void testGetSettings()
{
    final List<UsbInterface> settings = this.iface.getSettings();
    assertEquals(0, settings.size());
}
 

import javax.usb.UsbInterface; //导入依赖的package包/类
/**
 * Checks if the specified USB interface is an ADB interface.
 * 
 * @param iface
 *            The interface to check.
 * @return True if interface is an ADB interface, false if not.
 */
private static boolean isAdbInterface(UsbInterface iface)
{
    UsbInterfaceDescriptor desc = iface.getUsbInterfaceDescriptor();
    return desc.bInterfaceClass() == ADB_CLASS &&
        desc.bInterfaceSubClass() == ADB_SUBCLASS &&
        desc.bInterfaceProtocol() == ADB_PROTOCOL;
}
 

import javax.usb.UsbInterface; //导入依赖的package包/类
@Override
public List<UsbInterface> getUsbInterfaces()
{
    return this.interfaces;
}
 

import javax.usb.UsbInterface; //导入依赖的package包/类
@Override
public UsbInterface getUsbInterface(final byte number)
{
    if (number != 0) return null;
    return this.interfaces.get(0);
}
 

import javax.usb.UsbInterface; //导入依赖的package包/类
@Override
public UsbInterface getActiveSetting()
{
    return this;
}
 

import javax.usb.UsbInterface; //导入依赖的package包/类
@Override
public UsbInterface getSetting(final byte number)
{
    return this;
}
 

import javax.usb.UsbInterface; //导入依赖的package包/类
@Override
public List<UsbInterface> getSettings()
{
    return this.settings;
}
 

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

import javax.usb.UsbInterface; //导入依赖的package包/类
/**
 * Constructs a new ADB interface.
 * 
 * @param iface
 *            The USB interface. Must not be null.
 * @param inEndpoint
 *            The in endpoint address.
 * @param outEndpoint
 *            THe out endpoint address.
 */
public AdbDevice(UsbInterface iface, byte inEndpoint,
    byte outEndpoint)
{
    if (iface == null)
        throw new IllegalArgumentException("iface must be set");
    this.iface = iface;
    this.inEndpoint = inEndpoint;
    this.outEndpoint = outEndpoint;
}