Omnigears: [2/3] Battery Light Settings
Change-Id: I0a0192162468fc1ca43f7015940b01d569e5fec9
diff --git a/res/drawable/ic_settings_leds.xml b/res/drawable/ic_settings_leds.xml
new file mode 100644
index 0000000..8e564d6
--- /dev/null
+++ b/res/drawable/ic_settings_leds.xml
@@ -0,0 +1,25 @@
+<!--
+ Copyright (C) 2016 The Android Open Source 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.
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+ android:width="24.0dp"
+ android:height="24.0dp"
+ android:viewportWidth="24.0"
+ android:viewportHeight="24.0"
+ android:tint="?android:attr/colorAccent">
+ <path
+ android:fillColor="#FFFFFFFF"
+ android:pathData="M11,0V4H13V0H11M18.3,2.29L15.24,5.29L16.64,6.71L19.7,3.71L18.3,2.29M5.71,2.29L4.29,3.71L7.29,6.71L8.71,5.29L5.71,2.29M12,6A4,4 0 0,0 8,10V16H6V18H9V23H11V18H13V23H15V18H18V16H16V10A4,4 0 0,0 12,6M2,9V11H6V9H2M18,9V11H22V9H18Z" />
+</vector>
diff --git a/res/values/custom_strings.xml b/res/values/custom_strings.xml
index 8c641c1..1fc58ae 100644
--- a/res/values/custom_strings.xml
+++ b/res/values/custom_strings.xml
@@ -19,6 +19,7 @@
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+ <string name="ok">OK</string>
<!-- Hardware keys -->
<string name="button_keys_title">Keys</string>
<string name="keys_bindings_title">Key actions</string>
@@ -148,6 +149,7 @@
<string name="color_picker_dialog_title">Color</string>
<!-- Battery light settings -->
+ <string name="batterylight_title">Battery LED settings</string>
<string name="battery_light_enable">Enable</string>
<string name="battery_low_pulse_title">Pulse if battery low</string>
<string name="battery_light_list_title">Colors</string>
diff --git a/res/xml/battery_light_settings.xml b/res/xml/battery_light_settings.xml
index d3a59fb..c6e40bc 100644
--- a/res/xml/battery_light_settings.xml
+++ b/res/xml/battery_light_settings.xml
@@ -17,7 +17,7 @@
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:settings="http://schemas.android.com/apk/res/com.android.settings">
- <SwitchPreference
+ <org.omnirom.omnigears.preference.SystemSettingSwitchPreference
android:key="battery_light_enabled"
android:title="@string/battery_light_enable"
android:persistent="false"/>
@@ -26,7 +26,7 @@
android:key="general_section"
android:title="@string/notification_light_general_title">
- <CheckBoxPreference
+ <org.omnirom.omnigears.preference.SystemSettingSwitchPreference
android:key="battery_light_pulse"
android:title="@string/battery_low_pulse_title"
android:dependency="battery_light_enabled"
diff --git a/src/org/omnirom/omnigears/batterylight/BatteryLightDialog.java b/src/org/omnirom/omnigears/batterylight/BatteryLightDialog.java
new file mode 100644
index 0000000..cb1e820
--- /dev/null
+++ b/src/org/omnirom/omnigears/batterylight/BatteryLightDialog.java
@@ -0,0 +1,291 @@
+/*
+ * Copyright (C) 2010 Daniel Nilsson
+ * Copyright (C) 2012 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 org.omnirom.omnigears.batterylight;
+
+import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.Context;
+import android.graphics.Color;
+import android.graphics.PixelFormat;
+import android.os.Bundle;
+import android.text.Editable;
+import android.text.TextWatcher;
+import android.text.InputFilter;
+import android.text.InputFilter.LengthFilter;
+import android.util.Pair;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.View.OnFocusChangeListener;
+import android.view.ViewGroup;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.AdapterView;
+import android.widget.BaseAdapter;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.Spinner;
+import android.widget.SpinnerAdapter;
+import android.widget.TextView;
+
+import com.android.settings.R;
+import org.omnirom.omnigears.ui.ColorPanelView;
+import org.omnirom.omnigears.ui.ColorPickerView;
+import org.omnirom.omnigears.ui.ColorPickerView.OnColorChangedListener;
+
+import java.util.ArrayList;
+import java.util.IllegalFormatException;
+import java.util.Locale;
+
+public class BatteryLightDialog extends AlertDialog implements
+ ColorPickerView.OnColorChangedListener, TextWatcher, OnFocusChangeListener {
+
+ private static final String TAG = "BatteryLightDialog";
+ private final static String STATE_KEY_COLOR = "BatteryLightDialog:color";
+
+ private ColorPickerView mColorPicker;
+
+ private EditText mHexColorInput;
+ private ColorPanelView mNewColor;
+ private LayoutInflater mInflater;
+ private boolean mMultiColor = true;
+ private Spinner mColorList;
+ private LinearLayout mColorListView;
+ private LinearLayout mColorPanelView;
+ private ColorPanelView mNewListColor;
+ private LedColorAdapter mLedColorAdapter;
+ private boolean mWithAlpha;
+
+ protected BatteryLightDialog(Context context, int initialColor) {
+ super(context);
+ mWithAlpha = false;
+ mMultiColor = getContext().getResources().getBoolean(R.bool.config_has_multi_color_led);
+ init(initialColor);
+ }
+
+ private void init(int color) {
+ // To fight color banding.
+ getWindow().setFormat(PixelFormat.RGBA_8888);
+ setUp(color);
+ }
+
+ /**
+ * This function sets up the dialog with the proper values. If the speedOff parameters
+ * has a -1 value disable both spinners
+ *
+ * @param color - the color to set
+ * @param speedOn - the flash time in ms
+ * @param speedOff - the flash length in ms
+ */
+ private void setUp(int color) {
+ mInflater = (LayoutInflater) getContext()
+ .getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+ View layout = mInflater.inflate(R.layout.dialog_battery_settings, null);
+
+ mColorPicker = (ColorPickerView) layout.findViewById(R.id.color_picker_view);
+ mHexColorInput = (EditText) layout.findViewById(R.id.hex_color_input);
+ mNewColor = (ColorPanelView) layout.findViewById(R.id.color_panel);
+ mColorPanelView = (LinearLayout) layout.findViewById(R.id.color_panel_view);
+
+ mColorListView = (LinearLayout) layout.findViewById(R.id.color_list_view);
+ mColorList = (Spinner) layout.findViewById(R.id.color_list_spinner);
+ mNewListColor = (ColorPanelView) layout.findViewById(R.id.color_list_panel);
+
+ mColorPicker.setOnColorChangedListener(this);
+ mHexColorInput.setOnFocusChangeListener(this);
+ setAlphaSliderVisible(mWithAlpha);
+ mColorPicker.setColor(color, true);
+
+ mColorList = (Spinner) layout.findViewById(R.id.color_list_spinner);
+ mLedColorAdapter = new LedColorAdapter(
+ R.array.entries_led_colors,
+ R.array.values_led_colors);
+ mColorList.setAdapter(mLedColorAdapter);
+ mColorList.setSelection(mLedColorAdapter.getColorPosition(color));
+ mColorList.setOnItemSelectedListener(mColorListListener);
+
+ setView(layout);
+
+ // show and hide the correct UI depending if we have multi-color led or not
+ if (mMultiColor){
+ mColorListView.setVisibility(View.GONE);
+ mColorPicker.setVisibility(View.VISIBLE);
+ mColorPanelView.setVisibility(View.VISIBLE);
+ } else {
+ mColorListView.setVisibility(View.VISIBLE);
+ mColorPicker.setVisibility(View.GONE);
+ mColorPanelView.setVisibility(View.GONE);
+ }
+ }
+
+ private AdapterView.OnItemSelectedListener mColorListListener = new AdapterView.OnItemSelectedListener() {
+
+ @Override
+ public void onItemSelected(AdapterView<?> parent, View view, int position, long id) {
+ int color = mLedColorAdapter.getColor(position);
+ mNewListColor.setColor(color);
+ }
+
+ @Override
+ public void onNothingSelected(AdapterView<?> parent) {
+ }
+ };
+
+ @Override
+ public Bundle onSaveInstanceState() {
+ Bundle state = super.onSaveInstanceState();
+ state.putInt(STATE_KEY_COLOR, getColor());
+ return state;
+ }
+
+ @Override
+ public void onRestoreInstanceState(Bundle state) {
+ super.onRestoreInstanceState(state);
+ mColorPicker.setColor(state.getInt(STATE_KEY_COLOR), true);
+ }
+
+ @Override
+ public void onColorChanged(int color) {
+ final boolean hasAlpha = mWithAlpha;
+ final String format = hasAlpha ? "%08x" : "%06x";
+ final int mask = hasAlpha ? 0xFFFFFFFF : 0x00FFFFFF;
+
+ mNewColor.setColor(color);
+ mHexColorInput.setText(String.format(Locale.US, format, color & mask));
+ }
+
+ public void setAlphaSliderVisible(boolean visible) {
+ mHexColorInput.setFilters(new InputFilter[] { new InputFilter.LengthFilter(visible ? 8 : 6) } );
+ mColorPicker.setAlphaSliderVisible(visible);
+ }
+
+ public int getColor() {
+ if (mMultiColor){
+ return mColorPicker.getColor();
+ } else {
+ return mNewListColor.getColor();
+ }
+ }
+
+ class LedColorAdapter extends BaseAdapter implements SpinnerAdapter {
+ private ArrayList<Pair<String, Integer>> mColors;
+
+ public LedColorAdapter(int ledColorResource, int ledValueResource) {
+ mColors = new ArrayList<Pair<String, Integer>>();
+
+ String[] color_names = getContext().getResources().getStringArray(ledColorResource);
+ String[] color_values = getContext().getResources().getStringArray(ledValueResource);
+
+ for(int i = 0; i < color_values.length; ++i) {
+ try {
+ int color = Color.parseColor(color_values[i]);
+ mColors.add(new Pair<String, Integer>(color_names[i], color));
+ } catch (IllegalArgumentException ex) {
+ // Number format is incorrect, ignore entry
+ }
+ }
+ }
+
+ /**
+ * Will return the position of the spinner entry with the specified
+ * color. Returns 0 if there is no such entry.
+ */
+ public int getColorPosition(int color) {
+ for (int position = 0; position < getCount(); ++position) {
+ if (getItem(position).second.equals(color)) {
+ return position;
+ }
+ }
+
+ return 0;
+ }
+
+ public int getColor(int position) {
+ Pair<String, Integer> item = getItem(position);
+ if (item != null){
+ return item.second;
+ }
+
+ // -1 is white
+ return -1;
+ }
+
+ @Override
+ public int getCount() {
+ return mColors.size();
+ }
+
+ @Override
+ public Pair<String, Integer> getItem(int position) {
+ return mColors.get(position);
+ }
+
+ @Override
+ public long getItemId(int position) {
+ return position;
+ }
+
+ @Override
+ public View getView(int position, View view, ViewGroup parent) {
+ if (view == null) {
+ view = mInflater.inflate(R.layout.led_color_item, null);
+ }
+
+ Pair<String, Integer> entry = getItem(position);
+ ((TextView) view.findViewById(R.id.textViewName)).setText(entry.first);
+
+ return view;
+ }
+ }
+
+ @Override
+ public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+ }
+
+ @Override
+ public void onTextChanged(CharSequence s, int start, int before, int count) {
+ }
+
+ @Override
+ public void afterTextChanged(Editable s) {
+ String hexColor = mHexColorInput.getText().toString();
+ if (!hexColor.isEmpty()) {
+ try {
+ int color = Color.parseColor('#' + hexColor);
+ if (!mWithAlpha) {
+ color |= 0xFF000000; // set opaque
+ }
+ mColorPicker.setColor(color);
+ mNewColor.setColor(color);
+ } catch (IllegalArgumentException ex) {
+ // Number format is incorrect, ignore
+ }
+ }
+ }
+
+ @Override
+ public void onFocusChange(View v, boolean hasFocus) {
+ if (!hasFocus) {
+ mHexColorInput.removeTextChangedListener(this);
+ InputMethodManager inputMethodManager = (InputMethodManager) getContext()
+ .getSystemService(Activity.INPUT_METHOD_SERVICE);
+ inputMethodManager.hideSoftInputFromWindow(v.getWindowToken(), 0);
+ } else {
+ mHexColorInput.addTextChangedListener(this);
+ }
+ }
+}
diff --git a/src/org/omnirom/omnigears/batterylight/BatteryLightPreference.java b/src/org/omnirom/omnigears/batterylight/BatteryLightPreference.java
new file mode 100644
index 0000000..5f316c7
--- /dev/null
+++ b/src/org/omnirom/omnigears/batterylight/BatteryLightPreference.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright (C) 2012 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 org.omnirom.omnigears.batterylight;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.content.res.Resources;
+import android.graphics.drawable.ShapeDrawable;
+import android.graphics.drawable.shapes.RectShape;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceViewHolder;
+import android.util.AttributeSet;
+import android.widget.ImageView;
+
+import com.android.settings.R;
+
+public class BatteryLightPreference extends Preference implements DialogInterface.OnDismissListener {
+
+ private static String TAG = "BatteryLightPreference";
+ public static final int DEFAULT_COLOR = 0xFFFFFF; //White
+
+ private ImageView mLightColorView;
+ private Resources mResources;
+ private int mColorValue;
+ private Dialog mDialog;
+
+ /**
+ * @param context
+ * @param attrs
+ */
+ public BatteryLightPreference(Context context, AttributeSet attrs) {
+ super(context, attrs);
+ mColorValue = DEFAULT_COLOR;
+ init();
+ }
+
+ public BatteryLightPreference(Context context, int color) {
+ super(context, null);
+ mColorValue = color;
+ init();
+ }
+
+ private void init() {
+ setLayoutResource(R.layout.preference_battery_light);
+ mResources = getContext().getResources();
+ }
+
+ public void setColor(int color) {
+ mColorValue = color;
+ updatePreferenceViews();
+ }
+
+ public int getColor() {
+ return mColorValue;
+ }
+
+ @Override
+ public void onBindViewHolder(PreferenceViewHolder holder) {
+ super.onBindViewHolder(holder);
+
+ mLightColorView = (ImageView) holder.findViewById(R.id.light_color);
+
+ updatePreferenceViews();
+ }
+
+ private void updatePreferenceViews() {
+ final int width = (int) mResources.getDimension(R.dimen.color_preference_width);
+ final int height = (int) mResources.getDimension(R.dimen.color_preference_height);
+
+ if (mLightColorView != null) {
+ mLightColorView.setEnabled(true);
+ mLightColorView.setImageDrawable(createRectShape(width, height, 0xFF000000 | mColorValue));
+ }
+ }
+
+ @Override
+ protected void onClick() {
+ if (mDialog != null && mDialog.isShowing()) return;
+ mDialog = getDialog();
+ mDialog.setOnDismissListener(this);
+ mDialog.show();
+ }
+
+ public Dialog getDialog() {
+ final BatteryLightDialog d = new BatteryLightDialog(getContext(),
+ 0xFF000000 | mColorValue);
+
+ d.setButton(AlertDialog.BUTTON_POSITIVE, mResources.getString(R.string.ok),
+ new DialogInterface.OnClickListener() {
+ @Override
+ public void onClick(DialogInterface dialog, int which) {
+ mColorValue = d.getColor() & 0x00FFFFFF; // strip alpha, led does not support it
+ updatePreferenceViews();
+ callChangeListener(this);
+ }
+ });
+ d.setButton(AlertDialog.BUTTON_NEGATIVE, mResources.getString(R.string.cancel),
+ (DialogInterface.OnClickListener) null);
+
+ return d;
+ }
+
+ private static ShapeDrawable createRectShape(int width, int height, int color) {
+ ShapeDrawable shape = new ShapeDrawable(new RectShape());
+ shape.setIntrinsicHeight(height);
+ shape.setIntrinsicWidth(width);
+ shape.getPaint().setColor(color);
+ return shape;
+ }
+
+ @Override
+ public void onDismiss(DialogInterface dialog) {
+ mDialog = null;
+ }
+}
diff --git a/src/org/omnirom/omnigears/batterylight/BatteryLightSettings.java b/src/org/omnirom/omnigears/batterylight/BatteryLightSettings.java
new file mode 100644
index 0000000..e519b8a
--- /dev/null
+++ b/src/org/omnirom/omnigears/batterylight/BatteryLightSettings.java
@@ -0,0 +1,248 @@
+/*
+ * Copyright (C) 2012 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 org.omnirom.omnigears.batterylight;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceGroup;
+import android.support.v7.preference.PreferenceScreen;
+import android.support.v14.preference.PreferenceFragment;
+import android.provider.SearchIndexableResource;
+import android.provider.Settings;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+
+import com.android.internal.logging.MetricsProto.MetricsEvent;
+import com.android.settings.R;
+import com.android.settings.SettingsPreferenceFragment;
+import com.android.settings.search.BaseSearchIndexProvider;
+import com.android.settings.search.Indexable;
+
+import org.omnirom.omnigears.preference.SystemSettingSwitchPreference;
+
+import java.util.List;
+import java.util.ArrayList;
+
+public class BatteryLightSettings extends SettingsPreferenceFragment implements
+ Preference.OnPreferenceChangeListener, Indexable {
+ private static final String TAG = "BatteryLightSettings";
+
+ private static final String LOW_COLOR_PREF = "low_color";
+ private static final String MEDIUM_COLOR_PREF = "medium_color";
+ private static final String FULL_COLOR_PREF = "full_color";
+ private static final String REALLY_FULL_COLOR_PREF = "really_full_color";
+ private static final String BATTERY_LIGHT_PREF = "battery_light_enabled";
+ private static final String BATTERY_PULSE_PREF = "battery_light_pulse";
+
+ private boolean mMultiColorLed;
+ private SystemSettingSwitchPreference mEnabledPref;
+ private SystemSettingSwitchPreference mPulsePref;
+ private PreferenceGroup mColorPrefs;
+ private BatteryLightPreference mLowColorPref;
+ private BatteryLightPreference mMediumColorPref;
+ private BatteryLightPreference mFullColorPref;
+ private BatteryLightPreference mReallyFullColorPref;
+ private static final int MENU_RESET = Menu.FIRST;
+ private int mLowBatteryWarningLevel;
+ private boolean mBatteryLightEnabled;
+
+ @Override
+ protected int getMetricsCategory() {
+ return MetricsEvent.OMNI_SETTINGS;
+ }
+
+ @Override
+ public void onCreate(Bundle savedInstanceState) {
+ super.onCreate(savedInstanceState);
+ addPreferencesFromResource(R.xml.battery_light_settings);
+
+ PreferenceScreen prefSet = getPreferenceScreen();
+ ContentResolver resolver = getContentResolver();
+
+ mLowBatteryWarningLevel = getResources().getInteger(
+ com.android.internal.R.integer.config_lowBatteryWarningLevel);
+ mBatteryLightEnabled = getResources().getBoolean(
+ com.android.internal.R.bool.config_intrusiveBatteryLed);
+
+ mEnabledPref = (SystemSettingSwitchPreference)prefSet.findPreference(BATTERY_LIGHT_PREF);
+ mEnabledPref.setChecked(Settings.System.getInt(resolver,
+ Settings.System.BATTERY_LIGHT_ENABLED, mBatteryLightEnabled ? 1 : 0) != 0);
+ mEnabledPref.setOnPreferenceChangeListener(this);
+
+ mPulsePref = (SystemSettingSwitchPreference)prefSet.findPreference(BATTERY_PULSE_PREF);
+ mPulsePref.setChecked(Settings.System.getInt(resolver,
+ Settings.System.BATTERY_LIGHT_PULSE, mBatteryLightEnabled ? 1 : 0) != 0);
+
+ // Does the Device support changing battery LED colors?
+ if (getResources().getBoolean(com.android.internal.R.bool.config_multiColorBatteryLed)) {
+ setHasOptionsMenu(true);
+
+ // Low, Medium and full color preferences
+ mLowColorPref = (BatteryLightPreference) prefSet.findPreference(LOW_COLOR_PREF);
+ mLowColorPref.setOnPreferenceChangeListener(this);
+
+ mMediumColorPref = (BatteryLightPreference) prefSet.findPreference(MEDIUM_COLOR_PREF);
+ mMediumColorPref.setOnPreferenceChangeListener(this);
+
+ mFullColorPref = (BatteryLightPreference) prefSet.findPreference(FULL_COLOR_PREF);
+ mFullColorPref.setOnPreferenceChangeListener(this);
+
+ mReallyFullColorPref = (BatteryLightPreference) prefSet.findPreference(REALLY_FULL_COLOR_PREF);
+ mReallyFullColorPref.setOnPreferenceChangeListener(this);
+ } else {
+ prefSet.removePreference(prefSet.findPreference("colors_list"));
+ }
+ }
+
+ @Override
+ public void onResume() {
+ super.onResume();
+ refreshDefault();
+ }
+
+ private void refreshDefault() {
+ ContentResolver resolver = getContentResolver();
+ Resources res = getResources();
+
+ if (mLowColorPref != null) {
+ int lowColor = Settings.System.getInt(resolver, Settings.System.BATTERY_LIGHT_LOW_COLOR,
+ res.getInteger(com.android.internal.R.integer.config_notificationsBatteryLowARGB));
+ mLowColorPref.setColor(lowColor);
+ }
+
+ if (mMediumColorPref != null) {
+ int mediumColor = Settings.System.getInt(resolver, Settings.System.BATTERY_LIGHT_MEDIUM_COLOR,
+ res.getInteger(com.android.internal.R.integer.config_notificationsBatteryMediumARGB));
+ mMediumColorPref.setColor(mediumColor);
+ }
+
+ if (mFullColorPref != null) {
+ int fullColor = Settings.System.getInt(resolver, Settings.System.BATTERY_LIGHT_FULL_COLOR,
+ res.getInteger(com.android.internal.R.integer.config_notificationsBatteryFullARGB));
+ mFullColorPref.setColor(fullColor);
+ }
+
+ if (mReallyFullColorPref != null) {
+ int reallyFullColor = Settings.System.getInt(resolver, Settings.System.BATTERY_LIGHT_REALLY_FULL_COLOR,
+ res.getInteger(com.android.internal.R.integer.config_notificationsBatteryFullARGB));
+ mReallyFullColorPref.setColor(reallyFullColor);
+ }
+ }
+
+ /**
+ * Updates the default or application specific notification settings.
+ *
+ * @param key of the specific setting to update
+ * @param color
+ */
+ protected void updateValues(String key, Integer color) {
+ ContentResolver resolver = getContentResolver();
+
+ if (key.equals(LOW_COLOR_PREF)) {
+ Settings.System.putInt(resolver, Settings.System.BATTERY_LIGHT_LOW_COLOR, color);
+ } else if (key.equals(MEDIUM_COLOR_PREF)) {
+ Settings.System.putInt(resolver, Settings.System.BATTERY_LIGHT_MEDIUM_COLOR, color);
+ } else if (key.equals(FULL_COLOR_PREF)) {
+ Settings.System.putInt(resolver, Settings.System.BATTERY_LIGHT_FULL_COLOR, color);
+ } else if (key.equals(REALLY_FULL_COLOR_PREF)) {
+ Settings.System.putInt(resolver, Settings.System.BATTERY_LIGHT_REALLY_FULL_COLOR, color);
+ }
+ }
+
+ /*@Override
+ public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+ menu.add(0, MENU_RESET, 0, R.string.reset)
+ .setIcon(R.drawable.ic_settings_backup) // use the backup icon
+ .setAlphabeticShortcut('r')
+ .setShowAsActionFlags(MenuItem.SHOW_AS_ACTION_ALWAYS | MenuItem.SHOW_AS_ACTION_WITH_TEXT);
+ }
+
+ @Override
+ public boolean onOptionsItemSelected(MenuItem item) {
+ switch (item.getItemId()) {
+ case MENU_RESET:
+ resetColors();
+ return true;
+ }
+ return false;
+ }
+
+ protected void resetColors() {
+ ContentResolver resolver = getContentResolver();
+ Resources res = getResources();
+
+ // Reset to the framework default colors
+ Settings.System.putInt(resolver, Settings.System.BATTERY_LIGHT_LOW_COLOR,
+ res.getInteger(com.android.internal.R.integer.config_notificationsBatteryLowARGB));
+ Settings.System.putInt(resolver, Settings.System.BATTERY_LIGHT_MEDIUM_COLOR,
+ res.getInteger(com.android.internal.R.integer.config_notificationsBatteryMediumARGB));
+ Settings.System.putInt(resolver, Settings.System.BATTERY_LIGHT_FULL_COLOR,
+ res.getInteger(com.android.internal.R.integer.config_notificationsBatteryFullARGB));
+ Settings.System.putInt(resolver, Settings.System.BATTERY_LIGHT_REALLY_FULL_COLOR,
+ res.getInteger(com.android.internal.R.integer.config_notificationsBatteryFullARGB));
+ refreshDefault();
+ }*/
+
+ @Override
+ public boolean onPreferenceChange(Preference preference, Object objValue) {
+ if (preference == mEnabledPref) {
+ boolean value = (Boolean) objValue;
+ Settings.System.putInt(getActivity().getContentResolver(),
+ Settings.System.BATTERY_LIGHT_ENABLED, value ? 1:0);
+ } else {
+ BatteryLightPreference lightPref = (BatteryLightPreference) preference;
+ updateValues(lightPref.getKey(), lightPref.getColor());
+ }
+ return true;
+ }
+
+ public static final Indexable.SearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
+ new BaseSearchIndexProvider() {
+ @Override
+ public List<SearchIndexableResource> getXmlResourcesToIndex(Context context,
+ boolean enabled) {
+ ArrayList<SearchIndexableResource> result =
+ new ArrayList<SearchIndexableResource>();
+
+ SearchIndexableResource sir = new SearchIndexableResource(context);
+ sir.xmlResId = R.xml.battery_light_settings;
+ result.add(sir);
+ return result;
+ }
+
+ @Override
+ public List<String> getNonIndexableKeys(Context context) {
+ ArrayList<String> result = new ArrayList<String>();
+ final Resources res = context.getResources();
+ if (!res.getBoolean(com.android.internal.R.bool.config_intrusiveBatteryLed)) {
+ result.add(BATTERY_LIGHT_PREF);
+ result.add(BATTERY_PULSE_PREF);
+ }
+ if (!res.getBoolean(com.android.internal.R.bool.config_multiColorBatteryLed)) {
+ result.add(LOW_COLOR_PREF);
+ result.add(MEDIUM_COLOR_PREF);
+ result.add(FULL_COLOR_PREF);
+ result.add(REALLY_FULL_COLOR_PREF);
+ }
+ return result;
+ }
+ };
+}