android.hardware.usb.UsbDevice.getInterface java code examples

Common ways to obtain UsbDevice

private void myMethod () {
     UsbDevice u =Intent intent;String name;intent.getParcelableExtra(name)
Intent intent;String name;(UsbDevice) intent.getParcelableExtra(name)
Smart code suggestions by Codota
}

public void open() throws IOException {
  if (!device_found) {
    throw new IOException("Device not Connected");
  }
  mConnection = mUsbManager.openDevice(mUsbDevice);
  Log.d(TAG, "Claiming interfaces, count=" + mUsbDevice.getInterfaceCount());
  mConnection.controlTransfer(0x21, 0x22, 0x1, 0, null, 0, 0);
  mControlInterface = mUsbDevice.getInterface(0);
  Log.d(TAG, "Control interface=" + mControlInterface);
  if (!mConnection.claimInterface(mControlInterface, true)) {
    throw new IOException("Could not claim control interface.");
  }
  mControlEndpoint = mControlInterface.getEndpoint(0);
  Log.d(TAG, "Control endpoint direction: " + mControlEndpoint.getDirection());
  Log.d(TAG, "Claiming data interface.");
  mDataInterface = mUsbDevice.getInterface(1);
  Log.d(TAG, "data interface=" + mDataInterface);
  if (!mConnection.claimInterface(mDataInterface, true)) {
    throw new IOException("Could not claim data interface.");
  }
  mReadEndpoint = mDataInterface.getEndpoint(1);
  Log.d(TAG, "Read endpoint direction: " + mReadEndpoint.getDirection());
  mWriteEndpoint = mDataInterface.getEndpoint(0);
  Log.d(TAG, "Write endpoint direction: " + mWriteEndpoint.getDirection());
  connected = true;
  setBaudRate(1000000);
  //Thread.sleep(1000);
  clear();
}

public XdcVcpSerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
{
  super(device, connection);
  mInterface = device.getInterface(iface >= 0 ? iface : 0);
}

public static boolean isCdcDevice(UsbDevice device)
{
  int iIndex = device.getInterfaceCount();
  for(int i=0;i<=iIndex-1;i++)
  {
    UsbInterface iface = device.getInterface(i);
    if(iface.getInterfaceClass() == UsbConstants.USB_CLASS_CDC_DATA)
      return true;
  }
  return false;
}

public CP2130SpiDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
{
  super(device, connection);
  mInterface = device.getInterface(iface >= 0 ? iface : 0);
  currentChannel = 0;
}

private static int findFirstCDC(UsbDevice device)
{
  int interfaceCount = device.getInterfaceCount();
  for (int iIndex = 0; iIndex < interfaceCount; ++iIndex)
  {
    if (device.getInterface(iIndex).getInterfaceClass() == UsbConstants.USB_CLASS_CDC_DATA)
    {
      return iIndex;
    }
  }
  Log.i(CLASS_ID, "There is no CDC class interface");
  return -1;
}

public CH34xSerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
{
  super(device, connection);
  rtsCtsEnabled = false;
  dtrDsrEnabled = false;
  mInterface = device.getInterface(iface >= 0 ? iface : 0);
}

private UsbMidiDevice(UsbDevice device) {
 super(device);
 int ifaceCount = device.getInterfaceCount();
 for (int i = 0; i < ifaceCount; ++i) {
  UsbMidiInterface iface = asMidiInterface(device.getInterface(i));
  if (iface != null) {
   interfaces.add(iface);
  }
 }
}

public CP2102SerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
{
  super(device, connection);
  rtsCtsEnabled = false;
  dtrDsrEnabled = false;
  ctsState = true;
  dsrState = true;
  mInterface = device.getInterface(iface >= 0 ? iface : 0);
}

/**
 * Find {@link UsbInterface} from {@link UsbDevice} with the direction
 * 
 * @param usbDevice the UsbDevice
 * @param direction {@link UsbConstants#USB_DIR_IN} or {@link UsbConstants#USB_DIR_OUT}
 * @param deviceFilters the List of {@link DeviceFilter}
 * @return {@link Set<UsbInterface>} always not null
 */
