Close the fd to wake the reading thread up for termination

This reverts commit 2c23dbd2be.

AndroidManifest.xml

@@ -1,8 +1,8 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
-    package="com.limelight"
-    android:versionCode="31"
-    android:versionName="2.5.3.1" >
+    package="com.limelight.root"
+    android:versionCode="33"
+    android:versionName="2.5.4.1" >
 
     <uses-sdk
         android:minSdkVersion="16"
@@ -14,6 +14,9 @@
     <uses-permission android:name="android.permission.CHANGE_WIFI_MULTICAST_STATE" />
     <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
     
+    <!-- Root permissions -->
+    <uses-permission android:name="android.permission.ACCESS_SUPERUSER" />
+    
     <uses-feature android:name="android.hardware.touchscreen" android:required="false" />
     <uses-feature android:name="android.hardware.wifi" android:required="false" />
 

gen/com/limelight/root/BuildConfig.java

@@ -1,5 +1,5 @@
 /** Automatically generated file. DO NOT MODIFY */
-package com.limelight;
+package com.limelight.root;
 
 public final class BuildConfig {
     public final static boolean DEBUG = true;

gen/com/limelight/root/R.java

@@ -5,7 +5,7 @@
  * should not be modified by hand.
  */
 
-package com.limelight;
+package com.limelight.root;
 
 public final class R {
     public static final class attr {
@@ -49,13 +49,14 @@ or to a theme attribute in the form "<code>?[<i>package</i>:][<i>type</i>:]<i>na
         public static final int config720p30Selected=0x7f08000f;
         public static final int config720p60Selected=0x7f080010;
         public static final int decoderConfigGroup=0x7f080002;
+        public static final int disableToasts=0x7f080014;
         public static final int discoveryText=0x7f08000b;
-        public static final int enableSops=0x7f080014;
+        public static final int enableSops=0x7f080016;
         public static final int hardwareDec=0x7f080005;
         public static final int hostTextView=0x7f080000;
         public static final int manuallyAddPc=0x7f08000c;
         public static final int pcListView=0x7f080008;
-        public static final int rowTextView=0x7f080016;
+        public static final int rowTextView=0x7f080017;
         public static final int settingsButton=0x7f08000d;
         public static final int softwareDec=0x7f080003;
         public static final int streamConfigGroup=0x7f08000e;
@@ -122,8 +123,8 @@ or to a theme attribute in the form "<code>?[<i>package</i>:][<i>type</i>:]<i>na
            <colgroup align="left" />
            <colgroup align="left" />
            <tr><th>Attribute</th><th>Description</th></tr>
-           <tr><td><code>{@link #ButtonBarContainerTheme_buttonBarButtonStyle com.limelight:buttonBarButtonStyle}</code></td><td></td></tr>
-           <tr><td><code>{@link #ButtonBarContainerTheme_buttonBarStyle com.limelight:buttonBarStyle}</code></td><td></td></tr>
+           <tr><td><code>{@link #ButtonBarContainerTheme_buttonBarButtonStyle com.limelight.root:buttonBarButtonStyle}</code></td><td></td></tr>
+           <tr><td><code>{@link #ButtonBarContainerTheme_buttonBarStyle com.limelight.root:buttonBarStyle}</code></td><td></td></tr>
            </table>
            @see #ButtonBarContainerTheme_buttonBarButtonStyle
            @see #ButtonBarContainerTheme_buttonBarStyle
@@ -132,23 +133,23 @@ or to a theme attribute in the form "<code>?[<i>package</i>:][<i>type</i>:]<i>na
             0x7f010000, 0x7f010001
         };
         /**
-          <p>This symbol is the offset where the {@link com.limelight.R.attr#buttonBarButtonStyle}
+          <p>This symbol is the offset where the {@link com.limelight.root.R.attr#buttonBarButtonStyle}
           attribute's value can be found in the {@link #ButtonBarContainerTheme} array.
 
 
           <p>Must be a reference to another resource, in the form "<code>@[+][<i>package</i>:]<i>type</i>:<i>name</i></code>"
 or to a theme attribute in the form "<code>?[<i>package</i>:][<i>type</i>:]<i>name</i></code>".
-          @attr name com.limelight:buttonBarButtonStyle
+          @attr name com.limelight.root:buttonBarButtonStyle
         */
         public static final int ButtonBarContainerTheme_buttonBarButtonStyle = 1;
         /**
-          <p>This symbol is the offset where the {@link com.limelight.R.attr#buttonBarStyle}
+          <p>This symbol is the offset where the {@link com.limelight.root.R.attr#buttonBarStyle}
           attribute's value can be found in the {@link #ButtonBarContainerTheme} array.
 
 
           <p>Must be a reference to another resource, in the form "<code>@[+][<i>package</i>:]<i>type</i>:<i>name</i></code>"
 or to a theme attribute in the form "<code>?[<i>package</i>:][<i>type</i>:]<i>name</i></code>".
-          @attr name com.limelight:buttonBarStyle
+          @attr name com.limelight.root:buttonBarStyle
         */
         public static final int ButtonBarContainerTheme_buttonBarStyle = 0;
     };

jni/evdev_reader/Android.mk

@@ -0,0 +1,12 @@
+# Android.mk for Limelight's Evdev Reader
+MY_LOCAL_PATH := $(call my-dir)
+
+include $(call all-subdir-makefiles)
+
+LOCAL_PATH := $(MY_LOCAL_PATH)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE    := evdev_reader
+LOCAL_SRC_FILES := evdev_reader.c
+
+include $(BUILD_SHARED_LIBRARY)

jni/evdev_reader/evdev_reader.c

@@ -0,0 +1,100 @@
+#include <stdlib.h>
+#include <jni.h>
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <linux/input.h>
+#include <unistd.h>
+#include <poll.h>
+
+JNIEXPORT jint JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_open(JNIEnv *env, jobject this, jstring absolutePath) {
+	const char *path;
+	
+	path = (*env)->GetStringUTFChars(env, absolutePath, NULL);
+	
+	return open(path, O_RDWR);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_grab(JNIEnv *env, jobject this, jint fd) {
+    return ioctl(fd, EVIOCGRAB, 1) == 0;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_ungrab(JNIEnv *env, jobject this, jint fd) {
+    return ioctl(fd, EVIOCGRAB, 0) == 0;
+}
+
+// has*() and friends are based on Android's EventHub.cpp
+
+#define test_bit(bit, array)    (array[bit/8] & (1<<(bit%8)))
+
+JNIEXPORT jboolean JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_hasRelAxis(JNIEnv *env, jobject this, jint fd, jshort axis) {
+    unsigned char relBitmask[(REL_MAX + 1) / 8];
+    
+    ioctl(fd, EVIOCGBIT(EV_REL, sizeof(relBitmask)), relBitmask);
+    
+    return test_bit(axis, relBitmask);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_hasAbsAxis(JNIEnv *env, jobject this, jint fd, jshort axis) {
+    unsigned char absBitmask[(ABS_MAX + 1) / 8];
+    
+    ioctl(fd, EVIOCGBIT(EV_ABS, sizeof(absBitmask)), absBitmask);
+    
+    return test_bit(axis, absBitmask);
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_hasKey(JNIEnv *env, jobject this, jint fd, jshort key) {
+    unsigned char keyBitmask[(KEY_MAX + 1) / 8];
+    
+    ioctl(fd, EVIOCGBIT(EV_KEY, sizeof(keyBitmask)), keyBitmask);
+    
+    return test_bit(key, keyBitmask);
+}
+
+JNIEXPORT jint JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_read(JNIEnv *env, jobject this, jint fd, jbyteArray buffer) {
+    jint ret;
+    jbyte *data;
+    int pollres;
+    struct pollfd pollinfo;
+    
+    data = (*env)->GetByteArrayElements(env, buffer, NULL);
+    if (data == NULL) {
+        return -1;
+    }
+
+    do
+    {
+        // Unwait every 250 ms to return to caller if the fd is closed
+        pollinfo.fd = fd;
+        pollinfo.events = POLLIN;
+        pollinfo.revents = 0;
+        pollres = poll(&pollinfo, 1, 250);
+    }
+    while (pollres == 0);
+    
+    if (pollres > 0 && (pollinfo.revents & POLLIN)) {
+        // We'll have data available now
+        ret = read(fd, data, sizeof(struct input_event));
+    }
+    else {
+        // There must have been a failure
+        ret = -1;
+    }
+    
+    (*env)->ReleaseByteArrayElements(env, buffer, data, 0);
+
+	return ret;
+}
+
+JNIEXPORT jint JNICALL
+Java_com_limelight_binding_input_evdev_EvdevReader_close(JNIEnv *env, jobject this, jint fd) {
+	return close(fd);
+}

res/layout/activity_stream_settings.xml

@@ -54,7 +54,7 @@
             android:id="@+id/advancedSettingsButton"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:layout_below="@+id/enableSops"
+            android:layout_below="@+id/disableToasts"
             android:layout_centerHorizontal="true"
             android:layout_marginTop="15dp"
             android:text="Advanced Settings" />
@@ -74,6 +74,14 @@
             android:layout_below="@+id/stretchToFill"
             android:layout_marginTop="15dp"
             android:text="Allow GFE to modify game settings for optimal streaming" />
+        
+        <CheckBox
+            android:id="@+id/disableToasts"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_below="@+id/enableSops"
+            android:layout_marginTop="15dp"
+            android:text="Disable on-screen connection warning messages" />
 
     </RelativeLayout>
 	

res/values/strings.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
 
-    <string name="app_name">Limelight</string>
+    <string name="app_name">Limelight (Root)</string>
     <string name="title_activity_game">Game</string>
 
 </resources>

src/com/limelight/AddComputerManually.java

@@ -5,6 +5,7 @@ import java.net.UnknownHostException;
 import java.util.concurrent.LinkedBlockingQueue;
 
 import com.limelight.computers.ComputerManagerService;
+import com.limelight.root.R;
 import com.limelight.utils.Dialog;
 
 import android.app.Activity;

src/com/limelight/AdvancedSettings.java

@@ -1,5 +1,6 @@
 package com.limelight;
 
+import com.limelight.root.R;
 import com.limelight.utils.Dialog;
 
 import android.app.Activity;

src/com/limelight/AppView.java

@@ -12,6 +12,7 @@ import com.limelight.binding.PlatformBinding;
 import com.limelight.nvstream.http.GfeHttpResponseException;
 import com.limelight.nvstream.http.NvApp;
 import com.limelight.nvstream.http.NvHTTP;
+import com.limelight.root.R;
 import com.limelight.utils.Dialog;
 import com.limelight.utils.SpinnerDialog;
 

src/com/limelight/Game.java

@@ -4,12 +4,17 @@ package com.limelight;
 import com.limelight.binding.PlatformBinding;
 import com.limelight.binding.input.ControllerHandler;
 import com.limelight.binding.input.KeyboardTranslator;
+import com.limelight.binding.input.TouchContext;
+import com.limelight.binding.input.evdev.EvdevListener;
+import com.limelight.binding.input.evdev.EvdevWatcher;
 import com.limelight.binding.video.ConfigurableDecoderRenderer;
 import com.limelight.nvstream.NvConnection;
 import com.limelight.nvstream.NvConnectionListener;
 import com.limelight.nvstream.StreamConfiguration;
 import com.limelight.nvstream.av.video.VideoDecoderRenderer;
 import com.limelight.nvstream.input.KeyboardPacket;
+import com.limelight.nvstream.input.MouseButtonPacket;
+import com.limelight.root.R;
 import com.limelight.utils.Dialog;
 import com.limelight.utils.SpinnerDialog;
 
@@ -38,13 +43,15 @@ import android.view.WindowManager;
 import android.widget.Toast;
 
 
-public class Game extends Activity implements SurfaceHolder.Callback, OnGenericMotionListener, OnTouchListener, NvConnectionListener {
+public class Game extends Activity implements SurfaceHolder.Callback,
+	OnGenericMotionListener, OnTouchListener, NvConnectionListener, EvdevListener
+{
 	private int lastMouseX = Integer.MIN_VALUE;
 	private int lastMouseY = Integer.MIN_VALUE;
 	private int lastButtonState = 0;
-	private int lastTouchX = 0;
-	private int lastTouchY = 0;
-	private boolean hasMoved = false;
+	
+	// Only 2 touches are supported
+	private TouchContext[] touchContextMap = new TouchContext[2];
 	
 	private ControllerHandler controllerHandler;
 	private KeyboardTranslator keybTranslator;
@@ -60,6 +67,9 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 	private boolean connected = false;
 	
 	private boolean stretchToFit;
+	private boolean toastsDisabled;
+	
+	private EvdevWatcher evdevWatcher;
 	
 	private ConfigurableDecoderRenderer decoderRenderer;
 	
@@ -81,6 +91,7 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 	public static final String BITRATE_PREF_STRING = "Bitrate";
 	public static final String STRETCH_PREF_STRING = "Stretch";
 	public static final String SOPS_PREF_STRING = "Sops";
+	public static final String DISABLE_TOASTS_PREF_STRING = "NoToasts";
 	
 	public static final int BITRATE_DEFAULT_720_30 = 5;
 	public static final int BITRATE_DEFAULT_720_60 = 10;
@@ -94,6 +105,7 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 	public static final int DEFAULT_BITRATE = BITRATE_DEFAULT_720_60;
 	public static final boolean DEFAULT_STRETCH = false;
 	public static final boolean DEFAULT_SOPS = true;
+	public static final boolean DEFAULT_DISABLE_TOASTS = false;
 	
 	public static final int FORCE_HARDWARE_DECODER = -1;
 	public static final int AUTOSELECT_DECODER = 0;
@@ -156,6 +168,7 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 		refreshRate = prefs.getInt(REFRESH_RATE_PREF_STRING, DEFAULT_REFRESH_RATE);
 		bitrate = prefs.getInt(BITRATE_PREF_STRING, DEFAULT_BITRATE);
 		sops = prefs.getBoolean(SOPS_PREF_STRING, DEFAULT_SOPS);
+		toastsDisabled = prefs.getBoolean(DISABLE_TOASTS_PREF_STRING, DEFAULT_DISABLE_TOASTS);
 		
 		Display display = getWindowManager().getDefaultDisplay();
 		display.getSize(screenSize);
@@ -178,7 +191,7 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 		String app = Game.this.getIntent().getStringExtra(EXTRA_APP);
 		String uniqueId = Game.this.getIntent().getStringExtra(EXTRA_UNIQUEID);
         
-		// Start the connection
+		// Initialize the connection
 		conn = new NvConnection(host, uniqueId, Game.this,
 				new StreamConfiguration(app, width, height, refreshRate, bitrate * 1000, sops),
 				PlatformBinding.getCryptoProvider(this));
@@ -194,6 +207,17 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 			sh.setFixedSize(width, height);
 		}
 		
+		// Initialize touch contexts
+		for (int i = 0; i < touchContextMap.length; i++) {
+			touchContextMap[i] = new TouchContext(conn, i);
+		}
+		
+		if (LimelightBuildProps.ROOT_BUILD) {
+			// Start watching for raw input
+			evdevWatcher = new EvdevWatcher(this);
+			evdevWatcher.start();
+		}
+		
 		// The connection will be started when the surface gets created
 		sh.addCallback(this);
 	}
@@ -277,6 +301,10 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 		if (message != null) {
 			Toast.makeText(this, message, Toast.LENGTH_LONG).show();
 		}
+		
+		if (evdevWatcher != null) {
+			evdevWatcher.shutdown();
+		}
 
 		finish();
 	}
@@ -368,43 +396,13 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 		return true;
 	}
 	
-	public void touchDownEvent(int eventX, int eventY)
-	{
-		lastTouchX = eventX;
-		lastTouchY = eventY;
-		hasMoved = false;
-	}
-	
-	public void touchUpEvent(int eventX, int eventY)
-	{
-		if (!hasMoved)
-		{
-			// We haven't moved so send a click
-
-			// Lower the mouse button
-			conn.sendMouseButtonDown((byte) 0x01);
-			
-			// We need to sleep a bit here because some games
-			// do input detection by polling
-			try {
-				Thread.sleep(100);
-			} catch (InterruptedException e) {}
-			
-			// Raise the mouse button
-			conn.sendMouseButtonUp((byte) 0x01);
+	private TouchContext getTouchContext(int actionIndex)
+	{	
+		if (actionIndex < touchContextMap.length) {
+			return touchContextMap[actionIndex];
 		}
-	}
-	
-	public void touchMoveEvent(int eventX, int eventY)
-	{
-		if (eventX != lastTouchX || eventY != lastTouchY)
-		{
-			hasMoved = true;
-			conn.sendMouseMove((short)(eventX - lastTouchX),
-					(short)(eventY - lastTouchY));
-			
-			lastTouchX = eventX;
-			lastTouchY = eventY;
+		else {
+			return null;
 		}
 	}
 	
@@ -416,19 +414,36 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 			if (event.getSource() == InputDevice.SOURCE_TOUCHSCREEN ||
 				event.getSource() == InputDevice.SOURCE_STYLUS)
 			{
-				int eventX = (int)event.getX();
-				int eventY = (int)event.getY();
+				int actionIndex = event.getActionIndex();
 				
+				int eventX = (int)event.getX(actionIndex);
+				int eventY = (int)event.getY(actionIndex);
+				
+				TouchContext context = getTouchContext(actionIndex);
+				if (context == null) {
+					return super.onTouchEvent(event);
+				}
+								
 				switch (event.getActionMasked())
 				{
+				case MotionEvent.ACTION_POINTER_DOWN:
 				case MotionEvent.ACTION_DOWN:
-					touchDownEvent(eventX, eventY);
+					context.touchDownEvent(eventX, eventY);
 					break;
+				case MotionEvent.ACTION_POINTER_UP:
 				case MotionEvent.ACTION_UP:
-					touchUpEvent(eventX, eventY);
+					context.touchUpEvent(eventX, eventY);
+					if (actionIndex == 0 && event.getPointerCount() > 1) {
+						// The original secondary touch now becomes primary
+						context.touchDownEvent((int)event.getX(1), (int)event.getY(1));
+					}
 					break;
 				case MotionEvent.ACTION_MOVE:
-					touchMoveEvent(eventX, eventY);
+					// ACTION_MOVE is special because it always has actionIndex == 0
+					// We'll call the move handlers for all indexes manually
+					for (int i = 0; i < touchContextMap.length; i++) {
+						touchContextMap[i].touchMoveEvent(eventX, eventY);
+					}
 					break;
 				default:
 					return super.onTouchEvent(event);
@@ -441,28 +456,28 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 				
 				if ((changedButtons & MotionEvent.BUTTON_PRIMARY) != 0) {
 					if ((event.getButtonState() & MotionEvent.BUTTON_PRIMARY) != 0) {
-						conn.sendMouseButtonDown((byte) 0x01);
+						conn.sendMouseButtonDown(MouseButtonPacket.BUTTON_LEFT);
 					}
 					else {
-						conn.sendMouseButtonUp((byte) 0x01);
+						conn.sendMouseButtonUp(MouseButtonPacket.BUTTON_LEFT);
 					}
 				}
 				
 				if ((changedButtons & MotionEvent.BUTTON_SECONDARY) != 0) {
 					if ((event.getButtonState() & MotionEvent.BUTTON_SECONDARY) != 0) {
-						conn.sendMouseButtonDown((byte) 0x03);
+						conn.sendMouseButtonDown(MouseButtonPacket.BUTTON_RIGHT);
 					}
 					else {
-						conn.sendMouseButtonUp((byte) 0x03);
+						conn.sendMouseButtonUp(MouseButtonPacket.BUTTON_RIGHT);
 					}
 				}
 				
 				if ((changedButtons & MotionEvent.BUTTON_TERTIARY) != 0) {
 					if ((event.getButtonState() & MotionEvent.BUTTON_TERTIARY) != 0) {
-						conn.sendMouseButtonDown((byte) 0x02);
+						conn.sendMouseButtonDown(MouseButtonPacket.BUTTON_MIDDLE);
 					}
 					else {
-						conn.sendMouseButtonUp((byte) 0x02);
+						conn.sendMouseButtonUp(MouseButtonPacket.BUTTON_MIDDLE);
 					}
 				}
 				
@@ -489,9 +504,19 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 			}		
 		}
 		else if ((event.getSource() & InputDevice.SOURCE_CLASS_POINTER) != 0)
-		{	
-			// Send a mouse move update (if neccessary)
-			updateMousePosition((int)event.getX(), (int)event.getY());
+		{
+			switch (event.getActionMasked())
+			{
+			case MotionEvent.ACTION_HOVER_MOVE:
+				// Send a mouse move update (if neccessary)
+				updateMousePosition((int)event.getX(), (int)event.getY());
+				break;
+			case MotionEvent.ACTION_SCROLL:
+				// Send the vertical scroll packet
+				byte vScrollClicks = (byte) event.getAxisValue(MotionEvent.AXIS_VSCROLL);
+				conn.sendMouseScroll(vScrollClicks);
+				break;
+			}
 			return true;
 		}
 	    
@@ -547,8 +572,10 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 
 	@Override
 	public void stageFailed(Stage stage) {
-		spinner.dismiss();
-		spinner = null;
+		if (spinner != null) {
+			spinner.dismiss();
+			spinner = null;
+		}
 
 		if (!displayedFailureDialog) {
 			displayedFailureDialog = true;
@@ -571,8 +598,10 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 
 	@Override
 	public void connectionStarted() {
-		spinner.dismiss();
-		spinner = null;
+		if (spinner != null) {
+			spinner.dismiss();
+			spinner = null;
+		}
 		
 		connecting = false;
 		connected = true;
@@ -592,12 +621,14 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 
 	@Override
 	public void displayTransientMessage(final String message) {
-		runOnUiThread(new Runnable() {
-			@Override
-			public void run() {
-				Toast.makeText(Game.this, message, Toast.LENGTH_LONG).show();
-			}
-		});
+		if (!toastsDisabled) {
+			runOnUiThread(new Runnable() {
+				@Override
+				public void run() {
+					Toast.makeText(Game.this, message, Toast.LENGTH_LONG).show();
+				}
+			});	
+		}
 	}
 
 	@Override
@@ -627,4 +658,55 @@ public class Game extends Activity implements SurfaceHolder.Callback, OnGenericM
 			connected = false;
 		}
 	}
+
+	@Override
+	public void mouseMove(int deltaX, int deltaY) {
+		conn.sendMouseMove((short) deltaX, (short) deltaY);
+	}
+
+	@Override
+	public void mouseButtonEvent(int buttonId, boolean down) {
+		byte buttonIndex;
+		
+		switch (buttonId)
+		{
+		case EvdevListener.BUTTON_LEFT:
+			buttonIndex = MouseButtonPacket.BUTTON_LEFT;
+			break;
+		case EvdevListener.BUTTON_MIDDLE:
+			buttonIndex = MouseButtonPacket.BUTTON_MIDDLE;
+			break;
+		case EvdevListener.BUTTON_RIGHT:
+			buttonIndex = MouseButtonPacket.BUTTON_RIGHT;
+			break;
+		default:
+			LimeLog.warning("Unhandled button: "+buttonId);
+			return;
+		}
+		
+		if (down) {
+			conn.sendMouseButtonDown(buttonIndex);
+		}
+		else {
+			conn.sendMouseButtonUp(buttonIndex);
+		}
+	}
+
+	@Override
+	public void mouseScroll(byte amount) {
+		conn.sendMouseScroll(amount);
+	}
+
+	@Override
+	public void keyboardEvent(boolean buttonDown, short keyCode) {
+		short keyMap = keybTranslator.translate(keyCode);
+		if (keyMap != 0) {
+			if (buttonDown) {
+				keybTranslator.sendKeyDown(keyMap, (byte) 0);
+			}
+			else {
+				keybTranslator.sendKeyUp(keyMap, (byte) 0);
+			}
+		}
+	}
 }

src/com/limelight/LimelightBuildProps.java

@@ -0,0 +1,5 @@
+package com.limelight;
+
+public class LimelightBuildProps {
+	public static final boolean ROOT_BUILD = true;
+}

src/com/limelight/PcView.java

@@ -13,6 +13,7 @@ import com.limelight.nvstream.http.NvHTTP;
 import com.limelight.nvstream.http.PairingManager;
 import com.limelight.nvstream.http.PairingManager.PairState;
 import com.limelight.nvstream.wol.WakeOnLanSender;
+import com.limelight.root.R;
 import com.limelight.utils.Dialog;
 
 import android.app.Activity;

src/com/limelight/StreamSettings.java

@@ -1,5 +1,6 @@
 package com.limelight;
 
+import com.limelight.root.R;
 import com.limelight.utils.Dialog;
 
 import android.os.Bundle;
@@ -19,7 +20,7 @@ public class StreamSettings extends Activity {
 	private Button advancedSettingsButton;
 	private SharedPreferences prefs;
 	private RadioButton rbutton720p30, rbutton720p60, rbutton1080p30, rbutton1080p60;
-	private CheckBox stretchToFill, enableSops;
+	private CheckBox stretchToFill, enableSops, toastsDisabled;
 	
 	@Override
 	protected void onStop() {
@@ -36,6 +37,7 @@ public class StreamSettings extends Activity {
 		
 		this.stretchToFill = (CheckBox) findViewById(R.id.stretchToFill);
 		this.enableSops = (CheckBox) findViewById(R.id.enableSops);
+		this.toastsDisabled = (CheckBox) findViewById(R.id.disableToasts);
 		this.advancedSettingsButton = (Button) findViewById(R.id.advancedSettingsButton);
 		this.rbutton720p30 = (RadioButton) findViewById(R.id.config720p30Selected);
 		this.rbutton720p60 = (RadioButton) findViewById(R.id.config720p60Selected);
@@ -49,6 +51,7 @@ public class StreamSettings extends Activity {
 
 		stretchToFill.setChecked(prefs.getBoolean(Game.STRETCH_PREF_STRING, Game.DEFAULT_STRETCH));
 		enableSops.setChecked(prefs.getBoolean(Game.SOPS_PREF_STRING, Game.DEFAULT_SOPS));
+		toastsDisabled.setChecked(prefs.getBoolean(Game.DISABLE_TOASTS_PREF_STRING, Game.DEFAULT_DISABLE_TOASTS));
 		
 		rbutton720p30.setChecked(false);
 		rbutton720p60.setChecked(false);
@@ -132,5 +135,12 @@ public class StreamSettings extends Activity {
 				prefs.edit().putBoolean(Game.SOPS_PREF_STRING, isChecked).commit();
 			}
 		});
+		toastsDisabled.setOnCheckedChangeListener(new OnCheckedChangeListener() {
+			@Override
+			public void onCheckedChanged(CompoundButton buttonView,
+					boolean isChecked) {
+				prefs.edit().putBoolean(Game.DISABLE_TOASTS_PREF_STRING, isChecked).commit();
+			}
+		});
 	}
 }

src/com/limelight/binding/input/TouchContext.java

@@ -0,0 +1,93 @@
+package com.limelight.binding.input;
+
+import com.limelight.nvstream.NvConnection;
+import com.limelight.nvstream.input.MouseButtonPacket;
+
+public class TouchContext {
+	private int lastTouchX = 0;
+	private int lastTouchY = 0;
+	private int originalTouchX = 0;
+	private int originalTouchY = 0;
+	private long originalTouchTime = 0;
+	
+	private NvConnection conn;
+	private int actionIndex;
+	
+	private static final int TAP_MOVEMENT_THRESHOLD = 10;
+	private static final int TAP_TIME_THRESHOLD = 250;
+	
+	public TouchContext(NvConnection conn, int actionIndex)
+	{
+		this.conn = conn;
+		this.actionIndex = actionIndex;
+	}
+	
+	private boolean isTap()
+	{
+		int xDelta = Math.abs(lastTouchX - originalTouchX);
+		int yDelta = Math.abs(lastTouchY - originalTouchY);
+		long timeDelta = System.currentTimeMillis() - originalTouchTime;
+		
+		return xDelta <= TAP_MOVEMENT_THRESHOLD &&
+				yDelta <= TAP_MOVEMENT_THRESHOLD &&
+				timeDelta <= TAP_TIME_THRESHOLD;
+	}
+	
+	private byte getMouseButtonIndex()
+	{
+		if (actionIndex == 1) {
+			return MouseButtonPacket.BUTTON_RIGHT;
+		}
+		else {
+			return MouseButtonPacket.BUTTON_LEFT;
+		}
+	}
+	
+	public boolean touchDownEvent(int eventX, int eventY)
+	{
+		originalTouchX = lastTouchX = eventX;
+		originalTouchY = lastTouchY = eventY;
+		originalTouchTime = System.currentTimeMillis();
+		
+		return true;
+	}
+	
+	public void touchUpEvent(int eventX, int eventY)
+	{
+		if (isTap())
+		{
+			byte buttonIndex = getMouseButtonIndex();
+			
+			// Lower the mouse button
+			conn.sendMouseButtonDown(buttonIndex);
+			
+			// We need to sleep a bit here because some games
+			// do input detection by polling
+			try {
+				Thread.sleep(100);
+			} catch (InterruptedException e) {}
+			
+			// Raise the mouse button
+			conn.sendMouseButtonUp(buttonIndex);
+		}
+	}
+	
+	public boolean touchMoveEvent(int eventX, int eventY)
+	{	
+		if (eventX != lastTouchX || eventY != lastTouchY)
+		{
+			// We only send moves for the primary touch point
+			if (actionIndex == 0) {
+				conn.sendMouseMove((short)(eventX - lastTouchX),
+						(short)(eventY - lastTouchY));
+			}
+			
+			lastTouchX = eventX;
+			lastTouchY = eventY;
+			
+			return true;
+		}
+		
+		return false;
+	}
+}

src/com/limelight/binding/input/evdev/EvdevEvent.java

@@ -0,0 +1,41 @@
+package com.limelight.binding.input.evdev;
+
+public class EvdevEvent {
+	public static final int EVDEV_MIN_EVENT_SIZE = 16;
+	public static final int EVDEV_MAX_EVENT_SIZE = 24;
+	
+	/* Event types */
+	public static final short EV_SYN = 0x00;
+	public static final short EV_KEY = 0x01;
+	public static final short EV_REL = 0x02;
+	public static final short EV_MSC = 0x04;
+	
+	/* Relative axes */
+	public static final short REL_X = 0x00;
+	public static final short REL_Y = 0x01;
+	public static final short REL_WHEEL = 0x08;
+	
+	/* Buttons */
+	public static final short BTN_LEFT = 0x110;
+	public static final short BTN_RIGHT = 0x111;
+	public static final short BTN_MIDDLE = 0x112;
+	public static final short BTN_SIDE = 0x113;
+	public static final short BTN_EXTRA = 0x114;
+	public static final short BTN_FORWARD = 0x115;
+	public static final short BTN_BACK = 0x116;
+	public static final short BTN_TASK = 0x117;
+	public static final short BTN_GAMEPAD = 0x130;
+	
+	/* Keys */
+	public static final short KEY_Q = 16;
+	
+	public short type;
+	public short code;
+	public int value;
+	
+	public EvdevEvent(short type, short code, int value) {
+		this.type = type;
+		this.code = code;
+		this.value = value;
+	}
+}

src/com/limelight/binding/input/evdev/EvdevHandler.java

@@ -0,0 +1,167 @@
+package com.limelight.binding.input.evdev;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+
+import com.limelight.LimeLog;
+
+public class EvdevHandler {
+
+	private String absolutePath;
+	private EvdevListener listener;
+	private boolean shutdown = false;
+	private int fd = -1;
+	
+	private Thread handlerThread = new Thread() {
+		@Override
+		public void run() {
+			// All the finally blocks here make this code look like a mess
+			// but it's important that we get this right to avoid causing
+			// system-wide input problems.
+			
+			// Open the /dev/input/eventX file
+			fd = EvdevReader.open(absolutePath);
+			if (fd == -1) {
+				LimeLog.warning("Unable to open "+absolutePath);
+				return;
+			}
+
+			try {
+				// Check if it's a mouse or keyboard, but not a gamepad
+				if ((!EvdevReader.isMouse(fd) && !EvdevReader.isAlphaKeyboard(fd)) ||
+					EvdevReader.isGamepad(fd)) {
+					// We only handle keyboards and mice
+					return;
+				}
+
+				// Grab it for ourselves
+				if (!EvdevReader.grab(fd)) {
+					LimeLog.warning("Unable to grab "+absolutePath);
+					return;
+				}
+
+				LimeLog.info("Grabbed device for raw keyboard/mouse input: "+absolutePath);
+
+				ByteBuffer buffer = ByteBuffer.allocate(EvdevEvent.EVDEV_MAX_EVENT_SIZE).order(ByteOrder.nativeOrder());
+
+				try {
+					int deltaX = 0;
+					int deltaY = 0;
+					byte deltaScroll = 0;
+
+					while (!isInterrupted() && !shutdown) {
+						EvdevEvent event = EvdevReader.read(fd, buffer);
+						if (event == null) {
+							return;
+						}
+
+						switch (event.type)
+						{
+						case EvdevEvent.EV_SYN:
+							if (deltaX != 0 || deltaY != 0) {
+								listener.mouseMove(deltaX, deltaY);
+								deltaX = deltaY = 0;
+							}
+							if (deltaScroll != 0) {
+								listener.mouseScroll(deltaScroll);
+								deltaScroll = 0;
+							}
+							break;
+
+						case EvdevEvent.EV_REL:
+							switch (event.code)
+							{
+							case EvdevEvent.REL_X:
+								deltaX = event.value;
+								break;
+							case EvdevEvent.REL_Y:
+								deltaY = event.value;
+								break;
+							case EvdevEvent.REL_WHEEL:
+								deltaScroll = (byte) event.value;
+								break;
+							}
+							break;
+
+						case EvdevEvent.EV_KEY:
+							switch (event.code)
+							{
+							case EvdevEvent.BTN_LEFT:
+								listener.mouseButtonEvent(EvdevListener.BUTTON_LEFT,
+										event.value != 0);
+								break;
+							case EvdevEvent.BTN_MIDDLE:
+								listener.mouseButtonEvent(EvdevListener.BUTTON_MIDDLE,
+										event.value != 0);
+								break;
+							case EvdevEvent.BTN_RIGHT:
+								listener.mouseButtonEvent(EvdevListener.BUTTON_RIGHT,
+										event.value != 0);
+								break;
+								
+							case EvdevEvent.BTN_SIDE:
+							case EvdevEvent.BTN_EXTRA:
+							case EvdevEvent.BTN_FORWARD:
+							case EvdevEvent.BTN_BACK:
+							case EvdevEvent.BTN_TASK:
+								// Other unhandled mouse buttons
+								break;
+								
+							default:
+								// We got some unrecognized button. This means
+								// someone is trying to use the other device in this
+								// "combination" input device. We'll try to handle
+								// it via keyboard, but we're not going to disconnect
+								// if we can't
+								short keyCode = EvdevTranslator.translateEvdevKeyCode(event.code);
+								if (keyCode != 0) {
+									listener.keyboardEvent(event.value != 0, keyCode);
+								}
+								break;
+							}
+							break;
+							
+						case EvdevEvent.EV_MSC:
+							break;
+						}
+					}
+				} finally {
+					// Release our grab
+					EvdevReader.ungrab(fd);
+				}
+			} finally {
+				// Close the file
+				EvdevReader.close(fd);
+			}
+		}
+	};
+	
+	public EvdevHandler(String absolutePath, EvdevListener listener) {
+		this.absolutePath = absolutePath;
+		this.listener = listener;
+	}
+	
+	public void start() {
+		handlerThread.start();
+	}
+	
+	public void stop() {
+		// Close the fd. It doesn't matter if this races
+		// with the handler thread. We'll close this out from
+		// under the thread to wake it up
+		if (fd != -1) {
+			EvdevReader.close(fd);
+		}
+		
+		shutdown = true;
+		handlerThread.interrupt();
+		
+		try {
+			handlerThread.join();
+		} catch (InterruptedException e) {}
+	}
+	
+	public void notifyDeleted() {
+		stop();
+	}
+}

src/com/limelight/binding/input/evdev/EvdevListener.java

@@ -0,0 +1,12 @@
+package com.limelight.binding.input.evdev;
+
+public interface EvdevListener {
+	public static final int BUTTON_LEFT = 1;
+	public static final int BUTTON_MIDDLE = 2;
+	public static final int BUTTON_RIGHT = 3;
+	
+	public void mouseMove(int deltaX, int deltaY);
+	public void mouseButtonEvent(int buttonId, boolean down);
+	public void mouseScroll(byte amount);
+	public void keyboardEvent(boolean buttonDown, short keyCode);
+}

src/com/limelight/binding/input/evdev/EvdevReader.java

@@ -0,0 +1,101 @@
+package com.limelight.binding.input.evdev;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.nio.ByteBuffer;
+
+import com.limelight.LimeLog;
+
+public class EvdevReader {
+	static {
+		System.loadLibrary("evdev_reader");
+	}
+	
+	// Requires root to chmod /dev/input/eventX
+	public static boolean setPermissions(String[] files, int octalPermissions) {		
+		ProcessBuilder builder = new ProcessBuilder("su");
+		
+		try {
+			Process p = builder.start();
+			
+			OutputStream stdin = p.getOutputStream();
+			for (String file : files) {
+				stdin.write(String.format("chmod %o %s\n", octalPermissions, file).getBytes("UTF-8"));
+			}
+			stdin.write("exit\n".getBytes("UTF-8"));
+			stdin.flush();
+			
+			p.waitFor();
+			p.destroy();
+		} catch (IOException e) {
+			e.printStackTrace();
+		} catch (InterruptedException e) {
+			e.printStackTrace();
+		}
+		
+		return false;
+	}
+	
+	// Returns the fd to be passed to other function or -1 on error
+	public static native int open(String fileName);
+	
+	// Prevent other apps (including Android itself) from using the device while "grabbed"
+	public static native boolean grab(int fd);
+	public static native boolean ungrab(int fd);
+	
+	// Used for checking device capabilities
+	public static native boolean hasRelAxis(int fd, short axis);
+	public static native boolean hasAbsAxis(int fd, short axis);
+	public static native boolean hasKey(int fd, short key);
+	
+	public static boolean isMouse(int fd) {
+		// This is the same check that Android does in EventHub.cpp
+		return hasRelAxis(fd, EvdevEvent.REL_X) &&
+				hasRelAxis(fd, EvdevEvent.REL_Y) &&
+				hasKey(fd, EvdevEvent.BTN_LEFT);
+	}
+	
+	public static boolean isAlphaKeyboard(int fd) {
+		// This is the same check that Android does in EventHub.cpp
+		return hasKey(fd, EvdevEvent.KEY_Q);
+	}
+	
+	public static boolean isGamepad(int fd) {
+		return hasKey(fd, EvdevEvent.BTN_GAMEPAD);
+	}
+	
+	// Returns the bytes read or -1 on error
+	private static native int read(int fd, byte[] buffer);
+	
+	// Takes a byte buffer to use to read the output into.
+	// This buffer MUST be in native byte order and at least
+	// EVDEV_MAX_EVENT_SIZE bytes long.
+	public static EvdevEvent read(int fd, ByteBuffer buffer) {
+		int bytesRead = read(fd, buffer.array());
+		if (bytesRead < 0) {
+			LimeLog.warning("Failed to read: "+bytesRead);
+			return null;
+		}
+		else if (bytesRead < EvdevEvent.EVDEV_MIN_EVENT_SIZE) {
+			LimeLog.warning("Short read: "+bytesRead);
+			return null;
+		}
+		
+		buffer.limit(bytesRead);
+		buffer.rewind();
+		
+		// Throw away the time stamp
+		if (bytesRead == EvdevEvent.EVDEV_MAX_EVENT_SIZE) {
+			buffer.getLong();
+			buffer.getLong();
+		} else {
+			buffer.getInt();
+			buffer.getInt();
+		}
+		
+		return new EvdevEvent(buffer.getShort(), buffer.getShort(), buffer.getInt());
+	}
+	
+	// Closes the fd from open()
+	public static native int close(int fd);
+}

src/com/limelight/binding/input/evdev/EvdevTranslator.java

@@ -0,0 +1,139 @@
+package com.limelight.binding.input.evdev;
+
+import android.view.KeyEvent;
+
+public class EvdevTranslator {
+
+	public static final short EVDEV_KEY_CODES[] = {
+		0, //KeyEvent.VK_RESERVED
+		KeyEvent.KEYCODE_ESCAPE,
+		KeyEvent.KEYCODE_1,
+		KeyEvent.KEYCODE_2,
+		KeyEvent.KEYCODE_3,
+		KeyEvent.KEYCODE_4,
+		KeyEvent.KEYCODE_5,
+		KeyEvent.KEYCODE_6,
+		KeyEvent.KEYCODE_7,
+		KeyEvent.KEYCODE_8,
+		KeyEvent.KEYCODE_9,
+		KeyEvent.KEYCODE_0,
+		KeyEvent.KEYCODE_MINUS,
+		KeyEvent.KEYCODE_EQUALS,
+		KeyEvent.KEYCODE_DEL,
+		KeyEvent.KEYCODE_TAB,
+		KeyEvent.KEYCODE_Q,
+		KeyEvent.KEYCODE_W,
+		KeyEvent.KEYCODE_E,
+		KeyEvent.KEYCODE_R,
+		KeyEvent.KEYCODE_T,
+		KeyEvent.KEYCODE_Y,
+		KeyEvent.KEYCODE_U,
+		KeyEvent.KEYCODE_I,
+		KeyEvent.KEYCODE_O,
+		KeyEvent.KEYCODE_P,
+		KeyEvent.KEYCODE_LEFT_BRACKET,
+		KeyEvent.KEYCODE_RIGHT_BRACKET,
+		KeyEvent.KEYCODE_ENTER,
+		KeyEvent.KEYCODE_CTRL_LEFT,
+		KeyEvent.KEYCODE_A,
+		KeyEvent.KEYCODE_S,
+		KeyEvent.KEYCODE_D,
+		KeyEvent.KEYCODE_F,
+		KeyEvent.KEYCODE_G,
+		KeyEvent.KEYCODE_H,
+		KeyEvent.KEYCODE_J,
+		KeyEvent.KEYCODE_K,
+		KeyEvent.KEYCODE_L,
+		KeyEvent.KEYCODE_SEMICOLON,
+		KeyEvent.KEYCODE_APOSTROPHE,
+		KeyEvent.KEYCODE_GRAVE,
+		KeyEvent.KEYCODE_SHIFT_LEFT,
+		KeyEvent.KEYCODE_BACKSLASH,
+		KeyEvent.KEYCODE_Z,
+		KeyEvent.KEYCODE_X,
+		KeyEvent.KEYCODE_C,
+		KeyEvent.KEYCODE_V,
+		KeyEvent.KEYCODE_B,
+		KeyEvent.KEYCODE_N,
+		KeyEvent.KEYCODE_M,
+		KeyEvent.KEYCODE_COMMA,
+		KeyEvent.KEYCODE_PERIOD,
+		KeyEvent.KEYCODE_SLASH,
+		KeyEvent.KEYCODE_SHIFT_RIGHT,
+		KeyEvent.KEYCODE_NUMPAD_MULTIPLY,
+		KeyEvent.KEYCODE_ALT_LEFT,
+		KeyEvent.KEYCODE_SPACE,
+		KeyEvent.KEYCODE_CAPS_LOCK,
+		KeyEvent.KEYCODE_F1,
+		KeyEvent.KEYCODE_F2,
+		KeyEvent.KEYCODE_F3,
+		KeyEvent.KEYCODE_F4,
+		KeyEvent.KEYCODE_F5,
+		KeyEvent.KEYCODE_F6,
+		KeyEvent.KEYCODE_F7,
+		KeyEvent.KEYCODE_F8,
+		KeyEvent.KEYCODE_F9,
+		KeyEvent.KEYCODE_F10,
+		KeyEvent.KEYCODE_NUM_LOCK,
+		KeyEvent.KEYCODE_SCROLL_LOCK,
+		KeyEvent.KEYCODE_NUMPAD_7,
+		KeyEvent.KEYCODE_NUMPAD_8,
+		KeyEvent.KEYCODE_NUMPAD_9,
+		KeyEvent.KEYCODE_NUMPAD_SUBTRACT,
+		KeyEvent.KEYCODE_NUMPAD_4,
+		KeyEvent.KEYCODE_NUMPAD_5,
+		KeyEvent.KEYCODE_NUMPAD_6,
+		KeyEvent.KEYCODE_NUMPAD_ADD,
+		KeyEvent.KEYCODE_NUMPAD_1,
+		KeyEvent.KEYCODE_NUMPAD_2,
+		KeyEvent.KEYCODE_NUMPAD_3,
+		KeyEvent.KEYCODE_NUMPAD_0,
+		KeyEvent.KEYCODE_NUMPAD_DOT,
+		0,
+		0, //KeyEvent.VK_ZENKAKUHANKAKU,
+		0, //KeyEvent.VK_102ND,
+		KeyEvent.KEYCODE_F11,
+		KeyEvent.KEYCODE_F12,
+		0, //KeyEvent.VK_RO,
+		0, //KeyEvent.VK_KATAKANA,
+		0, //KeyEvent.VK_HIRAGANA,
+		0, //KeyEvent.VK_HENKAN,
+		0, //KeyEvent.VK_KATAKANAHIRAGANA,
+		0, //KeyEvent.VK_MUHENKAN,
+		0, //KeyEvent.VK_KPJPCOMMA,
+		KeyEvent.KEYCODE_NUMPAD_ENTER,
+		KeyEvent.KEYCODE_CTRL_RIGHT,
+		KeyEvent.KEYCODE_NUMPAD_DIVIDE,
+		KeyEvent.KEYCODE_SYSRQ,
+		KeyEvent.KEYCODE_ALT_RIGHT,
+		0, //KeyEvent.VK_LINEFEED,
+		KeyEvent.KEYCODE_HOME,
+		KeyEvent.KEYCODE_DPAD_UP,
+		KeyEvent.KEYCODE_PAGE_UP,
+		KeyEvent.KEYCODE_DPAD_LEFT,
+		KeyEvent.KEYCODE_DPAD_RIGHT,
+		KeyEvent.KEYCODE_MOVE_END,
+		KeyEvent.KEYCODE_DPAD_DOWN,
+		KeyEvent.KEYCODE_PAGE_DOWN,
+		KeyEvent.KEYCODE_INSERT,
+		KeyEvent.KEYCODE_FORWARD_DEL,
+		0, //KeyEvent.VK_MACRO,
+		0, //KeyEvent.VK_MUTE,
+		0, //KeyEvent.VK_VOLUMEDOWN,
+		0, //KeyEvent.VK_VOLUMEUP,
+		0, //KeyEvent.VK_POWER, /* SC System Power Down */
+		KeyEvent.KEYCODE_NUMPAD_EQUALS,
+		0, //KeyEvent.VK_KPPLUSMINUS,
+		KeyEvent.KEYCODE_BREAK,
+		0, //KeyEvent.VK_SCALE, /* AL Compiz Scale (Expose) */
+	};
+	
+	public static short translateEvdevKeyCode(short evdevKeyCode) {
+		if (evdevKeyCode < EVDEV_KEY_CODES.length) {
+			return EVDEV_KEY_CODES[evdevKeyCode];
+		}
+		
+		return 0;
+	}
+
+}

src/com/limelight/binding/input/evdev/EvdevWatcher.java

@@ -0,0 +1,132 @@
+package com.limelight.binding.input.evdev;
+
+import java.io.File;
+import java.util.HashMap;
+
+import com.limelight.LimeLog;
+
+import android.os.FileObserver;
+
+public class EvdevWatcher {
+	private static final String PATH = "/dev/input";
+	private static final String REQUIRED_FILE_PREFIX = "event";
+	
+	private HashMap<String, EvdevHandler> handlers = new HashMap<String, EvdevHandler>();
+	private boolean shutdown = false;
+	private boolean init = false;
+	private EvdevListener listener;
+	private Thread startThread;
+	
+	private FileObserver observer = new FileObserver(PATH, FileObserver.CREATE | FileObserver.DELETE) {
+		@Override
+		public void onEvent(int event, String fileName) {
+			if (fileName == null) {
+				return;
+			}
+			
+			if (!fileName.startsWith(REQUIRED_FILE_PREFIX)) {
+				return;
+			}
+			
+			synchronized (handlers) {
+				if (shutdown) {
+					return;
+				}
+				
+				if ((event & FileObserver.CREATE) != 0) {
+					LimeLog.info("Starting evdev handler for "+fileName);
+					
+					if (!init) {
+						// If this a real new device, update permissions again so we can read it
+						EvdevReader.setPermissions(new String[]{PATH + "/" + fileName}, 0666);
+					}
+					
+					EvdevHandler handler = new EvdevHandler(PATH + "/" + fileName, listener);
+					handler.start();
+					
+					handlers.put(fileName, handler);
+				}
+				
+				if ((event & FileObserver.DELETE) != 0) {
+					LimeLog.info("Halting evdev handler for "+fileName);
+					
+					EvdevHandler handler = handlers.remove(fileName);
+					if (handler != null) {
+						handler.notifyDeleted();
+					}
+				}
+			}
+		}
+	};
+	
+	public EvdevWatcher(EvdevListener listener) {
+		this.listener = listener;
+	}
+	
+	private File[] rundownWithPermissionsChange(int newPermissions) {
+		// Rundown existing files
+		File devInputDir = new File(PATH);
+		File[] files = devInputDir.listFiles();
+		
+		// Set desired permissions
+		String[] filePaths = new String[files.length];
+		for (int i = 0; i < files.length; i++) {
+			filePaths[i] = files[i].getAbsolutePath();
+		}
+		EvdevReader.setPermissions(filePaths, newPermissions);
+		
+		return files;
+	}
+	
+	public void start() {
+		startThread = new Thread() {
+			@Override
+			public void run() {
+				// List all files and allow us access
+				File[] files = rundownWithPermissionsChange(0666);
+				
+				init = true;
+				for (File f : files) {
+					observer.onEvent(FileObserver.CREATE, f.getName());
+				}
+				
+				// Done with initial onEvent calls
+				init = false;
+				
+				// Start watching for new files
+				observer.startWatching();
+				
+				synchronized (startThread) {
+					// Wait to be awoken again by shutdown()
+					try {
+						startThread.wait();
+					} catch (InterruptedException e) {}
+				}
+				
+				// Giveup eventX permissions
+				rundownWithPermissionsChange(066);
+			}
+		};
+		startThread.start();
+	}
+	
+	public void shutdown() {
+		// Let start thread cleanup on it's own sweet time
+		synchronized (startThread) {
+			startThread.notify();
+		}
+		
+		// Stop the observer
+		observer.stopWatching();
+		
+		synchronized (handlers) {
+			// Stop creating new handlers
+			shutdown = true;
+			
+			// Stop all handlers
+			for (EvdevHandler handler : handlers.values()) {
+				handler.stop();
+			}
+		}
+	}
+}

src/com/limelight/binding/video/ConfigurableDecoderRenderer.java

@@ -25,7 +25,7 @@ public class ConfigurableDecoderRenderer implements VideoDecoderRenderer {
 	public void initializeWithFlags(int drFlags) {
 		if ((drFlags & VideoDecoderRenderer.FLAG_FORCE_HARDWARE_DECODING) != 0 ||
 				((drFlags & VideoDecoderRenderer.FLAG_FORCE_SOFTWARE_DECODING) == 0 &&
-				MediaCodecDecoderRenderer.findSafeDecoder() != null)) {
+				MediaCodecDecoderRenderer.findProbableSafeDecoder() != null)) {
 			decoderRenderer = new MediaCodecDecoderRenderer();
 		}
 		else {

src/com/limelight/binding/video/MediaCodecDecoderRenderer.java

@@ -33,6 +33,11 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 	private long decoderTimeMs;
 	private int totalFrames;
 	
+	private String decoderName;
+	private int numSpsIn;
+	private int numPpsIn;
+	private int numIframeIn;
+	
 	private final static byte[] BITSTREAM_RESTRICTIONS = new byte[] {(byte) 0xF1, (byte) 0x83, 0x2A, 0x00};
 	
 	public static final List<String> blacklistedDecoderPrefixes;
@@ -42,7 +47,9 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 	static {
 		blacklistedDecoderPrefixes = new LinkedList<String>();
 		
-		// Nothing here right now :)
+		// Software decoders that don't support H264 high profile
+		blacklistedDecoderPrefixes.add("omx.google");
+		blacklistedDecoderPrefixes.add("AVCDecoder");
 	}
 	
 	static {
@@ -70,7 +77,8 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 		return false;
 	}
 	
-	public static void dumpDecoders() {
+	public static String dumpDecoders() throws Exception {
+		String str = "";
 		for (int i = 0; i < MediaCodecList.getCodecCount(); i++) {
 			MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
 			
@@ -79,19 +87,63 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 				continue;
 			}
 			
-			LimeLog.info("Decoder: "+codecInfo.getName());
+			str += "Decoder: "+codecInfo.getName()+"\n";
 			for (String type : codecInfo.getSupportedTypes()) {
-				LimeLog.info("\t"+type);
+				str += "\t"+type+"\n";
 				CodecCapabilities caps = codecInfo.getCapabilitiesForType(type);
 				
 				for (CodecProfileLevel profile : caps.profileLevels) {
-					LimeLog.info("\t\t"+profile.profile+" "+profile.level);
+					str += "\t\t"+profile.profile+" "+profile.level+"\n";
 				}
 			}
 		}
+		return str;
+	}
+	
+	private static MediaCodecInfo findFirstDecoder() {
+		for (int i = 0; i < MediaCodecList.getCodecCount(); i++) {
+			MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
+						
+			// Skip encoders
+			if (codecInfo.isEncoder()) {
+				continue;
+			}
+			
+			// Check for explicitly blacklisted decoders
+			if (isDecoderInList(blacklistedDecoderPrefixes, codecInfo.getName())) {
+				LimeLog.info("Skipping blacklisted decoder: "+codecInfo.getName());
+				continue;
+			}
+			
+			// Find a decoder that supports H.264
+			for (String mime : codecInfo.getSupportedTypes()) {
+				if (mime.equalsIgnoreCase("video/avc")) {
+					LimeLog.info("First decoder choice is "+codecInfo.getName());
+					return codecInfo;
+				}
+			}
+		}
+		
+		return null;
+	}
+	
+	public static MediaCodecInfo findProbableSafeDecoder() {
+		// First look for decoders we know are safe
+		try {
+			// If this function completes, it will determine if the decoder is safe
+			return findKnownSafeDecoder();
+		} catch (Exception e) {
+			// Some buggy devices seem to throw exceptions
+			// from getCapabilitiesForType() so we'll just assume
+			// they're okay and go with the first one we find
+			return findFirstDecoder();
+		}
 	}
 
-	public static MediaCodecInfo findSafeDecoder() {
+	// We declare this method as explicitly throwing Exception
+	// since some bad decoders can throw IllegalArgumentExceptions unexpectedly
+	// and we want to be sure all callers are handling this possibility
+	private static MediaCodecInfo findKnownSafeDecoder() throws Exception {
 		for (int i = 0; i < MediaCodecList.getCodecCount(); i++) {
 			MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);
 						
@@ -132,37 +184,37 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 	public boolean setup(int width, int height, int redrawRate, Object renderTarget, int drFlags) {
 		//dumpDecoders();
 		
-		// It's nasty to put all this in a try-catch block,
-		// but codecs have been known to throw all sorts of crazy runtime exceptions
+		MediaCodecInfo decoder = findProbableSafeDecoder();
+		if (decoder == null) {
+			decoder = findFirstDecoder();
+		}
+		if (decoder == null) {
+			LimeLog.severe("No available hardware decoder!");
+			return false;
+		}
+		
+		decoderName = decoder.getName();
+		
+		// Codecs have been known to throw all sorts of crazy runtime exceptions
 		// due to implementation problems
 		try {
-			MediaCodecInfo safeDecoder = findSafeDecoder();
-			if (safeDecoder != null) {
-				videoDecoder = MediaCodec.createByCodecName(safeDecoder.getName());
-				needsSpsBitstreamFixup = isDecoderInList(spsFixupBitstreamFixupDecoderPrefixes, safeDecoder.getName());
-				needsSpsNumRefFixup = isDecoderInList(spsFixupNumRefFixupDecoderPrefixes, safeDecoder.getName());
-				if (needsSpsBitstreamFixup) {
-					LimeLog.info("Decoder "+safeDecoder.getName()+" needs SPS bitstream restrictions fixup");
-				}
-				if (needsSpsNumRefFixup) {
-					LimeLog.info("Decoder "+safeDecoder.getName()+" needs SPS ref num fixup");
-				}
-			}
-			else {
-				videoDecoder = MediaCodec.createDecoderByType("video/avc");
-				needsSpsBitstreamFixup = false;
-				needsSpsNumRefFixup = false;
-			}
+			videoDecoder = MediaCodec.createByCodecName(decoderName);
 		} catch (Exception e) {
 			return false;
 		}
 		
+		needsSpsBitstreamFixup = isDecoderInList(spsFixupBitstreamFixupDecoderPrefixes, decoder.getName());
+		needsSpsNumRefFixup = isDecoderInList(spsFixupNumRefFixupDecoderPrefixes, decoder.getName());
+		if (needsSpsBitstreamFixup) {
+			LimeLog.info("Decoder "+decoder.getName()+" needs SPS bitstream restrictions fixup");
+		}
+		if (needsSpsNumRefFixup) {
+			LimeLog.info("Decoder "+decoder.getName()+" needs SPS ref num fixup");
+		}
+		
 		MediaFormat videoFormat = MediaFormat.createVideoFormat("video/avc", width, height);
 		videoDecoder.configure(videoFormat, ((SurfaceHolder)renderTarget).getSurface(), null, 0);
 		videoDecoder.setVideoScalingMode(MediaCodec.VIDEO_SCALING_MODE_SCALE_TO_FIT);
-		videoDecoder.start();
-
-		videoDecoderInputBuffers = videoDecoder.getInputBuffers();
 		
 		LimeLog.info("Using hardware decoding");
 		
@@ -190,43 +242,48 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 						}
 					}
 					
-					int outIndex = videoDecoder.dequeueOutputBuffer(info, 0);
-				    if (outIndex >= 0) {
-				    	long presentationTimeUs = info.presentationTimeUs;
-					    int lastIndex = outIndex;
-					    
-					    // Get the last output buffer in the queue
-					    while ((outIndex = videoDecoder.dequeueOutputBuffer(info, 0)) >= 0) {
-					    	videoDecoder.releaseOutputBuffer(lastIndex, false);
-					    	lastIndex = outIndex;
-					    	presentationTimeUs = info.presentationTimeUs;
+					try {
+						int outIndex = videoDecoder.dequeueOutputBuffer(info, 0);
+
+					    if (outIndex >= 0) {
+					    	long presentationTimeUs = info.presentationTimeUs;
+						    int lastIndex = outIndex;
+						    
+						    // Get the last output buffer in the queue
+						    while ((outIndex = videoDecoder.dequeueOutputBuffer(info, 0)) >= 0) {
+						    	videoDecoder.releaseOutputBuffer(lastIndex, false);
+						    	lastIndex = outIndex;
+						    	presentationTimeUs = info.presentationTimeUs;
+						    }
+						    
+						    // Render the last buffer
+					    	videoDecoder.releaseOutputBuffer(lastIndex, true);
+					    	
+						    // Add delta time to the totals (excluding probable outliers)
+						    long delta = System.currentTimeMillis()-(presentationTimeUs/1000);
+						    if (delta > 5 && delta < 300) {
+						    	decoderTimeMs += delta;
+							    totalTimeMs += delta;
+						    }
+					    } else {
+						    switch (outIndex) {
+						    case MediaCodec.INFO_TRY_AGAIN_LATER:
+						    	LockSupport.parkNanos(1);
+						    	break;
+						    case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
+						    	LimeLog.info("Output buffers changed");
+							    break;
+						    case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
+						    	LimeLog.info("Output format changed");
+						    	LimeLog.info("New output Format: " + videoDecoder.getOutputFormat());
+						    	break;
+						    default:
+						      break;
+						    }
 					    }
-					    
-					    // Render the last buffer
-				    	videoDecoder.releaseOutputBuffer(lastIndex, true);
-				    	
-					    // Add delta time to the totals (excluding probable outliers)
-					    long delta = System.currentTimeMillis()-(presentationTimeUs/1000);
-					    if (delta > 5 && delta < 300) {
-					    	decoderTimeMs += delta;
-						    totalTimeMs += delta;
-					    }
-				    } else {
-					    switch (outIndex) {
-					    case MediaCodec.INFO_TRY_AGAIN_LATER:
-					    	LockSupport.parkNanos(1);
-					    	break;
-					    case MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED:
-					    	LimeLog.info("Output buffers changed");
-						    break;
-					    case MediaCodec.INFO_OUTPUT_FORMAT_CHANGED:
-					    	LimeLog.info("Output format changed");
-					    	LimeLog.info("New output Format: " + videoDecoder.getOutputFormat());
-					    	break;
-					    default:
-					      break;
-					    }
-				    }
+					} catch (Exception e) {
+						throw new RendererException(MediaCodecDecoderRenderer.this, e);
+					}
 				}
 			}
 		};
@@ -238,17 +295,26 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 	@Override
 	public boolean start(VideoDepacketizer depacketizer) {
 		this.depacketizer = depacketizer;
+		
+		// Start the decoder
+		videoDecoder.start();
+		videoDecoderInputBuffers = videoDecoder.getInputBuffers();
+		
+		// Start the rendering thread
 		startRendererThread();
 		return true;
 	}
 
 	@Override
 	public void stop() {
+		// Halt the rendering thread
 		rendererThread.interrupt();
-
 		try {
 			rendererThread.join();
 		} catch (InterruptedException e) { }
+		
+		// Stop the decoder
+		videoDecoder.stop();
 	}
 
 	@Override
@@ -266,7 +332,11 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 				return false;
 			}
 			
-			inputIndex = videoDecoder.dequeueInputBuffer(100000);
+			try {
+				inputIndex = videoDecoder.dequeueInputBuffer(100000);
+			} catch (Exception e) {
+				throw new RendererException(this, e);
+			}
 		} while (inputIndex < 0);
 		
 		ByteBuffer buf = videoDecoderInputBuffers[inputIndex];
@@ -288,70 +358,79 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 		}
 		if ((decodeUnitFlags & DecodeUnit.DU_FLAG_SYNC_FRAME) != 0) {
 			codecFlags |= MediaCodec.BUFFER_FLAG_SYNC_FRAME;
+			numIframeIn++;
 		}
 		
-		if ((decodeUnitFlags & DecodeUnit.DU_FLAG_CODEC_CONFIG) != 0 &&
-			(needsSpsBitstreamFixup || needsSpsNumRefFixup)) {
+		if ((decodeUnitFlags & DecodeUnit.DU_FLAG_CODEC_CONFIG) != 0) {
 			ByteBufferDescriptor header = decodeUnit.getBufferList().get(0);
 			if (header.data[header.offset+4] == 0x67) {
-				byte last = header.data[header.length+header.offset-1];
+				numSpsIn++;
+				
+				if ((needsSpsBitstreamFixup || needsSpsNumRefFixup)) {
+					byte last = header.data[header.length+header.offset-1];
 
-				// TI OMAP4 requires a reference frame count of 1 to decode successfully
-				if (needsSpsNumRefFixup) {
-					LimeLog.info("Fixing up num ref frames");
-					this.replace(header, 80, 9, new byte[] {0x40}, 3);
-				}
+					// TI OMAP4 requires a reference frame count of 1 to decode successfully
+					if (needsSpsNumRefFixup) {
+						LimeLog.info("Fixing up num ref frames");
+						this.replace(header, 80, 9, new byte[] {0x40}, 3);
+					}
 
-				// The SPS that comes in the current H264 bytestream doesn't set bitstream_restriction_flag
-				// or max_dec_frame_buffering which increases decoding latency on Tegra.
-				// We manually modify the SPS here to speed-up decoding if the decoder was flagged as needing it.
-				int spsLength;
-				if (needsSpsBitstreamFixup) {
-					if (!needsSpsNumRefFixup) {
-						switch (header.length) {
-						case 26:
-							LimeLog.info("Adding bitstream restrictions to SPS (26)");
-							buf.put(header.data, header.offset, 24);
-							buf.put((byte) 0x11);
-							buf.put((byte) 0xe3);
-							buf.put((byte) 0x06);
-							buf.put((byte) 0x50);
-							spsLength = header.length + 2;
-							break;
-						case 27:
-							LimeLog.info("Adding bitstream restrictions to SPS (27)");
-							buf.put(header.data, header.offset, 25);
-							buf.put((byte) 0x04);
-							buf.put((byte) 0x78);
-							buf.put((byte) 0xc1);
-							buf.put((byte) 0x94);
-							spsLength = header.length + 2;
-							break;
-						default:
-							LimeLog.warning("Unknown SPS of length "+header.length);
+					// The SPS that comes in the current H264 bytestream doesn't set bitstream_restriction_flag
+					// or max_dec_frame_buffering which increases decoding latency on Tegra.
+					// We manually modify the SPS here to speed-up decoding if the decoder was flagged as needing it.
+					int spsLength;
+					if (needsSpsBitstreamFixup) {
+						if (!needsSpsNumRefFixup) {
+							switch (header.length) {
+							case 26:
+								LimeLog.info("Adding bitstream restrictions to SPS (26)");
+								buf.put(header.data, header.offset, 24);
+								buf.put((byte) 0x11);
+								buf.put((byte) 0xe3);
+								buf.put((byte) 0x06);
+								buf.put((byte) 0x50);
+								spsLength = header.length + 2;
+								break;
+							case 27:
+								LimeLog.info("Adding bitstream restrictions to SPS (27)");
+								buf.put(header.data, header.offset, 25);
+								buf.put((byte) 0x04);
+								buf.put((byte) 0x78);
+								buf.put((byte) 0xc1);
+								buf.put((byte) 0x94);
+								spsLength = header.length + 2;
+								break;
+							default:
+								LimeLog.warning("Unknown SPS of length "+header.length);
+								buf.put(header.data, header.offset, header.length);
+								spsLength = header.length;
+								break;
+							}
+						}
+						else {
+							// Set bitstream restrictions to only buffer single frame
+							// (starts 9 bits before stop bit and 6 bits earlier because of the shortening above)
+							this.replace(header, header.length*8+Integer.numberOfLeadingZeros(last & - last)%8-9-6, 2, BITSTREAM_RESTRICTIONS, 3*8);
 							buf.put(header.data, header.offset, header.length);
 							spsLength = header.length;
-							break;
 						}
 					}
 					else {
-						// Set bitstream restrictions to only buffer single frame
-						// (starts 9 bits before stop bit and 6 bits earlier because of the shortening above)
-						this.replace(header, header.length*8+Integer.numberOfLeadingZeros(last & - last)%8-9-6, 2, BITSTREAM_RESTRICTIONS, 3*8);
 						buf.put(header.data, header.offset, header.length);
 						spsLength = header.length;
 					}
-
+					
+					try {
+						videoDecoder.queueInputBuffer(inputIndex,
+								0, spsLength,
+								currentTime * 1000, codecFlags);
+					} catch (Exception e) {
+						throw new RendererException(this, e, buf, codecFlags);
+					}
+					return true;
 				}
-				else {
-					buf.put(header.data, header.offset, header.length);
-					spsLength = header.length;
-				}
-
-				videoDecoder.queueInputBuffer(inputIndex,
-						0, spsLength,
-						currentTime * 1000, codecFlags);
-				return true;
+			} else if (header.data[header.offset+4] == 0x68) {
+				numPpsIn++;
 			}
 		}
 
@@ -361,9 +440,13 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 			buf.put(desc.data, desc.offset, desc.length);
 		}
 
-		videoDecoder.queueInputBuffer(inputIndex,
-				0, decodeUnit.getDataLength(),
-				currentTime * 1000, codecFlags);
+		try {
+			videoDecoder.queueInputBuffer(inputIndex,
+					0, decodeUnit.getDataLength(),
+					currentTime * 1000, codecFlags);
+		} catch (Exception e) {
+			throw new RendererException(this, e, buf, codecFlags);
+		}
 		
 		return true;
 	}
@@ -467,4 +550,54 @@ public class MediaCodecDecoderRenderer implements VideoDecoderRenderer {
 		}
 		return (int)(totalTimeMs / totalFrames);
 	}
+	
+	public class RendererException extends RuntimeException {
+		private static final long serialVersionUID = 8985937536997012406L;
+		
+		private Exception originalException;
+		private MediaCodecDecoderRenderer renderer;
+		private ByteBuffer currentBuffer;
+		private int currentCodecFlags;
+		
+		public RendererException(MediaCodecDecoderRenderer renderer, Exception e) {
+			this.renderer = renderer;
+			this.originalException = e;
+		}
+		
+		public RendererException(MediaCodecDecoderRenderer renderer, Exception e, ByteBuffer currentBuffer, int currentCodecFlags) {
+			this.renderer = renderer;
+			this.originalException = e;
+			this.currentBuffer = currentBuffer;
+			this.currentCodecFlags = currentCodecFlags;
+		}
+		
+		public String toString() {
+			String str = "";
+			
+			str += "Decoder: "+renderer.decoderName+"\n";
+			str += "In stats: "+renderer.numSpsIn+", "+renderer.numPpsIn+", "+renderer.numIframeIn+"\n";
+			str += "Total frames: "+renderer.totalFrames+"\n";
+			
+			if (currentBuffer != null) {
+				str += "Current buffer: ";
+				currentBuffer.flip();
+				while (currentBuffer.hasRemaining() && currentBuffer.position() < 10) {
+					str += String.format("%02x ", currentBuffer.get());
+				}
+				str += "\n";
+				str += "Buffer codec flags: "+currentCodecFlags+"\n";
+			}
+			
+			str += "Full decoder dump:\n";
+			try {
+				str += dumpDecoders();
+			} catch (Exception e) {
+				str += e.getMessage();
+			}
+			
+			str += originalException.toString();
+			
+			return str;
+		}
+	}
 }