msm8996-common: doze improvements

* restructure the app
* add a tilt sensor from hammerhead-caf with an option to enable/disable
* add a one time dialog on first start to help users understand how the app works
* remove proximity wake up option and add an option to enable the sensors as soon as the screen turns off
* adjust and add new doze configs
* squashed translations

Change-Id: Ia9d9a807d6c4f1a80a2ba8780e7486560f9a1d87
Signed-off-by: Davide Garberi <dade.garberi@gmail.com>

7 files changed, 493 insertions, 257 deletions

diff --git a/doze/src/com/cyanogenmod/settings/doze/BootCompletedReceiver.java b/doze/src/com/cyanogenmod/settings/doze/BootCompletedReceiver.java
index af656fe..e1b2b50 100644
--- a/doze/src/com/cyanogenmod/settings/doze/BootCompletedReceiver.java
+++ b/doze/src/com/cyanogenmod/settings/doze/BootCompletedReceiver.java
@@ -28,8 +28,10 @@ public class BootCompletedReceiver extends BroadcastReceiver {
 
     @Override
     public void onReceive(final Context context, Intent intent) {
-        if (DEBUG) Log.d(TAG, "Starting service");
-        context.startService(new Intent(context, ZukDozeService.class));
+        if (Utils.isDozeEnabled(context) && Utils.sensorsEnabled(context)) {
+            if (DEBUG) Log.d(TAG, "Starting service");
+            Utils.startService(context);
+        }
     }
 
 }
diff --git a/doze/src/com/cyanogenmod/settings/doze/DozeService.java b/doze/src/com/cyanogenmod/settings/doze/DozeService.java
new file mode 100644
index 0000000..354d97f
--- /dev/null
+++ b/doze/src/com/cyanogenmod/settings/doze/DozeService.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (c) 2015 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.cyanogenmod.settings.doze;
+
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentFilter;
+import android.os.IBinder;
+import android.util.Log;
+
+public class DozeService extends Service {
+    private static final String TAG = "DozeService";
+    private static final boolean DEBUG = false;
+
+    private ProximitySensor mProximitySensor;
+    private TiltSensor mTiltSensor;
+
+    @Override
+    public void onCreate() {
+        if (DEBUG) Log.d(TAG, "Creating service");
+        mProximitySensor = new ProximitySensor(this);
+        mTiltSensor = new TiltSensor(this);
+
+        IntentFilter screenStateFilter = new IntentFilter(Intent.ACTION_SCREEN_ON);
+        screenStateFilter.addAction(Intent.ACTION_SCREEN_OFF);
+        registerReceiver(mScreenStateReceiver, screenStateFilter);
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        if (DEBUG) Log.d(TAG, "Starting service");
+        return START_STICKY;
+    }
+
+    @Override
+    public void onDestroy() {
+        if (DEBUG) Log.d(TAG, "Destroying service");
+        super.onDestroy();
+        this.unregisterReceiver(mScreenStateReceiver);
+        mProximitySensor.disable();
+        mTiltSensor.disable();
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    private void onDisplayOn() {
+        if (DEBUG) Log.d(TAG, "Display on");
+        if (Utils.pickUpEnabled(this)) {
+            mTiltSensor.disable();
+        }
+        if (Utils.handwaveGestureEnabled(this) ||
+                Utils.pocketGestureEnabled(this)) {
+            mProximitySensor.disable();
+        }
+    }
+
+    private void onDisplayOff() {
+        if (DEBUG) Log.d(TAG, "Display off");
+        if (Utils.pickUpEnabled(this) && Utils.tiltAlwaysEnabled(this)) {
+            mTiltSensor.enable();
+        }
+        if (Utils.proximityAlwaysEnabled(this) && (Utils.handwaveGestureEnabled(this) ||
+                Utils.pocketGestureEnabled(this))) {
+            mProximitySensor.enable();
+        }
+    }
+
+    private BroadcastReceiver mScreenStateReceiver = new BroadcastReceiver() {
+        @Override
+        public void onReceive(Context context, Intent intent) {
+            if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
+                onDisplayOn();
+            } else if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
+                onDisplayOff();
+            }
+        }
+    };
+}
diff --git a/doze/src/com/cyanogenmod/settings/doze/DozeSettings.java b/doze/src/com/cyanogenmod/settings/doze/DozeSettings.java
index d0697db..d2c408a 100644
--- a/doze/src/com/cyanogenmod/settings/doze/DozeSettings.java
+++ b/doze/src/com/cyanogenmod/settings/doze/DozeSettings.java
@@ -17,61 +17,84 @@
 package com.cyanogenmod.settings.doze;
 
 import android.app.ActionBar;
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.DialogFragment;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.SharedPreferences;
 import android.os.Bundle;
 import android.preference.Preference;
