src/com/android/settings/gestures/GestureSettings.java

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.settings.gestures;
  18
  19 import android.content.Context;
  20 import android.content.res.Resources;
  21 import android.hardware.Sensor;
  22 import android.hardware.SensorManager;
  23 import android.os.Build;
  24 import android.os.Bundle;
  25 import android.os.SystemProperties;
  26 import android.provider.SearchIndexableResource;
  27 import android.provider.Settings.Secure;
  28 import android.support.v7.preference.Preference;
  29 import android.support.v7.widget.RecyclerView;
  30 import android.text.TextUtils;
  31 import android.view.LayoutInflater;
  32 import android.view.View;
  33 import android.view.ViewGroup;
  34
  35 import com.android.internal.logging.MetricsProto.MetricsEvent;
  36 import com.android.settings.R;
  37 import com.android.settings.search.BaseSearchIndexProvider;
  38 import com.android.settings.search.Indexable;
  39 import com.android.settings.SettingsPreferenceFragment;
  40
  41 import java.util.ArrayList;
  42 import java.util.List;
  43
  44 /**
  45  * Top level fragment for gesture settings.
  46  * This will create individual switch preference for each gesture and handle updates when each
  47  * preference is updated
  48  */
  49 public class GestureSettings extends SettingsPreferenceFragment implements
  50         Preference.OnPreferenceChangeListener, Indexable {
  51
  52     private static final String TAG = "GestureSettings";
  53     private static final String PREF_KEY_DOUBLE_TAP_POWER = "gesture_double_tap_power";
  54     private static final String PREF_KEY_DOUBLE_TWIST = "gesture_double_twist";
  55     private static final String PREF_KEY_PICK_UP = "gesture_pick_up";
  56     private static final String PREF_KEY_SWIPE_DOWN_FINGERPRINT = "gesture_swipe_down_fingerprint";
  57     private static final String PREF_KEY_DOUBLE_TAP_SCREEN = "gesture_double_tap_screen";
  58     private static final String DEBUG_DOZE_COMPONENT = "debug.doze.component";
  59     private static final int PREF_ID_DOUBLE_TAP_POWER = 0;
  60     private static final int PREF_ID_DOUBLE_TWIST = 1;
  61     private static final int PREF_ID_PICK_UP = 2;
  62     private static final int PREF_ID_SWIPE_DOWN_FINGERPRINT = 3;
  63     private static final int PREF_ID_DOUBLE_TAP_SCREEN = 4;
  64
  65     private List<GesturePreference> mPreferences;
  66
  67     @Override
  68     public void onCreate(Bundle savedInstanceState) {
  69         super.onCreate(savedInstanceState);
  70         addPreferencesFromResource(R.xml.gesture_settings);
  71         Context context = getActivity();
  72         mPreferences = new ArrayList();
  73
  74         // Double tap power for camera
  75         if (isCameraDoubleTapPowerGestureAvailable(getResources())) {
  76             int cameraDisabled = Secure.getInt(
  77                     getContentResolver(), Secure.CAMERA_DOUBLE_TAP_POWER_GESTURE_DISABLED, 0);
  78             addPreference(PREF_KEY_DOUBLE_TAP_POWER, cameraDisabled == 0, PREF_ID_DOUBLE_TAP_POWER);
  79         } else {
  80             removePreference(PREF_KEY_DOUBLE_TAP_POWER);
  81         }
  82
  83         // Ambient Display
  84         boolean dozeEnabled = isDozeAvailable(context);
  85         if (dozeEnabled) {
  86             int pickup = Secure.getInt(getContentResolver(), Secure.DOZE_PULSE_ON_PICK_UP, 1);
  87             addPreference(PREF_KEY_PICK_UP, pickup != 0, PREF_ID_PICK_UP);
  88         } else {
  89             removePreference(PREF_KEY_PICK_UP);
  90         }
  91         if (dozeEnabled && isDoubleTapAvailable(context)) {
  92             int doubleTap = Secure.getInt(getContentResolver(), Secure.DOZE_PULSE_ON_DOUBLE_TAP, 1);
  93             addPreference(PREF_KEY_DOUBLE_TAP_SCREEN, doubleTap != 0, PREF_ID_DOUBLE_TAP_SCREEN);
  94         } else {
  95             removePreference(PREF_KEY_DOUBLE_TAP_SCREEN);
  96         }
  97
  98         // Fingerprint slide for notifications
  99         if (isSystemUINavigationAvailable(context)) {
 100             addPreference(PREF_KEY_SWIPE_DOWN_FINGERPRINT, isSystemUINavigationEnabled(context),
 101                     PREF_ID_SWIPE_DOWN_FINGERPRINT);
 102         } else {
 103             removePreference(PREF_KEY_SWIPE_DOWN_FINGERPRINT);
 104         }
 105
 106         // Double twist for camera mode
 107         if (isDoubleTwistAvailable(context)) {
 108             int doubleTwistEnabled = Secure.getInt(
 109                     getContentResolver(), Secure.CAMERA_DOUBLE_TWIST_TO_FLIP_ENABLED, 1);
 110             addPreference(PREF_KEY_DOUBLE_TWIST, doubleTwistEnabled != 0, PREF_ID_DOUBLE_TWIST);
 111         } else {
 112             removePreference(PREF_KEY_DOUBLE_TWIST);
 113         }
 114
 115     }
 116
 117     @Override
 118     public View onCreateView(LayoutInflater inflater, ViewGroup container,
 119                              Bundle savedInstanceState) {
 120         View view = super.onCreateView(inflater, container, savedInstanceState);
 121         RecyclerView listview = getListView();
 122         listview.addOnScrollListener(new RecyclerView.OnScrollListener() {
 123             @Override
 124             public void onScrollStateChanged(RecyclerView recyclerView, int newState) {
 125                 if (newState == RecyclerView.SCROLL_STATE_DRAGGING) {
 126                     for (GesturePreference pref : mPreferences) {
 127                         pref.setScrolling(true);
 128                     }
 129                 } else if (newState == RecyclerView.SCROLL_STATE_IDLE) {
 130                     for (GesturePreference pref : mPreferences) {
 131                         pref.setScrolling(false);
 132                     }
 133                 }
 134             }
 135
 136             @Override
 137             public void onScrolled(RecyclerView recyclerView, int dx, int dy) {
 138             }
 139         });
 140         return view;
 141     }
 142
 143     @Override
 144     public void onStart() {
 145         super.onStart();
 146         for (GesturePreference preference : mPreferences) {
 147             preference.onViewVisible();
 148         }
 149     }
 150
 151     @Override
 152     public boolean onPreferenceChange(Preference preference, Object newValue) {
 153         boolean enabled = (boolean) newValue;
 154         String key = preference.getKey();
 155         if (PREF_KEY_DOUBLE_TAP_POWER.equals(key)) {
 156             Secure.putInt(getContentResolver(),
 157                     Secure.CAMERA_DOUBLE_TAP_POWER_GESTURE_DISABLED, enabled ? 0 : 1);
 158         } else if (PREF_KEY_PICK_UP.equals(key)) {
 159             Secure.putInt(getContentResolver(), Secure.DOZE_PULSE_ON_PICK_UP, enabled ? 1 : 0);
 160         } else if (PREF_KEY_DOUBLE_TAP_SCREEN.equals(key)) {
 161             Secure.putInt(getContentResolver(), Secure.DOZE_PULSE_ON_DOUBLE_TAP, enabled ? 1 : 0);
 162         } else if (PREF_KEY_SWIPE_DOWN_FINGERPRINT.equals(key)) {
 163             Secure.putInt(getContentResolver(),
 164                     Secure.SYSTEM_NAVIGATION_KEYS_ENABLED, enabled ? 1 : 0);
 165         } else if (PREF_KEY_DOUBLE_TWIST.equals(key)) {
 166             Secure.putInt(getContentResolver(),
 167                     Secure.CAMERA_DOUBLE_TWIST_TO_FLIP_ENABLED, enabled ? 1 : 0);
 168         }
 169         return true;
 170     }
 171
 172     @Override
 173     protected int getHelpResource() {
 174         return R.string.help_url_gestures;
 175     }
 176
 177     @Override
 178     protected int getMetricsCategory() {
 179         return MetricsEvent.SETTINGS_GESTURES;
 180     }
 181
 182     private static boolean isCameraDoubleTapPowerGestureAvailable(Resources res) {
 183         return res.getBoolean(
 184                 com.android.internal.R.bool.config_cameraDoubleTapPowerGestureEnabled);
 185     }
 186
 187     private static boolean isDozeAvailable(Context context) {
 188         String name = Build.IS_DEBUGGABLE ? SystemProperties.get(DEBUG_DOZE_COMPONENT) : null;
 189         if (TextUtils.isEmpty(name)) {
 190             name = context.getResources().getString(
 191                     com.android.internal.R.string.config_dozeComponent);
 192         }
 193         return !TextUtils.isEmpty(name);
 194     }
 195
 196     private static boolean isSystemUINavigationAvailable(Context context) {
 197         return context.getResources().getBoolean(
 198                 com.android.internal.R.bool.config_supportSystemNavigationKeys);
 199     }
 200
 201     private static boolean isSystemUINavigationEnabled(Context context) {
 202         return Secure.getInt(context.getContentResolver(), Secure.SYSTEM_NAVIGATION_KEYS_ENABLED, 0)
 203                 == 1;
 204     }
 205
 206     private static boolean isDoubleTwistAvailable(Context context) {
 207         Resources resources = context.getResources();
 208         String name = resources.getString(R.string.gesture_double_twist_sensor_name);
 209         String vendor = resources.getString(R.string.gesture_double_twist_sensor_vendor);
 210         if (!TextUtils.isEmpty(name) && !TextUtils.isEmpty(vendor)) {
 211             SensorManager sensorManager =
 212                     (SensorManager) context.getSystemService(Context.SENSOR_SERVICE);
 213             for (Sensor s : sensorManager.getSensorList(Sensor.TYPE_ALL)) {
 214                 if (name.equals(s.getName()) && vendor.equals(s.getVendor())) {
 215                     return true;
 216                 }
 217             }
 218         }
 219         return false;
 220     }
 221
 222     private static boolean isDoubleTapAvailable(Context context) {
 223         return context.getResources().getBoolean(
 224                 R.bool.config_gesture_double_tap_settings_enabled);
 225     }
 226
 227     private void addPreference(String key, boolean enabled, int id) {
 228         GesturePreference preference = (GesturePreference) findPreference(key);
 229         preference.setChecked(enabled);
 230         preference.setOnPreferenceChangeListener(this);
 231         preference.loadPreview(getLoaderManager(), id);
 232         mPreferences.add(preference);
 233     }
 234
 235     public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
 236         new BaseSearchIndexProvider() {
 237             @Override
 238             public List<SearchIndexableResource> getXmlResourcesToIndex(Context context,
 239                      boolean enabled) {
 240                 ArrayList<SearchIndexableResource> result =
 241                         new ArrayList<SearchIndexableResource>();
 242
 243                 SearchIndexableResource sir = new SearchIndexableResource(context);
 244                 sir.xmlResId = R.xml.gesture_settings;
 245                 result.add(sir);
 246
 247                 return result;
 248             }
 249
 250             @Override
 251             public List<String> getNonIndexableKeys(Context context) {
 252                 ArrayList<String> result = new ArrayList<String>();
 253                 if (!isCameraDoubleTapPowerGestureAvailable(context.getResources())) {
 254                     result.add(PREF_KEY_DOUBLE_TAP_POWER);
 255                 }
 256                 if (!isDozeAvailable(context)) {
 257                     result.add(PREF_KEY_PICK_UP);
 258                     result.add(PREF_KEY_DOUBLE_TAP_SCREEN);
 259                 } else if (!isDoubleTapAvailable(context)) {
 260                     result.add(PREF_KEY_DOUBLE_TAP_SCREEN);
 261                 }
 262                 if (!isSystemUINavigationAvailable(context)) {
 263                     result.add(PREF_KEY_SWIPE_DOWN_FINGERPRINT);
 264                 }
 265                 if (!isDoubleTwistAvailable(context)) {
 266                     result.add(PREF_KEY_DOUBLE_TWIST);
 267                 }
 268                 return result;
 269             }
 270         };
 271
 272 }