diff options
Diffstat (limited to 'java/com/android/contacts/common/preference')
3 files changed, 447 insertions, 0 deletions
diff --git a/java/com/android/contacts/common/preference/ContactsPreferences.java b/java/com/android/contacts/common/preference/ContactsPreferences.java new file mode 100644 index 000000000..7f0d99acd --- /dev/null +++ b/java/com/android/contacts/common/preference/ContactsPreferences.java @@ -0,0 +1,269 @@ +/* + * Copyright (C) 2010 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. + */ + +package com.android.contacts.common.preference; + +import android.content.Context; +import android.content.SharedPreferences; +import android.content.SharedPreferences.Editor; +import android.content.SharedPreferences.OnSharedPreferenceChangeListener; +import android.os.Handler; +import android.preference.PreferenceManager; +import android.provider.Settings; +import android.provider.Settings.SettingNotFoundException; +import android.text.TextUtils; +import com.android.contacts.common.R; +import com.android.contacts.common.model.account.AccountWithDataSet; + +/** Manages user preferences for contacts. */ +public class ContactsPreferences implements OnSharedPreferenceChangeListener { + + /** The value for the DISPLAY_ORDER key to show the given name first. */ + public static final int DISPLAY_ORDER_PRIMARY = 1; + + /** The value for the DISPLAY_ORDER key to show the family name first. */ + public static final int DISPLAY_ORDER_ALTERNATIVE = 2; + + public static final String DISPLAY_ORDER_KEY = "android.contacts.DISPLAY_ORDER"; + + /** The value for the SORT_ORDER key corresponding to sort by given name first. */ + public static final int SORT_ORDER_PRIMARY = 1; + + public static final String SORT_ORDER_KEY = "android.contacts.SORT_ORDER"; + + /** The value for the SORT_ORDER key corresponding to sort by family name first. */ + public static final int SORT_ORDER_ALTERNATIVE = 2; + + public static final String PREF_DISPLAY_ONLY_PHONES = "only_phones"; + + public static final boolean PREF_DISPLAY_ONLY_PHONES_DEFAULT = false; + + /** + * Value to use when a preference is unassigned and needs to be read from the shared preferences + */ + private static final int PREFERENCE_UNASSIGNED = -1; + + private final Context mContext; + private final SharedPreferences mPreferences; + private int mSortOrder = PREFERENCE_UNASSIGNED; + private int mDisplayOrder = PREFERENCE_UNASSIGNED; + private String mDefaultAccount = null; + private ChangeListener mListener = null; + private Handler mHandler; + private String mDefaultAccountKey; + private String mDefaultAccountSavedKey; + + public ContactsPreferences(Context context) { + mContext = context; + mHandler = new Handler(); + mPreferences = mContext.getSharedPreferences(context.getPackageName(), Context.MODE_PRIVATE); + mDefaultAccountKey = + mContext.getResources().getString(R.string.contact_editor_default_account_key); + mDefaultAccountSavedKey = + mContext.getResources().getString(R.string.contact_editor_anything_saved_key); + maybeMigrateSystemSettings(); + } + + public boolean isSortOrderUserChangeable() { + return mContext.getResources().getBoolean(R.bool.config_sort_order_user_changeable); + } + + public int getDefaultSortOrder() { + if (mContext.getResources().getBoolean(R.bool.config_default_sort_order_primary)) { + return SORT_ORDER_PRIMARY; + } else { + return SORT_ORDER_ALTERNATIVE; + } + } + + public int getSortOrder() { + if (!isSortOrderUserChangeable()) { + return getDefaultSortOrder(); + } + if (mSortOrder == PREFERENCE_UNASSIGNED) { + mSortOrder = mPreferences.getInt(SORT_ORDER_KEY, getDefaultSortOrder()); + } + return mSortOrder; + } + + public void setSortOrder(int sortOrder) { + mSortOrder = sortOrder; + final Editor editor = mPreferences.edit(); + editor.putInt(SORT_ORDER_KEY, sortOrder); + editor.commit(); + } + + public boolean isDisplayOrderUserChangeable() { + return mContext.getResources().getBoolean(R.bool.config_display_order_user_changeable); + } + + public int getDefaultDisplayOrder() { + if (mContext.getResources().getBoolean(R.bool.config_default_display_order_primary)) { + return DISPLAY_ORDER_PRIMARY; + } else { + return DISPLAY_ORDER_ALTERNATIVE; + } + } + + public int getDisplayOrder() { + if (!isDisplayOrderUserChangeable()) { + return getDefaultDisplayOrder(); + } + if (mDisplayOrder == PREFERENCE_UNASSIGNED) { + mDisplayOrder = mPreferences.getInt(DISPLAY_ORDER_KEY, getDefaultDisplayOrder()); + } + return mDisplayOrder; + } + + public void setDisplayOrder(int displayOrder) { + mDisplayOrder = displayOrder; + final Editor editor = mPreferences.edit(); + editor.putInt(DISPLAY_ORDER_KEY, displayOrder); + editor.commit(); + } + + public boolean isDefaultAccountUserChangeable() { + return mContext.getResources().getBoolean(R.bool.config_default_account_user_changeable); + } + + public String getDefaultAccount() { + if (!isDefaultAccountUserChangeable()) { + return mDefaultAccount; + } + if (TextUtils.isEmpty(mDefaultAccount)) { + final String accountString = mPreferences.getString(mDefaultAccountKey, mDefaultAccount); + if (!TextUtils.isEmpty(accountString)) { + final AccountWithDataSet accountWithDataSet = AccountWithDataSet.unstringify(accountString); + mDefaultAccount = accountWithDataSet.name; + } + } + return mDefaultAccount; + } + + public void setDefaultAccount(AccountWithDataSet accountWithDataSet) { + mDefaultAccount = accountWithDataSet == null ? null : accountWithDataSet.name; + final Editor editor = mPreferences.edit(); + if (TextUtils.isEmpty(mDefaultAccount)) { + editor.remove(mDefaultAccountKey); + } else { + editor.putString(mDefaultAccountKey, accountWithDataSet.stringify()); + } + editor.putBoolean(mDefaultAccountSavedKey, true); + editor.commit(); + } + + public void registerChangeListener(ChangeListener listener) { + if (mListener != null) { + unregisterChangeListener(); + } + + mListener = listener; + + // Reset preferences to "unknown" because they may have changed while the + // listener was unregistered. + mDisplayOrder = PREFERENCE_UNASSIGNED; + mSortOrder = PREFERENCE_UNASSIGNED; + mDefaultAccount = null; + + mPreferences.registerOnSharedPreferenceChangeListener(this); + } + + public void unregisterChangeListener() { + if (mListener != null) { + mListener = null; + } + + mPreferences.unregisterOnSharedPreferenceChangeListener(this); + } + + @Override + public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, final String key) { + // This notification is not sent on the Ui thread. Use the previously created Handler + // to switch to the Ui thread + mHandler.post( + new Runnable() { + @Override + public void run() { + refreshValue(key); + } + }); + } + + /** + * Forces the value for the given key to be looked up from shared preferences and notifies the + * registered {@link ChangeListener} + * + * @param key the {@link SharedPreferences} key to look up + */ + public void refreshValue(String key) { + if (DISPLAY_ORDER_KEY.equals(key)) { + mDisplayOrder = PREFERENCE_UNASSIGNED; + mDisplayOrder = getDisplayOrder(); + } else if (SORT_ORDER_KEY.equals(key)) { + mSortOrder = PREFERENCE_UNASSIGNED; + mSortOrder = getSortOrder(); + } else if (mDefaultAccountKey.equals(key)) { + mDefaultAccount = null; + mDefaultAccount = getDefaultAccount(); + } + if (mListener != null) { + mListener.onChange(); + } + } + + /** + * If there are currently no preferences (which means this is the first time we are run), For sort + * order and display order, check to see if there are any preferences stored in system settings + * (pre-L) which can be copied into our own SharedPreferences. For default account setting, check + * to see if there are any preferences stored in the previous SharedPreferences which can be + * copied into current SharedPreferences. + */ + private void maybeMigrateSystemSettings() { + if (!mPreferences.contains(SORT_ORDER_KEY)) { + int sortOrder = getDefaultSortOrder(); + try { + sortOrder = Settings.System.getInt(mContext.getContentResolver(), SORT_ORDER_KEY); + } catch (SettingNotFoundException e) { + } + setSortOrder(sortOrder); + } + + if (!mPreferences.contains(DISPLAY_ORDER_KEY)) { + int displayOrder = getDefaultDisplayOrder(); + try { + displayOrder = Settings.System.getInt(mContext.getContentResolver(), DISPLAY_ORDER_KEY); + } catch (SettingNotFoundException e) { + } + setDisplayOrder(displayOrder); + } + + if (!mPreferences.contains(mDefaultAccountKey)) { + final SharedPreferences previousPrefs = + PreferenceManager.getDefaultSharedPreferences(mContext); + final String defaultAccount = previousPrefs.getString(mDefaultAccountKey, null); + if (!TextUtils.isEmpty(defaultAccount)) { + final AccountWithDataSet accountWithDataSet = + AccountWithDataSet.unstringify(defaultAccount); + setDefaultAccount(accountWithDataSet); + } + } + } + + public interface ChangeListener { + + void onChange(); + } +} diff --git a/java/com/android/contacts/common/preference/DisplayOrderPreference.java b/java/com/android/contacts/common/preference/DisplayOrderPreference.java new file mode 100644 index 000000000..8dda57f9f --- /dev/null +++ b/java/com/android/contacts/common/preference/DisplayOrderPreference.java @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2010 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. + */ + +package com.android.contacts.common.preference; + +import android.app.AlertDialog.Builder; +import android.content.Context; +import android.preference.ListPreference; +import android.util.AttributeSet; +import com.android.contacts.common.R; + +/** Custom preference: view-name-as (first name first or last name first). */ +public final class DisplayOrderPreference extends ListPreference { + + private ContactsPreferences mPreferences; + private Context mContext; + + public DisplayOrderPreference(Context context) { + super(context); + prepare(); + } + + public DisplayOrderPreference(Context context, AttributeSet attrs) { + super(context, attrs); + prepare(); + } + + private void prepare() { + mContext = getContext(); + mPreferences = new ContactsPreferences(mContext); + setEntries( + new String[] { + mContext.getString(R.string.display_options_view_given_name_first), + mContext.getString(R.string.display_options_view_family_name_first), + }); + setEntryValues( + new String[] { + String.valueOf(ContactsPreferences.DISPLAY_ORDER_PRIMARY), + String.valueOf(ContactsPreferences.DISPLAY_ORDER_ALTERNATIVE), + }); + setValue(String.valueOf(mPreferences.getDisplayOrder())); + } + + @Override + protected boolean shouldPersist() { + return false; // This preference takes care of its own storage + } + + @Override + public CharSequence getSummary() { + switch (mPreferences.getDisplayOrder()) { + case ContactsPreferences.DISPLAY_ORDER_PRIMARY: + return mContext.getString(R.string.display_options_view_given_name_first); + case ContactsPreferences.DISPLAY_ORDER_ALTERNATIVE: + return mContext.getString(R.string.display_options_view_family_name_first); + } + return null; + } + + @Override + protected boolean persistString(String value) { + int newValue = Integer.parseInt(value); + if (newValue != mPreferences.getDisplayOrder()) { + mPreferences.setDisplayOrder(newValue); + notifyChanged(); + } + return true; + } + + @Override + // UX recommendation is not to show cancel button on such lists. + protected void onPrepareDialogBuilder(Builder builder) { + super.onPrepareDialogBuilder(builder); + builder.setNegativeButton(null, null); + } +} diff --git a/java/com/android/contacts/common/preference/SortOrderPreference.java b/java/com/android/contacts/common/preference/SortOrderPreference.java new file mode 100644 index 000000000..9b6f57860 --- /dev/null +++ b/java/com/android/contacts/common/preference/SortOrderPreference.java @@ -0,0 +1,89 @@ +/* + * Copyright (C) 2010 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. + */ + +package com.android.contacts.common.preference; + +import android.app.AlertDialog.Builder; +import android.content.Context; +import android.preference.ListPreference; +import android.util.AttributeSet; +import com.android.contacts.common.R; + +/** Custom preference: sort-by. */ +public final class SortOrderPreference extends ListPreference { + + private ContactsPreferences mPreferences; + private Context mContext; + + public SortOrderPreference(Context context) { + super(context); + prepare(); + } + + public SortOrderPreference(Context context, AttributeSet attrs) { + super(context, attrs); + prepare(); + } + + private void prepare() { + mContext = getContext(); + mPreferences = new ContactsPreferences(mContext); + setEntries( + new String[] { + mContext.getString(R.string.display_options_sort_by_given_name), + mContext.getString(R.string.display_options_sort_by_family_name), + }); + setEntryValues( + new String[] { + String.valueOf(ContactsPreferences.SORT_ORDER_PRIMARY), + String.valueOf(ContactsPreferences.SORT_ORDER_ALTERNATIVE), + }); + setValue(String.valueOf(mPreferences.getSortOrder())); + } + + @Override + protected boolean shouldPersist() { + return false; // This preference takes care of its own storage + } + + @Override + public CharSequence getSummary() { + switch (mPreferences.getSortOrder()) { + case ContactsPreferences.SORT_ORDER_PRIMARY: + return mContext.getString(R.string.display_options_sort_by_given_name); + case ContactsPreferences.SORT_ORDER_ALTERNATIVE: + return mContext.getString(R.string.display_options_sort_by_family_name); + } + return null; + } + + @Override + protected boolean persistString(String value) { + int newValue = Integer.parseInt(value); + if (newValue != mPreferences.getSortOrder()) { + mPreferences.setSortOrder(newValue); + notifyChanged(); + } + return true; + } + + @Override + // UX recommendation is not to show cancel button on such lists. + protected void onPrepareDialogBuilder(Builder builder) { + super.onPrepareDialogBuilder(builder); + builder.setNegativeButton(null, null); + } +} |