Skip to content

Commit

Permalink
Merge remote branch 'defy/rewrite' into rewrite
Browse files Browse the repository at this point in the history
  • Loading branch information
@nadlabak
nadlabak committed Aug 24, 2011
2 parents 99bd5f2 + 06873ff commit 5a9471d
Show file tree
Hide file tree
Showing 2 changed files with 95 additions and 90 deletions.
171 changes: 86 additions & 85 deletions src/com/motorola/usb/UsbListener.java
View file
Original file line number Original file line Diff line number Diff line change
Expand Up @@ -20,6 +20,7 @@
import android.net.LocalSocket; import android.net.LocalSocket;
import android.net.LocalSocketAddress; import android.net.LocalSocketAddress;
import android.os.Handler; import android.os.Handler;
import android.os.HandlerThread;
import android.os.Looper; import android.os.Looper;
import android.os.Message; import android.os.Message;
import android.os.SystemClock; import android.os.SystemClock;
Expand All @@ -32,9 +33,13 @@ public final class UsbListener implements Runnable
{ {
private static final String TAG = "UsbListener"; private static final String TAG = "UsbListener";


private LocalSocket mSocket;
private OutputStream mOutputStream; private OutputStream mOutputStream;
private Handler mHandler;
private WriteCommandThread mWriteThread; private boolean mRunning;
private Handler mUiHandler;
private Handler mWriteHandler;
private HandlerThread mWriteThread;


public static final String EVENT_CABLE_CONNECTED = "cable_connected"; public static final String EVENT_CABLE_CONNECTED = "cable_connected";
public static final String EVENT_CABLE_CONNECTED_FACTORY = "cable_connected_factory"; public static final String EVENT_CABLE_CONNECTED_FACTORY = "cable_connected_factory";
Expand Down Expand Up @@ -76,10 +81,13 @@ public final class UsbListener implements Runnable
public static final String CMD_UNLOAD_DRIVER = "usb_unload_driver"; public static final String CMD_UNLOAD_DRIVER = "usb_unload_driver";


public UsbListener(Handler handler) { public UsbListener(Handler handler) {
mHandler = handler; mUiHandler = handler;
mWriteThread = new WriteCommandThread(); mRunning = true;


mWriteThread = new HandlerThread("UsbService command writer");
mWriteThread.start(); mWriteThread.start();

mWriteHandler = new Handler(mWriteThread.getLooper());
} }


private void handleEvent(String event) { private void handleEvent(String event) {
Expand All @@ -91,91 +99,75 @@ private void handleEvent(String event) {
} }


if (event.equals(EVENT_CABLE_CONNECTED)) { if (event.equals(EVENT_CABLE_CONNECTED)) {
mHandler.sendEmptyMessage(UsbService.MSG_CABLE_ATTACHED); mUiHandler.sendEmptyMessage(UsbService.MSG_CABLE_ATTACHED);
} else if (event.equals(EVENT_ENUMERATED)) { } else if (event.equals(EVENT_ENUMERATED)) {
mHandler.sendEmptyMessage(UsbService.MSG_ENUMERATED); mUiHandler.sendEmptyMessage(UsbService.MSG_ENUMERATED);
} else if (event.equals(EVENT_CABLE_CONNECTED_FACTORY)) { } else if (event.equals(EVENT_CABLE_CONNECTED_FACTORY)) {
sendUsbModeSwitchCmd(MODE_NGP); sendUsbModeSwitchCmd(MODE_NGP);
} else if (event.equals(EVENT_GET_DESCRIPTOR)) { } else if (event.equals(EVENT_GET_DESCRIPTOR)) {
mHandler.sendEmptyMessage(UsbService.MSG_GET_DESCRIPTOR); mUiHandler.sendEmptyMessage(UsbService.MSG_GET_DESCRIPTOR);
} else if (event.equals(EVENT_CABLE_DISCONNECTED)) { } else if (event.equals(EVENT_CABLE_DISCONNECTED)) {
mHandler.sendEmptyMessage(UsbService.MSG_CABLE_DETACHED); mUiHandler.sendEmptyMessage(UsbService.MSG_CABLE_DETACHED);
} else if (event.equals(EVENT_ADB_ON)) { } else if (event.equals(EVENT_ADB_ON)) {
mHandler.sendMessage(mHandler.obtainMessage(UsbService.MSG_ADB_CHANGE, 1, 0)); mUiHandler.sendMessage(mUiHandler.obtainMessage(UsbService.MSG_ADB_CHANGE, 1, 0));
} else if (event.equals(EVENT_ADB_OFF)) { } else if (event.equals(EVENT_ADB_OFF)) {
mHandler.sendMessage(mHandler.obtainMessage(UsbService.MSG_ADB_CHANGE, 0, 0)); mUiHandler.sendMessage(mUiHandler.obtainMessage(UsbService.MSG_ADB_CHANGE, 0, 0));
} else if (event.startsWith(EVENT_START_PREFIX)) { } else if (event.startsWith(EVENT_START_PREFIX)) {
mHandler.sendMessage(mHandler.obtainMessage(UsbService.MSG_START_SERVICE, event)); mUiHandler.sendMessage(mUiHandler.obtainMessage(UsbService.MSG_START_SERVICE, event));
} else if (event.startsWith(EVENT_REQ_PREFIX)) { } else if (event.startsWith(EVENT_REQ_PREFIX)) {
mHandler.sendMessage(mHandler.obtainMessage(UsbService.MSG_USBD_MODE_SWITCH, event)); mUiHandler.sendMessage(mUiHandler.obtainMessage(UsbService.MSG_USBD_MODE_SWITCH, event));
} else if (event.contains(SWITCH_OK_POSTFIX)) { } else if (event.contains(SWITCH_OK_POSTFIX)) {
mHandler.sendMessage(mHandler.obtainMessage(UsbService.MSG_MODE_SWITCH_COMPLETE, 1, 0)); mUiHandler.sendMessage(mUiHandler.obtainMessage(UsbService.MSG_MODE_SWITCH_COMPLETE, 1, 0));
} else if (event.contains(SWITCH_FAIL_POSTFIX)) { } else if (event.contains(SWITCH_FAIL_POSTFIX)) {
mHandler.sendMessage(mHandler.obtainMessage(UsbService.MSG_MODE_SWITCH_COMPLETE, 0, 0)); mUiHandler.sendMessage(mUiHandler.obtainMessage(UsbService.MSG_MODE_SWITCH_COMPLETE, 0, 0));
} else { } else {
Log.e(TAG, "Got invalid event " + event); Log.e(TAG, "Got invalid event " + event);
} }
} }


private void listenToSocket() { private synchronized void openSocket() throws IOException {
LocalSocket usbdSocket = null; LocalSocketAddress socketAddress =

new LocalSocketAddress("/dev/socket/usbd", LocalSocketAddress.Namespace.FILESYSTEM);
try {
usbdSocket = new LocalSocket();
LocalSocketAddress socketAddress =
new LocalSocketAddress("/dev/socket/usbd", LocalSocketAddress.Namespace.FILESYSTEM);

usbdSocket.connect(socketAddress);


InputStream usbdInputStream = usbdSocket.getInputStream(); mSocket = new LocalSocket();
synchronized (this) { mSocket.connect(socketAddress);
mOutputStream = usbdSocket.getOutputStream(); mOutputStream = mSocket.getOutputStream();
} }


byte[] buffer = new byte[100]; private void listenToSocket() throws IOException {
InputStream usbdInputStream = mSocket.getInputStream();
byte[] buffer = new byte[100];


while (true) { while (true) {
int count = usbdInputStream.read(buffer); int count = usbdInputStream.read(buffer);


if (count < 0) { if (count < 0) {
/* failure */ throw new IOException("Unexpected end of stream");
break; }
}


int pos, start; int pos, start;
for (pos = 0, start = 0; pos < count; pos++) { for (pos = 0, start = 0; pos < count; pos++) {
if (buffer[pos] == 0) { if (buffer[pos] == 0) {
handleEvent(new String(buffer, start, pos - start)); handleEvent(new String(buffer, start, pos - start));
start = pos + 1; start = pos + 1;
}
} }
} }
} catch (IOException e) {
Log.e(TAG, "IOException, connect/read socket", e);
} }
}


//clean up private synchronized void closeSocket() {
synchronized (this) { try {
if (mOutputStream != null) { if (mOutputStream != null) {
try { mOutputStream.close();
mOutputStream.close();
} catch (IOException e) {
Log.w(TAG, "IOException closing output stream", e);
}

mOutputStream = null;
} }
mOutputStream = null;


if (usbdSocket != null) { if (mSocket != null) {
try { mSocket.close();
usbdSocket.close();
} catch (IOException e) {
Log.w(TAG, "IOException closing socket", e);
}
} }

mSocket = null;
Log.e(TAG, "Failed to connect to usbd", new IllegalStateException()); } catch (IOException e) {
SystemClock.sleep(2000); Log.w(TAG, "IOException during cleanup", e);
} }
} }