@NonNull
public static Set<UsbInterface> findMidiInterfaces(@NonNull UsbDevice usbDevice, int direction, @NonNull List<DeviceFilter> deviceFilters) {
  Set<UsbInterface> usbInterfaces = new HashSet<>();
  
  int count = usbDevice.getInterfaceCount();
  for (int i = 0; i < count; i++) {
    UsbInterface usbInterface = usbDevice.getInterface(i);
    
    if (findMidiEndpoint(usbDevice, usbInterface, direction, deviceFilters) != null) {
      usbInterfaces.add(usbInterface);
    }
  }
  return Collections.unmodifiableSet(usbInterfaces);
}

@Deprecated
public BLED112SerialDevice(UsbDevice device, UsbDeviceConnection connection)
{
  super(device, connection);
  mInterface = device.getInterface(1); // BLED112 Interface 0: Communications | Interface 1: CDC Data
}

/**
 * Find all {@link UsbInterface} from {@link UsbDevice}
 *
 * @param usbDevice the UsbDevice
 * @param deviceFilters the List of {@link DeviceFilter}
 * @return {@link Set<UsbInterface>} always not null
 */
@NonNull
public static Set<UsbInterface> findAllMidiInterfaces(@NonNull UsbDevice usbDevice, @NonNull List<DeviceFilter> deviceFilters) {
  Set<UsbInterface> usbInterfaces = new HashSet<>();
  
  int count = usbDevice.getInterfaceCount();
  for (int i = 0; i < count; i++) {
    UsbInterface usbInterface = usbDevice.getInterface(i);
    
    if (findMidiEndpoint(usbDevice, usbInterface, UsbConstants.USB_DIR_IN, deviceFilters) != null) {
      usbInterfaces.add(usbInterface);
    }
    if (findMidiEndpoint(usbDevice, usbInterface, UsbConstants.USB_DIR_OUT, deviceFilters) != null) {
      usbInterfaces.add(usbInterface);
    }
  }
  return Collections.unmodifiableSet(usbInterfaces);
}

public PL2303SerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
{
  super(device, connection);
  if (iface > 1)
  {
    throw new IllegalArgumentException("Multi-interface PL2303 devices not supported!");
  }
  mInterface = device.getInterface(iface >= 0 ? iface : 0);
}

/**
 * Tests to see if a {@link android.hardware.usb.UsbDevice}
 * supports the PTP protocol (typically used by digital cameras)
 *
 * @param device the device to test
 * @return true if the device is a PTP device.
 */
static public boolean isCamera(UsbDevice device) {
  int count = device.getInterfaceCount();
  for (int i = 0; i < count; i++) {
    UsbInterface intf = device.getInterface(i);
    if (intf.getInterfaceClass() == UsbConstants.USB_CLASS_STILL_IMAGE &&
        intf.getInterfaceSubclass() == 1 &&
        intf.getInterfaceProtocol() == 1) {
      return true;
    }
  }
  return false;
}

public FTDISerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
{
  super(device, connection);
  ftdiUtilities = new FTDIUtilities();
  rtsCtsEnabled = false;
  dtrDsrEnabled = false;
  ctsState = true;
  dsrState = true;
  firstTime = true;
  mInterface = device.getInterface(iface >= 0 ? iface : 0);
}

private void openInterface() throws IOException {
  Log.d(TAG, "claiming interfaces, count=" + mDevice.getInterfaceCount());
  mControlInterface = mDevice.getInterface(0);
  Log.d(TAG, "Control iface=" + mControlInterface);
  // class should be USB_CLASS_COMM
  if (!mConnection.claimInterface(mControlInterface, true)) {
    throw new IOException("Could not claim control interface.");
  }
  mControlEndpoint = mControlInterface.getEndpoint(0);
  Log.d(TAG, "Control endpoint direction: " + mControlEndpoint.getDirection());
  Log.d(TAG, "Claiming data interface.");
  mDataInterface = mDevice.getInterface(1);
  Log.d(TAG, "data iface=" + mDataInterface);
  // class should be USB_CLASS_CDC_DATA
  if (!mConnection.claimInterface(mDataInterface, true)) {
    throw new IOException("Could not claim data interface.");
  }
  mReadEndpoint = mDataInterface.getEndpoint(1);
  Log.d(TAG, "Read endpoint direction: " + mReadEndpoint.getDirection());
  mWriteEndpoint = mDataInterface.getEndpoint(0);
  Log.d(TAG, "Write endpoint direction: " + mWriteEndpoint.getDirection());
}

