Bump version to 4.0.4

Hide on-screen controls preference until bugs are resolved
Disable on-screen controls by default
2016-01-07 16:08:08 -06:00 · 2016-01-07 16:01:33 -06:00 · 2016-01-07 12:57:59 -06:00 · 2016-01-07 12:57:37 -06:00 · 2016-01-07 12:49:30 -06:00 · 2016-01-07 02:23:34 -06:00
24 changed files with 2091 additions and 84 deletions
@@ -11,8 +11,8 @@ android {
        minSdkVersion 16
        targetSdkVersion 23

-        versionName "4.0.2"
-        versionCode = 79
+        versionName "4.0.4"
+        versionCode = 82
    }

    productFlavors {
@@ -76,6 +76,7 @@
                android:name="android.support.PARENT_ACTIVITY"
                android:value="com.limelight.AppView" />
        </activity>
+
        <service
            android:name=".discovery.DiscoveryService"
            android:label="mDNS PC Auto-Discovery Service" />
@@ -8,6 +8,7 @@ import com.limelight.binding.input.TouchContext;
 import com.limelight.binding.input.driver.UsbDriverService;
 import com.limelight.binding.input.evdev.EvdevHandler;
 import com.limelight.binding.input.evdev.EvdevListener;
+import com.limelight.binding.input.virtual_controller.VirtualController;
 import com.limelight.binding.video.EnhancedDecoderRenderer;
 import com.limelight.binding.video.MediaCodecDecoderRenderer;
 import com.limelight.binding.video.MediaCodecHelper;
@@ -53,6 +54,7 @@ import android.view.View.OnTouchListener;
 import android.view.ViewGroup;
 import android.view.Window;
 import android.view.WindowManager;
+import android.widget.FrameLayout;
 import android.view.inputmethod.InputMethodManager;
 import android.widget.Toast;

@@ -77,6 +79,7 @@ public class Game extends Activity implements SurfaceHolder.Callback,
    private static final int THREE_FINGER_TAP_THRESHOLD = 300;

    private ControllerHandler controllerHandler;
+    private VirtualController virtualController;
    private KeyboardTranslator keybTranslator;

    private PreferenceConfiguration prefConfig;
@@ -284,6 +287,14 @@ public class Game extends Activity implements SurfaceHolder.Callback,
            evdevHandler.start();
        }

+        if (prefConfig.onscreenController) {
+            // create virtual onscreen controller
+            virtualController = new VirtualController(conn,
+                    (FrameLayout)findViewById(R.id.surfaceView).getParent(),
+                    this);
+            virtualController.refreshLayout();
+        }
+
        if (prefConfig.usbDriver) {
            // Start the USB driver
            bindService(new Intent(this, UsbDriverService.class),
@@ -307,6 +318,11 @@ public class Game extends Activity implements SurfaceHolder.Callback,

        // Apply the size change
        sv.setLayoutParams(lp);
+
+        // refresh virtual controller layout
+        if (virtualController != null) {
+            virtualController.refreshLayout();
+        }
    }

    private void checkDataConnection()
@@ -354,8 +370,10 @@ public class Game extends Activity implements SurfaceHolder.Callback,
        SpinnerDialog.closeDialogs(this);
        Dialog.closeDialogs();

-        InputManager inputManager = (InputManager) getSystemService(Context.INPUT_SERVICE);
-        inputManager.unregisterInputDeviceListener(controllerHandler);
+        if (controllerHandler != null) {
+            InputManager inputManager = (InputManager) getSystemService(Context.INPUT_SERVICE);
+            inputManager.unregisterInputDeviceListener(controllerHandler);
+        }

        wifiLock.release();

@@ -364,36 +382,38 @@ public class Game extends Activity implements SurfaceHolder.Callback,
            unbindService(usbDriverServiceConnection);
        }

