I&#39;m trying to get some data out of a USB device connected to my Android phone that is on host mode. I&#39;m able to send data to it, but reading fails.

I&#39;ve looked at [several][1] [examples][2] and tried all I could but I don&#39;t have any experience in USB communication, although by now I know a little, and I&#39;ve been stuck on this longer that I care to admit.

I&#39;m not very familiar with the endpoint configuration, but I know is that my device uses a CDC type communication method and both the output (from phone to device) and input are registered.

Here&#39;s the whole class that manages the USB connection with the only device that is connected to the phone, it&#39;s not finished by any means, but I&#39;d like to get that reading part to work before I go any further.

    public class UsbCommunicationManager
    {
    	static final String ACTION_USB_PERMISSION = &quot;com.android.example.USB_PERMISSION&quot;;
    
    	UsbManager usbManager;
    	UsbDevice usbDevice;
    	UsbInterface intf = null;
    	UsbEndpoint input, output;
    	UsbDeviceConnection connection;
    
    	PendingIntent permissionIntent;
    
    	Context context;
    
    	byte[] readBytes = new byte[64];
    
    	public UsbCommunicationManager(Context context)
    	{
    		this.context = context;
    		usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
    
    		// ask permission from user to use the usb device
    		permissionIntent = PendingIntent.getBroadcast(context, 0, new Intent(ACTION_USB_PERMISSION), 0);
    		IntentFilter filter = new IntentFilter(ACTION_USB_PERMISSION);
    		context.registerReceiver(usbReceiver, filter);
    	}
    
    	public void connect()
    	{
    		// check if there&#39;s a connected usb device
    		if(usbManager.getDeviceList().isEmpty())
    		{
    			Log.d(&quot;trebla&quot;, &quot;No connected devices&quot;);
    			return;
    		}
    
    		// get the first (only) connected device
    		usbDevice = usbManager.getDeviceList().values().iterator().next();
    
    		// user must approve of connection
    		usbManager.requestPermission(usbDevice, permissionIntent);
    	}
    
    	public void stop()
    	{
    		context.unregisterReceiver(usbReceiver);
    	}
    
    	public String send(String data)
    	{
    		if(usbDevice == null)
    		{
    			return &quot;no usb device selected&quot;;
    		}
    
    		int sentBytes = 0;
    		if(!data.equals(&quot;&quot;))
    		{
    			synchronized(this)
    			{
    				// send data to usb device
    				byte[] bytes = data.getBytes();
    				sentBytes = connection.bulkTransfer(output, bytes, bytes.length, 1000);
    			}
    		}
    
    		return Integer.toString(sentBytes);
    	}
    
    	public String read()
    	{
    		// reinitialize read value byte array
    		Arrays.fill(readBytes, (byte) 0);
    
    		// wait for some data from the mcu
    		int recvBytes = connection.bulkTransfer(input, readBytes, readBytes.length, 3000);
    
    		if(recvBytes &gt; 0)
    		{
    			Log.d(&quot;trebla&quot;, &quot;Got some data: &quot; + new String(readBytes));
    		}
    		else
    		{
    			Log.d(&quot;trebla&quot;, &quot;Did not get any data: &quot; + recvBytes);
    		}
    
    		return Integer.toString(recvBytes);
    	}
    
    	public String listUsbDevices()
    	{
    		HashMap&lt;String, UsbDevice&gt; deviceList = usbManager.getDeviceList();
    
    		if(deviceList.size() == 0)
    		{
    			return &quot;no usb devices found&quot;;
    		}
    
    		Iterator&lt;UsbDevice&gt; deviceIterator = deviceList.values().iterator();
    		String returnValue = &quot;&quot;;
    		UsbInterface usbInterface;
    
    		while(deviceIterator.hasNext())
    		{
    			UsbDevice device = deviceIterator.next();
    			returnValue += &quot;Name: &quot; + device.getDeviceName();
    			returnValue += &quot;\nID: &quot; + device.getDeviceId();
    			returnValue += &quot;\nProtocol: &quot; + device.getDeviceProtocol();
    			returnValue += &quot;\nClass: &quot; + device.getDeviceClass();
    			returnValue += &quot;\nSubclass: &quot; + device.getDeviceSubclass();
    			returnValue += &quot;\nProduct ID: &quot; + device.getProductId();
    			returnValue += &quot;\nVendor ID: &quot; + device.getVendorId();
    			returnValue += &quot;\nInterface count: &quot; + device.getInterfaceCount();
    
    			for(int i = 0; i &lt; device.getInterfaceCount(); i++)
    			{
    				usbInterface = device.getInterface(i);
    				returnValue += &quot;\n  Interface &quot; + i;
    				returnValue += &quot;\n\tInterface ID: &quot; + usbInterface.getId();
    				returnValue += &quot;\n\tClass: &quot; + usbInterface.getInterfaceClass();
    				returnValue += &quot;\n\tProtocol: &quot; + usbInterface.getInterfaceProtocol();
    				returnValue += &quot;\n\tSubclass: &quot; + usbInterface.getInterfaceSubclass();
    				returnValue += &quot;\n\tEndpoint count: &quot; + usbInterface.getEndpointCount();
    
    				for(int j = 0; j &lt; usbInterface.getEndpointCount(); j++)
    				{
    					returnValue += &quot;\n\t  Endpoint &quot; + j;
    					returnValue += &quot;\n\t\tAddress: &quot; + usbInterface.getEndpoint(j).getAddress();
    					returnValue += &quot;\n\t\tAttributes: &quot; + usbInterface.getEndpoint(j).getAttributes();
    					returnValue += &quot;\n\t\tDirection: &quot; + usbInterface.getEndpoint(j).getDirection();
    					returnValue += &quot;\n\t\tNumber: &quot; + usbInterface.getEndpoint(j).getEndpointNumber();
    					returnValue += &quot;\n\t\tInterval: &quot; + usbInterface.getEndpoint(j).getInterval();
    					returnValue += &quot;\n\t\tType: &quot; + usbInterface.getEndpoint(j).getType();
    					returnValue += &quot;\n\t\tMax packet size: &quot; + usbInterface.getEndpoint(j).getMaxPacketSize();
    				}
    			}
    		}
    
    		return returnValue;
    	}
    
    	private void setupConnection()
    	{
    		// find the right interface
    		for(int i = 0; i &lt; usbDevice.getInterfaceCount(); i++)
    		{
    			// communications device class (CDC) type device
    			if(usbDevice.getInterface(i).getInterfaceClass() == UsbConstants.USB_CLASS_CDC_DATA)
    			{
    				intf = usbDevice.getInterface(i);
    
    				// find the endpoints
    				for(int j = 0; j &lt; intf.getEndpointCount(); j++)
    				{
    					if(intf.getEndpoint(j).getDirection() == UsbConstants.USB_DIR_OUT &amp;&amp; intf.getEndpoint(j).getType() == UsbConstants.USB_ENDPOINT_XFER_BULK)
    					{
    						// from android to device
    						output = intf.getEndpoint(j);
    					}
    
    					if(intf.getEndpoint(j).getDirection() == UsbConstants.USB_DIR_IN &amp;&amp; intf.getEndpoint(j).getType() == UsbConstants.USB_ENDPOINT_XFER_BULK)
    					{
    						// from device to android
    						input = intf.getEndpoint(j);
    					}
    				}
    			}
    		}
    	}
    
    	private final BroadcastReceiver usbReceiver = new BroadcastReceiver()
    	{
    		public void onReceive(Context context, Intent intent)
    		{
    			String action = intent.getAction();
    			if(ACTION_USB_PERMISSION.equals(action))
    			{
    				// broadcast is like an interrupt and works asynchronously with the class, it must be synced just in case
    				synchronized(this)
    				{
    					if(intent.getBooleanExtra(UsbManager.EXTRA_PERMISSION_GRANTED, false))
    					{
    						setupConnection();
    
    						connection = usbManager.openDevice(usbDevice);
    						connection.claimInterface(intf, true);
    
    						// set flow control to 8N1 at 9600 baud
    						int baudRate = 9600;
    						byte stopBitsByte = 1;
    						byte parityBitesByte = 0;
    						byte dataBits = 8;
    						byte[] msg = {
    							(byte) (baudRate &amp; 0xff),
    							(byte) ((baudRate &gt;&gt; 8) &amp; 0xff),
    							(byte) ((baudRate &gt;&gt; 16) &amp; 0xff),
    							(byte) ((baudRate &gt;&gt; 24) &amp; 0xff),
    							stopBitsByte,
    							parityBitesByte,
    							(byte) dataBits
    						};
    
    						connection.controlTransfer(UsbConstants.USB_TYPE_CLASS | 0x01, 0x20, 0, 0, msg, msg.length, 5000);
    					}
    					else
    					{
    						Log.d(&quot;trebla&quot;, &quot;Permission denied for USB device&quot;);
    					}
    				}
    			}
    			else if(UsbManager.ACTION_USB_DEVICE_DETACHED.equals(action))
    			{
    				Log.d(&quot;trebla&quot;, &quot;USB device detached&quot;);
    			}
    		}
    	};
    }

