gecko/mobile/android/base/MultiChoicePreference.java

249 lines
8.4 KiB
Java
Raw Normal View History

/* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*-
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
package org.mozilla.gecko;
import android.app.AlertDialog;
import android.app.AlertDialog.Builder;
import android.content.Context;
import android.content.DialogInterface;
import android.content.res.TypedArray;
import android.preference.DialogPreference;
import android.preference.PreferenceManager;
import android.util.AttributeSet;
import android.widget.Button;
class MultiChoicePreference extends DialogPreference {
private static final String LOGTAG = "GeckoMultiChoicePreference";
private boolean mValues[];
private boolean mPrevValues[];
private CharSequence mEntryKeys[];
private CharSequence mEntries[];
private CharSequence mInitialValues[];
public MultiChoicePreference(Context context, AttributeSet attrs) {
super(context, attrs);
TypedArray a = context.obtainStyledAttributes(attrs, R.styleable.MultiChoicePreference);
mEntries = a.getTextArray(R.styleable.MultiChoicePreference_entries);
mEntryKeys = a.getTextArray(R.styleable.MultiChoicePreference_entryKeys);
mInitialValues = a.getTextArray(R.styleable.MultiChoicePreference_initialValues);
a.recycle();
loadPersistedValues();
}
public MultiChoicePreference(Context context) {
this(context, null);
}
/**
* Sets the human-readable entries to be shown in the list. This will be
* shown in subsequent dialogs.
* <p>
* Each entry must have a corresponding index in
* {@link #setEntryKeys(CharSequence[])} and
* {@link #setInitialValues(CharSequence[])}.
*
* @param entries The entries.
*/
public void setEntries(CharSequence[] entries) {
mEntries = entries.clone();
}
/**
* @param entriesResId The entries array as a resource.
*/
public void setEntries(int entriesResId) {
setEntries(getContext().getResources().getTextArray(entriesResId));
}
/**
* Sets the preference keys for preferences shown in the list.
*
* @param entryKeys The entry keys.
*/
public void setEntryKeys(CharSequence[] entryKeys) {
mEntryKeys = entryKeys.clone();
loadPersistedValues();
}
/**
* @param entryKeysResId The entryKeys array as a resource.
*/
public void setEntryKeys(int entryKeysResId) {
setEntryKeys(getContext().getResources().getTextArray(entryKeysResId));
}
/**
* The array of initial entry values in this list. Each entryValue
* corresponds to an entryKey. These values are used if a) the preference
* isn't persisted, or b) the preference is persisted but hasn't yet been
* set.
*
* @param initialValues The entry values
*/
public void setInitialValues(CharSequence[] initialValues) {
mInitialValues = initialValues.clone();
loadPersistedValues();
}
/**
* @param initialValuesResId The initialValues array as a resource.
*/
public void setInitialValues(int initialValuesResId) {
setInitialValues(getContext().getResources().getTextArray(initialValuesResId));
}
/**
* The list of translated strings corresponding to each preference.
*
* @return The array of entries.
*/
public CharSequence[] getEntries() {
return mEntries.clone();
}
/**
* The list of keys corresponding to each preference.
*
* @return The array of keys.
*/
public CharSequence[] getEntryKeys() {
return mEntryKeys.clone();
}
/**
* The list of initial values for each preference. Each string in this list
* should be either "true" or "false".
*
* @return The array of initial values.
*/
public CharSequence[] getInitialValues() {
return mInitialValues.clone();
}
/**
* The list of values for each preference. These values are updated after
* the dialog has been displayed.
*
* @return The array of values.
*/
public boolean[] getValues() {
return mValues.clone();
}
@Override
protected void onPrepareDialogBuilder(Builder builder) {
if (mEntries == null || mEntryKeys == null || mInitialValues == null) {
throw new IllegalStateException(
"MultiChoicePreference requires entries, entryKeys, and initialValues arrays.");
}
if (mEntries.length != mEntryKeys.length || mEntryKeys.length != mInitialValues.length) {
throw new IllegalStateException(
"MultiChoicePreference entries, entryKeys, and initialValues arrays must be the same length");
}
builder.setMultiChoiceItems(mEntries, mValues, new DialogInterface.OnMultiChoiceClickListener() {
@Override
public void onClick(DialogInterface dialog, int which, boolean val) {
// mValues is automatically updated when checkboxes are clicked
// enable positive button only if at least one item is checked
boolean enabled = false;
for (int i = 0; i < mValues.length; i++) {
if (mValues[i]) {
enabled = true;
break;
}
}
Button button = ((AlertDialog) dialog).getButton(DialogInterface.BUTTON_POSITIVE);
if (button.isEnabled() != enabled)
button.setEnabled(enabled);
}
});
}
@Override
protected void onDialogClosed(boolean positiveResult) {
if (mPrevValues == null || mInitialValues == null) {
// Initialization is done asynchronously, so these values may not
// have been set before the dialog was closed.
return;
}
if (!positiveResult) {
// user cancelled; reset checkbox values to their previous state
mValues = mPrevValues.clone();
return;
} else {
mPrevValues = mValues.clone();
}
GeckoAppShell.getHandler().post(new Runnable() {
@Override
public void run() {
for (int i = 0; i < mEntryKeys.length; i++) {
String key = mEntryKeys[i].toString();
persistBoolean(key, mValues[i]);
}
}
});
}
protected boolean persistBoolean(String key, boolean value) {
if (isPersistent()) {
if (value == getPersistedBoolean(!value)) {
// It's already there, so the same as persisting
return true;
}
PreferenceManager.getDefaultSharedPreferences(getContext())
.edit().putBoolean(key, value).commit();
return true;
}
return false;
}
protected boolean getPersistedBoolean(String key, boolean defaultReturnValue) {
if (!isPersistent())
return defaultReturnValue;
return PreferenceManager.getDefaultSharedPreferences(getContext())
.getBoolean(key, defaultReturnValue);
}
/**
* Loads persistent prefs from shared preferences. If the preferences
* aren't persistent or haven't yet been stored, they will be set to their
* initial values.
*/
private void loadPersistedValues() {
if (mEntryKeys == null || mInitialValues == null)
return;
final int entryCount = mEntryKeys.length;
if (entryCount != mEntries.length || entryCount != mInitialValues.length) {
throw new IllegalStateException(
"MultiChoicePreference entryKeys and initialValues arrays must be the same length");
}
mValues = new boolean[entryCount];
GeckoAppShell.getHandler().post(new Runnable() {
@Override
public void run() {
for (int i = 0; i < entryCount; i++) {
String key = mEntryKeys[i].toString();
boolean initialValue = mInitialValues[i].equals("true");
mValues[i] = getPersistedBoolean(key, initialValue);
}
mPrevValues = mValues.clone();
}
});
}
}