How to establish communication between android device and usb

[NeelNisha Singh]

I need to establish communication between Android device(Acting as USB Host) and USB for data transfer and receive both
i'v gone through some sites and found some idea ,I have attached code ,Please tell while testing on emulator how can i get USB connectivity,or if i'm testing attached android app directly on
real device then if any error will come then how can i see log cat,I'm not able to understand.Please help
Please advice me also whether attached source code will be helpful for establishing communication between android host device and USB.Please help its urgent

Here the code
<1>

public class UsbControllerActivity extends Activity {
	/** Called when the activity is first created. */
	private static final int VID = 4292;//will be change as per connected usb device
	private static final int PID = 60000;//will be change as per connected usb device
	private static UsbController sUsbController;

	@Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        
        initialize();
    }

	private void initialize() {
		if(sUsbController == null){
	        sUsbController = new UsbController(this, mConnectionHandler, VID, PID);//##########1//creating usbcontroller class for creating usbmanager and finding connected usb devices
        }
      
        ((Button)findViewById(R.id.button1)).setOnClickListener(new View.OnClickListener() {
			@Override
			public void onClick(View v) {
				if(sUsbController == null)
					sUsbController = new UsbController(UsbControllerActivity.this, mConnectionHandler, VID, PID);
				else{
					sUsbController.stop();
					sUsbController = new UsbController(UsbControllerActivity.this, mConnectionHandler, VID, PID);
				}
			}
		});
	}

	private final IUsbConnectionHandler mConnectionHandler = new IUsbConnectionHandler() {
		@Override
		public void onUsbStopped() {
			L.e("Usb stopped!");
		}
		
		@Override
		public void onErrorLooperRunningAlready() {
			L.e("Looper already running!");
		}
		
		@Override
		public void onDeviceNotFound() {
			if(sUsbController != null){
				sUsbController.stop();
				sUsbController = null;
			}
		}
	};
}

<2>

public class UsbController {

	private final Context mApplicationContext;
	private final UsbManager mUsbManager;
	private final IUsbConnectionHandler mConnectionHandler;
	private final int VID;
	private final int PID;
	protected static final String ACTION_USB_PERMISSION = "ch.serverbox.android.USB";

	/**
	 * Activity is needed for onResult
	 * 
	 * @param parentActivity
	 */
	public UsbController(Activity parentActivity,
			IUsbConnectionHandler connectionHandler, int vid, int pid) {   //############ 2  Usbmanager creation
		mApplicationContext = parentActivity.getApplicationContext();
		mConnectionHandler = connectionHandler;
		mUsbManager = (UsbManager) mApplicationContext
				.getSystemService(Context.USB_SERVICE);
		VID = vid;
		PID = pid;
		init();// ########### 3
	}

	private void init() {// ########  3 finding connected usb devices and obtaining permission for the connected device through Broadcast Receiver
		enumerate(new IPermissionListener() {
			@Override
			public void onPermissionDenied(UsbDevice d) {
				UsbManager usbman = (UsbManager) mApplicationContext
						.getSystemService(Context.USB_SERVICE);
				PendingIntent pi = PendingIntent.getBroadcast(
						mApplicationContext, 0, new Intent(
								ACTION_USB_PERMISSION), 0);
				mApplicationContext.registerReceiver(mPermissionReceiver,
						new IntentFilter(ACTION_USB_PERMISSION));
				usbman.requestPermission(d, pi);
			}
		});
	}

	public void stop() {
		mStop = true;
		synchronized (sSendLock) {
			sSendLock.notify();
		}
		try {
			if(mUsbThread != null)
				mUsbThread.join();
		} catch (InterruptedException e) {
			e(e);
		}
		mStop = false;
		mLoop = null;
		mUsbThread = null;
		
		try{
			mApplicationContext.unregisterReceiver(mPermissionReceiver);
		}catch(IllegalArgumentException e){};//bravo
	}

	private UsbRunnable mLoop;
	private Thread mUsbThread;

	private void startHandler(UsbDevice d) {
		if (mLoop != null) {// if already running then no need to initialize run method
			mConnectionHandler.onErrorLooperRunningAlready();
			return;
		}
		mLoop = new UsbRunnable(d);//else start run method /thread
		mUsbThread = new Thread(mLoop);
		mUsbThread.start();
	}