Expand All @@ -191,6 +183,8 @@ private synchronized void writeCommand(String cmd, String arg) {
} }
line += '\0'; line += '\0';


Log.d(TAG, "Writing command " + line + " to usbd");

try { try {
mOutputStream.write(line.getBytes()); mOutputStream.write(line.getBytes());
} catch (IOException e) { } catch (IOException e) {
Expand All @@ -199,40 +193,47 @@ private synchronized void writeCommand(String cmd, String arg) {
} }


public void run() { public void run() {
try { while (mRunning) {
while (true) { try {
openSocket();
listenToSocket(); listenToSocket();
closeSocket();
} catch (IOException e) {
if (mRunning) {
Log.w(TAG, "I/O error in socket communication, retrying...", e);
/* do a little rate limitation */
SystemClock.sleep(2000);
}
} catch (Exception e) {
Log.e(TAG, "Fatal error in UsbListener thread!", e);
return;
} }
} catch (Exception e) {
Log.e(TAG, "Fatal error in UsbListener thread!", e);
} }
} }


public void sendUsbModeSwitchCmd(final String cmd) { public synchronized void stop() {
if (cmd != null) { Log.d(TAG, "Stopping...");
Log.d(TAG, "received usb mode change command from UI: " + cmd); mRunning = false;

if (mSocket != null) {
Handler handler = mWriteThread.mHandler; try {
handler.sendMessage(handler.obtainMessage(WriteCommandThread.MSG_WRITE, cmd)); /* forcably stop socket communication */
mSocket.shutdownInput();
} catch (IOException e) {
Log.w(TAG, "I/O error during listener shutdown", e);
}
} }
mWriteThread.quit();
} }


private class WriteCommandThread extends Thread { public void sendUsbModeSwitchCmd(final String cmd) {
public Handler mHandler; if (cmd != null) {
public static final int MSG_WRITE = 1; Log.d(TAG, "received usb mode change command from UI: " + cmd);

mWriteHandler.post(new Runnable() {
public void run() { @Override
Looper.prepare(); public void run() {

writeCommand(cmd, null);
mHandler = new Handler() {
public void handleMessage(Message msg) {
if (msg.what == MSG_WRITE) {
writeCommand((String) msg.obj, null);
}
} }
}; });

Looper.loop();
} }
} }
} }
14 changes: 9 additions & 5 deletions src/com/motorola/usb/UsbService.java
View file
Original file line number Original file line Diff line number Diff line change
Expand Up @@ -225,6 +225,7 @@ public ModeInfo(String name, String mode, String adbMode) {
private StorageManager mStorageManager; private StorageManager mStorageManager;
private NotificationManager mNotifManager; private NotificationManager mNotifManager;


private HandlerThread mStorageThread;
private Handler mStorageHandler; private Handler mStorageHandler;
private Toast mConnectedToast; private Toast mConnectedToast;


Expand Down Expand Up @@ -385,9 +386,9 @@ public void onCreate() {
mStorageManager = (StorageManager) getSystemService(STORAGE_SERVICE); mStorageManager = (StorageManager) getSystemService(STORAGE_SERVICE);
mNotifManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE); mNotifManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);


