src/com/android/settings/livedisplay/LiveDisplay.java

   1 /*
   2  * Copyright (C) 2015 The CyanogenMod 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 package com.android.settings.livedisplay;
  17
  18 import android.app.Activity;
  19 import android.database.ContentObserver;
  20 import android.content.ContentResolver;
  21 import android.content.Context;
  22 import android.content.res.Resources;
  23 import android.database.ContentObserver;
  24 import android.hardware.CmHardwareManager;
  25 import android.net.Uri;
  26 import android.os.Build;
  27 import android.os.Bundle;
  28 import android.os.Handler;
  29 import android.os.UserHandle;
  30 import android.preference.ListPreference;
  31 import android.preference.Preference;
  32 import android.preference.PreferenceCategory;
  33 import android.preference.PreferenceScreen;
  34 import android.preference.SwitchPreference;
  35 import android.provider.SearchIndexableResource;
  36 import android.provider.Settings;
  37
  38 import static android.hardware.CmHardwareManager.FEATURE_ADAPTIVE_BACKLIGHT;
  39 import static android.hardware.CmHardwareManager.FEATURE_COLOR_ENHANCEMENT;
  40 import static android.hardware.CmHardwareManager.FEATURE_DISPLAY_GAMMA_CALIBRATION;
  41 import static android.hardware.CmHardwareManager.FEATURE_SUNLIGHT_ENHANCEMENT;
  42
  43 import com.android.internal.util.ArrayUtils;
  44 import com.android.settings.R;
  45 import com.android.settings.SettingsPreferenceFragment;
  46 import com.android.settings.Utils;
  47 import com.android.settings.search.BaseSearchIndexProvider;
  48 import com.android.settings.search.Indexable;
  49
  50 import java.util.ArrayList;
  51 import java.util.List;
  52
  53 public class LiveDisplay extends SettingsPreferenceFragment implements
  54         Preference.OnPreferenceChangeListener, Indexable {
  55
  56     private static final String TAG = "LiveDisplay";
  57
  58     private static final String KEY_CATEGORY_LIVE_DISPLAY = "live_display_options";
  59     private static final String KEY_CATEGORY_CALIBRATION = "calibration";
  60
  61     private static final String KEY_LIVE_DISPLAY = "live_display";
  62     private static final String KEY_LIVE_DISPLAY_AUTO_OUTDOOR_MODE =
  63             "live_display_auto_outdoor_mode";
  64     private static final String KEY_LIVE_DISPLAY_LOW_POWER = "live_display_low_power";
  65     private static final String KEY_LIVE_DISPLAY_COLOR_ENHANCE = "live_display_color_enhance";
  66     private static final String KEY_LIVE_DISPLAY_TEMPERATURE = "live_display_color_temperature";
  67
  68     private static final String KEY_DISPLAY_COLOR = "color_calibration";
  69     private static final String KEY_DISPLAY_GAMMA = "gamma_tuning";
  70     private static final String KEY_SCREEN_COLOR_SETTINGS = "screencolor_settings";
  71
  72     public static final int MODE_DAY = 0;
  73     public static final int MODE_NIGHT = 1;
  74     public static final int MODE_AUTO = 2;
  75     public static final int MODE_OUTDOOR = 3;
  76
  77     private final Handler mHandler = new Handler();
  78     private final SettingsObserver mObserver = new SettingsObserver();
  79
  80     private ListPreference mLiveDisplay;
  81
  82     private SwitchPreference mColorEnhancement;
  83     private SwitchPreference mLowPower;
  84     private SwitchPreference mOutdoorMode;
  85
  86     private PreferenceScreen mScreenColorSettings;
  87     private DisplayTemperature mDisplayTemperature;
  88
  89     private String[] mModeEntries;
  90     private String[] mModeValues;
  91     private String[] mModeSummaries;
  92
  93     private int mDefaultDayTemperature;
  94     private int mDefaultNightTemperature;
  95
  96     private CmHardwareManager mCmHardwareManager;
  97
  98     @Override
  99     public void onCreate(Bundle savedInstanceState) {
 100         super.onCreate(savedInstanceState);
 101         final Activity activity = getActivity();
 102         final ContentResolver resolver = activity.getContentResolver();
 103         final Resources res = getResources();
 104
 105         mDefaultDayTemperature = res.getInteger(
 106                 com.android.internal.R.integer.config_dayColorTemperature);
 107         mDefaultNightTemperature = res.getInteger(
 108                 com.android.internal.R.integer.config_nightColorTemperature);
 109
 110         mCmHardwareManager = (CmHardwareManager) activity.getSystemService(Context.CMHW_SERVICE);
 111
 112         addPreferencesFromResource(R.xml.livedisplay);
 113
 114         PreferenceCategory liveDisplayPrefs = (PreferenceCategory)
 115                 findPreference(KEY_CATEGORY_LIVE_DISPLAY);
 116         PreferenceCategory calibrationPrefs = (PreferenceCategory)
 117                 findPreference(KEY_CATEGORY_CALIBRATION);
 118
 119         int displayMode = Settings.System.getIntForUser(resolver,
 120                 Settings.System.DISPLAY_TEMPERATURE_MODE,
 121                 0, UserHandle.USER_CURRENT);
 122         mLiveDisplay = (ListPreference) findPreference(KEY_LIVE_DISPLAY);
 123         mLiveDisplay.setValue(String.valueOf(displayMode));
 124
 125         mModeEntries = res.getStringArray(
 126                 com.android.internal.R.array.live_display_entries);
 127         mModeValues = res.getStringArray(
 128                 com.android.internal.R.array.live_display_values);
 129         mModeSummaries = res.getStringArray(
 130                 com.android.internal.R.array.live_display_summaries);
 131
 132         // Remove outdoor mode from lists if there is no support
 133         if (!mCmHardwareManager.isSupported(FEATURE_SUNLIGHT_ENHANCEMENT)) {
 134             int idx = ArrayUtils.indexOf(mModeValues, String.valueOf(MODE_OUTDOOR));
 135             String[] entriesTemp = new String[mModeEntries.length - 1];
 136             String[] valuesTemp = new String[mModeValues.length - 1];
 137             String[] summariesTemp = new String[mModeSummaries.length - 1];
 138             int j = 0;
 139             for (int i = 0; i < mModeEntries.length; i++) {
 140                 if (i == idx) {
 141                     continue;
 142                 }
 143                 entriesTemp[j] = mModeEntries[i];
 144                 valuesTemp[j] = mModeValues[i];
 145                 summariesTemp[j] = mModeSummaries[i];
 146                 j++;
 147             }
 148             mModeEntries = entriesTemp;
 149             mModeValues = valuesTemp;
 150             mModeSummaries = summariesTemp;
 151         }
 152
 153         mLiveDisplay.setEntries(mModeEntries);
 154         mLiveDisplay.setEntryValues(mModeValues);
 155         mLiveDisplay.setOnPreferenceChangeListener(this);
 156
 157         mDisplayTemperature = (DisplayTemperature) findPreference(KEY_LIVE_DISPLAY_TEMPERATURE);
 158
 159         mLowPower = (SwitchPreference) findPreference(KEY_LIVE_DISPLAY_LOW_POWER);
 160         if (liveDisplayPrefs != null && mLowPower != null
 161                 && !mCmHardwareManager.isSupported(FEATURE_ADAPTIVE_BACKLIGHT)) {
 162             liveDisplayPrefs.removePreference(mLowPower);
 163             mLowPower = null;
 164         }
 165
 166         mOutdoorMode = (SwitchPreference) findPreference(KEY_LIVE_DISPLAY_AUTO_OUTDOOR_MODE);
 167         if (liveDisplayPrefs != null && mOutdoorMode != null
 168                 && !mCmHardwareManager.isSupported(FEATURE_SUNLIGHT_ENHANCEMENT)) {
 169             liveDisplayPrefs.removePreference(mOutdoorMode);
 170             mOutdoorMode = null;
 171         }
 172
 173         mColorEnhancement = (SwitchPreference) findPreference(KEY_LIVE_DISPLAY_COLOR_ENHANCE);
 174         if (liveDisplayPrefs != null && mColorEnhancement != null
 175                 && !mCmHardwareManager.isSupported(FEATURE_COLOR_ENHANCEMENT)) {
 176             liveDisplayPrefs.removePreference(mColorEnhancement);
 177             mColorEnhancement = null;
 178         }
 179
 180         if (calibrationPrefs != null
 181                 && !mCmHardwareManager.isSupported(FEATURE_DISPLAY_GAMMA_CALIBRATION)) {
 182             Preference gammaPref = findPreference(KEY_DISPLAY_GAMMA);
 183             if (gammaPref != null) {
 184                 calibrationPrefs.removePreference(gammaPref);
 185             }
 186         }
 187
 188         mScreenColorSettings = (PreferenceScreen) findPreference(KEY_SCREEN_COLOR_SETTINGS);
 189         if (calibrationPrefs != null) {
 190             if (!isPostProcessingSupported(getActivity()) && mScreenColorSettings != null) {
 191                 calibrationPrefs.removePreference(mScreenColorSettings);
 192             } else if ("user".equals(Build.TYPE)) {
 193                 // Remove simple RGB controls if HSIC controls are available
 194                 Preference displayColor = findPreference(KEY_DISPLAY_COLOR);
 195                 if (displayColor != null) {
 196                     calibrationPrefs.removePreference(displayColor);
 197                 }
 198             }
 199         }
 200     }
 201
 202     @Override
 203     public void onResume() {
 204         super.onResume();
 205         updateModeSummary();
 206         updateTemperatureSummary();
 207         mObserver.register(true);
 208     }
 209
 210     @Override
 211     public void onPause() {
 212         super.onPause();
 213         mObserver.register(false);
 214     }
 215
 216     private void updateModeSummary() {
 217         int mode = Settings.System.getIntForUser(getContentResolver(),
 218                 Settings.System.DISPLAY_TEMPERATURE_MODE,
 219                 MODE_DAY, UserHandle.USER_CURRENT);
 220
 221         int index = ArrayUtils.indexOf(mModeValues, String.valueOf(mode));
 222         mLiveDisplay.setSummary(mModeSummaries[index]);
 223     }
 224
 225     private void updateTemperatureSummary() {
 226         int day = Settings.System.getIntForUser(getContentResolver(),
 227                 Settings.System.DISPLAY_TEMPERATURE_DAY,
 228                 mDefaultDayTemperature,
 229                 UserHandle.USER_CURRENT);
 230         int night = Settings.System.getIntForUser(getContentResolver(),
 231                 Settings.System.DISPLAY_TEMPERATURE_NIGHT,
 232                 mDefaultNightTemperature,
 233                 UserHandle.USER_CURRENT);
 234
 235         mDisplayTemperature.setSummary(getResources().getString(
 236                 R.string.live_display_color_temperature_summary, day, night));
 237     }
 238
 239     @Override
 240     public boolean onPreferenceChange(Preference preference, Object objValue) {
 241         if (preference == mLiveDisplay) {
 242             Settings.System.putIntForUser(getContentResolver(),
 243                     Settings.System.DISPLAY_TEMPERATURE_MODE,
 244                     Integer.valueOf((String)objValue), UserHandle.USER_CURRENT);
 245         }
 246         return true;
 247     }
 248
 249     private static boolean isPostProcessingSupported(Context context) {
 250         return Utils.isPackageInstalled(context, "com.qualcomm.display");
 251     }
 252
 253     private final class SettingsObserver extends ContentObserver {
 254         private final Uri DISPLAY_TEMPERATURE_DAY_URI =
 255                 Settings.System.getUriFor(Settings.System.DISPLAY_TEMPERATURE_DAY);
 256         private final Uri DISPLAY_TEMPERATURE_NIGHT_URI =
 257                 Settings.System.getUriFor(Settings.System.DISPLAY_TEMPERATURE_NIGHT);
 258         private final Uri DISPLAY_TEMPERATURE_MODE_URI =
 259                 Settings.System.getUriFor(Settings.System.DISPLAY_TEMPERATURE_MODE);
 260
 261         public SettingsObserver() {
 262             super(mHandler);
 263         }
 264
 265         public void register(boolean register) {
 266             final ContentResolver cr = getContentResolver();
 267             if (register) {
 268                 cr.registerContentObserver(DISPLAY_TEMPERATURE_DAY_URI, false, this);
 269                 cr.registerContentObserver(DISPLAY_TEMPERATURE_NIGHT_URI, false, this);
 270                 cr.registerContentObserver(DISPLAY_TEMPERATURE_MODE_URI, false, this);
 271             } else {
 272                 cr.unregisterContentObserver(this);
 273             }
 274         }
 275
 276         @Override
 277         public void onChange(boolean selfChange, Uri uri) {
 278             super.onChange(selfChange,  uri);
 279             updateModeSummary();
 280             updateTemperatureSummary();
 281         }
 282     }
 283
 284     public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
 285             new BaseSearchIndexProvider() {
 286         private boolean mHasSunlightEnhancement, mHasColorEnhancement, mHasLowPower;
 287         private boolean mHasDisplayGamma;
 288
 289         @Override
 290         public List<SearchIndexableResource> getXmlResourcesToIndex(Context context,
 291                 boolean enabled) {
 292             ArrayList<SearchIndexableResource> result =
 293                     new ArrayList<SearchIndexableResource>();
 294
 295             SearchIndexableResource sir = new SearchIndexableResource(context);
 296             sir.xmlResId = R.xml.livedisplay;
 297             result.add(sir);
 298
 299             return result;
 300         }
 301
 302         @Override
 303         public List<String> getNonIndexableKeys(Context context) {
 304              CmHardwareManager cmHardwareManager =
 305                     (CmHardwareManager) context.getSystemService(Context.CMHW_SERVICE);
 306
 307             ArrayList<String> result = new ArrayList<String>();
 308             if (!cmHardwareManager.isSupported(FEATURE_SUNLIGHT_ENHANCEMENT)) {
 309                 result.add(KEY_LIVE_DISPLAY_AUTO_OUTDOOR_MODE);
 310             }
 311             if (!cmHardwareManager.isSupported(FEATURE_COLOR_ENHANCEMENT)) {
 312                 result.add(KEY_LIVE_DISPLAY_COLOR_ENHANCE);
 313             }
 314             if (!cmHardwareManager.isSupported(FEATURE_ADAPTIVE_BACKLIGHT)) {
 315                 result.add(KEY_LIVE_DISPLAY_LOW_POWER);
 316             }
 317             if (!isPostProcessingSupported(context)) {
 318                 result.add(KEY_SCREEN_COLOR_SETTINGS);
 319             } else {
 320                 result.add(KEY_DISPLAY_COLOR);
 321             }
 322             if (!cmHardwareManager.isSupported(FEATURE_DISPLAY_GAMMA_CALIBRATION)) {
 323                 result.add(KEY_DISPLAY_GAMMA);
 324             }
 325             return result;
 326         }
 327     };
 328 }