How to use android.hardware.usb

mUsbManager         = (UsbManager) getSystemService( Context.USB_SERVICE );
 HashMap< String, UsbDevice > stringDeviceMap    =       mUsbManager.getDeviceList();
 Collection< UsbDevice > usbDevices              = stringDeviceMap.values();
 mPermissionIntent = PendingIntent.getBroadcast(this, 0, new Intent( ACTION_USB_PERMISSION ), 0 );
 IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
 registerReceiver( mUsbReceiver, filter );
 Iterator< UsbDevice > usbDeviceIter             = usbDevices.iterator();
 while( usbDeviceIter.hasNext() )
 {
   if ( USBDeviceValid( usbDevice ) )
   {
     // Request permission to access the device.
     mUsbManager.requestPermission( usbDevice, mPermissionIntent );
     // Open the device.
     UsbDeviceConnection connection = mUsbManager.openDevice( usbDevice );
     int fd = connection.getFileDescriptor();
     // Now pass the file descriptor to libusb through a native call.
   }
 }

/**
 * Adds a USB device into available USB devices map with permission value. If the USB device
 * already exists, updates the USB device with new permission value.
 */
public void addOrUpdateUsbDevice(UsbDevice usbDevice, boolean hasPermission) {
 Preconditions.checkNotNull(usbDevice);
 Preconditions.checkNotNull(usbDevice.getDeviceName());
 usbDevices.put(usbDevice.getDeviceName(), usbDevice);
 if (hasPermission) {
  grantPermission(usbDevice);
 } else {
  revokePermission(usbDevice, RuntimeEnvironment.application.getPackageName());
 }
}

public UsbEndpointAssert hasMaximumPacketSize(int size) {
 isNotNull();
 int actualSize = actual.getMaxPacketSize();
 assertThat(actualSize) //
   .overridingErrorMessage("Expected maximum packet size <%s> but was <%s>.", size,
     actualSize) //
   .isEqualTo(size);
 return this;
}

public UsbDeviceAssert hasProductId(int id) {
 isNotNull();
 int actualId = actual.getProductId();
 assertThat(actualId) //
   .overridingErrorMessage("Expected product ID <%s> but was <%s>.", id, actualId) //
   .isEqualTo(id);
 return this;
}

@Test
@Config(minSdk = N)
public void grantPermission_selfPackage_shouldHavePermission() {
 usbManager.grantPermission(usbDevice1);
 assertThat(usbManager.hasPermission(usbDevice1)).isTrue();
}

public UsbEndpointAssert hasDirection(int direction) {
 isNotNull();
 int actualDirection = actual.getDirection();
 assertThat(actualDirection) //
   .overridingErrorMessage("Expected direction <%s> but was <%s>.", direction,
     actualDirection) //
   .isEqualTo(direction);
 return this;
}

@Test
public void hasPermission() {
 assertThat(usbManager.hasPermission(usbDevice1)).isFalse();
 shadowOf(usbManager).addOrUpdateUsbDevice(usbDevice1, false);
 shadowOf(usbManager).addOrUpdateUsbDevice(usbDevice2, false);
 assertThat(usbManager.hasPermission(usbDevice1)).isFalse();
 assertThat(usbManager.hasPermission(usbDevice2)).isFalse();
 shadowOf(usbManager).addOrUpdateUsbDevice(usbDevice1, true);
 assertThat(usbManager.hasPermission(usbDevice1)).isTrue();
 assertThat(usbManager.hasPermission(usbDevice2)).isFalse();
}

public UsbDeviceAssert hasDeviceSubclass(int subclass) {
 isNotNull();
 int actualSubclass = actual.getDeviceSubclass();
 assertThat(actualSubclass) //
   .overridingErrorMessage("Expected device subclass <%s> but was <%s>.", subclass,
     actualSubclass) //
   .isEqualTo(subclass);
 return this;
}

 public UsbInterfaceAssert hasInterfaceSubclass(int subclass) {
  isNotNull();
  int actualSubclass = actual.getInterfaceSubclass();
  Assertions.assertThat(actualSubclass) //
    .overridingErrorMessage("Expected interface subclass <%s> but was <%s>.", subclass,
      actualSubclass) //
    .isEqualTo(subclass);
  return this;
 }
}

public UsbInterfaceAssert hasId(int id) {
 isNotNull();
 int actualId = actual.getId();
 Assertions.assertThat(actualId) //
   .overridingErrorMessage("Expected id <%s> but was <%s>.", id, actualId) //
   .isEqualTo(id);
 return this;
}

public UsbEndpointAssert hasEndpointNumber(int number) {
 isNotNull();
 int actualNumber = actual.getEndpointNumber();
 assertThat(actualNumber) //
   .overridingErrorMessage("Expected endpoint number <%s> but was <%s>.", number,
     actualNumber) //
   .isEqualTo(number);
 return this;
}

public UsbAccessoryAssert hasSerial(String serial) {
 isNotNull();
 String actualSerial = actual.getSerial();
 assertThat(actualSerial) //
   .overridingErrorMessage("Expected serial <%s> but was <%s>.", serial, actualSerial) //
   .isEqualTo(serial);
 return this;
}

public UsbAccessoryAssert hasDescription(String description) {
 isNotNull();
 String actualDescription = actual.getDescription();
 assertThat(actualDescription) //
   .overridingErrorMessage("Expected description <%s> but was <%s>.", description,
     actualDescription) //
   .isEqualTo(description);
 return this;
}

public UsbAccessoryAssert hasUri(String uri) {
 isNotNull();
 String actualUri = actual.getUri();
 assertThat(actualUri) //
   .overridingErrorMessage("Expected uri <%s> but was <%s>.", uri, actualUri) //
   .isEqualTo(uri);
 return this;
}

public UsbAccessoryAssert hasModel(String model) {
 isNotNull();
 String actualModel = actual.getModel();
 assertThat(actualModel) //
   .overridingErrorMessage("Expected model <%s> but was <%s>.", model, actualModel) //
   .isEqualTo(model);
 return this;
}

 public UsbAccessoryAssert hasVersion(String version) {
  isNotNull();
  String actualVersion = actual.getVersion();
  assertThat(actualVersion) //
    .overridingErrorMessage("Expected version <%s> but was <%s>.", version, actualVersion) //
    .isEqualTo(version);
  return this;
 }
}

@Test
public void openAccessory() {
 assertThat(usbManager.openAccessory(usbAccessory)).isNotNull();
}

/** Adds a USB port to UsbManager. */
public void addPort(String portId) {
 usbPorts.put(
   callConstructor(UsbPort.class,
     from(String.class, portId),
     from(int.class, getStaticField(UsbPort.class, "MODE_DUAL"))),
   new UsbPortStatus(
     getStaticField(UsbPort.class, "MODE_DUAL"),
     getStaticField(UsbPort.class, "POWER_ROLE_SINK"),
     getStaticField(UsbPort.class, "DATA_ROLE_DEVICE"),
     0));
}

/** Removes a USB device from available USB devices map. */
public void removeUsbDevice(UsbDevice usbDevice) {
 Preconditions.checkNotNull(usbDevice);
 usbDevices.remove(usbDevice.getDeviceName());
 revokePermission(usbDevice, RuntimeEnvironment.application.getPackageName());
}

public UsbDeviceConnectionAssert hasFileDescriptor(int descriptor) {
 isNotNull();
 int actualDescriptor = actual.getFileDescriptor();
 assertThat(actualDescriptor) //
   .overridingErrorMessage("Expected file descriptor <%s> but was <%s>.", descriptor,
     actualDescriptor) //
   .isEqualTo(descriptor);
 return this;
}