+import android.preference.Preference.OnPreferenceChangeListener;
 import android.preference.PreferenceActivity;
+import android.preference.PreferenceScreen;
 import android.preference.SwitchPreference;
 import android.provider.Settings;
 import android.view.Menu;
 import android.view.MenuItem;
 
-import org.cyanogenmod.internal.util.ScreenType;
+public class DozeSettings extends PreferenceActivity implements OnPreferenceChangeListener {
 
-public class DozeSettings extends PreferenceActivity {
-
-    private static final String KEY_AMBIENT_DISPLAY_ENABLE = "ambient_display_enable";
-    private static final String KEY_HAND_WAVE = "gesture_hand_wave";
-    private static final String KEY_GESTURE_POCKET = "gesture_pocket";
-    private static final String KEY_PROXIMITY_WAKE = "proximity_wake_enable";
+    private Context mContext;
+    private SharedPreferences mPreferences;
 
     private SwitchPreference mAmbientDisplayPreference;
+    private SwitchPreference mPickUpPreference;
+    private SwitchPreference mTiltAlwaysPreference;
     private SwitchPreference mHandwavePreference;
     private SwitchPreference mPocketPreference;
-    private SwitchPreference mProximityWakePreference;
+    private SwitchPreference mProximityAlwaysPreference;
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
-        addPreferencesFromResource(R.xml.gesture_panel);
-        boolean dozeEnabled = isDozeEnabled();
+        addPreferencesFromResource(R.xml.doze_settings);
+        mContext = getApplicationContext();
+        boolean dozeEnabled = Utils.isDozeEnabled(mContext);
+
+        // get shared preference
+        mPreferences = mContext.getSharedPreferences("doze_settings", Activity.MODE_PRIVATE);
+        if (savedInstanceState == null && !mPreferences.getBoolean("first_help_shown", false)) {
+            showHelp();
+        }
+
         mAmbientDisplayPreference =
-            (SwitchPreference) findPreference(KEY_AMBIENT_DISPLAY_ENABLE);
+            (SwitchPreference) findPreference(Utils.AMBIENT_DISPLAY_KEY);
         // Read from DOZE_ENABLED secure setting
         mAmbientDisplayPreference.setChecked(dozeEnabled);
-        mAmbientDisplayPreference.setOnPreferenceChangeListener(mAmbientDisplayPrefListener);
+        mAmbientDisplayPreference.setOnPreferenceChangeListener(this);
+
+        mTiltAlwaysPreference =
+            (SwitchPreference) findPreference(Utils.TILT_ALWAYS_KEY);
+        mTiltAlwaysPreference.setOnPreferenceChangeListener(this);
+
+        mPickUpPreference =
+            (SwitchPreference) findPreference(Utils.PICK_UP_KEY);
+        mPickUpPreference.setOnPreferenceChangeListener(this);
+
         mHandwavePreference =
-            (SwitchPreference) findPreference(KEY_HAND_WAVE);
-        mHandwavePreference.setEnabled(dozeEnabled);
-        mHandwavePreference.setOnPreferenceChangeListener(mProximityListener);
+            (SwitchPreference) findPreference(Utils.GESTURE_HAND_WAVE_KEY);
+        mHandwavePreference.setOnPreferenceChangeListener(this);
+
         mPocketPreference =
-            (SwitchPreference) findPreference(KEY_GESTURE_POCKET);
-        mPocketPreference.setEnabled(dozeEnabled);
-        mProximityWakePreference =
-            (SwitchPreference) findPreference(KEY_PROXIMITY_WAKE);
-        mProximityWakePreference.setOnPreferenceChangeListener(mProximityListener);
+            (SwitchPreference) findPreference(Utils.GESTURE_POCKET_KEY);
+        mPocketPreference.setOnPreferenceChangeListener(this);
+
+        mProximityAlwaysPreference =
+            (SwitchPreference) findPreference(Utils.PROXIMITY_ALWAYS_KEY);
+        mProximityAlwaysPreference.setOnPreferenceChangeListener(this);
 
         final ActionBar actionBar = getActionBar();
         actionBar.setDisplayHomeAsUpEnabled(true);
+
+        updateAlwaysEnabledPreference();
     }
 
     @Override
     protected void onResume() {
         super.onResume();
-
-        // If running on a phone, remove padding around the listview
-        if (!ScreenType.isTablet(this)) {
-            getListView().setPadding(0, 0, 0, 0);
-        }
+        updateAlwaysEnabledPreference();
     }
 
     @Override
@@ -83,42 +106,73 @@ public class DozeSettings extends PreferenceActivity {
         return false;
     }
 
-    private boolean enableDoze(boolean enable) {
-        return Settings.Secure.putInt(getContentResolver(),
-                Settings.Secure.DOZE_ENABLED, enable ? 1 : 0);
-    }
-
-    private boolean isDozeEnabled() {
-        return Settings.Secure.getInt(getContentResolver(),
-                Settings.Secure.DOZE_ENABLED, 1) != 0;
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        final String key = preference.getKey();
+        final boolean value = (Boolean) newValue;
+        if (Utils.AMBIENT_DISPLAY_KEY.equals(key)) {
+            mAmbientDisplayPreference.setChecked(value);
+            Utils.enableDoze(value, mContext);
+            return true;
+        } else if (Utils.PICK_UP_KEY.equals(key)) {
+            mPickUpPreference.setChecked(value);
+            updateAlwaysEnabledPreference();
+            Utils.startService(mContext);
+            return true;
+        } else if (Utils.TILT_ALWAYS_KEY.equals(key)) {
+            mTiltAlwaysPreference.setChecked(value);
+            return true;
+        } else if (Utils.GESTURE_HAND_WAVE_KEY.equals(key)) {
+            mHandwavePreference.setChecked(value);
+            updateAlwaysEnabledPreference();
+            Utils.startService(mContext);
+            return true;
+        } else if (Utils.GESTURE_POCKET_KEY.equals(key)) {
+            mPocketPreference.setChecked(value);
+            updateAlwaysEnabledPreference();
+            Utils.startService(mContext);
+            return true;
+        } else if (Utils.PROXIMITY_ALWAYS_KEY.equals(key)) {
+            mProximityAlwaysPreference.setChecked(value);
+            return true;
+        }
+        return false;
     }
 
-    private Preference.OnPreferenceChangeListener mAmbientDisplayPrefListener =
-        new Preference.OnPreferenceChangeListener() {
+    public static class HelpDialogFragment extends DialogFragment {
         @Override
-        public boolean onPreferenceChange(Preference preference, Object newValue) {
-            boolean enable = (boolean) newValue;
-            boolean ret = enableDoze(enable);
-            if (ret) {
-                mHandwavePreference.setEnabled(enable);
-                mPocketPreference.setEnabled(enable);
-            }
-            return ret;
+        public Dialog onCreateDialog(Bundle savedInstanceState) {
+            return new AlertDialog.Builder(getActivity())
+                    .setTitle(R.string.doze_settings_help_title)
+                    .setMessage(R.string.doze_settings_help_text)
+                    .setNegativeButton(R.string.dlg_ok, new DialogInterface.OnClickListener() {
+                        @Override
+                        public void onClick(DialogInterface dialog, int which) {
+                            dialog.cancel();
+                        }
+                    })
+                    .create();
         }
-    };
 
-    private Preference.OnPreferenceChangeListener mProximityListener =
-        new Preference.OnPreferenceChangeListener() {
         @Override
-        public boolean onPreferenceChange(Preference preference, Object newValue) {
-            if ((boolean) newValue) {
-                if (preference.getKey().equals(KEY_HAND_WAVE)) {
-                    mProximityWakePreference.setChecked(false);
-                } else if (preference.getKey().equals(KEY_PROXIMITY_WAKE)) {
-                    mHandwavePreference.setChecked(false);
-                }
-            }
-            return true;
+        public void onCancel(DialogInterface dialog) {
+            getActivity().getSharedPreferences("doze_settings", Activity.MODE_PRIVATE)
+                    .edit()
+                    .putBoolean("first_help_shown", true)
+                    .commit();
         }
-    };
+    }
+
+    private void showHelp() {
+        HelpDialogFragment fragment = new HelpDialogFragment();
+        fragment.show(getFragmentManager(), "help_dialog");
+    }
+
+    private void updateAlwaysEnabledPreference() {
+        boolean tiltEnabled = Utils.pickUpEnabled(mContext);
+        boolean proximityEnabled = Utils.handwaveGestureEnabled(mContext)
+                || Utils.pocketGestureEnabled(mContext);
+        mTiltAlwaysPreference.setEnabled(tiltEnabled);
+        mProximityAlwaysPreference.setEnabled(proximityEnabled);
+    }
 }
diff --git a/doze/src/com/cyanogenmod/settings/doze/ProximitySensor.java b/doze/src/com/cyanogenmod/settings/doze/ProximitySensor.java
new file mode 100644
index 0000000..0f62b11
--- /dev/null
+++ b/doze/src/com/cyanogenmod/settings/doze/ProximitySensor.java
@@ -0,0 +1,91 @@
+/*
+ * Copyright (c) 2015 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.cyanogenmod.settings.doze;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.util.Log;
+
+public class ProximitySensor implements SensorEventListener {
+
+    private static final boolean DEBUG = false;
+    private static final String TAG = "ProximitySensor";
+
+    private static final int POCKET_DELTA_NS = 1000 * 1000 * 1000;
+
+    private SensorManager mSensorManager;
+    private Sensor mSensor;
+    private Context mContext;
+
+    private boolean mSawNear = false;
+    private long mInPocketTime = 0;
+
+    public ProximitySensor(Context context) {
+        mContext = context;
+        mSensorManager = (SensorManager)
+                mContext.getSystemService(Context.SENSOR_SERVICE);
+        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
+    }
+
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+        boolean isNear = event.values[0] < mSensor.getMaximumRange();
+        if (mSawNear && !isNear) {
+            if (shouldPulse(event.timestamp)) {
+                Utils.launchDozePulse(mContext);
+            }
+        } else {
+            mInPocketTime = event.timestamp;
+        }
+        mSawNear = isNear;
+    }
+
+    private boolean shouldPulse(long timestamp) {
+        long delta = timestamp - mInPocketTime;
+
+        if (Utils.handwaveGestureEnabled(mContext)
+                    && Utils.pocketGestureEnabled(mContext)) {
+            return true;
+        } else if (Utils.handwaveGestureEnabled(mContext)
+                    && !Utils.pocketGestureEnabled(mContext)) {
+            return delta < POCKET_DELTA_NS;
+        } else if (!Utils.handwaveGestureEnabled(mContext)
+                    && Utils.pocketGestureEnabled(mContext)) {
+            return delta >= POCKET_DELTA_NS;
+        }
+        return false;
+    }
+
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+        /* Empty */
+    }
+
+    protected void enable() {
+        if (DEBUG) Log.d(TAG, "Enabling");
+        mSensorManager.registerListener(this, mSensor,
+                SensorManager.SENSOR_DELAY_NORMAL);
+    }
+
+    protected void disable() {
+        if (DEBUG) Log.d(TAG, "Disabling");
+        mSensorManager.unregisterListener(this, mSensor);
+    }
+}
diff --git a/doze/src/com/cyanogenmod/settings/doze/TiltSensor.java b/doze/src/com/cyanogenmod/settings/doze/TiltSensor.java
new file mode 100644
index 0000000..443a10d
--- /dev/null
+++ b/doze/src/com/cyanogenmod/settings/doze/TiltSensor.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2015 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.cyanogenmod.settings.doze;
+
+import android.content.Context;
+import android.hardware.Sensor;
+import android.hardware.SensorEvent;
+import android.hardware.SensorEventListener;
+import android.hardware.SensorManager;
+import android.os.PowerManager;
+import android.os.PowerManager.WakeLock;
+import android.os.SystemClock;
+import android.util.Log;
+
+public class TiltSensor implements SensorEventListener {
+
+    private static final boolean DEBUG = false;
+    private static final String TAG = "TiltSensor";
+
+    private static final int SENSOR_WAKELOCK_DURATION = 200;
+    private static final int BATCH_LATENCY_IN_MS = 100;
+    private static final int MIN_PULSE_INTERVAL_MS = 2500;
+
+    private PowerManager mPowerManager;
+    private SensorManager mSensorManager;
+    private Sensor mSensor;
+    private WakeLock mSensorWakeLock;
+    private Context mContext;
+
+    private long mEntryTimestamp;
+
+    public TiltSensor(Context context) {
+        mContext = context;
+        mPowerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
+        mSensorManager = (SensorManager) mContext.getSystemService(Context.SENSOR_SERVICE);
+        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_TILT_DETECTOR);
+        mSensorWakeLock = mPowerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK,
+                "SensorWakeLock");
+    }
+
+    @Override
+    public void onSensorChanged(SensorEvent event) {
+        if (DEBUG) Log.d(TAG, "Got sensor event: " + event.values[0]);
+
+        long delta = SystemClock.elapsedRealtime() - mEntryTimestamp;
+        if (delta < MIN_PULSE_INTERVAL_MS) {
+            return;
+        } else {
+            mEntryTimestamp = SystemClock.elapsedRealtime();
+        }
+
+        if (event.values[0] == 1) {
+            Utils.launchDozePulse(mContext);
+        }
+    }
+
+    @Override
+    public void onAccuracyChanged(Sensor sensor, int accuracy) {
+        /* Empty */
+    }
+
+    protected void enable() {
+        if (DEBUG) Log.d(TAG, "Enabling");
+        mSensorManager.registerListener(this, mSensor,
+                SensorManager.SENSOR_DELAY_NORMAL, BATCH_LATENCY_IN_MS * 1000);
+        mEntryTimestamp = SystemClock.elapsedRealtime();
+    }
+
+    protected void disable() {
+        if (DEBUG) Log.d(TAG, "Disabling");
+        mSensorManager.unregisterListener(this, mSensor);
+    }
+}
diff --git a/doze/src/com/cyanogenmod/settings/doze/Utils.java b/doze/src/com/cyanogenmod/settings/doze/Utils.java
new file mode 100644
index 0000000..bdc696b
--- /dev/null
+++ b/doze/src/com/cyanogenmod/settings/doze/Utils.java
@@ -0,0 +1,104 @@
+/*
+ * Copyright (c) 2015 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.cyanogenmod.settings.doze;
+
+import android.app.ActivityManager;
+import android.app.ActivityManager.RunningServiceInfo;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.os.UserHandle;
+import android.preference.PreferenceManager;
+import android.provider.Settings;
+import android.util.Log;
+
+public final class Utils {
+
+    private static final String TAG = "DozeUtils";
+    private static final boolean DEBUG = false;
+
+    private static final String DOZE_INTENT = "com.android.systemui.doze.pulse";
+
+    protected static final String AMBIENT_DISPLAY_KEY = "ambient_display";
+    protected static final String PICK_UP_KEY = "pick_up";
+    protected static final String TILT_ALWAYS_KEY = "tilt_always";
+    protected static final String GESTURE_HAND_WAVE_KEY = "gesture_hand_wave";
+    protected static final String GESTURE_POCKET_KEY = "gesture_pocket";
+    protected static final String PROXIMITY_ALWAYS_KEY = "proximity_always";
+
+    protected static void startService(Context context) {
+        if (DEBUG) Log.d(TAG, "Starting service");
+        context.startService(new Intent(context, DozeService.class));
+    }
+
+    protected static void stopService(Context context) {
+        if (DEBUG) Log.d(TAG, "Stopping service");
+        context.stopService(new Intent(context, DozeService.class));
+    }
+
+    protected static boolean isDozeEnabled(Context context) {
+        return Settings.Secure.getInt(context.getContentResolver(),
+                Settings.Secure.DOZE_ENABLED, 1) != 0;
+    }
+
+    protected static boolean enableDoze(boolean enable, Context context) {
+        boolean dozeEnabled = Settings.Secure.putInt(context.getContentResolver(),
+                Settings.Secure.DOZE_ENABLED, enable ? 1 : 0);
+        if (enable) {
+            startService(context);
+        } else {
+            stopService(context);
+        }
+        return dozeEnabled;
+    }
+
+    protected static void launchDozePulse(Context context) {
+        if (DEBUG) Log.d(TAG, "Launch doze pulse");
+        context.sendBroadcastAsUser(new Intent(DOZE_INTENT),
+                new UserHandle(UserHandle.USER_CURRENT));
+    }
+
+    protected static boolean pickUpEnabled(Context context) {
+        return PreferenceManager.getDefaultSharedPreferences(context)
+                .getBoolean(PICK_UP_KEY, false);
+    }
+
+    protected static boolean tiltAlwaysEnabled(Context context) {
+        return PreferenceManager.getDefaultSharedPreferences(context)
+                .getBoolean(TILT_ALWAYS_KEY, false);
+    }
+
+    protected static boolean handwaveGestureEnabled(Context context) {
+        return PreferenceManager.getDefaultSharedPreferences(context)
+                .getBoolean(GESTURE_HAND_WAVE_KEY, false);
+    }
+
+    protected static boolean pocketGestureEnabled(Context context) {
+        return PreferenceManager.getDefaultSharedPreferences(context)
+                .getBoolean(GESTURE_POCKET_KEY, false);
+    }
+
+    protected static boolean proximityAlwaysEnabled(Context context) {
+        return PreferenceManager.getDefaultSharedPreferences(context)
+                .getBoolean(PROXIMITY_ALWAYS_KEY, false);
+    }
+
+    protected static boolean sensorsEnabled(Context context) {
+        return pickUpEnabled(context) || handwaveGestureEnabled(context)
+                || pocketGestureEnabled(context);
+    }
+}
diff --git a/doze/src/com/cyanogenmod/settings/doze/ZukDozeService.java b/doze/src/com/cyanogenmod/settings/doze/ZukDozeService.java
deleted file mode 100644
index 4163972..0000000
--- a/doze/src/com/cyanogenmod/settings/doze/ZukDozeService.java
+++ /dev/null
@@ -1,199 +0,0 @@
-/*
- * Copyright (c) 2015 The CyanogenMod Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.cyanogenmod.settings.doze;
-
-import android.app.Service;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
-import android.content.SharedPreferences;
-import android.hardware.Sensor;
-import android.hardware.SensorEvent;
-import android.hardware.SensorEventListener;
-import android.hardware.SensorManager;
-import android.os.IBinder;
-import android.os.PowerManager;
-import android.preference.PreferenceManager;
-import android.provider.Settings;
-import android.util.Log;
-
-import java.lang.System;
-import java.util.ArrayList;
-import java.util.concurrent.TimeUnit;
-import java.util.List;
-
-public class ZukDozeService extends Service {
-    private static final String TAG = "ZukDozeService";
-    private static final boolean DEBUG = false;
-
-    private static final String DOZE_INTENT = "com.android.systemui.doze.pulse";
-
-    private static final String GESTURE_HAND_WAVE_KEY = "gesture_hand_wave";
-    private static final String GESTURE_POCKET_KEY = "gesture_pocket";
-    private static final String PROXIMITY_WAKE_KEY = "proximity_wake_enable";
-
-    private static final int POCKET_DELTA_NS = 1000 * 1000 * 1000;
-
-    private Context mContext;
-    private OneplusProximitySensor mSensor;
-    private PowerManager mPowerManager;
-
-    private boolean mHandwaveGestureEnabled = false;
-    private boolean mPocketGestureEnabled = false;
-    private boolean mProximityWakeEnabled = false;
-
-    class OneplusProximitySensor implements SensorEventListener {
-        private SensorManager mSensorManager;
-        private Sensor mSensor;
-
-        private boolean mSawNear = false;
-        private long mInPocketTime = 0;
-
-        public OneplusProximitySensor(Context context) {
-            mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
-            mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
-        }
-
-        @Override
-        public void onSensorChanged(SensorEvent event) {
-            boolean isNear = event.values[0] < mSensor.getMaximumRange();
-            if (mSawNear && !isNear) {
-                if (shouldPulse(event.timestamp)) {
-                    launchDozePulse();
-                }
-            } else {
-                mInPocketTime = event.timestamp;
-            }
-            mSawNear = isNear;
-        }
-
-        @Override
-        public void onAccuracyChanged(Sensor sensor, int accuracy) {
-            /* Empty */
-        }
-
-        private boolean shouldPulse(long timestamp) {
-            long delta = timestamp - mInPocketTime;
-
-            if (mHandwaveGestureEnabled && mPocketGestureEnabled) {
-                return true;
-            } else if (mProximityWakeEnabled && (delta < POCKET_DELTA_NS)) {
-                mPowerManager.wakeUp(TimeUnit.NANOSECONDS.toMillis(System.nanoTime()));
-                return false;
-            } else if (mHandwaveGestureEnabled && !mPocketGestureEnabled) {
-                return delta < POCKET_DELTA_NS;
-            } else if (!mHandwaveGestureEnabled && mPocketGestureEnabled) {
-                return delta >= POCKET_DELTA_NS;
-            }
-            return false;
-        }
-
-        public void testAndEnable() {
-            if ((isDozeEnabled() && (mHandwaveGestureEnabled || mPocketGestureEnabled)) ||
-                    mProximityWakeEnabled) {
-                mSensorManager.registerListener(this, mSensor, SensorManager.SENSOR_DELAY_NORMAL);
-            }
-        }
-
-        public void disable() {
-            mSensorManager.unregisterListener(this, mSensor);
-        }
-    }
-
-    @Override
-    public void onCreate() {
-        if (DEBUG) Log.d(TAG, "ZukDozeService Started");
-        mContext = this;
-        mPowerManager = (PowerManager)getSystemService(Context.POWER_SERVICE);
-        mSensor = new OneplusProximitySensor(mContext);
-        SharedPreferences sharedPrefs = PreferenceManager.getDefaultSharedPreferences(mContext);
-        loadPreferences(sharedPrefs);
-        sharedPrefs.registerOnSharedPreferenceChangeListener(mPrefListener);
-        if (!isInteractive()) {
-            mSensor.testAndEnable();
-        }
-    }
-
-    @Override
-    public int onStartCommand(Intent intent, int flags, int startId) {
-        if (DEBUG) Log.d(TAG, "Starting service");
-        IntentFilter screenStateFilter = new IntentFilter(Intent.ACTION_SCREEN_ON);
-        screenStateFilter.addAction(Intent.ACTION_SCREEN_OFF);
-        mContext.registerReceiver(mScreenStateReceiver, screenStateFilter);
-        return START_STICKY;
-    }
-
-    @Override
-    public IBinder onBind(Intent intent) {
-        return null;
-    }
-
-    private void launchDozePulse() {
-        mContext.sendBroadcast(new Intent(DOZE_INTENT));
-    }
-
-    private boolean isInteractive() {
-        return mPowerManager.isInteractive();
-    }
-
-    private boolean isDozeEnabled() {
-        return Settings.Secure.getInt(mContext.getContentResolver(),
-                Settings.Secure.DOZE_ENABLED, 1) != 0;
-    }
-
-    private void onDisplayOn() {
-        if (DEBUG) Log.d(TAG, "Display on");
-        mSensor.disable();
-    }
-
-    private void onDisplayOff() {
-        if (DEBUG) Log.d(TAG, "Display off");
-        mSensor.testAndEnable();
-    }
-
-    private void loadPreferences(SharedPreferences sharedPreferences) {
-        mHandwaveGestureEnabled = sharedPreferences.getBoolean(GESTURE_HAND_WAVE_KEY, false);
-        mPocketGestureEnabled = sharedPreferences.getBoolean(GESTURE_POCKET_KEY, false);
-        mProximityWakeEnabled = sharedPreferences.getBoolean(PROXIMITY_WAKE_KEY, false);
-    }
-
-    private BroadcastReceiver mScreenStateReceiver = new BroadcastReceiver() {
-        @Override
-        public void onReceive(Context context, Intent intent) {
-            if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
-                onDisplayOff();
-            } else if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
-                onDisplayOn();
-            }
-        }
-    };
-
-    private SharedPreferences.OnSharedPreferenceChangeListener mPrefListener =
-            new SharedPreferences.OnSharedPreferenceChangeListener() {
-        @Override
-        public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
-            if (GESTURE_HAND_WAVE_KEY.equals(key)) {
-                mHandwaveGestureEnabled = sharedPreferences.getBoolean(GESTURE_HAND_WAVE_KEY, false);
-            } else if (GESTURE_POCKET_KEY.equals(key)) {
-                mPocketGestureEnabled = sharedPreferences.getBoolean(GESTURE_POCKET_KEY, false);
-            } else if (PROXIMITY_WAKE_KEY.equals(key)) {
-                mProximityWakeEnabled = sharedPreferences.getBoolean(PROXIMITY_WAKE_KEY, false);
-            }
-        }
-    };
-}