	public void send(byte data) {
		mData = data;
		synchronized (sSendLock) {
			sSendLock.notify();
		}
	}

	private void enumerate(IPermissionListener listener) {   // ########## 4 finding list of connected devices ans after finding
		l("enumerating");
		HashMap<String, UsbDevice> devlist = mUsbManager.getDeviceList();
		Iterator<UsbDevice> deviter = devlist.values().iterator();
		
		System.out.println("Before deviceIterator:"+devlist.size() );
		l("Before deviceIterator:"+devlist.size() );
		
		while (deviter.hasNext()) 
		{
			UsbDevice d = deviter.next();
			l("Found device: "+ String.format("%04X:%04X", d.getVendorId(),d.getProductId()));
			
			System.out.println("Found device:" + String.format("%04X:%04X", d.getVendorId(),d.getProductId()));
			
				l("Device under: " + d.getDeviceName());
				if (!mUsbManager.hasPermission(d))
					listener.onPermissionDenied(d);
				else{
					startHandler(d);// ########### 5 start handling of usb device
					return;
				}
				break;
			
		}
		l("no more devices found");
		mConnectionHandler.onDeviceNotFound();
	}

	private class PermissionReceiver extends BroadcastReceiver {
		private final IPermissionListener mPermissionListener;

		public PermissionReceiver(IPermissionListener permissionListener) {
			mPermissionListener = permissionListener;
		}

		@Override
		public void onReceive(Context context, Intent intent) {
			mApplicationContext.unregisterReceiver(this);
			if (intent.getAction().equals(ACTION_USB_PERMISSION)) {
				if (!intent.getBooleanExtra(
						UsbManager.EXTRA_PERMISSION_GRANTED, false)) {
					mPermissionListener.onPermissionDenied((UsbDevice) intent
							.getParcelableExtra(UsbManager.EXTRA_DEVICE));
				} else {
					l("Permission granted");
					UsbDevice dev = (UsbDevice) intent
							.getParcelableExtra(UsbManager.EXTRA_DEVICE);
					if (dev != null) {
//						if (dev.getVendorId() == VID
//								&& dev.getProductId() == PID) {
							startHandler(dev);// has new thread
//						}
					} else {
						e("device not present!");
					}
				}
			}
		}

	}

	// MAIN LOOP
	private static final Object[] sSendLock = new Object[]{};//learned this trick from some google example :)
	//basically an empty array is lighter than an  actual new Object()...
	private boolean mStop = false;
	private byte mData = 0x00;

	private class UsbRunnable implements Runnable {// ######### 6 Usb handling
		private final UsbDevice mDevice;
	
		UsbRunnable(UsbDevice dev) {
			mDevice = dev;
		}
	
		@Override
		public void run() {//here the main USB functionality is implemented
			UsbDeviceConnection conn = mUsbManager.openDevice(mDevice);
			if (!conn.claimInterface(mDevice.getInterface(1), true)) {
				return;
			}
			
			// Arduino Serial usb Conv
			conn.controlTransfer(0x40, 0, 0, 0, null, 0, 0);  // reset
                                                              // mConnection.controlTransfer(0×40,
                                                              // 0, 1, 0, null, 0,
                                                              // 0);//clear Rx
            conn.controlTransfer(0x40, 0, 2, 0, null, 0, 0);  // clear Tx
            conn.controlTransfer(0x40, 0x02, 0x0000, 0, null, 0, 0); // flow
                                                                     // control
                                                                     // none
            conn.controlTransfer(0x40, 0x03, 0x0034, 0, null, 0, 0);   // baudrate
                                                                    // 57600
            conn.controlTransfer(0x40, 0x04, 0x0008, 0, null, 0, 0);// data bit
                                                                    // 8, parity
                                                                    // none,
                                                                   // stop bit
                                                                   // 1, tx off
	
			UsbEndpoint epIN = null;//usb endpoints used for receiving data through USB
			UsbEndpoint epOUT = null;//usb endpoints used for sending data through USB
	
			UsbInterface usbIf = mDevice.getInterface(1);
			
			for (int i = 0; i < usbIf.getEndpointCount(); i++) {// this loop is for finding endpoint direction and type
				if (usbIf.getEndpoint(i).getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
					if (usbIf.getEndpoint(i).getDirection() == UsbConstants.USB_DIR_IN)//from device to host(android device is host)
						epIN = usbIf.getEndpoint(i);
					else
						epOUT = usbIf.getEndpoint(i);
				}
			}
	
			for (;;) {// ##################### this is the main loop for send/ transferring ##########
                try 
                {
                    Thread.sleep(100);
                } 
                catch (InterruptedException e) 
                {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                String get = "$fDump G" + "\n";
                l("Sending: " + get);

                byte[] by = get.getBytes();

                // This is where it sends
                
                int transferData=conn.bulkTransfer(epOUT, by, by.length, 500);
                
                l("out " + transferData);
                
                // ################## This is where it is meant to receive ########################
                
                byte[] buffer = new byte[4096];

                StringBuilder str = new StringBuilder();

                if (conn.bulkTransfer(epIN, buffer, 4096, 500) >= 0) {
                    for (int i = 2; i < 4096; i++) {
                        if (buffer[i] != 0) {
                            str.append((char) buffer[i]);
                        } else {
                            l(str);
                            break;
                        }
                    }

                }
                // ##################### this shows the complete string #####################
                l(str);
                
				if (mStop) {
					mConnectionHandler.onUsbStopped();
					return;
				}
			}
		}
	}

