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 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 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 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; }