public CDCSerialDevice(UsbDevice device, UsbDeviceConnection connection, int iface)
{
  super(device, connection);
  mInterface = device.getInterface(iface >= 0 ? iface : findFirstCDC(device));
}

private void openInterface() throws IOException {
  Log.d(TAG, "claiming interfaces, count=" + mDevice.getInterfaceCount());
  mControlInterface = mDevice.getInterface(0);
  Log.d(TAG, "Control iface=" + mControlInterface);
  // class should be USB_CLASS_COMM
  if (!mConnection.claimInterface(mControlInterface, true)) {
    throw new IOException("Could not claim control interface.");
  }
  mControlEndpoint = mControlInterface.getEndpoint(0);
  Log.d(TAG, "Control endpoint direction: " + mControlEndpoint.getDirection());
  Log.d(TAG, "Claiming data interface.");
  mDataInterface = mDevice.getInterface(1);
  Log.d(TAG, "data iface=" + mDataInterface);
  // class should be USB_CLASS_CDC_DATA
  if (!mConnection.claimInterface(mDataInterface, true)) {
    throw new IOException("Could not claim data interface.");
  }
  mReadEndpoint = mDataInterface.getEndpoint(1);
  Log.d(TAG, "Read endpoint direction: " + mReadEndpoint.getDirection());
  mWriteEndpoint = mDataInterface.getEndpoint(0);
  Log.d(TAG, "Write endpoint direction: " + mWriteEndpoint.getDirection());
}

/**
 * Stops listening on all inputs and closes the current USB connection, if any.
 */
@Override
public synchronized void close() {
 if (connection == null) return;
 for (UsbMidiInterface iface : interfaces) {
  iface.stop();
  connection.releaseInterface(iface.getInterface());
 }
 connection.close();
 connection = null;
}

@Override
public void onConnect() {
  int ifIdx = 0;
  UsbInterface iface = usbDevice.getInterface(ifIdx);
  if (usbConnection.claimInterface(iface, true)) {
    logger.log("Interface claimed successfully\n");
  } else {
    logger.log("ERROR - can't claim interface\n");
  }
  super.onConnect();
}

@Override
public void onConnect() {
  // Serial mode only
  // TODO: find the interface and endpoint indexes no matter what mode it is
  int ifIdx = 1;
  int epInIdx = 1;
  int epOutIdx = 0;
  UsbInterface iface = usbDevice.getInterface(ifIdx);
  if (usbConnection.claimInterface(iface, true)) {
    logger.log("Interface claimed successfully\n");
  } else {
    logger.log("ERROR - can't claim interface\n");
    return;
  }
  endpointIn = iface.getEndpoint(epInIdx);
  endpointOut = iface.getEndpoint(epOutIdx);
  super.onConnect();
}

Popular methods of UsbDevice

Popular in Java

Creating JSON documents from java classes using gson
onCreateOptionsMenu (Activity)
compareTo (BigDecimal)
Compares this BigDecimal with the specified BigDecimal. Two BigDecimal objects that are equal in val
setScale (BigDecimal)
Returns a BigDecimal whose scale is the specified value, and whose value is numerically equal to thi
Thread (java.lang)
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to ha
DateFormat (java.text)
Formats or parses dates and times.This class provides factories for obtaining instances configured f
HashSet (java.util)
HashSet is an implementation of a Set. All optional operations (adding and removing) are supported.
CountDownLatch (java.util.concurrent)
A synchronization aid that allows one or more threads to wait until a set of operations being perfor
Semaphore (java.util.concurrent)
A counting semaphore. Conceptually, a semaphore maintains a set of permits. Each #acquire blocks if
Logger (org.slf4j)
The org.slf4j.Logger interface is the main user entry point of SLF4J API. It is expected that loggin

Best Java code snippets using android.hardware.usb.UsbDevice.getInterface (Showing top 20 results out of 315)