Merge pull request #14 from y3seker/cm-12.1

back button and gestures fixed

1 files changed, 162 insertions, 100 deletions

diff --git a/keyhandler/src/com/cyanogenmod/settings/device/KeyHandler.java b/keyhandler/src/com/cyanogenmod/settings/device/KeyHandler.java
index 926a5bf..9c7dc05 100644
--- a/keyhandler/src/com/cyanogenmod/settings/device/KeyHandler.java
+++ b/keyhandler/src/com/cyanogenmod/settings/device/KeyHandler.java
@@ -49,6 +49,12 @@ import android.view.WindowManagerGlobal;
 import com.android.internal.os.DeviceKeyHandler;
 import com.android.internal.util.ArrayUtils;
 
+import java.io.BufferedReader;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.FileReader;
+import java.io.IOException;
+
 import android.app.Instrumentation;
 import android.content.SharedPreferences;
 import android.content.ContextWrapper;
@@ -58,6 +64,9 @@ public class KeyHandler implements DeviceKeyHandler {
     private static final String TAG = KeyHandler.class.getSimpleName();
     private static final int GESTURE_REQUEST = 1;
 
+    private static final String MEIZU_GESTURE_DATA =
+            "/sys/devices/platform/mx-gs/gesture_data";
+
     private static final String KEY_GESTURE_HAPTIC_FEEDBACK =
             "touchscreen_gesture_haptic_feedback";
 
@@ -67,31 +76,27 @@ public class KeyHandler implements DeviceKeyHandler {
     private static final String ACTION_DISMISS_KEYGUARD =
             "com.android.keyguard.action.DISMISS_KEYGUARD_SECURELY";
 
-    // Supported scancodes
-    private static final int KEY_DOUBLE_TAP = 160;
-    private static final int GESTURE_C_SCANCODE = 193;
-    private static final int GESTURE_Z_SCANCODE = 202;
-    private static final int GESTURE_DOWN_SCANCODE = 179;
-    private static final int GESTURE_LTR_SCANCODE = 176;
-    private static final int GESTURE_GTR_SCANCODE = 177;
-    private static final int MODE_MUTE = 614; //M
-    private static final int MODE_DO_NOT_DISTURB = 616; //S
-    private static final int MODE_NORMAL = 194; //W
+    // M2Note gesture codes
+    public static final int DOUBLE_TAP = 0xA0;
+    public static final int SWIPE_X_LEFT = 0xB0;
+    public static final int SWIPE_X_RIGHT = 0xB1;
+    public static final int SWIPE_Y_UP = 0xB2;
+    public static final int SWIPE_Y_DOWN = 0xB3;
+
+    public static final int UNICODE_E = 0xC0;
+    public static final int UNICODE_C = 0xC1;
+    public static final int UNICODE_W = 0xC2;
+    public static final int UNICODE_M = 0xC3;
+    public static final int UNICODE_O = 0xC4;
+    public static final int UNICODE_S = 0xC5;
+    public static final int UNICODE_V_UP = 0xC6;
+    public static final int UNICODE_V_DOWN = 0xC7;
+    public static final int UNICODE_V_L = 0xC8;
+    public static final int UNICODE_V_R = 0xC9;
+    public static final int UNICODE_Z = 0xCA;
 
     private static final int GESTURE_WAKELOCK_DURATION = 3000;
 
-    private static final int[] sSupportedGestures = new int[] {
-        KEY_DOUBLE_TAP,
-        GESTURE_C_SCANCODE,
-        GESTURE_Z_SCANCODE,
-        GESTURE_DOWN_SCANCODE,
-        GESTURE_LTR_SCANCODE,
-        GESTURE_GTR_SCANCODE,
-        MODE_MUTE,
-        MODE_DO_NOT_DISTURB,
-        MODE_NORMAL
-    };
-
     private final Context mContext;
 
     private final PowerManager mPowerManager;
@@ -159,87 +164,121 @@ public class KeyHandler implements DeviceKeyHandler {
     private class EventHandler extends Handler {
         @Override
         public void handleMessage(Message msg) {
-            KeyEvent event = (KeyEvent) msg.obj;
-            int scanCode = event.getScanCode();
-            switch (scanCode) {
-            case GESTURE_C_SCANCODE:
-                ensureKeyguardManager();
-                final String action;
-                mGestureWakeLock.acquire(GESTURE_WAKELOCK_DURATION);
-                if (mKeyguardManager.isKeyguardSecure() && mKeyguardManager.isKeyguardLocked()) {
-                    action = MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE;
-                } else {
-                    mContext.sendBroadcastAsUser(new Intent(ACTION_DISMISS_KEYGUARD),
-                            UserHandle.CURRENT);
-                    action = MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA;
-                }
-                mPowerManager.wakeUp(SystemClock.uptimeMillis());
-                Intent intent = new Intent(action, null);
-                startActivitySafely(intent);
-                doHapticFeedback();
-                break;
-            case GESTURE_Z_SCANCODE:
-                dispatchMediaKeyWithWakeLockToMediaSession(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE);
-                doHapticFeedback();
-                break;
-            case GESTURE_DOWN_SCANCODE:
-                ensureTorchManager();
-                mGestureWakeLock.acquire(GESTURE_WAKELOCK_DURATION);
-                mTorchManager.toggleTorch();
-                doHapticFeedback();
-                break;
-            case GESTURE_LTR_SCANCODE:
-                dispatchMediaKeyWithWakeLockToMediaSession(KeyEvent.KEYCODE_MEDIA_PREVIOUS);
-                doHapticFeedback();
-                break;
-            case GESTURE_GTR_SCANCODE:
-                dispatchMediaKeyWithWakeLockToMediaSession(KeyEvent.KEYCODE_MEDIA_NEXT);
-                doHapticFeedback();
-                break;
-            case MODE_MUTE:
-            case MODE_DO_NOT_DISTURB:
-            case MODE_NORMAL:
-                int zenMode = Global.ZEN_MODE_OFF;
-                if (scanCode == MODE_MUTE) {
-                    zenMode = Global.ZEN_MODE_NO_INTERRUPTIONS;
-                } else if (scanCode == MODE_DO_NOT_DISTURB) {
-                    zenMode = Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS;
-                }
-                Global.putInt(mContext.getContentResolver(), Global.ZEN_MODE,
-                        zenMode);
-                if (mNotificationSliderVibrate) {
-                    doHapticFeedback();
+            try {
+                int gestureData = (int) msg.obj;
+                Log.i(TAG, "Handling gesture: " + gestureData);
+                switch (gestureData) {
+                    case DOUBLE_TAP:
+                        mPowerManager.wakeUpWithProximityCheck(SystemClock.uptimeMillis());
+                        doHapticFeedback();
+                        break;
+                    case UNICODE_C:
+                        ensureKeyguardManager();
+                        final String action;
+                        mGestureWakeLock.acquire(GESTURE_WAKELOCK_DURATION);
+                        if (mKeyguardManager.isKeyguardSecure() && mKeyguardManager.isKeyguardLocked()) {
+                            action = MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA_SECURE;
+                        } else {
+                            mContext.sendBroadcastAsUser(new Intent(ACTION_DISMISS_KEYGUARD),
+                                    UserHandle.CURRENT);
+                            action = MediaStore.INTENT_ACTION_STILL_IMAGE_CAMERA;
+                        }
+                        mPowerManager.wakeUp(SystemClock.uptimeMillis());
+                        Intent intent = new Intent(action, null);
+                        startActivitySafely(intent);
+                        doHapticFeedback();
+                        break;
+                    case UNICODE_Z:
+                        dispatchMediaKeyWithWakeLockToMediaSession(KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE);
+                        doHapticFeedback();
+                        break;
+                    case SWIPE_Y_DOWN:
+                        ensureTorchManager();
+                        mGestureWakeLock.acquire(GESTURE_WAKELOCK_DURATION);
+                        mTorchManager.toggleTorch();
+                        doHapticFeedback();
+                        break;
+                    case SWIPE_X_LEFT:
+                        dispatchMediaKeyWithWakeLockToMediaSession(KeyEvent.KEYCODE_MEDIA_PREVIOUS);
+                        doHapticFeedback();
+                        break;
+                    case SWIPE_X_RIGHT:
+                        dispatchMediaKeyWithWakeLockToMediaSession(KeyEvent.KEYCODE_MEDIA_NEXT);
+                        doHapticFeedback();
+                        break;
+                    case UNICODE_S:
+                    case UNICODE_W:
+                    case UNICODE_M:
+                        int zenMode = Global.ZEN_MODE_OFF;
+                        if (gestureData == UNICODE_M) {
+                            zenMode = Global.ZEN_MODE_NO_INTERRUPTIONS;
+                        } else if (gestureData == UNICODE_S) {
+                            zenMode = Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS;
+                        }
+                        Global.putInt(mContext.getContentResolver(), Global.ZEN_MODE,
+                                zenMode);
+                        if (mNotificationSliderVibrate) {
+                            doHapticFeedback();
+                        }
+                        mNotificationSliderVibrate = true;
+                        break;
                 }
-                mNotificationSliderVibrate = true;
-                break;
+            } catch (Exception e) {
+                Log.e(TAG, "Gesture EventHandler", e);
+                //e.printStackTrace();
             }
         }
     }
 
+    private boolean isLastPressHomeButton = false;
+
     public boolean handleKeyEvent(KeyEvent event) {
-        if (event.getAction() != KeyEvent.ACTION_UP) {
-            return false;
-        }
-        boolean isKeySupported = ArrayUtils.contains(sSupportedGestures, event.getScanCode());
-        if (isKeySupported && !mEventHandler.hasMessages(GESTURE_REQUEST)) {
-            if (event.getScanCode() == KEY_DOUBLE_TAP && !mPowerManager.isScreenOn()) {
-                mPowerManager.wakeUpWithProximityCheck(SystemClock.uptimeMillis());
-                doHapticFeedback();
-                return true;
-            }
-            Message msg = getMessageForKeyEvent(event);
-            boolean defaultProximity = mContext.getResources().getBoolean(
-                com.android.internal.R.bool.config_proximityCheckOnWakeEnabledByDefault);
-            boolean proximityWakeCheckEnabled = Settings.System.getInt(mContext.getContentResolver(),
-                    Settings.System.PROXIMITY_ON_WAKE, defaultProximity ? 1 : 0) == 1;
-            if (mProximityWakeSupported && proximityWakeCheckEnabled && mProximitySensor != null) {
-                mEventHandler.sendMessageDelayed(msg, mProximityTimeOut);
-                processEvent(event);
-            } else {
-                mEventHandler.sendMessage(msg);
-            }
+        boolean isHandled = false;
+
+        switch (event.getScanCode()) {
+            case 102: // Home button event
+                if (event.getDeviceId() == 2 && event.getAction() == KeyEvent.ACTION_DOWN) {
+                    if (isLastPressHomeButton) {
+                        isHandled = true;
+                    }
+                }
+                isLastPressHomeButton = event.getDeviceId() == 6;
+                break;
+            case 195: // Gesture event
+                if (event.getAction() == KeyEvent.ACTION_UP)
+                    return true;
+
+                try {
+                    int gestureData = readGestureData();
+                    if (gestureData == 0)
+                        return true;
+
+                    if (!mEventHandler.hasMessages(GESTURE_REQUEST)) {
+                        Message msg = getGestureMessage(gestureData);
+                        boolean defaultProximity = mContext.getResources().getBoolean(
+                                com.android.internal.R.bool.config_proximityCheckOnWakeEnabledByDefault);
+                        boolean proximityWakeCheckEnabled = Settings.System.getInt(mContext.getContentResolver(),
+                                Settings.System.PROXIMITY_ON_WAKE, defaultProximity ? 1 : 0) == 1;
+                        if (mProximityWakeSupported && proximityWakeCheckEnabled && mProximitySensor != null) {
+                            mEventHandler.sendMessageDelayed(msg, mProximityTimeOut);
+                            processEvent(event);
+                        } else {
+                            mEventHandler.sendMessage(msg);
+                        }
+                    }
+                    return true;
+                } catch (Exception e) {
+                    // Gesture data read failed
+                    return false;
+                }
         }
-        return isKeySupported;
+        return isHandled;
+    }
+
+    private Message getGestureMessage(int gestureData) {
+        Message msg = mEventHandler.obtainMessage(GESTURE_REQUEST);
+        msg.obj = gestureData;
+        return msg;
     }
 
     private Message getMessageForKeyEvent(KeyEvent keyEvent) {
@@ -267,7 +306,8 @@ public class KeyHandler implements DeviceKeyHandler {
             }
 
             @Override
-            public void onAccuracyChanged(Sensor sensor, int accuracy) {}
+            public void onAccuracyChanged(Sensor sensor, int accuracy) {
+            }
 
         }, mProximitySensor, SensorManager.SENSOR_DELAY_FASTEST);
     }
@@ -288,8 +328,8 @@ public class KeyHandler implements DeviceKeyHandler {
     private void startActivitySafely(Intent intent) {
         intent.addFlags(
                 Intent.FLAG_ACTIVITY_NEW_TASK
-                | Intent.FLAG_ACTIVITY_SINGLE_TOP
-                | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+                        | Intent.FLAG_ACTIVITY_SINGLE_TOP
+                        | Intent.FLAG_ACTIVITY_CLEAR_TOP);
         try {
             UserHandle user = new UserHandle(UserHandle.USER_CURRENT);
             mContext.startActivityAsUser(intent, null, user);
@@ -314,4 +354,26 @@ public class KeyHandler implements DeviceKeyHandler {
             mVibrator.vibrate(50);
         }
     }
-}
+
+    public String readSingleLine(File f) throws IOException {
+        BufferedReader reader = null;
+        try {
+            reader = new BufferedReader(new FileReader(f));
+            String line = reader.readLine();
+            reader.close();
+            return line;
+        } finally {
+            if (reader != null) {
+                try {
+                    reader.close();
+                } catch (IOException ignored) {
+                }
+            }
+        }
+    }
+
+    private int readGestureData() throws Exception {
+        File f = new File(MEIZU_GESTURE_DATA);
+        return Integer.valueOf(readSingleLine(f));
+    }
+}
\ No newline at end of file