	// END MAIN LOOP
	private BroadcastReceiver mPermissionReceiver = new PermissionReceiver(
			new IPermissionListener() {
				@Override
				public void onPermissionDenied(UsbDevice d) {
					l("Permission denied on " + d.getDeviceId());
				}
			});

	private static interface IPermissionListener {
		void onPermissionDenied(UsbDevice d);
	}

	public final static String TAG = "USBController";

	private void l(Object msg) {
		Log.d(TAG, ">==< " + msg.toString() + " >==<");
	}

	private void e(Object msg) {
		Log.e(TAG, ">==< " + msg.toString() + " >==<");
	}
}

[Ulf Dittmer]

My advice would be to find a real device and simply check whether what this code does is useful for your purposes or not. If you're serious about Android development, then there is no substitute to having an actual device available.

[NeelNisha Singh]

Thanks for the Reply Ulf !!!
I asked one more question that if I'll be testing my code on real device then how I'll be able to see log cat to trace errors/information,since my real device will be connected to some other device through USB

I have already gone through this link for Window XP

http://developer.android.com/tools/extras/oem-usb.html

[Ulf Dittmer]

Maybe add a TextView to the main layout, and append all logged messages to that.

[NeelNisha Singh]

Hi,
I found this

public class LogTest extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
try {
Process process = Runtime.getRuntime().exec("logcat -d");
BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(process.getInputStream()));

StringBuilder log=new StringBuilder();
String line;
while ((line = bufferedReader.readLine()) != null) {
log.append(line);
}
TextView tv = (TextView)findViewById(R.id.textView1);
tv.setText(log.toString());
} catch (IOException e) {
}
}
}


But one confusion is there how I'll find line numbers also and option "logcat -d" will give only debugging messages not error messages,so ow to get error messages of logcat too with line number,if any small code example will be there then please provide and explain

[Ulf Dittmer]

logcat never shows line numbers; what benefit would that have? If you create logcat output you know where in the code you are, after all.

option "logcat -d" will give only debugging messages not error messages

That's not what I'm seeing on my device. How did you get that idea?

[Ulf Dittmer]

If you need to experiment with the Android command line, install Jack Palevich's "Terminal Emulator" app.

[NeelNisha Singh]

I want to show only my app related all log cat messages,But writ now I'm getting all unnecessary messages

Here is my code

try {

Process process = Runtime.getRuntime().exec("logcat -d");


BufferedReader bufferedReader = new BufferedReader(
new InputStreamReader(process.getInputStream()));

StringBuilder log=new StringBuilder();
String line;
while ((line = bufferedReader.readLine()) != null) {
log.append(line+"\n");
}
TextView tv = (TextView)findViewById(R.id.textView1);
tv.setText(log.toString());
}
catch (IOException exception)
{
exception.printStackTrace();
}


I have attached output screen shot also,Please help

[Ulf Dittmer]

Hm, on the command line you could just do a "logcat | grep -i <my package name>", but that won't work with Runtime.exec.

The alternative is to change your code so it prints just the lines that have your logging tag, or the package name of your classes. That's one line of code.