diff options
Diffstat (limited to 'src/com/android/settings/DisplaySettings.java')
| -rw-r--r-- | src/com/android/settings/DisplaySettings.java | 531 |
1 files changed, 395 insertions, 136 deletions
diff --git a/src/com/android/settings/DisplaySettings.java b/src/com/android/settings/DisplaySettings.java index de15d4c..399e1eb 100644 --- a/src/com/android/settings/DisplaySettings.java +++ b/src/com/android/settings/DisplaySettings.java @@ -1,5 +1,6 @@ /* * 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. @@ -15,14 +16,24 @@ */ package com.android.settings; - import com.android.internal.logging.MetricsLogger; + +import android.app.AlertDialog; +import android.content.DialogInterface; +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_DOUBLE_TAP_POWER_GESTURE_DISABLED; 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; @@ -35,30 +46,45 @@ 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.pm.PackageManager; +import android.content.pm.PackageManager.NameNotFoundException; 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.providers.CMSettings; public class DisplaySettings extends SettingsPreferenceFragment implements Preference.OnPreferenceChangeListener, OnPreferenceClickListener, Indexable { @@ -67,7 +93,11 @@ public class DisplaySettings extends SettingsPreferenceFragment implements /** 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"; @@ -77,24 +107,48 @@ public class DisplaySettings extends SettingsPreferenceFragment implements 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_CAMERA_DOUBLE_TAP_POWER_GESTURE - = "camera_double_tap_power_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 int DLG_GLOBAL_CHANGE_WARNING = 1; - private WarnedListPreference mFontSizePref; + private ListPreference mLcdDensityPreference; + private FontDialogPreference mFontSizePref; + private PreferenceScreen mDisplayRotationPreference; 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 mProximityCheckOnWakePreference; private SwitchPreference mAutoBrightnessPreference; + private SwitchPreference mWakeWhenPluggedOrUnplugged; + + 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; - private SwitchPreference mCameraDoubleTapPowerGesturePreference; @Override protected int getMetricsCategory() { @@ -106,14 +160,23 @@ public class DisplaySettings extends SettingsPreferenceFragment implements super.onCreate(savedInstanceState); final Activity activity = getActivity(); final ContentResolver resolver = activity.getContentResolver(); + addPreferencesFromResource(R.xml.display); - addPreferencesFromResource(R.xml.display_settings); + 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); + } mScreenSaverPreference = findPreference(KEY_SCREEN_SAVER); if (mScreenSaverPreference != null && getResources().getBoolean( com.android.internal.R.bool.config_dreamsSupported) == false) { - getPreferenceScreen().removePreference(mScreenSaverPreference); + interfacePrefs.removePreference(mScreenSaverPreference); } mScreenTimeoutPreference = (ListPreference) findPreference(KEY_SCREEN_TIMEOUT); @@ -123,90 +186,87 @@ public class DisplaySettings extends SettingsPreferenceFragment implements 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; + } - mFontSizePref = (WarnedListPreference) findPreference(KEY_FONT_SIZE); + 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); - if (isAutomaticBrightnessAvailable(getResources())) { - mAutoBrightnessPreference = (SwitchPreference) findPreference(KEY_AUTO_BRIGHTNESS); + mAutoBrightnessPreference = (SwitchPreference) findPreference(KEY_AUTO_BRIGHTNESS); + if (mAutoBrightnessPreference != null && isAutomaticBrightnessAvailable(getResources())) { mAutoBrightnessPreference.setOnPreferenceChangeListener(this); } else { - removePreference(KEY_AUTO_BRIGHTNESS); + if (displayPrefs != null && mAutoBrightnessPreference != null) { + displayPrefs.removePreference(mAutoBrightnessPreference); + mAutoBrightnessPreference = null; + } } - if (isLiftToWakeAvailable(activity)) { - mLiftToWakePreference = (SwitchPreference) findPreference(KEY_LIFT_TO_WAKE); + mLiftToWakePreference = (SwitchPreference) findPreference(KEY_LIFT_TO_WAKE); + if (mLiftToWakePreference != null && isLiftToWakeAvailable(activity)) { mLiftToWakePreference.setOnPreferenceChangeListener(this); } else { - removePreference(KEY_LIFT_TO_WAKE); + if (displayPrefs != null && mLiftToWakePreference != null) { + displayPrefs.removePreference(mLiftToWakePreference); + mLiftToWakePreference = null; + } } - if (isDozeAvailable(activity)) { - mDozePreference = (SwitchPreference) findPreference(KEY_DOZE); + mDozePreference = (SwitchPreference) findPreference(KEY_DOZE); + if (mDozePreference != null && Utils.isDozeAvailable(activity)) { mDozePreference.setOnPreferenceChangeListener(this); } else { - removePreference(KEY_DOZE); - } - - if (isTapToWakeAvailable(getResources())) { - mTapToWakePreference = (SwitchPreference) findPreference(KEY_TAP_TO_WAKE); - mTapToWakePreference.setOnPreferenceChangeListener(this); - } else { - removePreference(KEY_TAP_TO_WAKE); + if (displayPrefs != null && mDozePreference != null) { + displayPrefs.removePreference(mDozePreference); + } } - if (isCameraGestureAvailable(getResources())) { - mCameraGesturePreference = (SwitchPreference) findPreference(KEY_CAMERA_GESTURE); + mCameraGesturePreference = (SwitchPreference) findPreference(KEY_CAMERA_GESTURE); + if (mCameraGesturePreference != null && isCameraGestureAvailable(getResources())) { mCameraGesturePreference.setOnPreferenceChangeListener(this); } else { - removePreference(KEY_CAMERA_GESTURE); - } - - if (isCameraDoubleTapPowerGestureAvailable(getResources())) { - mCameraDoubleTapPowerGesturePreference - = (SwitchPreference) findPreference(KEY_CAMERA_DOUBLE_TAP_POWER_GESTURE); - mCameraDoubleTapPowerGesturePreference.setOnPreferenceChangeListener(this); - } else { - removePreference(KEY_CAMERA_DOUBLE_TAP_POWER_GESTURE); - } - - if (RotationPolicy.isRotationLockToggleVisible(activity)) { - DropDownPreference rotatePreference = - (DropDownPreference) findPreference(KEY_AUTO_ROTATE); - rotatePreference.addItem(activity.getString(R.string.display_auto_rotate_rotate), - false); - int rotateLockedResourceId; - // The following block sets the string used when rotation is locked. - // If the device locks specifically to portrait or landscape (rather than current - // rotation), then we use a different string to include this information. - if (allowAllRotations(activity)) { - rotateLockedResourceId = R.string.display_auto_rotate_stay_in_current; - } else { - if (RotationPolicy.getRotationLockOrientation(activity) - == Configuration.ORIENTATION_PORTRAIT) { - rotateLockedResourceId = - R.string.display_auto_rotate_stay_in_portrait; - } else { - rotateLockedResourceId = - R.string.display_auto_rotate_stay_in_landscape; - } + if (displayPrefs != null && mCameraGesturePreference != null) { + displayPrefs.removePreference(mCameraGesturePreference); } - rotatePreference.addItem(activity.getString(rotateLockedResourceId), true); - rotatePreference.setSelectedItem(RotationPolicy.isRotationLocked(activity) ? - 1 : 0); - rotatePreference.setCallback(new Callback() { - @Override - public boolean onItemSelected(int pos, Object value) { - final boolean locked = (Boolean) value; - MetricsLogger.action(getActivity(), MetricsLogger.ACTION_ROTATION_LOCK, - locked); - RotationPolicy.setRotationLock(activity, locked); - return true; - } - }); - } else { - removePreference(KEY_AUTO_ROTATE); } mNightModePreference = (ListPreference) findPreference(KEY_NIGHT_MODE); @@ -217,6 +277,51 @@ public class DisplaySettings extends SettingsPreferenceFragment implements 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); + } + } + + 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, 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) { @@ -229,15 +334,6 @@ public class DisplaySettings extends SettingsPreferenceFragment implements return sensors != null && sensors.getDefaultSensor(Sensor.TYPE_WAKE_GESTURE) != null; } - private static boolean isDozeAvailable(Context context) { - String name = Build.IS_DEBUGGABLE ? SystemProperties.get("debug.doze.component") : null; - if (TextUtils.isEmpty(name)) { - name = context.getResources().getString( - com.android.internal.R.string.config_dozeComponent); - } - return !TextUtils.isEmpty(name); - } - private static boolean isTapToWakeAvailable(Resources res) { return res.getBoolean(com.android.internal.R.bool.config_supportDoubleTapWake); } @@ -246,6 +342,59 @@ public class DisplaySettings extends SettingsPreferenceFragment implements 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<String> rotationList = new ArrayList<String>(); + 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; @@ -253,11 +402,6 @@ public class DisplaySettings extends SettingsPreferenceFragment implements !SystemProperties.getBoolean("gesture.disable_camera_launch", false); } - private static boolean isCameraDoubleTapPowerGestureAvailable(Resources res) { - return res.getBoolean( - com.android.internal.R.bool.config_cameraDoubleTapPowerGestureEnabled); - } - private void updateTimeoutPreferenceDescription(long currentTimeout) { ListPreference preference = mScreenTimeoutPreference; String summary; @@ -284,6 +428,12 @@ public class DisplaySettings extends SettingsPreferenceFragment implements 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( @@ -325,41 +475,44 @@ public class DisplaySettings extends SettingsPreferenceFragment implements screenTimeoutPreference.setEnabled(revisedEntries.size() > 0); } - int floatToIndex(float val) { - String[] indices = getResources().getStringArray(R.array.entryvalues_font_size); - float lastVal = Float.parseFloat(indices[0]); - for (int i=1; i<indices.length; i++) { - float thisVal = Float.parseFloat(indices[i]); - if (val < (lastVal + (thisVal-lastVal)*.5f)) { - return i-1; - } - lastVal = thisVal; - } - return indices.length-1; - } + @Override + public void onResume() { + super.onResume(); + updateDisplayRotationPreferenceDescription(); - public void readFontSizePreference(ListPreference pref) { - try { - mCurConfig.updateFrom(ActivityManagerNative.getDefault().getConfiguration()); - } catch (RemoteException e) { - Log.w(TAG, "Unable to retrieve font size"); - } + RotationPolicy.registerRotationPolicyListener(getActivity(), + mRotationPolicyListener); - // mark the appropriate item in the preferences list - int index = floatToIndex(mCurConfig.fontScale); - pref.setValueIndex(index); + final ContentResolver resolver = getContentResolver(); - // report the current size in the summary text - final Resources res = getResources(); - String[] fontSizeNames = res.getStringArray(R.array.entries_font_size); - pref.setSummary(String.format(res.getString(R.string.summary_font_size), - fontSizeNames[index])); + // 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 onResume() { - super.onResume(); - updateState(); + public void onPause() { + super.onPause(); + + RotationPolicy.unregisterRotationPolicyListener(getActivity(), + mRotationPolicyListener); + + // Display rotation observer + getContentResolver().unregisterContentObserver(mAccelerometerRotationObserver); } @Override @@ -410,13 +563,6 @@ public class DisplaySettings extends SettingsPreferenceFragment implements int value = Settings.Secure.getInt(getContentResolver(), CAMERA_GESTURE_DISABLED, 0); mCameraGesturePreference.setChecked(value == 0); } - - // Update camera gesture #2 if it is available. - if (mCameraDoubleTapPowerGesturePreference != null) { - int value = Settings.Secure.getInt( - getContentResolver(), CAMERA_DOUBLE_TAP_POWER_GESTURE_DISABLED, 0); - mCameraDoubleTapPowerGesturePreference.setChecked(value == 0); - } } private void updateScreenSaverSummary() { @@ -426,6 +572,79 @@ public class DisplaySettings extends SettingsPreferenceFragment implements } } + 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<Void, Void, Void> task = new AsyncTask<Void, Void, Void>() { + @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()); @@ -437,6 +656,16 @@ public class DisplaySettings extends SettingsPreferenceFragment implements @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()); + } + return super.onPreferenceTreeClick(preferenceScreen, preference); } @@ -452,6 +681,14 @@ public class DisplaySettings extends SettingsPreferenceFragment implements 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); } @@ -477,11 +714,6 @@ public class DisplaySettings extends SettingsPreferenceFragment implements Settings.Secure.putInt(getContentResolver(), CAMERA_GESTURE_DISABLED, value ? 0 : 1 /* Backwards because setting is for disabling */); } - if (preference == mCameraDoubleTapPowerGesturePreference) { - boolean value = (Boolean) objValue; - Settings.Secure.putInt(getContentResolver(), CAMERA_DOUBLE_TAP_POWER_GESTURE_DISABLED, - value ? 0 : 1 /* Backwards because setting is for disabling */); - } if (preference == mNightModePreference) { try { final int value = Integer.parseInt((String) objValue); @@ -495,6 +727,26 @@ public class DisplaySettings extends SettingsPreferenceFragment implements 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) { @@ -515,6 +767,7 @@ public class DisplaySettings extends SettingsPreferenceFragment implements public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = new BaseSearchIndexProvider() { + @Override public List<SearchIndexableResource> getXmlResourcesToIndex(Context context, boolean enabled) { @@ -522,7 +775,7 @@ public class DisplaySettings extends SettingsPreferenceFragment implements new ArrayList<SearchIndexableResource>(); SearchIndexableResource sir = new SearchIndexableResource(context); - sir.xmlResId = R.xml.display_settings; + sir.xmlResId = R.xml.display; result.add(sir); return result; @@ -535,27 +788,33 @@ public class DisplaySettings extends SettingsPreferenceFragment implements 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 (!isDozeAvailable(context)) { + if (!Utils.isDozeAvailable(context)) { result.add(KEY_DOZE); } - if (!RotationPolicy.isRotationLockToggleVisible(context)) { - result.add(KEY_AUTO_ROTATE); - } 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 (!isCameraDoubleTapPowerGestureAvailable(context.getResources())) { - result.add(KEY_CAMERA_DOUBLE_TAP_POWER_GESTURE); - } return result; } }; |