-        VideoDecoderRenderer.VideoFormat videoFormat = conn.getActiveVideoFormat();
+        if (conn != null) {
+            VideoDecoderRenderer.VideoFormat videoFormat = conn.getActiveVideoFormat();

-        displayedFailureDialog = true;
-        stopConnection();
+            displayedFailureDialog = true;
+            stopConnection();

-        int averageEndToEndLat = decoderRenderer.getAverageEndToEndLatency();
-        int averageDecoderLat = decoderRenderer.getAverageDecoderLatency();
-        String message = null;
-        if (averageEndToEndLat > 0) {
-            message = getResources().getString(R.string.conn_client_latency)+" "+averageEndToEndLat+" ms";
-            if (averageDecoderLat > 0) {
-                message += " ("+getResources().getString(R.string.conn_client_latency_hw)+" "+averageDecoderLat+" ms)";
+            int averageEndToEndLat = decoderRenderer.getAverageEndToEndLatency();
+            int averageDecoderLat = decoderRenderer.getAverageDecoderLatency();
+            String message = null;
+            if (averageEndToEndLat > 0) {
+                message = getResources().getString(R.string.conn_client_latency)+" "+averageEndToEndLat+" ms";
+                if (averageDecoderLat > 0) {
+                    message += " ("+getResources().getString(R.string.conn_client_latency_hw)+" "+averageDecoderLat+" ms)";
+                }
            }
-        }
-        else if (averageDecoderLat > 0) {
-            message = getResources().getString(R.string.conn_hardware_latency)+" "+averageDecoderLat+" ms";
-        }
-
-        // Add the video codec to the post-stream toast
-        if (message != null && videoFormat != VideoDecoderRenderer.VideoFormat.Unknown) {
-            if (videoFormat == VideoDecoderRenderer.VideoFormat.H265) {
-                message += " [H.265]";
+            else if (averageDecoderLat > 0) {
+                message = getResources().getString(R.string.conn_hardware_latency)+" "+averageDecoderLat+" ms";
            }
-            else {
-                message += " [H.264]";
-            }
-        }

-        if (message != null) {
-            Toast.makeText(this, message, Toast.LENGTH_LONG).show();
+            // Add the video codec to the post-stream toast
+            if (message != null && videoFormat != VideoDecoderRenderer.VideoFormat.Unknown) {
+                if (videoFormat == VideoDecoderRenderer.VideoFormat.H265) {
+                    message += " [H.265]";
+                }
+                else {
+                    message += " [H.264]";
+                }
+            }
+
+            if (message != null) {
+                Toast.makeText(this, message, Toast.LENGTH_LONG).show();
+            }
        }

        finish();
@@ -362,7 +362,7 @@ public class ControllerHandler implements InputManager.InputDeviceListener, UsbD
            }
            // Samsung's face buttons appear as a non-virtual button so we'll explicitly ignore
            // back presses on this device
-            else if (devName.equals("sec_touchscreen")) {
+            else if (devName.equals("sec_touchscreen") || devName.equals("sec_touchkey")) {
                context.ignoreBack = true;
            }
            // The Serval has a couple of unknown buttons that are start and select. It also has
@@ -12,6 +12,8 @@ import android.hardware.usb.UsbManager;
 import android.os.Binder;
 import android.os.IBinder;

+import com.limelight.LimeLog;
+
 import java.util.ArrayList;

 public class UsbDriverService extends Service implements UsbDriverListener {
@@ -110,6 +112,10 @@ public class UsbDriverService extends Service implements UsbDriverListener {

            // Open the device
            UsbDeviceConnection connection = usbManager.openDevice(device);
+            if (connection == null) {
+                LimeLog.warning("Unable to open USB device: "+device.getDeviceName());
+                return;
+            }

            // Try to initialize it
            XboxOneController controller = new XboxOneController(device, connection, nextDeviceId++, this);
@@ -2,10 +2,15 @@ package com.limelight.binding.input.evdev;

 import android.content.Context;

+import com.limelight.LimeLog;
+
+import java.io.DataOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
+import java.net.ServerSocket;
+import java.net.Socket;

 public class EvdevHandler {

@@ -15,7 +20,9 @@ public class EvdevHandler {
    private boolean shutdown = false;
    private InputStream evdevIn;
    private OutputStream evdevOut;
-    private Process reader;
+    private Process su;
+    private ServerSocket servSock;
+    private Socket evdevSock;

    private static final byte UNGRAB_REQUEST = 1;
    private static final byte REGRAB_REQUEST = 2;
@@ -27,19 +34,45 @@ public class EvdevHandler {
            int deltaY = 0;
            byte deltaScroll = 0;

-            // Launch the evdev reader shell
-            ProcessBuilder builder = new ProcessBuilder("su", "-c", libraryPath+File.separatorChar+"libevdev_reader.so");
-            builder.redirectErrorStream(false);
-
+            // Bind a local listening socket for evdevreader to connect to
            try {
-                reader = builder.start();
+                servSock = new ServerSocket(0, 1);
            } catch (IOException e) {
                e.printStackTrace();
                return;
            }

-            evdevIn = reader.getInputStream();
-            evdevOut = reader.getOutputStream();
+            // Launch a su shell
+            ProcessBuilder builder = new ProcessBuilder("su");
+            builder.redirectErrorStream(true);
+
+            try {
+                su = builder.start();
+            } catch (IOException e) {
+                e.printStackTrace();
+                return;
+            }
+
+            // Start evdevreader
+            DataOutputStream suOut = new DataOutputStream(su.getOutputStream());
+            try {
+                suOut.writeChars(libraryPath+File.separatorChar+"libevdev_reader.so "+servSock.getLocalPort()+"\n");
+            } catch (IOException e) {
+                e.printStackTrace();
+                return;
+            }
+
+            // Wait for evdevreader's connection
+            LimeLog.info("Waiting for EvdevReader connection to port "+servSock.getLocalPort());
+            try {
+                evdevSock = servSock.accept();
+                evdevIn = evdevSock.getInputStream();
+                evdevOut = evdevSock.getOutputStream();
+            } catch (IOException e) {
+                e.printStackTrace();
+                return;
+            }
+            LimeLog.info("EvdevReader connected from port "+evdevSock.getPort());

            while (!isInterrupted() && !shutdown) {
                EvdevEvent event;
@@ -159,6 +192,22 @@ public class EvdevHandler {
        shutdown = true;
        handlerThread.interrupt();

+        if (servSock != null) {
+            try {
+                servSock.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
+        if (evdevSock != null) {
+            try {
+                evdevSock.close();
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
+
        if (evdevIn != null) {
            try {
                evdevIn.close();
@@ -175,8 +224,8 @@ public class EvdevHandler {
            }
        }

-        if (reader != null) {
-            reader.destroy();
+        if (su != null) {
+            su.destroy();
        }

        try {
@@ -0,0 +1,359 @@
+/**
+ * Created by Karim Mreisi.
+ */
+
+package com.limelight.binding.input.virtual_controller;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.view.MotionEvent;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * This is a analog stick on screen element. It is used to get 2-Axis user input.
+ */
+public class AnalogStick extends VirtualControllerElement {
+
+    /**
+     * outer radius size in percent of the ui element
+     */
+    public static final int SIZE_RADIUS_COMPLETE = 90;
+    /**
+     * analog stick size in percent of the ui element
+     */
+    public static final int SIZE_RADIUS_ANALOG_STICK = 90;
+    /**
+     * dead zone size in percent of the ui element
+     */
+    public static final int SIZE_RADIUS_DEADZONE = 90;
+    /**
+     * time frame for a double click
+     */
+    public final static long timeoutDoubleClick = 250;
+
+    /**
+     * Listener interface to update registered observers.
+     */
+    public interface AnalogStickListener {
+
+        /**
+         * onMovement event will be fired on real analog stick movement (outside of the deadzone).
+         *
+         * @param x horizontal position, value from -1.0 ... 0 .. 1.0
+         * @param y vertical position, value from -1.0 ... 0 .. 1.0
+         */
+        void onMovement(float x, float y);
+
+        /**
+         * onClick event will be fired on click on the analog stick
+         */
+        void onClick();
+
+        /**
+         * onDoubleClick event will be fired on a double click in a short time frame on the analog
+         * stick.
+         */
+        void onDoubleClick();
+
+        /**
+         * onRevoke event will be fired on unpress of the analog stick.
+         */
+        void onRevoke();
+    }
+
+    /**
+     * Movement states of the analog sick.
+     */
+    private enum STICK_STATE {
+        NO_MOVEMENT,
+        MOVED_IN_DEAD_ZONE,
+        MOVED_ACTIVE
+    }
+
+    /**
+     * Click type states.
+     */
+    private enum CLICK_STATE {
+        SINGLE,
+        DOUBLE
+    }
+
+    /**
+     * configuration if the analog stick should be displayed as circle or square
+     */
+    private boolean circle_stick = true; // TODO: implement square sick for simulations
+
+    /**
+     * outer radius, this size will be automatically updated on resize
+     */
+    private float radius_complete = 0;
+    /**
+     * analog stick radius, this size will be automatically updated on resize
+     */
+    private float radius_analog_stick = 0;
+    /**
+     * dead zone radius, this size will be automatically updated on resize
+     */
+    private float radius_dead_zone = 0;
+
+    /**
+     * horizontal position in relation to the center of the element
+     */
+    private float relative_x = 0;
+    /**
+     * vertical position in relation to the center of the element
+     */
+    private float relative_y = 0;
+
+
+    private double movement_radius = 0;
+    private double movement_angle = 0;
+
+    private float position_stick_x = 0;
+    private float position_stick_y = 0;
+
+    private final Paint paint = new Paint();
+
+    private STICK_STATE stick_state = STICK_STATE.NO_MOVEMENT;
+    private CLICK_STATE click_state = CLICK_STATE.SINGLE;
+
+    private List<AnalogStickListener> listeners = new ArrayList<>();
+    private long timeLastClick = 0;
+
+    private static double getMovementRadius(float x, float y) {
+        // corner cases
+        if (x == 0) {
+            return y > 0 ? y : -y;
+        }
+        if (y == 0) {
+            return x > 0 ? x : -x;
+        }
+        // return hypotenuse (pythagoras)
+        return Math.sqrt(x * x + y * y);
+    }
+
+    private static double getAngle(float way_x, float way_y) {
+        // prevent divisions by zero for corner cases
+        if (way_x == 0) {
+            return way_y < 0 ? Math.PI : 0;
+        } else if (way_y == 0) {
+            if (way_x > 0) {
+                return Math.PI * 3 / 2;
+            } else if (way_x < 0) {
+                return Math.PI * 1 / 2;
+            }
+        }
+        // return correct calculated angle for each quadrant
+        if (way_x > 0) {
+            if (way_y < 0) {
+                // first quadrant
+                return 3 * Math.PI / 2 + Math.atan((double) (-way_y / way_x));
+            } else {
+                // second quadrant
+                return Math.PI + Math.atan((double) (way_x / way_y));
+            }
+        } else {
+            if (way_y > 0) {
+                // third quadrant
+                return Math.PI / 2 + Math.atan((double) (way_y / -way_x));
+            } else {
+                // fourth quadrant
+                return 0 + Math.atan((double) (-way_x / -way_y));
+            }
+        }
+    }
+
+    public AnalogStick(VirtualController controller, Context context) {
+        super(controller, context);
+        // reset stick position
+        position_stick_x = getWidth() / 2;
+        position_stick_y = getHeight() / 2;
+    }
+
+    public void addAnalogStickListener(AnalogStickListener listener) {
+        listeners.add(listener);
+    }
+
+    private void notifyOnMovement(float x, float y) {
+        _DBG("movement x: " + x + " movement y: " + y);
+        // notify listeners
+        for (AnalogStickListener listener : listeners) {
+            listener.onMovement(x, y);
+        }
+    }
+
+    private void notifyOnClick() {
+        _DBG("click");
+        // notify listeners
+        for (AnalogStickListener listener : listeners) {
+            listener.onClick();
+        }
+    }
+
+    private void notifyOnDoubleClick() {
+        _DBG("double click");
+        // notify listeners
+        for (AnalogStickListener listener : listeners) {
+            listener.onDoubleClick();
+        }
+    }
+
+    private void notifyOnRevoke() {
+        _DBG("revoke");
+        // notify listeners
+        for (AnalogStickListener listener : listeners) {
+            listener.onRevoke();
+        }
+    }
+
+    public void setColors(int normalColor, int pressedColor) {
+        this.normalColor = normalColor;
+        this.pressedColor = pressedColor;
+    }
+
+    @Override
+    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
+        // calculate new radius sizes depending
+        radius_complete = getPercent(getCorrectWidth() / 2, 90);
+        radius_dead_zone = getPercent(getCorrectWidth() / 2, 30);
+        radius_analog_stick = getPercent(getCorrectWidth() / 2, 20);
+
+        super.onSizeChanged(w, h, oldw, oldh);
+    }
+
+    @Override
+    protected void onElementDraw(Canvas canvas) {
+        // set transparent background
+        canvas.drawColor(Color.TRANSPARENT);
+
+        paint.setStyle(Paint.Style.STROKE);
+        paint.setStrokeWidth(getPercent(getCorrectWidth() / 2, 2));
+
+        // draw outer circle
+        if (!isPressed() || click_state == CLICK_STATE.SINGLE) {
+            paint.setColor(normalColor);
+        } else {
+            paint.setColor(pressedColor);
+        }
+        canvas.drawCircle(getWidth() / 2, getHeight() / 2, radius_complete, paint);
+
+        paint.setColor(normalColor);
+        // draw dead zone
+        canvas.drawCircle(getWidth() / 2, getHeight() / 2, radius_dead_zone, paint);
+
+        // draw stick depending on state
+        switch (stick_state) {
+            case NO_MOVEMENT: {
+                paint.setColor(normalColor);
+                canvas.drawCircle(getWidth() / 2, getHeight() / 2, radius_analog_stick, paint);
+                break;
+            }
+            case MOVED_IN_DEAD_ZONE: {
+                paint.setColor(normalColor);
+                canvas.drawCircle(position_stick_x, position_stick_y, radius_analog_stick, paint);
+
+                break;
+            }
+            case MOVED_ACTIVE: {
+                paint.setColor(pressedColor);
+                canvas.drawCircle(position_stick_x, position_stick_y, radius_analog_stick, paint);
+                break;
+            }
+        }
+    }
+
+    private void updatePosition() {
+        // get 100% way
+        float complete = (radius_complete - radius_analog_stick - radius_dead_zone);
+
+        // calculate relative way
+        float correlated_y = (float) (Math.sin(Math.PI / 2 - movement_angle) * (movement_radius));
+        float correlated_x = (float) (Math.cos(Math.PI / 2 - movement_angle) * (movement_radius));
+
+        // update positions
+        position_stick_x = getWidth() / 2 - correlated_x;
+        position_stick_y = getHeight() / 2 - correlated_y;
+
+        // set active depending on dead zone
+        stick_state = movement_radius > radius_dead_zone ?
+                STICK_STATE.MOVED_ACTIVE : STICK_STATE.MOVED_IN_DEAD_ZONE;
+
+        //  trigger move event if state active
+        if (stick_state == STICK_STATE.MOVED_ACTIVE) {
+            notifyOnMovement(-(1 / complete) *
+                    (correlated_x - (correlated_x > 0 ? radius_dead_zone : -radius_dead_zone)), (1 / complete) *
+                    (correlated_y - (correlated_y > 0 ? radius_dead_zone : -radius_dead_zone)));
+        }
+    }
+
+    @Override
+    public boolean onElementTouchEvent(MotionEvent event) {
+        // save last click state
+        CLICK_STATE lastClickState = click_state;
+
+        // get absolute way for each axis
+        relative_x = -(getWidth() / 2 - event.getX());
+        relative_y = -(getHeight() / 2 - event.getY());
+
+        // get radius and angel of movement from center
+        movement_radius = getMovementRadius(relative_x, relative_y);
+        movement_angle = getAngle(relative_x, relative_y);
+
+        // chop radius if out of outer circle and already pressed
+        if (movement_radius > (radius_complete - radius_analog_stick)) {
+            // not pressed already, so ignore event from outer circle
+            if (!isPressed()) {
+                return false;
+            }
+            movement_radius = radius_complete - radius_analog_stick;
+        }
+
+        // handle event depending on action
+        switch (event.getActionMasked()) {
+            // down event (touch event)
+            case MotionEvent.ACTION_DOWN:
+            case MotionEvent.ACTION_POINTER_DOWN: {
+                // set to dead zoned, will be corrected in update position if necessary
+                stick_state = STICK_STATE.MOVED_IN_DEAD_ZONE;
+                // check for double click
+                if (lastClickState == CLICK_STATE.SINGLE &&
+                        timeLastClick + timeoutDoubleClick > System.currentTimeMillis()) {
+                    click_state = CLICK_STATE.DOUBLE;
+                    notifyOnDoubleClick();
+                } else {
+                    click_state = CLICK_STATE.SINGLE;
+                    notifyOnClick();
+                }
+                // reset last click timestamp
+                timeLastClick = System.currentTimeMillis();
+                // set item pressed and update
+                setPressed(true);
+                break;
+            }
+            // up event (revoke touch)
+            case MotionEvent.ACTION_UP:
+            case MotionEvent.ACTION_POINTER_UP: {
+                setPressed(false);
+                break;
+            }
+        }
+
+        if (isPressed()) {
+            // when is pressed calculate new positions (will trigger movement if necessary)
+            updatePosition();
+        } else {
+            stick_state = STICK_STATE.NO_MOVEMENT;
+            notifyOnRevoke();
+            // not longer pressed reset analog stick
+            notifyOnMovement(0, 0);
+        }
+        // refresh view
+        invalidate();
+        // accept the touch event
+        return true;
+    }
+}
@@ -0,0 +1,235 @@
+/**
+ * Created by Karim Mreisi.
+ */
+
+package com.limelight.binding.input.virtual_controller;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.graphics.drawable.Drawable;
+import android.view.MotionEvent;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Timer;
+import java.util.TimerTask;
+
+/**
+ * This is a digital button on screen element. It is used to get click and double click user input.
+ */
+public class DigitalButton extends VirtualControllerElement {
+
+    /**
+     * Listener interface to update registered observers.
+     */
+    public interface DigitalButtonListener {
+
+        /**
+         * onClick event will be fired on button click.
+         */
+        void onClick();
+
+        /**
+         * onLongClick event will be fired on button long click.
+         */
+        void onLongClick();
+
+        /**
+         * onRelease event will be fired on button unpress.
+         */
+        void onRelease();
+    }
+
+    /**
+     *
+     */
+    private class TimerLongClickTimerTask extends TimerTask {
+        @Override
+        public void run() {
+            onLongClickCallback();
+        }
+    }
+
+    private List<DigitalButtonListener> listeners = new ArrayList<DigitalButtonListener>();
+    private String text = "";
+    private int icon = -1;
+    private long timerLongClickTimeout = 3000;
+    private Timer timerLongClick = null;
+    private TimerLongClickTimerTask longClickTimerTask = null;
+
+    private final Paint paint = new Paint();
+
+    private int layer;
+    private DigitalButton movingButton = null;
+
+    boolean inRange(float x, float y) {
+        return (this.getX() < x && this.getX() + this.getWidth() > x) &&
+                (this.getY() < y && this.getY() + this.getHeight() > y);
+    }
+
+    public boolean checkMovement(float x, float y, DigitalButton movingButton) {
+        // check if the movement happened in the same layer
+        if (movingButton.layer != this.layer) {
+            return false;
+        }
+
+        // save current pressed state
+        boolean wasPressed = isPressed();
+
+        // check if the movement directly happened on the button
+        if ((this.movingButton == null || movingButton == this.movingButton)
+                && this.inRange(x, y)) {
+            // set button pressed state depending on moving button pressed state
+            if (this.isPressed() != movingButton.isPressed()) {
+                this.setPressed(movingButton.isPressed());
+            }
+        }
+        // check if the movement is outside of the range and the movement button
+        // is the saved moving button
+        else if (movingButton == this.movingButton) {
+            this.setPressed(false);
+        }
+
+        // check if a change occurred
+        if (wasPressed != isPressed()) {
+            if (isPressed()) {
+                // is pressed set moving button and emit click event
+                this.movingButton = movingButton;
+                onClickCallback();
+            } else {
+                // no longer pressed reset moving button and emit release event
+                this.movingButton = null;
+                onReleaseCallback();
+            }
+
+            invalidate();
+
+            return true;
+        }
+
+        return false;
+    }
+
+    private void checkMovementForAllButtons(float x, float y) {
+        for (VirtualControllerElement element : virtualController.getElements()) {
+            if (element != this && element instanceof DigitalButton) {
+                ((DigitalButton) element).checkMovement(x, y, this);
+            }
+        }
+    }
+
+    public DigitalButton(VirtualController controller, int layer, Context context) {
+        super(controller, context);
+        this.layer = layer;
+    }
+
+    public void addDigitalButtonListener(DigitalButtonListener listener) {
+        listeners.add(listener);
+    }
+
+    public void setText(String text) {
+        this.text = text;
+        invalidate();
+    }
+
+    public void setIcon(int id) {
+        this.icon = id;
+        invalidate();
+    }
+
+    @Override
+    protected void onElementDraw(Canvas canvas) {
+        // set transparent background
+        canvas.drawColor(Color.TRANSPARENT);
+
+        paint.setTextSize(getPercent(getCorrectWidth(), 50));
+        paint.setTextAlign(Paint.Align.CENTER);
+        paint.setStrokeWidth(3);
+
+        paint.setColor(isPressed() ? pressedColor : normalColor);
+        paint.setStyle(Paint.Style.STROKE);
+        canvas.drawRect(1, 1, getWidth() - 1, getHeight() - 1, paint);
+
+        if (icon != -1) {
+            Drawable d = getResources().getDrawable(icon);
+            d.setBounds(5, 5, getWidth() - 5, getHeight() - 5);
+            d.draw(canvas);
+        } else {
+            paint.setStyle(Paint.Style.FILL_AND_STROKE);
+            canvas.drawText(text, getPercent(getWidth(), 50), getPercent(getHeight(), 73), paint);
+        }
+    }
+
+    private void onClickCallback() {
+        _DBG("clicked");
+        // notify listeners
+        for (DigitalButtonListener listener : listeners) {
+            listener.onClick();
+        }
+
+        timerLongClick = new Timer();
+        longClickTimerTask = new TimerLongClickTimerTask();
+        timerLongClick.schedule(longClickTimerTask, timerLongClickTimeout);
+    }
+
+    private void onLongClickCallback() {
+        _DBG("long click");
+        // notify listeners
+        for (DigitalButtonListener listener : listeners) {
+            listener.onLongClick();
+        }
+    }
+
+    private void onReleaseCallback() {
+        _DBG("released");
+        // notify listeners
+        for (DigitalButtonListener listener : listeners) {
+            listener.onRelease();
+        }
+        timerLongClick.cancel();
+        longClickTimerTask.cancel();
+    }
+
+    @Override
+    public boolean onElementTouchEvent(MotionEvent event) {
+        // get masked (not specific to a pointer) action
+        float x = getX() + event.getX();
+        float y = getY() + event.getY();
+        int action = event.getActionMasked();
+
+        switch (action) {
+            case MotionEvent.ACTION_DOWN:
+            case MotionEvent.ACTION_POINTER_DOWN: {
+                movingButton = null;
+                setPressed(true);
+                onClickCallback();
+
+                invalidate();
+
+                return true;
+            }
+            case MotionEvent.ACTION_MOVE: {
+                checkMovementForAllButtons(x, y);
+
+                return true;
+            }
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP:
+            case MotionEvent.ACTION_POINTER_UP: {
+                setPressed(false);
+                onReleaseCallback();
+
+                checkMovementForAllButtons(x, y);
+
+                invalidate();
+
+                return true;
+            }
+            default: {
+            }
+        }
+        return true;
+    }
+}
@@ -0,0 +1,202 @@
+/**
+ * Created by Karim Mreisi.
+ */
+
+package com.limelight.binding.input.virtual_controller;
+
+import android.content.Context;
+import android.graphics.Canvas;
+import android.graphics.Color;
+import android.graphics.Paint;
+import android.view.MotionEvent;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DigitalPad extends VirtualControllerElement {
+    public final static int DIGITAL_PAD_DIRECTION_NO_DIRECTION = 0;
+    int direction = DIGITAL_PAD_DIRECTION_NO_DIRECTION;
+    public final static int DIGITAL_PAD_DIRECTION_LEFT = 1;
+    public final static int DIGITAL_PAD_DIRECTION_UP = 2;
+    public final static int DIGITAL_PAD_DIRECTION_RIGHT = 4;
+    public final static int DIGITAL_PAD_DIRECTION_DOWN = 8;
+    List<DigitalPadListener> listeners = new ArrayList<DigitalPadListener>();
+
+    private final Paint paint = new Paint();
+
+    public DigitalPad(VirtualController controller, Context context) {
+        super(controller, context);
+    }
+
+    public void addDigitalPadListener(DigitalPadListener listener) {
+        listeners.add(listener);
+    }
+
+    @Override
+    protected void onElementDraw(Canvas canvas) {
+        // set transparent background
+        canvas.drawColor(Color.TRANSPARENT);
+
+        paint.setTextSize(getPercent(getCorrectWidth(), 20));
+        paint.setTextAlign(Paint.Align.CENTER);
+        paint.setStrokeWidth(3);
+
+        if (direction == DIGITAL_PAD_DIRECTION_NO_DIRECTION) {
+            // draw no direction rect
+            paint.setStyle(Paint.Style.STROKE);
+            paint.setColor(normalColor);
+            canvas.drawRect(
+                    getPercent(getWidth(), 36), getPercent(getHeight(), 36),
+                    getPercent(getWidth(), 63), getPercent(getHeight(), 63),
+                    paint
+            );
+        }
+
+        // draw left rect
+        paint.setColor(
+                (direction & DIGITAL_PAD_DIRECTION_LEFT) > 0 ? pressedColor : normalColor);
+        paint.setStyle(Paint.Style.STROKE);
+        canvas.drawRect(
+                0, getPercent(getHeight(), 33),
+                getPercent(getWidth(), 33), getPercent(getHeight(), 66),
+                paint
+        );
+
+        // draw left up line
+        paint.setColor((
+                        (direction & DIGITAL_PAD_DIRECTION_LEFT) > 0 &&
+                                (direction & DIGITAL_PAD_DIRECTION_UP) > 0
+                ) ? pressedColor : normalColor
+        );
+        paint.setStyle(Paint.Style.STROKE);
+        canvas.drawLine(
+                0, getPercent(getHeight(), 33),
+                getPercent(getWidth(), 33), 0,
+                paint
+        );
+
+        // draw up rect
+        paint.setColor(
+                (direction & DIGITAL_PAD_DIRECTION_UP) > 0 ? pressedColor : normalColor);
+        paint.setStyle(Paint.Style.STROKE);
+        canvas.drawRect(
+                getPercent(getWidth(), 33), 0,
+                getPercent(getWidth(), 66), getPercent(getHeight(), 33),
+                paint
+        );
+
+        // draw up right line
+        paint.setColor((
+                        (direction & DIGITAL_PAD_DIRECTION_UP) > 0 &&
+                                (direction & DIGITAL_PAD_DIRECTION_RIGHT) > 0
+                ) ? pressedColor : normalColor
+        );
+        paint.setStyle(Paint.Style.STROKE);
+        canvas.drawLine(
+                getPercent(getWidth(), 66), 0,
+                getPercent(getWidth(), 100), getPercent(getHeight(), 33),
+                paint
+        );
+
+        // draw right rect
+        paint.setColor(
+                (direction & DIGITAL_PAD_DIRECTION_RIGHT) > 0 ? pressedColor : normalColor);
+        paint.setStyle(Paint.Style.STROKE);
+        canvas.drawRect(
+                getPercent(getWidth(), 66), getPercent(getHeight(), 33),
+                getPercent(getWidth(), 100), getPercent(getHeight(), 66),
+                paint
+        );
+
+        // draw right down line
+        paint.setColor((
+                        (direction & DIGITAL_PAD_DIRECTION_RIGHT) > 0 &&
+                                (direction & DIGITAL_PAD_DIRECTION_DOWN) > 0
+                ) ? pressedColor : normalColor
+        );
+        paint.setStyle(Paint.Style.STROKE);
+        canvas.drawLine(
+                getPercent(getWidth(), 100), getPercent(getHeight(), 66),
+                getPercent(getWidth(), 66), getPercent(getHeight(), 100),
+                paint
+        );
+
+        // draw down rect
+        paint.setColor(
+                (direction & DIGITAL_PAD_DIRECTION_DOWN) > 0 ? pressedColor : normalColor);
+        paint.setStyle(Paint.Style.STROKE);
+        canvas.drawRect(
+                getPercent(getWidth(), 33), getPercent(getHeight(), 66),
+                getPercent(getWidth(), 66), getPercent(getHeight(), 100),
+                paint
+        );
+
+        // draw down left line
+        paint.setColor((
+                        (direction & DIGITAL_PAD_DIRECTION_DOWN) > 0 &&
+                                (direction & DIGITAL_PAD_DIRECTION_LEFT) > 0
+                ) ? pressedColor : normalColor
+        );
+        paint.setStyle(Paint.Style.STROKE);
+        canvas.drawLine(
+                getPercent(getWidth(), 33), getPercent(getHeight(), 100),
+                getPercent(getWidth(), 0), getPercent(getHeight(), 66),
+                paint
+        );
+    }
+
+    private void newDirectionCallback(int direction) {
+        _DBG("direction: " + direction);
+
+        // notify listeners
+        for (DigitalPadListener listener : listeners) {
+            listener.onDirectionChange(direction);
+        }
+    }
+
+    @Override
+    public boolean onElementTouchEvent(MotionEvent event) {
+        // get masked (not specific to a pointer) action
+        switch (event.getActionMasked()) {
+            case MotionEvent.ACTION_DOWN:
+            case MotionEvent.ACTION_POINTER_DOWN:
+            case MotionEvent.ACTION_MOVE: {
+                direction = 0;
+
+                if (event.getX() < getPercent(getWidth(), 33)) {
+                    direction |= DIGITAL_PAD_DIRECTION_LEFT;
+                }
+                if (event.getX() > getPercent(getWidth(), 66)) {
+                    direction |= DIGITAL_PAD_DIRECTION_RIGHT;
+                }
+                if (event.getY() > getPercent(getHeight(), 66)) {
+                    direction |= DIGITAL_PAD_DIRECTION_DOWN;
+                }
+                if (event.getY() < getPercent(getHeight(), 33)) {
+                    direction |= DIGITAL_PAD_DIRECTION_UP;
+                }
+                newDirectionCallback(direction);
+                invalidate();
+
+                return true;
+            }
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP:
+            case MotionEvent.ACTION_POINTER_UP: {
+                direction = 0;
+                newDirectionCallback(direction);
+                invalidate();
+
+                return true;
+            }
+            default: {
+            }
+        }
+
+        return true;
+    }
+
+    public interface DigitalPadListener {
+        void onDirectionChange(int direction);
+    }
+}
@@ -0,0 +1,49 @@
+/**
+ * Created by Karim Mreisi.
+ */
+
+package com.limelight.binding.input.virtual_controller;
+
+import android.content.Context;
+
+import com.limelight.nvstream.input.ControllerPacket;
+
+public class LeftAnalogStick extends AnalogStick {
+    public LeftAnalogStick(final VirtualController controller, final Context context) {
+        super(controller, context);
+
+        addAnalogStickListener(new AnalogStick.AnalogStickListener() {
+            @Override
+            public void onMovement(float x, float y) {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.leftStickX = (short) (x * 0x7FFE);
+                inputContext.leftStickY = (short) (y * 0x7FFE);
+
+                controller.sendControllerInputContext();
+            }
+
+            @Override
+            public void onClick() {
+            }
+
+            @Override
+            public void onDoubleClick() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.inputMap |= ControllerPacket.LS_CLK_FLAG;
+
+                controller.sendControllerInputContext();
+            }
+
+            @Override
+            public void onRevoke() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.inputMap &= ~ControllerPacket.LS_CLK_FLAG;
+
+                controller.sendControllerInputContext();
+            }
+        });
+    }
+}
@@ -0,0 +1,36 @@
+/**
+ * Created by Karim Mreisi.
+ */
+
+package com.limelight.binding.input.virtual_controller;
+
+import android.content.Context;
+
+public class LeftTrigger extends DigitalButton {
+    public LeftTrigger(final VirtualController controller, final int layer, final Context context) {
+        super(controller, layer, context);
+        addDigitalButtonListener(new DigitalButton.DigitalButtonListener() {
+            @Override
+            public void onClick() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.leftTrigger = (byte) 0xFF;
+
+                controller.sendControllerInputContext();
+            }
+
+            @Override
+            public void onLongClick() {
+            }
+
+            @Override
+            public void onRelease() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.leftTrigger = (byte) 0x00;
+
+                controller.sendControllerInputContext();
+            }
+        });
+    }
+}
@@ -0,0 +1,49 @@
+/**
+ * Created by Karim Mreisi.
+ */
+
+package com.limelight.binding.input.virtual_controller;
+
+import android.content.Context;
+
+import com.limelight.nvstream.input.ControllerPacket;
+
+public class RightAnalogStick extends AnalogStick {
+    public RightAnalogStick(final VirtualController controller, final Context context) {
+        super(controller, context);
+
+        addAnalogStickListener(new AnalogStick.AnalogStickListener() {
+            @Override
+            public void onMovement(float x, float y) {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.rightStickX = (short) (x * 0x7FFE);
+                inputContext.rightStickY = (short) (y * 0x7FFE);
+
+                controller.sendControllerInputContext();
+            }
+
+            @Override
+            public void onClick() {
+            }
+
+            @Override
+            public void onDoubleClick() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.inputMap |= ControllerPacket.RS_CLK_FLAG;
+
+                controller.sendControllerInputContext();
+            }
+
+            @Override
+            public void onRevoke() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.inputMap &= ~ControllerPacket.RS_CLK_FLAG;
+
+                controller.sendControllerInputContext();
+            }
+        });
+    }
+}
@@ -0,0 +1,36 @@
+/**
+ * Created by Karim Mreisi.
+ */
+
+package com.limelight.binding.input.virtual_controller;
+
+import android.content.Context;
+
+public class RightTrigger extends DigitalButton {
+    public RightTrigger(final VirtualController controller, final int layer, final Context context) {
+        super(controller, layer, context);
+        addDigitalButtonListener(new DigitalButton.DigitalButtonListener() {
+            @Override
+            public void onClick() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.rightTrigger = (byte) 0xFF;
+
+                controller.sendControllerInputContext();
+            }
+
+            @Override
+            public void onLongClick() {
+            }
+
+            @Override
+            public void onRelease() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.rightTrigger = (byte) 0x00;
+
+                controller.sendControllerInputContext();
+            }
+        });
+    }
+}
@@ -0,0 +1,149 @@
+/**
+ * Created by Karim Mreisi.
+ */
+
+package com.limelight.binding.input.virtual_controller;
+
+import android.content.Context;
+import android.view.View;
+import android.widget.Button;
+import android.widget.FrameLayout;
+import android.widget.RelativeLayout;
+import android.widget.Toast;
+
+import com.limelight.R;
+import com.limelight.nvstream.NvConnection;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class VirtualController {
+    public class ControllerInputContext {
+        public short inputMap = 0x0000;
+        public byte leftTrigger = 0x00;
+        public byte rightTrigger = 0x00;
+        public short rightStickX = 0x0000;
+        public short rightStickY = 0x0000;
+        public short leftStickX = 0x0000;
+        public short leftStickY = 0x0000;
+    }
+
+    public enum ControllerMode {
+        Active,
+        Configuration
+    }
+
+    private static final boolean _PRINT_DEBUG_INFORMATION = true;
+
+    private NvConnection connection = null;
+    private Context context = null;
+
+    private FrameLayout frame_layout = null;
+    private RelativeLayout relative_layout = null;
+
+    ControllerMode currentMode = ControllerMode.Active;
+    ControllerInputContext inputContext = new ControllerInputContext();
+
+    private RelativeLayout.LayoutParams layoutParamsButtonConfigure = null;
+    private Button buttonConfigure = null;
+
+    private List<VirtualControllerElement> elements = new ArrayList<VirtualControllerElement>();
+
+    public VirtualController(final NvConnection conn, FrameLayout layout, final Context context) {
+        this.connection = conn;
+        this.frame_layout = layout;
+        this.context = context;
+
+        relative_layout = new RelativeLayout(context);
+
+        frame_layout.addView(relative_layout);
+
+        buttonConfigure = new Button(context);
+        buttonConfigure.setBackgroundResource(R.drawable.settings);
+        buttonConfigure.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if (currentMode == ControllerMode.Configuration) {
+                    currentMode = ControllerMode.Active;
+                } else {
+                    currentMode = ControllerMode.Configuration;
+                }
+                Toast.makeText(context, "CHANGE MODE " + currentMode, Toast.LENGTH_SHORT).show();
+
+                relative_layout.invalidate();
+            }
+        });
+    }
+
+    public void removeElements() {
+        for (VirtualControllerElement element : elements) {
+            relative_layout.removeView(element);
+        }
+        elements.clear();
+    }
+
+    public void addElement(VirtualControllerElement element, int x, int y, int width, int height) {
+        elements.add(element);
+        RelativeLayout.LayoutParams layoutParams = new RelativeLayout.LayoutParams(width, height);
+        layoutParams.setMargins(x, y, 0, 0);
+
+        relative_layout.addView(element, layoutParams);
+    }
+
+    public List<VirtualControllerElement> getElements() {
+        return elements;
+    }
+
+    private static final void _DBG(String text) {
+        if (_PRINT_DEBUG_INFORMATION) {
+            System.out.println("VirtualController: " + text);
+        }
+    }
+
+    public void refreshLayout() {
+        relative_layout.removeAllViews();
+        removeElements();
+
+        layoutParamsButtonConfigure = new RelativeLayout.LayoutParams(50, 50);
+        relative_layout.addView(buttonConfigure, layoutParamsButtonConfigure);
+
+        VirtualControllerConfigurationLoader.createDefaultLayout(this, context);
+    }
+
+    public ControllerMode getControllerMode() {
+        return currentMode;
+    }
+
+    public ControllerInputContext getControllerInputContext() {
+        return inputContext;
+    }
+
+    public void sendControllerInputContext() {
+        sendControllerInputPacket();
+    }
+
+    private void sendControllerInputPacket() {
+        try {
+            _DBG("INPUT_MAP + " + inputContext.inputMap);
+            _DBG("LEFT_TRIGGER " + inputContext.leftTrigger);
+            _DBG("RIGHT_TRIGGER " + inputContext.rightTrigger);
+            _DBG("LEFT STICK X: " + inputContext.leftStickX + " Y: " + inputContext.leftStickY);
+            _DBG("RIGHT STICK X: " + inputContext.rightStickX + " Y: " + inputContext.rightStickY);
+            _DBG("RIGHT STICK X: " + inputContext.rightStickX + " Y: " + inputContext.rightStickY);
+
+            if (connection != null) {
+                connection.sendControllerInput(
+                        inputContext.inputMap,
+                        inputContext.leftTrigger,
+                        inputContext.rightTrigger,
+                        inputContext.leftStickX,
+                        inputContext.leftStickY,
+                        inputContext.rightStickX,
+                        inputContext.rightStickY
+                );
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}
@@ -0,0 +1,277 @@
+/**
+ * Created by Karim Mreisi.
+ */
+
+package com.limelight.binding.input.virtual_controller;
+
+import android.content.Context;
+import android.util.DisplayMetrics;
+
+import com.limelight.nvstream.input.ControllerPacket;
+
+public class VirtualControllerConfigurationLoader {
+    private static final String PROFILE_PATH = "profiles";
+
+    private static int getPercent(
+            int percent,
+            int total) {
+        return (int) (((float) total / (float) 100) * (float) percent);
+    }
+
+    private static DigitalPad createDigitalPad(
+            final VirtualController controller,
+            final Context context) {
+
+        DigitalPad digitalPad = new DigitalPad(controller, context);
+        digitalPad.addDigitalPadListener(new DigitalPad.DigitalPadListener() {
+            @Override
+            public void onDirectionChange(int direction) {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+
+                if (direction == DigitalPad.DIGITAL_PAD_DIRECTION_NO_DIRECTION) {
+                    inputContext.inputMap &= ~ControllerPacket.LEFT_FLAG;
+                    inputContext.inputMap &= ~ControllerPacket.RIGHT_FLAG;
+                    inputContext.inputMap &= ~ControllerPacket.UP_FLAG;
+                    inputContext.inputMap &= ~ControllerPacket.DOWN_FLAG;
+
+                    controller.sendControllerInputContext();
+                    return;
+                }
+                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_LEFT) > 0) {
+                    inputContext.inputMap |= ControllerPacket.LEFT_FLAG;
+                }
+                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_RIGHT) > 0) {
+                    inputContext.inputMap |= ControllerPacket.RIGHT_FLAG;
+                }
+                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_UP) > 0) {
+                    inputContext.inputMap |= ControllerPacket.UP_FLAG;
+                }
+                if ((direction & DigitalPad.DIGITAL_PAD_DIRECTION_DOWN) > 0) {
+                    inputContext.inputMap |= ControllerPacket.DOWN_FLAG;
+                }
+                controller.sendControllerInputContext();
+            }
+        });
+
+        return digitalPad;
+    }
+
+    private static DigitalButton createDigitalButton(
+            final int keyShort,
+            final int keyLong,
+            final int layer,
+            final String text,
+            final int icon,
+            final VirtualController controller,
+            final Context context) {
+        DigitalButton button = new DigitalButton(controller, layer, context);
+        button.setText(text);
+        button.setIcon(icon);
+
+        button.addDigitalButtonListener(new DigitalButton.DigitalButtonListener() {
+            @Override
+            public void onClick() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.inputMap |= keyShort;
+
+                controller.sendControllerInputContext();
+            }
+
+            @Override
+            public void onLongClick() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.inputMap |= keyLong;
+
+                controller.sendControllerInputContext();
+            }
+
+            @Override
+            public void onRelease() {
+                VirtualController.ControllerInputContext inputContext =
+                        controller.getControllerInputContext();
+                inputContext.inputMap &= ~keyShort;
+                inputContext.inputMap &= ~keyLong;
+
+                controller.sendControllerInputContext();
+            }
+        });
+
+        return button;
+    }
+
+    private static DigitalButton createLeftTrigger(
+            final int layer,
+            final String text,
+            final int icon,
+            final VirtualController controller,
+            final Context context) {
+        LeftTrigger button = new LeftTrigger(controller, layer, context);
+        button.setText(text);
+        button.setIcon(icon);
+        return button;
+    }
+
+    private static DigitalButton createRightTrigger(
+            final int layer,
+            final String text,
+            final int icon,
+            final VirtualController controller,
+            final Context context) {
+        RightTrigger button = new RightTrigger(controller, layer, context);
+        button.setText(text);
+        button.setIcon(icon);
+        return button;
+    }
+
+    private static AnalogStick createLeftStick(
+            final VirtualController controller,
+            final Context context) {
+        return new LeftAnalogStick(controller, context);
+    }
+
+    private static AnalogStick createRightStick(
+            final VirtualController controller,
+            final Context context) {
+        return new RightAnalogStick(controller, context);
+    }
+
+    public static void createDefaultLayout(final VirtualController controller, final Context context) {
+
+        DisplayMetrics screen = context.getResources().getDisplayMetrics();
+
+        controller.addElement(createDigitalPad(controller, context),
+                getPercent(5, screen.widthPixels),
+                getPercent(10, screen.heightPixels),
+                getPercent(30, screen.widthPixels),
+                getPercent(40, screen.heightPixels)
+        );
+
+        controller.addElement(createDigitalButton(
+                ControllerPacket.A_FLAG, 0, 1, "A", -1, controller, context),
+                getPercent(75, screen.widthPixels),
+                getPercent(40, screen.heightPixels),
+                getPercent(10, screen.widthPixels),
+                getPercent(10, screen.heightPixels)
+        );
+
+        controller.addElement(createDigitalButton(
+                ControllerPacket.B_FLAG, 0, 1, "B", -1, controller, context),
+                getPercent(85, screen.widthPixels),
+                getPercent(30, screen.heightPixels),
+                getPercent(10, screen.widthPixels),
+                getPercent(10, screen.heightPixels)
+        );
+
+        controller.addElement(createDigitalButton(
+                ControllerPacket.X_FLAG, 0, 1, "X", -1, controller, context),
+                getPercent(65, screen.widthPixels),
+                getPercent(30, screen.heightPixels),
+                getPercent(10, screen.widthPixels),
+                getPercent(10, screen.heightPixels)
+        );
+
+        controller.addElement(createDigitalButton(
+                ControllerPacket.Y_FLAG, 0, 1, "Y", -1, controller, context),
+                getPercent(75, screen.widthPixels),
+                getPercent(20, screen.heightPixels),
+                getPercent(10, screen.widthPixels),
+                getPercent(10, screen.heightPixels)
+        );
+
+        controller.addElement(createLeftTrigger(
+                0, "LT", -1, controller, context),
+                getPercent(65, screen.widthPixels),
+                getPercent(20, screen.heightPixels),
+                getPercent(10, screen.widthPixels),
+                getPercent(10, screen.heightPixels)
+        );
+
+        controller.addElement(createRightTrigger(
+                0, "RT", -1, controller, context),
+                getPercent(85, screen.widthPixels),
+                getPercent(20, screen.heightPixels),
+                getPercent(10, screen.widthPixels),
+                getPercent(10, screen.heightPixels)
+        );
+
+        controller.addElement(createDigitalButton(
+                ControllerPacket.LB_FLAG, 0, 1, "LB", -1, controller, context),
+                getPercent(65, screen.widthPixels),
+                getPercent(40, screen.heightPixels),
+                getPercent(10, screen.widthPixels),
+                getPercent(10, screen.heightPixels)
+        );
+
+        controller.addElement(createDigitalButton(
+                ControllerPacket.RB_FLAG, 0, 1, "RB", -1, controller, context),
+                getPercent(85, screen.widthPixels),
+                getPercent(40, screen.heightPixels),
+                getPercent(10, screen.widthPixels),
+                getPercent(10, screen.heightPixels)
+        );
+
+        controller.addElement(createLeftStick(controller, context),
+                getPercent(5, screen.widthPixels),
+                getPercent(50, screen.heightPixels),
+                getPercent(40, screen.widthPixels),
+                getPercent(50, screen.heightPixels)
+        );
+
+        controller.addElement(createRightStick(controller, context),
+                getPercent(55, screen.widthPixels),
+                getPercent(50, screen.heightPixels),
+                getPercent(40, screen.widthPixels),
+                getPercent(50, screen.heightPixels)
+        );
+
+        controller.addElement(createDigitalButton(
+                ControllerPacket.BACK_FLAG, 0, 2, "SELECT", -1, controller, context),
+                getPercent(40, screen.widthPixels),
+                getPercent(90, screen.heightPixels),
+                getPercent(10, screen.widthPixels),
+                getPercent(10, screen.heightPixels)
+        );
+
+        controller.addElement(createDigitalButton(
+                ControllerPacket.PLAY_FLAG, 0, 3, "START", -1, controller, context),
+                getPercent(50, screen.widthPixels),
+                getPercent(90, screen.heightPixels),
+                getPercent(10, screen.widthPixels),
+                getPercent(10, screen.heightPixels)
+        );
+    }
+
+    /*
+    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 preferences = context.getSharedPreferences(PROFILE_PATH + "/" +
+                name, Activity.MODE_PRIVATE);
+
+        JSONArray elementConfigurations = new JSONArray();
+        for (VirtualControllerElement element : controller.getElements()) {
+            JSONObject elementConfiguration = new JSONObject();
+            try {
+                elementConfiguration.put("TYPE", element.getClass().getName());
+                elementConfiguration.put("CONFIGURATION", element.getConfiguration());
+                elementConfigurations.put(elementConfiguration);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+
+        SharedPreferences.Editor editor= preferences.edit();
+        editor.putString("ELEMENTS", elementConfigurations.toString());
+    }
+
+	public static void loadFromPreferences(final VirtualController controller) {
+
+	}
+	*/
+}
@@ -0,0 +1,277 @@
+/**
+ * Created by Karim Mreisi.
+ */
+
+package com.limelight.binding.input.virtual_controller;
+
+import android.app.AlertDialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.graphics.Canvas;
+import android.graphics.Paint;
+import android.view.MotionEvent;
+import android.view.View;
+import android.widget.RelativeLayout;
+
+public abstract class VirtualControllerElement extends View {
+    protected static boolean _PRINT_DEBUG_INFORMATION = false;
+
+    protected VirtualController virtualController;
+
+    private final Paint paint = new Paint();
+
+    protected int normalColor = 0xF0888888;
+    protected int pressedColor = 0xF00000FF;
+
+    protected int startSize_x;
+    protected int startSize_y;
+
+    float position_pressed_x = 0;
+    float position_pressed_y = 0;
+
+    private enum Mode {
+        Normal,
+        Resize,
+        Move
+    }
+
+    private Mode currentMode = Mode.Normal;
+
+    protected VirtualControllerElement(VirtualController controller, Context context) {
+        super(context);
+
+        this.virtualController = controller;
+    }
+
+    protected void moveElement(int pressed_x, int pressed_y, int x, int y) {
+        int newPos_x = (int) getX() + x - pressed_x;
+        int newPos_y = (int) getY() + y - pressed_y;
+
+        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
+
+        layoutParams.leftMargin = newPos_x > 0 ? newPos_x : 0;
+        layoutParams.topMargin = newPos_y > 0 ? newPos_y : 0;
+        layoutParams.rightMargin = 0;
+        layoutParams.bottomMargin = 0;
+
+        requestLayout();
+    }
+
+    protected void resizeElement(int pressed_x, int pressed_y, int width, int height) {
+        RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams) getLayoutParams();
+
+        int newHeight = height + (startSize_y - pressed_y);
+        int newWidth = width + (startSize_x - pressed_x);
+
+        layoutParams.height = newHeight > 20 ? newHeight : 20;
+        layoutParams.width = newWidth > 20 ? newWidth : 20;
+
+        requestLayout();
+    }
+
+    @Override
+    protected void onDraw(Canvas canvas) {
+        if (virtualController.getControllerMode() == VirtualController.ControllerMode.
+                Configuration) {
+            paint.setColor(pressedColor);
+            paint.setStrokeWidth(3);
+            paint.setStyle(Paint.Style.STROKE);
+
+            canvas.drawRect(0, 0,
+                    getWidth(), getHeight(),
+                    paint);
+        }
+
+        onElementDraw(canvas);
+
+        super.onDraw(canvas);
+    }
+
+    /*
+    protected void actionShowNormalColorChooser() {
+		AmbilWarnaDialog colorDialog = new AmbilWarnaDialog(getContext(), normalColor, true, new AmbilWarnaDialog.OnAmbilWarnaListener() {
+			@Override
+			public void onCancel(AmbilWarnaDialog dialog)
+			{}
+
+			@Override
+			public void onOk(AmbilWarnaDialog dialog, int color) {
+				normalColor = color;
+				invalidate();
+			}
+		});
+		colorDialog.show();
+	}
+
+	protected void actionShowPressedColorChooser() {
+		AmbilWarnaDialog colorDialog = new AmbilWarnaDialog(getContext(), normalColor, true, new AmbilWarnaDialog.OnAmbilWarnaListener() {
+			@Override
+			public void onCancel(AmbilWarnaDialog dialog) {
+			}
+
+			@Override
+			public void onOk(AmbilWarnaDialog dialog, int color) {
+				pressedColor = color;
+				invalidate();
+			}
+		});
+		colorDialog.show();
+	}
+    */
+
+    protected void actionEnableMove() {
+        currentMode = Mode.Move;
+    }
+
+    protected void actionEnableResize() {
+        currentMode = Mode.Resize;
+    }
+
+    protected void actionCancel() {
+        currentMode = Mode.Normal;
+        invalidate();
+    }
+
+    protected void showConfigurationDialog() {
+        try {
+            AlertDialog.Builder alertBuilder = new AlertDialog.Builder(getContext());
+
+            alertBuilder.setTitle("Configuration");
+
+            CharSequence functions[] = new CharSequence[]{
+                    "Move",
+                    "Resize",
+                /*election
+                "Set n
+                Disable color sormal color",
+                "Set pressed color",
+                */
+                    "Cancel"
+            };
+
+            alertBuilder.setItems(functions, new DialogInterface.OnClickListener() {
+
+                @Override
+                public void onClick(DialogInterface dialog, int which) {
+                    switch (which) {
+                        case 0: { // move
+                            actionEnableMove();
+                            break;
+                        }
+                        case 1: { // resize
+                            actionEnableResize();
+                            break;
+                        }
+                    /*
+                    case 2:	{ // set default color
+                        actionShowNormalColorChooser();
+                        break;
+                    }
+                    case 3:	{ // set pressed color
+                        actionShowPressedColorChooser();
+                        break;
+                    }
+                    */
+                        default: { // cancel
+                            actionCancel();
+                            break;
+                        }
+                    }
+                }
+            });
+            AlertDialog alert = alertBuilder.create();
+            // show menu
+            alert.show();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    @Override
+    public boolean onTouchEvent(MotionEvent event) {
+        if (virtualController.getControllerMode() == VirtualController.ControllerMode.Active) {
+            return onElementTouchEvent(event);
+        }
+
+        switch (event.getActionMasked()) {
+            case MotionEvent.ACTION_DOWN:
+            case MotionEvent.ACTION_POINTER_DOWN: {
+                position_pressed_x = event.getX();
+                position_pressed_y = event.getY();
+                startSize_x = getWidth();
+                startSize_y = getHeight();
+
+                return true;
+            }
+            case MotionEvent.ACTION_MOVE: {
+                switch (currentMode) {
+                    case Move: {
+                        moveElement(
+                                (int) position_pressed_x,
+                                (int) position_pressed_y,
+                                (int) event.getX(),
+                                (int) event.getY());
+                        break;
+                    }
+                    case Resize: {
+                        resizeElement(
+                                (int) position_pressed_x,
+                                (int) position_pressed_y,
+                                (int) event.getX(),
+                                (int) event.getY());
+                        break;
+                    }
+                    case Normal: {
+                        break;
+                    }
+                }
+                return true;
+            }
+            case MotionEvent.ACTION_CANCEL:
+            case MotionEvent.ACTION_UP:
+            case MotionEvent.ACTION_POINTER_UP: {
+                currentMode = Mode.Normal;
+                showConfigurationDialog();
+                return true;
+            }
+            default: {
+            }
+        }
+        return true;
+    }
+
+    abstract protected void onElementDraw(Canvas canvas);
+
+    abstract public boolean onElementTouchEvent(MotionEvent event);
+
+    protected static final void _DBG(String text) {
+        if (_PRINT_DEBUG_INFORMATION) {
+            System.out.println(text);
+        }
+    }
+
+    public void setColors(int normalColor, int pressedColor) {
+        this.normalColor = normalColor;
+        this.pressedColor = pressedColor;
+
+        invalidate();
+    }
+
+    protected final float getPercent(float value, float percent) {
+        return value / 100 * percent;
+    }
+
+    protected final int getCorrectWidth() {
+        return getWidth() > getHeight() ? getHeight() : getWidth();
+    }
+
+    /**
+     public JSONObject getConfiguration () {
+     JSONObject configuration = new JSONObject();
+     return  configuration;
+     }
+
+     public  void loadConfiguration (JSONObject configuration) {
+     }
+     */
+}
@@ -76,14 +76,31 @@ public class MediaCodecHelper {

 		constrainedHighProfilePrefixes = new LinkedList<String>();
 		constrainedHighProfilePrefixes.add("omx.intel");
+	}

+	static {
 		whitelistedHevcDecoders = new LinkedList<>();
+
+		// Exynos seems to be the only HEVC decoder that works reliably
 		whitelistedHevcDecoders.add("omx.exynos");
-		// whitelistedHevcDecoders.add("omx.nvidia"); TODO: This needs a similar fixup to the Tegra 3
-		whitelistedHevcDecoders.add("omx.mtk");
-		whitelistedHevcDecoders.add("omx.amlogic");
-		whitelistedHevcDecoders.add("omx.rk");
-		// omx.qcom added conditionally during initialization
+
+		// TODO: This needs a similar fixup to the Tegra 3 otherwise it buffers 16 frames
+		//whitelistedHevcDecoders.add("omx.nvidia");
+
+		// 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");
+		}
+
+		// These theoretically have good HEVC decoding capabilities (potentially better than
+		// their AVC decoders), but haven't been tested enough
+		//whitelistedHevcDecoders.add("omx.amlogic");
+		//whitelistedHevcDecoders.add("omx.rk");
+
+		// Based on GPU attributes queried at runtime, the omx.qcom prefix will be added
+		// during initialization to avoid SoCs with broken HEVC decoders.
 	}

 	public static void initializeWithContext(Context context) {
@@ -53,7 +53,7 @@ public class ComputerDatabaseManager {
    }

    public void deleteComputer(String name) {
-        computerDb.delete(COMPUTER_TABLE_NAME, COMPUTER_NAME_COLUMN_NAME+"='"+name+"'", null);
+        computerDb.delete(COMPUTER_TABLE_NAME, COMPUTER_NAME_COLUMN_NAME+"=?", new String[]{name});
    }

    public boolean updateComputer(ComputerDetails details) {
@@ -118,7 +118,7 @@ public class ComputerDatabaseManager {
    }

    public ComputerDetails getComputerByName(String name) {
-        Cursor c = computerDb.rawQuery("SELECT * FROM "+COMPUTER_TABLE_NAME+" WHERE "+COMPUTER_NAME_COLUMN_NAME+"='"+name+"'", null);
+        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
@@ -21,6 +21,7 @@ public class PreferenceConfiguration {
    private static final String ENABLE_51_SURROUND_PREF_STRING = "checkbox_51_surround";
    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_onscreen_controller";

    private static final int BITRATE_DEFAULT_720_30 = 5;
    private static final int BITRATE_DEFAULT_720_60 = 10;
@@ -42,6 +43,7 @@ public class PreferenceConfiguration {
    private static final boolean DEFAULT_ENABLE_51_SURROUND = false;
    private static final boolean DEFAULT_USB_DRIVER = true;
    private static final String DEFAULT_VIDEO_FORMAT = "auto";
+    private static final boolean ONSCREEN_CONTROLLER_DEFAULT = false;

    public static final int FORCE_H265_ON = -1;
    public static final int AUTOSELECT_H265 = 0;
@@ -54,6 +56,7 @@ public class PreferenceConfiguration {
    public boolean stretchVideo, enableSops, playHostAudio, disableWarnings;
    public String language;
    public boolean listMode, smallIconMode, multiController, enable51Surround, usbDriver;
+    public boolean onscreenController;

    public static int getDefaultBitrate(String resFpsString) {
        if (resFpsString.equals("720p30")) {
@@ -183,6 +186,7 @@ public class PreferenceConfiguration {
        config.multiController = prefs.getBoolean(MULTI_CONTROLLER_PREF_STRING, DEFAULT_MULTI_CONTROLLER);
        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);

        return config;
    }
@@ -3,6 +3,7 @@
 #include <string.h>

 #include <sys/types.h>
+#include <sys/socket.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <linux/input.h>
@@ -11,9 +12,13 @@
 #include <errno.h>
 #include <dirent.h>
 #include <pthread.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>

 #include <android/log.h>

+#define EVDEV_MAX_EVENT_SIZE 24
+
 #define REL_X 0x00
 #define REL_Y 0x01
 #define KEY_Q 16
@@ -30,9 +35,11 @@ struct DeviceEntry {
 static struct DeviceEntry *DeviceListHead;
 static int grabbing = 1;
 static pthread_mutex_t DeviceListLock = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t SocketSendLock = PTHREAD_MUTEX_INITIALIZER;
+static int sock;

 // This is a small executable that runs in a root shell. It reads input
-// devices and writes the evdev output packets to stdout. This allows
+// devices and writes the evdev output packets to a socket. This allows
 // Moonlight to read input devices without having to muck with changing
 // device permissions or modifying SELinux policy (which is prevented in
 // Marshmallow anyway).
@@ -56,20 +63,23 @@ static int hasKey(int fd, short key) {
 }

 static void outputEvdevData(char *data, int dataSize) {
-    // We need to lock stdout before writing to prevent
-    // interleaving of data between threads.
-    flockfile(stdout);
-    fwrite(&dataSize, sizeof(dataSize), 1, stdout);
-    fwrite(data, dataSize, 1, stdout);
-    fflush(stdout);
-    funlockfile(stdout);
+    char packetBuffer[EVDEV_MAX_EVENT_SIZE + sizeof(dataSize)];
+
+    // Copy the full packet into our buffer
+    memcpy(packetBuffer, &dataSize, sizeof(dataSize));
+    memcpy(&packetBuffer[sizeof(dataSize)], data, dataSize);
+
+    // Lock to prevent other threads from sending at the same time
+    pthread_mutex_lock(&SocketSendLock);
+    send(sock, packetBuffer, dataSize + sizeof(dataSize), 0);
+    pthread_mutex_unlock(&SocketSendLock);
 }

 void* pollThreadFunc(void* context) {
    struct DeviceEntry *device = context;
    struct pollfd pollinfo;
    int pollres, ret;
-    char data[64];
+    char data[EVDEV_MAX_EVENT_SIZE];

    __android_log_print(ANDROID_LOG_INFO, "EvdevReader", "Polling /dev/input/%s", device->devName);

@@ -94,7 +104,7 @@ void* pollThreadFunc(void* context) {

        if (pollres > 0 && (pollinfo.revents & POLLIN)) {
            // We'll have data available now
-            ret = read(device->fd, data, sizeof(struct input_event));
+            ret = read(device->fd, data, EVDEV_MAX_EVENT_SIZE);
            if (ret < 0) {
                __android_log_print(ANDROID_LOG_ERROR, "EvdevReader",
                                    "read() failed: %d", errno);
@@ -132,6 +142,9 @@ cleanup:
    {
        struct DeviceEntry *lastEntry;

+        // Lock the device list
+        pthread_mutex_lock(&DeviceListLock);
+
        if (DeviceListHead == device) {
            DeviceListHead = device->next;
        }
@@ -146,6 +159,9 @@ cleanup:
                lastEntry = lastEntry->next;
            }
        }
+
+        // Unlock device list
+        pthread_mutex_unlock(&DeviceListLock);
    }

    // Free the context
@@ -254,6 +270,11 @@ static int enumerateDevices(void) {
            continue;
        }

+        if (strstr(dirEnt->d_name, "event") == NULL) {
+            // Skip non-event devices
+            continue;
+        }
+
        startPollForDevice(dirEnt->d_name);
    }

@@ -261,6 +282,39 @@ static int enumerateDevices(void) {
    return 0;
 }

+static int connectSocket(int port) {
+    struct sockaddr_in saddr;
+    int ret;
+    int val;
+
+    sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+    if (sock < 0) {
+        __android_log_print(ANDROID_LOG_ERROR, "EvdevReader", "socket() failed: %d", errno);
+        return -1;
+    }
+
+    memset(&saddr, 0, sizeof(saddr));
+    saddr.sin_family = AF_INET;
+    saddr.sin_port = htons(port);
+    saddr.sin_addr.s_addr = inet_addr("127.0.0.1");
+    ret = connect(sock, (struct sockaddr*)&saddr, sizeof(saddr));
+    if (ret < 0) {
+        __android_log_print(ANDROID_LOG_ERROR, "EvdevReader", "connect() failed: %d", errno);
+        return -1;
+    }
+
+    val = 1;
+    ret = setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, (char*)&val, sizeof(val));
+    if (ret < 0) {
+        __android_log_print(ANDROID_LOG_ERROR, "EvdevReader", "setsockopt() failed: %d", errno);
+        // We can continue anyways
+    }
+
+    __android_log_print(ANDROID_LOG_INFO, "EvdevReader", "Connection established to port %d", port);
+
+    return 0;
+}
+
 #define UNGRAB_REQ 1
 #define REGRAB_REQ 2

@@ -268,6 +322,18 @@ int main(int argc, char* argv[]) {
    int ret;
    int pollres;
    struct pollfd pollinfo;
+    int port;
+
+    __android_log_print(ANDROID_LOG_INFO, "EvdevReader", "Entered main()");
+
+    port = atoi(argv[1]);
+    __android_log_print(ANDROID_LOG_INFO, "EvdevReader", "Requested port number: %d", port);
+
+    // Connect to the app's socket
+    ret = connectSocket(port);
+    if (ret < 0) {
+        return ret;
+    }

    // Perform initial enumeration
    ret = enumerateDevices();
@@ -282,7 +348,7 @@ int main(int argc, char* argv[]) {
        do {
            // Every second we poll again for new devices if
            // we haven't received any new events
-            pollinfo.fd = STDIN_FILENO;
+            pollinfo.fd = sock;
            pollinfo.events = POLLIN;
            pollinfo.revents = 0;
            pollres = poll(&pollinfo, 1, 1000);
@@ -293,33 +359,52 @@ int main(int argc, char* argv[]) {
        }
        while (pollres == 0);

-        ret = fread(&requestId, sizeof(requestId), 1, stdin);
-        if (ret < sizeof(requestId)) {
-            __android_log_print(ANDROID_LOG_ERROR, "EvdevReader", "Short read on input");
-            return errno;
-        }
-
-        if (requestId != UNGRAB_REQ && requestId != REGRAB_REQ) {
-            __android_log_print(ANDROID_LOG_ERROR, "EvdevReader", "Unknown request");
-            return requestId;
-        }
-
-        {
-            struct DeviceEntry *currentEntry;
-
-            pthread_mutex_lock(&DeviceListLock);
-
-            // Update state for future devices
-            grabbing = (requestId == REGRAB_REQ);
-
-            // Carry out the requested action on each device
-            currentEntry = DeviceListHead;
-            while (currentEntry != NULL) {
-                ioctl(currentEntry->fd, EVIOCGRAB, grabbing);
-                currentEntry = currentEntry->next;
+        if (pollres > 0 && (pollinfo.revents & POLLIN)) {
+            // We'll have data available now
+            ret = recv(sock, &requestId, sizeof(requestId), 0);
+            if (ret < sizeof(requestId)) {
+                __android_log_print(ANDROID_LOG_ERROR, "EvdevReader", "Short read on socket");
+                return errno;
            }

-            pthread_mutex_unlock(&DeviceListLock);
+            if (requestId != UNGRAB_REQ && requestId != REGRAB_REQ) {
+                __android_log_print(ANDROID_LOG_ERROR, "EvdevReader", "Unknown request");
+                return requestId;
+            }
+
+            {
+                struct DeviceEntry *currentEntry;
+
+                pthread_mutex_lock(&DeviceListLock);
+
+                // Update state for future devices
+                grabbing = (requestId == REGRAB_REQ);
+
+                // Carry out the requested action on each device
+                currentEntry = DeviceListHead;
+                while (currentEntry != NULL) {
+                    ioctl(currentEntry->fd, EVIOCGRAB, grabbing);
+                    currentEntry = currentEntry->next;
+                }
+
+                pthread_mutex_unlock(&DeviceListLock);
+
+                __android_log_print(ANDROID_LOG_INFO, "EvdevReader", "New grab status is: %s",
+                    grabbing ? "enabled" : "disabled");
+            }
+        }
+        else {
+            // Terminate this thread
+            if (pollres < 0) {
+                __android_log_print(ANDROID_LOG_ERROR, "EvdevReader",
+                                    "Socket recv poll() failed: %d", errno);
+            }
+            else {
+                __android_log_print(ANDROID_LOG_ERROR, "EvdevReader",
+                                    "Socket poll unexpected revents: %d", pollinfo.revents);
+            }
+
+            return -1;
        }
    }
 }
@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:id="@+id/configure_virtual_controller_frameLayout"
+    >
+
+</FrameLayout>
@@ -0,0 +1,144 @@
+<?xml version="1.0" encoding="utf-8"?>
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              android:orientation="vertical"
+              android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              android:layout_margin="10dp">
+
+    <ScrollView
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:id="@+id/scrollView">
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="vertical">
+            <LinearLayout
+                android:layout_height="wrap_content"
+                android:layout_width="match_parent"
+                android:orientation="vertical">
+
+                <Button
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:text="Load Configuration"/>
+            </LinearLayout>
+            <LinearLayout
+                android:layout_height="wrap_content"
+                android:layout_width="match_parent"
+                android:orientation="vertical">
+
+                <Button
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:text="Save Configuration"/>
+            </LinearLayout>
+            <LinearLayout
+                android:layout_height="wrap_content"
+                android:layout_width="match_parent"
+                android:orientation="vertical">
+
+                <Button
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:text="Unlock layout"/>
+            </LinearLayout>
+            <LinearLayout
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="horizontal">
+
+            <LinearLayout
+                    android:layout_height="wrap_content"
+                    android:layout_width="wrap_content"
+                    android:orientation="vertical">
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:textAppearance="?android:attr/textAppearanceMedium"
+                        android:text="Color 1"/>
+
+                    <ImageView
+                        android:layout_width="200dp"
+                        android:layout_height="100dp"
+                        android:layout_gravity="center_horizontal"/>
+
+                    <SeekBar
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"/>
+
+                    <SeekBar
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"/>
+
+                    <SeekBar
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"/>
+
+                    <SeekBar
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"/>
+
+                </LinearLayout>
+                <LinearLayout
+                    android:layout_height="wrap_content"
+                    android:layout_width="wrap_content"
+                    android:orientation="vertical">
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:textAppearance="?android:attr/textAppearanceMedium"
+                        android:text="Color 2"/>
+
+                    <ImageView
+                        android:layout_width="200dp"
+
+                        android:layout_height="100dp"
+                        android:layout_gravity="center_horizontal"/>
+
+                    <SeekBar
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"/>
+
+                    <SeekBar
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"/>
+
+                    <SeekBar
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"/>
+
+                    <SeekBar
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"/>
+
+                </LinearLayout>
+            </LinearLayout>
+                <LinearLayout
+                    android:layout_height="wrap_content"
+                    android:layout_width="match_parent"
+                    android:orientation="vertical">
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:textAppearance="?android:attr/textAppearanceMedium"
+                        android:text="analog stick time out"/>
+
+                    <TextView
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"
+                        android:textAppearance="?android:attr/textAppearanceMedium"
+                        android:textAlignment="center"
+                        android:text="250ms"/>
+
+                    <SeekBar
+                        android:layout_width="match_parent"
+                        android:layout_height="wrap_content"/>
+
+                </LinearLayout>
+        </LinearLayout>
+    </ScrollView>
+</LinearLayout>
@@ -50,6 +50,11 @@
            android:title="@string/title_checkbox_xb1_driver"
            android:summary="@string/summary_checkbox_xb1_driver"
            android:defaultValue="true" />
+        <!--CheckBoxPreference
+            android:key="checkbox_onscreen_controller"
+            android:title="On-screen controls"
+            android:summary="Show virtual controller overlay on touchscreen"
+            android:defaultValue="false"/-->
    </PreferenceCategory>
    <PreferenceCategory android:title="@string/category_host_settings">
        <CheckBoxPreference
@@ -90,5 +95,4 @@
            android:summary="@string/summary_video_format"
            android:defaultValue="auto" />
    </PreferenceCategory>
-
 </PreferenceScreen>
Author	SHA1	Message	Date
Cameron Gutman	ac7504e017	Bump version to 4.0.4	2016-01-07 16:08:08 -06:00
Cameron Gutman	345bd3f7c1	Hide on-screen controls preference until bugs are resolved	2016-01-07 16:01:33 -06:00
Cameron Gutman	2e2960ec69	Disable on-screen controls by default	2016-01-07 12:57:59 -06:00
Cameron Gutman	e93b103d1e	Fix ConcurrentModificationException in virtual controller code	2016-01-07 12:57:37 -06:00
Cameron Gutman	22977a4c5b	Use a socket for communication from EvdevReader to Moonlight rather than stdin/stdout. On some devices, fwrite(stdout) hangs for unknown reasons.	2016-01-07 12:49:30 -06:00
Cameron Gutman	7da5d5322b	Cache Paint objects instead of allocation in draw method	2016-01-07 02:23:34 -06:00
Cameron Gutman	49e2c40ba4	Add LB and RB buttons to virtual controller	2016-01-07 01:06:22 -06:00
Cameron Gutman	8041a004c2	Remove text from d-pad as it tends to get in the way of visuals on screen	2016-01-07 01:00:15 -06:00
Cameron Gutman	db62d78e04	On-screen controls: Fix functionality of Select button and rename Play to Start	2016-01-07 00:45:30 -06:00
Cameron Gutman	bd79318b1e	Cleanup new virtual controller code	2016-01-07 00:30:45 -06:00
Cameron Gutman	2736bd9165	Android Studio auto-reformat of new virtual controller code	2016-01-07 00:24:39 -06:00
Cameron Gutman	b6bd48584f	Refactor to match other preference conventions	2016-01-07 00:20:46 -06:00
Cameron Gutman	7b4f3c975a	Fix on-screen controls not showing up on 16:9 devices	2016-01-07 00:15:33 -06:00
Cameron Gutman	b165fadc55	Remove unused file	2016-01-07 00:14:16 -06:00
Cameron Gutman	274e0d0557	Merge branch 'master' into virtualcontroller_master Conflicts: app/app.iml app/build.gradle app/libs/limelight-common.jar app/src/main/java/com/limelight/Game.java app/src/main/java/com/limelight/binding/input/ControllerHandler.java app/src/main/java/com/limelight/binding/video/MediaCodecHelper.java app/src/main/java/com/limelight/computers/ComputerDatabaseManager.java app/src/main/java/com/limelight/preferences/PreferenceConfiguration.java app/src/main/jni/evdev_reader/evdev_reader.c app/src/main/res/xml/preferences.xml limelight-android.iml limelight_vc.iml moonlight-android.iml	2016-01-07 00:01:03 -06:00
Cameron Gutman	7594e51a18	Fix SQL injection vulnerability and crashes when an apostrophe is present in a computer name	2016-01-06 15:17:30 -06:00
Cameron Gutman	bf22819b53	Update common with timeouts for RTSP handshake	2016-01-06 13:08:18 -06:00
Cameron Gutman	3dea4b15e0	Fix support for kernels that output 24-byte input events	2016-01-06 13:05:51 -06:00
Cameron Gutman	5836b3292b	Only grab event devices	2016-01-06 12:36:09 -06:00
Cameron Gutman	a8fd49a234	Fix possible segmentation fault or memory corruption if EVIOCGRAB fails and the cleanup is executed before the device entry is inserted into the list	2016-01-06 12:35:45 -06:00
Cameron Gutman	006ad72eb2	Check the stdin poll() return value before reading	2016-01-05 19:53:23 -06:00
Cameron Gutman	dc254e1ee5	Some S6s have back buttons on the device called sec_touchkey so also ignore back presses on those too	2016-01-05 00:27:19 -06:00
Cameron Gutman	b0d31a4d35	Update version for 4.0.3 r2	2016-01-04 09:30:56 -06:00
Cameron Gutman	24155feea4	Update common with proper HEVC fix for r2 of 4.0.3	2016-01-04 09:29:22 -06:00
Cameron Gutman	db0a4e35c6	Bump to 4.0.3	2016-01-03 16:35:21 -06:00
Cameron Gutman	68ef98d346	Update common to fix broken mobile 900-series GPU detection for H.265	2016-01-03 16:29:02 -06:00
Karim	f23bb9fac1	improve virtual controller: * add digital 8-Way pad * add on screen element size and position configuration * begin with cleanup	2016-01-03 11:12:43 +01:00
Cameron Gutman	d20dde0b6d	Print a message when the EvdevReader starts	2016-01-02 19:42:40 -06:00
Cameron Gutman	f76b30d109	Fix exceptions in onStop when the connection is aborted due to lack of H.264 support	2016-01-02 18:28:01 -06:00
Cameron Gutman	ee1a047cde	Remove several decoders from the whitelist based on some user-reported issues	2016-01-02 18:16:12 -06:00
hop3l3ss	4c533fedfd	Merge pull request #1 from ruqqq/master Merge https://github.com/limelight-stream/limelight-android	2015-12-31 11:44:42 +01:00
Faruq Rasid	f8ab7b8e13	Merge https://github.com/limelight-stream/limelight-android	2015-12-31 10:14:30 +08:00
Cameron Gutman	46c5eaf0e1	Fix a user-reported crash in USB code	2015-12-23 14:03:55 -06:00
Karim Mreisi	1d6b5a35bd	Merge https://github.com/limelight-stream/limelight-android	2015-02-03 21:52:02 +01:00
Karim Mreisi	1ff6ee14ac	fix analogstick, add minimum range and press deadzone, add movement touch to digital buttons depending on layers	2015-02-03 21:51:27 +01:00
Karim Mreisi	d2e51e97c0	square analog stick for testing	2015-01-28 08:25:22 +01:00
Karim Mreisi	9f94465979	add virtual controller element abstraction class	2015-01-28 07:12:20 +01:00
Karim Mreisi	d83526ff5c	add analog stick double click event, add button long press event, add virtual controller settings draft	2015-01-26 09:38:52 +01:00
Karim Mreisi	1d6b7e1b2e	fix digital button/pad mouse movement, add selct & start button	2015-01-25 09:21:37 +01:00
Karim Mreisi	1c9458d056	fix digital button revoke event, update colors	2015-01-24 11:46:31 +01:00
Karim Mreisi	4e29f2ae8b	add real digital pad and new digital buttons	2015-01-24 10:26:28 +01:00
Karim Mreisi	69321636b5	add LB and RB	2015-01-23 07:30:08 +01:00
Karim Mreisi	d190b254bd	Merge https://github.com/limelight-stream/limelight-android	2015-01-23 06:57:51 +01:00
Karim Mreisi	005a96f3d3	fix not implemented toast message	2015-01-22 09:01:30 +01:00
Karim Mreisi	e39e0910a1	add virtual controller configuration screen	2015-01-22 08:59:55 +01:00
Karim Mreisi	56a6cee8f2	add touch controls	2015-01-22 08:06:14 +01:00