/* * Copyright (C) 2010 The Android Open Source Project * Copyright (C) 2014 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.android.settings; import com.android.internal.logging.MetricsLogger; import android.app.AlertDialog; import android.content.DialogInterface; import android.content.SharedPreferences; import android.preference.CheckBoxPreference; import android.os.UserHandle; import android.view.Display; import android.view.IWindowManager; import android.view.WindowManager; import android.view.WindowManagerGlobal; import android.view.WindowManagerImpl; import android.widget.Toast; import com.android.internal.view.RotationPolicy; import com.android.settings.DropDownPreference.Callback; import com.android.settings.search.BaseSearchIndexProvider; import com.android.settings.search.Indexable; import static android.provider.Settings.Secure.CAMERA_GESTURE_DISABLED; import static android.provider.Settings.Secure.DOUBLE_TAP_TO_WAKE; import static android.provider.Settings.Secure.DOZE_ENABLED; import static android.provider.Settings.Secure.WAKE_GESTURE_ENABLED; import static android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE; import static android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE_AUTOMATIC; import static android.provider.Settings.System.SCREEN_BRIGHTNESS_MODE_MANUAL; import static android.provider.Settings.System.SCREEN_OFF_TIMEOUT; import android.app.Activity; import android.app.ActivityManagerNative; import android.app.Dialog; import android.app.IActivityManager; import android.app.ProgressDialog; import android.app.UiModeManager; import android.app.admin.DevicePolicyManager; import android.content.ContentResolver; import android.content.Context; import android.content.res.Configuration; import android.content.res.Resources; import android.hardware.Sensor; import android.hardware.SensorManager; import android.os.AsyncTask; import android.os.Build; import android.database.ContentObserver; import android.os.Bundle; import android.os.Handler; import android.os.RemoteException; import android.os.ServiceManager; import android.os.SystemProperties; import android.preference.ListPreference; import android.preference.Preference; import android.preference.PreferenceManager; import android.preference.Preference.OnPreferenceClickListener; import android.preference.PreferenceCategory; import android.preference.PreferenceManager; import android.preference.PreferenceScreen; import android.preference.SwitchPreference; import android.provider.SearchIndexableResource; import android.provider.Settings; import android.text.TextUtils; import android.util.DisplayMetrics; import android.util.Log; import java.util.ArrayList; import java.util.List; import com.android.settings.Utils; import com.android.settings.cyanogenmod.DisplayRotation; import cyanogenmod.hardware.CMHardwareManager; import cyanogenmod.hardware.LiveDisplayManager; import cyanogenmod.providers.CMSettings; public class DisplaySettings extends SettingsPreferenceFragment implements Preference.OnPreferenceChangeListener, OnPreferenceClickListener, Indexable { private static final String TAG = "DisplaySettings"; /** If there is no setting in the provider, use this. */ private static final int FALLBACK_SCREEN_TIMEOUT_VALUE = 30000; private static final String KEY_CATEGORY_LIGHTS = "lights"; private static final String KEY_CATEGORY_DISPLAY = "display"; private static final String KEY_CATEGORY_INTERFACE = "interface"; private static final String KEY_SCREEN_TIMEOUT = "screen_timeout"; private static final String KEY_LCD_DENSITY = "lcd_density"; private static final String KEY_FONT_SIZE = "font_size"; private static final String KEY_SCREEN_SAVER = "screensaver"; private static final String KEY_LIFT_TO_WAKE = "lift_to_wake"; private static final String KEY_DOZE = "doze"; private static final String KEY_TAP_TO_WAKE = "tap_to_wake"; private static final String KEY_AUTO_BRIGHTNESS = "auto_brightness"; private static final String KEY_AUTO_ROTATE = "auto_rotate"; private static final String KEY_NIGHT_MODE = "night_mode"; private static final String KEY_CAMERA_GESTURE = "camera_gesture"; private static final String KEY_PROXIMITY_WAKE = "proximity_on_wake"; private static final String KEY_DISPLAY_ROTATION = "display_rotation"; private static final String KEY_WAKE_WHEN_PLUGGED_OR_UNPLUGGED = "wake_when_plugged_or_unplugged"; private static final String KEY_NOTIFICATION_LIGHT = "notification_light"; private static final String KEY_BATTERY_LIGHT = "battery_light"; private static final String KEY_LIVEDISPLAY = "live_display"; private static final String KEY_HIGH_TOUCH_SENSITIVITY = "high_touch_sensitivity"; private static final int DLG_GLOBAL_CHANGE_WARNING = 1; private ListPreference mLcdDensityPreference; private FontDialogPreference mFontSizePref; private PreferenceScreen mDisplayRotationPreference; private PreferenceScreen mLiveDisplayPreference; private final Configuration mCurConfig = new Configuration(); private ListPreference mScreenTimeoutPreference; private ListPreference mNightModePreference; private Preference mScreenSaverPreference; private SwitchPreference mAccelerometer; private SwitchPreference mLiftToWakePreference; private SwitchPreference mDozePreference; private SwitchPreference mTapToWakePreference; private SwitchPreference mHighTouchSensitivity; private SwitchPreference mProximityCheckOnWakePreference; private SwitchPreference mAutoBrightnessPreference; private SwitchPreference mWakeWhenPluggedOrUnplugged; private CMHardwareManager mHardware; private ContentObserver mAccelerometerRotationObserver = new ContentObserver(new Handler()) { @Override public void onChange(boolean selfChange) { updateDisplayRotationPreferenceDescription(); updateAccelerometerRotationSwitch(); } }; private final RotationPolicy.RotationPolicyListener mRotationPolicyListener = new RotationPolicy.RotationPolicyListener() { @Override public void onChange() { updateDisplayRotationPreferenceDescription(); } }; private SwitchPreference mCameraGesturePreference; @Override protected int getMetricsCategory() { return MetricsLogger.DISPLAY; } @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); final Activity activity = getActivity(); final ContentResolver resolver = activity.getContentResolver(); addPreferencesFromResource(R.xml.display); mHardware = CMHardwareManager.getInstance(activity); PreferenceCategory displayPrefs = (PreferenceCategory) findPreference(KEY_CATEGORY_DISPLAY); PreferenceCategory interfacePrefs = (PreferenceCategory) findPreference(KEY_CATEGORY_INTERFACE); mDisplayRotationPreference = (PreferenceScreen) findPreference(KEY_DISPLAY_ROTATION); mAccelerometer = (SwitchPreference) findPreference(DisplayRotation.KEY_ACCELEROMETER); if (mAccelerometer != null) { mAccelerometer.setPersistent(false); } mLiveDisplayPreference = (PreferenceScreen) findPreference(KEY_LIVEDISPLAY); if (!LiveDisplayManager.getInstance(getActivity()).getConfig().isAvailable()) { displayPrefs.removePreference(mLiveDisplayPreference); } mScreenSaverPreference = findPreference(KEY_SCREEN_SAVER); if (mScreenSaverPreference != null && getResources().getBoolean( com.android.internal.R.bool.config_dreamsSupported) == false) { interfacePrefs.removePreference(mScreenSaverPreference); } mScreenTimeoutPreference = (ListPreference) findPreference(KEY_SCREEN_TIMEOUT); final long currentTimeout = Settings.System.getLong(resolver, SCREEN_OFF_TIMEOUT, FALLBACK_SCREEN_TIMEOUT_VALUE); mScreenTimeoutPreference.setValue(String.valueOf(currentTimeout)); mScreenTimeoutPreference.setOnPreferenceChangeListener(this); disableUnusableTimeouts(mScreenTimeoutPreference); updateTimeoutPreferenceDescription(currentTimeout); updateDisplayRotationPreferenceDescription(); mLcdDensityPreference = (ListPreference) findPreference(KEY_LCD_DENSITY); if (mLcdDensityPreference != null) { if (UserHandle.myUserId() != UserHandle.USER_OWNER) { interfacePrefs.removePreference(mLcdDensityPreference); } else { int defaultDensity = getDefaultDensity(); int currentDensity = getCurrentDensity(); if (currentDensity < 10 || currentDensity >= 1000) { // Unsupported value, force default currentDensity = defaultDensity; } int factor = defaultDensity >= 480 ? 40 : 20; int minimumDensity = defaultDensity - 4 * factor; int currentIndex = -1; String[] densityEntries = new String[7]; String[] densityValues = new String[7]; for (int idx = 0; idx < 7; ++idx) { int val = minimumDensity + factor * idx; int valueFormatResId = val == defaultDensity ? R.string.lcd_density_default_value_format : R.string.lcd_density_value_format; densityEntries[idx] = getString(valueFormatResId, val); densityValues[idx] = Integer.toString(val); if (currentDensity == val) { currentIndex = idx; } } mLcdDensityPreference.setEntries(densityEntries); mLcdDensityPreference.setEntryValues(densityValues); if (currentIndex != -1) { mLcdDensityPreference.setValueIndex(currentIndex); } mLcdDensityPreference.setOnPreferenceChangeListener(this); updateLcdDensityPreferenceDescription(currentDensity); } } mFontSizePref = (FontDialogPreference) findPreference(KEY_FONT_SIZE); mFontSizePref.setOnPreferenceChangeListener(this); mFontSizePref.setOnPreferenceClickListener(this); mAutoBrightnessPreference = (SwitchPreference) findPreference(KEY_AUTO_BRIGHTNESS); if (mAutoBrightnessPreference != null && isAutomaticBrightnessAvailable(getResources())) { mAutoBrightnessPreference.setOnPreferenceChangeListener(this); } else { if (displayPrefs != null && mAutoBrightnessPreference != null) { displayPrefs.removePreference(mAutoBrightnessPreference); mAutoBrightnessPreference = null; } } mLiftToWakePreference = (SwitchPreference) findPreference(KEY_LIFT_TO_WAKE); if (mLiftToWakePreference != null && isLiftToWakeAvailable(activity)) { mLiftToWakePreference.setOnPreferenceChangeListener(this); } else { if (displayPrefs != null && mLiftToWakePreference != null) { displayPrefs.removePreference(mLiftToWakePreference); mLiftToWakePreference = null; } } mDozePreference = (SwitchPreference) findPreference(KEY_DOZE); if (mDozePreference != null && Utils.isDozeAvailable(activity)) { mDozePreference.setOnPreferenceChangeListener(this); } else { if (displayPrefs != null && mDozePreference != null) { displayPrefs.removePreference(mDozePreference); } } mCameraGesturePreference = (SwitchPreference) findPreference(KEY_CAMERA_GESTURE); if (mCameraGesturePreference != null && isCameraGestureAvailable(getResources())) { mCameraGesturePreference.setOnPreferenceChangeListener(this); } else { if (displayPrefs != null && mCameraGesturePreference != null) { displayPrefs.removePreference(mCameraGesturePreference); } } mNightModePreference = (ListPreference) findPreference(KEY_NIGHT_MODE); if (mNightModePreference != null) { final UiModeManager uiManager = (UiModeManager) getSystemService( Context.UI_MODE_SERVICE); final int currentNightMode = uiManager.getNightMode(); mNightModePreference.setValue(String.valueOf(currentNightMode)); mNightModePreference.setOnPreferenceChangeListener(this); } mTapToWakePreference = (SwitchPreference) findPreference(KEY_TAP_TO_WAKE); if (mTapToWakePreference != null && isTapToWakeAvailable(getResources())) { mTapToWakePreference.setOnPreferenceChangeListener(this); } else { if (displayPrefs != null && mTapToWakePreference != null) { displayPrefs.removePreference(mTapToWakePreference); } } mHighTouchSensitivity = (SwitchPreference) findPreference(KEY_HIGH_TOUCH_SENSITIVITY); if (!mHardware.isSupported( CMHardwareManager.FEATURE_HIGH_TOUCH_SENSITIVITY)) { displayPrefs.removePreference(mHighTouchSensitivity); mHighTouchSensitivity = null; } else { mHighTouchSensitivity.setChecked( mHardware.get(CMHardwareManager.FEATURE_HIGH_TOUCH_SENSITIVITY)); } mProximityCheckOnWakePreference = (SwitchPreference) findPreference(KEY_PROXIMITY_WAKE); boolean proximityCheckOnWake = getResources().getBoolean( org.cyanogenmod.platform.internal.R.bool.config_proximityCheckOnWake); if (!proximityCheckOnWake) { if (displayPrefs != null && mProximityCheckOnWakePreference != null) { displayPrefs.removePreference(mProximityCheckOnWakePreference); } CMSettings.System.putInt(getContentResolver(), CMSettings.System.PROXIMITY_ON_WAKE, 0); } else { boolean proximityCheckOnWakeDefault = getResources().getBoolean( org.cyanogenmod.platform.internal.R.bool.config_proximityCheckOnWakeEnabledByDefault); mProximityCheckOnWakePreference.setChecked(CMSettings.System.getInt(getContentResolver(), CMSettings.System.PROXIMITY_ON_WAKE, (proximityCheckOnWakeDefault ? 1 : 0)) == 1); } mWakeWhenPluggedOrUnplugged = (SwitchPreference) findPreference(KEY_WAKE_WHEN_PLUGGED_OR_UNPLUGGED); initPulse((PreferenceCategory) findPreference(KEY_CATEGORY_LIGHTS)); } private int getDefaultDensity() { IWindowManager wm = IWindowManager.Stub.asInterface(ServiceManager.checkService( Context.WINDOW_SERVICE)); try { return wm.getInitialDisplayDensity(Display.DEFAULT_DISPLAY); } catch (RemoteException e) { e.printStackTrace(); } return DisplayMetrics.DENSITY_DEVICE; } private int getCurrentDensity() { IWindowManager wm = IWindowManager.Stub.asInterface(ServiceManager.checkService( Context.WINDOW_SERVICE)); try { return wm.getBaseDisplayDensity(Display.DEFAULT_DISPLAY); } catch (RemoteException e) { e.printStackTrace(); } return DisplayMetrics.DENSITY_DEVICE; } private static boolean allowAllRotations(Context context) { return Resources.getSystem().getBoolean( com.android.internal.R.bool.config_allowAllRotations); } private static boolean isLiftToWakeAvailable(Context context) { SensorManager sensors = (SensorManager) context.getSystemService(Context.SENSOR_SERVICE); return sensors != null && sensors.getDefaultSensor(Sensor.TYPE_WAKE_GESTURE) != null; } private static boolean isTapToWakeAvailable(Resources res) { return res.getBoolean(com.android.internal.R.bool.config_supportDoubleTapWake); } private static boolean isAutomaticBrightnessAvailable(Resources res) { return res.getBoolean(com.android.internal.R.bool.config_automatic_brightness_available); } private void updateAccelerometerRotationSwitch() { if (mAccelerometer != null) { mAccelerometer.setChecked(!RotationPolicy.isRotationLocked(getActivity())); } } private void updateDisplayRotationPreferenceDescription() { if (mDisplayRotationPreference == null) { // The preference was removed, do nothing return; } // We have a preference, lets update the summary boolean rotationEnabled = Settings.System.getInt(getContentResolver(), Settings.System.ACCELEROMETER_ROTATION, 0) != 0; if (!rotationEnabled) { mDisplayRotationPreference.setSummary(R.string.display_rotation_disabled); return; } StringBuilder summary = new StringBuilder(); int mode = Settings.System.getInt(getContentResolver(), Settings.System.ACCELEROMETER_ROTATION_ANGLES, DisplayRotation.ROTATION_0_MODE | DisplayRotation.ROTATION_90_MODE | DisplayRotation.ROTATION_270_MODE); ArrayList rotationList = new ArrayList(); String delim = ""; if ((mode & DisplayRotation.ROTATION_0_MODE) != 0) { rotationList.add("0"); } if ((mode & DisplayRotation.ROTATION_90_MODE) != 0) { rotationList.add("90"); } if ((mode & DisplayRotation.ROTATION_180_MODE) != 0) { rotationList.add("180"); } if ((mode & DisplayRotation.ROTATION_270_MODE) != 0) { rotationList.add("270"); } for (int i = 0; i < rotationList.size(); i++) { summary.append(delim).append(rotationList.get(i)); if ((rotationList.size() - i) > 2) { delim = ", "; } else { delim = " & "; } } summary.append(" " + getString(R.string.display_rotation_unit)); mDisplayRotationPreference.setSummary(summary); } private static boolean isCameraGestureAvailable(Resources res) { boolean configSet = res.getInteger( com.android.internal.R.integer.config_cameraLaunchGestureSensorType) != -1; return configSet && !SystemProperties.getBoolean("gesture.disable_camera_launch", false); } private void updateTimeoutPreferenceDescription(long currentTimeout) { ListPreference preference = mScreenTimeoutPreference; String summary; if (currentTimeout < 0) { // Unsupported value summary = ""; } else { final CharSequence[] entries = preference.getEntries(); final CharSequence[] values = preference.getEntryValues(); if (entries == null || entries.length == 0) { summary = ""; } else { int best = 0; for (int i = 0; i < values.length; i++) { long timeout = Long.parseLong(values[i].toString()); if (currentTimeout >= timeout) { best = i; } } summary = preference.getContext().getString(R.string.screen_timeout_summary, entries[best]); } } preference.setSummary(summary); } private void updateLcdDensityPreferenceDescription(int currentDensity) { final int summaryResId = currentDensity == getDefaultDensity() ? R.string.lcd_density_default_value_format : R.string.lcd_density_value_format; mLcdDensityPreference.setSummary(getString(summaryResId, currentDensity)); } private void disableUnusableTimeouts(ListPreference screenTimeoutPreference) { final DevicePolicyManager dpm = (DevicePolicyManager) getActivity().getSystemService( Context.DEVICE_POLICY_SERVICE); final long maxTimeout = dpm != null ? dpm.getMaximumTimeToLock(null) : 0; if (maxTimeout == 0) { return; // policy not enforced } final CharSequence[] entries = screenTimeoutPreference.getEntries(); final CharSequence[] values = screenTimeoutPreference.getEntryValues(); ArrayList revisedEntries = new ArrayList(); ArrayList revisedValues = new ArrayList(); for (int i = 0; i < values.length; i++) { long timeout = Long.parseLong(values[i].toString()); if (timeout <= maxTimeout) { revisedEntries.add(entries[i]); revisedValues.add(values[i]); } } if (revisedEntries.size() != entries.length || revisedValues.size() != values.length) { final int userPreference = Integer.parseInt(screenTimeoutPreference.getValue()); screenTimeoutPreference.setEntries( revisedEntries.toArray(new CharSequence[revisedEntries.size()])); screenTimeoutPreference.setEntryValues( revisedValues.toArray(new CharSequence[revisedValues.size()])); if (userPreference <= maxTimeout) { screenTimeoutPreference.setValue(String.valueOf(userPreference)); } else if (revisedValues.size() > 0 && Long.parseLong(revisedValues.get(revisedValues.size() - 1).toString()) == maxTimeout) { // If the last one happens to be the same as the max timeout, select that screenTimeoutPreference.setValue(String.valueOf(maxTimeout)); } else { // There will be no highlighted selection since nothing in the list matches // maxTimeout. The user can still select anything less than maxTimeout. // TODO: maybe append maxTimeout to the list and mark selected. } } screenTimeoutPreference.setEnabled(revisedEntries.size() > 0); } @Override public void onResume() { super.onResume(); updateDisplayRotationPreferenceDescription(); RotationPolicy.registerRotationPolicyListener(getActivity(), mRotationPolicyListener); final ContentResolver resolver = getContentResolver(); // Display rotation observer resolver.registerContentObserver( Settings.System.getUriFor(Settings.System.ACCELEROMETER_ROTATION), true, mAccelerometerRotationObserver); // Default value for wake-on-plug behavior from config.xml boolean wakeUpWhenPluggedOrUnpluggedConfig = getResources().getBoolean( com.android.internal.R.bool.config_unplugTurnsOnScreen); if (mWakeWhenPluggedOrUnplugged != null) { mWakeWhenPluggedOrUnplugged.setChecked(CMSettings.Global.getInt(getContentResolver(), CMSettings.Global.WAKE_WHEN_PLUGGED_OR_UNPLUGGED, (wakeUpWhenPluggedOrUnpluggedConfig ? 1 : 0)) == 1); } updateState(); updateAccelerometerRotationSwitch(); } @Override public void onPause() { super.onPause(); RotationPolicy.unregisterRotationPolicyListener(getActivity(), mRotationPolicyListener); // Display rotation observer getContentResolver().unregisterContentObserver(mAccelerometerRotationObserver); } @Override public Dialog onCreateDialog(int dialogId) { if (dialogId == DLG_GLOBAL_CHANGE_WARNING) { return Utils.buildGlobalChangeWarningDialog(getActivity(), R.string.global_font_change_title, new Runnable() { public void run() { mFontSizePref.click(); } }); } return null; } private void updateState() { readFontSizePreference(mFontSizePref); updateScreenSaverSummary(); // Update auto brightness if it is available. if (mAutoBrightnessPreference != null) { int brightnessMode = Settings.System.getInt(getContentResolver(), SCREEN_BRIGHTNESS_MODE, SCREEN_BRIGHTNESS_MODE_MANUAL); mAutoBrightnessPreference.setChecked(brightnessMode != SCREEN_BRIGHTNESS_MODE_MANUAL); } // Update lift-to-wake if it is available. if (mLiftToWakePreference != null) { int value = Settings.Secure.getInt(getContentResolver(), WAKE_GESTURE_ENABLED, 0); mLiftToWakePreference.setChecked(value != 0); } // Update doze if it is available. if (mDozePreference != null) { int value = Settings.Secure.getInt(getContentResolver(), DOZE_ENABLED, 1); mDozePreference.setChecked(value != 0); } // Update tap to wake if it is available. if (mTapToWakePreference != null) { int value = Settings.Secure.getInt(getContentResolver(), DOUBLE_TAP_TO_WAKE, 0); mTapToWakePreference.setChecked(value != 0); } // Update camera gesture #1 if it is available. if (mCameraGesturePreference != null) { int value = Settings.Secure.getInt(getContentResolver(), CAMERA_GESTURE_DISABLED, 0); mCameraGesturePreference.setChecked(value == 0); } } private void updateScreenSaverSummary() { if (mScreenSaverPreference != null) { mScreenSaverPreference.setSummary( DreamSettings.getSummaryTextWithDreamName(getActivity())); } } private void writeLcdDensityPreference(final Context context, final int density) { final IActivityManager am = ActivityManagerNative.asInterface( ServiceManager.checkService("activity")); final IWindowManager wm = IWindowManager.Stub.asInterface(ServiceManager.checkService( Context.WINDOW_SERVICE)); AsyncTask task = new AsyncTask() { @Override protected void onPreExecute() { ProgressDialog dialog = new ProgressDialog(context); dialog.setMessage(getResources().getString(R.string.restarting_ui)); dialog.setCancelable(false); dialog.setIndeterminate(true); dialog.show(); } @Override protected Void doInBackground(Void... params) { // Give the user a second to see the dialog try { Thread.sleep(1000); } catch (InterruptedException e) { // Ignore } try { wm.setForcedDisplayDensity(Display.DEFAULT_DISPLAY, density); } catch (RemoteException e) { Log.e(TAG, "Failed to set density to " + density, e); } // Restart the UI try { am.restart(); } catch (RemoteException e) { Log.e(TAG, "Failed to restart"); } return null; } }; task.execute(); } // === Pulse notification light === private void initPulse(PreferenceCategory parent) { if (!getResources().getBoolean( com.android.internal.R.bool.config_intrusiveNotificationLed)) { parent.removePreference(parent.findPreference(KEY_NOTIFICATION_LIGHT)); } if (!getResources().getBoolean( com.android.internal.R.bool.config_intrusiveBatteryLed) || UserHandle.myUserId() != UserHandle.USER_OWNER) { parent.removePreference(parent.findPreference(KEY_BATTERY_LIGHT)); } if (parent.getPreferenceCount() == 0) { getPreferenceScreen().removePreference(parent); } } /** * Reads the current font size and sets the value in the summary text */ public void readFontSizePreference(Preference pref) { try { mCurConfig.updateFrom(ActivityManagerNative.getDefault().getConfiguration()); } catch (RemoteException e) { Log.w(TAG, "Unable to retrieve font size"); } // report the current size in the summary text final Resources res = getResources(); String fontDesc = FontDialogPreference.getFontSizeDescription(res, mCurConfig.fontScale); pref.setSummary(getString(R.string.summary_font_size, fontDesc)); } public void writeFontSizePreference(Object objValue) { try { mCurConfig.fontScale = Float.parseFloat(objValue.toString()); ActivityManagerNative.getDefault().updatePersistentConfiguration(mCurConfig); } catch (RemoteException e) { Log.w(TAG, "Unable to save font size"); } } @Override public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen, Preference preference) { if (preference == mWakeWhenPluggedOrUnplugged) { CMSettings.Global.putInt(getContentResolver(), CMSettings.Global.WAKE_WHEN_PLUGGED_OR_UNPLUGGED, mWakeWhenPluggedOrUnplugged.isChecked() ? 1 : 0); return true; } else if (preference == mAccelerometer) { RotationPolicy.setRotationLockForAccessibility(getActivity(), !mAccelerometer.isChecked()); } else if (preference == mHighTouchSensitivity) { boolean mHighTouchSensitivityEnable = mHighTouchSensitivity.isChecked(); CMSettings.System.putInt(getActivity().getContentResolver(), CMSettings.System.HIGH_TOUCH_SENSITIVITY_ENABLE, mHighTouchSensitivityEnable ? 1 : 0); return true; } return super.onPreferenceTreeClick(preferenceScreen, preference); } @Override public boolean onPreferenceChange(Preference preference, Object objValue) { final String key = preference.getKey(); if (KEY_SCREEN_TIMEOUT.equals(key)) { try { int value = Integer.parseInt((String) objValue); Settings.System.putInt(getContentResolver(), SCREEN_OFF_TIMEOUT, value); updateTimeoutPreferenceDescription(value); } catch (NumberFormatException e) { Log.e(TAG, "could not persist screen timeout setting", e); } } if (KEY_LCD_DENSITY.equals(key)) { String newValue = (String) objValue; String oldValue = mLcdDensityPreference.getValue(); if (!TextUtils.equals(newValue, oldValue)) { showLcdConfirmationDialog((String) objValue); } return false; } if (KEY_FONT_SIZE.equals(key)) { writeFontSizePreference(objValue); } if (preference == mAutoBrightnessPreference) { boolean auto = (Boolean) objValue; Settings.System.putInt(getContentResolver(), SCREEN_BRIGHTNESS_MODE, auto ? SCREEN_BRIGHTNESS_MODE_AUTOMATIC : SCREEN_BRIGHTNESS_MODE_MANUAL); } if (preference == mLiftToWakePreference) { boolean value = (Boolean) objValue; Settings.Secure.putInt(getContentResolver(), WAKE_GESTURE_ENABLED, value ? 1 : 0); } if (preference == mDozePreference) { boolean value = (Boolean) objValue; Settings.Secure.putInt(getContentResolver(), DOZE_ENABLED, value ? 1 : 0); } if (preference == mTapToWakePreference) { boolean value = (Boolean) objValue; Settings.Secure.putInt(getContentResolver(), DOUBLE_TAP_TO_WAKE, value ? 1 : 0); } if (preference == mCameraGesturePreference) { boolean value = (Boolean) objValue; Settings.Secure.putInt(getContentResolver(), CAMERA_GESTURE_DISABLED, value ? 0 : 1 /* Backwards because setting is for disabling */); } if (preference == mNightModePreference) { try { final int value = Integer.parseInt((String) objValue); final UiModeManager uiManager = (UiModeManager) getSystemService( Context.UI_MODE_SERVICE); uiManager.setNightMode(value); } catch (NumberFormatException e) { Log.e(TAG, "could not persist night mode setting", e); } } return true; } private void showLcdConfirmationDialog(final String lcdDensity) { AlertDialog.Builder builder = new AlertDialog.Builder(getActivity()); builder.setTitle(R.string.lcd_density); builder.setMessage(R.string.lcd_density_prompt_message); builder.setPositiveButton(R.string.print_restart, new DialogInterface.OnClickListener() { public void onClick(DialogInterface dialog, int id) { try { int value = Integer.parseInt(lcdDensity); writeLcdDensityPreference(getActivity(), value); updateLcdDensityPreferenceDescription(value); } catch (NumberFormatException e) { Log.e(TAG, "could not persist display density setting", e); } } }); builder.setNegativeButton(android.R.string.cancel, null); builder.show(); } @Override public boolean onPreferenceClick(Preference preference) { if (preference == mFontSizePref) { if (Utils.hasMultipleUsers(getActivity())) { showDialog(DLG_GLOBAL_CHANGE_WARNING); return true; } else { mFontSizePref.click(); } } return false; } @Override protected int getHelpResource() { return R.string.help_uri_display; } public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = new BaseSearchIndexProvider() { @Override public List getXmlResourcesToIndex(Context context, boolean enabled) { ArrayList result = new ArrayList(); SearchIndexableResource sir = new SearchIndexableResource(context); sir.xmlResId = R.xml.display; result.add(sir); return result; } @Override public List getNonIndexableKeys(Context context) { final CMHardwareManager hardware = CMHardwareManager.getInstance(context); ArrayList result = new ArrayList(); if (!context.getResources().getBoolean( com.android.internal.R.bool.config_dreamsSupported)) { result.add(KEY_SCREEN_SAVER); } if (!context.getResources().getBoolean( com.android.internal.R.bool.config_intrusiveNotificationLed)) { result.add(KEY_NOTIFICATION_LIGHT); } if (!context.getResources().getBoolean( com.android.internal.R.bool.config_intrusiveBatteryLed)) { result.add(KEY_BATTERY_LIGHT); } if (!isAutomaticBrightnessAvailable(context.getResources())) { result.add(KEY_AUTO_BRIGHTNESS); } if (!isLiftToWakeAvailable(context)) { result.add(KEY_LIFT_TO_WAKE); } if (!Utils.isDozeAvailable(context)) { result.add(KEY_DOZE); } if (!isTapToWakeAvailable(context.getResources())) { result.add(KEY_TAP_TO_WAKE); } if (!context.getResources().getBoolean( org.cyanogenmod.platform.internal.R.bool.config_proximityCheckOnWake)) { result.add(KEY_PROXIMITY_WAKE); } if (!isCameraGestureAvailable(context.getResources())) { result.add(KEY_CAMERA_GESTURE); } if (!hardware.isSupported(CMHardwareManager.FEATURE_HIGH_TOUCH_SENSITIVITY)) { result.add(KEY_HIGH_TOUCH_SENSITIVITY); } return result; } }; public static void restore(Context context) { final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context); final CMHardwareManager hardware = CMHardwareManager.getInstance(context); if (hardware.isSupported(CMHardwareManager.FEATURE_HIGH_TOUCH_SENSITIVITY)) { final boolean enabled = prefs.getBoolean(KEY_HIGH_TOUCH_SENSITIVITY, hardware.get(CMHardwareManager.FEATURE_HIGH_TOUCH_SENSITIVITY)); CMSettings.System.putInt(context.getContentResolver(), CMSettings.System.HIGH_TOUCH_SENSITIVITY_ENABLE, enabled ? 1 : 0); } } }