Version 5.8

* Fix russian translation

* Complete russian translation

.gitignore

@@ -30,7 +30,7 @@ Thumbs.db
 #.idea/workspace.xml - remove # and delete .idea if it better suit your needs.
 .gradle
 build/
-app/app.iml
+*.iml
 
 # Compiled JNI libraries folder
 **/jniLibs

README.md

@@ -1,4 +1,4 @@
-#Moonlight
+# Moonlight
 
 [Moonlight](http://moonlight-stream.com) is an open source implementation of NVIDIA's GameStream, as used by the NVIDIA Shield.
 We reverse engineered the Shield streaming software and created a version that can be run on any Android device.
@@ -10,35 +10,35 @@ whether in your own home or over the internet.
 
 Check our [wiki](https://github.com/moonlight-stream/moonlight-docs/wiki) for more detailed information or a troubleshooting guide. 
 
-##Features
+## Features
 
 * Streams any of your games from your PC to your Android device
 * Full gamepad support for MOGA, Xbox 360, PS3, OUYA, and Shield
 * Automatically finds GameStream-compatible PCs on your network
 
-##Installation
+## Installation
 
 * Download and install Moonlight for Android from
 [Google Play](https://play.google.com/store/apps/details?id=com.limelight), [Amazon App Store](http://www.amazon.com/gp/product/B00JK4MFN2), or directly from the [releases page](https://github.com/moonlight-stream/moonlight-android/releases)
 * Download [GeForce Experience](http://www.geforce.com/geforce-experience) and install on your Windows PC
 
-##Requirements
+## Requirements
 
-* [GameStream compatible](http://shield.nvidia.com/play-pc-games/) computer with GTX 600/700 series GPU
+* [GameStream compatible](http://shield.nvidia.com/play-pc-games/) computer with an NVIDIA GeForce GTX 600 series or higher desktop or mobile GPU (GT-series and AMD GPUs not supported)
 * Android device running 4.1 (Jelly Bean) or higher
 * High-end wireless router (802.11n dual-band recommended)
 
-##Usage
+## Usage
 
 * Turn on GameStream in the GFE settings
 * If you are connecting from outside the same network, turn on internet
   streaming
 * When on the same network as your PC, open Moonlight and tap on your PC in the list
-* Accept the pairing confirmation on your PC
+* Accept the pairing confirmation on your PC and add the PIN if needed
 * Tap your PC again to view the list of apps to stream
 * Play games!
 
-##Contribute
+## Contribute
 
 This project is being actively developed at [XDA Developers](http://forum.xda-developers.com/showthread.php?t=2505510)
 
@@ -46,13 +46,13 @@ This project is being actively developed at [XDA Developers](http://forum.xda-de
 2. Write code
 3. Send Pull Requests
 
-##Building
+## Building
 * Install Android Studio and the Android NDK
 * Run ‘git submodule update --init --recursive’ from within moonlight-android/
 * In moonlight-android/, create a file called ‘local.properties’. Add an ‘ndk.dir=’ property to the local.properties file and set it equal to your NDK directory.
 * Build the APK using Android Studio
 
-##Authors
+## Authors
 
 * [Cameron Gutman](https://github.com/cgutman)  
 * [Diego Waxemberg](https://github.com/dwaxemberg)  

app/build.gradle

@@ -1,37 +1,43 @@
-import com.android.builder.model.ProductFlavor
-import org.apache.tools.ant.taskdefs.condition.Os
-
 apply plugin: 'com.android.application'
 
 android {
-    compileSdkVersion 26
+    compileSdkVersion 27
-    buildToolsVersion '26.0.0'
 
     defaultConfig {
         minSdkVersion 16
-        targetSdkVersion 26
+        targetSdkVersion 27
 
-        versionName "5.1"
+        versionName "5.8"
-        versionCode = 128
+        versionCode = 161
     }
 
+    flavorDimensions "root"
+
     productFlavors {
         root {
             // Android O has native mouse capture, so don't show the rooted
             // version to devices running O on the Play Store.
             maxSdkVersion 25
 
-            applicationId "com.limelight.root"
+            externalNativeBuild {
-            ndk {
+                ndkBuild {
-                abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64", "mips", "mips64"
+                    arguments "PRODUCT_FLAVOR=root"
+                }
             }
+
+            applicationId "com.limelight.root"
+            dimension "root"
         }
 
         nonRoot {
-            applicationId "com.limelight"
+            externalNativeBuild {
-            ndk {
+                ndkBuild {
-                abiFilters "armeabi-v7a", "arm64-v8a", "x86", "x86_64", "mips", "mips64"
+                    arguments "PRODUCT_FLAVOR=nonRoot"
+                }
             }
+
+            applicationId "com.limelight"
+            dimension "root"
         }
     }
 
@@ -39,10 +45,57 @@ android {
         disable 'MissingTranslation'
     }
 
+    bundle {
+        language {
+            // Avoid splitting by language, since we allow users
+            // to manually switch language in settings.
+            enableSplit = false
+        }
+    }
+
     buildTypes {
+        debug {
+            applicationIdSuffix ".debug"
+
+            minifyEnabled true
+            useProguard false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+        }
         release {
-            minifyEnabled false
+            // To whomever is releasing/using an APK in release mode with
-            proguardFiles getDefaultProguardFile('proguard-android.txt')
+            // Moonlight's official application ID, please stop. I see every
+            // single one of your crashes in my Play Console and it makes
+            // Moonlight's reliability look worse and makes it more difficult
+            // to distinguish real crashes from your crashy VR app. Seriously,
+            // 44 of the *same* native crash in 72 hours and a few each of
+            // several other crashes.
+            //
+            // This is technically not your fault. I would have hoped Google
+            // would validate the signature of the APK before attributing
+            // the crash to it. I asked their Play Store support about this
+            // and they said they don't and don't have plans to, so that sucks.
+            //
+            // In any case, it's bad form to release an APK using someone
+            // else's application ID. There is no legitimate reason, that
+            // anyone would need to comment out the following line, except me
+            // when I release an official signed Moonlight build. If you feel
+            // like doing so would solve something, I can tell you it will not.
+            // You can't upgrade an app while retaining data without having the
+            // same signature as the official version. Nor can you post it on
+            // the Play Store, since that application ID is already taken.
+            // Reputable APK hosting websites similarly validate the signature
+            // is consistent with the Play Store and won't allow an APK that
+            // isn't signed the same as the original.
+            //
+            // I wish any and all people using Moonlight as the basis of other
+            // cool projects the best of luck with their efforts. All I ask
+            // is to please change the applicationId before you publish.
+            //
+            // TL;DR: Leave the following line alone!
+            applicationIdSuffix ".unofficial"
+
+            minifyEnabled true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
 
@@ -54,10 +107,9 @@ android {
 }
 
 dependencies {
-    compile 'org.bouncycastle:bcprov-jdk15on:1.52'
+    implementation 'org.bouncycastle:bcprov-jdk15on:1.59'
-    compile 'org.bouncycastle:bcpkix-jdk15on:1.52'
+    implementation 'org.bouncycastle:bcpkix-jdk15on:1.59'
-    compile files('libs/jcodec-0.1.9-patched.jar')
+    implementation 'org.jcodec:jcodec:0.2.3'
 
-    debugCompile project(path:':moonlight-common', configuration:'debug')
+    implementation project(':moonlight-common')
-    releaseCompile project(path:':moonlight-common', configuration:'release')
 }

app/proguard-rules.pro

@@ -0,0 +1,27 @@
+# Don't obfuscate code
+-dontobfuscate
+
+# Our code
+-keep class com.limelight.binding.input.evdev.* {*;}
+
+# Moonlight common
+-keep class com.limelight.nvstream.jni.* {*;}
+
+# Okio
+-keep class sun.misc.Unsafe {*;}
+-dontwarn java.nio.file.*
+-dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
+-dontwarn okio.**
+
+# BouncyCastle
+-keep class org.bouncycastle.jcajce.provider.asymmetric.* {*;}
+-keep class org.bouncycastle.jcajce.provider.asymmetric.util.* {*;}
+-keep class org.bouncycastle.jcajce.provider.asymmetric.rsa.* {*;}
+-keep class org.bouncycastle.jcajce.provider.digest.** {*;}
+-keep class org.bouncycastle.jcajce.provider.symmetric.** {*;}
+-keep class org.bouncycastle.jcajce.spec.* {*;}
+-keep class org.bouncycastle.jce.** {*;}
+-dontwarn javax.naming.**
+
+# jMDNS
+-dontwarn javax.jmdns.impl.DNSCache

app/src/debug/res/values/strings.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <string name="app_label" translatable="false">Moonlight (Debug)</string>
+    <string name="app_label_root" translatable="false">Moonlight (Root Debug)</string>
+
+</resources>

app/src/main/AndroidManifest.xml

@@ -24,12 +24,20 @@
         android:name="android.software.leanback"
         android:required="false" />
 
+    <!-- Disable legacy input emulation on ChromeOS -->
+    <uses-feature
+        android:name="android.hardware.type.pc"
+        android:required="false"/>
+
     <application
         android:allowBackup="true"
         android:fullBackupContent="@xml/backup_rules"
+        android:networkSecurityConfig="@xml/network_security_config"
         android:isGame="true"
         android:banner="@drawable/atv_banner"
-        android:icon="@drawable/ic_launcher"
+        android:appCategory="game"
+        android:icon="@mipmap/ic_launcher"
+        android:roundIcon="@mipmap/ic_launcher"
         android:theme="@style/AppTheme">
 
         <!-- Samsung multi-window support -->
@@ -91,12 +99,16 @@
                 android:name="android.support.PARENT_ACTIVITY"
                 android:value="com.limelight.PcView" />
         </activity>
+        <!-- This will fall back to sensorLandscape at runtime on Android 4.2 and below -->
         <activity
             android:name=".Game"
             android:configChanges="mcc|mnc|locale|touchscreen|keyboard|keyboardHidden|navigation|screenLayout|fontScale|uiMode|orientation|screenSize|smallestScreenSize|layoutDirection"
-            android:screenOrientation="sensorLandscape"
+            android:screenOrientation="userLandscape"
             android:noHistory="true"
+            android:supportsPictureInPicture="true"
             android:resizeableActivity="true"
+            android:launchMode="singleTask"
+            android:excludeFromRecents="true"
             android:theme="@style/StreamTheme">
             <meta-data
                 android:name="android.support.PARENT_ACTIVITY"

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

@@ -2,7 +2,6 @@ package com.limelight;
 
 import java.io.StringReader;
 import java.util.List;
-import java.util.Locale;
 import java.util.UUID;
 
 import com.limelight.computers.ComputerManagerListener;
@@ -27,7 +26,6 @@ import android.app.Service;
 import android.content.ComponentName;
 import android.content.Intent;
 import android.content.ServiceConnection;
-import android.content.res.Configuration;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.view.ContextMenu;
@@ -237,6 +235,10 @@ public class AppView extends Activity implements AdapterFragmentCallbacks {
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
+        // Assume we're in the foreground when created to avoid a race
+        // between binding to CMS and onResume()
+        inForeground = true;
+
         shortcutHelper = new ShortcutHelper(this);
 
         UiHelper.setLocale(this);
@@ -250,7 +252,7 @@ public class AppView extends Activity implements AdapterFragmentCallbacks {
         String computerName = getIntent().getStringExtra(NAME_EXTRA);
 
         String labelText = getResources().getString(R.string.title_applist)+" "+computerName;
-        TextView label = (TextView) findViewById(R.id.appListText);
+        TextView label = findViewById(R.id.appListText);
         setTitle(labelText);
         label.setText(labelText);
 
@@ -302,6 +304,9 @@ public class AppView extends Activity implements AdapterFragmentCallbacks {
     protected void onResume() {
         super.onResume();
 
+        // Display a decoder crash notification if we've returned after a crash
+        UiHelper.showDecoderCrashDialog(this);
+
         inForeground = true;
         startComputerUpdates();
     }

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

@@ -69,6 +69,13 @@ public class AppViewShortcutTrampoline extends Activity {
                                             blockingLoadSpinner = null;
                                         }
 
+                                        // If the managerBinder was destroyed before this callback,
+                                        // just finish the activity.
+                                        if (managerBinder == null) {
+                                            finish();
+                                            return;
+                                        }
+
                                         if (details.state == ComputerDetails.State.ONLINE) {
                                             // Close this activity
                                             finish();
@@ -91,7 +98,7 @@ public class AppViewShortcutTrampoline extends Activity {
                                             // If a game is running, we'll make the stream the top level activity
                                             if (details.runningGameId != 0) {
                                                 intentStack.add(ServerHelper.createStartIntent(AppViewShortcutTrampoline.this,
-                                                        new NvApp("app", details.runningGameId), details, managerBinder));
+                                                        new NvApp("app", details.runningGameId, false), details, managerBinder));
                                             }
 
                                             // Now start the activities

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

@@ -10,6 +10,7 @@ import com.limelight.binding.input.TouchContext;
 import com.limelight.binding.input.driver.UsbDriverService;
 import com.limelight.binding.input.evdev.EvdevListener;
 import com.limelight.binding.input.virtual_controller.VirtualController;
+import com.limelight.binding.video.CrashListener;
 import com.limelight.binding.video.MediaCodecDecoderRenderer;
 import com.limelight.binding.video.MediaCodecHelper;
 import com.limelight.nvstream.NvConnection;
@@ -19,6 +20,7 @@ import com.limelight.nvstream.http.NvApp;
 import com.limelight.nvstream.input.KeyboardPacket;
 import com.limelight.nvstream.input.MouseButtonPacket;
 import com.limelight.nvstream.jni.MoonBridge;
+import com.limelight.preferences.GlPreferences;
 import com.limelight.preferences.PreferenceConfiguration;
 import com.limelight.ui.GameGestures;
 import com.limelight.ui.StreamView;
@@ -28,13 +30,19 @@ import com.limelight.utils.SpinnerDialog;
 import com.limelight.utils.UiHelper;
 
 import android.annotation.SuppressLint;
+import android.annotation.TargetApi;
 import android.app.Activity;
+import android.app.PictureInPictureParams;
 import android.app.Service;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
+import android.content.SharedPreferences;
+import android.content.pm.ActivityInfo;
+import android.content.res.Configuration;
 import android.graphics.Point;
+import android.graphics.Rect;
 import android.hardware.input.InputManager;
 import android.media.AudioManager;
 import android.net.ConnectivityManager;
@@ -44,6 +52,7 @@ import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.SystemClock;
+import android.util.Rational;
 import android.view.Display;
 import android.view.InputDevice;
 import android.view.KeyEvent;
@@ -62,7 +71,7 @@ import android.widget.Toast;
 
 public class Game extends Activity implements SurfaceHolder.Callback,
     OnGenericMotionListener, OnTouchListener, NvConnectionListener, EvdevListener,
-    OnSystemUiVisibilityChangeListener, GameGestures
+    OnSystemUiVisibilityChangeListener, GameGestures, StreamView.InputCallbacks
 {
     private int lastMouseX = Integer.MIN_VALUE;
     private int lastMouseY = Integer.MIN_VALUE;
@@ -81,12 +90,15 @@ public class Game extends Activity implements SurfaceHolder.Callback,
     private VirtualController virtualController;
 
     private PreferenceConfiguration prefConfig;
+    private SharedPreferences tombstonePrefs;
 
     private NvConnection conn;
     private SpinnerDialog spinner;
     private boolean displayedFailureDialog = false;
     private boolean connecting = false;
     private boolean connected = false;
+    private boolean surfaceCreated = false;
+    private boolean attemptedConnection = false;
 
     private InputCaptureProvider inputCaptureProvider;
     private int modifierFlags = 0;
@@ -97,6 +109,7 @@ public class Game extends Activity implements SurfaceHolder.Callback,
     private ShortcutHelper shortcutHelper;
 
     private MediaCodecDecoderRenderer decoderRenderer;
+    private boolean reportedCrash;
 
     private WifiManager.WifiLock wifiLock;
 
@@ -122,13 +135,12 @@ public class Game extends Activity implements SurfaceHolder.Callback,
     public static final String EXTRA_STREAMING_REMOTE = "Remote";
     public static final String EXTRA_PC_UUID = "UUID";
     public static final String EXTRA_PC_NAME = "PcName";
+    public static final String EXTRA_APP_HDR = "HDR";
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
-        shortcutHelper = new ShortcutHelper(this);
-
         UiHelper.setLocale(this);
 
         // We don't want a title bar
@@ -150,6 +162,12 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             getWindow().addFlags(WindowManager.LayoutParams.FLAG_LAYOUT_IN_SCREEN);
         }
 
+        // We specified userLandscape in the manifest which isn't supported until 4.3,
+        // so we must fall back at runtime to sensorLandscape.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.JELLY_BEAN_MR2) {
+            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
+        }
+
         // Listen for UI visibility events
         getWindow().getDecorView().setOnSystemUiVisibilityChangeListener(this);
 
@@ -165,11 +183,14 @@ public class Game extends Activity implements SurfaceHolder.Callback,
 
         // Read the stream preferences
         prefConfig = PreferenceConfiguration.readPreferences(this);
+        tombstonePrefs = Game.this.getSharedPreferences("DecoderTombstone", 0);
+
 
         // Listen for events on the game surface
-        streamView = (StreamView) findViewById(R.id.surfaceView);
+        streamView = findViewById(R.id.surfaceView);
         streamView.setOnGenericMotionListener(this);
         streamView.setOnTouchListener(this);
+        streamView.setInputCallbacks(this);
 
         inputCaptureProvider = InputCaptureManager.getInputCaptureProvider(this, this);
 
@@ -186,7 +207,10 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         }
 
         // Warn the user if they're on a metered connection
-        checkDataConnection();
+        ConnectivityManager connMgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
+        if (connMgr.isActiveNetworkMetered()) {
+            displayTransientMessage(getResources().getString(R.string.conn_metered));
+        }
 
         // Make sure Wi-Fi is fully powered up
         WifiManager wifiMgr = (WifiManager) getApplicationContext().getSystemService(Context.WIFI_SERVICE);
@@ -201,6 +225,7 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         boolean remote = Game.this.getIntent().getBooleanExtra(EXTRA_STREAMING_REMOTE, false);
         String uuid = Game.this.getIntent().getStringExtra(EXTRA_PC_UUID);
         String pcName = Game.this.getIntent().getStringExtra(EXTRA_PC_NAME);
+        boolean willStreamHdr = Game.this.getIntent().getBooleanExtra(EXTRA_APP_HDR, false);
 
         if (appId == StreamConfiguration.INVALID_APP_ID) {
             finish();
@@ -208,41 +233,146 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         }
 
         // Add a launcher shortcut for this PC (forced, since this is user interaction)
+        shortcutHelper = new ShortcutHelper(this);
         shortcutHelper.createAppViewShortcut(uuid, pcName, uuid, true);
         shortcutHelper.reportShortcutUsed(uuid);
 
         // Initialize the MediaCodec helper before creating the decoder
-        MediaCodecHelper.initializeWithContext(this);
+        GlPreferences glPrefs = GlPreferences.readPreferences(this);
+        MediaCodecHelper.initialize(this, glPrefs.glRenderer);
 
-        decoderRenderer = new MediaCodecDecoderRenderer(prefConfig.videoFormat, prefConfig.bitrate);
+        // Check if the user has enabled HDR
+        if (prefConfig.enableHdr) {
+            // Check if the app supports it
+            if (!willStreamHdr) {
+                Toast.makeText(this, "This game does not support HDR10", Toast.LENGTH_SHORT).show();
+            }
+            // It does, so start our HDR checklist
+            else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+                // We already know the app supports HDR if willStreamHdr is set.
+                Display display = getWindowManager().getDefaultDisplay();
+                Display.HdrCapabilities hdrCaps = display.getHdrCapabilities();
+
+                // We must now ensure our display is compatible with HDR10
+                boolean foundHdr10 = false;
+                for (int hdrType : hdrCaps.getSupportedHdrTypes()) {
+                    if (hdrType == Display.HdrCapabilities.HDR_TYPE_HDR10) {
+                        LimeLog.info("Display supports HDR10");
+                        foundHdr10 = true;
+                    }
+                }
+
+                if (!foundHdr10) {
+                    // Nope, no HDR for us :(
+                    willStreamHdr = false;
+                    Toast.makeText(this, "Display does not support HDR10", Toast.LENGTH_LONG).show();
+                }
+            }
+            else {
+                Toast.makeText(this, "HDR requires Android 7.0 or later", Toast.LENGTH_LONG).show();
+                willStreamHdr = false;
+            }
+        }
+        else {
+            willStreamHdr = false;
+        }
+
+        decoderRenderer = new MediaCodecDecoderRenderer(prefConfig,
+                new CrashListener() {
+                    @Override
+                    public void notifyCrash(Exception e) {
+                        // The MediaCodec instance is going down due to a crash
+                        // let's tell the user something when they open the app again
+
+                        // We must use commit because the app will crash when we return from this function
+                        tombstonePrefs.edit().putInt("CrashCount", tombstonePrefs.getInt("CrashCount", 0) + 1).commit();
+                        reportedCrash = true;
+                    }
+                },
+                tombstonePrefs.getInt("CrashCount", 0),
+                connMgr.isActiveNetworkMetered(),
+                willStreamHdr,
+                glPrefs.glRenderer
+                );
+
+        // Don't stream HDR if the decoder can't support it
+        if (willStreamHdr && !decoderRenderer.isHevcMain10Hdr10Supported()) {
+            willStreamHdr = false;
+            Toast.makeText(this, "Decoder does not support HEVC Main10HDR10", Toast.LENGTH_LONG).show();
+        }
 
         // Display a message to the user if H.265 was forced on but we still didn't find a decoder
         if (prefConfig.videoFormat == PreferenceConfiguration.FORCE_H265_ON && !decoderRenderer.isHevcSupported()) {
             Toast.makeText(this, "No H.265 decoder found.\nFalling back to H.264.", Toast.LENGTH_LONG).show();
         }
 
-        if (!decoderRenderer.isAvcSupported()) {
+        int gamepadMask = ControllerHandler.getAttachedControllerMask(this);
-            if (spinner != null) {
+        if (!prefConfig.multiController) {
-                spinner.dismiss();
+            // Always set gamepad 1 present for when multi-controller is
-                spinner = null;
+            // disabled for games that don't properly support detection
-            }
+            // of gamepads removed and replugged at runtime.
+            gamepadMask = 1;
+        }
+        if (prefConfig.onscreenController) {
+            // If we're using OSC, always set at least gamepad 1.
+            gamepadMask |= 1;
+        }
 
-            // If we can't find an AVC decoder, we can't proceed
+        // Set to the optimal mode for streaming
-            Dialog.displayDialog(this, getResources().getString(R.string.conn_error_title),
+        float displayRefreshRate = prepareDisplayForRendering();
-                    "This device or ROM doesn't support hardware accelerated H.264 playback.", true);
+        LimeLog.info("Display refresh rate: "+displayRefreshRate);
-            return;
+
+        // HACK: Despite many efforts to ensure low latency consistent frame
+        // delivery, the best non-lossy mechanism is to buffer 1 extra frame
+        // in the output pipeline. Android does some buffering on its end
+        // in SurfaceFlinger and it's difficult (impossible?) to inspect
+        // the precise state of the buffer queue to the screen after we
+        // release a frame for rendering.
+        //
+        // Since buffering a frame adds latency and we are primarily a
+        // latency-optimized client, rather than one designed for picture-perfect
+        // accuracy, we will synthetically induce a negative pressure on the display
+        // output pipeline by driving the decoder input pipeline under the speed
+        // that the display can refresh. This ensures a constant negative pressure
+        // to keep latency down but does induce a periodic frame loss. However, this
+        // periodic frame loss is *way* less than what we'd already get in Marshmallow's
+        // display pipeline where frames are dropped outside of our control if they land
+        // on the same V-sync.
+        //
+        // Hopefully, we can get rid of this once someone comes up with a better way
+        // to track the state of the pipeline and time frames.
+        int roundedRefreshRate = Math.round(displayRefreshRate);
+        if (!prefConfig.disableFrameDrop && prefConfig.fps >= roundedRefreshRate) {
+            if (roundedRefreshRate <= 49) {
+                // Let's avoid clearly bogus refresh rates and fall back to legacy rendering
+                decoderRenderer.enableLegacyFrameDropRendering();
+                LimeLog.info("Bogus refresh rate: "+roundedRefreshRate);
+            }
+            // HACK: Avoid crashing on some MTK devices
+            else if (roundedRefreshRate == 50 && decoderRenderer.is49FpsBlacklisted()) {
+                // Use the old rendering strategy on these broken devices
+                decoderRenderer.enableLegacyFrameDropRendering();
+            }
+            else {
+                prefConfig.fps = roundedRefreshRate - 1;
+                LimeLog.info("Adjusting FPS target for screen to "+prefConfig.fps);
+            }
         }
 
         StreamConfiguration config = new StreamConfiguration.Builder()
                 .setResolution(prefConfig.width, prefConfig.height)
                 .setRefreshRate(prefConfig.fps)
-                .setApp(new NvApp(appName, appId))
+                .setApp(new NvApp(appName, appId, willStreamHdr))
-                .setBitrate(prefConfig.bitrate * 1000)
+                .setBitrate(prefConfig.bitrate)
                 .setEnableSops(prefConfig.enableSops)
                 .enableLocalAudioPlayback(prefConfig.playHostAudio)
-                .setMaxPacketSize(remote ? 1024 : 1292)
+                .setMaxPacketSize((remote || prefConfig.width <= 1920) ? 1024 : 1292)
                 .setRemote(remote)
+                .setHevcBitratePercentageMultiplier(75)
                 .setHevcSupported(decoderRenderer.isHevcSupported())
+                .setEnableHdr(willStreamHdr)
+                .setAttachedGamepadMask(gamepadMask)
+                .setClientRefreshRateX100((int)(displayRefreshRate * 100))
                 .setAudioConfiguration(prefConfig.enable51Surround ?
                         MoonBridge.AUDIO_CONFIGURATION_51_SURROUND :
                         MoonBridge.AUDIO_CONFIGURATION_STEREO)
@@ -250,14 +380,11 @@ public class Game extends Activity implements SurfaceHolder.Callback,
 
         // Initialize the connection
         conn = new NvConnection(host, uniqueId, config, PlatformBinding.getCryptoProvider(this));
-        controllerHandler = new ControllerHandler(this, conn, this, prefConfig.multiController, prefConfig.deadzonePercentage);
+        controllerHandler = new ControllerHandler(this, conn, this, prefConfig);
 
         InputManager inputManager = (InputManager) getSystemService(Context.INPUT_SERVICE);
         inputManager.registerInputDeviceListener(controllerHandler, null);
 
-        // Set to the optimal mode for streaming
-        prepareDisplayForRendering();
-
         // Initialize touch contexts
         for (int i = 0; i < touchContextMap.length; i++) {
             touchContextMap[i] = new TouchContext(conn, i,
@@ -274,7 +401,7 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         if (prefConfig.onscreenController) {
             // create virtual onscreen controller
             virtualController = new VirtualController(conn,
-                    (FrameLayout)findViewById(R.id.surfaceView).getParent(),
+                    (FrameLayout)streamView.getParent(),
                     this);
             virtualController.refreshLayout();
         }
@@ -285,10 +412,66 @@ public class Game extends Activity implements SurfaceHolder.Callback,
                     usbDriverServiceConnection, Service.BIND_AUTO_CREATE);
         }
 
+        if (!decoderRenderer.isAvcSupported()) {
+            if (spinner != null) {
+                spinner.dismiss();
+                spinner = null;
+            }
+
+            // If we can't find an AVC decoder, we can't proceed
+            Dialog.displayDialog(this, getResources().getString(R.string.conn_error_title),
+                    "This device or ROM doesn't support hardware accelerated H.264 playback.", true);
+            return;
+        }
+
         // The connection will be started when the surface gets created
         streamView.getHolder().addCallback(this);
     }
 
+    @Override
+    public void onConfigurationChanged(Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+
+        if (virtualController != null) {
+            // Refresh layout of OSC for possible new screen size
+            virtualController.refreshLayout();
+
+            // Hide OSC in PiP
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                if (isInPictureInPictureMode()) {
+                    virtualController.hide();
+                }
+                else {
+                    virtualController.show();
+                }
+            }
+        }
+    }
+
+    @Override
+    public void onUserLeaveHint() {
+        super.onUserLeaveHint();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            if (prefConfig.enablePip && connected) {
+                try {
+                    // This has thrown all sorts of weird exceptions on Samsung devices
+                    // running Oreo. Just eat them and close gracefully on leave, rather
+                    // than crashing.
+                    enterPictureInPictureMode(
+                            new PictureInPictureParams.Builder()
+                                    .setAspectRatio(new Rational(prefConfig.width, prefConfig.height))
+                                    .setSourceRectHint(new Rect(
+                                            streamView.getLeft(), streamView.getTop(),
+                                            streamView.getRight(), streamView.getBottom()))
+                                    .build());
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+    }
+
     @Override
     public void onWindowFocusChanged(boolean hasFocus) {
         super.onWindowFocusChanged(hasFocus);
@@ -303,9 +486,10 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         }
     }
 
-    private void prepareDisplayForRendering() {
+    private float prepareDisplayForRendering() {
         Display display = getWindowManager().getDefaultDisplay();
         WindowManager.LayoutParams windowLayoutParams = getWindow().getAttributes();
+        float displayRefreshRate;
 
         // On M, we can explicitly set the optimal display mode
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
@@ -343,6 +527,7 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             LimeLog.info("Selected display mode: "+bestMode.getPhysicalWidth()+"x"+
                     bestMode.getPhysicalHeight()+"x"+bestMode.getRefreshRate());
             windowLayoutParams.preferredDisplayModeId = bestMode.getModeId();
+            displayRefreshRate = bestMode.getRefreshRate();
         }
         // On L, we can at least tell the OS that we want 60 Hz
         else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
@@ -355,6 +540,12 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             }
             LimeLog.info("Selected refresh rate: "+bestRefreshRate);
             windowLayoutParams.preferredRefreshRate = bestRefreshRate;
+            displayRefreshRate = bestRefreshRate;
+        }
+        else {
+            // Otherwise, the active display refresh rate is just
+            // whatever is currently in use.
+            displayRefreshRate = display.getRefreshRate();
         }
 
         // Apply the display mode change
@@ -390,22 +581,22 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             // Set the surface to scale based on the aspect ratio of the stream
             streamView.setDesiredAspectRatio((double)prefConfig.width / (double)prefConfig.height);
         }
-    }
 
-    private void checkDataConnection()
+        return displayRefreshRate;
-    {
-        ConnectivityManager mgr = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
-        if (mgr.isActiveNetworkMetered()) {
-            displayTransientMessage(getResources().getString(R.string.conn_metered));
-        }
     }
 
     @SuppressLint("InlinedApi")
     private final Runnable hideSystemUi = new Runnable() {
             @Override
             public void run() {
+                // In multi-window mode on N+, we need to drop our layout flags or we'll
+                // be drawing underneath the system UI.
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && isInMultiWindowMode()) {
+                    Game.this.getWindow().getDecorView().setSystemUiVisibility(
+                            View.SYSTEM_UI_FLAG_LAYOUT_STABLE);
+                }
                 // Use immersive mode on 4.4+ or standard low profile on previous builds
-                if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.KITKAT) {
+                else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
                     Game.this.getWindow().getDecorView().setSystemUiVisibility(
                             View.SYSTEM_UI_FLAG_LAYOUT_STABLE |
                             View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
@@ -430,6 +621,34 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         }
     }
 
+    @Override
+    @TargetApi(Build.VERSION_CODES.N)
+    public void onMultiWindowModeChanged(boolean isInMultiWindowMode) {
+        super.onMultiWindowModeChanged(isInMultiWindowMode);
+
+        // In multi-window, we don't want to use the full-screen layout
+        // flag. It will cause us to collide with the system UI.
+        // This function will also be called for PiP so we can cover
+        // that case here too.
+        if (isInMultiWindowMode) {
+            getWindow().clearFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
+
+            // Disable performance optimizations for foreground
+            getWindow().setSustainedPerformanceMode(false);
+            decoderRenderer.notifyVideoBackground();
+        }
+        else {
+            getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
+
+            // Enable performance optimizations for foreground
+            getWindow().setSustainedPerformanceMode(true);
+            decoderRenderer.notifyVideoForeground();
+        }
+
+        // Correct the system UI visibility flags
+        hideSystemUi(50);
+    }
+
     @Override
     protected void onDestroy() {
         super.onDestroy();
@@ -478,7 +697,10 @@ public class Game extends Activity implements SurfaceHolder.Callback,
 
             // Add the video codec to the post-stream toast
             if (message != null) {
-                if (videoFormat == MoonBridge.VIDEO_FORMAT_H265) {
+                if (videoFormat == MoonBridge.VIDEO_FORMAT_H265_MAIN10) {
+                    message += " [H.265 HDR]";
+                }
+                else if (videoFormat == MoonBridge.VIDEO_FORMAT_H265) {
                     message += " [H.265]";
                 }
                 else if (videoFormat == MoonBridge.VIDEO_FORMAT_H264) {
@@ -489,6 +711,14 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             if (message != null) {
                 Toast.makeText(this, message, Toast.LENGTH_LONG).show();
             }
+
+            // Clear the tombstone count if we terminated normally
+            if (!reportedCrash && tombstonePrefs.getInt("CrashCount", 0) != 0) {
+                tombstonePrefs.edit()
+                        .putInt("CrashCount", 0)
+                        .putInt("LastNotifiedCrashCount", 0)
+                        .apply();
+            }
         }
 
         finish();
@@ -509,19 +739,19 @@ public class Game extends Activity implements SurfaceHolder.Callback,
     };
 
     // Returns true if the key stroke was consumed
-    private boolean handleSpecialKeys(short translatedKey, boolean down) {
+    private boolean handleSpecialKeys(int androidKeyCode, boolean down) {
         int modifierMask = 0;
 
-        // Mask off the high byte
+        if (androidKeyCode == KeyEvent.KEYCODE_CTRL_LEFT ||
-        translatedKey &= 0xff;
+            androidKeyCode == KeyEvent.KEYCODE_CTRL_RIGHT) {
-
-        if (translatedKey == KeyboardTranslator.VK_CONTROL) {
             modifierMask = KeyboardPacket.MODIFIER_CTRL;
         }
-        else if (translatedKey == KeyboardTranslator.VK_SHIFT) {
+        else if (androidKeyCode == KeyEvent.KEYCODE_SHIFT_LEFT ||
+                 androidKeyCode == KeyEvent.KEYCODE_SHIFT_RIGHT) {
             modifierMask = KeyboardPacket.MODIFIER_SHIFT;
         }
-        else if (translatedKey == KeyboardTranslator.VK_ALT) {
+        else if (androidKeyCode == KeyEvent.KEYCODE_ALT_LEFT ||
+                 androidKeyCode == KeyEvent.KEYCODE_ALT_RIGHT) {
             modifierMask = KeyboardPacket.MODIFIER_ALT;
         }
 
@@ -533,7 +763,7 @@ public class Game extends Activity implements SurfaceHolder.Callback,
         }
 
         // Check if Ctrl+Shift+Z is pressed
-        if (translatedKey == KeyboardTranslator.VK_Z &&
+        if (androidKeyCode == KeyEvent.KEYCODE_Z &&
             (modifierFlags & (KeyboardPacket.MODIFIER_CTRL | KeyboardPacket.MODIFIER_SHIFT)) ==
                 (KeyboardPacket.MODIFIER_CTRL | KeyboardPacket.MODIFIER_SHIFT))
         {
@@ -589,19 +819,26 @@ public class Game extends Activity implements SurfaceHolder.Callback,
 
     @Override
     public boolean onKeyDown(int keyCode, KeyEvent event) {
+        return handleKeyDown(event) || super.onKeyDown(keyCode, event);
+    }
+
+    @Override
+    public boolean handleKeyDown(KeyEvent event) {
         // Pass-through virtual navigation keys
         if ((event.getFlags() & KeyEvent.FLAG_VIRTUAL_HARD_KEY) != 0) {
-            return super.onKeyDown(keyCode, event);
+            return false;
+        }
+
+        // Handle a synthetic back button event that some Android OS versions
+        // create as a result of a right-click.
+        if (event.getSource() == InputDevice.SOURCE_MOUSE && event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
+            conn.sendMouseButtonDown(MouseButtonPacket.BUTTON_RIGHT);
+            return true;
         }
 
         boolean handled = false;
 
-        boolean detectedGamepad = event.getDevice() == null ? false :
+        if (ControllerHandler.isGameControllerDevice(event.getDevice())) {
-                ((event.getDevice().getSources() & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK ||
-                        (event.getDevice().getSources() & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD);
-        if (detectedGamepad || (event.getDevice() == null ||
-                event.getDevice().getKeyboardType() != InputDevice.KEYBOARD_TYPE_ALPHABETIC
-        )) {
             // Always try the controller handler first, unless it's an alphanumeric keyboard device.
             // Otherwise, controller handler will eat keyboard d-pad events.
             handled = controllerHandler.handleButtonDown(event);
@@ -611,20 +848,20 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             // Try the keyboard handler
             short translated = KeyboardTranslator.translate(event.getKeyCode());
             if (translated == 0) {
-                return super.onKeyDown(keyCode, event);
+                return false;
             }
 
             // Let this method take duplicate key down events
-            if (handleSpecialKeys(translated, true)) {
+            if (handleSpecialKeys(event.getKeyCode(), true)) {
                 return true;
             }
 
             // Pass through keyboard input if we're not grabbing
             if (!grabbedInput) {
-                return super.onKeyDown(keyCode, event);
+                return false;
             }
 
-            conn.sendKeyboardInput(translated, KeyboardPacket.KEY_DOWN, getModifierState());
+            conn.sendKeyboardInput(translated, KeyboardPacket.KEY_DOWN, getModifierState(event));
         }
 
         return true;
@@ -632,18 +869,25 @@ public class Game extends Activity implements SurfaceHolder.Callback,
 
     @Override
     public boolean onKeyUp(int keyCode, KeyEvent event) {
+        return handleKeyUp(event) || super.onKeyUp(keyCode, event);
+    }
+
+    @Override
+    public boolean handleKeyUp(KeyEvent event) {
         // Pass-through virtual navigation keys
         if ((event.getFlags() & KeyEvent.FLAG_VIRTUAL_HARD_KEY) != 0) {
-            return super.onKeyUp(keyCode, event);
+            return false;
+        }
+
+        // Handle a synthetic back button event that some Android OS versions
+        // create as a result of a right-click.
+        if (event.getSource() == InputDevice.SOURCE_MOUSE && event.getKeyCode() == KeyEvent.KEYCODE_BACK) {
+            conn.sendMouseButtonUp(MouseButtonPacket.BUTTON_RIGHT);
+            return true;
         }
 
         boolean handled = false;
-        boolean detectedGamepad = event.getDevice() == null ? false :
+        if (ControllerHandler.isGameControllerDevice(event.getDevice())) {
-                ((event.getDevice().getSources() & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK ||
-                        (event.getDevice().getSources() & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD);
-        if (detectedGamepad || (event.getDevice() == null ||
-                event.getDevice().getKeyboardType() != InputDevice.KEYBOARD_TYPE_ALPHABETIC
-        )) {
             // Always try the controller handler first, unless it's an alphanumeric keyboard device.
             // Otherwise, controller handler will eat keyboard d-pad events.
             handled = controllerHandler.handleButtonUp(event);
@@ -653,16 +897,16 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             // Try the keyboard handler
             short translated = KeyboardTranslator.translate(event.getKeyCode());
             if (translated == 0) {
-                return super.onKeyUp(keyCode, event);
+                return false;
             }
 
-            if (handleSpecialKeys(translated, false)) {
+            if (handleSpecialKeys(event.getKeyCode(), false)) {
                 return true;
             }
 
             // Pass through keyboard input if we're not grabbing
             if (!grabbedInput) {
-                return super.onKeyUp(keyCode, event);
+                return false;
             }
 
             conn.sendKeyboardInput(translated, KeyboardPacket.KEY_UP, getModifierState(event));
@@ -759,6 +1003,12 @@ public class Game extends Activity implements SurfaceHolder.Callback,
                     lastMouseX = (int)event.getX();
                     lastMouseY = (int)event.getY();
                 }
+                else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    // We get a normal (non-relative) MotionEvent when starting pointer capture to synchronize the
+                    // location of the cursor with our app. We don't want this, so we must discard this event.
+                    lastMouseX = (int)event.getX();
+                    lastMouseY = (int)event.getY();
+                }
                 else {
                     // First process the history
                     for (int i = 0; i < event.getHistorySize(); i++) {
@@ -926,7 +1176,17 @@ public class Game extends Activity implements SurfaceHolder.Callback,
     private void stopConnection() {
         if (connecting || connected) {
             connecting = connected = false;
-            conn.stop();
+
+            // Stop may take a few hundred ms to do some network I/O to tell
+            // the server we're going away and clean up. Let it run in a separate
+            // thread to keep things smooth for the UI. Inside moonlight-common,
+            // we prevent another thread from starting a connection before and
+            // during the process of stopping this one.
+            new Thread() {
+                public void run() {
+                    conn.stop();
+                }
+            }.start();
         }
     }
 
@@ -944,6 +1204,16 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             displayedFailureDialog = true;
             LimeLog.severe(stage+" failed: "+errorCode);
 
+            // If video initialization failed and the surface is still valid, display extra information for the user
+            if (stage.contains("video") && streamView.getHolder().getSurface().isValid()) {
+                runOnUiThread(new Runnable() {
+                    @Override
+                    public void run() {
+                        Toast.makeText(Game.this, "Video decoder failed to initialize. Your device may not support the selected resolution.", Toast.LENGTH_LONG).show();
+                    }
+                });
+            }
+
             Dialog.displayDialog(this, getResources().getString(R.string.conn_error_title),
                     getResources().getString(R.string.conn_error_msg)+" "+stage, true);
         }
@@ -971,8 +1241,8 @@ public class Game extends Activity implements SurfaceHolder.Callback,
             spinner = null;
         }
 
-        connecting = false;
         connected = true;
+        connecting = false;
 
         runOnUiThread(new Runnable() {
             @Override
@@ -1011,12 +1281,12 @@ public class Game extends Activity implements SurfaceHolder.Callback,
 
     @Override
     public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
-    }
+        if (!surfaceCreated) {
+            throw new IllegalStateException("Surface changed before creation!");
+        }
 
-    @Override
+        if (!attemptedConnection) {
-    public void surfaceCreated(SurfaceHolder holder) {
+            attemptedConnection = true;
-        if (!connected && !connecting) {
-            connecting = true;
 
             decoderRenderer.setRenderTarget(holder);
             conn.start(PlatformBinding.getAudioRenderer(), decoderRenderer, Game.this);
@@ -1024,12 +1294,23 @@ public class Game extends Activity implements SurfaceHolder.Callback,
     }
 
     @Override
-    public void surfaceDestroyed(SurfaceHolder holder) {
+    public void surfaceCreated(SurfaceHolder holder) {
-        // Let the decoder know immediately that the surface is gone
+        surfaceCreated = true;
-        decoderRenderer.prepareForStop();
+    }
 
-        if (connected) {
+    @Override
-            stopConnection();
+    public void surfaceDestroyed(SurfaceHolder holder) {
+        if (!surfaceCreated) {
+            throw new IllegalStateException("Surface destroyed before creation!");
+        }
+
+        if (attemptedConnection) {
+            // Let the decoder know immediately that the surface is gone
+            decoderRenderer.prepareForStop();
+
+            if (connected) {
+                stopConnection();
+            }
         }
     }
 
@@ -1075,7 +1356,8 @@ public class Game extends Activity implements SurfaceHolder.Callback,
     public void keyboardEvent(boolean buttonDown, short keyCode) {
         short keyMap = KeyboardTranslator.translate(keyCode);
         if (keyMap != 0) {
-            if (handleSpecialKeys(keyMap, buttonDown)) {
+            // handleSpecialKeys() takes the Android keycode
+            if (handleSpecialKeys(keyCode, buttonDown)) {
                 return;
             }
 

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

@@ -51,14 +51,8 @@ public class HelpActivity extends Activity {
 
             @Override
             public boolean shouldOverrideUrlLoading(WebView view, String url) {
-                if (url.toUpperCase().startsWith("https://github.com/moonlight-stream/moonlight-docs/wiki/".toUpperCase()) ||
+                return !(url.toUpperCase().startsWith("https://github.com/moonlight-stream/moonlight-docs/wiki/".toUpperCase()) ||
-                        url.toUpperCase().startsWith("http://github.com/moonlight-stream/moonlight-docs/wiki/".toUpperCase())) {
+                        url.toUpperCase().startsWith("http://github.com/moonlight-stream/moonlight-docs/wiki/".toUpperCase()));
-                    // Allow navigation to Moonlight docs
-                    return false;
-                }
-                else {
-                    return true;
-                }
             }
         });
 

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

@@ -2,9 +2,7 @@ package com.limelight;
 
 import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.net.InetAddress;
 import java.net.UnknownHostException;
-import java.util.Locale;
 
 import com.limelight.binding.PlatformBinding;
 import com.limelight.binding.crypto.AndroidCryptoProvider;
@@ -18,6 +16,7 @@ import com.limelight.nvstream.http.PairingManager;
 import com.limelight.nvstream.http.PairingManager.PairState;
 import com.limelight.nvstream.wol.WakeOnLanSender;
 import com.limelight.preferences.AddComputerManually;
+import com.limelight.preferences.GlPreferences;
 import com.limelight.preferences.PreferenceConfiguration;
 import com.limelight.preferences.StreamSettings;
 import com.limelight.ui.AdapterFragment;
@@ -34,6 +33,8 @@ import android.content.ComponentName;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.content.res.Configuration;
+import android.opengl.GLSurfaceView;
+import android.os.Build;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.preference.PreferenceManager;
@@ -51,12 +52,15 @@ import android.widget.RelativeLayout;
 import android.widget.Toast;
 import android.widget.AdapterView.AdapterContextMenuInfo;
 
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
 public class PcView extends Activity implements AdapterFragmentCallbacks {
     private RelativeLayout noPcFoundLayout;
     private PcGridAdapter pcGridAdapter;
     private ShortcutHelper shortcutHelper;
     private ComputerManagerService.ComputerManagerBinder managerBinder;
-    private boolean freezeUpdates, runningPolling, inForeground;
+    private boolean freezeUpdates, runningPolling, inForeground, completeOnCreateCalled;
     private final ServiceConnection serviceConnection = new ServiceConnection() {
         public void onServiceConnected(ComponentName className, IBinder binder) {
             final ComputerManagerService.ComputerManagerBinder localBinder =
@@ -86,11 +90,19 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
         }
     };
 
+    @Override
     public void onConfigurationChanged(Configuration newConfig) {
         super.onConfigurationChanged(newConfig);
 
-        // Reinitialize views just in case orientation changed
+        // Only reinitialize views if completeOnCreate() was called
-        initializeViews();
+        // before this callback. If it was not, completeOnCreate() will
+        // handle initializing views with the config change accounted for.
+        // This is not prone to races because both callbacks are invoked
+        // in the main thread.
+        if (completeOnCreateCalled) {
+            // Reinitialize views just in case orientation changed
+            initializeViews();
+        }
     }
 
     private final static int APP_LIST_ID = 1;
@@ -110,9 +122,9 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
         PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
 
         // Setup the list view
-        ImageButton settingsButton = (ImageButton) findViewById(R.id.settingsButton);
+        ImageButton settingsButton = findViewById(R.id.settingsButton);
-        ImageButton addComputerButton = (ImageButton) findViewById(R.id.manuallyAddPc);
+        ImageButton addComputerButton = findViewById(R.id.manuallyAddPc);
-        ImageButton helpButton = (ImageButton) findViewById(R.id.helpButton);
+        ImageButton helpButton = findViewById(R.id.helpButton);
 
         settingsButton.setOnClickListener(new OnClickListener() {
             @Override
@@ -138,7 +150,7 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
             .replace(R.id.pcFragmentContainer, new AdapterFragment())
             .commitAllowingStateLoss();
 
-        noPcFoundLayout = (RelativeLayout) findViewById(R.id.no_pc_found_layout);
+        noPcFoundLayout = findViewById(R.id.no_pc_found_layout);
         if (pcGridAdapter.getCount() == 0) {
             noPcFoundLayout.setVisibility(View.VISIBLE);
         }
@@ -152,6 +164,52 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
+        // Assume we're in the foreground when created to avoid a race
+        // between binding to CMS and onResume()
+        inForeground = true;
+
+        // Create a GLSurfaceView to fetch GLRenderer unless we have
+        // a cached result already.
+        final GlPreferences glPrefs = GlPreferences.readPreferences(this);
+        if (!glPrefs.savedFingerprint.equals(Build.FINGERPRINT) || glPrefs.glRenderer.isEmpty()) {
+            GLSurfaceView surfaceView = new GLSurfaceView(this);
+            surfaceView.setRenderer(new GLSurfaceView.Renderer() {
+                @Override
+                public void onSurfaceCreated(GL10 gl10, EGLConfig eglConfig) {
+                    // Save the GLRenderer string so we don't need to do this next time
+                    glPrefs.glRenderer = gl10.glGetString(GL10.GL_RENDERER);
+                    glPrefs.savedFingerprint = Build.FINGERPRINT;
+                    glPrefs.writePreferences();
+
+                    LimeLog.info("Fetched GL Renderer: " + glPrefs.glRenderer);
+
+                    runOnUiThread(new Runnable() {
+                        @Override
+                        public void run() {
+                            completeOnCreate();
+                        }
+                    });
+                }
+
+                @Override
+                public void onSurfaceChanged(GL10 gl10, int i, int i1) {
+                }
+
+                @Override
+                public void onDrawFrame(GL10 gl10) {
+                }
+            });
+            setContentView(surfaceView);
+        }
+        else {
+            LimeLog.info("Cached GL Renderer: " + glPrefs.glRenderer);
+            completeOnCreate();
+        }
+    }
+
+    private void completeOnCreate() {
+        completeOnCreateCalled = true;
+
         shortcutHelper = new ShortcutHelper(this);
 
         UiHelper.setLocale(this);
@@ -220,6 +278,9 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
     protected void onResume() {
         super.onResume();
 
+        // Display a decoder crash notification if we've returned after a crash
+        UiHelper.showDecoderCrashDialog(this);
+
         inForeground = true;
         startComputerUpdates();
     }
@@ -306,19 +367,7 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
                     // Stop updates and wait while pairing
                     stopComputerUpdates(true);
 
-                    InetAddress addr;
+                    httpConn = new NvHTTP(ServerHelper.getCurrentAddressFromComputer(computer),
-                    if (computer.reachability == ComputerDetails.Reachability.LOCAL) {
-                        addr = computer.localIp;
-                    }
-                    else if (computer.reachability == ComputerDetails.Reachability.REMOTE) {
-                        addr = computer.remoteIp;
-                    }
-                    else {
-                        LimeLog.warning("Unknown reachability - using local IP");
-                        addr = computer.localIp;
-                    }
-
-                    httpConn = new NvHTTP(addr,
                             managerBinder.getUniqueId(),
                             PlatformBinding.getDeviceName(),
                             PlatformBinding.getCryptoProvider(PcView.this));
@@ -443,19 +492,7 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
                 NvHTTP httpConn;
                 String message;
                 try {
-                    InetAddress addr;
+                    httpConn = new NvHTTP(ServerHelper.getCurrentAddressFromComputer(computer),
-                    if (computer.reachability == ComputerDetails.Reachability.LOCAL) {
-                        addr = computer.localIp;
-                    }
-                    else if (computer.reachability == ComputerDetails.Reachability.REMOTE) {
-                        addr = computer.remoteIp;
-                    }
-                    else {
-                        LimeLog.warning("Unknown reachability - using local IP");
-                        addr = computer.localIp;
-                    }
-
-                    httpConn = new NvHTTP(addr,
                             managerBinder.getUniqueId(),
                             PlatformBinding.getDeviceName(),
                             PlatformBinding.getCryptoProvider(PcView.this));
@@ -542,7 +579,7 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
                     return true;
                 }
 
-                ServerHelper.doStart(this, new NvApp("app", computer.details.runningGameId), computer.details, managerBinder);
+                ServerHelper.doStart(this, new NvApp("app", computer.details.runningGameId, false), computer.details, managerBinder);
                 return true;
 
             case QUIT_ID:
@@ -557,7 +594,7 @@ public class PcView extends Activity implements AdapterFragmentCallbacks {
                     public void run() {
                         ServerHelper.doQuit(PcView.this,
                                 ServerHelper.getCurrentAddressFromComputer(computer.details),
-                                new NvApp("app", 0), managerBinder, null);
+                                new NvApp("app", 0, false), managerBinder, null);
                     }
                 }, null);
                 return true;

app/src/main/java/com/limelight/binding/audio/AndroidAudioRenderer.java

@@ -1,8 +1,10 @@
 package com.limelight.binding.audio;
 
+import android.media.AudioAttributes;
 import android.media.AudioFormat;
 import android.media.AudioManager;
 import android.media.AudioTrack;
+import android.os.Build;
 
 import com.limelight.LimeLog;
 import com.limelight.nvstream.av.audio.AudioRenderer;
@@ -12,10 +14,58 @@ public class AndroidAudioRenderer implements AudioRenderer {
 
     private AudioTrack track;
 
+    private AudioTrack createAudioTrack(int channelConfig, int bufferSize, boolean lowLatency) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
+            return new AudioTrack(AudioManager.STREAM_MUSIC,
+                    48000,
+                    channelConfig,
+                    AudioFormat.ENCODING_PCM_16BIT,
+                    bufferSize,
+                    AudioTrack.MODE_STREAM);
+        }
+        else {
+            AudioAttributes.Builder attributesBuilder = new AudioAttributes.Builder()
+                    .setUsage(AudioAttributes.USAGE_GAME);
+            AudioFormat format = new AudioFormat.Builder()
+                    .setEncoding(AudioFormat.ENCODING_PCM_16BIT)
+                    .setSampleRate(48000)
+                    .setChannelMask(channelConfig)
+                    .build();
+
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+                // Use FLAG_LOW_LATENCY on L through N
+                if (lowLatency) {
+                    attributesBuilder.setFlags(AudioAttributes.FLAG_LOW_LATENCY);
+                }
+            }
+
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                AudioTrack.Builder trackBuilder = new AudioTrack.Builder()
+                        .setAudioFormat(format)
+                        .setAudioAttributes(attributesBuilder.build())
+                        .setTransferMode(AudioTrack.MODE_STREAM)
+                        .setBufferSizeInBytes(bufferSize);
+
+                // Use PERFORMANCE_MODE_LOW_LATENCY on O and later
+                if (lowLatency) {
+                    trackBuilder.setPerformanceMode(AudioTrack.PERFORMANCE_MODE_LOW_LATENCY);
+                }
+
+                return trackBuilder.build();
+            }
+            else {
+                return new AudioTrack(attributesBuilder.build(),
+                        format,
+                        bufferSize,
+                        AudioTrack.MODE_STREAM,
+                        AudioManager.AUDIO_SESSION_ID_GENERATE);
+            }
+        }
+    }
+
     @Override
     public int setup(int audioConfiguration) {
         int channelConfig;
-        int bufferSize;
         int bytesPerFrame;
 
         switch (audioConfiguration)
@@ -38,44 +88,82 @@ public class AndroidAudioRenderer implements AudioRenderer {
         // do this on many devices and it lowers audio latency.
         // We'll try the small buffer size first and if it fails,
         // use the recommended larger buffer size.
-        try {
-            // Buffer two frames of audio if possible
-            bufferSize = bytesPerFrame * 2;
 
-            track = new AudioTrack(AudioManager.STREAM_MUSIC,
+        for (int i = 0; i < 4; i++) {
-                    48000,
+            boolean lowLatency;
-                    channelConfig,
+            int bufferSize;
-                    AudioFormat.ENCODING_PCM_16BIT,
-                    bufferSize,
-                    AudioTrack.MODE_STREAM);
-            track.play();
-        } catch (Exception e) {
-            // Try to release the AudioTrack if we got far enough
-            try {
-                if (track != null) {
-                    track.release();
-                }
-            } catch (Exception ignored) {}
 
-            // Now try the larger buffer size
+            // We will try:
-            bufferSize = Math.max(AudioTrack.getMinBufferSize(48000,
+            // 1) Small buffer, low latency mode
+            // 2) Large buffer, low latency mode
+            // 3) Small buffer, standard mode
+            // 4) Large buffer, standard mode
+
+            switch (i) {
+                case 0:
+                case 1:
+                    lowLatency = true;
+                    break;
+                case 2:
+                case 3:
+                    lowLatency = false;
+                    break;
+                default:
+                    // Unreachable
+                    throw new IllegalStateException();
+            }
+
+            switch (i) {
+                case 0:
+                case 2:
+                    bufferSize = bytesPerFrame * 2;
+                    break;
+
+                case 1:
+                case 3:
+                    // Try the larger buffer size
+                    bufferSize = Math.max(AudioTrack.getMinBufferSize(48000,
                             channelConfig,
                             AudioFormat.ENCODING_PCM_16BIT),
-                    bytesPerFrame * 2);
+                            bytesPerFrame * 2);
 
-            // Round to next frame
+                    // Round to next frame
-            bufferSize = (((bufferSize + (bytesPerFrame - 1)) / bytesPerFrame) * bytesPerFrame);
+                    bufferSize = (((bufferSize + (bytesPerFrame - 1)) / bytesPerFrame) * bytesPerFrame);
+                    break;
+                default:
+                    // Unreachable
+                    throw new IllegalStateException();
+            }
 
-            track = new AudioTrack(AudioManager.STREAM_MUSIC,
+            // Skip low latency options if hardware sample rate isn't 48000Hz
-                    48000,
+            if (AudioTrack.getNativeOutputSampleRate(AudioManager.STREAM_MUSIC) != 48000 && lowLatency) {
-                    channelConfig,
+                continue;
-                    AudioFormat.ENCODING_PCM_16BIT,
+            }
-                    bufferSize,
+
-                    AudioTrack.MODE_STREAM);
+            try {
-            track.play();
+                track = createAudioTrack(channelConfig, bufferSize, lowLatency);
+                track.play();
+
+                // Successfully created working AudioTrack. We're done here.
+                LimeLog.info("Audio track configuration: "+bufferSize+" "+lowLatency);
+                break;
+            } catch (Exception e) {
+                // Try to release the AudioTrack if we got far enough
+                e.printStackTrace();
+                try {
+                    if (track != null) {
+                        track.release();
+                        track = null;
+                    }
+                } catch (Exception ignored) {}
+            }
+        }
+
+        if (track == null) {
+            // Couldn't create any audio track for playback
+            return -2;
         }
 
-        LimeLog.info("Audio track buffer size: "+bufferSize);
         return 0;
     }
 
@@ -88,14 +176,14 @@ public class AndroidAudioRenderer implements AudioRenderer {
     public void start() {}
 
     @Override
-    public void stop() {
+    public void stop() {}
-        // Immediately drop all pending data
-        track.pause();
-        track.flush();
-    }
 
     @Override
     public void cleanup() {
+        // Immediately drop all pending data
+        track.pause();
+        track.flush();
+
         track.release();
     }
 }

app/src/main/java/com/limelight/binding/crypto/AndroidCryptoProvider.java

@@ -13,8 +13,8 @@ import java.security.KeyPair;
 import java.security.KeyPairGenerator;
 import java.security.NoSuchAlgorithmException;
 import java.security.NoSuchProviderException;
+import java.security.Provider;
 import java.security.SecureRandom;
-import java.security.Security;
 import java.security.cert.CertificateException;
 import java.security.cert.CertificateFactory;
 import java.security.cert.X509Certificate;
@@ -54,10 +54,7 @@ public class AndroidCryptoProvider implements LimelightCryptoProvider {
 
     private static final Object globalCryptoLock = new Object();
 
-    static {
+    private static final Provider bcProvider = new BouncyCastleProvider();
-        // Install the Bouncy Castle provider
-        Security.addProvider(new BouncyCastleProvider());
-    }
 
     public AndroidCryptoProvider(Context c) {
         String dataPath = c.getFilesDir().getAbsolutePath();
@@ -96,10 +93,10 @@ public class AndroidCryptoProvider implements LimelightCryptoProvider {
         }
 
         try {
-            CertificateFactory certFactory = CertificateFactory.getInstance("X.509", "BC");
+            CertificateFactory certFactory = CertificateFactory.getInstance("X.509", bcProvider);
             cert = (X509Certificate) certFactory.generateCertificate(new ByteArrayInputStream(certBytes));
             pemCertBytes = certBytes;
-            KeyFactory keyFactory = KeyFactory.getInstance("RSA", "BC");
+            KeyFactory keyFactory = KeyFactory.getInstance("RSA", bcProvider);
             key = (RSAPrivateKey) keyFactory.generatePrivate(new PKCS8EncodedKeySpec(keyBytes));
         } catch (CertificateException e) {
             // May happen if the cert is corrupt
@@ -113,10 +110,6 @@ public class AndroidCryptoProvider implements LimelightCryptoProvider {
             // May happen if the key is corrupt
             LimeLog.warning("Corrupted key");
             return false;
-        } catch (NoSuchProviderException e) {
-            // Should never happen
-            e.printStackTrace();
-            return false;
         }
 
         return true;
@@ -129,17 +122,13 @@ public class AndroidCryptoProvider implements LimelightCryptoProvider {
 
         KeyPair keyPair;
         try {
-            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA", "BC");
+            KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance("RSA", bcProvider);
             keyPairGenerator.initialize(2048);
             keyPair = keyPairGenerator.generateKeyPair();
         } catch (NoSuchAlgorithmException e1) {
             // Should never happen
             e1.printStackTrace();
             return false;
-        } catch (NoSuchProviderException e) {
-            // Should never happen
-            e.printStackTrace();
-            return false;
         }
 
         Date now = new Date();
@@ -160,8 +149,8 @@ public class AndroidCryptoProvider implements LimelightCryptoProvider {
             SubjectPublicKeyInfo.getInstance(keyPair.getPublic().getEncoded()));
 
         try {
-            ContentSigner sigGen = new JcaContentSignerBuilder("SHA1withRSA").setProvider(BouncyCastleProvider.PROVIDER_NAME).build(keyPair.getPrivate());
+            ContentSigner sigGen = new JcaContentSignerBuilder("SHA1withRSA").setProvider(bcProvider).build(keyPair.getPrivate());
-            cert = new JcaX509CertificateConverter().setProvider(BouncyCastleProvider.PROVIDER_NAME).getCertificate(certBuilder.build(sigGen));
+            cert = new JcaX509CertificateConverter().setProvider(bcProvider).getCertificate(certBuilder.build(sigGen));
             key = (RSAPrivateKey) keyPair.getPrivate();
         } catch (Exception e) {
             // Nothing should go wrong here

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

@@ -2,6 +2,8 @@ package com.limelight.binding.input;
 
 import android.content.Context;
 import android.hardware.input.InputManager;
+import android.hardware.usb.UsbDevice;
+import android.hardware.usb.UsbManager;
 import android.os.SystemClock;
 import android.util.SparseArray;
 import android.view.InputDevice;
@@ -12,9 +14,11 @@ import android.widget.Toast;
 
 import com.limelight.LimeLog;
 import com.limelight.binding.input.driver.UsbDriverListener;
+import com.limelight.binding.input.driver.UsbDriverService;
 import com.limelight.nvstream.NvConnection;
 import com.limelight.nvstream.input.ControllerPacket;
 import com.limelight.nvstream.input.MouseButtonPacket;
+import com.limelight.preferences.PreferenceConfiguration;
 import com.limelight.ui.GameGestures;
 import com.limelight.utils.Vector2d;
 
@@ -47,18 +51,18 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
     private final GameGestures gestures;
     private boolean hasGameController;
 
-    private final boolean multiControllerEnabled;
+    private final PreferenceConfiguration prefConfig;
-    private short currentControllers;
+    private short currentControllers, initialControllers;
 
-    public ControllerHandler(Context activityContext, NvConnection conn, GameGestures gestures, boolean multiControllerEnabled, int deadzonePercentage) {
+    public ControllerHandler(Context activityContext, NvConnection conn, GameGestures gestures, PreferenceConfiguration prefConfig) {
         this.activityContext = activityContext;
         this.conn = conn;
         this.gestures = gestures;
-        this.multiControllerEnabled = multiControllerEnabled;
+        this.prefConfig = prefConfig;
 
         // HACK: For now we're hardcoding a 10% deadzone. Some deadzone
         // is required for controller batching support to work.
-        deadzonePercentage = 10;
+        int deadzonePercentage = 10;
 
         int[] ids = InputDevice.getDeviceIds();
         for (int id : ids) {
@@ -96,6 +100,18 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         defaultContext.rightTriggerAxis = MotionEvent.AXIS_GAS;
         defaultContext.controllerNumber = (short) 0;
         defaultContext.assignedControllerNumber = true;
+
+        // Some devices (GPD XD) have a back button which sends input events
+        // with device ID == 0. This hits the default context which would normally
+        // consume these. Instead, let's ignore them since that's probably the
+        // most likely case.
+        defaultContext.ignoreBack = true;
+
+        // Get the initially attached set of gamepads. As each gamepad receives
+        // its initial InputEvent, we will move these from this set onto the
+        // currentControllers set which will allow them to properly unplug
+        // if they are removed.
+        initialControllers = getAttachedControllerMask(activityContext);
     }
 
     private static InputDevice.MotionRange getMotionRangeForJoystickAxis(InputDevice dev, int axis) {
@@ -133,8 +149,75 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         onInputDeviceAdded(deviceId);
     }
 
+    private static boolean hasJoystickAxes(InputDevice device) {
+        return (device.getSources() & InputDevice.SOURCE_JOYSTICK) == InputDevice.SOURCE_JOYSTICK &&
+                getMotionRangeForJoystickAxis(device, MotionEvent.AXIS_X) != null &&
+                getMotionRangeForJoystickAxis(device, MotionEvent.AXIS_Y) != null;
+    }
+
+    private static boolean hasGamepadButtons(InputDevice device) {
+        return (device.getSources() & InputDevice.SOURCE_GAMEPAD) == InputDevice.SOURCE_GAMEPAD;
+    }
+
+    public static boolean isGameControllerDevice(InputDevice device) {
+        if (device == null) {
+            return true;
+        }
+
+        if (hasJoystickAxes(device) || hasGamepadButtons(device)) {
+            // Has real joystick axes or gamepad buttons
+            return true;
+        }
+
+        // Otherwise, we'll try anything that claims to be a non-alphabetic keyboard
+        return device.getKeyboardType() != InputDevice.KEYBOARD_TYPE_ALPHABETIC;
+    }
+
+    public static short getAttachedControllerMask(Context context) {
+        int count = 0;
+        short mask = 0;
+
+        // Count all input devices that are gamepads
+        InputManager im = (InputManager) context.getSystemService(Context.INPUT_SERVICE);
+        for (int id : im.getInputDeviceIds()) {
+            InputDevice dev = im.getInputDevice(id);
+            if (dev == null) {
+                continue;
+            }
+
+            if (hasJoystickAxes(dev)) {
+                LimeLog.info("Counting InputDevice: "+dev.getName());
+                mask |= 1 << count++;
+            }
+        }
+
+        // Count all USB devices that match our drivers
+        if (PreferenceConfiguration.readPreferences(context).usbDriver) {
+            UsbManager usbManager = (UsbManager) context.getSystemService(Context.USB_SERVICE);
+            for (UsbDevice dev : usbManager.getDeviceList().values()) {
+                // We explicitly ask not to claim devices that appear as InputDevices
+                // otherwise we will double count them.
+                if (UsbDriverService.shouldClaimDevice(dev, false)) {
+                    LimeLog.info("Counting UsbDevice: "+dev.getDeviceName());
+                    mask |= 1 << count++;
+                }
+            }
+        }
+
+        LimeLog.info("Enumerated "+count+" gamepads");
+        return mask;
+    }
+
     private void releaseControllerNumber(GenericControllerContext context) {
-        // If this device sent data as a gamepad, zero the values before removing
+        // If we reserved a controller number, remove that reservation
+        if (context.reservedControllerNumber) {
+            LimeLog.info("Controller number "+context.controllerNumber+" is now available");
+            currentControllers &= ~(1 << context.controllerNumber);
+        }
+
+        // If this device sent data as a gamepad, zero the values before removing.
+        // We must do this after clearing the currentControllers entry so this
+        // causes the device to be removed on the server PC.
         if (context.assignedControllerNumber) {
             conn.sendControllerInput(context.controllerNumber, getActiveControllerMask(),
                     (short) 0,
@@ -142,12 +225,6 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
                     (short) 0, (short) 0,
                     (short) 0, (short) 0);
         }
-
-        // If we reserved a controller number, remove that reservation
-        if (context.reservedControllerNumber) {
-            LimeLog.info("Controller number "+context.controllerNumber+" is now available");
-            currentControllers &= ~(1 << context.controllerNumber);
-        }
     }
 
     // Called before sending input but after we've determined that this
@@ -167,7 +244,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
                 LimeLog.info("Built-in buttons hardcoded as controller 0");
                 context.controllerNumber = 0;
             }
-            else if (multiControllerEnabled && devContext.hasJoystickAxes) {
+            else if (prefConfig.multiController && devContext.hasJoystickAxes) {
                 context.controllerNumber = 0;
 
                 LimeLog.info("Reserving the next available controller number");
@@ -175,6 +252,10 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
                     if ((currentControllers & (1 << i)) == 0) {
                         // Found an unused controller value
                         currentControllers |= (1 << i);
+
+                        // Take this value out of the initial gamepad set
+                        initialControllers &= ~(1 << i);
+
                         context.controllerNumber = i;
                         context.reservedControllerNumber = true;
                         break;
@@ -187,7 +268,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
             }
         }
         else {
-            if (multiControllerEnabled) {
+            if (prefConfig.multiController) {
                 context.controllerNumber = 0;
 
                 LimeLog.info("Reserving the next available controller number");
@@ -195,6 +276,10 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
                     if ((currentControllers & (1 << i)) == 0) {
                         // Found an unused controller value
                         currentControllers |= (1 << i);
+
+                        // Take this value out of the initial gamepad set
+                        initialControllers &= ~(1 << i);
+
                         context.controllerNumber = i;
                         context.reservedControllerNumber = true;
                         break;
@@ -375,7 +460,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
                 context.triggerDeadzone = 0.30f;
             }
             // Classify this device as a remote by name
-            else if (devName.contains("Fire TV Remote") || devName.contains("Nexus Remote")) {
+            else if (devName.toLowerCase().contains("remote")) {
                 // It's only a remote if it doesn't any sticks
                 if (!context.hasJoystickAxes) {
                     context.ignoreBack = true;
@@ -387,8 +472,10 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
                 context.rightStickDeadzoneRadius = 0.07f;
             }
             // Samsung's face buttons appear as a non-virtual button so we'll explicitly ignore
-            // back presses on this device
+            // back presses on this device. The Goodix buttons on the Nokia 6 also appear
-            else if (devName.equals("sec_touchscreen") || devName.equals("sec_touchkey")) {
+            // non-virtual so we'll ignore those too.
+            else if (devName.equals("sec_touchscreen") || devName.equals("sec_touchkey") ||
+                    devName.equals("goodix_fp")) {
                 context.ignoreBack = true;
             }
             // The Serval has a couple of unknown buttons that are start and select. It also has
@@ -464,8 +551,8 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
     }
 
     private short getActiveControllerMask() {
-        if (multiControllerEnabled) {
+        if (prefConfig.multiController) {
-            return currentControllers;
+            return (short)(currentControllers | initialControllers);
         }
         else {
             // Only Player 1 is active with multi-controller disabled
@@ -551,6 +638,16 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
                     conn.sendMouseButtonUp(MouseButtonPacket.BUTTON_RIGHT);
                 }
             }
+            if ((changedMask & ControllerPacket.UP_FLAG) != 0) {
+                if ((inputMap & ControllerPacket.UP_FLAG) != 0) {
+                    conn.sendMouseScroll((byte) 1);
+                }
+            }
+            if ((changedMask & ControllerPacket.DOWN_FLAG) != 0) {
+                if ((inputMap & ControllerPacket.DOWN_FLAG) != 0) {
+                    conn.sendMouseScroll((byte) -1);
+                }
+            }
 
             conn.sendControllerInput(controllerNumber, getActiveControllerMask(),
                     (short)0, (byte)0, (byte)0, (short)0, (short)0, (short)0, (short)0);
@@ -762,16 +859,16 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
             // to normal behavior, so ignore triggersIdleNegative for each trigger until
             // first touch.
             if (lt != 0) {
-                context.leftTriggerUsed = true;
+                context.leftTriggerAxisUsed = true;
             }
             if (rt != 0) {
-                context.rightTriggerUsed = true;
+                context.rightTriggerAxisUsed = true;
             }
             if (context.triggersIdleNegative) {
-                if (context.leftTriggerUsed) {
+                if (context.leftTriggerAxisUsed) {
                     lt = (lt + 1) / 2;
                 }
-                if (context.rightTriggerUsed) {
+                if (context.rightTriggerAxisUsed) {
                     rt = (rt + 1) / 2;
                 }
             }
@@ -917,7 +1014,8 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
             // Make sure it's real by checking that the key is actually down before taking
             // any action.
             if ((context.inputMap & ControllerPacket.PLAY_FLAG) != 0 &&
-                SystemClock.uptimeMillis() - context.startDownTime > ControllerHandler.START_DOWN_TIME_MOUSE_MODE_MS) {
+                    SystemClock.uptimeMillis() - context.startDownTime > ControllerHandler.START_DOWN_TIME_MOUSE_MODE_MS &&
+                    prefConfig.mouseEmulation) {
                 toggleMouseEmulation(context);
             }
             context.inputMap &= ~ControllerPacket.PLAY_FLAG;
@@ -966,9 +1064,17 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
             context.inputMap &= ~ControllerPacket.RS_CLK_FLAG;
             break;
         case KeyEvent.KEYCODE_BUTTON_L2:
+            if (context.leftTriggerAxisUsed) {
+                // Suppress this digital event if an analog trigger is active
+                return true;
+            }
             context.leftTrigger = 0;
             break;
         case KeyEvent.KEYCODE_BUTTON_R2:
+            if (context.rightTriggerAxisUsed) {
+                // Suppress this digital event if an analog trigger is active
+                return true;
+            }
             context.rightTrigger = 0;
             break;
         default:
@@ -1078,9 +1184,17 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
             context.inputMap |= ControllerPacket.RS_CLK_FLAG;
             break;
         case KeyEvent.KEYCODE_BUTTON_L2:
+            if (context.leftTriggerAxisUsed) {
+                // Suppress this digital event if an analog trigger is active
+                return true;
+            }
             context.leftTrigger = (byte)0xFF;
             break;
         case KeyEvent.KEYCODE_BUTTON_R2:
+            if (context.rightTriggerAxisUsed) {
+                // Suppress this digital event if an analog trigger is active
+                return true;
+            }
             context.rightTrigger = (byte)0xFF;
             break;
         default:
@@ -1209,7 +1323,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
         public int leftTriggerAxis = -1;
         public int rightTriggerAxis = -1;
         public boolean triggersIdleNegative;
-        public boolean leftTriggerUsed, rightTriggerUsed;
+        public boolean leftTriggerAxisUsed, rightTriggerAxisUsed;
 
         public int hatXAxis = -1;
         public int hatYAxis = -1;

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

@@ -2,8 +2,6 @@ package com.limelight.binding.input;
 
 import android.view.KeyEvent;
 
-import com.limelight.nvstream.NvConnection;
-
 /**
  * Class to translate a Android key code into the codes GFE is expecting
  * @author Diego Waxemberg
@@ -20,22 +18,15 @@ public class KeyboardTranslator {
 	public static final int VK_9 = 57;
 	public static final int VK_A = 65;
 	public static final int VK_Z = 90;
-	public static final int VK_ALT = 18;
 	public static final int VK_NUMPAD0 = 96;
     public static final int VK_BACK_SLASH = 92;
     public static final int VK_CAPS_LOCK = 20;
 	public static final int VK_CLEAR = 12;
 	public static final int VK_COMMA = 44;
-	public static final int VK_CONTROL = 17;
 	public static final int VK_BACK_SPACE = 8;
 	public static final int VK_EQUALS = 61;
 	public static final int VK_ESCAPE = 27;
 	public static final int VK_F1 = 112;
-	public static final int VK_PERIOD = 46;
-	public static final int VK_INSERT = 155;
-	public static final int VK_OPEN_BRACKET = 91;
-	public static final int VK_WINDOWS = 524;
-	public static final int VK_MINUS = 45;
 	public static final int VK_END = 35;
 	public static final int VK_HOME = 36;
 	public static final int VK_NUM_LOCK = 144;
@@ -45,7 +36,6 @@ public class KeyboardTranslator {
 	public static final int VK_CLOSE_BRACKET = 93;
 	public static final int VK_SCROLL_LOCK = 145;
 	public static final int VK_SEMICOLON = 59;
-	public static final int VK_SHIFT = 16;
 	public static final int VK_SLASH = 47;
 	public static final int VK_SPACE = 32;
 	public static final int VK_PRINTSCREEN = 154;
@@ -66,10 +56,9 @@ public class KeyboardTranslator {
 	public static short translate(int keycode) {
 		int translated;
 		
-		/* There seems to be no clean mapping between Android key codes
+		// This is a poor man's mapping between Android key codes
-		 * and what Nvidia sends over the wire. If someone finds one,
+		// and Windows VK_* codes. For all defined VK_ codes, see:
-		 * I'll happily delete this code :)
+		// https://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
-		 */
 		if (keycode >= KeyEvent.KEYCODE_0 &&
 			keycode <= KeyEvent.KEYCODE_9) {
 			translated = (keycode - KeyEvent.KEYCODE_0) + VK_0;
@@ -89,8 +78,11 @@ public class KeyboardTranslator {
 		else {
 			switch (keycode) {
 			case KeyEvent.KEYCODE_ALT_LEFT:
+				translated = 0xA4;
+				break;
+
 			case KeyEvent.KEYCODE_ALT_RIGHT:
-				translated = VK_ALT;
+				translated = 0xA5;
 				break;
 				
 			case KeyEvent.KEYCODE_BACKSLASH:
@@ -110,8 +102,11 @@ public class KeyboardTranslator {
 				break;
 				
 			case KeyEvent.KEYCODE_CTRL_LEFT:
+				translated = 0xA2;
+				break;
+
 			case KeyEvent.KEYCODE_CTRL_RIGHT:
-				translated = VK_CONTROL;
+				translated = 0xA3;
 				break;
 				
 			case KeyEvent.KEYCODE_DEL:
@@ -131,12 +126,11 @@ public class KeyboardTranslator {
 				break;
 				
 			case KeyEvent.KEYCODE_FORWARD_DEL:
-				// Nvidia maps period to delete
+				translated = 0x2e;
-				translated = VK_PERIOD;
 				break;
 				
 			case KeyEvent.KEYCODE_INSERT:
-				translated = -1;
+				translated = 0x2d;
 				break;
 				
 			case KeyEvent.KEYCODE_LEFT_BRACKET:
@@ -144,8 +138,11 @@ public class KeyboardTranslator {
 				break;
 
 			case KeyEvent.KEYCODE_META_LEFT:
+				translated = 0x5b;
+				break;
+
 			case KeyEvent.KEYCODE_META_RIGHT:
-				translated = VK_WINDOWS;
+				translated = 0x5c;
 				break;
 
 			case KeyEvent.KEYCODE_MINUS:
@@ -189,8 +186,11 @@ public class KeyboardTranslator {
 				break;
 				
 			case KeyEvent.KEYCODE_SHIFT_LEFT:
+				translated = 0xA0;
+				break;
+
 			case KeyEvent.KEYCODE_SHIFT_RIGHT:
-				translated = VK_SHIFT;
+				translated = 0xA1;
 				break;
 				
 			case KeyEvent.KEYCODE_SLASH:
@@ -238,6 +238,26 @@ public class KeyboardTranslator {
 				translated = VK_PAUSE;
 				break;
 
+			case KeyEvent.KEYCODE_NUMPAD_DIVIDE:
+				translated = 0x6F;
+				break;
+
+			case KeyEvent.KEYCODE_NUMPAD_MULTIPLY:
+				translated = 0x6A;
+				break;
+
+			case KeyEvent.KEYCODE_NUMPAD_SUBTRACT:
+				translated = 0x6D;
+				break;
+
+			case KeyEvent.KEYCODE_NUMPAD_ADD:
+				translated = 0x6B;
+				break;
+
+			case KeyEvent.KEYCODE_NUMPAD_DOT:
+				translated = 0x6E;
+				break;
+				
 			default:
 				System.out.println("No key for "+keycode);
 				return 0;

app/src/main/java/com/limelight/binding/input/capture/InputCaptureManager.java

@@ -3,8 +3,9 @@ package com.limelight.binding.input.capture;
 import android.app.Activity;
 
 import com.limelight.LimeLog;
+import com.limelight.LimelightBuildProps;
 import com.limelight.R;
-import com.limelight.binding.input.evdev.EvdevCaptureProvider;
+import com.limelight.binding.input.evdev.EvdevCaptureProviderShim;
 import com.limelight.binding.input.evdev.EvdevListener;
 
 public class InputCaptureManager {
@@ -13,13 +14,15 @@ public class InputCaptureManager {
             LimeLog.info("Using Android O+ native mouse capture");
             return new AndroidNativePointerCaptureProvider(activity.findViewById(R.id.surfaceView));
         }
-        else if (ShieldCaptureProvider.isCaptureProviderSupported()) {
+        // LineageOS implemented broken NVIDIA capture extensions, so avoid using them on root builds.
+        // See https://github.com/LineageOS/android_frameworks_base/commit/d304f478a023430f4712dbdc3ee69d9ad02cebd3
+        else if (!LimelightBuildProps.ROOT_BUILD && ShieldCaptureProvider.isCaptureProviderSupported()) {
             LimeLog.info("Using NVIDIA mouse capture extension");
             return new ShieldCaptureProvider(activity);
         }
-        else if (EvdevCaptureProvider.isCaptureProviderSupported()) {
+        else if (EvdevCaptureProviderShim.isCaptureProviderSupported()) {
             LimeLog.info("Using Evdev mouse capture");
-            return new EvdevCaptureProvider(activity, rootListener);
+            return EvdevCaptureProviderShim.createEvdevCaptureProvider(activity, rootListener);
         }
         else if (AndroidPointerIconCaptureProvider.isCaptureProviderSupported()) {
             // Android N's native capture can't capture over system UI elements

app/src/main/java/com/limelight/binding/input/driver/UsbDriverService.java

@@ -11,10 +11,14 @@ import android.hardware.usb.UsbDeviceConnection;
 import android.hardware.usb.UsbManager;
 import android.os.Binder;
 import android.os.Build;
+import android.os.Handler;
 import android.os.IBinder;
 import android.view.InputDevice;
+import android.widget.Toast;
 
 import com.limelight.LimeLog;
+import com.limelight.R;
+import com.limelight.preferences.PreferenceConfiguration;
 
 import java.util.ArrayList;
 
@@ -24,6 +28,7 @@ public class UsbDriverService extends Service implements UsbDriverListener {
             "com.limelight.USB_PERMISSION";
 
     private UsbManager usbManager;
+    private PreferenceConfiguration prefConfig;
 
     private final UsbEventReceiver receiver = new UsbEventReceiver();
     private final UsbDriverBinder binder = new UsbDriverBinder();
@@ -72,10 +77,22 @@ public class UsbDriverService extends Service implements UsbDriverListener {
 
             // Initial attachment broadcast
             if (action.equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {
-                UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
+                final UsbDevice device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE);
 
-                // Continue the state machine
+                // shouldClaimDevice() looks at the kernel's enumerated input
-                handleUsbDeviceState(device);
+                // devices to make its decision about whether to prompt to take
+                // control of the device. The kernel bringing up the input stack
+                // may race with this callback and cause us to prompt when the
+                // kernel is capable of running the device. Let's post a delayed
+                // message to process this state change to allow the kernel
+                // some time to bring up the stack.
+                new Handler().postDelayed(new Runnable() {
+                    @Override
+                    public void run() {
+                        // Continue the state machine
+                        handleUsbDeviceState(device);
+                    }
+                }, 1000);
             }
             // Subsequent permission dialog completion intent
             else if (action.equals(ACTION_USB_PERMISSION)) {
@@ -104,11 +121,21 @@ public class UsbDriverService extends Service implements UsbDriverListener {
 
     private void handleUsbDeviceState(UsbDevice device) {
         // Are we able to operate it?
-        if (shouldClaimDevice(device)) {
+        if (shouldClaimDevice(device, prefConfig.bindAllUsb)) {
             // Do we have permission yet?
             if (!usbManager.hasPermission(device)) {
                 // Let's ask for permission
-                usbManager.requestPermission(device, PendingIntent.getBroadcast(UsbDriverService.this, 0, new Intent(ACTION_USB_PERMISSION), 0));
+                try {
+                    // This function is not documented as throwing any exceptions (denying access
+                    // is indicated by calling the PendingIntent with a false result). However,
+                    // Samsung Knox has some policies which block this request, but rather than
+                    // just returning a false result or returning 0 enumerated devices,
+                    // they throw an undocumented SecurityException from this call, crashing
+                    // the whole app. :(
+                    usbManager.requestPermission(device, PendingIntent.getBroadcast(UsbDriverService.this, 0, new Intent(ACTION_USB_PERMISSION), 0));
+                } catch (SecurityException e) {
+                    Toast.makeText(this, this.getText(R.string.error_usb_prohibited), Toast.LENGTH_LONG).show();
+                }
                 return;
             }
 
@@ -144,13 +171,17 @@ public class UsbDriverService extends Service implements UsbDriverListener {
         }
     }
 
-    private boolean isRecognizedInputDevice(UsbDevice device) {
+    private static boolean isRecognizedInputDevice(UsbDevice device) {
         // On KitKat and later, we can determine if this VID and PID combo
         // matches an existing input device and defer to the built-in controller
         // support in that case. Prior to KitKat, we'll always return true to be safe.
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
             for (int id : InputDevice.getDeviceIds()) {
                 InputDevice inputDev = InputDevice.getDevice(id);
+                if (inputDev == null) {
+                    // Device was removed while looping
+                    continue;
+                }
 
                 if (inputDev.getVendorId() == device.getVendorId() &&
                         inputDev.getProductId() == device.getProductId()) {
@@ -165,16 +196,17 @@ public class UsbDriverService extends Service implements UsbDriverListener {
         }
     }
 
-    private boolean shouldClaimDevice(UsbDevice device) {
+    public static boolean shouldClaimDevice(UsbDevice device, boolean claimAllAvailable) {
         // We always bind to XB1 controllers but only bind to XB360 controllers
         // if we know the kernel isn't already driving this device.
         return XboxOneController.canClaimDevice(device) ||
-                (!isRecognizedInputDevice(device) && Xbox360Controller.canClaimDevice(device));
+                ((!isRecognizedInputDevice(device) || claimAllAvailable) && Xbox360Controller.canClaimDevice(device));
     }
 
     @Override
     public void onCreate() {
         this.usbManager = (UsbManager) getSystemService(Context.USB_SERVICE);
+        this.prefConfig = PreferenceConfiguration.readPreferences(this);
 
         // Register for USB attach broadcasts and permission completions
         IntentFilter filter = new IntentFilter();
@@ -184,7 +216,7 @@ public class UsbDriverService extends Service implements UsbDriverListener {
 
         // Enumerate existing devices
         for (UsbDevice dev : usbManager.getDeviceList().values()) {
-            if (shouldClaimDevice(dev)) {
+            if (shouldClaimDevice(dev, prefConfig.bindAllUsb)) {
                 // Start the process of claiming this device
                 handleUsbDeviceState(dev);
             }

app/src/main/java/com/limelight/binding/input/driver/Xbox360Controller.java

@@ -17,18 +17,22 @@ public class Xbox360Controller extends AbstractXboxController {
             0x044f, // Thrustmaster
             0x045e, // Microsoft
             0x046d, // Logitech
+            0x056e, // Elecom
+            0x06a3, // Saitek
             0x0738, // Mad Catz
+            0x07ff, // Mad Catz
             0x0e6f, // Unknown
+            0x0f0d, // Hori
+            0x11c9, // Nacon
             0x12ab, // Unknown
             0x1430, // RedOctane
             0x146b, // BigBen
-            0x1bad, // Harmonix
-            0x0f0d, // Hori
-            0x1689, // Razer Onza
-            0x24c6, // PowerA
             0x1532, // Razer Sabertooth
             0x15e4, // Numark
             0x162e, // Joytech
+            0x1689, // Razer Onza
+            0x1bad, // Harmonix
+            0x24c6, // PowerA
     };
 
     public static boolean canClaimDevice(UsbDevice device) {

app/src/main/java/com/limelight/binding/input/driver/XboxOneController.java

@@ -19,6 +19,7 @@ public class XboxOneController extends AbstractXboxController {
             0x0738, // Mad Catz
             0x0e6f, // Unknown
             0x0f0d, // Hori
+            0x1532, // Razer Wildcat
             0x24c6, // PowerA
     };
 

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

@@ -0,0 +1,24 @@
+package com.limelight.binding.input.evdev;
+
+
+import android.app.Activity;
+
+import com.limelight.LimelightBuildProps;
+import com.limelight.binding.input.capture.InputCaptureProvider;
+
+public class EvdevCaptureProviderShim {
+    public static boolean isCaptureProviderSupported() {
+        return LimelightBuildProps.ROOT_BUILD;
+    }
+
+    // We need to construct our capture provider using reflection because it isn't included in non-root builds
+    public static InputCaptureProvider createEvdevCaptureProvider(Activity activity, EvdevListener listener) {
+        try {
+            Class providerClass = Class.forName("com.limelight.binding.input.evdev.EvdevCaptureProvider");
+            return (InputCaptureProvider) providerClass.getConstructors()[0].newInstance(activity, listener);
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new RuntimeException(e);
+        }
+    }
+}

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

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

app/src/main/java/com/limelight/binding/input/virtual_controller/AnalogStick.java

@@ -164,8 +164,8 @@ public class AnalogStick extends VirtualControllerElement {
         }
     }
 
-    public AnalogStick(VirtualController controller, Context context) {
+    public AnalogStick(VirtualController controller, Context context, int elementId) {
-        super(controller, context);
+        super(controller, context, elementId);
         // reset stick position
         position_stick_x = getWidth() / 2;
         position_stick_y = getHeight() / 2;
@@ -210,7 +210,7 @@ public class AnalogStick extends VirtualControllerElement {
     @Override
     protected void onSizeChanged(int w, int h, int oldw, int oldh) {
         // calculate new radius sizes depending
-        radius_complete = getPercent(getCorrectWidth() / 2, 90);
+        radius_complete = getPercent(getCorrectWidth() / 2, 100);
         radius_dead_zone = getPercent(getCorrectWidth() / 2, 30);
         radius_analog_stick = getPercent(getCorrectWidth() / 2, 20);
 

app/src/main/java/com/limelight/binding/input/virtual_controller/DigitalButton.java

@@ -120,8 +120,8 @@ public class DigitalButton extends VirtualControllerElement {
         }
     }
 
-    public DigitalButton(VirtualController controller, int layer, Context context) {
+    public DigitalButton(VirtualController controller, int elementId, int layer, Context context) {
-        super(controller, context);
+        super(controller, context, elementId);
         this.layer = layer;
     }
 

app/src/main/java/com/limelight/binding/input/virtual_controller/DigitalPad.java

@@ -27,7 +27,7 @@ public class DigitalPad extends VirtualControllerElement {
     private final Paint paint = new Paint();
 
     public DigitalPad(VirtualController controller, Context context) {
-        super(controller, context);
+        super(controller, context, EID_DPAD);
     }
 
     public void addDigitalPadListener(DigitalPadListener listener) {

app/src/main/java/com/limelight/binding/input/virtual_controller/LeftAnalogStick.java

@@ -10,7 +10,7 @@ import com.limelight.nvstream.input.ControllerPacket;
 
 public class LeftAnalogStick extends AnalogStick {
     public LeftAnalogStick(final VirtualController controller, final Context context) {
-        super(controller, context);
+        super(controller, context, EID_LS);
 
         addAnalogStickListener(new AnalogStick.AnalogStickListener() {
             @Override

app/src/main/java/com/limelight/binding/input/virtual_controller/LeftTrigger.java

@@ -8,7 +8,7 @@ import android.content.Context;
 
 public class LeftTrigger extends DigitalButton {
     public LeftTrigger(final VirtualController controller, final int layer, final Context context) {
-        super(controller, layer, context);
+        super(controller, EID_LT, layer, context);
         addDigitalButtonListener(new DigitalButton.DigitalButtonListener() {
             @Override
             public void onClick() {

app/src/main/java/com/limelight/binding/input/virtual_controller/RightAnalogStick.java

@@ -10,7 +10,7 @@ import com.limelight.nvstream.input.ControllerPacket;
 
 public class RightAnalogStick extends AnalogStick {
     public RightAnalogStick(final VirtualController controller, final Context context) {
-        super(controller, context);
+        super(controller, context, EID_RS);
 
         addAnalogStickListener(new AnalogStick.AnalogStickListener() {
             @Override

app/src/main/java/com/limelight/binding/input/virtual_controller/RightTrigger.java

@@ -8,7 +8,7 @@ import android.content.Context;
 
 public class RightTrigger extends DigitalButton {
     public RightTrigger(final VirtualController controller, final int layer, final Context context) {
-        super(controller, layer, context);
+        super(controller, EID_RT, layer, context);
         addDigitalButtonListener(new DigitalButton.DigitalButtonListener() {
             @Override
             public void onClick() {

app/src/main/java/com/limelight/binding/input/virtual_controller/VirtualController.java

@@ -45,7 +45,6 @@ public class VirtualController {
     ControllerMode currentMode = ControllerMode.Active;
     ControllerInputContext inputContext = new ControllerInputContext();
 
-    private RelativeLayout.LayoutParams layoutParamsButtonConfigure = null;
     private Button buttonConfigure = null;
 
     private List<VirtualControllerElement> elements = new ArrayList<>();
@@ -60,6 +59,7 @@ public class VirtualController {
         frame_layout.addView(relative_layout);
 
         buttonConfigure = new Button(context);
+        buttonConfigure.setAlpha(0.25f);
         buttonConfigure.setBackgroundResource(R.drawable.ic_settings);
         buttonConfigure.setOnClickListener(new View.OnClickListener() {
             @Override
@@ -68,6 +68,7 @@ public class VirtualController {
 
                 if (currentMode == ControllerMode.Configuration) {
                     currentMode = ControllerMode.Active;
+                    VirtualControllerConfigurationLoader.saveProfile(VirtualController.this, context);
                     message = "Exiting configuration mode";
                 } else {
                     currentMode = ControllerMode.Configuration;
@@ -85,6 +86,14 @@ public class VirtualController {
         });
     }
 
+    public void hide() {
+        relative_layout.setVisibility(View.INVISIBLE);
+    }
+
+    public void show() {
+        relative_layout.setVisibility(View.VISIBLE);
+    }
+
     public void removeElements() {
         for (VirtualControllerElement element : elements) {
             relative_layout.removeView(element);
@@ -116,11 +125,19 @@ public class VirtualController {
 
         DisplayMetrics screen = context.getResources().getDisplayMetrics();
 
-        int buttonSize = (int)(screen.heightPixels*0.05f);
+        int buttonSize = (int)(screen.heightPixels*0.06f);
-        layoutParamsButtonConfigure = new RelativeLayout.LayoutParams(buttonSize, buttonSize);
+        RelativeLayout.LayoutParams params = new RelativeLayout.LayoutParams(buttonSize, buttonSize);
-        relative_layout.addView(buttonConfigure, layoutParamsButtonConfigure);
+        params.addRule(RelativeLayout.ALIGN_PARENT_LEFT, RelativeLayout.TRUE);
+        params.addRule(RelativeLayout.ALIGN_PARENT_TOP, RelativeLayout.TRUE);
+        params.leftMargin = 15;
+        params.topMargin = 15;
+        relative_layout.addView(buttonConfigure, params);
 
+        // Start with the default layout
         VirtualControllerConfigurationLoader.createDefaultLayout(this, context);
+
+        // Apply user preferences onto the default layout
+        VirtualControllerConfigurationLoader.loadFromPreferences(this, context);
     }
 
     public ControllerMode getControllerMode() {

app/src/main/java/com/limelight/binding/input/virtual_controller/VirtualControllerConfigurationLoader.java

@@ -4,13 +4,19 @@
 
 package com.limelight.binding.input.virtual_controller;
 
+import android.app.Activity;
 import android.content.Context;
+import android.content.SharedPreferences;
 import android.util.DisplayMetrics;
 
 import com.limelight.nvstream.input.ControllerPacket;
+import com.limelight.preferences.PreferenceConfiguration;
+
+import org.json.JSONException;
+import org.json.JSONObject;
 
 public class VirtualControllerConfigurationLoader {
-    private static final String PROFILE_PATH = "profiles";
+    public static final String OSC_PREFERENCE = "OSC";
 
     private static int getPercent(
             int percent,
@@ -58,6 +64,7 @@ public class VirtualControllerConfigurationLoader {
     }
 
     private static DigitalButton createDigitalButton(
+            final int elementId,
             final int keyShort,
             final int keyLong,
             final int layer,
@@ -65,7 +72,7 @@ public class VirtualControllerConfigurationLoader {
             final int icon,
             final VirtualController controller,
             final Context context) {
-        DigitalButton button = new DigitalButton(controller, layer, context);
+        DigitalButton button = new DigitalButton(controller, elementId, layer, context);
         button.setText(text);
         button.setIcon(icon);
 
@@ -146,140 +153,176 @@ public class VirtualControllerConfigurationLoader {
     public static void createDefaultLayout(final VirtualController controller, final Context context) {
 
         DisplayMetrics screen = context.getResources().getDisplayMetrics();
+        PreferenceConfiguration config = PreferenceConfiguration.readPreferences(context);
 
         // NOTE: Some of these getPercent() expressions seem like they can be combined
         // into a single call. Due to floating point rounding, this isn't actually possible.
 
-        controller.addElement(createDigitalPad(controller, context),
+        if (!config.onlyL3R3)
-                getPercent(5, screen.widthPixels),
+        {
-                getPercent(BUTTON_BASE_Y, screen.heightPixels),
+            controller.addElement(createDigitalPad(controller, context),
-                getPercent(30, screen.widthPixels),
+                    getPercent(5, screen.widthPixels),
-                getPercent(40, screen.heightPixels)
+                    getPercent(BUTTON_BASE_Y, screen.heightPixels),
-        );
+                    getPercent(30, screen.widthPixels),
+                    getPercent(40, screen.heightPixels)
+            );
 
-        controller.addElement(createDigitalButton(
+            controller.addElement(createDigitalButton(
-                ControllerPacket.A_FLAG, 0, 1, "A", -1, controller, context),
+                    VirtualControllerElement.EID_A,
-                getPercent(BUTTON_BASE_X, screen.widthPixels)+getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    ControllerPacket.A_FLAG, 0, 1, "A", -1, controller, context),
-                getPercent(BUTTON_BASE_Y, screen.heightPixels)+2*getPercent(BUTTON_HEIGHT, screen.heightPixels),
+                    getPercent(BUTTON_BASE_X, screen.widthPixels) + getPercent(BUTTON_WIDTH, screen.widthPixels),
-                getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_BASE_Y, screen.heightPixels) + 2 * getPercent(BUTTON_HEIGHT, screen.heightPixels),
-                getPercent(BUTTON_HEIGHT, screen.heightPixels)
+                    getPercent(BUTTON_WIDTH, screen.widthPixels),
-        );
+                    getPercent(BUTTON_HEIGHT, screen.heightPixels)
+            );
 
-        controller.addElement(createDigitalButton(
+            controller.addElement(createDigitalButton(
-                ControllerPacket.B_FLAG, 0, 1, "B", -1, controller, context),
+                    VirtualControllerElement.EID_B,
-                getPercent(BUTTON_BASE_X, screen.widthPixels)+2*getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    ControllerPacket.B_FLAG, 0, 1, "B", -1, controller, context),
-                getPercent(BUTTON_BASE_Y, screen.heightPixels)+getPercent(BUTTON_HEIGHT, screen.heightPixels),
+                    getPercent(BUTTON_BASE_X, screen.widthPixels) + 2 * getPercent(BUTTON_WIDTH, screen.widthPixels),
-                getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_BASE_Y, screen.heightPixels) + getPercent(BUTTON_HEIGHT, screen.heightPixels),
-                getPercent(BUTTON_HEIGHT, screen.heightPixels)
+                    getPercent(BUTTON_WIDTH, screen.widthPixels),
-        );
+                    getPercent(BUTTON_HEIGHT, screen.heightPixels)
+            );
 
-        controller.addElement(createDigitalButton(
+            controller.addElement(createDigitalButton(
-                ControllerPacket.X_FLAG, 0, 1, "X", -1, controller, context),
+                    VirtualControllerElement.EID_X,
-                getPercent(BUTTON_BASE_X, screen.widthPixels),
+                    ControllerPacket.X_FLAG, 0, 1, "X", -1, controller, context),
-                getPercent(BUTTON_BASE_Y, screen.heightPixels)+getPercent(BUTTON_HEIGHT, screen.heightPixels),
+                    getPercent(BUTTON_BASE_X, screen.widthPixels),
-                getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_BASE_Y, screen.heightPixels) + getPercent(BUTTON_HEIGHT, screen.heightPixels),
-                getPercent(BUTTON_HEIGHT, screen.heightPixels)
+                    getPercent(BUTTON_WIDTH, screen.widthPixels),
-        );
+                    getPercent(BUTTON_HEIGHT, screen.heightPixels)
+            );
 
-        controller.addElement(createDigitalButton(
+            controller.addElement(createDigitalButton(
-                ControllerPacket.Y_FLAG, 0, 1, "Y", -1, controller, context),
+                    VirtualControllerElement.EID_Y,
-                getPercent(BUTTON_BASE_X, screen.widthPixels)+getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    ControllerPacket.Y_FLAG, 0, 1, "Y", -1, controller, context),
-                getPercent(BUTTON_BASE_Y, screen.heightPixels),
+                    getPercent(BUTTON_BASE_X, screen.widthPixels) + getPercent(BUTTON_WIDTH, screen.widthPixels),
-                getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_BASE_Y, screen.heightPixels),
-                getPercent(BUTTON_HEIGHT, screen.heightPixels)
+                    getPercent(BUTTON_WIDTH, screen.widthPixels),
-        );
+                    getPercent(BUTTON_HEIGHT, screen.heightPixels)
+            );
 
-        controller.addElement(createLeftTrigger(
+            controller.addElement(createLeftTrigger(
-                        0, "LT", -1, controller, context),
+                    0, "LT", -1, controller, context),
-                getPercent(BUTTON_BASE_X, screen.widthPixels),
+                    getPercent(BUTTON_BASE_X, screen.widthPixels),
-                getPercent(BUTTON_BASE_Y, screen.heightPixels),
+                    getPercent(BUTTON_BASE_Y, screen.heightPixels),
-                getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_WIDTH, screen.widthPixels),
-                getPercent(BUTTON_HEIGHT, screen.heightPixels)
+                    getPercent(BUTTON_HEIGHT, screen.heightPixels)
-        );
+            );
 
-        controller.addElement(createRightTrigger(
+            controller.addElement(createRightTrigger(
-                0, "RT", -1, controller, context),
+                    0, "RT", -1, controller, context),
-                getPercent(BUTTON_BASE_X, screen.widthPixels)+2*getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_BASE_X, screen.widthPixels) + 2 * getPercent(BUTTON_WIDTH, screen.widthPixels),
-                getPercent(BUTTON_BASE_Y, screen.heightPixels),
+                    getPercent(BUTTON_BASE_Y, screen.heightPixels),
-                getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_WIDTH, screen.widthPixels),
-                getPercent(BUTTON_HEIGHT, screen.heightPixels)
+                    getPercent(BUTTON_HEIGHT, screen.heightPixels)
-        );
+            );
 
-        controller.addElement(createDigitalButton(
+            controller.addElement(createDigitalButton(
-                ControllerPacket.LB_FLAG, 0, 1, "LB", -1, controller, context),
+                    VirtualControllerElement.EID_LB,
-                getPercent(BUTTON_BASE_X, screen.widthPixels),
+                    ControllerPacket.LB_FLAG, 0, 1, "LB", -1, controller, context),
-                getPercent(BUTTON_BASE_Y, screen.heightPixels)+2*getPercent(BUTTON_HEIGHT, screen.heightPixels),
+                    getPercent(BUTTON_BASE_X, screen.widthPixels),
-                getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_BASE_Y, screen.heightPixels) + 2 * getPercent(BUTTON_HEIGHT, screen.heightPixels),
-                getPercent(BUTTON_HEIGHT, screen.heightPixels)
+                    getPercent(BUTTON_WIDTH, screen.widthPixels),
-        );
+                    getPercent(BUTTON_HEIGHT, screen.heightPixels)
+            );
 
-        controller.addElement(createDigitalButton(
+            controller.addElement(createDigitalButton(
-                ControllerPacket.RB_FLAG, 0, 1, "RB", -1, controller, context),
+                    VirtualControllerElement.EID_RB,
-                getPercent(BUTTON_BASE_X, screen.widthPixels)+2*getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    ControllerPacket.RB_FLAG, 0, 1, "RB", -1, controller, context),
-                getPercent(BUTTON_BASE_Y, screen.heightPixels)+2*getPercent(BUTTON_HEIGHT, screen.heightPixels),
+                    getPercent(BUTTON_BASE_X, screen.widthPixels) + 2 * getPercent(BUTTON_WIDTH, screen.widthPixels),
-                getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_BASE_Y, screen.heightPixels) + 2 * getPercent(BUTTON_HEIGHT, screen.heightPixels),
-                getPercent(BUTTON_HEIGHT, screen.heightPixels)
+                    getPercent(BUTTON_WIDTH, screen.widthPixels),
-        );
+                    getPercent(BUTTON_HEIGHT, screen.heightPixels)
+            );
 
-        controller.addElement(createLeftStick(controller, context),
+            controller.addElement(createLeftStick(controller, context),
-                getPercent(5, screen.widthPixels),
+                    getPercent(5, screen.widthPixels),
-                getPercent(50, screen.heightPixels),
+                    getPercent(50, screen.heightPixels),
-                getPercent(40, screen.widthPixels),
+                    getPercent(40, screen.widthPixels),
-                getPercent(50, screen.heightPixels)
+                    getPercent(50, screen.heightPixels)
-        );
+            );
 
-        controller.addElement(createRightStick(controller, context),
+            controller.addElement(createRightStick(controller, context),
-                getPercent(55, screen.widthPixels),
+                    getPercent(55, screen.widthPixels),
-                getPercent(50, screen.heightPixels),
+                    getPercent(50, screen.heightPixels),
-                getPercent(40, screen.widthPixels),
+                    getPercent(40, screen.widthPixels),
-                getPercent(50, screen.heightPixels)
+                    getPercent(50, screen.heightPixels)
-        );
+            );
 
-        controller.addElement(createDigitalButton(
+            controller.addElement(createDigitalButton(
-                ControllerPacket.BACK_FLAG, 0, 2, "BACK", -1, controller, context),
+                    VirtualControllerElement.EID_BACK,
-                getPercent(40, screen.widthPixels),
+                    ControllerPacket.BACK_FLAG, 0, 2, "BACK", -1, controller, context),
-                getPercent(90, screen.heightPixels),
+                    getPercent(40, screen.widthPixels),
-                getPercent(10, screen.widthPixels),
+                    getPercent(90, screen.heightPixels),
-                getPercent(10, screen.heightPixels)
+                    getPercent(10, screen.widthPixels),
-        );
+                    getPercent(10, screen.heightPixels)
+            );
 
-        controller.addElement(createDigitalButton(
+            controller.addElement(createDigitalButton(
-                ControllerPacket.PLAY_FLAG, 0, 3, "START", -1, controller, context),
+                    VirtualControllerElement.EID_START,
-                getPercent(40, screen.widthPixels)+getPercent(10, screen.widthPixels),
+                    ControllerPacket.PLAY_FLAG, 0, 3, "START", -1, controller, context),
-                getPercent(90, screen.heightPixels),
+                    getPercent(40, screen.widthPixels) + getPercent(10, screen.widthPixels),
-                getPercent(10, screen.widthPixels),
+                    getPercent(90, screen.heightPixels),
-                getPercent(10, screen.heightPixels)
+                    getPercent(10, screen.widthPixels),
-        );
+                    getPercent(10, screen.heightPixels)
+            );
+        }
+        else {
+            controller.addElement(createDigitalButton(
+                    VirtualControllerElement.EID_LSB,
+                    ControllerPacket.LS_CLK_FLAG, 0, 1, "L3", -1, controller, context),
+                    getPercent(2, screen.widthPixels),
+                    getPercent(80, screen.heightPixels),
+                    getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_HEIGHT, screen.heightPixels)
+            );
+
+            controller.addElement(createDigitalButton(
+                    VirtualControllerElement.EID_RSB,
+                    ControllerPacket.RS_CLK_FLAG, 0, 1, "R3", -1, controller, context),
+                    getPercent(89, screen.widthPixels),
+                    getPercent(80, screen.heightPixels),
+                    getPercent(BUTTON_WIDTH, screen.widthPixels),
+                    getPercent(BUTTON_HEIGHT, screen.heightPixels)
+            );
+        }
     }
 
-    /*
+    public static void saveProfile(final VirtualController controller,
-    NOT IMPLEMENTED YET,
-    this should later be used to store and load a profile for the virtual controller
-    public static void saveProfile(final String name,
-                                   final VirtualController controller,
                                    final Context context) {
+        SharedPreferences.Editor prefEditor = context.getSharedPreferences(OSC_PREFERENCE, Activity.MODE_PRIVATE).edit();
 
-        SharedPreferences preferences = context.getSharedPreferences(PROFILE_PATH + "/" +
-                name, Activity.MODE_PRIVATE);
-
-        JSONArray elementConfigurations = new JSONArray();
         for (VirtualControllerElement element : controller.getElements()) {
-            JSONObject elementConfiguration = new JSONObject();
+            String prefKey = ""+element.elementId;
             try {
-                elementConfiguration.put("TYPE", element.getClass().getName());
+                prefEditor.putString(prefKey, element.getConfiguration().toString());
-                elementConfiguration.put("CONFIGURATION", element.getConfiguration());
+            } catch (JSONException e) {
-                elementConfigurations.put(elementConfiguration);
-            } catch (Exception e) {
                 e.printStackTrace();
             }
         }
 
-        SharedPreferences.Editor editor= preferences.edit();
+        prefEditor.apply();
-        editor.putString("ELEMENTS", elementConfigurations.toString());
     }
 
-	public static void loadFromPreferences(final VirtualController controller) {
+	public static void loadFromPreferences(final VirtualController controller, final Context context) {
+        SharedPreferences pref = context.getSharedPreferences(OSC_PREFERENCE, Activity.MODE_PRIVATE);
 
+        for (VirtualControllerElement element : controller.getElements()) {
+            String prefKey = ""+element.elementId;
+
+            String jsonConfig = pref.getString(prefKey, null);
+            if (jsonConfig != null) {
+                try {
+                    element.loadConfiguration(new JSONObject(jsonConfig));
+                } catch (JSONException e) {
+                    e.printStackTrace();
+
+                    // Remove the corrupt element from the preferences
+                    pref.edit().remove(prefKey).apply();
+                }
+            }
+        }
 	}
-	*/
 }

app/src/main/java/com/limelight/binding/input/virtual_controller/VirtualControllerElement.java

@@ -14,10 +14,30 @@ import android.view.MotionEvent;
 import android.view.View;
 import android.widget.RelativeLayout;
 
+import org.json.JSONException;
+import org.json.JSONObject;
+
 public abstract class VirtualControllerElement extends View {
     protected static boolean _PRINT_DEBUG_INFORMATION = false;
 
+    public static final int EID_DPAD = 1;
+    public static final int EID_LT = 2;
+    public static final int EID_RT = 3;
+    public static final int EID_LB = 4;
+    public static final int EID_RB = 5;
+    public static final int EID_A = 6;
+    public static final int EID_B = 7;
+    public static final int EID_X = 8;
+    public static final int EID_Y = 9;
+    public static final int EID_BACK = 10;
+    public static final int EID_START = 11;
+    public static final int EID_LS = 12;
+    public static final int EID_RS = 13;
+    public static final int EID_LSB = 14;
+    public static final int EID_RSB = 15;
+
     protected VirtualController virtualController;
+    protected final int elementId;
 
     private final Paint paint = new Paint();
 
@@ -40,10 +60,11 @@ public abstract class VirtualControllerElement extends View {
 
     private Mode currentMode = Mode.Normal;
 
-    protected VirtualControllerElement(VirtualController controller, Context context) {
+    protected VirtualControllerElement(VirtualController controller, Context context, int elementId) {
         super(context);
 
         this.virtualController = controller;
+        this.elementId = elementId;
     }
 
     protected void moveElement(int pressed_x, int pressed_y, int x, int y) {
@@ -278,13 +299,28 @@ public abstract class VirtualControllerElement extends View {
         return getWidth() > getHeight() ? getHeight() : getWidth();
     }
 
-    /**
-     public JSONObject getConfiguration () {
-     JSONObject configuration = new JSONObject();
-     return  configuration;
-     }
 
-     public  void loadConfiguration (JSONObject configuration) {
+    public JSONObject getConfiguration() throws JSONException {
-     }
+        JSONObject configuration = new JSONObject();
-     */
+
+        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
+
+        configuration.put("LEFT", layoutParams.leftMargin);
+        configuration.put("TOP", layoutParams.topMargin);
+        configuration.put("WIDTH", layoutParams.width);
+        configuration.put("HEIGHT", layoutParams.height);
+
+        return configuration;
+    }
+
+    public void loadConfiguration(JSONObject configuration) throws JSONException {
+        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
+
+        layoutParams.leftMargin = configuration.getInt("LEFT");
+        layoutParams.topMargin = configuration.getInt("TOP");
+        layoutParams.width = configuration.getInt("WIDTH");
+        layoutParams.height = configuration.getInt("HEIGHT");
+
+        requestLayout();
+    }
 }

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

@@ -0,0 +1,5 @@
+package com.limelight.binding.video;
+
+public interface CrashListener {
+    void notifyCrash(Exception e);
+}

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

@@ -18,6 +18,7 @@ import android.media.MediaFormat;
 import android.media.MediaCodec.BufferInfo;
 import android.media.MediaCodec.CodecException;
 import android.os.Build;
+import android.util.Range;
 import android.view.SurfaceHolder;
 
 public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
@@ -31,13 +32,14 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
     private MediaCodecInfo avcDecoder;
     private MediaCodecInfo hevcDecoder;
 
-    // Used for HEVC only
     private byte[] vpsBuffer;
     private byte[] spsBuffer;
+    private byte[] ppsBuffer;
+    private boolean submittedCsd;
+    private boolean submitCsdNextCall;
 
     private MediaCodec videoDecoder;
     private Thread rendererThread;
-    private Thread[] spinnerThreads;
     private boolean needsSpsBitstreamFixup, isExynos4;
     private boolean adaptivePlayback, directSubmit;
     private boolean constrainedHighProfile;
@@ -47,19 +49,30 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
     private int videoFormat;
     private SurfaceHolder renderTarget;
     private volatile boolean stopping;
+    private CrashListener crashListener;
+    private boolean reportedCrash;
+    private int consecutiveCrashCount;
+    private String glRenderer;
+    private boolean foreground = true;
+    private boolean legacyFrameDropRendering = false;
 
     private boolean needsBaselineSpsHack;
     private SeqParameterSet savedSps;
 
+    private RendererException initialException;
+    private long initialExceptionTimestamp;
+    private static final int EXCEPTION_REPORT_DELAY_MS = 3000;
+
     private long lastTimestampUs;
     private long decoderTimeMs;
     private long totalTimeMs;
-    private int totalFrames;
+    private int totalFramesReceived;
+    private int totalFramesRendered;
     private int frameLossEvents;
     private int framesLost;
     private int lastFrameNumber;
     private int refreshRate;
-    private int bitrate;
+    private PreferenceConfiguration prefs;
 
     private int numSpsIn;
     private int numPpsIn;
@@ -73,9 +86,9 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         return decoder;
     }
 
-    private MediaCodecInfo findHevcDecoder(int videoFormat) {
+    private MediaCodecInfo findHevcDecoder(PreferenceConfiguration prefs, boolean meteredNetwork, boolean requestedHdr) {
         // Don't return anything if H.265 is forced off
-        if (videoFormat == PreferenceConfiguration.FORCE_H265_OFF) {
+        if (prefs.videoFormat == PreferenceConfiguration.FORCE_H265_OFF) {
             return null;
         }
 
@@ -86,10 +99,11 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         // for even required levels of HEVC.
         MediaCodecInfo decoderInfo = MediaCodecHelper.findProbableSafeDecoder("video/hevc", -1);
         if (decoderInfo != null) {
-            if (!MediaCodecHelper.decoderIsWhitelistedForHevc(decoderInfo.getName())) {
+            if (!MediaCodecHelper.decoderIsWhitelistedForHevc(decoderInfo.getName(), meteredNetwork)) {
                 LimeLog.info("Found HEVC decoder, but it's not whitelisted - "+decoderInfo.getName());
 
-                if (videoFormat == PreferenceConfiguration.FORCE_H265_ON) {
+                // HDR implies HEVC forced on, since HEVCMain10HDR10 is required for HDR
+                if (prefs.videoFormat == PreferenceConfiguration.FORCE_H265_ON || requestedHdr) {
                     LimeLog.info("Forcing H265 enabled despite non-whitelisted decoder");
                 }
                 else {
@@ -105,12 +119,16 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         this.renderTarget = renderTarget;
     }
 
-    public MediaCodecDecoderRenderer(int videoFormat, int bitrate) {
+    public MediaCodecDecoderRenderer(PreferenceConfiguration prefs,
+                                     CrashListener crashListener, int consecutiveCrashCount,
+                                     boolean meteredData, boolean requestedHdr,
+                                     String glRenderer) {
         //dumpDecoders();
 
-        this.bitrate = bitrate;
+        this.prefs = prefs;
-
+        this.crashListener = crashListener;
-        spinnerThreads = new Thread[Runtime.getRuntime().availableProcessors()];
+        this.consecutiveCrashCount = consecutiveCrashCount;
+        this.glRenderer = glRenderer;
 
         avcDecoder = findAvcDecoder();
         if (avcDecoder != null) {
@@ -120,7 +138,7 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
             LimeLog.warning("No AVC decoder found");
         }
 
-        hevcDecoder = findHevcDecoder(videoFormat);
+        hevcDecoder = findHevcDecoder(prefs, meteredData, requestedHdr);
         if (hevcDecoder != null) {
             LimeLog.info("Selected HEVC decoder: "+hevcDecoder.getName());
         }
@@ -135,10 +153,15 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         // shared between AVC and HEVC decoders on the same device.
         if (avcDecoder != null) {
             directSubmit = MediaCodecHelper.decoderCanDirectSubmit(avcDecoder.getName());
-            adaptivePlayback = MediaCodecHelper.decoderSupportsAdaptivePlayback(avcDecoder.getName());
+            adaptivePlayback = MediaCodecHelper.decoderSupportsAdaptivePlayback(avcDecoder);
-            refFrameInvalidationAvc = MediaCodecHelper.decoderSupportsRefFrameInvalidationAvc(avcDecoder.getName());
+            refFrameInvalidationAvc = MediaCodecHelper.decoderSupportsRefFrameInvalidationAvc(avcDecoder.getName(), prefs.height);
             refFrameInvalidationHevc = MediaCodecHelper.decoderSupportsRefFrameInvalidationHevc(avcDecoder.getName());
 
+            if (consecutiveCrashCount % 2 == 1) {
+                refFrameInvalidationAvc = refFrameInvalidationHevc = false;
+                LimeLog.warning("Disabling RFI due to previous crash");
+            }
+
             if (directSubmit) {
                 LimeLog.info("Decoder "+avcDecoder.getName()+" will use direct submit");
             }
@@ -159,6 +182,38 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         return avcDecoder != null;
     }
 
+    public boolean is49FpsBlacklisted() {
+        return avcDecoder != null && MediaCodecHelper.decoderBlacklistedFor49Fps(avcDecoder.getName());
+    }
+
+    public void enableLegacyFrameDropRendering() {
+        LimeLog.info("Legacy frame drop rendering enabled");
+        legacyFrameDropRendering = true;
+    }
+
+    public boolean isHevcMain10Hdr10Supported() {
+        if (hevcDecoder == null) {
+            return false;
+        }
+
+        for (MediaCodecInfo.CodecProfileLevel profileLevel : hevcDecoder.getCapabilitiesForType("video/hevc").profileLevels) {
+            if (profileLevel.profile == MediaCodecInfo.CodecProfileLevel.HEVCProfileMain10HDR10) {
+                LimeLog.info("HEVC decoder "+hevcDecoder.getName()+" supports HEVC Main10 HDR10");
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public void notifyVideoForeground() {
+        foreground = true;
+    }
+
+    public void notifyVideoBackground() {
+        foreground = false;
+    }
+
     public int getActiveVideoFormat() {
         return this.videoFormat;
     }
@@ -173,7 +228,7 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         String mimeType;
         String selectedDecoderName;
 
-        if (videoFormat == MoonBridge.VIDEO_FORMAT_H264) {
+        if ((videoFormat & MoonBridge.VIDEO_FORMAT_MASK_H264) != 0) {
             mimeType = "video/avc";
             selectedDecoderName = avcDecoder.getName();
 
@@ -202,7 +257,7 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
 
             refFrameInvalidationActive = refFrameInvalidationAvc;
         }
-        else if (videoFormat == MoonBridge.VIDEO_FORMAT_H265) {
+        else if ((videoFormat & MoonBridge.VIDEO_FORMAT_MASK_H265) != 0) {
             mimeType = "video/hevc";
             selectedDecoderName = hevcDecoder.getName();
 
@@ -294,13 +349,35 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
             }
         }
 
-        // Only throw if the surface is still around and we're not stopping
+        // Only throw if we're not stopping
-        if (!stopping && renderTarget.getSurface().isValid()) {
+        if (!stopping) {
-            if (buf != null || codecFlags != 0) {
+            //
-                throw new RendererException(this, e, buf, codecFlags);
+            // There seems to be a race condition with decoder/surface teardown causing some
+            // decoders to to throw IllegalStateExceptions even before 'stopping' is set.
+            // To workaround this while allowing real exceptions to propagate, we will eat the
+            // first exception. If we are still receiving exceptions 3 seconds later, we will
+            // throw the original exception again.
+            //
+            if (initialException != null) {
+                // This isn't the first time we've had an exception processing video
+                if (System.currentTimeMillis() - initialExceptionTimestamp >= EXCEPTION_REPORT_DELAY_MS) {
+                    // It's been over 3 seconds and we're still getting exceptions. Throw the original now.
+                    if (!reportedCrash) {
+                        reportedCrash = true;
+                        crashListener.notifyCrash(initialException);
+                    }
+                    throw initialException;
+                }
             }
             else {
-                throw new RendererException(this, e);
+                // This is the first exception we've hit
+                if (buf != null || codecFlags != 0) {
+                    initialException = new RendererException(this, e, buf, codecFlags);
+                }
+                else {
+                    initialException = new RendererException(this, e);
+                }
+                initialExceptionTimestamp = System.currentTimeMillis();
             }
         }
     }
@@ -311,7 +388,7 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
             @Override
             public void run() {
                 BufferInfo info = new BufferInfo();
-                while (!isInterrupted()) {
+                while (!stopping) {
                     try {
                         // Try to output a frame
                         int outIndex = videoDecoder.dequeueOutputBuffer(info, 50000);
@@ -328,7 +405,16 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
                             }
 
                             // Render the last buffer
-                            videoDecoder.releaseOutputBuffer(lastIndex, true);
+                            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && !legacyFrameDropRendering) {
+                                // Use a PTS that will cause this frame to never be dropped if frame dropping
+                                // is disabled
+                                videoDecoder.releaseOutputBuffer(lastIndex, 0);
+                            }
+                            else {
+                                videoDecoder.releaseOutputBuffer(lastIndex, true);
+                            }
+
+                            totalFramesRendered++;
 
                             // Add delta time to the totals (excluding probable outliers)
                             long delta = MediaCodecHelper.getMonotonicMillis() - (presentationTimeUs / 1000);
@@ -361,32 +447,9 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         rendererThread.start();
     }
 
-    private void startSpinnerThreads() {
-        LimeLog.info("Using "+spinnerThreads.length+" spinner threads");
-        for (int i = 0; i < spinnerThreads.length; i++) {
-            spinnerThreads[i] = new Thread() {
-                @Override
-                public void run() {
-                    // This thread exists to keep the CPU at a higher DVFS state on devices
-                    // where the governor scales clock speed sporadically, causing dropped frames.
-                    while (!isInterrupted()) {
-                        try {
-                            Thread.sleep(0, 1);
-                        } catch (InterruptedException e) {
-                            break;
-                        }
-                    }
-                }
-            };
-            spinnerThreads[i].setName("Spinner-"+i);
-            spinnerThreads[i].setPriority(Thread.MIN_PRIORITY);
-            spinnerThreads[i].start();
-        }
-    }
-
     private int dequeueInputBuffer() {
         int index = -1;
-        long startTime, queueTime;
+        long startTime;
 
         startTime = MediaCodecHelper.getMonotonicMillis();
 
@@ -399,14 +462,24 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
             return MediaCodec.INFO_TRY_AGAIN_LATER;
         }
 
-        if (index < 0) {
+        int deltaMs = (int)(MediaCodecHelper.getMonotonicMillis() - startTime);
-            return index;
+
+        if (deltaMs >= 20) {
+            LimeLog.warning("Dequeue input buffer ran long: " + deltaMs + " ms");
         }
 
-        queueTime = MediaCodecHelper.getMonotonicMillis();
+        if (index < 0) {
-
+            // We've been hung for 5 seconds and no other exception was reported,
-        if (queueTime - startTime >= 20) {
+            // so generate a decoder hung exception
-            LimeLog.warning("Queue input buffer ran long: " + (queueTime - startTime) + " ms");
+            if (deltaMs >= 5000 && initialException == null) {
+                DecoderHungException decoderHungException = new DecoderHungException(deltaMs);
+                if (!reportedCrash) {
+                    reportedCrash = true;
+                    crashListener.notifyCrash(decoderHungException);
+                }
+                throw new RendererException(this, decoderHungException);
+            }
+            return index;
         }
 
         return index;
@@ -415,49 +488,28 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
     @Override
     public void start() {
         startRendererThread();
-        startSpinnerThreads();
     }
 
+    // !!! May be called even if setup()/start() fails !!!
     public void prepareForStop() {
         // Let the decoding code know to ignore codec exceptions now
         stopping = true;
+
+        // Halt the rendering thread
+        if (rendererThread != null) {
+            rendererThread.interrupt();
+        }
     }
 
     @Override
     public void stop() {
-        stopping = true;
+        // May be called already, but we'll call it now to be safe
-
+        prepareForStop();
-        // Halt the rendering thread
-        rendererThread.interrupt();
-
-        try {
-            // Invalidate pending decode buffers
-            videoDecoder.flush();
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
 
         // Wait for the renderer thread to shut down
         try {
             rendererThread.join();
         } catch (InterruptedException ignored) { }
-
-        try {
-            // Stop the video decoder
-            videoDecoder.stop();
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-        // Halt the spinner threads
-        for (Thread t : spinnerThreads) {
-            t.interrupt();
-        }
-        for (Thread t : spinnerThreads) {
-            try {
-                t.join();
-            } catch (InterruptedException ignored) { }
-        }
     }
 
     @Override
@@ -505,22 +557,28 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         // High Profile which allows the decoder to assume there will be no B-frames and
         // reduce delay and buffering accordingly. Some devices (Marvell, Exynos 4) don't
         // like it so we only set them on devices that are confirmed to benefit from it.
-        if (sps.profile_idc == 100 && constrainedHighProfile) {
+        if (sps.profileIdc == 100 && constrainedHighProfile) {
             LimeLog.info("Setting constraint set flags for constrained high profile");
-            sps.constraint_set_4_flag = true;
+            sps.constraintSet4Flag = true;
-            sps.constraint_set_5_flag = true;
+            sps.constraintSet5Flag = true;
         }
         else {
             // Force the constraints unset otherwise (some may be set by default)
-            sps.constraint_set_4_flag = false;
+            sps.constraintSet4Flag = false;
-            sps.constraint_set_5_flag = false;
+            sps.constraintSet5Flag = false;
         }
     }
 
     @SuppressWarnings("deprecation")
     @Override
-    public int submitDecodeUnit(byte[] frameData, int frameLength, int frameNumber, long receiveTimeMs) {
+    public int submitDecodeUnit(byte[] decodeUnitData, int decodeUnitLength, int decodeUnitType,
-        totalFrames++;
+                                int frameNumber, long receiveTimeMs) {
+        if (stopping) {
+            // Don't bother if we're stopping
+            return MoonBridge.DR_OK;
+        }
+
+        totalFramesReceived++;
 
         // We can receive the same "frame" multiple times if it's an IDR frame.
         // In that case, each frame start NALU is submitted independently.
@@ -550,14 +608,12 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         lastTimestampUs = timestampUs;
 
         int codecFlags = 0;
-        boolean needsSpsReplay = false;
 
         // H264 SPS
-        if (frameData[4] == 0x67) {
+        if (decodeUnitData[4] == 0x67) {
             numSpsIn++;
-            codecFlags |= MediaCodec.BUFFER_FLAG_CODEC_CONFIG;
 
-            ByteBuffer spsBuf = ByteBuffer.wrap(frameData);
+            ByteBuffer spsBuf = ByteBuffer.wrap(decodeUnitData);
 
             // Skip to the start of the NALU data
             spsBuf.position(5);
@@ -571,15 +627,20 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
             // for known resolution combinations. Reference frame invalidation may need
             // these, so leave them be for those decoders.
             if (!refFrameInvalidationActive) {
-                if (initialWidth == 1280 && initialHeight == 720) {
+                if (initialWidth <= 720 && initialHeight <= 480) {
+                    // Max 5 buffered frames at 720x480x60
+                    LimeLog.info("Patching level_idc to 31");
+                    sps.levelIdc = 31;
+                }
+                else if (initialWidth <= 1280 && initialHeight <= 720) {
                     // Max 5 buffered frames at 1280x720x60
                     LimeLog.info("Patching level_idc to 32");
-                    sps.level_idc = 32;
+                    sps.levelIdc = 32;
                 }
-                else if (initialWidth == 1920 && initialHeight == 1080) {
+                else if (initialWidth <= 1920 && initialHeight <= 1080) {
                     // Max 4 buffered frames at 1920x1080x64
                     LimeLog.info("Patching level_idc to 42");
-                    sps.level_idc = 42;
+                    sps.levelIdc = 42;
                 }
                 else {
                     // Leave the profile alone (currently 5.0)
@@ -597,14 +658,14 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
             // where we've enabled reference frame invalidation.
             if (!refFrameInvalidationActive) {
                 LimeLog.info("Patching num_ref_frames in SPS");
-                sps.num_ref_frames = 1;
+                sps.numRefFrames = 1;
             }
 
             // GFE 2.5.11 changed the SPS to add additional extensions
             // Some devices don't like these so we remove them here.
-            sps.vuiParams.video_signal_type_present_flag = false;
+            sps.vuiParams.videoSignalTypePresentFlag = false;
-            sps.vuiParams.colour_description_present_flag = false;
+            sps.vuiParams.colourDescriptionPresentFlag = false;
-            sps.vuiParams.chroma_loc_info_present_flag = false;
+            sps.vuiParams.chromaLocInfoPresentFlag = false;
 
             if ((needsSpsBitstreamFixup || isExynos4) && !refFrameInvalidationActive) {
                 // The SPS that comes in the current H264 bytestream doesn't set bitstream_restriction_flag
@@ -614,22 +675,22 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
                 if (sps.vuiParams.bitstreamRestriction == null) {
                     LimeLog.info("Adding bitstream restrictions");
                     sps.vuiParams.bitstreamRestriction = new VUIParameters.BitstreamRestriction();
-                    sps.vuiParams.bitstreamRestriction.motion_vectors_over_pic_boundaries_flag = true;
+                    sps.vuiParams.bitstreamRestriction.motionVectorsOverPicBoundariesFlag = true;
-                    sps.vuiParams.bitstreamRestriction.log2_max_mv_length_horizontal = 16;
+                    sps.vuiParams.bitstreamRestriction.log2MaxMvLengthHorizontal = 16;
-                    sps.vuiParams.bitstreamRestriction.log2_max_mv_length_vertical = 16;
+                    sps.vuiParams.bitstreamRestriction.log2MaxMvLengthVertical = 16;
-                    sps.vuiParams.bitstreamRestriction.num_reorder_frames = 0;
+                    sps.vuiParams.bitstreamRestriction.numReorderFrames = 0;
                 }
                 else {
                     LimeLog.info("Patching bitstream restrictions");
                 }
 
-                // Some devices throw errors if max_dec_frame_buffering < num_ref_frames
+                // Some devices throw errors if maxDecFrameBuffering < numRefFrames
-                sps.vuiParams.bitstreamRestriction.max_dec_frame_buffering = sps.num_ref_frames;
+                sps.vuiParams.bitstreamRestriction.maxDecFrameBuffering = sps.numRefFrames;
 
                 // These values are the defaults for the fields, but they are more aggressive
                 // than what GFE sends in 2.5.11, but it doesn't seem to cause picture problems.
-                sps.vuiParams.bitstreamRestriction.max_bytes_per_pic_denom = 2;
+                sps.vuiParams.bitstreamRestriction.maxBytesPerPicDenom = 2;
-                sps.vuiParams.bitstreamRestriction.max_bits_per_mb_denom = 1;
+                sps.vuiParams.bitstreamRestriction.maxBitsPerMbDenom = 1;
 
                 // log2_max_mv_length_horizontal and log2_max_mv_length_vertical are set to more
                 // conservative values by GFE 2.5.11. We'll let those values stand.
@@ -643,126 +704,122 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
             // If we need to hack this SPS to say we're baseline, do so now
             if (needsBaselineSpsHack) {
                 LimeLog.info("Hacking SPS to baseline");
-                sps.profile_idc = 66;
+                sps.profileIdc = 66;
                 savedSps = sps;
             }
 
             // Patch the SPS constraint flags
             doProfileSpecificSpsPatching(sps);
 
-            inputBufferIndex = dequeueInputBuffer();
-            if (inputBufferIndex < 0) {
-                // We're being torn down now
-                return MoonBridge.DR_OK;
-            }
-
-            buf = getEmptyInputBuffer(inputBufferIndex);
-            if (buf == null) {
-                // We're being torn down now
-                return MoonBridge.DR_OK;
-            }
-
-            // Write the annex B header
-            buf.put(frameData, 0, 5);
-
             // The H264Utils.writeSPS function safely handles
             // Annex B NALUs (including NALUs with escape sequences)
-            ByteBuffer escapedNalu = H264Utils.writeSPS(sps, frameLength);
+            ByteBuffer escapedNalu = H264Utils.writeSPS(sps, decodeUnitLength);
-            buf.put(escapedNalu);
 
-            if (queueInputBuffer(inputBufferIndex,
+            // Batch this to submit together with PPS
-                    0, buf.position(),
+            spsBuffer = new byte[5 + escapedNalu.limit()];
-                    timestampUs, codecFlags)) {
+            System.arraycopy(decodeUnitData, 0, spsBuffer, 0, 5);
-                return MoonBridge.DR_OK;
+            escapedNalu.get(spsBuffer, 5, escapedNalu.limit());
-            }
+            return MoonBridge.DR_OK;
-            else {
-                return MoonBridge.DR_NEED_IDR;
-            }
-
-            // H264 PPS
-        } else if (frameData[4] == 0x68) {
-            numPpsIn++;
-            codecFlags |= MediaCodec.BUFFER_FLAG_CODEC_CONFIG;
-
-            inputBufferIndex = dequeueInputBuffer();
-            if (inputBufferIndex < 0) {
-                // We're being torn down now
-                return MoonBridge.DR_OK;
-            }
-
-            buf = getEmptyInputBuffer(inputBufferIndex);
-            if (buf == null) {
-                // We're being torn down now
-                return MoonBridge.DR_OK;
-            }
-
-            if (needsBaselineSpsHack) {
-                LimeLog.info("Saw PPS; disabling SPS hack");
-                needsBaselineSpsHack = false;
-
-                // Give the decoder the SPS again with the proper profile now
-                needsSpsReplay = true;
-            }
         }
-        else if (frameData[4] == 0x40) {
+        else if (decodeUnitType == MoonBridge.BUFFER_TYPE_VPS) {
             numVpsIn++;
 
             // Batch this to submit together with SPS and PPS per AOSP docs
-            vpsBuffer = new byte[frameLength];
+            vpsBuffer = new byte[decodeUnitLength];
-            System.arraycopy(frameData, 0, vpsBuffer, 0, frameLength);
+            System.arraycopy(decodeUnitData, 0, vpsBuffer, 0, decodeUnitLength);
             return MoonBridge.DR_OK;
         }
-        else if (frameData[4] == 0x42) {
+        // Only the HEVC SPS hits this path (H.264 is handled above)
+        else if (decodeUnitType == MoonBridge.BUFFER_TYPE_SPS) {
             numSpsIn++;
 
             // Batch this to submit together with VPS and PPS per AOSP docs
-            spsBuffer = new byte[frameLength];
+            spsBuffer = new byte[decodeUnitLength];
-            System.arraycopy(frameData, 0, spsBuffer, 0, frameLength);
+            System.arraycopy(decodeUnitData, 0, spsBuffer, 0, decodeUnitLength);
             return MoonBridge.DR_OK;
         }
-        else if (frameData[4] == 0x44) {
+        else if (decodeUnitType == MoonBridge.BUFFER_TYPE_PPS) {
             numPpsIn++;
 
-            inputBufferIndex = dequeueInputBuffer();
+            // If this is the first CSD blob or we aren't supporting
-            if (inputBufferIndex < 0) {
+            // adaptive playback, we will submit the CSD blob in a
-                // We're being torn down now
+            // separate input buffer.
+            if (!submittedCsd || !adaptivePlayback) {
+                inputBufferIndex = dequeueInputBuffer();
+                if (inputBufferIndex < 0) {
+                    // We're being torn down now
+                    return MoonBridge.DR_NEED_IDR;
+                }
+
+                buf = getEmptyInputBuffer(inputBufferIndex);
+                if (buf == null) {
+                    // We're being torn down now
+                    return MoonBridge.DR_NEED_IDR;
+                }
+
+                // When we get the PPS, submit the VPS and SPS together with
+                // the PPS, as required by AOSP docs on use of MediaCodec.
+                if (vpsBuffer != null) {
+                    buf.put(vpsBuffer);
+                }
+                if (spsBuffer != null) {
+                    buf.put(spsBuffer);
+                }
+
+                // This is the CSD blob
+                codecFlags |= MediaCodec.BUFFER_FLAG_CODEC_CONFIG;
+            }
+            else {
+                // Batch this to submit together with the next I-frame
+                ppsBuffer = new byte[decodeUnitLength];
+                System.arraycopy(decodeUnitData, 0, ppsBuffer, 0, decodeUnitLength);
+
+                // Next call will be I-frame data
+                submitCsdNextCall = true;
+
                 return MoonBridge.DR_OK;
             }
-
-            buf = getEmptyInputBuffer(inputBufferIndex);
-            if (buf == null) {
-                // We're being torn down now
-                return MoonBridge.DR_OK;
-            }
-
-            // When we get the PPS, submit the VPS and SPS together with
-            // the PPS, as required by AOSP docs on use of HEVC and MediaCodec.
-            if (vpsBuffer != null) {
-                buf.put(vpsBuffer);
-            }
-            if (spsBuffer != null) {
-                buf.put(spsBuffer);
-            }
-
-            // This is the HEVC CSD blob
-            codecFlags |= MediaCodec.BUFFER_FLAG_CODEC_CONFIG;
         }
         else {
             inputBufferIndex = dequeueInputBuffer();
             if (inputBufferIndex < 0) {
                 // We're being torn down now
-                return MoonBridge.DR_OK;
+                return MoonBridge.DR_NEED_IDR;
             }
 
             buf = getEmptyInputBuffer(inputBufferIndex);
             if (buf == null) {
                 // We're being torn down now
-                return MoonBridge.DR_OK;
+                return MoonBridge.DR_NEED_IDR;
+            }
+
+            if (submitCsdNextCall) {
+                if (vpsBuffer != null) {
+                    buf.put(vpsBuffer);
+                }
+                if (spsBuffer != null) {
+                    buf.put(spsBuffer);
+                }
+                if (ppsBuffer != null) {
+                    buf.put(ppsBuffer);
+                }
+
+                submitCsdNextCall = false;
             }
         }
 
+        if (decodeUnitLength > buf.limit() - buf.position()) {
+            IllegalArgumentException exception = new IllegalArgumentException(
+                    "Decode unit length "+decodeUnitLength+" too large for input buffer "+buf.limit());
+            if (!reportedCrash) {
+                reportedCrash = true;
+                crashListener.notifyCrash(exception);
+            }
+            throw new RendererException(this, exception);
+        }
+
         // Copy data from our buffer list into the input buffer
-        buf.put(frameData, 0, frameLength);
+        buf.put(decodeUnitData, 0, decodeUnitLength);
 
         if (!queueInputBuffer(inputBufferIndex,
                 0, buf.position(),
@@ -770,12 +827,18 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
             return MoonBridge.DR_NEED_IDR;
         }
 
-        if (needsSpsReplay) {
+        if ((codecFlags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
-            if (!replaySps()) {
+            submittedCsd = true;
-                return MoonBridge.DR_NEED_IDR;
-            }
 
-            LimeLog.info("SPS replay complete");
+            if (needsBaselineSpsHack) {
+                needsBaselineSpsHack = false;
+
+                if (!replaySps()) {
+                    return MoonBridge.DR_NEED_IDR;
+                }
+
+                LimeLog.info("SPS replay complete");
+            }
         }
 
         return MoonBridge.DR_OK;
@@ -796,7 +859,7 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
         inputBuffer.put(new byte[]{0x00, 0x00, 0x00, 0x01, 0x67});
 
         // Switch the H264 profile back to high
-        savedSps.profile_idc = 100;
+        savedSps.profileIdc = 100;
 
         // Patch the SPS constraint flags
         doProfileSpecificSpsPatching(savedSps);
@@ -840,53 +903,82 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
     }
 
     public int getAverageEndToEndLatency() {
-        if (totalFrames == 0) {
+        if (totalFramesReceived == 0) {
             return 0;
         }
-        return (int)(totalTimeMs / totalFrames);
+        return (int)(totalTimeMs / totalFramesReceived);
     }
 
     public int getAverageDecoderLatency() {
-        if (totalFrames == 0) {
+        if (totalFramesReceived == 0) {
             return 0;
         }
-        return (int)(decoderTimeMs / totalFrames);
+        return (int)(decoderTimeMs / totalFramesReceived);
     }
 
-    public class RendererException extends RuntimeException {
+    static class DecoderHungException extends RuntimeException {
-        private static final long serialVersionUID = 8985937536997012406L;
+        private int hangTimeMs;
 
-        private final Exception originalException;
+        DecoderHungException(int hangTimeMs) {
-        private final MediaCodecDecoderRenderer renderer;
+            this.hangTimeMs = hangTimeMs;
-        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 += "Format: "+renderer.videoFormat+"\n";
+            str += "Hang time: "+hangTimeMs+" ms\n";
+            str += super.toString();
+
+            return str;
+        }
+    }
+
+    static class RendererException extends RuntimeException {
+        private static final long serialVersionUID = 8985937536997012406L;
+
+        private String text;
+
+        RendererException(MediaCodecDecoderRenderer renderer, Exception e) {
+            this.text = generateText(renderer, e, null, 0);
+        }
+
+        RendererException(MediaCodecDecoderRenderer renderer, Exception e, ByteBuffer currentBuffer, int currentCodecFlags) {
+            this.text = generateText(renderer, e, currentBuffer, currentCodecFlags);
+        }
+
+        public String toString() {
+            return text;
+        }
+
+        private String generateText(MediaCodecDecoderRenderer renderer, Exception originalException, ByteBuffer currentBuffer, int currentCodecFlags) {
+            String str = "";
+
+            str += "Format: "+String.format("%x", renderer.videoFormat)+"\n";
             str += "AVC Decoder: "+((renderer.avcDecoder != null) ? renderer.avcDecoder.getName():"(none)")+"\n";
             str += "HEVC Decoder: "+((renderer.hevcDecoder != null) ? renderer.hevcDecoder.getName():"(none)")+"\n";
-            str += "Initial video dimensions: "+renderer.initialWidth+"x"+renderer.initialHeight+"\n";
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && renderer.avcDecoder != null) {
+                Range<Integer> avcWidthRange = renderer.avcDecoder.getCapabilitiesForType("video/avc").getVideoCapabilities().getSupportedWidths();
+                str += "AVC supported width range: "+avcWidthRange.getLower()+" - "+avcWidthRange.getUpper()+"\n";
+            }
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP && renderer.hevcDecoder != null) {
+                Range<Integer> hevcWidthRange = renderer.hevcDecoder.getCapabilitiesForType("video/hevc").getVideoCapabilities().getSupportedWidths();
+                str += "HEVC supported width range: "+hevcWidthRange.getLower()+" - "+hevcWidthRange.getUpper()+"\n";
+            }
+            str += "Adaptive playback: "+renderer.adaptivePlayback+"\n";
+            str += "GL Renderer: "+renderer.glRenderer+"\n";
+            str += "Build fingerprint: "+Build.FINGERPRINT+"\n";
+            str += "Foreground: "+renderer.foreground+"\n";
+            str += "Consecutive crashes: "+renderer.consecutiveCrashCount+"\n";
+            str += "RFI active: "+renderer.refFrameInvalidationActive+"\n";
+            str += "Video dimensions: "+renderer.initialWidth+"x"+renderer.initialHeight+"\n";
             str += "FPS target: "+renderer.refreshRate+"\n";
-            str += "Bitrate: "+renderer.bitrate+" Mbps \n";
+            str += "Bitrate: "+renderer.prefs.bitrate+" Kbps \n";
             str += "In stats: "+renderer.numVpsIn+", "+renderer.numSpsIn+", "+renderer.numPpsIn+"\n";
-            str += "Total frames: "+renderer.totalFrames+"\n";
+            str += "Total frames received: "+renderer.totalFramesReceived+"\n";
-            str += "Frame losses: "+renderer.framesLost+" in "+frameLossEvents+" loss events\n";
+            str += "Total frames rendered: "+renderer.totalFramesRendered+"\n";
-            str += "Average end-to-end client latency: "+getAverageEndToEndLatency()+"ms\n";
+            str += "Frame losses: "+renderer.framesLost+" in "+renderer.frameLossEvents+" loss events\n";
-            str += "Average hardware decoder latency: "+getAverageDecoderLatency()+"ms\n";
+            str += "Average end-to-end client latency: "+renderer.getAverageEndToEndLatency()+"ms\n";
+            str += "Average hardware decoder latency: "+renderer.getAverageDecoderLatency()+"ms\n";
 
             if (currentBuffer != null) {
                 str += "Current buffer: ";
@@ -900,6 +992,27 @@ public class MediaCodecDecoderRenderer extends VideoDecoderRenderer {
 
             str += "Is Exynos 4: "+renderer.isExynos4+"\n";
 
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+                if (originalException instanceof CodecException) {
+                    CodecException ce = (CodecException) originalException;
+
+                    str += "Diagnostic Info: "+ce.getDiagnosticInfo()+"\n";
+                    str += "Recoverable: "+ce.isRecoverable()+"\n";
+                    str += "Transient: "+ce.isTransient()+"\n";
+
+                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                        str += "Codec Error Code: "+ce.getErrorCode()+"\n";
+                    }
+                }
+            }
+
+            str += "/proc/cpuinfo:\n";
+            try {
+                str += MediaCodecHelper.readCpuinfo();
+            } catch (Exception e) {
+                str += e.getMessage();
+            }
+
             str += "Full decoder dump:\n";
             try {
                 str += MediaCodecHelper.dumpDecoders();

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

@@ -7,9 +7,10 @@ import java.util.Collections;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Locale;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 import android.annotation.SuppressLint;
-import android.annotation.TargetApi;
 import android.app.ActivityManager;
 import android.content.Context;
 import android.content.pm.ConfigurationInfo;
@@ -27,13 +28,18 @@ public class MediaCodecHelper {
 
 	private static final List<String> blacklistedDecoderPrefixes;
 	private static final List<String> spsFixupBitstreamFixupDecoderPrefixes;
-	private static final List<String> whitelistedAdaptiveResolutionPrefixes;
+	private static final List<String> blacklistedAdaptivePlaybackPrefixes;
+	private static final List<String> deprioritizedHevcDecoders;
     private static final List<String> baselineProfileHackPrefixes;
     private static final List<String> directSubmitPrefixes;
 	private static final List<String> constrainedHighProfilePrefixes;
 	private static final List<String> whitelistedHevcDecoders;
 	private static final List<String> refFrameInvalidationAvcPrefixes;
     private static final List<String> refFrameInvalidationHevcPrefixes;
+    private static final List<String> blacklisted49FpsDecoderPrefixes;
+
+    private static boolean isLowEndSnapdragon = false;
+    private static boolean initialized = false;
 
     static {
         directSubmitPrefixes = new LinkedList<>();
@@ -65,16 +71,14 @@ public class MediaCodecHelper {
 		blacklistedDecoderPrefixes = new LinkedList<>();
 
 		// Blacklist software decoders that don't support H264 high profile,
-		// but exclude the official AOSP emulator from this restriction.
+		// but exclude the official AOSP and CrOS emulator from this restriction.
-		if (!Build.HARDWARE.equals("ranchu") || !Build.BRAND.equals("google")) {
+		if (!Build.HARDWARE.equals("ranchu") && !Build.HARDWARE.equals("cheets")) {
 			blacklistedDecoderPrefixes.add("omx.google");
 			blacklistedDecoderPrefixes.add("AVCDecoder");
 		}
 
-		// Without bitstream fixups, we perform horribly on NVIDIA's HEVC
+		// Never use ffmpeg decoders since they're software decoders
-		// decoder. While not strictly necessary, I'm going to fully blacklist this
+		blacklistedDecoderPrefixes.add("OMX.ffmpeg");
-		// one to avoid users getting inaccurate impressions of Tegra X1/Moonlight performance.
-		blacklistedDecoderPrefixes.add("OMX.Nvidia.h265.decode");
 
 		// Force these decoders disabled because:
 		// 1) They are software decoders, so the performance is terrible
@@ -94,11 +98,13 @@ public class MediaCodecHelper {
         baselineProfileHackPrefixes = new LinkedList<>();
         baselineProfileHackPrefixes.add("omx.intel");
 
-		whitelistedAdaptiveResolutionPrefixes = new LinkedList<>();
+		blacklistedAdaptivePlaybackPrefixes = new LinkedList<>();
-		whitelistedAdaptiveResolutionPrefixes.add("omx.nvidia");
+		// The Intel decoder on Lollipop on Nexus Player would increase latency badly
-		whitelistedAdaptiveResolutionPrefixes.add("omx.qcom");
+		// if adaptive playback was enabled so let's avoid it to be safe.
-		whitelistedAdaptiveResolutionPrefixes.add("omx.sec");
+		blacklistedAdaptivePlaybackPrefixes.add("omx.intel");
-		whitelistedAdaptiveResolutionPrefixes.add("omx.TI");
+		// The MediaTek decoder crashes at 1080p when adaptive playback is enabled
+		// on some Android TV devices with H.265 only.
+		blacklistedAdaptivePlaybackPrefixes.add("omx.mtk");
 
 		constrainedHighProfilePrefixes = new LinkedList<>();
 		constrainedHighProfilePrefixes.add("omx.intel");
@@ -115,14 +121,21 @@ public class MediaCodecHelper {
 		// Exynos seems to be the only HEVC decoder that works reliably
 		whitelistedHevcDecoders.add("omx.exynos");
 
-		// TODO: This needs a similar fixup to the Tegra 3 otherwise it buffers 16 frames
+		// On Darcy (Shield 2017), HEVC runs fine with no fixups required.
-		//whitelistedHevcDecoders.add("omx.nvidia");
+		// For some reason, other X1 implementations require bitstream fixups.
+		if (Build.DEVICE.equalsIgnoreCase("darcy")) {
+			whitelistedHevcDecoders.add("omx.nvidia");
+		}
+		else {
+			// TODO: This needs a similar fixup to the Tegra 3 otherwise it buffers 16 frames
+		}
 
 		// Sony ATVs have broken MediaTek codecs (decoder hangs after rendering the first frame).
 		// I know the Fire TV 2 works, so I'll just whitelist Amazon devices which seem
 		// to actually be tested. Ugh...
 		if (Build.MANUFACTURER.equalsIgnoreCase("Amazon")) {
 			whitelistedHevcDecoders.add("omx.mtk");
+			whitelistedHevcDecoders.add("omx.amlogic");
 		}
 
 		// These theoretically have good HEVC decoding capabilities (potentially better than
@@ -134,20 +147,90 @@ public class MediaCodecHelper {
 		// during initialization to avoid SoCs with broken HEVC decoders.
 	}
 
-	public static void initializeWithContext(Context context) {
+	static {
+		deprioritizedHevcDecoders = new LinkedList<>();
+
+		// These are decoders that work but aren't used by default for various reasons.
+
+		// Qualcomm is currently the only decoders in this group.
+	}
+
+	static {
+		blacklisted49FpsDecoderPrefixes = new LinkedList<>();
+
+		// We see a bunch of crashes on MediaTek Android TVs running
+		// at 49 FPS (PAL 50 Hz - 1). Blacklist this frame rate for
+		// these devices and hope they fix it in Oreo.
+		if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+			blacklisted49FpsDecoderPrefixes.add("omx.mtk");
+		}
+	}
+
+	private static String getAdrenoVersionString(String glRenderer) {
+		glRenderer = glRenderer.toLowerCase().trim();
+
+		if (!glRenderer.contains("adreno")) {
+			return null;
+		}
+
+		Pattern modelNumberPattern = Pattern.compile("(.*)([0-9]{3})(.*)");
+
+		Matcher matcher = modelNumberPattern.matcher(glRenderer);
+		if (!matcher.matches()) {
+			return null;
+		}
+
+		String modelNumber = matcher.group(2);
+		LimeLog.info("Found Adreno GPU: "+modelNumber);
+		return modelNumber;
+	}
+
+	private static boolean isLowEndSnapdragonRenderer(String glRenderer) {
+		String modelNumber = getAdrenoVersionString(glRenderer);
+		if (modelNumber == null) {
+			// Not an Adreno GPU
+			return false;
+		}
+
+		// The current logic is to identify low-end SoCs based on a zero in the x0x place.
+		return modelNumber.charAt(1) == '0';
+	}
+
+	// This is a workaround for some broken devices that report
+	// only GLES 3.0 even though the GPU is an Adreno 4xx series part.
+	// An example of such a device is the Huawei Honor 5x with the
+	// Snapdragon 616 SoC (Adreno 405).
+	private static boolean isGLES31SnapdragonRenderer(String glRenderer) {
+		String modelNumber = getAdrenoVersionString(glRenderer);
+		if (modelNumber == null) {
+			// Not an Adreno GPU
+			return false;
+		}
+
+		// Snapdragon 4xx and higher support GLES 3.1
+		return modelNumber.charAt(0) >= '4';
+	}
+
+	public static void initialize(Context context, String glRenderer) {
+		if (initialized) {
+			return;
+		}
+
 		ActivityManager activityManager =
 				(ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
 		ConfigurationInfo configInfo = activityManager.getDeviceConfigurationInfo();
 		if (configInfo.reqGlEsVersion != ConfigurationInfo.GL_ES_VERSION_UNDEFINED) {
 			LimeLog.info("OpenGL ES version: "+configInfo.reqGlEsVersion);
 
+			isLowEndSnapdragon = isLowEndSnapdragonRenderer(glRenderer);
+
 			// Tegra K1 and later can do reference frame invalidation properly
 			if (configInfo.reqGlEsVersion >= 0x30000) {
 				LimeLog.info("Added omx.nvidia to AVC reference frame invalidation support list");
 				refFrameInvalidationAvcPrefixes.add("omx.nvidia");
 
-                LimeLog.info("Added omx.qcom to AVC reference frame invalidation support list");
+				LimeLog.info("Added omx.qcom to AVC reference frame invalidation support list");
-                refFrameInvalidationAvcPrefixes.add("omx.qcom");
+				refFrameInvalidationAvcPrefixes.add("omx.qcom");
 
 				// Prior to M, we were tricking the decoder into using baseline profile, which
 				// won't support RFI properly.
@@ -155,26 +238,37 @@ public class MediaCodecHelper {
 					LimeLog.info("Added omx.intel to AVC reference frame invalidation support list");
 					refFrameInvalidationAvcPrefixes.add("omx.intel");
 				}
+			}
 
-				// Qualcomm's early HEVC decoders break hard on our HEVC stream. The best check to
+			// Qualcomm's early HEVC decoders break hard on our HEVC stream. The best check to
-				// tell the good from the bad decoders are the generation of Adreno GPU included:
+			// tell the good from the bad decoders are the generation of Adreno GPU included:
-				// 3xx - bad
+			// 3xx - bad
-				// 4xx - good
+			// 4xx - good
-				//
+			//
-				// Unfortunately, it's not that easy to get that information here, so I'll use an
+			// The "good" GPUs support GLES 3.1, but we can't just check that directly
-				// approximation by checking the GLES level (<= 3.0 is bad).
+			// (see comment on isGLES31SnapdragonRenderer).
-				if (configInfo.reqGlEsVersion > 0x30000) {
+			//
-					// FIXME: We prefer reference frame invalidation support (which is only doable on AVC on
+			if (isGLES31SnapdragonRenderer(glRenderer)) {
-					// older Qualcomm chips) vs. enabling HEVC by default. The user can override using the settings
+				// We prefer reference frame invalidation support (which is only doable on AVC on
-					// to force HEVC on.
+				// older Qualcomm chips) vs. enabling HEVC by default. The user can override using the settings
-					//LimeLog.info("Added omx.qcom to supported HEVC decoders based on GLES 3.1+ support");
+				// to force HEVC on. If HDR or mobile data will be used, we'll override this and use
-					//whitelistedHevcDecoders.add("omx.qcom");
+				// HEVC anyway.
-				}
+				LimeLog.info("Added omx.qcom to deprioritized HEVC decoders based on GLES 3.1+ support");
+				deprioritizedHevcDecoders.add("omx.qcom");
+			}
+			else {
+				blacklistedDecoderPrefixes.add("OMX.qcom.video.decoder.hevc");
 			}
 		}
+
+		initialized = true;
     }
 
 	private static boolean isDecoderInList(List<String> decoderList, String decoderName) {
+		if (!initialized) {
+			throw new IllegalStateException("MediaCodecHelper must be initialized before use");
+		}
+
 		for (String badPrefix : decoderList) {
 			if (decoderName.length() >= badPrefix.length()) {
 				String prefix = decoderName.substring(0, badPrefix.length());
@@ -191,19 +285,14 @@ public class MediaCodecHelper {
 		return System.nanoTime() / 1000000L;
 	}
 
-	@TargetApi(Build.VERSION_CODES.KITKAT)
+	public static boolean decoderSupportsAdaptivePlayback(MediaCodecInfo decoderInfo) {
-	public static boolean decoderSupportsAdaptivePlayback(String decoderName) {
-		/*
-        FIXME: Intel's decoder on Nexus Player forces the high latency path if adaptive playback is enabled
-        so we'll keep it off for now, since we don't know whether other devices also do the same
-
-		if (isDecoderInList(whitelistedAdaptiveResolutionPrefixes, decoderName)) {
-			LimeLog.info("Adaptive playback supported (whitelist)");
-			return true;
-		}
-		
 		// Possibly enable adaptive playback on KitKat and above
 		if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
+			if (isDecoderInList(blacklistedAdaptivePlaybackPrefixes, decoderInfo.getName())) {
+				LimeLog.info("Decoder blacklisted for adaptive playback");
+				return false;
+			}
+
 			try {
 				if (decoderInfo.getCapabilitiesForType("video/avc").
 						isFeatureSupported(CodecCapabilities.FEATURE_AdaptivePlayback))
@@ -215,7 +304,7 @@ public class MediaCodecHelper {
 			} catch (Exception e) {
 				// Tolerate buggy codecs
 			}
-		}*/
+		}
 		
 		return false;
 	}
@@ -236,7 +325,22 @@ public class MediaCodecHelper {
         return isDecoderInList(baselineProfileHackPrefixes, decoderName);
     }
 
-    public static boolean decoderSupportsRefFrameInvalidationAvc(String decoderName) {
+	public static boolean decoderBlacklistedFor49Fps(String decoderName) {
+		return isDecoderInList(blacklisted49FpsDecoderPrefixes, decoderName);
+	}
+
+	public static boolean decoderSupportsRefFrameInvalidationAvc(String decoderName, int videoHeight) {
+		// Reference frame invalidation is broken on low-end Snapdragon SoCs at 1080p.
+		if (videoHeight > 720 && isLowEndSnapdragon) {
+			return false;
+		}
+
+		// This device seems to crash constantly at 720p, so try disabling
+		// RFI to see if we can get that under control.
+		if (Build.DEVICE.equals("b3") || Build.DEVICE.equals("b5")) {
+			return false;
+		}
+
 		return isDecoderInList(refFrameInvalidationAvcPrefixes, decoderName);
 	}
 
@@ -244,7 +348,7 @@ public class MediaCodecHelper {
         return isDecoderInList(refFrameInvalidationHevcPrefixes, decoderName);
     }
 
-	public static boolean decoderIsWhitelistedForHevc(String decoderName) {
+	public static boolean decoderIsWhitelistedForHevc(String decoderName, boolean meteredData) {
 		// TODO: Shield Tablet K1/LTE?
 		//
 		// NVIDIA does partial HEVC acceleration on the Shield Tablet. I don't know
@@ -276,6 +380,15 @@ public class MediaCodecHelper {
 			return false;
 		}
 
+		// Some devices have HEVC decoders that we prefer not to use
+		// typically because it can't support reference frame invalidation.
+		// However, we will use it for HDR and for streaming over mobile networks
+		// since it works fine otherwise.
+		if (meteredData && isDecoderInList(deprioritizedHevcDecoders, decoderName)) {
+			LimeLog.info("Selected deprioritized decoder");
+			return true;
+		}
+
 		return isDecoderInList(whitelistedHevcDecoders, decoderName);
 	}
 	
@@ -324,6 +437,10 @@ public class MediaCodecHelper {
 		// because we want to evaluate the decoders in our list's order
 		// rather than MediaCodecList's order
 
+		if (!initialized) {
+			throw new IllegalStateException("MediaCodecHelper must be initialized before use");
+		}
+		
 		for (String preferredDecoder : preferredDecoders) {
 			for (MediaCodecInfo codecInfo : getMediaCodecList()) {
 				// Skip encoders

app/src/main/java/com/limelight/computers/ComputerDatabaseManager.java

@@ -25,6 +25,8 @@ public class ComputerDatabaseManager {
     private static final String REMOTE_IP_COLUMN_NAME = "RemoteIp";
     private static final String MAC_COLUMN_NAME = "Mac";
 
+    private static final String ADDRESS_PREFIX = "ADDRESS_PREFIX__";
+
     private SQLiteDatabase computerDb;
 
     public ComputerDatabaseManager(Context c) {
@@ -60,50 +62,74 @@ public class ComputerDatabaseManager {
         ContentValues values = new ContentValues();
         values.put(COMPUTER_NAME_COLUMN_NAME, details.name);
         values.put(COMPUTER_UUID_COLUMN_NAME, details.uuid.toString());
-        values.put(LOCAL_IP_COLUMN_NAME, details.localIp.getAddress());
+        values.put(LOCAL_IP_COLUMN_NAME, ADDRESS_PREFIX+details.localAddress);
-        values.put(REMOTE_IP_COLUMN_NAME, details.remoteIp.getAddress());
+        values.put(REMOTE_IP_COLUMN_NAME, ADDRESS_PREFIX+details.remoteAddress);
         values.put(MAC_COLUMN_NAME, details.macAddress);
         return -1 != computerDb.insertWithOnConflict(COMPUTER_TABLE_NAME, null, values, SQLiteDatabase.CONFLICT_REPLACE);
     }
 
+    private ComputerDetails getComputerFromCursor(Cursor c) {
+        ComputerDetails details = new ComputerDetails();
+
+        details.name = c.getString(0);
+
+        String uuidStr = c.getString(1);
+        try {
+            details.uuid = UUID.fromString(uuidStr);
+        } catch (IllegalArgumentException e) {
+            // We'll delete this entry
+            LimeLog.severe("DB: Corrupted UUID for "+details.name);
+        }
+
+        // An earlier schema defined addresses as byte blobs. We'll
+        // gracefully migrate those to strings so we can store DNS names
+        // too. To disambiguate, we'll need to prefix them with a string
+        // greater than the allowable IP address length.
+        try {
+            details.localAddress = InetAddress.getByAddress(c.getBlob(2)).getHostAddress();
+            LimeLog.warning("DB: Legacy local address for "+details.name);
+        } catch (UnknownHostException e) {
+            // This is probably a hostname/address with the prefix string
+            String stringData = c.getString(2);
+            if (stringData.startsWith(ADDRESS_PREFIX)) {
+                details.localAddress = c.getString(2).substring(ADDRESS_PREFIX.length());
+            }
+            else {
+                LimeLog.severe("DB: Corrupted local address for "+details.name);
+            }
+        }
+
+        try {
+            details.remoteAddress = InetAddress.getByAddress(c.getBlob(3)).getHostAddress();
+            LimeLog.warning("DB: Legacy remote address for "+details.name);
+        } catch (UnknownHostException e) {
+            // This is probably a hostname/address with the prefix string
+            String stringData = c.getString(3);
+            if (stringData.startsWith(ADDRESS_PREFIX)) {
+                details.remoteAddress = c.getString(3).substring(ADDRESS_PREFIX.length());
+            }
+            else {
+                LimeLog.severe("DB: Corrupted local address for "+details.name);
+            }
+        }
+
+        details.macAddress = c.getString(4);
+
+        // This signifies we don't have dynamic state (like pair state)
+        details.state = ComputerDetails.State.UNKNOWN;
+        details.reachability = ComputerDetails.Reachability.UNKNOWN;
+
+        return details;
+    }
+
     public List<ComputerDetails> getAllComputers() {
         Cursor c = computerDb.rawQuery("SELECT * FROM "+COMPUTER_TABLE_NAME, null);
         LinkedList<ComputerDetails> computerList = new LinkedList<>();
         while (c.moveToNext()) {
-            ComputerDetails details = new ComputerDetails();
+            ComputerDetails details = getComputerFromCursor(c);
-
-            details.name = c.getString(0);
-
-            String uuidStr = c.getString(1);
-            try {
-                details.uuid = UUID.fromString(uuidStr);
-            } catch (IllegalArgumentException e) {
-                // We'll delete this entry
-                LimeLog.severe("DB: Corrupted UUID for "+details.name);
-            }
-
-            try {
-                details.localIp = InetAddress.getByAddress(c.getBlob(2));
-            } catch (UnknownHostException e) {
-                // We'll delete this entry
-                LimeLog.severe("DB: Corrupted local IP for "+details.name);
-            }
-
-            try {
-                details.remoteIp = InetAddress.getByAddress(c.getBlob(3));
-            } catch (UnknownHostException e) {
-                // We'll delete this entry
-                LimeLog.severe("DB: Corrupted remote IP for "+details.name);
-            }
-
-            details.macAddress = c.getString(4);
-
-            // This signifies we don't have dynamic state (like pair state)
-            details.state = ComputerDetails.State.UNKNOWN;
-            details.reachability = ComputerDetails.Reachability.UNKNOWN;
 
             // If a field is corrupt or missing, skip the database entry
-            if (details.uuid == null || details.localIp == null || details.remoteIp == null ||
+            if (details.uuid == null || details.localAddress == null || details.remoteAddress == null ||
                     details.macAddress == null) {
                 continue;
             }
@@ -119,46 +145,17 @@ public class ComputerDatabaseManager {
 
     public ComputerDetails getComputerByName(String name) {
         Cursor c = computerDb.query(COMPUTER_TABLE_NAME, null, COMPUTER_NAME_COLUMN_NAME+"=?", new String[]{name}, null, null, null);
-        ComputerDetails details = new ComputerDetails();
         if (!c.moveToFirst()) {
             // No matching computer
             c.close();
             return null;
         }
 
-        details.name = c.getString(0);
+        ComputerDetails details = getComputerFromCursor(c);
-
-        String uuidStr = c.getString(1);
-        try {
-            details.uuid = UUID.fromString(uuidStr);
-        } catch (IllegalArgumentException e) {
-            // We'll delete this entry
-            LimeLog.severe("DB: Corrupted UUID for "+details.name);
-        }
-
-        try {
-            details.localIp = InetAddress.getByAddress(c.getBlob(2));
-        } catch (UnknownHostException e) {
-            // We'll delete this entry
-            LimeLog.severe("DB: Corrupted local IP for "+details.name);
-        }
-
-        try {
-            details.remoteIp = InetAddress.getByAddress(c.getBlob(3));
-        } catch (UnknownHostException e) {
-            // We'll delete this entry
-            LimeLog.severe("DB: Corrupted remote IP for "+details.name);
-        }
-
-        details.macAddress = c.getString(4);
-
         c.close();
 
-        details.state = ComputerDetails.State.UNKNOWN;
-        details.reachability = ComputerDetails.Reachability.UNKNOWN;
-
         // If a field is corrupt or missing, delete the database entry
-        if (details.uuid == null || details.localIp == null || details.remoteIp == null ||
+        if (details.uuid == null || details.localAddress == null || details.remoteAddress == null ||
                 details.macAddress == null) {
             deleteComputer(details.name);
             return null;

app/src/main/java/com/limelight/computers/ComputerManagerListener.java

@@ -3,5 +3,5 @@ package com.limelight.computers;
 import com.limelight.nvstream.http.ComputerDetails;
 
 public interface ComputerManagerListener {
-    public void notifyComputerUpdated(ComputerDetails details);
+    void notifyComputerUpdated(ComputerDetails details);
 }

app/src/main/java/com/limelight/computers/ComputerManagerService.java

@@ -6,6 +6,7 @@ import java.io.StringReader;
 import java.net.InetAddress;
 import java.net.InetSocketAddress;
 import java.net.Socket;
+import java.net.UnknownHostException;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.UUID;
@@ -20,6 +21,7 @@ import com.limelight.nvstream.http.NvHTTP;
 import com.limelight.nvstream.mdns.MdnsComputer;
 import com.limelight.nvstream.mdns.MdnsDiscoveryListener;
 import com.limelight.utils.CacheHelper;
+import com.limelight.utils.ServerHelper;
 
 import android.app.Service;
 import android.content.ComponentName;
@@ -35,7 +37,7 @@ public class ComputerManagerService extends Service {
     private static final int APPLIST_POLLING_PERIOD_MS = 30000;
     private static final int APPLIST_FAILED_POLLING_RETRY_MS = 2000;
     private static final int MDNS_QUERY_PERIOD_MS = 1000;
-    private static final int FAST_POLL_TIMEOUT = 500;
+    private static final int FAST_POLL_TIMEOUT = 1000;
     private static final int OFFLINE_POLL_TRIES = 5;
     private static final int INITIAL_POLL_TRIES = 2;
     private static final int EMPTY_LIST_THRESHOLD = 3;
@@ -132,7 +134,7 @@ public class ComputerManagerService extends Service {
             public void run() {
 
                 int offlineCount = 0;
-                while (!isInterrupted() && pollingActive) {
+                while (!isInterrupted() && pollingActive && tuple.thread == this) {
                     try {
                         // Only allow one request to the machine at a time
                         synchronized (tuple.networkLock) {
@@ -154,7 +156,7 @@ public class ComputerManagerService extends Service {
                 }
             }
         };
-        t.setName("Polling thread for " + tuple.computer.localIp.getHostAddress());
+        t.setName("Polling thread for " + tuple.computer.localAddress);
         return t;
     }
 
@@ -210,8 +212,8 @@ public class ComputerManagerService extends Service {
             }
         }
 
-        public boolean addComputerBlocking(InetAddress addr) {
+        public boolean addComputerBlocking(String addr, boolean manuallyAdded) {
-            return ComputerManagerService.this.addComputerBlocking(addr);
+            return ComputerManagerService.this.addComputerBlocking(addr, manuallyAdded);
         }
 
         public void removeComputer(String name) {
@@ -289,7 +291,7 @@ public class ComputerManagerService extends Service {
             @Override
             public void notifyComputerAdded(MdnsComputer computer) {
                 // Kick off a serverinfo poll on this machine
-                addComputerBlocking(computer.getAddress());
+                addComputerBlocking(computer.getAddress().getHostAddress(), false);
             }
 
             @Override
@@ -305,15 +307,22 @@ public class ComputerManagerService extends Service {
         };
     }
 
-    private void addTuple(ComputerDetails details) {
+    private void addTuple(ComputerDetails details, boolean manuallyAdded) {
         synchronized (pollingTuples) {
             for (PollingTuple tuple : pollingTuples) {
                 // Check if this is the same computer
                 if (tuple.computer.uuid.equals(details.uuid)) {
-                    // Update details anyway in case this machine has been re-added by IP
+                    if (manuallyAdded) {
-                    // after not being reachable by our existing information
+                        // Update details anyway in case this machine has been re-added by IP
-                    tuple.computer.localIp = details.localIp;
+                        // after not being reachable by our existing information
-                    tuple.computer.remoteIp = details.remoteIp;
+                        tuple.computer.localAddress = details.localAddress;
+                        tuple.computer.remoteAddress = details.remoteAddress;
+                    }
+                    else {
+                        // This indicates that mDNS discovered this address, so we
+                        // should only apply the local address.
+                        tuple.computer.localAddress = details.localAddress;
+                    }
 
                     // Start a polling thread if polling is active
                     if (pollingActive && tuple.thread == null) {
@@ -338,11 +347,11 @@ public class ComputerManagerService extends Service {
         }
     }
 
-    public boolean addComputerBlocking(InetAddress addr) {
+    public boolean addComputerBlocking(String addr, boolean manuallyAdded) {
         // Setup a placeholder
         ComputerDetails fakeDetails = new ComputerDetails();
-        fakeDetails.localIp = addr;
+        fakeDetails.localAddress = addr;
-        fakeDetails.remoteIp = addr;
+        fakeDetails.remoteAddress = addr;
 
         // Block while we try to fill the details
         try {
@@ -356,10 +365,14 @@ public class ComputerManagerService extends Service {
             LimeLog.info("New PC ("+fakeDetails.name+") is UUID "+fakeDetails.uuid);
 
             // Start a polling thread for this machine
-            addTuple(fakeDetails);
+            addTuple(fakeDetails, manuallyAdded);
             return true;
         }
         else {
+            if (!manuallyAdded) {
+                LimeLog.warning("Auto-discovered PC failed to respond: "+addr);
+            }
+
             return false;
         }
     }
@@ -379,6 +392,7 @@ public class ComputerManagerService extends Service {
                     if (tuple.thread != null) {
                         // Interrupt the thread on this entry
                         tuple.thread.interrupt();
+                        tuple.thread = null;
                     }
                     pollingTuples.remove(tuple);
                     break;
@@ -404,14 +418,14 @@ public class ComputerManagerService extends Service {
         }
     }
 
-    private ComputerDetails tryPollIp(ComputerDetails details, InetAddress ipAddr) {
+    private ComputerDetails tryPollIp(ComputerDetails details, String address) {
         // Fast poll this address first to determine if we can connect at the TCP layer
-        if (!fastPollIp(ipAddr)) {
+        if (!fastPollIp(address)) {
             return null;
         }
 
         try {
-            NvHTTP http = new NvHTTP(ipAddr, idManager.getUniqueId(),
+            NvHTTP http = new NvHTTP(address, idManager.getUniqueId(),
                     null, PlatformBinding.getCryptoProvider(ComputerManagerService.this));
 
             ComputerDetails newDetails = http.getComputerDetails();
@@ -432,10 +446,10 @@ public class ComputerManagerService extends Service {
 
     // Just try to establish a TCP connection to speculatively detect a running
     // GFE server
-    private boolean fastPollIp(InetAddress addr) {
+    private boolean fastPollIp(String address) {
         Socket s = new Socket();
         try {
-            s.connect(new InetSocketAddress(addr, NvHTTP.HTTPS_PORT), FAST_POLL_TIMEOUT);
+            s.connect(new InetSocketAddress(address, NvHTTP.HTTPS_PORT), FAST_POLL_TIMEOUT);
             s.close();
             return true;
         } catch (IOException e) {
@@ -443,11 +457,11 @@ public class ComputerManagerService extends Service {
         }
     }
 
-    private void startFastPollThread(final InetAddress addr, final boolean[] info) {
+    private void startFastPollThread(final String address, final boolean[] info) {
         Thread t = new Thread() {
             @Override
             public void run() {
-                boolean pollRes = fastPollIp(addr);
+                boolean pollRes = fastPollIp(address);
 
                 synchronized (info) {
                     info[0] = true; // Done
@@ -457,16 +471,16 @@ public class ComputerManagerService extends Service {
                 }
             }
         };
-        t.setName("Fast Poll - "+addr.getHostAddress());
+        t.setName("Fast Poll - "+address);
         t.start();
     }
 
-    private ComputerDetails.Reachability fastPollPc(final InetAddress local, final InetAddress remote) throws InterruptedException {
+    private ComputerDetails.Reachability fastPollPc(final String localAddress, final String remoteAddress) throws InterruptedException {
         final boolean[] remoteInfo = new boolean[2];
         final boolean[] localInfo = new boolean[2];
 
-        startFastPollThread(local, localInfo);
+        startFastPollThread(localAddress, localInfo);
-        startFastPollThread(remote, remoteInfo);
+        startFastPollThread(remoteAddress, remoteInfo);
 
         // Check local first
         synchronized (localInfo) {
@@ -493,19 +507,31 @@ public class ComputerManagerService extends Service {
         return ComputerDetails.Reachability.OFFLINE;
     }
 
+    private static boolean isAddressLikelyLocal(String str) {
+        try {
+            // This will tend to be wrong for IPv6 but falling back to
+            // remote will be fine in that case. For IPv4, it should be
+            // pretty accurate due to NAT prevalence.
+            InetAddress addr = InetAddress.getByName(str);
+            return addr.isSiteLocalAddress() || addr.isLinkLocalAddress();
+        } catch (UnknownHostException e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+
     private ReachabilityTuple pollForReachability(ComputerDetails details) throws InterruptedException {
         ComputerDetails polledDetails;
         ComputerDetails.Reachability reachability;
 
-        // If the local address is routable across the Internet,
+        if (details.localAddress.equals(details.remoteAddress)) {
-        // always consider this PC remote to be conservative
+            reachability = isAddressLikelyLocal(details.localAddress) ?
-        if (details.localIp.equals(details.remoteIp)) {
+                    ComputerDetails.Reachability.LOCAL : ComputerDetails.Reachability.REMOTE;
-            reachability = ComputerDetails.Reachability.REMOTE;
         }
         else {
             // Do a TCP-level connection to the HTTP server to see if it's listening
-            LimeLog.info("Starting fast poll for "+details.name+" ("+details.localIp+", "+details.remoteIp+")");
+            LimeLog.info("Starting fast poll for "+details.name+" ("+details.localAddress +", "+details.remoteAddress +")");
-            reachability = fastPollPc(details.localIp, details.remoteIp);
+            reachability = fastPollPc(details.localAddress, details.remoteAddress);
             LimeLog.info("Fast poll for "+details.name+" returned "+reachability.toString());
 
             // If no connection could be established to either IP address, there's nothing we can do
@@ -517,39 +543,46 @@ public class ComputerManagerService extends Service {
         boolean localFirst = (reachability == ComputerDetails.Reachability.LOCAL);
 
         if (localFirst) {
-            polledDetails = tryPollIp(details, details.localIp);
+            polledDetails = tryPollIp(details, details.localAddress);
         }
         else {
-            polledDetails = tryPollIp(details, details.remoteIp);
+            polledDetails = tryPollIp(details, details.remoteAddress);
         }
 
-        InetAddress reachableAddr = null;
+        String reachableAddr = null;
-        if (polledDetails == null && !details.localIp.equals(details.remoteIp)) {
+        if (polledDetails == null && !details.localAddress.equals(details.remoteAddress)) {
             // Failed, so let's try the fallback
             if (!localFirst) {
-                polledDetails = tryPollIp(details, details.localIp);
+                polledDetails = tryPollIp(details, details.localAddress);
             }
             else {
-                polledDetails = tryPollIp(details, details.remoteIp);
+                polledDetails = tryPollIp(details, details.remoteAddress);
             }
 
             if (polledDetails != null) {
                 // The fallback poll worked
-                reachableAddr = !localFirst ? details.localIp : details.remoteIp;
+                reachableAddr = !localFirst ? details.localAddress : details.remoteAddress;
             }
         }
         else if (polledDetails != null) {
-            reachableAddr = localFirst ? details.localIp : details.remoteIp;
+            reachableAddr = localFirst ? details.localAddress : details.remoteAddress;
         }
 
         if (reachableAddr == null) {
             return null;
         }
 
-        if (polledDetails.remoteIp.equals(reachableAddr)) {
+        // If both addresses are the same, guess whether we're local based on
+        // IP address heuristics.
+        if (reachableAddr.equals(polledDetails.localAddress) &&
+                reachableAddr.equals(polledDetails.remoteAddress)) {
+            polledDetails.reachability = isAddressLikelyLocal(reachableAddr) ?
+                    ComputerDetails.Reachability.LOCAL : ComputerDetails.Reachability.REMOTE;
+        }
+        else if (polledDetails.remoteAddress.equals(reachableAddr)) {
             polledDetails.reachability = ComputerDetails.Reachability.REMOTE;
         }
-        else if (polledDetails.localIp.equals(reachableAddr)) {
+        else if (polledDetails.localAddress.equals(reachableAddr)) {
             polledDetails.reachability = ComputerDetails.Reachability.LOCAL;
         }
         else {
@@ -571,7 +604,7 @@ public class ComputerManagerService extends Service {
             ReachabilityTuple confirmationReachTuple = pollForReachability(initialReachTuple.computer);
             if (confirmationReachTuple == null) {
                 // Neither of those seem to work, so we'll hold onto the address that did work
-                initialReachTuple.computer.localIp = initialReachTuple.reachableAddress;
+                initialReachTuple.computer.localAddress = initialReachTuple.reachableAddress;
                 initialReachTuple.computer.reachability = ComputerDetails.Reachability.LOCAL;
             }
             else {
@@ -581,8 +614,11 @@ public class ComputerManagerService extends Service {
             }
         }
 
-        // Save the old MAC address
+        // Save some details about the old state of the PC that we may wish
+        // to restore later.
         String savedMacAddress = details.macAddress;
+        String savedLocalAddress = details.localAddress;
+        String savedRemoteAddress = details.remoteAddress;
 
         // If we got here, it's reachable
         details.update(initialReachTuple.computer);
@@ -593,6 +629,33 @@ public class ComputerManagerService extends Service {
             details.macAddress = savedMacAddress;
         }
 
+        // We never want to lose IP addresses by polling server info. If we get a poll back
+        // where localAddress == remoteAddress but savedLocalAddress != savedRemoteAddress,
+        // then we've lost an address in the polling and we should restore the one that's missing.
+        if (details.localAddress.equals(details.remoteAddress) &&
+                !savedLocalAddress.equals(savedRemoteAddress)) {
+            if (details.localAddress.equals(savedLocalAddress)) {
+                // Local addresses are identical, so put the old remote address back
+                details.remoteAddress = savedRemoteAddress;
+            }
+            else if (details.remoteAddress.equals(savedRemoteAddress)) {
+                // Remote addresses are identical, so put the old local address back
+                details.localAddress = savedLocalAddress;
+            }
+            else {
+                // Neither IP address match. Let's restore the remote address to be safe.
+                details.remoteAddress = savedRemoteAddress;
+            }
+
+            // Now update the reachability so the correct address is used
+            if (details.localAddress.equals(initialReachTuple.reachableAddress)) {
+                details.reachability = ComputerDetails.Reachability.LOCAL;
+            }
+            else {
+                details.reachability = ComputerDetails.Reachability.REMOTE;
+            }
+        }
+
         return true;
     }
 
@@ -616,7 +679,7 @@ public class ComputerManagerService extends Service {
 
         for (ComputerDetails computer : dbManager.getAllComputers()) {
             // Add tuples for each computer
-            addTuple(computer);
+            addTuple(computer, true);
         }
 
         releaseLocalDatabaseReference();
@@ -694,8 +757,6 @@ public class ComputerManagerService extends Service {
                 public void run() {
                     int emptyAppListResponses = 0;
                     do {
-                        InetAddress selectedAddr;
-
                         // Can't poll if it's not online
                         if (computer.state != ComputerDetails.State.ONLINE) {
                             if (listener != null) {
@@ -709,19 +770,12 @@ public class ComputerManagerService extends Service {
                             continue;
                         }
 
-                        if (computer.reachability == ComputerDetails.Reachability.LOCAL) {
-                            selectedAddr = computer.localIp;
-                        }
-                        else {
-                            selectedAddr = computer.remoteIp;
-                        }
-
-                        NvHTTP http = new NvHTTP(selectedAddr, idManager.getUniqueId(),
-                                null, PlatformBinding.getCryptoProvider(ComputerManagerService.this));
-
                         PollingTuple tuple = getPollingTuple(computer);
 
                         try {
+                            NvHTTP http = new NvHTTP(ServerHelper.getCurrentAddressFromComputer(computer), idManager.getUniqueId(),
+                                    null, PlatformBinding.getCryptoProvider(ComputerManagerService.this));
+
                             String appList;
                             if (tuple != null) {
                                 // If we're polling this machine too, grab the network lock
@@ -787,6 +841,7 @@ public class ComputerManagerService extends Service {
                     } while (waitPollingDelay());
                 }
             };
+            thread.setName("App list polling thread for " + computer.localAddress);
             thread.start();
         }
 
@@ -816,10 +871,10 @@ class PollingTuple {
 }
 
 class ReachabilityTuple {
-    public final InetAddress reachableAddress;
+    public final String reachableAddress;
     public final ComputerDetails computer;
 
-    public ReachabilityTuple(ComputerDetails computer, InetAddress reachableAddress) {
+    public ReachabilityTuple(ComputerDetails computer, String reachableAddress) {
         this.computer = computer;
         this.reachableAddress = reachableAddress;
     }

app/src/main/java/com/limelight/grid/GenericGridAdapter.java

@@ -55,10 +55,10 @@ public abstract class GenericGridAdapter<T> extends BaseAdapter {
             convertView = inflater.inflate(layoutId, viewGroup, false);
         }
 
-        ImageView imgView = (ImageView) convertView.findViewById(R.id.grid_image);
+        ImageView imgView = convertView.findViewById(R.id.grid_image);
-        ImageView overlayView = (ImageView) convertView.findViewById(R.id.grid_overlay);
+        ImageView overlayView = convertView.findViewById(R.id.grid_overlay);
-        TextView txtView = (TextView) convertView.findViewById(R.id.grid_text);
+        TextView txtView = convertView.findViewById(R.id.grid_text);
-        ProgressBar prgView = (ProgressBar) convertView.findViewById(R.id.grid_spinner);
+        ProgressBar prgView = convertView.findViewById(R.id.grid_spinner);
 
         if (imgView != null) {
             if (!populateImageView(imgView, prgView, itemList.get(i))) {

app/src/main/java/com/limelight/grid/assets/DiskAssetLoader.java

@@ -13,7 +13,11 @@ import java.io.OutputStream;
 
 public class DiskAssetLoader {
     // 5 MB
-    private final long MAX_ASSET_SIZE = 5 * 1024 * 1024;
+    private static final long MAX_ASSET_SIZE = 5 * 1024 * 1024;
+
+    // Standard box art is 300x400
+    private static final int STANDARD_ASSET_WIDTH = 300;
+    private static final int STANDARD_ASSET_HEIGHT = 400;
 
     private final File cacheDir;
 
@@ -25,33 +29,65 @@ public class DiskAssetLoader {
         return CacheHelper.cacheFileExists(cacheDir, "boxart", tuple.computer.uuid.toString(), tuple.app.getAppId() + ".png");
     }
 
-    public Bitmap loadBitmapFromCache(CachedAppAssetLoader.LoaderTuple tuple, int sampleSize) {
+    // https://developer.android.com/topic/performance/graphics/load-bitmap.html
-        InputStream in = null;
+    public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
-        Bitmap bmp = null;
+        // Raw height and width of image
-        try {
+        final int height = options.outHeight;
-            // Make sure the cached asset doesn't exceed the maximum size
+        final int width = options.outWidth;
-            if (CacheHelper.getFileSize(cacheDir, "boxart", tuple.computer.uuid.toString(), tuple.app.getAppId() + ".png") > MAX_ASSET_SIZE) {
+        int inSampleSize = 1;
-                LimeLog.warning("Removing cached tuple exceeding size threshold: "+tuple);
-                CacheHelper.deleteCacheFile(cacheDir, "boxart", tuple.computer.uuid.toString(), tuple.app.getAppId() + ".png");
-                return null;
-            }
 
-            in = CacheHelper.openCacheFileForInput(cacheDir, "boxart", tuple.computer.uuid.toString(), tuple.app.getAppId() + ".png");
+        if (height > reqHeight || width > reqWidth) {
-            BitmapFactory.Options options = new BitmapFactory.Options();
+
-            options.inSampleSize = sampleSize;
+            final int halfHeight = height / 2;
-            options.inPreferredConfig = Bitmap.Config.RGB_565;
+            final int halfWidth = width / 2;
-            bmp = BitmapFactory.decodeStream(in, null, options);
+
-        } catch (IOException ignored) {
+            // Calculates the largest inSampleSize value that is a power of 2 and keeps both
-        } finally {
+            // height and width larger than the requested height and width.
-            if (in != null) {
+            while ((halfHeight / inSampleSize) >= reqHeight && (halfWidth / inSampleSize) >= reqWidth) {
-                try {
+                inSampleSize *= 2;
-                    in.close();
-                } catch (IOException ignored) {}
             }
         }
 
+        return inSampleSize;
+    }
+
+    public Bitmap loadBitmapFromCache(CachedAppAssetLoader.LoaderTuple tuple, int sampleSize) {
+        File file = CacheHelper.openPath(false, cacheDir, "boxart", tuple.computer.uuid.toString(), tuple.app.getAppId() + ".png");
+
+        // Don't bother with anything if it doesn't exist
+        if (!file.exists()) {
+            return null;
+        }
+
+        // Make sure the cached asset doesn't exceed the maximum size
+        if (file.length() > MAX_ASSET_SIZE) {
+            LimeLog.warning("Removing cached tuple exceeding size threshold: "+tuple);
+            file.delete();
+            return null;
+        }
+
+        // Lookup bounds of the downloaded image
+        BitmapFactory.Options decodeOnlyOptions = new BitmapFactory.Options();
+        decodeOnlyOptions.inJustDecodeBounds = true;
+        BitmapFactory.decodeFile(file.getAbsolutePath(), decodeOnlyOptions);
+        if (decodeOnlyOptions.outWidth <= 0 || decodeOnlyOptions.outHeight <= 0) {
+            // Dimensions set to -1 on error. Return value always null.
+            return null;
+        }
+
+        LimeLog.info("Tuple "+tuple+" has cached art of size: "+decodeOnlyOptions.outWidth+"x"+decodeOnlyOptions.outHeight);
+
+        // Load the image scaled to the appropriate size
+        BitmapFactory.Options options = new BitmapFactory.Options();
+        options.inSampleSize = calculateInSampleSize(decodeOnlyOptions,
+                STANDARD_ASSET_WIDTH / sampleSize,
+                STANDARD_ASSET_HEIGHT / sampleSize);
+        options.inPreferredConfig = Bitmap.Config.RGB_565;
+        options.inDither = true;
+        Bitmap bmp = BitmapFactory.decodeFile(file.getAbsolutePath(), options);
+
         if (bmp != null) {
-            LimeLog.info("Disk cache hit for tuple: "+tuple);
+            LimeLog.info("Tuple "+tuple+" decoded from disk cache with sample size: "+options.inSampleSize);
         }
 
         return bmp;

app/src/main/java/com/limelight/grid/assets/NetworkAssetLoader.java

@@ -4,12 +4,11 @@ import android.content.Context;
 
 import com.limelight.LimeLog;
 import com.limelight.binding.PlatformBinding;
-import com.limelight.nvstream.http.ComputerDetails;
 import com.limelight.nvstream.http.NvHTTP;
+import com.limelight.utils.ServerHelper;
 
 import java.io.IOException;
 import java.io.InputStream;
-import java.net.InetAddress;
 
 public class NetworkAssetLoader {
     private final Context context;
@@ -21,10 +20,9 @@ public class NetworkAssetLoader {
     }
 
     public InputStream getBitmapStream(CachedAppAssetLoader.LoaderTuple tuple) {
-        NvHTTP http = new NvHTTP(getCurrentAddress(tuple.computer), uniqueId, null, PlatformBinding.getCryptoProvider(context));
-
         InputStream in = null;
         try {
+            NvHTTP http = new NvHTTP(ServerHelper.getCurrentAddressFromComputer(tuple.computer), uniqueId, null, PlatformBinding.getCryptoProvider(context));
             in = http.getBoxArt(tuple.app);
         } catch (IOException ignored) {}
 
@@ -37,13 +35,4 @@ public class NetworkAssetLoader {
 
         return in;
     }
-
-    private static InetAddress getCurrentAddress(ComputerDetails computer) {
-        if (computer.reachability == ComputerDetails.Reachability.LOCAL) {
-            return computer.localIp;
-        }
-        else {
-            return computer.remoteIp;
-        }
-    }
 }

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

@@ -1,8 +1,12 @@
 package com.limelight.preferences;
 
+import java.net.Inet4Address;
 import java.net.InetAddress;
+import java.net.InterfaceAddress;
+import java.net.NetworkInterface;
+import java.net.SocketException;
 import java.net.UnknownHostException;
-import java.util.Locale;
+import java.util.Collections;
 import java.util.concurrent.LinkedBlockingQueue;
 
 import com.limelight.computers.ComputerManagerService;
@@ -17,7 +21,6 @@ import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
-import android.content.res.Configuration;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.view.KeyEvent;
@@ -43,42 +46,84 @@ public class AddComputerManually extends Activity {
         }
     };
 
+    private boolean isWrongSubnetSiteLocalAddress(String address) {
+        try {
+            InetAddress targetAddress = InetAddress.getByName(address);
+            if (!(targetAddress instanceof Inet4Address) || !targetAddress.isSiteLocalAddress()) {
+                return false;
+            }
+
+            // We have a site-local address. Look for a matching local interface.
+            for (NetworkInterface iface : Collections.list(NetworkInterface.getNetworkInterfaces())) {
+                for (InterfaceAddress addr : iface.getInterfaceAddresses()) {
+                    if (!(addr.getAddress() instanceof Inet4Address) || !addr.getAddress().isSiteLocalAddress()) {
+                        // Skip non-site-local or non-IPv4 addresses
+                        continue;
+                    }
+
+                    byte[] targetAddrBytes = targetAddress.getAddress();
+                    byte[] ifaceAddrBytes = addr.getAddress().getAddress();
+
+                    // Compare prefix to ensure it's the same
+                    boolean addressMatches = true;
+                    for (int i = 0; i < addr.getNetworkPrefixLength(); i++) {
+                        if ((ifaceAddrBytes[i / 8] & (1 << (i % 8))) != (targetAddrBytes[i / 8] & (1 << (i % 8)))) {
+                            addressMatches = false;
+                            break;
+                        }
+                    }
+
+                    if (addressMatches) {
+                        return false;
+                    }
+                }
+            }
+
+            // Couldn't find a matching interface
+            return true;
+        } catch (SocketException e) {
+            e.printStackTrace();
+            return false;
+        } catch (UnknownHostException e) {
+            return false;
+        }
+    }
+
     private void doAddPc(String host) {
         String msg;
-        boolean finish = false;
+        boolean wrongSiteLocal = false;
+        boolean success;
 
         SpinnerDialog dialog = SpinnerDialog.displayDialog(this, getResources().getString(R.string.title_add_pc),
             getResources().getString(R.string.msg_add_pc), false);
 
-        try {
+        success = managerBinder.addComputerBlocking(host, true);
-            InetAddress addr = InetAddress.getByName(host);
+        if (!success){
-
+            wrongSiteLocal = isWrongSubnetSiteLocalAddress(host);
-            if (!managerBinder.addComputerBlocking(addr)){
-                msg = getResources().getString(R.string.addpc_fail);
-            }
-            else {
-                msg = getResources().getString(R.string.addpc_success);
-                finish = true;
-            }
-        } catch (UnknownHostException e) {
-            msg = getResources().getString(R.string.addpc_unknown_host);
         }
 
         dialog.dismiss();
 
-        final boolean toastFinish = finish;
+        if (wrongSiteLocal) {
-        final String toastMsg = msg;
+            Dialog.displayDialog(this, getResources().getString(R.string.conn_error_title), getResources().getString(R.string.addpc_wrong_sitelocal), false);
-        AddComputerManually.this.runOnUiThread(new Runnable() {
+        }
-            @Override
+        else if (!success) {
-            public void run() {
+            Dialog.displayDialog(this, getResources().getString(R.string.conn_error_title), getResources().getString(R.string.addpc_fail), false);
-                Toast.makeText(AddComputerManually.this, toastMsg, Toast.LENGTH_LONG).show();
+        }
+        else {
+            AddComputerManually.this.runOnUiThread(new Runnable() {
+                @Override
+                public void run() {
+                Toast.makeText(AddComputerManually.this, getResources().getString(R.string.addpc_success), Toast.LENGTH_LONG).show();
 
-                if (toastFinish && !isFinishing()) {
+                if (!isFinishing()) {
                     // Close the activity
                     AddComputerManually.this.finish();
                 }
-            }
+                }
-        });
+            });
+        }
+
     }
 
     private void startAddThread() {
@@ -142,7 +187,7 @@ public class AddComputerManually extends Activity {
 
         UiHelper.notifyNewRootView(this);
 
-        this.hostText = (TextView) findViewById(R.id.hostTextView);
+        this.hostText = findViewById(R.id.hostTextView);
         hostText.setImeOptions(EditorInfo.IME_ACTION_DONE);
         hostText.setOnEditorActionListener(new TextView.OnEditorActionListener() {
             @Override

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

@@ -0,0 +1,41 @@
+package com.limelight.preferences;
+
+import android.annotation.TargetApi;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.SharedPreferences;
+import android.os.Build;
+import android.preference.DialogPreference;
+import android.util.AttributeSet;
+import android.widget.Toast;
+
+import com.limelight.R;
+
+import static com.limelight.binding.input.virtual_controller.VirtualControllerConfigurationLoader.OSC_PREFERENCE;
+
+public class ConfirmDeleteOscPreference extends DialogPreference {
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    public ConfirmDeleteOscPreference(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+    }
+
+    public ConfirmDeleteOscPreference(Context context, AttributeSet attrs, int defStyleAttr) {
+        super(context, attrs, defStyleAttr);
+    }
+
+    public ConfirmDeleteOscPreference(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    @TargetApi(Build.VERSION_CODES.LOLLIPOP)
+    public ConfirmDeleteOscPreference(Context context) {
+        super(context);
+    }
+
+    public void onClick(DialogInterface dialog, int which) {
+        if (which == DialogInterface.BUTTON_POSITIVE) {
+            getContext().getSharedPreferences(OSC_PREFERENCE, Context.MODE_PRIVATE).edit().clear().apply();
+            Toast.makeText(getContext(), R.string.toast_reset_osc_success, Toast.LENGTH_SHORT).show();
+        }
+    }
+}

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

@@ -0,0 +1,37 @@
+package com.limelight.preferences;
+
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+public class GlPreferences {
+    private static final String PREF_NAME = "GlPreferences";
+
+    private static final String FINGERPRINT_PREF_STRING = "Fingerprint";
+    private static final String GL_RENDERER_PREF_STRING = "Renderer";
+
+    private SharedPreferences prefs;
+    public String glRenderer;
+    public String savedFingerprint;
+
+    private GlPreferences(SharedPreferences prefs) {
+        this.prefs = prefs;
+    }
+
+    public static GlPreferences readPreferences(Context context) {
+        SharedPreferences prefs = context.getSharedPreferences(PREF_NAME, 0);
+        GlPreferences glPrefs = new GlPreferences(prefs);
+
+        glPrefs.glRenderer = prefs.getString(GL_RENDERER_PREF_STRING, "");
+        glPrefs.savedFingerprint = prefs.getString(FINGERPRINT_PREF_STRING, "");
+
+        return glPrefs;
+    }
+
+    public boolean writePreferences() {
+        return prefs.edit()
+                .putString(GL_RENDERER_PREF_STRING, glRenderer)
+                .putString(FINGERPRINT_PREF_STRING, savedFingerprint)
+                .commit();
+    }
+}

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

@@ -3,13 +3,13 @@ package com.limelight.preferences;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.content.pm.PackageManager;
-import android.content.res.Configuration;
 import android.os.Build;
 import android.preference.PreferenceManager;
 
 public class PreferenceConfiguration {
     static final String RES_FPS_PREF_STRING = "list_resolution_fps";
-    static final String BITRATE_PREF_STRING = "seekbar_bitrate";
+    static final String BITRATE_PREF_STRING = "seekbar_bitrate_kbps";
+    private static final String BITRATE_PREF_OLD_STRING = "seekbar_bitrate";
     private static final String STRETCH_PREF_STRING = "checkbox_stretch_video";
     private static final String SOPS_PREF_STRING = "checkbox_enable_sops";
     private static final String DISABLE_TOASTS_PREF_STRING = "checkbox_disable_warnings";
@@ -23,13 +23,21 @@ public class PreferenceConfiguration {
     private static final String USB_DRIVER_PREF_SRING = "checkbox_usb_driver";
     private static final String VIDEO_FORMAT_PREF_STRING = "video_format";
     private static final String ONSCREEN_CONTROLLER_PREF_STRING = "checkbox_show_onscreen_controls";
+    private static final String ONLY_L3_R3_PREF_STRING = "checkbox_only_show_L3R3";
+    private static final String DISABLE_FRAME_DROP_PREF_STRING = "checkbox_disable_frame_drop";
+    private static final String ENABLE_HDR_PREF_STRING = "checkbox_enable_hdr";
+    private static final String ENABLE_PIP_PREF_STRING = "checkbox_enable_pip";
+    private static final String BIND_ALL_USB_STRING = "checkbox_usb_bind_all";
+    private static final String MOUSE_EMULATION_STRING = "checkbox_mouse_emulation";
 
-    private static final int BITRATE_DEFAULT_720_30 = 5;
+    private static final int BITRATE_DEFAULT_360_30 = 1000;
-    private static final int BITRATE_DEFAULT_720_60 = 10;
+    private static final int BITRATE_DEFAULT_360_60 = 2000;
-    private static final int BITRATE_DEFAULT_1080_30 = 10;
+    private static final int BITRATE_DEFAULT_720_30 = 5000;
-    private static final int BITRATE_DEFAULT_1080_60 = 20;
+    private static final int BITRATE_DEFAULT_720_60 = 10000;
-    private static final int BITRATE_DEFAULT_4K_30 = 40;
+    private static final int BITRATE_DEFAULT_1080_30 = 10000;
-    private static final int BITRATE_DEFAULT_4K_60 = 80;
+    private static final int BITRATE_DEFAULT_1080_60 = 20000;
+    private static final int BITRATE_DEFAULT_4K_30 = 40000;
+    private static final int BITRATE_DEFAULT_4K_60 = 80000;
 
     private static final String DEFAULT_RES_FPS = "720p60";
     private static final int DEFAULT_BITRATE = BITRATE_DEFAULT_720_60;
@@ -45,6 +53,13 @@ public class PreferenceConfiguration {
     private static final boolean DEFAULT_USB_DRIVER = true;
     private static final String DEFAULT_VIDEO_FORMAT = "auto";
     private static final boolean ONSCREEN_CONTROLLER_DEFAULT = false;
+    private static final boolean ONLY_L3_R3_DEFAULT = false;
+    private static final boolean DEFAULT_BATTERY_SAVER = false;
+    private static final boolean DEFAULT_DISABLE_FRAME_DROP = false;
+    private static final boolean DEFAULT_ENABLE_HDR = false;
+    private static final boolean DEFAULT_ENABLE_PIP = false;
+    private static final boolean DEFAULT_BIND_ALL_USB = false;
+    private static final boolean DEFAULT_MOUSE_EMULATION = true;
 
     public static final int FORCE_H265_ON = -1;
     public static final int AUTOSELECT_H265 = 0;
@@ -58,9 +73,21 @@ public class PreferenceConfiguration {
     public String language;
     public boolean listMode, smallIconMode, multiController, enable51Surround, usbDriver;
     public boolean onscreenController;
+    public boolean onlyL3R3;
+    public boolean disableFrameDrop;
+    public boolean enableHdr;
+    public boolean enablePip;
+    public boolean bindAllUsb;
+    public boolean mouseEmulation;
 
     public static int getDefaultBitrate(String resFpsString) {
-        if (resFpsString.equals("720p30")) {
+        if (resFpsString.equals("360p30")) {
+            return BITRATE_DEFAULT_360_30;
+        }
+        else if (resFpsString.equals("360p60")) {
+            return BITRATE_DEFAULT_360_60;
+        }
+        else if (resFpsString.equals("720p30")) {
             return BITRATE_DEFAULT_720_30;
         }
         else if (resFpsString.equals("720p60")) {
@@ -128,13 +155,39 @@ public class PreferenceConfiguration {
         }
     }
 
+    public static void resetStreamingSettings(Context context) {
+        // We consider resolution, FPS, bitrate, HDR, and video format as "streaming settings" here
+        SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
+        prefs.edit()
+                .remove(BITRATE_PREF_STRING)
+                .remove(BITRATE_PREF_OLD_STRING)
+                .remove(RES_FPS_PREF_STRING)
+                .remove(VIDEO_FORMAT_PREF_STRING)
+                .remove(ENABLE_HDR_PREF_STRING)
+                .apply();
+    }
+
     public static PreferenceConfiguration readPreferences(Context context) {
         SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
         PreferenceConfiguration config = new PreferenceConfiguration();
 
-        config.bitrate = prefs.getInt(BITRATE_PREF_STRING, getDefaultBitrate(context));
+        config.bitrate = prefs.getInt(BITRATE_PREF_STRING, prefs.getInt(BITRATE_PREF_OLD_STRING, 0) * 1000);
+        if (config.bitrate == 0) {
+            config.bitrate = getDefaultBitrate(context);
+        }
+
         String str = prefs.getString(RES_FPS_PREF_STRING, DEFAULT_RES_FPS);
-        if (str.equals("720p30")) {
+        if (str.equals("360p30")) {
+            config.width = 640;
+            config.height = 360;
+            config.fps = 30;
+        }
+        else if (str.equals("360p60")) {
+            config.width = 640;
+            config.height = 360;
+            config.fps = 60;
+        }
+        else if (str.equals("720p30")) {
             config.width = 1280;
             config.height = 720;
             config.fps = 30;
@@ -188,6 +241,12 @@ public class PreferenceConfiguration {
         config.enable51Surround = prefs.getBoolean(ENABLE_51_SURROUND_PREF_STRING, DEFAULT_ENABLE_51_SURROUND);
         config.usbDriver = prefs.getBoolean(USB_DRIVER_PREF_SRING, DEFAULT_USB_DRIVER);
         config.onscreenController = prefs.getBoolean(ONSCREEN_CONTROLLER_PREF_STRING, ONSCREEN_CONTROLLER_DEFAULT);
+        config.onlyL3R3 = prefs.getBoolean(ONLY_L3_R3_PREF_STRING, ONLY_L3_R3_DEFAULT);
+        config.disableFrameDrop = prefs.getBoolean(DISABLE_FRAME_DROP_PREF_STRING, DEFAULT_DISABLE_FRAME_DROP);
+        config.enableHdr = prefs.getBoolean(ENABLE_HDR_PREF_STRING, DEFAULT_ENABLE_HDR);
+        config.enablePip = prefs.getBoolean(ENABLE_PIP_PREF_STRING, DEFAULT_ENABLE_PIP);
+        config.bindAllUsb = prefs.getBoolean(BIND_ALL_USB_STRING, DEFAULT_BIND_ALL_USB);
+        config.mouseEmulation = prefs.getBoolean(MOUSE_EMULATION_STRING, DEFAULT_MOUSE_EMULATION);
 
         return config;
     }

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

@@ -16,7 +16,8 @@ import android.widget.TextView;
 // Based on a Stack Overflow example: http://stackoverflow.com/questions/1974193/slider-on-my-preferencescreen
 public class SeekBarPreference extends DialogPreference
 {
-    private static final String SCHEMA_URL = "http://schemas.android.com/apk/res/android";
+    private static final String ANDROID_SCHEMA_URL = "http://schemas.android.com/apk/res/android";
+    private static final String SEEKBAR_SCHEMA_URL = "http://schemas.moonlight-stream.com/apk/res/seekbar";
 
     private SeekBar seekBar;
     private TextView valueText;
@@ -27,6 +28,7 @@ public class SeekBarPreference extends DialogPreference
     private final int defaultValue;
     private final int maxValue;
     private final int minValue;
+    private final int stepSize;
     private int currentValue;
 
     public SeekBarPreference(Context context, AttributeSet attrs) {
@@ -34,27 +36,28 @@ public class SeekBarPreference extends DialogPreference
         this.context = context;
 
         // Read the message from XML
-        int dialogMessageId = attrs.getAttributeResourceValue(SCHEMA_URL, "dialogMessage", 0);
+        int dialogMessageId = attrs.getAttributeResourceValue(ANDROID_SCHEMA_URL, "dialogMessage", 0);
         if (dialogMessageId == 0) {
-            dialogMessage = attrs.getAttributeValue(SCHEMA_URL, "dialogMessage");
+            dialogMessage = attrs.getAttributeValue(ANDROID_SCHEMA_URL, "dialogMessage");
         }
         else {
             dialogMessage = context.getString(dialogMessageId);
         }
 
         // Get the suffix for the number displayed in the dialog
-        int suffixId = attrs.getAttributeResourceValue(SCHEMA_URL, "text", 0);
+        int suffixId = attrs.getAttributeResourceValue(ANDROID_SCHEMA_URL, "text", 0);
         if (suffixId == 0) {
-            suffix = attrs.getAttributeValue(SCHEMA_URL, "text");
+            suffix = attrs.getAttributeValue(ANDROID_SCHEMA_URL, "text");
         }
         else {
             suffix = context.getString(suffixId);
         }
 
         // Get default, min, and max seekbar values
-        defaultValue = attrs.getAttributeIntValue(SCHEMA_URL, "defaultValue", PreferenceConfiguration.getDefaultBitrate(context));
+        defaultValue = attrs.getAttributeIntValue(ANDROID_SCHEMA_URL, "defaultValue", PreferenceConfiguration.getDefaultBitrate(context));
-        maxValue = attrs.getAttributeIntValue(SCHEMA_URL, "max", 100);
+        maxValue = attrs.getAttributeIntValue(ANDROID_SCHEMA_URL, "max", 100);
-        minValue = 1;
+        minValue = attrs.getAttributeIntValue(SEEKBAR_SCHEMA_URL, "min", 1);
+        stepSize = attrs.getAttributeIntValue(SEEKBAR_SCHEMA_URL, "step", 1);
     }
 
     @Override
@@ -89,6 +92,12 @@ public class SeekBarPreference extends DialogPreference
                     return;
                 }
 
+                int roundedValue = ((value + (stepSize - 1))/stepSize)*stepSize;
+                if (roundedValue != value) {
+                    seekBar.setProgress(roundedValue);
+                    return;
+                }
+
                 String t = String.valueOf(value);
                 valueText.setText(suffix == null ? t : t.concat(suffix.length() > 1 ? " "+suffix : suffix));
             }

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

@@ -2,21 +2,25 @@ package com.limelight.preferences;
 
 import android.content.Intent;
 import android.content.SharedPreferences;
-import android.content.res.Configuration;
+import android.media.MediaCodecInfo;
+import android.os.Build;
 import android.os.Bundle;
 import android.app.Activity;
+import android.preference.ListPreference;
 import android.preference.Preference;
 import android.preference.PreferenceCategory;
 import android.preference.PreferenceFragment;
 import android.preference.PreferenceManager;
 import android.preference.PreferenceScreen;
+import android.util.Range;
+import android.view.Display;
 
+import com.limelight.LimeLog;
 import com.limelight.PcView;
 import com.limelight.R;
+import com.limelight.binding.video.MediaCodecHelper;
 import com.limelight.utils.UiHelper;
 
-import java.util.Locale;
-
 public class StreamSettings extends Activity {
     private PreferenceConfiguration previousPrefs;
 
@@ -53,6 +57,37 @@ public class StreamSettings extends Activity {
     }
 
     public static class SettingsFragment extends PreferenceFragment {
+
+        private static void removeResolution(ListPreference pref, String prefix) {
+            int matchingCount = 0;
+
+            // Count the number of matching entries we'll be removing
+            for (CharSequence seq : pref.getEntryValues()) {
+                if (seq.toString().startsWith(prefix)) {
+                    matchingCount++;
+                }
+            }
+
+            // Create the new arrays
+            CharSequence[] entries = new CharSequence[pref.getEntries().length-matchingCount];
+            CharSequence[] entryValues = new CharSequence[pref.getEntryValues().length-matchingCount];
+            int outIndex = 0;
+            for (int i = 0; i < pref.getEntryValues().length; i++) {
+                if (pref.getEntryValues()[i].toString().startsWith(prefix)) {
+                    // Skip matching prefixes
+                    continue;
+                }
+
+                entries[outIndex] = pref.getEntries()[i];
+                entryValues[outIndex] = pref.getEntryValues()[i];
+                outIndex++;
+            }
+
+            // Update the preference with the new list
+            pref.setEntries(entries);
+            pref.setEntryValues(entryValues);
+        }
+
         @Override
         public void onCreate(Bundle savedInstanceState) {
             super.onCreate(savedInstanceState);
@@ -68,6 +103,130 @@ public class StreamSettings extends Activity {
                 screen.removePreference(category);
             }
 
+            // Remove PiP mode on devices pre-Oreo
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+                PreferenceCategory category =
+                        (PreferenceCategory) findPreference("category_basic_settings");
+                category.removePreference(findPreference("checkbox_enable_pip"));
+            }
+
+            // Hide non-supported resolution/FPS combinations
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                Display display = getActivity().getWindowManager().getDefaultDisplay();
+
+                int maxSupportedResW = 0;
+
+                // Always allow resolutions that are smaller or equal to the active
+                // display resolution because decoders can report total non-sense to us.
+                // For example, a p201 device reports:
+                // AVC Decoder: OMX.amlogic.avc.decoder.awesome
+                // HEVC Decoder: OMX.amlogic.hevc.decoder.awesome
+                // AVC supported width range: 64 - 384
+                // HEVC supported width range: 64 - 544
+                for (Display.Mode candidate : display.getSupportedModes()) {
+                    // Some devices report their dimensions in the portrait orientation
+                    // where height > width. Normalize these to the conventional width > height
+                    // arrangement before we process them.
+
+                    int width = Math.max(candidate.getPhysicalWidth(), candidate.getPhysicalHeight());
+                    int height = Math.min(candidate.getPhysicalWidth(), candidate.getPhysicalHeight());
+
+                    if ((width >= 3840 || height >= 2160) && maxSupportedResW < 3840) {
+                        maxSupportedResW = 3840;
+                    }
+                    else if ((width >= 1920 || height >= 1080) && maxSupportedResW < 1920) {
+                        maxSupportedResW = 1920;
+                    }
+                }
+
+                // This must be called to do runtime initialization before calling functions that evaluate
+                // decoder lists.
+                MediaCodecHelper.initialize(getContext(), GlPreferences.readPreferences(getContext()).glRenderer);
+
+                MediaCodecInfo avcDecoder = MediaCodecHelper.findProbableSafeDecoder("video/avc", -1);
+                MediaCodecInfo hevcDecoder = MediaCodecHelper.findProbableSafeDecoder("video/hevc", -1);
+
+                if (avcDecoder != null) {
+                    Range<Integer> avcWidthRange = avcDecoder.getCapabilitiesForType("video/avc").getVideoCapabilities().getSupportedWidths();
+
+                    LimeLog.info("AVC supported width range: "+avcWidthRange.getLower()+" - "+avcWidthRange.getUpper());
+
+                    // If 720p is not reported as supported, ignore all results from this API
+                    if (avcWidthRange.contains(1280)) {
+                        if (avcWidthRange.contains(3840) && maxSupportedResW < 3840) {
+                            maxSupportedResW = 3840;
+                        }
+                        else if (avcWidthRange.contains(1920) && maxSupportedResW < 1920) {
+                            maxSupportedResW = 1920;
+                        }
+                        else if (maxSupportedResW < 1280) {
+                            maxSupportedResW = 1280;
+                        }
+                    }
+                }
+
+                if (hevcDecoder != null) {
+                    Range<Integer> hevcWidthRange = hevcDecoder.getCapabilitiesForType("video/hevc").getVideoCapabilities().getSupportedWidths();
+
+                    LimeLog.info("HEVC supported width range: "+hevcWidthRange.getLower()+" - "+hevcWidthRange.getUpper());
+
+                    // If 720p is not reported as supported, ignore all results from this API
+                    if (hevcWidthRange.contains(1280)) {
+                        if (hevcWidthRange.contains(3840) && maxSupportedResW < 3840) {
+                            maxSupportedResW = 3840;
+                        }
+                        else if (hevcWidthRange.contains(1920) && maxSupportedResW < 1920) {
+                            maxSupportedResW = 1920;
+                        }
+                        else if (maxSupportedResW < 1280) {
+                            maxSupportedResW = 1280;
+                        }
+                    }
+                }
+
+                LimeLog.info("Maximum resolution slot: "+maxSupportedResW);
+
+                ListPreference resPref = (ListPreference) findPreference("list_resolution_fps");
+                if (maxSupportedResW != 0) {
+                    if (maxSupportedResW < 3840) {
+                        // 4K is unsupported
+                        removeResolution(resPref, "4K");
+                    }
+                    if (maxSupportedResW < 1920) {
+                        // 1080p is unsupported
+                        removeResolution(resPref, "1080p");
+                    }
+                    // Never remove 720p
+                }
+            }
+
+            // Remove HDR preference for devices below Nougat
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
+                LimeLog.info("Excluding HDR toggle based on OS");
+                PreferenceCategory category =
+                        (PreferenceCategory) findPreference("category_advanced_settings");
+                category.removePreference(findPreference("checkbox_enable_hdr"));
+            }
+            else {
+                Display display = getActivity().getWindowManager().getDefaultDisplay();
+                Display.HdrCapabilities hdrCaps = display.getHdrCapabilities();
+
+                // We must now ensure our display is compatible with HDR10
+                boolean foundHdr10 = false;
+                for (int hdrType : hdrCaps.getSupportedHdrTypes()) {
+                    if (hdrType == Display.HdrCapabilities.HDR_TYPE_HDR10) {
+                        foundHdr10 = true;
+                    }
+                }
+
+                if (!foundHdr10) {
+                    LimeLog.info("Excluding HDR toggle based on display capabilities");
+                    PreferenceCategory category =
+                            (PreferenceCategory) findPreference("category_advanced_settings");
+                    category.removePreference(findPreference("checkbox_enable_hdr"));
+                }
+            }
+
             // Add a listener to the FPS and resolution preference
             // so the bitrate can be auto-adjusted
             Preference pref = findPreference(PreferenceConfiguration.RES_FPS_PREF_STRING);

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

@@ -3,6 +3,6 @@ package com.limelight.ui;
 import android.widget.AbsListView;
 
 public interface AdapterFragmentCallbacks {
-    public int getAdapterFragmentLayoutId();
+    int getAdapterFragmentLayoutId();
-    public void receiveAbsListView(AbsListView gridView);
+    void receiveAbsListView(AbsListView gridView);
 }

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

@@ -1,5 +1,5 @@
 package com.limelight.ui;
 
 public interface GameGestures {
-    public void showKeyboard();
+    void showKeyboard();
 }

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

@@ -3,15 +3,21 @@ package com.limelight.ui;
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.util.AttributeSet;
+import android.view.KeyEvent;
 import android.view.SurfaceView;
 
 public class StreamView extends SurfaceView {
     private double desiredAspectRatio;
+    private InputCallbacks inputCallbacks;
 
     public void setDesiredAspectRatio(double aspectRatio) {
         this.desiredAspectRatio = aspectRatio;
     }
 
+    public void setInputCallbacks(InputCallbacks callbacks) {
+        this.inputCallbacks = callbacks;
+    }
+
     public StreamView(Context context) {
         super(context);
     }
@@ -52,4 +58,30 @@ public class StreamView extends SurfaceView {
 
         setMeasuredDimension(measuredWidth, measuredHeight);
     }
+
+    @Override
+    public boolean onKeyPreIme(int keyCode, KeyEvent event) {
+        // This callbacks allows us to override dumb IME behavior like when
+        // Samsung's default keyboard consumes Shift+Space. We'll process
+        // the input event directly if any modifier keys are down.
+        if (inputCallbacks != null && event.getModifiers() != 0) {
+            if (event.getAction() == KeyEvent.ACTION_DOWN) {
+                if (inputCallbacks.handleKeyDown(event)) {
+                    return true;
+                }
+            }
+            else if (event.getAction() == KeyEvent.ACTION_UP) {
+                if (inputCallbacks.handleKeyUp(event)) {
+                    return true;
+                }
+            }
+        }
+
+        return super.onKeyPreIme(keyCode, event);
+    }
+
+    public interface InputCallbacks {
+        boolean handleKeyUp(KeyEvent event);
+        boolean handleKeyDown(KeyEvent event);
+    }
 }

app/src/main/java/com/limelight/utils/CacheHelper.java

@@ -13,7 +13,7 @@ import java.io.OutputStream;
 import java.io.Reader;
 
 public class CacheHelper {
-    private static File openPath(boolean createPath, File root, String... path) {
+    public static File openPath(boolean createPath, File root, String... path) {
         File f = root;
         for (int i = 0; i < path.length; i++) {
             String component = path[i];

app/src/main/java/com/limelight/utils/Dialog.java

@@ -13,18 +13,18 @@ public class Dialog implements Runnable {
     private final String title;
     private final String message;
     private final Activity activity;
-    private final boolean endAfterDismiss;
+    private final Runnable runOnDismiss;
 
     private AlertDialog alert;
 
     private static final ArrayList<Dialog> rundownDialogs = new ArrayList<>();
 
-    private Dialog(Activity activity, String title, String message, boolean endAfterDismiss)
+    private Dialog(Activity activity, String title, String message, Runnable runOnDismiss)
     {
         this.activity = activity;
         this.title = title;
         this.message = message;
-        this.endAfterDismiss = endAfterDismiss;
+        this.runOnDismiss = runOnDismiss;
     }
 
     public static void closeDialogs()
@@ -40,9 +40,21 @@ public class Dialog implements Runnable {
         }
     }
 
-    public static void displayDialog(Activity activity, String title, String message, boolean endAfterDismiss)
+    public static void displayDialog(final Activity activity, String title, String message, final boolean endAfterDismiss)
     {
-        activity.runOnUiThread(new Dialog(activity, title, message, endAfterDismiss));
+        activity.runOnUiThread(new Dialog(activity, title, message, new Runnable() {
+            @Override
+            public void run() {
+                if (endAfterDismiss) {
+                    activity.finish();
+                }
+            }
+        }));
+    }
+
+    public static void displayDialog(Activity activity, String title, String message, Runnable runOnDismiss)
+    {
+        activity.runOnUiThread(new Dialog(activity, title, message, runOnDismiss));
     }
 
     @Override
@@ -65,9 +77,7 @@ public class Dialog implements Runnable {
                       alert.dismiss();
                   }
 
-                  if (endAfterDismiss) {
+                  runOnDismiss.run();
-                      activity.finish();
-                  }
               }
         });
         alert.setButton(AlertDialog.BUTTON_NEUTRAL, activity.getResources().getText(R.string.help), new DialogInterface.OnClickListener() {
@@ -77,9 +87,7 @@ public class Dialog implements Runnable {
                     alert.dismiss();
                 }
 
-                if (endAfterDismiss) {
+                runOnDismiss.run();
-                    activity.finish();
-                }
 
                 HelpLauncher.launchTroubleshooting(activity);
             }

app/src/main/java/com/limelight/utils/HelpLauncher.java

@@ -1,24 +1,43 @@
 package com.limelight.utils;
 
-import android.content.ActivityNotFoundException;
 import android.content.Context;
 import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
 import android.net.Uri;
-import android.os.Build;
 
 import com.limelight.HelpActivity;
 
 public class HelpLauncher {
 
+    private static boolean isKnownBrowser(Context context, Intent i) {
+        ResolveInfo resolvedActivity = context.getPackageManager().resolveActivity(i, PackageManager.MATCH_DEFAULT_ONLY);
+        if (resolvedActivity == null) {
+            // No browser
+            return false;
+        }
+
+        String name = resolvedActivity.activityInfo.name;
+        if (name == null) {
+            return false;
+        }
+
+        name = name.toLowerCase();
+        return name.contains("chrome") || name.contains("firefox");
+    }
+
     private static void launchUrl(Context context, String url) {
         // Try to launch the default browser
         try {
-            // Fire TV devices will lie and say they do have a browser
+            Intent i = new Intent(Intent.ACTION_VIEW);
-            // even though the OS just shows an error dialog if we
+            i.setData(Uri.parse(url));
-            // try to use it.
+
-            if (!"Amazon".equalsIgnoreCase(Build.MANUFACTURER)) {
+            // Several Android TV devices will lie and say they do have a browser
-                Intent i = new Intent(Intent.ACTION_VIEW);
+            // even though the OS just shows an error dialog if we try to use it. We need to
-                i.setData(Uri.parse(url));
+            // be a bit more clever on these devices and detect if the browser is a legitimate
+            // browser or just a fake error message activity.
+            if (!context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_LEANBACK) ||
+                    isKnownBrowser(context, i)) {
                 context.startActivity(i);
                 return;
             }

app/src/main/java/com/limelight/utils/ServerHelper.java

@@ -14,23 +14,21 @@ import com.limelight.nvstream.http.NvApp;
 import com.limelight.nvstream.http.NvHTTP;
 
 import java.io.FileNotFoundException;
-import java.net.InetAddress;
 import java.net.UnknownHostException;
 
 public class ServerHelper {
-    public static InetAddress getCurrentAddressFromComputer(ComputerDetails computer) {
+    public static String getCurrentAddressFromComputer(ComputerDetails computer) {
         return computer.reachability == ComputerDetails.Reachability.LOCAL ?
-                computer.localIp : computer.remoteIp;
+                computer.localAddress : computer.remoteAddress;
     }
 
     public static Intent createStartIntent(Activity parent, NvApp app, ComputerDetails computer,
                                            ComputerManagerService.ComputerManagerBinder managerBinder) {
         Intent intent = new Intent(parent, Game.class);
-        intent.putExtra(Game.EXTRA_HOST,
+        intent.putExtra(Game.EXTRA_HOST, getCurrentAddressFromComputer(computer));
-                computer.reachability == ComputerDetails.Reachability.LOCAL ?
-                        computer.localIp.getHostAddress() : computer.remoteIp.getHostAddress());
         intent.putExtra(Game.EXTRA_APP_NAME, app.getAppName());
         intent.putExtra(Game.EXTRA_APP_ID, app.getAppId());
+        intent.putExtra(Game.EXTRA_APP_HDR, app.isHdrSupported());
         intent.putExtra(Game.EXTRA_UNIQUEID, managerBinder.getUniqueId());
         intent.putExtra(Game.EXTRA_STREAMING_REMOTE,
                 computer.reachability != ComputerDetails.Reachability.LOCAL);
@@ -45,7 +43,7 @@ public class ServerHelper {
     }
 
     public static void doQuit(final Activity parent,
-                              final InetAddress address,
+                              final String address,
                               final NvApp app,
                               final ComputerManagerService.ComputerManagerBinder managerBinder,
                               final Runnable onComplete) {

app/src/main/java/com/limelight/utils/UiHelper.java

@@ -5,6 +5,7 @@ import android.app.AlertDialog;
 import android.app.UiModeManager;
 import android.content.Context;
 import android.content.DialogInterface;
+import android.content.SharedPreferences;
 import android.content.res.Configuration;
 import android.view.View;
 
@@ -58,6 +59,44 @@ public class UiHelper {
         }
     }
 
+    public static void showDecoderCrashDialog(Activity activity) {
+        final SharedPreferences prefs = activity.getSharedPreferences("DecoderTombstone", 0);
+        final int crashCount = prefs.getInt("CrashCount", 0);
+        int lastNotifiedCrashCount = prefs.getInt("LastNotifiedCrashCount", 0);
+
+        // Remember the last crash count we notified at, so we don't
+        // display the crash dialog every time the app is started until
+        // they stream again
+        if (crashCount != 0 && crashCount != lastNotifiedCrashCount) {
+            if (crashCount % 3 == 0) {
+                // At 3 consecutive crashes, we'll forcefully reset their settings
+                PreferenceConfiguration.resetStreamingSettings(activity);
+                Dialog.displayDialog(activity,
+                        activity.getResources().getString(R.string.title_decoding_reset),
+                        activity.getResources().getString(R.string.message_decoding_reset),
+                        new Runnable() {
+                            @Override
+                            public void run() {
+                                // Mark notification as acknowledged on dismissal
+                                prefs.edit().putInt("LastNotifiedCrashCount", crashCount).apply();
+                            }
+                        });
+            }
+            else {
+                Dialog.displayDialog(activity,
+                        activity.getResources().getString(R.string.title_decoding_error),
+                        activity.getResources().getString(R.string.message_decoding_error),
+                        new Runnable() {
+                            @Override
+                            public void run() {
+                                // Mark notification as acknowledged on dismissal
+                                prefs.edit().putInt("LastNotifiedCrashCount", crashCount).apply();
+                            }
+                        });
+            }
+        }
+    }
+
     public static void displayQuitConfirmationDialog(Activity parent, final Runnable onYes, final Runnable onNo) {
         DialogInterface.OnClickListener dialogClickListener = new DialogInterface.OnClickListener() {
             @Override

app/src/main/jni/Application.mk

@@ -1,10 +1,4 @@
-# Application.mk for Limelight
+# Application.mk for Moonlight
 
 # Our minimum version is Android 4.1
 APP_PLATFORM := android-16
-
-# Support all modern ABIs
-APP_ABI := armeabi-v7a arm64-v8a x86 x86_64 mips mips64
-
-# We want an optimized build
-APP_OPTIM := release

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

@@ -5,28 +5,32 @@ include $(call all-subdir-makefiles)
 
 LOCAL_PATH := $(MY_LOCAL_PATH)
 
-include $(CLEAR_VARS)
+# Only build evdev_reader for the rooted APK flavor
-LOCAL_MODULE    := evdev_reader
+ifeq (root,$(PRODUCT_FLAVOR))
-LOCAL_SRC_FILES := evdev_reader.c
+    include $(CLEAR_VARS)
-LOCAL_LDLIBS    := -llog
+    LOCAL_MODULE    := evdev_reader
+    LOCAL_SRC_FILES := evdev_reader.c
+    LOCAL_LDLIBS    := -llog
 
 
-# This next portion of the makefile is mostly copied from build-executable.mk but
+    # This next portion of the makefile is mostly copied from build-executable.mk but
-# creates a binary with the libXXX.so form so the APK will install and drop
+    # creates a binary with the libXXX.so form so the APK will install and drop
-# the binary correctly.
+    # the binary correctly.
 
-LOCAL_BUILD_SCRIPT := BUILD_EXECUTABLE
+    LOCAL_BUILD_SCRIPT := BUILD_EXECUTABLE
-LOCAL_MAKEFILE     := $(local-makefile)
+    LOCAL_MAKEFILE     := $(local-makefile)
 
-$(call check-defined-LOCAL_MODULE,$(LOCAL_BUILD_SCRIPT))
+    $(call check-defined-LOCAL_MODULE,$(LOCAL_BUILD_SCRIPT))
-$(call check-LOCAL_MODULE,$(LOCAL_MAKEFILE))
+    $(call check-LOCAL_MODULE,$(LOCAL_MAKEFILE))
-$(call check-LOCAL_MODULE_FILENAME)
+    $(call check-LOCAL_MODULE_FILENAME)
 
-# we are building target objects
+    # we are building target objects
-my := TARGET_
+    my := TARGET_
 
-$(call handle-module-filename,lib,$(TARGET_SONAME_EXTENSION))
+    $(call handle-module-filename,lib,$(TARGET_SONAME_EXTENSION))
-$(call handle-module-built)
+    $(call handle-module-built)
+
+    LOCAL_MODULE_CLASS := EXECUTABLE
+    include $(BUILD_SYSTEM)/build-module.mk
+endif
 
-LOCAL_MODULE_CLASS := EXECUTABLE
-include $(BUILD_SYSTEM)/build-module.mk

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

@@ -6,7 +6,7 @@
     android:paddingLeft="@dimen/activity_horizontal_margin"
     android:paddingRight="@dimen/activity_horizontal_margin"
     android:paddingTop="@dimen/activity_vertical_margin"
-    tools:context=".AddComputerManually" >
+    tools:context=".preferences.AddComputerManually" >
 
     <TextView
         android:id="@+id/manuallyAddPcText"

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

@@ -1,19 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:tools="http://schemas.android.com/tools"
-    android:id="@+id/activity_help"
-    android:layout_width="match_parent"
-    android:layout_height="match_parent"
-    android:paddingBottom="@dimen/activity_vertical_margin"
-    android:paddingLeft="@dimen/activity_horizontal_margin"
-    android:paddingRight="@dimen/activity_horizontal_margin"
-    android:paddingTop="@dimen/activity_vertical_margin"
-    tools:context="com.limelight.HelpActivity">
-
-    <WebView
-        android:layout_width="match_parent"
-        android:layout_height="match_parent"
-        android:layout_alignParentTop="true"
-        android:layout_alignParentLeft="true"
-        android:layout_alignParentStart="true" />
-</RelativeLayout>

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

@@ -1,3 +1,4 @@
+<!-- Portrait orientation only -->
 <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
     android:layout_width="match_parent"

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

@@ -7,6 +7,6 @@
     android:paddingTop="@dimen/activity_vertical_margin"
     android:paddingBottom="@dimen/activity_vertical_margin"
     android:id="@+id/stream_settings"
-    tools:context=".StreamSettings">
+    tools:context=".preferences.StreamSettings">
 
 </RelativeLayout>

app/src/main/res/mipmap-anydpi-v26/ic_launcher.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_launcher_background"/>
+    <foreground android:drawable="@mipmap/ic_launcher_foreground"/>
+</adaptive-icon>

app/src/main/res/mipmap-anydpi-v26/ic_pc_scut.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@color/ic_pc_scut_background"/>
+    <foreground android:drawable="@mipmap/ic_pc_scut_foreground"/>
+</adaptive-icon>

app/src/main/res/values-es/strings.xml

@@ -89,7 +89,7 @@
     <string name="summary_resolution_list">Establecer unos valores demasiado altos puede causar lag o cierres inesperados</string>
     <string name="title_seekbar_bitrate">Seleccionar bitrate de vídeo</string>
     <string name="summary_seekbar_bitrate">Usa bitrate bajo para reducir "parpadeo". Incrementa el bitrate para mayor calidad de imagen.</string>
-    <string name="suffix_seekbar_bitrate">Mbps</string>
+    <string name="suffix_seekbar_bitrate">Kbps</string>
     <string name="title_checkbox_stretch_video">Ajustar vídeo a pantalla completa</string>
     <string name="title_checkbox_disable_warnings">Desactivar mensajes de advertencia</string>
     <string name="summary_checkbox_disable_warnings">Desactivar mensajes de advertencia en pantalla durante la transmisión</string>
@@ -109,6 +109,8 @@
     <string name="category_on_screen_controls_settings">Configuración de controles en pantalla</string>
     <string name="title_checkbox_show_onscreen_controls">Mostrar controles en pantalla</string>
     <string name="summary_checkbox_show_onscreen_controls">Muestra controles virtuales superpuestos en la pantalla táctil</string>
+    <string name="title_only_l3r3">Solo muestra L3 y R3</string>
+    <string name="summary_only_l3r3">Ocultar todo excepto L3 y R3</string>
 
     <string name="category_ui_settings">Configuración de la interfaz</string>
     <string name="title_language_list">Idioma</string>

app/src/main/res/values-fr/strings.xml

@@ -100,7 +100,7 @@
     <string name="summary_resolution_list">Le réglage de valeurs trop élevées pour votre appareil peut provoquer un retard ou un plantage</string>
     <string name="title_seekbar_bitrate">Sélectionnez le bitrate vidéo à obtenir</string>
     <string name="summary_seekbar_bitrate">Bitrate inférieur pour réduire la saccade. Augmentez le bitrate pour augmenter la qualité de l\'image.</string>
-    <string name="suffix_seekbar_bitrate">Mbps</string>
+    <string name="suffix_seekbar_bitrate">Kbps</string>
     <string name="title_checkbox_stretch_video">Étirez la vidéo en plein écran</string>
     <string name="title_checkbox_disable_warnings">Désactiver les messages d\'avertissement</string>
     <string name="summary_checkbox_disable_warnings">Désactiver les messages d\'avertissement de connexion à l\'écran pendant le streaming</string>
@@ -120,6 +120,8 @@
     <string name="category_on_screen_controls_settings">Paramètres des contrôles à l\'écran</string>
     <string name="title_checkbox_show_onscreen_controls">Afficher les commandes à l\'écran</string>
     <string name="summary_checkbox_show_onscreen_controls">Afficher la superposition du contrôleur virtuel sur l\'écran tactile</string>
+    <string name="title_only_l3r3">Montre seulement L3 et R3</string>
+    <string name="summary_only_l3r3">Cacher tout sauf L3 et R3</string>
 
     <string name="category_ui_settings">Paramètres de l\'interface utilisateur</string>
     <string name="title_language_list">Langue</string>

app/src/main/res/values-it/strings.xml

@@ -1,5 +1,12 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
+    <!-- Shortcut strings -->
+    <string name="scut_deleted_pc">PC eliminato</string>
+    <string name="scut_not_paired">PC non accoppiato</string>
+
+    <!-- Help strings -->
+    <string name="help_loading_title">Visualizza assistenza</string>
+    <string name="help_loading_msg">Caricamento pagina di assistenza…</string>
 	
     <!-- PC view menu entries -->
     <string name="pcview_menu_app_list">Lista applicazioni</string>
@@ -10,21 +17,22 @@
 
     <!-- Pair messages -->
     <string name="pairing">Accoppiamento…</string>
-    <string name="pair_pc_offline">PC offline</string>
+    <string name="pair_pc_offline">Il PC è offline</string>
     <string name="pair_pc_ingame">PC con applicazione avviata. Devi chiudere l\'applicazione prima dell\'accoppiamento.</string>
     <string name="pair_pairing_title">Accoppiamento</string>
     <string name="pair_pairing_msg">Inserisci il seguente PIN sul PC:</string>
     <string name="pair_incorrect_pin">PIN non corretto</string>
     <string name="pair_fail">Accoppiamento fallito</string>
+    <string name="pair_already_in_progress">Accoppiamento già in corso</string>
 
     <!-- WOL messages -->
     <string name="wol_pc_online">PC già avviato</string>
-    <string name="wol_no_mac">Impossibile risvegliare il PC perchè GFE non ha inviato nessun indirizzo MAC</string>
+    <string name="wol_no_mac">Impossibile risvegliare il PC perché GFE non ha inviato nessun indirizzo MAC</string>
     <string name="wol_waking_pc">Risveglio PC…</string>
     <string name="wol_waking_msg">Il PC potrebbe impiegare qualche secondo per risvegliarsi.
-	    Se non succede niente, assicurati che l\'opzione Wake-On-LAN sia configurata correttamente.
+        Se non succede niente, assicurati che l\'opzione Wake-On-LAN sia configurata correttamente.
     </string>
-    <string name="wol_fail">Invio pacchetto Wake-On-LAN fallito</string>
+    <string name="wol_fail">Invio pacchetti Wake-On-LAN fallito</string>
 
     <!-- Unpair messages -->
     <string name="unpairing">Disaccoppiamento…</string>
@@ -37,33 +45,41 @@
     <string name="error_manager_not_running">Il servizio ComputerManager non è avviato. Attendi qualche secondo o riavvia l\'applicazione.</string>
     <string name="error_unknown_host">Risoluzione nome host fallita</string>
     <string name="error_404">GFE ha ritornato un errore HTTP 404 error. Assicurati che il PC stia usando una GPU supportata.
-	    Usare un software di remote-desktop può causare questo errore. Prova a riavviare il PC o a reinstallare GFE.
+        Usare un software di desktop remoto può causare questo errore. Prova a riavviare il PC o a reinstallare GFE.
     </string>
+    <string name="title_decoding_error">Il decodificatore video ha smesso di funzionare</string>
+    <string name="message_decoding_error">Moonlight ha smesso di funzionare per colpa di un problema al decodificatore video di questo dispositivo. Prova a modificare le impostazioni di stream se il problema persiste.</string>
+    <string name="title_decoding_reset">Ripristino impostazioni video</string>
+    <string name="message_decoding_reset">Il decodificatore video del dispositivo continua a funzionare in modo anomalo con le impostazioni di streaming selezionate. Le impostazioni di streaming sono state ripristinate ai valori predefiniti.</string>
+    <string name="error_usb_prohibited">L\'accesso USB è vietato dall\'amministratore del dispositivo. Verifica le impostazioni Knox o MDM.</string>
 
     <!-- Start application messages -->
-    <string name="conn_establishing_title">Connessione</string>
+    <string name="conn_establishing_title">Connessione in corso</string>
-    <string name="conn_establishing_msg">Connessione in corso</string>
+    <string name="conn_establishing_msg">Avvio connessione</string>
     <string name="conn_metered">Attenzione: la rete attiva prevede costi aggiuntivi in base all\'utilizzo!</string>
-    <string name="conn_client_latency">Latenza frame media client-side:</string>
+    <string name="conn_client_latency">Latenza decodifica fotogrammi media:</string>
-    <string name="conn_client_latency_hw">latenza decoder hardware:</string>
+    <string name="conn_client_latency_hw">latenza decodificatore hardware:</string>
-    <string name="conn_hardware_latency">Latenza decoder hardware media:</string>
+    <string name="conn_hardware_latency">Latenza decodificatore hardware media:</string>
     <string name="conn_starting">Avvio in corso…</string>
     <string name="conn_error_title">Errore connessione</string>
     <string name="conn_error_msg">Avvio fallito</string>
-    <string name="conn_terminated_title">Connessione terminata</string>
+    <string name="conn_terminated_title">Connessione interrotta</string>
     <string name="conn_terminated_msg">La connessione è stata interrotta</string>
 
     <!-- General strings -->
     <string name="ip_hint">Indirizzo IP del PC</string>
-    <string name="searching_pc">Ricerca PC in corso…</string>
+    <string name="searching_pc">Ricerca di PC con GameStream avviato…\n\n
+        Assicurati che GameStream sia abilitato nelle impostazioni SHIELD di GeForce Experience.</string>
     <string name="yes">Sì</string>
     <string name="no">No</string>
     <string name="lost_connection">Connessione con il PC persa</string>
+    <string name="help">Assistenza</string>
 
     <!-- AppList activity -->
     <string name="title_applist">Applicazioni su</string>
-    <string name="applist_menu_resume">Riprendi Sessione</string>
+    <string name="applist_connect_msg">Connessione al PC in corso…</string>
-    <string name="applist_menu_quit">Chiudi Sessione</string>
+    <string name="applist_menu_resume">Riprendi sessione</string>
+    <string name="applist_menu_quit">Chiudi sessione</string>
     <string name="applist_menu_quit_and_start">Chiudi sessione corrente e avvia</string>
     <string name="applist_menu_cancel">Annulla</string>
     <string name="applist_refresh_title">Lista applicazioni</string>
@@ -76,43 +92,74 @@
     <string name="applist_quit_confirmation">Sei sicuro di voler chiudere l\'applicazione avviata? Tutti i dati non salvati saranno persi.</string>
 
     <!-- Add computer manually activity -->
-    <string name="title_add_pc">Aggiungi PC Manualmente</string>
+    <string name="title_add_pc">Aggiungi PC manualmente</string>
     <string name="msg_add_pc">Connessione al PC in corso…</string>
-    <string name="addpc_fail">Impossibile connettersi al PC. Assicurati che il firewall del PC sia configurato correttamente.</string>
+    <string name="addpc_fail">Impossibile connettersi al PC specificato. Assicurati che le porte nel firewall del PC siano configurate correttamente.</string>
     <string name="addpc_success">PC aggiunto con successo</string>
     <string name="addpc_unknown_host">Impossibile risovere l\'indirizzo del PC. Assicurati di aver scritto correttamente l\'indirizzo.</string>
     <string name="addpc_enter_ip">Devi inserire un indirizzo IP</string>
+    <string name="addpc_wrong_sitelocal">Quell\'indirizzo non sembra corretto. È necessario utilizzare l\'indirizzo IP pubblico del router per lo streaming su Internet.</string>
 
     <!-- Preferences -->
-    <string name="category_basic_settings">Impostazioni Base</string>
+    <string name="category_basic_settings">Impostazioni generali</string>
     <string name="title_resolution_list">Risoluzione e FPS</string>
     <string name="summary_resolution_list">Valori troppo elevati possono causare lag o crash</string>
-    <string name="title_seekbar_bitrate">Bitrate video</string>
+    <string name="title_seekbar_bitrate">Velocità di trasmissione video</string>
-    <string name="summary_seekbar_bitrate">Abbassa il bitrate per ridurre lo stuttering; alza il bitrate per aumenteare la qualità dell\'immagine</string>
+    <string name="summary_seekbar_bitrate">Abbassa la velocità di trasmissione per ridurre lo stuttering; alzala per migliorare la qualità dell\'immagine</string>
-    <string name="suffix_seekbar_bitrate">Mbps</string>
+    <string name="suffix_seekbar_bitrate">Kbps</string>
-    <string name="title_checkbox_stretch_video">Forza video in full-screen</string>
+    <string name="title_checkbox_stretch_video">Forza video a schermo intero</string>
     <string name="title_checkbox_disable_warnings">Disabilita messaggi di warning</string>
     <string name="summary_checkbox_disable_warnings">Disabilita i messaggi di warning sullo schermo durante lo streaming</string>
+    <string name="title_checkbox_enable_pip">Abilita modalità spettatore Picture-in-Picture</string>
+    <string name="summary_checkbox_enable_pip">Permette di osservare (ma non di controllare) la stream in multitasking</string>
 
-    <string name="category_gamepad_settings">Impostazioni Gamepad</string>
+    <string name="category_audio_settings">Impostazioni audio</string>
-    <string name="title_checkbox_multi_controller">Supporto controller multipli</string>
+    <string name="title_checkbox_51_surround">Abilita l\'audio 5.1 surround</string>
-    <string name="summary_checkbox_multi_controller">Quando disabilitato, tutti i controllers appaiono come uno solo</string>
+    <string name="summary_checkbox_51_surround">Se riscontri problemi, disabilitalo. Richiede GFE 2.7 o versioni sucessive.</string>
-    <string name="title_seekbar_deadzone">Aggiusta deadzone degli stick analogici</string>
+
+    <string name="category_gamepad_settings">Impostazioni controller</string>
+    <string name="title_checkbox_multi_controller">Supporto a più controller</string>
+    <string name="summary_checkbox_multi_controller">Quando disabilitato, tutti i controller appaiono come uno solo</string>
+    <string name="title_seekbar_deadzone">Regola i punti morti degli stick analogici</string>
     <string name="suffix_seekbar_deadzone">%</string>
+    <string name="title_checkbox_xb1_driver">Driver del controller Xbox 360/One</string>
+    <string name="summary_checkbox_xb1_driver">Abilita un driver USB integrato per dispositivi senza supporto al controller Xbox nativo</string>
+    <string name="title_checkbox_usb_bind_all">Sovrascrivi il supporto ai controller su Android</string>
+    <string name="summary_checkbox_usb_bind_all">Forza i driver USB di Moonlight di assumere il controllo su tutti i controller Xbox supportati</string>
+    <string name="title_checkbox_mouse_emulation">Emulazione del mouse tramite controller</string>
+    <string name="summary_checkbox_mouse_emulation">Tenendo premuto il pulsante Start, il controller passerà alla modalità mouse</string>
 	
-    <string name="category_ui_settings">Impostazioni Interfaccia</string>
+    <string name="category_on_screen_controls_settings">Impostazioni dei controlli a schermo</string>
+    <string name="title_checkbox_show_onscreen_controls">Mostra controlli a schermo</string>
+    <string name="summary_checkbox_show_onscreen_controls">Mostra l\'overlay virtuale del controller su schermo</string>
+    <string name="title_only_l3r3">Mostra solo L3 e R3</string>
+    <string name="summary_only_l3r3">Nasconde tutti i pulsanti virtuali tranne L3 e R3</string>
+    <string name="title_reset_osc">Ripristina il layout personalizzato dei controlli a schermo</string>
+    <string name="summary_reset_osc">Ripristina tutti i controlli a schermo nelle loro posizioni e dimensioni predefinite</string>
+    <string name="dialog_title_reset_osc">Ripristino del layout</string>
+    <string name="dialog_text_reset_osc">Sei sicuro di voler ripristinare ai valori predefiniti i layout dei controlli a schermo?</string>
+    <string name="toast_reset_osc_success">I controlli a schermo sono stati ripristinati</string>
+
+    <string name="category_ui_settings">Impostazioni dell\'interfaccia</string>
     <string name="title_language_list">Lingua</string>
     <string name="summary_language_list">Lingua da usare in Moonlight</string>
     <string name="title_checkbox_list_mode">Usa lista invece della griglia</string>
-    <string name="summary_checkbox_list_mode">Visualizza applicazioni e computers in una lista invece di una griglia</string>
+    <string name="summary_checkbox_list_mode">Visualizza le applicazioni e i PC in una lista invece di una griglia</string>
     <string name="title_checkbox_small_icon_mode">Usa icone piccole</string>
-    <string name="summary_checkbox_small_icon_mode">Usa icone piccole nella vista a griglia per avere più oggetti sullo schermo</string>
+    <string name="summary_checkbox_small_icon_mode">Usa icone piccole nella griglia per avere più oggetti a schermo</string>
 
-    <string name="category_host_settings">Impostazioni Host</string>
+    <string name="category_host_settings">Impostazioni del PC host</string>
     <string name="title_checkbox_enable_sops">Ottimizza le impostazioni dei giochi</string>
     <string name="summary_checkbox_enable_sops">Permetti a GFE di modificare le impostazioni dei giochi per uno streaming ottimale</string>
     <string name="title_checkbox_host_audio">Riproduci audio sul PC</string>
-    <string name="summary_checkbox_host_audio">Riproduci l\'audio sul computer e su questo dispositivo</string>
+    <string name="summary_checkbox_host_audio">Riproduce l\'audio sul PC e su questo dispositivo</string>
+
+    <string name="category_advanced_settings">Impostazioni avanzate</string>
+    <string name="title_disable_frame_drop">Non saltare i fotogrammi</string>
+    <string name="summary_disable_frame_drop">Potrebbe ridurre il micro-stuttering su alcuni dispositivi, ma può aumentare la latenza</string>
+    <string name="title_video_format">Modifica impostazioni H.265</string>
+    <string name="summary_video_format">H.265 riduce i requisiti di larghezza di banda video ma richiede un dispositivo molto recente</string>
+    <string name="title_enable_hdr">Abilita HDR (sperimentale)</string>
+    <string name="summary_enable_hdr">Utilizza l\'HDR quando il gioco e la scheda video del PC lo supportano. L\'HDR richiede una scheda video serie GTX 1000 o sucessive.</string>
 	
-    <string name="category_advanced_settings">Impostazioni Avanzate</string>
 </resources>

app/src/main/res/values-ja/strings.xml

@@ -85,7 +85,7 @@
     <string name="summary_resolution_list">品質が高いほどラグとクラッシュが発生しやすくなります</string>
     <string name="title_seekbar_bitrate">映像のビットレート</string>
     <string name="summary_seekbar_bitrate">ビットレートを低くすればカクつきが抑制され、高くすれば画質が向上します</string>
-    <string name="suffix_seekbar_bitrate">Mbps</string>
+    <string name="suffix_seekbar_bitrate">Kbps</string>
     <string name="title_checkbox_stretch_video">映像を全画面に拡大</string>
     <string name="title_checkbox_disable_warnings">警告を無効化</string>
     <string name="summary_checkbox_disable_warnings">ストリーミング中に画面に警告メッセージを表示しない</string>

app/src/main/res/values-ko/strings.xml

@@ -100,7 +100,7 @@
     <string name="summary_resolution_list">세팅 값이 자신의 PC 성능보다 너무 높으면 렉이나 깨짐을 유발할 수 있습니다.</string>
     <string name="title_seekbar_bitrate">비트레이트 타겟 지정</string>
     <string name="summary_seekbar_bitrate">낮은 비트레이트는 끊김을 줄이고, 높은 비트레이트는 품질을 높입니다.</string>
-    <string name="suffix_seekbar_bitrate">Mbps</string>
+    <string name="suffix_seekbar_bitrate">Kbps</string>
     <string name="title_checkbox_stretch_video">전체 화면으로 렌더링 스크린 늘이기</string>
     <string name="title_checkbox_disable_warnings">경고 메세지 끄기</string>
     <string name="summary_checkbox_disable_warnings">화면 상의 연결 경고 메세지를 스트리밍 중에 비활성화합니다.</string>

app/src/main/res/values-nl/arrays.xml

@@ -1,14 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <resources>
-  <string-array name="resolution_names">
-    <item>720p 30 FPS</item>
-    <item>720p 60 FPS</item>
-    <item>1080p 30 FPS</item>
-    <item>1080p 60 FPS</item>
-    <item>4K 30 FPS</item>
-    <item>4K 60 FPS</item>
-  </string-array>
-
   <string-array name="decoder_names">
     <item>Selecteer Decoder Automatisch</item>
     <item>Forceer Software Decoderen</item>

app/src/main/res/values-nl/strings.xml

@@ -89,7 +89,7 @@
   <string name="summary_resolution_list">Te hoge instellingen kunnen crashes en haperingen veroorzaken.</string>
   <string name="title_seekbar_bitrate">Selecteer doel video bitsnelheid</string>
   <string name="summary_seekbar_bitrate">Verlaag bitsnelheid om haperingen te verminderen. Verhoog de bitsnelheid voor een betere videokwaliteit.</string>
-  <string name="suffix_seekbar_bitrate">Mbps</string>
+  <string name="suffix_seekbar_bitrate">Kbps</string>
   <string name="title_checkbox_stretch_video">Rek video uit tot volledig scherm</string>
   <string name="title_checkbox_disable_warnings">Verberg waarschuwingsberichten</string>
   <string name="summary_checkbox_disable_warnings">Verberg on-screen verbindingswaarschuwingen tijdens het streamen</string>

app/src/main/res/values-ru/strings.xml

@@ -28,7 +28,7 @@
 
     <!-- Unpair messages -->
     <string name="unpairing">Разрыв пары…</string>
-    <string name="unpair_success">Разрыв пары закончился успешно.</string>
+    <string name="unpair_success">Разрыв пары закончился успешно</string>
     <string name="unpair_fail">Разрыв пары не удался</string>
     <string name="unpair_error">Устройство не было спарено</string>
 
@@ -36,14 +36,14 @@
     <string name="error_pc_offline">Компьютер выключен или находится не в сети</string>
     <string name="error_manager_not_running">Сервис ComputerManager не запущен. Пожалуйста, подождите несколько секунд или перезапустите приложение.</string>
     <string name="error_unknown_host">Не удалось найти хост</string>
-    <string name="error_404">GFE вернул ошибку HTTP 404. Убедитесь что ваш PC is испольщует поддерживаемый GPU.
+    <string name="error_404">GFE вернул ошибку HTTP 404. Убедитесь что Ваш PC использует поддерживаемый GPU.
-	    Использование программ для удалённого доступа также можнт вызывать эту ошибку. Попробуйте перезагрузить компьютер или переустановить GFE.
+	    Использование программ для удалённого доступа также может вызывать эту ошибку. Попробуйте перезагрузить компьютер или переустановить GFE.
     </string>
 
     <!-- Start application messages -->
-    <string name="conn_establishing_title">Создание соединения.</string>
+    <string name="conn_establishing_title">Создание соединения</string>
     <string name="conn_establishing_msg">Подключение</string>
-    <string name="conn_metered">Внимание: Происходит измерение вашего сетевого соединения!</string>
+    <string name="conn_metered">Внимание: Происходит измерение Вашего сетевого соединения!</string>
     <string name="conn_client_latency">Средняя задержка декодирования кадра: </string>
     <string name="conn_client_latency_hw">задержка аппаратного декодирования:</string>
     <string name="conn_hardware_latency">Средняя задержка апаратного декодирования:</string>
@@ -54,8 +54,9 @@
     <string name="conn_terminated_msg">Подключение было прервано</string>
 
     <!-- General strings -->
-    <string name="ip_hint">IP адресс компьютера с GeForce</string>
+    <string name="ip_hint">IP-адрес компьютера с GeForce</string>
-    <string name="searching_pc">Поиск компьютеров…</string>
+    <string name="searching_pc">Поиск компьютеров с запущенным GameStream…\n\n
+        Убедитесь что GameStream включен в настройках GeForce Experience в разделе SHIELD.</string>
     <string name="yes">Да</string>
     <string name="no">Нет</string>
     <string name="lost_connection">Потеряно соединение с PC</string>
@@ -79,49 +80,82 @@
     <string name="title_add_pc">Добавление PC вручную</string>
     <string name="msg_add_pc">Соединение с PC…</string>
     <string name="addpc_fail">Не удалось подключиться к выбранному компьютеру. Удостоверьтесь, что необходимые порты разрешены в настройках брандмауэра.</string>
-    <string name="addpc_success">Компьютер добавлен успешно.</string>
+    <string name="addpc_success">Компьютер добавлен успешно</string>
-    <string name="addpc_unknown_host">Не удалось найти PC по указанному адресу. Убедитесь, что вы не совершили ошибок во время его написания.</string>
+    <string name="addpc_unknown_host">Не удалось найти PC по указанному адресу. Убедитесь, что Вы не совершили ошибок во время его написания.</string>
     <string name="addpc_enter_ip">Вы должны ввести IP адрес</string>
 
     <!-- Preferences -->
-    <string name="category_basic_settings">Базовые Настройки</string>
+    <string name="category_basic_settings">Общие Настройки</string>
-    <string name="title_resolution_list">Выберите разрешение и частоту кадров.</string>
+    <string name="title_resolution_list">Выберите разрешение и частоту кадров</string>
-    <string name="summary_resolution_list">Выбор слишком высокого значеня для своего устройства может вызвать тормоза или вылеты.</string>
+    <string name="summary_resolution_list">Выбор слишком высокого значеня для своего устройства может вызвать тормоза или вылеты</string>
-    <string name="title_seekbar_bitrate">Выберите битрейт видео.</string>
+    <string name="title_seekbar_bitrate">Выберите битрейт видео</string>
     <string name="summary_seekbar_bitrate">Низкий битрейт уменьшит зависания. Увеличение битрейта улучшит качество изображения.</string>
-    <string name="suffix_seekbar_bitrate">Mbps</string>
+    <string name="suffix_seekbar_bitrate">Kbps</string>
     <string name="title_checkbox_stretch_video">Растягивать видео на весь экран</string>
     <string name="title_checkbox_disable_warnings">Отключить сообщения с предупреждениями</string>
-    <string name="summary_checkbox_disable_warnings">Выключить экранные предупреждения о соединении во время стрима.</string>
+    <string name="summary_checkbox_disable_warnings">Выключить экранные предупреждения о соединении во время трансляции</string>
 
     <string name="category_audio_settings">Аудио Настройки</string>
     <string name="title_checkbox_51_surround">Включить объёмный звук 5.1</string>
     <string name="summary_checkbox_51_surround">Отключите, если появляются аудио проблемы. Требуется GFE 2.7 или выше.</string>
 
-    <string name="category_gamepad_settings">Настройки Гемпада</string>
+    <string name="category_gamepad_settings">Настройки Геймпада</string>
     <string name="title_checkbox_multi_controller">Поддержка нескольких контроллеров</string>
-    <string name="summary_checkbox_multi_controller">Когда отключена, все контроллеры определяются как один. </string>
+    <string name="summary_checkbox_multi_controller">Когда отключена, все контроллеры определяются как один</string>
-    <string name="title_seekbar_deadzone">Регулировать мертвую зону аналогового стика.</string>
+    <string name="title_seekbar_deadzone">Регулировать мертвую зону аналогового стика</string>
     <string name="suffix_seekbar_deadzone">%</string>
-    <string name="title_checkbox_xb1_driver">Драйвер контроллера от Xbox One</string>
+    <string name="title_checkbox_xb1_driver">Драйвер контроллеров Xbox 360/One</string>
-    <string name="summary_checkbox_xb1_driver">Включить встроенный USB драйвер для устройств без встроенной поддержки контроллера от Xbox One.</string>
+    <string name="summary_checkbox_xb1_driver">Включить встроенный USB драйвер для устройств без собственной поддержки контроллеров Xbox</string>
 
     <string name="category_ui_settings">Настройки Интерфейса</string>
     <string name="title_language_list">Язык</string>
     <string name="summary_language_list">Язык, который будет использоваться в Moonlight</string>
-    <string name="title_checkbox_list_mode">Использовать списки вместо сеток.</string>
+    <string name="title_checkbox_list_mode">Использовать списки вместо сеток</string>
-    <string name="summary_checkbox_list_mode">Выводить приложения и компьютеры списком, вместо использования сетки.</string>
+    <string name="summary_checkbox_list_mode">Выводить приложения и компьютеры списком, вместо использования сетки</string>
     <string name="title_checkbox_small_icon_mode">Использовать маленькие иконки</string>
-    <string name="summary_checkbox_small_icon_mode">Использовать маленькие иконки в сетки для увеличения числа элементов, отображаемых на экране.</string>
+    <string name="summary_checkbox_small_icon_mode">Использовать маленькие иконки в сетке для отображения большего числа элементов на экране</string>
 
     <string name="category_host_settings">Настройки Хоста</string>
     <string name="title_checkbox_enable_sops">Оптимизировать игровые настройки</string>
-    <string name="summary_checkbox_enable_sops">Разрешить GFE изменять настройки игр для оптимальной потоковой передачи</string>
+    <string name="summary_checkbox_enable_sops">Разрешить GFE изменять настройки игр для оптимальной трансляции</string>
     <string name="title_checkbox_host_audio">Проигрывать звук на PC</string>
-    <string name="summary_checkbox_host_audio">Проигрывать звук на компьютере и текущем устройстве.</string>
+    <string name="summary_checkbox_host_audio">Проигрывать звук на компьютере и текущем устройстве</string>
 
     <string name="category_advanced_settings">Расширенные Настройки</string>
     <string name="title_video_format">Изменить настройки H.265</string>
-    <string name="summary_video_format">H.265 снижает требования к пропускной способности, но требует очень свежих устройств.</string>
+    <string name="summary_video_format">H.265 снижает требования к пропускной способности, но требует очень нового устройства</string>
+    <string name="category_on_screen_controls_settings">Настройки Экранных Кнопок</string>
+    <string name="title_checkbox_show_onscreen_controls">Показывать экранные кнопки</string>
+    <string name="summary_checkbox_show_onscreen_controls">Отображать оверлей виртуального контроллера на сенсорном экране</string>
+    <string name="title_only_l3r3">Показывать только L3 и R3</string>
+    <string name="summary_only_l3r3">Скрывать все экранные кнопки кроме L3 и R3</string>
+    <string name="scut_deleted_pc">PC удален</string>
+    <string name="scut_not_paired">PC не сопряжен</string>
+    <string name="help_loading_title">Просмотр Помощи</string>
+    <string name="help_loading_msg">Загрузка страницы помощи…</string>
+    <string name="pair_already_in_progress">Сопряжение уже в процессе</string>
+    <string name="help">Помощь</string>
+    <string name="applist_connect_msg">Подключение к PC…</string>
+    <string name="title_decoding_error">Сбой Видео Декодера</string>
+    <string name="message_decoding_error">Произошел сбой Moonlight из-за проблем с видео декодером данного устройства. Попробуйте изменить настройки трансляции если сбои будут продолжаться.</string>
+    <string name="title_decoding_reset">Видео Настройки Сброшены</string>
+    <string name="message_decoding_reset">Видео декодер Вашего устройства давал сбои с выбранными настройками. Настройки трансляции были сброшены до значений по умолчанию.</string>
+    <string name="error_usb_prohibited">USB доступ запрещен администратором устройства. Проверьте настройки Knox или MDM.</string>
+    <string name="addpc_wrong_sitelocal">Адрес указан неверно. Вы должны ввести публичный IP-адрес Вашего роутера для передачи через интернет.</string>
+    <string name="title_checkbox_enable_pip">Включить просмотр в режиме \"Картинка в картинке\"</string>
+    <string name="summary_checkbox_enable_pip">Позволяет просматривать трансляцию (но не управлять ей) во время работы в других приложениях</string>
+    <string name="title_checkbox_usb_bind_all">Переопределить поддержку контроллеров Android</string>
+    <string name="summary_checkbox_usb_bind_all">Заставляет USB драйвер Moonlight взять на себя работу со всеми поддерживаемыми Xbox геймпадами</string>
+    <string name="title_checkbox_mouse_emulation">Эмуляция мыши на геймпаде</string>
+    <string name="summary_checkbox_mouse_emulation">Долгое нажатие кнопки Start переключит геймпад в режим мыши</string>
+    <string name="title_reset_osc">Сбросить схему расположения экранных кнопок</string>
+    <string name="summary_reset_osc">Возвращает все экранные элементы управления к их расположениям по умолчанию</string>
+    <string name="dialog_title_reset_osc">Сбросить Схему</string>
+    <string name="dialog_text_reset_osc">Вы уверены что хотите удалить сохранненную схему расположения кнопок?</string>
+    <string name="toast_reset_osc_success">Экранные элементы управления возвращены к положениям по умолчанию</string>
+    <string name="title_disable_frame_drop">Никогда не пропускать кадры</string>
+    <string name="summary_disable_frame_drop">Может уменьшить микрозависания на некоторых устройствах, но также увеличить задержку</string>
+    <string name="title_enable_hdr">Включить HDR (Экспериментально)</string>
+    <string name="summary_enable_hdr">Транслировать в HDR если игра и GPU компьютера поддерживают это. HDR требует видеокарты GTX 1000 серии или более новой.</string>
 
 </resources>