HandlerThread storageThread = new HandlerThread("Usb switching storage handler"); mStorageThread = new HandlerThread("Usb switching storage handler");
storageThread.start(); mStorageThread.start();
mStorageHandler = new Handler(storageThread.getLooper()); mStorageHandler = new Handler(mStorageThread.getLooper());


mStorageManager.registerListener(mStorageListener); mStorageManager.registerListener(mStorageListener);


Expand All @@ -398,6 +399,8 @@ public void onCreate() {


@Override @Override
public void onDestroy() { public void onDestroy() {
mUsbListener.stop();
mStorageThread.quit();
unregisterReceiver(mUsbServiceReceiver); unregisterReceiver(mUsbServiceReceiver);
mStorageManager.unregisterListener(mStorageListener); mStorageManager.unregisterListener(mStorageListener);
super.onDestroy(); super.onDestroy();
Expand Down Expand Up @@ -490,8 +493,9 @@ private synchronized void handleUsbEvent(int event) {


if (mIsSwitchFrom == USB_SWITCH_FROM_UI if (mIsSwitchFrom == USB_SWITCH_FROM_UI
|| mIsSwitchFrom == USB_SWITCH_FROM_AT_CMD || mIsSwitchFrom == USB_SWITCH_FROM_AT_CMD
|| mIsSwitchFrom == USB_SWITCH_FROM_USBD || mIsSwitchFrom == USB_SWITCH_FROM_USBD) {
|| mIsSwitchFrom == USB_SWITCH_FROM_ADB) { mUsbListener.sendUsbModeSwitchCmd(getSwitchCommand(mNewUsbMode));
} else if (mIsSwitchFrom == USB_SWITCH_FROM_ADB) {
mUsbListener.sendUsbModeSwitchCmd(getSwitchCommand(currentMode)); mUsbListener.sendUsbModeSwitchCmd(getSwitchCommand(currentMode));
} }
} }
Expand Down

0 comments on commit 5a9471d

Please sign in to comment.