Bump version to 4.5.9

This reverts commit 7c1eb80d62.

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "app/src/main/jni/jnienet/enet"]
+	path = app/src/main/jni/jnienet/enet
+	url = https://github.com/cgutman/enet.git

app/build.gradle

@@ -5,14 +5,14 @@ apply plugin: 'com.android.application'
 
 android {
     compileSdkVersion 23
-    buildToolsVersion "23.0.2"
+    buildToolsVersion "23.0.3"
 
     defaultConfig {
         minSdkVersion 16
         targetSdkVersion 23
 
-        versionName "4.5.3"
-        versionCode = 88
+        versionName "4.5.9"
+        versionCode = 100
     }
 
     productFlavors {
@@ -26,7 +26,7 @@ android {
     }
 
     lintOptions {
-        abortOnError false
+        disable 'MissingTranslation'
     }
 
     buildTypes {

app/src/main/AndroidManifest.xml

@@ -37,7 +37,7 @@
         </activity>
         <activity
             android:name=".AppView"
-            android:configChanges="mcc|mnc|locale|touchscreen|keyboard|keyboardHidden|navigation|screenLayout|fontScale|uiMode|orientation|screenSize|smallestScreenSize|layoutDirection" >
+            android:configChanges="mcc|mnc|locale|touchscreen|keyboard|keyboardHidden|navigation|fontScale|uiMode" >
             <meta-data
                 android:name="android.support.PARENT_ACTIVITY"
                 android:value="com.limelight.PcView" />

app/src/main/java/com/limelight/AppView.java

@@ -50,6 +50,7 @@ public class AppView extends Activity implements AdapterFragmentCallbacks {
     private String lastRawApplist;
     private int lastRunningAppId;
     private boolean suspendGridUpdates;
+    private boolean inForeground;
 
     private final static int START_OR_RESUME_ID = 1;
     private final static int QUIT_ID = 2;
@@ -95,9 +96,25 @@ public class AppView extends Activity implements AdapterFragmentCallbacks {
                     // Load the app grid with cached data (if possible)
                     populateAppGridWithCache();
 
-                    getFragmentManager().beginTransaction()
-                            .replace(R.id.appFragmentContainer, new AdapterFragment())
-                            .commitAllowingStateLoss();
+                    runOnUiThread(new Runnable() {
+                        @Override
+                        public void run() {
+                            if (isFinishing() || isChangingConfigurations()) {
+                                return;
+                            }
+
+                            // Despite my best efforts to catch all conditions that could
+                            // cause the activity to be destroyed when we try to commit
+                            // I haven't been able to, so we have this try-catch block.
+                            try {
+                                getFragmentManager().beginTransaction()
+                                        .replace(R.id.appFragmentContainer, new AdapterFragment())
+                                        .commitAllowingStateLoss();
+                            } catch (IllegalStateException e) {
+                                e.printStackTrace();
+                            }
+                        }
+                    });
                 }
             }.start();
         }
@@ -108,7 +125,8 @@ public class AppView extends Activity implements AdapterFragmentCallbacks {
     };
 
     private void startComputerUpdates() {
-        if (managerBinder == null) {
+        // Don't start polling if we're not bound or in the foreground
+        if (managerBinder == null || !inForeground) {
             return;
         }
 
@@ -252,6 +270,7 @@ public class AppView extends Activity implements AdapterFragmentCallbacks {
     protected void onResume() {
         super.onResume();
 
+        inForeground = true;
         startComputerUpdates();
     }
 
@@ -259,6 +278,7 @@ public class AppView extends Activity implements AdapterFragmentCallbacks {
     protected void onPause() {
         super.onPause();
 
+        inForeground = false;
         stopComputerUpdates();
     }
 

app/src/main/java/com/limelight/Game.java

@@ -22,6 +22,7 @@ import com.limelight.nvstream.input.KeyboardPacket;
 import com.limelight.nvstream.input.MouseButtonPacket;
 import com.limelight.preferences.PreferenceConfiguration;
 import com.limelight.ui.GameGestures;
+import com.limelight.ui.StreamView;
 import com.limelight.utils.Dialog;
 import com.limelight.utils.SpinnerDialog;
 
@@ -74,8 +75,8 @@ public class Game extends Activity implements SurfaceHolder.Callback,
     private final TouchContext[] touchContextMap = new TouchContext[2];
     private long threeFingerDownTime = 0;
 
-    private static final double REFERENCE_HORIZ_RES = 1280;
-    private static final double REFERENCE_VERT_RES = 720;
+    private static final int REFERENCE_HORIZ_RES = 1280;
+    private static final int REFERENCE_VERT_RES = 720;
 
     private static final int THREE_FINGER_TAP_THRESHOLD = 300;
 
@@ -84,19 +85,18 @@ public class Game extends Activity implements SurfaceHolder.Callback,
     private KeyboardTranslator keybTranslator;
 
     private PreferenceConfiguration prefConfig;
-    private final Point screenSize = new Point(0, 0);
 
     private NvConnection conn;
     private SpinnerDialog spinner;
     private boolean displayedFailureDialog = false;
     private boolean connecting = false;
     private boolean connected = false;
-    private boolean deferredSurfaceResize = false;
 
     private EvdevHandler evdevHandler;
     private int modifierFlags = 0;
     private boolean grabbedInput = true;
     private boolean grabComboDown = false;
+    private StreamView streamView;
 
     private EnhancedDecoderRenderer decoderRenderer;
 
@@ -175,13 +175,10 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             drFlags |= VideoDecoderRenderer.FLAG_FILL_SCREEN;
         }
 
-        Display display = getWindowManager().getDefaultDisplay();
-        display.getSize(screenSize);
-
         // Listen for events on the game surface
-        SurfaceView sv = (SurfaceView) findViewById(R.id.surfaceView);
-        sv.setOnGenericMotionListener(this);
-        sv.setOnTouchListener(this);
+        streamView = (StreamView) findViewById(R.id.surfaceView);
+        streamView.setOnGenericMotionListener(this);
+        streamView.setOnTouchListener(this);
 
         // Warn the user if they're on a metered connection
         checkDataConnection();
@@ -258,6 +255,10 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             // >= 4K screens have exactly 4K screens, so we'll be able to hit this good path
             // on these devices. On Marshmallow, we can start changing to 4K manually but no
             // 4K devices run 6.0 at the moment.
+            Display display = getWindowManager().getDefaultDisplay();
+            Point screenSize = new Point(0, 0);
+            display.getSize(screenSize);
+
             double screenAspectRatio = ((double)screenSize.y) / screenSize.x;
             double streamAspectRatio = ((double)prefConfig.height) / prefConfig.width;
             if (Math.abs(screenAspectRatio - streamAspectRatio) < 0.001) {
@@ -266,20 +267,21 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             }
         }
 
-        SurfaceHolder sh = sv.getHolder();
+        SurfaceHolder sh = streamView.getHolder();
         if (prefConfig.stretchVideo || aspectRatioMatch) {
             // Set the surface to the size of the video
             sh.setFixedSize(prefConfig.width, prefConfig.height);
         }
         else {
-            deferredSurfaceResize = true;
+            // Set the surface to scale based on the aspect ratio of the stream
+            streamView.setDesiredAspectRatio((double)prefConfig.width / (double)prefConfig.height);
         }
 
         // Initialize touch contexts
         for (int i = 0; i < touchContextMap.length; i++) {
             touchContextMap[i] = new TouchContext(conn, i,
-                    (REFERENCE_HORIZ_RES / (double)screenSize.x),
-                    (REFERENCE_VERT_RES / (double)screenSize.y));
+                    REFERENCE_HORIZ_RES, REFERENCE_VERT_RES,
+                    streamView);
         }
 
         if (LimelightBuildProps.ROOT_BUILD) {
@@ -306,26 +308,6 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         sh.addCallback(this);
     }
 
-    private void resizeSurfaceWithAspectRatio(SurfaceView sv, double vidWidth, double vidHeight)
-    {
-        // Get the visible width of the activity
-        double visibleWidth = getWindow().getDecorView().getWidth();
-
-        ViewGroup.LayoutParams lp = sv.getLayoutParams();
-
-        // Calculate the new size of the SurfaceView
-        lp.width = (int) visibleWidth;
-        lp.height = (int) ((vidHeight / vidWidth) * visibleWidth);
-
-        // Apply the size change
-        sv.setLayoutParams(lp);
-
-        // refresh virtual controller layout
-        if (virtualController != null) {
-            virtualController.refreshLayout();
-        }
-    }
-
     private void checkDataConnection()
     {
         ConnectivityManager mgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
@@ -802,8 +784,8 @@ public class Game extends Activity implements SurfaceHolder.Callback,
 
             // Scale the deltas if the device resolution is different
             // than the stream resolution
-            deltaX = (int)Math.round((double)deltaX * (REFERENCE_HORIZ_RES / (double)screenSize.x));
-            deltaY = (int)Math.round((double)deltaY * (REFERENCE_VERT_RES / (double)screenSize.y));
+            deltaX = (int)Math.round((double)deltaX * (REFERENCE_HORIZ_RES / (double)streamView.getWidth()));
+            deltaY = (int)Math.round((double)deltaY * (REFERENCE_VERT_RES / (double)streamView.getHeight()));
 
             conn.sendMouseMove((short)deltaX, (short)deltaY);
         }
@@ -932,13 +914,6 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         if (!connected && !connecting) {
             connecting = true;
 
-            // Resize the surface to match the aspect ratio of the video
-            // This must be done after the surface is created.
-            if (deferredSurfaceResize) {
-                resizeSurfaceWithAspectRatio((SurfaceView) findViewById(R.id.surfaceView),
-                        prefConfig.width, prefConfig.height);
-            }
-
             conn.start(PlatformBinding.getDeviceName(), holder, drFlags,
                     PlatformBinding.getAudioRenderer(), decoderRenderer);
         }

app/src/main/java/com/limelight/PcView.java

@@ -53,7 +53,7 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
     private RelativeLayout noPcFoundLayout;
     private PcGridAdapter pcGridAdapter;
     private ComputerManagerService.ComputerManagerBinder managerBinder;
-    private boolean freezeUpdates, runningPolling, hasResumed;
+    private boolean freezeUpdates, runningPolling, inForeground;
     private final ServiceConnection serviceConnection = new ServiceConnection() {
         public void onServiceConnected(ComponentName className, IBinder binder) {
             final ComputerManagerService.ComputerManagerBinder localBinder =
@@ -161,11 +161,9 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
     }
 
     private void startComputerUpdates() {
-        if (managerBinder != null) {
-            if (runningPolling) {
-                return;
-            }
-
+        // Only allow polling to start if we're bound to CMS, polling is not already running,
+        // and our activity is in the foreground.
+        if (managerBinder != null && !runningPolling && inForeground) {
             freezeUpdates = false;
             managerBinder.startPolling(new ComputerManagerListener() {
                 @Override
@@ -215,7 +213,7 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
     protected void onResume() {
         super.onResume();
 
-        hasResumed = true;
+        inForeground = true;
         startComputerUpdates();
     }
 
@@ -223,7 +221,7 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
     protected void onPause() {
         super.onPause();
 
-        hasResumed = false;
+        inForeground = false;
         stopComputerUpdates(false);
     }
 
@@ -271,10 +269,9 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
     @Override
     public void onContextMenuClosed(Menu menu) {
         // For some reason, this gets called again _after_ onPause() is called on this activity.
-        // We don't want to start computer updates again, so we need to keep track of whether we're paused.
-        if (hasResumed) {
-            startComputerUpdates();
-        }
+        // startComputerUpdates() manages this and won't actual start polling until the activity
+        // returns to the foreground.
+        startComputerUpdates();
     }
 
     private void doPair(final ComputerDetails computer) {
@@ -330,7 +327,7 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
                         Dialog.displayDialog(PcView.this, getResources().getString(R.string.pair_pairing_title),
                                 getResources().getString(R.string.pair_pairing_msg)+" "+pinStr, false);
 
-                        PairingManager.PairState pairState = httpConn.pair(pinStr);
+                        PairingManager.PairState pairState = httpConn.pair(httpConn.getServerInfo(), pinStr);
                         if (pairState == PairingManager.PairState.PIN_WRONG) {
                             message = getResources().getString(R.string.pair_incorrect_pin);
                         }
@@ -368,14 +365,15 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
                         }
 
                         if (toastSuccess) {
-                            // Open the app list after a successful pairing attemp
+                            // Open the app list after a successful pairing attempt
                             doAppList(computer);
                         }
+                        else {
+                            // Start polling again if we're still in the foreground
+                            startComputerUpdates();
+                        }
                     }
                 });
-
-                // Start polling again
-                startComputerUpdates();
             }
         }).start();
     }

app/src/main/java/com/limelight/binding/input/ControllerHandler.java

@@ -82,6 +82,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         defaultContext.leftTriggerAxis = MotionEvent.AXIS_BRAKE;
         defaultContext.rightTriggerAxis = MotionEvent.AXIS_GAS;
         defaultContext.controllerNumber = (short) 0;
+        defaultContext.assignedControllerNumber = true;
     }
 
     private static InputDevice.MotionRange getMotionRangeForJoystickAxis(InputDevice dev, int axis) {
@@ -146,8 +147,9 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
             InputDeviceContext devContext = (InputDeviceContext) context;
 
             LimeLog.info(devContext.name+" ("+context.id+") needs a controller number assigned");
-            if (devContext.name != null && devContext.name.contains("gpio-keys")) {
-                // This is the back button on Shield portable consoles
+            if (devContext.name != null &&
+                    (devContext.name.contains("gpio-keys") || // This is the back button on Shield portable consoles
+                            devContext.name.contains("joy_key"))) { // These are the gamepad buttons on the Archos Gamepad 2
                 LimeLog.info("Built-in buttons hardcoded as controller 0");
                 context.controllerNumber = 0;
             }
@@ -212,6 +214,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         String devName = dev.getName();
 
         LimeLog.info("Creating controller context for device: "+devName);
+        LimeLog.info(dev.toString());
 
         context.name = devName;
         context.id = dev.getId();
@@ -229,6 +232,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         InputDevice.MotionRange rightTriggerRange = getMotionRangeForJoystickAxis(dev, MotionEvent.AXIS_RTRIGGER);
         InputDevice.MotionRange brakeRange = getMotionRangeForJoystickAxis(dev, MotionEvent.AXIS_BRAKE);
         InputDevice.MotionRange gasRange = getMotionRangeForJoystickAxis(dev, MotionEvent.AXIS_GAS);
+        InputDevice.MotionRange throttleRange = getMotionRangeForJoystickAxis(dev, MotionEvent.AXIS_THROTTLE);
         if (leftTriggerRange != null && rightTriggerRange != null)
         {
             // Some controllers use LTRIGGER and RTRIGGER (like Ouya)
@@ -241,6 +245,12 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
             context.leftTriggerAxis = MotionEvent.AXIS_BRAKE;
             context.rightTriggerAxis = MotionEvent.AXIS_GAS;
         }
+        else if (brakeRange != null && throttleRange != null)
+        {
+            // Others use THROTTLE and BRAKE (like Xiaomi)
+            context.leftTriggerAxis = MotionEvent.AXIS_BRAKE;
+            context.rightTriggerAxis = MotionEvent.AXIS_THROTTLE;
+        }
         else
         {
             InputDevice.MotionRange rxRange = getMotionRangeForJoystickAxis(dev, MotionEvent.AXIS_RX);
@@ -324,8 +334,11 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT) {
             boolean[] hasSelectKey = dev.hasKeys(KeyEvent.KEYCODE_BUTTON_SELECT, KeyEvent.KEYCODE_BACK, 0);
             if (hasSelectKey[0] && hasSelectKey[1]) {
-                LimeLog.info("Ignoring back button because select is present");
-                context.ignoreBack = true;
+                // Xiaomi gamepads claim to have both buttons then only send KEYCODE_BACK events
+                if (dev.getVendorId() != 0x2717) {
+                    LimeLog.info("Ignoring back button because select is present");
+                    context.ignoreBack = true;
+                }
             }
         }
 
@@ -398,12 +411,82 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         return context;
     }
 
-    private void sendControllerInputPacket(GenericControllerContext context) {
-        assignControllerNumberIfNeeded(context);
-        conn.sendControllerInput(context.controllerNumber, context.inputMap,
-                context.leftTrigger, context.rightTrigger,
-                context.leftStickX, context.leftStickY,
-                context.rightStickX, context.rightStickY);
+    private byte maxByMagnitude(byte a, byte b) {
+        int absA = Math.abs(a);
+        int absB = Math.abs(b);
+        if (absA > absB) {
+            return a;
+        }
+        else {
+            return b;
+        }
+    }
+
+    private short maxByMagnitude(short a, short b) {
+        int absA = Math.abs(a);
+        int absB = Math.abs(b);
+        if (absA > absB) {
+            return a;
+        }
+        else {
+            return b;
+        }
+    }
+
+    private void sendControllerInputPacket(GenericControllerContext originalContext) {
+        assignControllerNumberIfNeeded(originalContext);
+
+        // Take the context's controller number and fuse all inputs with the same number
+        short controllerNumber = originalContext.controllerNumber;
+        short inputMap = 0;
+        byte leftTrigger = 0;
+        byte rightTrigger = 0;
+        short leftStickX = 0;
+        short leftStickY = 0;
+        short rightStickX = 0;
+        short rightStickY = 0;
+
+        // In order to properly handle controllers that are split into multiple devices,
+        // we must aggregate all controllers with the same controller number into a single
+        // device before we send it.
+        for (int i = 0; i < inputDeviceContexts.size(); i++) {
+            GenericControllerContext context = inputDeviceContexts.valueAt(i);
+            if (context.assignedControllerNumber && context.controllerNumber == controllerNumber) {
+                inputMap |= context.inputMap;
+                leftTrigger |= maxByMagnitude(leftTrigger, context.leftTrigger);
+                rightTrigger |= maxByMagnitude(rightTrigger, context.rightTrigger);
+                leftStickX |= maxByMagnitude(leftStickX, context.leftStickX);
+                leftStickY |= maxByMagnitude(leftStickY, context.leftStickY);
+                rightStickX |= maxByMagnitude(rightStickX, context.rightStickX);
+                rightStickY |= maxByMagnitude(rightStickY, context.rightStickY);
+            }
+        }
+        for (int i = 0; i < usbDeviceContexts.size(); i++) {
+            GenericControllerContext context = usbDeviceContexts.valueAt(i);
+            if (context.assignedControllerNumber && context.controllerNumber == controllerNumber) {
+                inputMap |= context.inputMap;
+                leftTrigger |= maxByMagnitude(leftTrigger, context.leftTrigger);
+                rightTrigger |= maxByMagnitude(rightTrigger, context.rightTrigger);
+                leftStickX |= maxByMagnitude(leftStickX, context.leftStickX);
+                leftStickY |= maxByMagnitude(leftStickY, context.leftStickY);
+                rightStickX |= maxByMagnitude(rightStickX, context.rightStickX);
+                rightStickY |= maxByMagnitude(rightStickY, context.rightStickY);
+            }
+        }
+        if (defaultContext.controllerNumber == controllerNumber) {
+            inputMap |= defaultContext.inputMap;
+            leftTrigger |= maxByMagnitude(leftTrigger, defaultContext.leftTrigger);
+            rightTrigger |= maxByMagnitude(rightTrigger, defaultContext.rightTrigger);
+            leftStickX |= maxByMagnitude(leftStickX, defaultContext.leftStickX);
+            leftStickY |= maxByMagnitude(leftStickY, defaultContext.leftStickY);
+            rightStickX |= maxByMagnitude(rightStickX, defaultContext.rightStickX);
+            rightStickY |= maxByMagnitude(rightStickY, defaultContext.rightStickY);
+        }
+
+        conn.sendControllerInput(controllerNumber, inputMap,
+                leftTrigger, rightTrigger,
+                leftStickX, leftStickY,
+                rightStickX, rightStickY);
     }
 
     // Return a valid keycode, 0 to consume, or -1 to not consume the event

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

@@ -1,5 +1,7 @@
 package com.limelight.binding.input;
 
+import android.view.View;
+
 import com.limelight.nvstream.NvConnection;
 import com.limelight.nvstream.input.MouseButtonPacket;
 
@@ -17,23 +19,27 @@ public class TouchContext {
     private boolean confirmedDrag;
     private Timer dragTimer;
     private double distanceMoved;
+    private double xFactor, yFactor;
 
     private final NvConnection conn;
     private final int actionIndex;
-    private final double xFactor;
-    private final double yFactor;
+    private final int referenceWidth;
+    private final int referenceHeight;
+    private final View targetView;
 
     private static final int TAP_MOVEMENT_THRESHOLD = 20;
     private static final int TAP_DISTANCE_THRESHOLD = 25;
     private static final int TAP_TIME_THRESHOLD = 250;
     private static final int DRAG_TIME_THRESHOLD = 650;
 
-    public TouchContext(NvConnection conn, int actionIndex, double xFactor, double yFactor)
+    public TouchContext(NvConnection conn, int actionIndex,
+                        int referenceWidth, int referenceHeight, View view)
     {
         this.conn = conn;
         this.actionIndex = actionIndex;
-        this.xFactor = xFactor;
-        this.yFactor = yFactor;
+        this.referenceWidth = referenceWidth;
+        this.referenceHeight = referenceHeight;
+        this.targetView = view;
     }
 
     public int getActionIndex()
@@ -68,6 +74,10 @@ public class TouchContext {
 
     public boolean touchDownEvent(int eventX, int eventY)
     {
+        // Get the view dimensions to scale inputs on this touch
+        xFactor = referenceWidth / (double)targetView.getWidth();
+        yFactor = referenceHeight / (double)targetView.getHeight();
+
         originalTouchX = lastTouchX = eventX;
         originalTouchY = lastTouchY = eventY;
         originalTouchTime = System.currentTimeMillis();

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

@@ -1,6 +1,7 @@
 package com.limelight.binding.input.evdev;
 
-import android.content.Context;
+import android.app.Activity;
+import android.widget.Toast;
 
 import com.limelight.LimeLog;
 
@@ -23,6 +24,7 @@ public class EvdevHandler {
     private Process su;
     private ServerSocket servSock;
     private Socket evdevSock;
+    private Activity activity;
 
     private static final byte UNGRAB_REQUEST = 1;
     private static final byte REGRAB_REQUEST = 2;
@@ -49,6 +51,12 @@ public class EvdevHandler {
             try {
                 su = builder.start();
             } catch (IOException e) {
+                activity.runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        Toast.makeText(activity, "This device is not rooted - Mouse capture is unavailable", Toast.LENGTH_LONG).show();
+                    }
+                });
                 e.printStackTrace();
                 return;
             }
@@ -155,9 +163,10 @@ public class EvdevHandler {
         }
     };
 
-    public EvdevHandler(Context context, EvdevListener listener) {
+    public EvdevHandler(Activity activity, EvdevListener listener) {
         this.listener = listener;
-        this.libraryPath = context.getApplicationInfo().nativeLibraryDir;
+        this.activity = activity;
+        this.libraryPath = activity.getApplicationInfo().nativeLibraryDir;
     }
 
     public void regrabAll() {

app/src/main/java/com/limelight/binding/video/MediaCodecHelper.java

@@ -57,6 +57,11 @@ public class MediaCodecHelper {
 		// Software decoders that don't support H264 high profile
 		blacklistedDecoderPrefixes.add("omx.google");
 		blacklistedDecoderPrefixes.add("AVCDecoder");
+
+		// Without bitstream fixups, we perform horribly on NVIDIA's HEVC
+		// decoder. While not strictly necessary, I'm going to fully blacklist this
+		// one to avoid users getting inaccurate impressions of Tegra X1/Moonlight performance.
+		blacklistedDecoderPrefixes.add("OMX.Nvidia.h265.decode");
 	}
 	
 	static {

app/src/main/java/com/limelight/preferences/PreferenceConfiguration.java

@@ -100,7 +100,7 @@ public class PreferenceConfiguration {
         }
 
         // Use small mode on anything smaller than a 7" tablet
-        return context.getResources().getConfiguration().smallestScreenWidthDp < 600;
+        return context.getResources().getConfiguration().screenWidthDp < 600;
     }
 
     public static int getDefaultBitrate(Context context) {

app/src/main/java/com/limelight/ui/StreamView.java

@@ -0,0 +1,55 @@
+package com.limelight.ui;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.SurfaceView;
+
+public class StreamView extends SurfaceView {
+    private double desiredAspectRatio;
+
+    public void setDesiredAspectRatio(double aspectRatio) {
+        this.desiredAspectRatio = aspectRatio;
+    }
+
+    public StreamView(Context context) {
+        super(context);
+    }
+
+    public StreamView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public StreamView(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    @TargetApi(21)
+    public StreamView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+
+    @Override
+    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
+        // If no fixed aspect ratio has been provided, simply use the default onMeasure() behavior
+        if (desiredAspectRatio == 0) {
+            super.onMeasure(widthMeasureSpec, heightMeasureSpec);
+            return;
+        }
+
+        // Based on code from: https://www.buzzingandroid.com/2012/11/easy-measuring-of-custom-views-with-specific-aspect-ratio/
+        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
+        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
+
+        int measuredHeight, measuredWidth;
+        if (widthSize > heightSize * desiredAspectRatio) {
+            measuredHeight = heightSize;
+            measuredWidth = (int)(measuredHeight * desiredAspectRatio);
+        } else {
+            measuredWidth = widthSize;
+            measuredHeight = (int)(measuredWidth / desiredAspectRatio);
+        }
+
+        setMeasuredDimension(measuredWidth, measuredHeight);
+    }
+}

app/src/main/jni/jnienet/Android.mk

@@ -0,0 +1,25 @@
+# Android.mk for Moonlight's ENet JNI binding
+MY_LOCAL_PATH := $(call my-dir)
+
+include $(call all-subdir-makefiles)
+
+LOCAL_PATH := $(MY_LOCAL_PATH)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE    := jnienet
+
+LOCAL_SRC_FILES := jnienet.c \
+                   enet/callbacks.c \
+                   enet/compress.c \
+                   enet/host.c \
+                   enet/list.c \
+                   enet/packet.c \
+                   enet/peer.c \
+                   enet/protocol.c \
+                   enet/unix.c \
+                   enet/win32.c \
+
+LOCAL_CFLAGS := -DHAS_SOCKLEN_T=1
+LOCAL_C_INCLUDES := $(LOCAL_PATH)/enet/include
+
+include $(BUILD_SHARED_LIBRARY)

app/src/main/jni/jnienet/jnienet.c

@@ -0,0 +1,148 @@
+#include "enet/enet.h"
+
+#include <stdlib.h>
+#include <string.h>
+
+#include <jni.h>
+
+#define CLIENT_TO_LONG(x) ((intptr_t)(x))
+#define LONG_TO_CLIENT(x) ((ENetHost*)(intptr_t)(x))
+
+#define PEER_TO_LONG(x) ((intptr_t)(x))
+#define LONG_TO_PEER(x) ((ENetPeer*)(intptr_t)(x))
+
+JNIEXPORT jint JNICALL
+Java_com_limelight_nvstream_enet_EnetConnection_initializeEnet(JNIEnv *env, jobject class) {
+    return enet_initialize();
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_limelight_nvstream_enet_EnetConnection_createClient(JNIEnv *env, jobject class, jstring address) {
+    ENetAddress enetAddress;
+    const char *addrStr;
+    int err;
+    
+    // Perform a lookup on the address to determine the address family
+    addrStr = (*env)->GetStringUTFChars(env, address, 0);
+    err = enet_address_set_host(&enetAddress, addrStr);
+    (*env)->ReleaseStringUTFChars(env, address, addrStr);
+    if (err < 0) {
+        return CLIENT_TO_LONG(NULL);
+    }
+    
+    // Create a client that can use 1 outgoing connection and 1 channel
+    return CLIENT_TO_LONG(enet_host_create(enetAddress.address.ss_family, NULL, 1, 1, 0, 0));
+}
+
+JNIEXPORT jlong JNICALL
+Java_com_limelight_nvstream_enet_EnetConnection_connectToPeer(JNIEnv *env, jobject class, jlong client, jstring address, jint port, jint timeout) {
+    ENetPeer* peer;
+    ENetAddress enetAddress;
+    ENetEvent event;
+    const char *addrStr;
+    int err;
+
+    // Initialize the ENet address
+    addrStr = (*env)->GetStringUTFChars(env, address, 0);    
+    err = enet_address_set_host(&enetAddress, addrStr);
+    enet_address_set_port(&enetAddress, port);
+    (*env)->ReleaseStringUTFChars(env, address, addrStr);
+    if (err < 0) {
+        return PEER_TO_LONG(NULL);
+    }
+    
+    // Start the connection
+    peer = enet_host_connect(LONG_TO_CLIENT(client), &enetAddress, 1, 0);
+    if (peer == NULL) {
+        return PEER_TO_LONG(NULL);
+    }
+    
+    // Wait for the connect to complete
+    if (enet_host_service(LONG_TO_CLIENT(client), &event, timeout) <= 0 || event.type != ENET_EVENT_TYPE_CONNECT) {
+        enet_peer_reset(peer);
+        return PEER_TO_LONG(NULL);
+    }
+    
+    // Ensure the connect verify ACK is sent immediately
+    enet_host_flush(LONG_TO_CLIENT(client));
+
+    // Set the max peer timeout to 10 seconds
+    enet_peer_timeout(peer, ENET_PEER_TIMEOUT_LIMIT, ENET_PEER_TIMEOUT_MINIMUM, 10000);
+    
+    return PEER_TO_LONG(peer);
+}
+
+JNIEXPORT jint JNICALL
+Java_com_limelight_nvstream_enet_EnetConnection_readPacket(JNIEnv *env, jobject class, jlong client, jbyteArray data, jint length, jint timeout) {
+    jint err;
+    jbyte* dataPtr;
+    ENetEvent event;
+    
+    // Wait for a receive event, timeout, or disconnect
+    err = enet_host_service(LONG_TO_CLIENT(client), &event, timeout);
+    if (err <= 0) {
+        return err;
+    }
+    else if (event.type != ENET_EVENT_TYPE_RECEIVE) {
+        return -1;
+    }
+    
+    // Check that the packet isn't too large
+    if (event.packet->dataLength > length) {
+        enet_packet_destroy(event.packet);
+        return event.packet->dataLength;
+    }
+    
+    // Copy the packet data into the caller's buffer
+    dataPtr = (*env)->GetByteArrayElements(env, data, 0);
+    memcpy(dataPtr, event.packet->data, event.packet->dataLength);
+    err = event.packet->dataLength;
+    (*env)->ReleaseByteArrayElements(env, data, dataPtr, 0);
+    
+    // Free the packet
+    enet_packet_destroy(event.packet);
+    
+    return err;
+}
+
+JNIEXPORT jboolean JNICALL
+Java_com_limelight_nvstream_enet_EnetConnection_writePacket(JNIEnv *env, jobject class, jlong client, jlong peer, jbyteArray data, jint length, jint packetFlags) {
+    ENetPacket* packet;
+    jboolean ret;
+    jbyte* dataPtr;
+    
+    dataPtr = (*env)->GetByteArrayElements(env, data, 0);
+    
+    // Create the reliable packet that describes our outgoing message
+    packet = enet_packet_create(dataPtr, length, packetFlags);
+    if (packet != NULL) {
+        // Send the message to the peer
+        if (enet_peer_send(LONG_TO_PEER(peer), 0, packet) < 0) {
+            // This can fail if the peer has been disconnected
+            enet_packet_destroy(packet);
+            ret = JNI_FALSE;
+        }
+        else {
+            // Force the client to send the packet now
+            enet_host_flush(LONG_TO_CLIENT(client));
+            ret = JNI_TRUE;
+        }
+    }
+    else {
+        ret = JNI_FALSE;
+    }
+    
+    (*env)->ReleaseByteArrayElements(env, data, dataPtr, JNI_ABORT);
+    
+    return ret;
+}
+
+JNIEXPORT void JNICALL
+Java_com_limelight_nvstream_enet_EnetConnection_destroyClient(JNIEnv *env, jobject class, jlong client) {
+    enet_host_destroy(LONG_TO_CLIENT(client));
+}
+
+JNIEXPORT void JNICALL
+Java_com_limelight_nvstream_enet_EnetConnection_disconnectPeer(JNIEnv *env, jobject class, jlong peer) {
+    enet_peer_disconnect_now(LONG_TO_PEER(peer), 0);
+}

app/src/main/res/layout/activity_game.xml

@@ -4,7 +4,7 @@
     android:layout_height="match_parent"
     tools:context=".Game" >
 
-    <SurfaceView
+    <com.limelight.ui.StreamView
         android:id="@+id/surfaceView"
         android:layout_width="match_parent"
         android:layout_height="match_parent"

build.gradle

@@ -4,7 +4,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:2.0.0-beta2'
+        classpath 'com.android.tools.build:gradle:2.1.0'
     }
 }