I keep getting `-1` from the `read()` method which indicates some kind of error, it always times out. Maybe the problem comes from the connection configuration, I&#39;ve tried several (read: trial and error) and none worked, surprisingly I don&#39;t need any configuration to send data to the device.

---

*Edit*

It must also be noted that the cable I&#39;m using is micro-USB to micro-USB and it only works in one way, that is my device is powered by my phone only when the plug A connected to phone and plug B connected to device, not the other way around... it seems very strange. The fact that I&#39;m able to send data and not receive when plugged the _right way_ remains.

---

*EDIT 2*

I found that [somebody else had the same problem][3] but it seems he wasn&#39;t able to solve it.

---

*EDIT 3*

I finally found the solution on [this page][4]:

&gt; Another major oversight is that there is no mechanism for the host to notify the device that there is a data sink on the host side ready to accept data. This means that the device may try to send data while the host isn&#39;t listening, causing lengthy blocking timeouts in the transmission routines. It is thus highly recommended that the virtual serial line DTR (Data Terminal Ready) signal be used where possible to determine if a host application is ready for data.

So the DTR signal was mandatory and all I had to do was to add this to the interface configuration:

    connection.controlTransfer(0x21, 0x22, 0x1, 0, null, 0, 0);


---

*EDIT 4*

If anybody is interested I finished the project and it&#39;s [open source and published on my GitHub account][5]. It&#39;s not stable all the time though (see the [notes][6]) and I don&#39;t plan working on it anymore, but it works. Feel free to use it for your own projects.


  [1]: https://github.com/mik3y/usb-serial-for-android
  [2]: https://github.com/ksksue/FTDriver
  [3]: http://www.basic4ppc.com/android/forum/threads/usb-to-arduino-only-working-in-one-direction.28569/
  [4]: http://www.fourwalledcubicle.com/files/LUFA/Doc/120730/html/group___group___u_s_b_class_c_d_c_device.html
  [5]: https://github.com/Nurgak/Smartphone-sensor-data-collection-application
  [6]: https://github.com/Nurgak/Smartphone-sensor-data-collection-application#notes

All Cdc Solutions on Gang of Coders

Total of 1 Cdc Solutions

Android USB host read from device