| /* |
| * Copyright (C) 2009 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.ui; |
| |
| import com.android.contacts.ContactsSearchManager; |
| import com.android.contacts.R; |
| import com.android.contacts.model.ContactsSource; |
| import com.android.contacts.model.GoogleSource; |
| import com.android.contacts.model.Sources; |
| import com.android.contacts.model.EntityDelta.ValuesDelta; |
| import com.android.contacts.util.EmptyService; |
| import com.android.contacts.util.WeakAsyncTask; |
| import com.google.android.collect.Lists; |
| |
| import android.accounts.Account; |
| import android.app.Activity; |
| import android.app.AlertDialog; |
| import android.app.Dialog; |
| import android.app.ExpandableListActivity; |
| import android.app.ProgressDialog; |
| import android.content.ContentProviderOperation; |
| import android.content.ContentResolver; |
| import android.content.ContentValues; |
| import android.content.Context; |
| import android.content.DialogInterface; |
| import android.content.EntityIterator; |
| import android.content.Intent; |
| import android.content.OperationApplicationException; |
| import android.content.SharedPreferences; |
| import android.content.ContentProviderOperation.Builder; |
| import android.content.SharedPreferences.Editor; |
| import android.database.Cursor; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.RemoteException; |
| import android.preference.PreferenceManager; |
| import android.provider.ContactsContract; |
| import android.provider.ContactsContract.Groups; |
| import android.provider.ContactsContract.Settings; |
| import android.util.Log; |
| import android.view.ContextMenu; |
| import android.view.LayoutInflater; |
| import android.view.MenuItem; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.view.MenuItem.OnMenuItemClickListener; |
| import android.widget.AdapterView; |
| import android.widget.BaseExpandableListAdapter; |
| import android.widget.CheckBox; |
| import android.widget.ExpandableListAdapter; |
| import android.widget.ExpandableListView; |
| import android.widget.ListView; |
| import android.widget.TextView; |
| import android.widget.ExpandableListView.ExpandableListContextMenuInfo; |
| |
| import java.lang.ref.WeakReference; |
| import java.util.ArrayList; |
| import java.util.Collections; |
| import java.util.Comparator; |
| import java.util.Iterator; |
| |
| /** |
| * Shows a list of all available {@link Groups} available, letting the user |
| * select which ones they want to be visible. |
| */ |
| public final class ContactsPreferencesActivity extends ExpandableListActivity implements |
| AdapterView.OnItemClickListener, View.OnClickListener { |
| private static final String TAG = "DisplayGroupsActivity"; |
| |
| public interface Prefs { |
| public static final String DISPLAY_ONLY_PHONES = "only_phones"; |
| public static final boolean DISPLAY_ONLY_PHONES_DEFAULT = false; |
| |
| } |
| |
| private static final int DIALOG_SORT_ORDER = 1; |
| private static final int DIALOG_DISPLAY_ORDER = 2; |
| |
| private ExpandableListView mList; |
| private DisplayAdapter mAdapter; |
| |
| private SharedPreferences mPrefs; |
| private ContactsPreferences mContactsPrefs; |
| |
| private CheckBox mDisplayPhones; |
| |
| private View mHeaderPhones; |
| private View mHeaderSeparator; |
| |
| private View mSortOrderView; |
| private TextView mSortOrderTextView; |
| private int mSortOrder; |
| |
| private View mDisplayOrderView; |
| private TextView mDisplayOrderTextView; |
| private int mDisplayOrder; |
| |
| @Override |
| protected void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| setContentView(R.layout.contacts_preferences); |
| |
| mList = getExpandableListView(); |
| mList.setHeaderDividersEnabled(true); |
| mPrefs = PreferenceManager.getDefaultSharedPreferences(this); |
| mContactsPrefs = new ContactsPreferences(this); |
| mAdapter = new DisplayAdapter(this); |
| |
| final LayoutInflater inflater = getLayoutInflater(); |
| |
| createWithPhonesOnlyPreferenceView(inflater); |
| createSortOrderPreferenceView(inflater); |
| createDisplayOrderPreferenceView(inflater); |
| createDisplayGroupHeader(inflater); |
| |
| findViewById(R.id.btn_done).setOnClickListener(this); |
| findViewById(R.id.btn_discard).setOnClickListener(this); |
| |
| // Catch clicks on the header views |
| mList.setOnItemClickListener(this); |
| mList.setOnCreateContextMenuListener(this); |
| |
| mSortOrder = mContactsPrefs.getSortOrder(); |
| mDisplayOrder = mContactsPrefs.getDisplayOrder(); |
| } |
| |
| private void createWithPhonesOnlyPreferenceView(LayoutInflater inflater) { |
| // Add the "Only contacts with phones" header modifier. |
| mHeaderPhones = inflater.inflate(R.layout.display_options_phones_only, mList, false); |
| mHeaderPhones.setId(R.id.header_phones); |
| mDisplayPhones = (CheckBox) mHeaderPhones.findViewById(android.R.id.checkbox); |
| mDisplayPhones.setChecked(mPrefs.getBoolean(Prefs.DISPLAY_ONLY_PHONES, |
| Prefs.DISPLAY_ONLY_PHONES_DEFAULT)); |
| { |
| final TextView text1 = (TextView)mHeaderPhones.findViewById(android.R.id.text1); |
| final TextView text2 = (TextView)mHeaderPhones.findViewById(android.R.id.text2); |
| text1.setText(R.string.showFilterPhones); |
| text2.setText(R.string.showFilterPhonesDescrip); |
| } |
| } |
| |
| private void createSortOrderPreferenceView(LayoutInflater inflater) { |
| mSortOrderView = inflater.inflate(R.layout.preference_with_more_button, mList, false); |
| |
| View preferenceLayout = mSortOrderView.findViewById(R.id.preference); |
| |
| TextView label = (TextView)preferenceLayout.findViewById(R.id.label); |
| label.setText(getString(R.string.display_options_sort_list_by)); |
| |
| mSortOrderTextView = (TextView)preferenceLayout.findViewById(R.id.data); |
| } |
| |
| private void createDisplayOrderPreferenceView(LayoutInflater inflater) { |
| mDisplayOrderView = inflater.inflate(R.layout.preference_with_more_button, mList, false); |
| View preferenceLayout = mDisplayOrderView.findViewById(R.id.preference); |
| |
| TextView label = (TextView)preferenceLayout.findViewById(R.id.label); |
| label.setText(getString(R.string.display_options_view_names_as)); |
| |
| mDisplayOrderTextView = (TextView)preferenceLayout.findViewById(R.id.data); |
| } |
| |
| private void createDisplayGroupHeader(LayoutInflater inflater) { |
| // Add the separator before showing the detailed group list. |
| mHeaderSeparator = inflater.inflate(R.layout.list_separator, mList, false); |
| { |
| final TextView text1 = (TextView)mHeaderSeparator; |
| text1.setText(R.string.headerContactGroups); |
| } |
| } |
| |
| @Override |
| protected void onResume() { |
| super.onResume(); |
| mList.removeHeaderView(mHeaderPhones); |
| mList.removeHeaderView(mSortOrderView); |
| mList.removeHeaderView(mDisplayOrderView); |
| mList.removeHeaderView(mHeaderSeparator); |
| |
| // List adapter needs to be reset, because header views cannot be added |
| // to a list with an existing adapter. |
| setListAdapter(null); |
| |
| mList.addHeaderView(mHeaderPhones, null, true); |
| if (mContactsPrefs.isSortOrderUserChangeable()) { |
| mList.addHeaderView(mSortOrderView, null, true); |
| } |
| |
| if (mContactsPrefs.isSortOrderUserChangeable()) { |
| mList.addHeaderView(mDisplayOrderView, null, true); |
| } |
| |
| mList.addHeaderView(mHeaderSeparator, null, false); |
| |
| setListAdapter(mAdapter); |
| |
| bindView(); |
| |
| // Start background query to find account details |
| new QueryGroupsTask(this).execute(); |
| } |
| |
| private void bindView() { |
| mSortOrderTextView.setText( |
| mSortOrder == ContactsContract.Preferences.SORT_ORDER_PRIMARY |
| ? getString(R.string.display_options_sort_by_given_name) |
| : getString(R.string.display_options_sort_by_family_name)); |
| |
| mDisplayOrderTextView.setText( |
| mDisplayOrder == ContactsContract.Preferences.DISPLAY_ORDER_PRIMARY |
| ? getString(R.string.display_options_view_given_name_first) |
| : getString(R.string.display_options_view_family_name_first)); |
| } |
| |
| @Override |
| protected Dialog onCreateDialog(int id, Bundle args) { |
| switch (id) { |
| case DIALOG_SORT_ORDER: |
| return createSortOrderDialog(); |
| case DIALOG_DISPLAY_ORDER: |
| return createDisplayOrderDialog(); |
| } |
| |
| return null; |
| } |
| |
| private Dialog createSortOrderDialog() { |
| String[] items = new String[] { |
| getString(R.string.display_options_sort_by_given_name), |
| getString(R.string.display_options_sort_by_family_name), |
| }; |
| |
| return new AlertDialog.Builder(this) |
| .setTitle(R.string.display_options_sort_list_by) |
| .setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface dialog, int whichButton) { |
| setSortOrder(dialog); |
| dialog.dismiss(); |
| } |
| }) |
| .setNegativeButton(android.R.string.cancel, null) |
| .create(); |
| } |
| |
| private Dialog createDisplayOrderDialog() { |
| String[] items = new String[] { |
| getString(R.string.display_options_view_given_name_first), |
| getString(R.string.display_options_view_family_name_first), |
| }; |
| |
| return new AlertDialog.Builder(this) |
| .setTitle(R.string.display_options_view_names_as) |
| .setSingleChoiceItems(items, -1, new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface dialog, int whichButton) { |
| setDisplayOrder(dialog); |
| dialog.dismiss(); |
| } |
| }) |
| .setNegativeButton(android.R.string.cancel, null) |
| .create(); |
| } |
| |
| @Override |
| protected void onPrepareDialog(int id, Dialog dialog, Bundle args) { |
| switch (id) { |
| case DIALOG_SORT_ORDER: |
| setCheckedItem(dialog, |
| mSortOrder == ContactsContract.Preferences.SORT_ORDER_PRIMARY ? 0 : 1); |
| break; |
| case DIALOG_DISPLAY_ORDER: |
| setCheckedItem(dialog, |
| mDisplayOrder == ContactsContract.Preferences.DISPLAY_ORDER_PRIMARY |
| ? 0 : 1); |
| break; |
| } |
| } |
| |
| private void setCheckedItem(Dialog dialog, int position) { |
| ListView listView = ((AlertDialog)dialog).getListView(); |
| listView.setItemChecked(position, true); |
| listView.setSelection(position); |
| } |
| |
| protected void setSortOrder(DialogInterface dialog) { |
| ListView listView = ((AlertDialog)dialog).getListView(); |
| int checked = listView.getCheckedItemPosition(); |
| mSortOrder = checked == 0 |
| ? ContactsContract.Preferences.SORT_ORDER_PRIMARY |
| : ContactsContract.Preferences.SORT_ORDER_ALTERNATIVE; |
| |
| bindView(); |
| } |
| |
| protected void setDisplayOrder(DialogInterface dialog) { |
| ListView listView = ((AlertDialog)dialog).getListView(); |
| int checked = listView.getCheckedItemPosition(); |
| mDisplayOrder = checked == 0 |
| ? ContactsContract.Preferences.DISPLAY_ORDER_PRIMARY |
| : ContactsContract.Preferences.DISPLAY_ORDER_ALTERNATIVE; |
| |
| bindView(); |
| } |
| |
| /** |
| * Background operation to build set of {@link AccountDisplay} for each |
| * {@link Sources#getAccounts(boolean)} that provides groups. |
| */ |
| private static class QueryGroupsTask extends |
| WeakAsyncTask<Void, Void, AccountSet, ContactsPreferencesActivity> { |
| public QueryGroupsTask(ContactsPreferencesActivity target) { |
| super(target); |
| } |
| |
| @Override |
| protected AccountSet doInBackground(ContactsPreferencesActivity target, |
| Void... params) { |
| final Context context = target; |
| final Sources sources = Sources.getInstance(context); |
| final ContentResolver resolver = context.getContentResolver(); |
| |
| // Inflate groups entry for each account |
| final AccountSet accounts = new AccountSet(); |
| for (Account account : sources.getAccounts(false)) { |
| accounts.add(new AccountDisplay(resolver, account.name, account.type)); |
| } |
| |
| return accounts; |
| } |
| |
| @Override |
| protected void onPostExecute(ContactsPreferencesActivity target, AccountSet result) { |
| target.mAdapter.setAccounts(result); |
| } |
| } |
| |
| private static final int DEFAULT_SHOULD_SYNC = 1; |
| private static final int DEFAULT_VISIBLE = 0; |
| |
| /** |
| * Entry holding any changes to {@link Groups} or {@link Settings} rows, |
| * such as {@link Groups#SHOULD_SYNC} or {@link Groups#GROUP_VISIBLE}. |
| */ |
| protected static class GroupDelta extends ValuesDelta { |
| private boolean mUngrouped = false; |
| private boolean mAccountHasGroups; |
| |
| private GroupDelta() { |
| super(); |
| } |
| |
| /** |
| * Build {@link GroupDelta} from the {@link Settings} row for the given |
| * {@link Settings#ACCOUNT_NAME} and {@link Settings#ACCOUNT_TYPE}. |
| */ |
| public static GroupDelta fromSettings(ContentResolver resolver, String accountName, |
| String accountType, boolean accountHasGroups) { |
| final Uri settingsUri = Settings.CONTENT_URI.buildUpon() |
| .appendQueryParameter(Settings.ACCOUNT_NAME, accountName) |
| .appendQueryParameter(Settings.ACCOUNT_TYPE, accountType).build(); |
| final Cursor cursor = resolver.query(settingsUri, new String[] { |
| Settings.SHOULD_SYNC, Settings.UNGROUPED_VISIBLE |
| }, null, null, null); |
| |
| try { |
| final ContentValues values = new ContentValues(); |
| values.put(Settings.ACCOUNT_NAME, accountName); |
| values.put(Settings.ACCOUNT_TYPE, accountType); |
| |
| if (cursor != null && cursor.moveToFirst()) { |
| // Read existing values when present |
| values.put(Settings.SHOULD_SYNC, cursor.getInt(0)); |
| values.put(Settings.UNGROUPED_VISIBLE, cursor.getInt(1)); |
| return fromBefore(values).setUngrouped(accountHasGroups); |
| } else { |
| // Nothing found, so treat as create |
| values.put(Settings.SHOULD_SYNC, DEFAULT_SHOULD_SYNC); |
| values.put(Settings.UNGROUPED_VISIBLE, DEFAULT_VISIBLE); |
| return fromAfter(values).setUngrouped(accountHasGroups); |
| } |
| } finally { |
| if (cursor != null) cursor.close(); |
| } |
| } |
| |
| public static GroupDelta fromBefore(ContentValues before) { |
| final GroupDelta entry = new GroupDelta(); |
| entry.mBefore = before; |
| entry.mAfter = new ContentValues(); |
| return entry; |
| } |
| |
| public static GroupDelta fromAfter(ContentValues after) { |
| final GroupDelta entry = new GroupDelta(); |
| entry.mBefore = null; |
| entry.mAfter = after; |
| return entry; |
| } |
| |
| protected GroupDelta setUngrouped(boolean accountHasGroups) { |
| mUngrouped = true; |
| mAccountHasGroups = accountHasGroups; |
| return this; |
| } |
| |
| @Override |
| public boolean beforeExists() { |
| return mBefore != null; |
| } |
| |
| public boolean getShouldSync() { |
| return getAsInteger(mUngrouped ? Settings.SHOULD_SYNC : Groups.SHOULD_SYNC, |
| DEFAULT_SHOULD_SYNC) != 0; |
| } |
| |
| public boolean getVisible() { |
| return getAsInteger(mUngrouped ? Settings.UNGROUPED_VISIBLE : Groups.GROUP_VISIBLE, |
| DEFAULT_VISIBLE) != 0; |
| } |
| |
| public void putShouldSync(boolean shouldSync) { |
| put(mUngrouped ? Settings.SHOULD_SYNC : Groups.SHOULD_SYNC, shouldSync ? 1 : 0); |
| } |
| |
| public void putVisible(boolean visible) { |
| put(mUngrouped ? Settings.UNGROUPED_VISIBLE : Groups.GROUP_VISIBLE, visible ? 1 : 0); |
| } |
| |
| public CharSequence getTitle(Context context) { |
| if (mUngrouped) { |
| if (mAccountHasGroups) { |
| return context.getText(R.string.display_ungrouped); |
| } else { |
| return context.getText(R.string.display_all_contacts); |
| } |
| } else { |
| final Integer titleRes = getAsInteger(Groups.TITLE_RES); |
| if (titleRes != null) { |
| final String packageName = getAsString(Groups.RES_PACKAGE); |
| return context.getPackageManager().getText(packageName, titleRes, null); |
| } else { |
| return getAsString(Groups.TITLE); |
| } |
| } |
| } |
| |
| /** |
| * Build a possible {@link ContentProviderOperation} to persist any |
| * changes to the {@link Groups} or {@link Settings} row described by |
| * this {@link GroupDelta}. |
| */ |
| public ContentProviderOperation buildDiff() { |
| if (isNoop()) { |
| return null; |
| } else if (isUpdate()) { |
| // When has changes and "before" exists, then "update" |
| final Builder builder = ContentProviderOperation |
| .newUpdate(mUngrouped ? Settings.CONTENT_URI : addCallerIsSyncAdapterParameter(Groups.CONTENT_URI)); |
| if (mUngrouped) { |
| builder.withSelection(Settings.ACCOUNT_NAME + "=? AND " + Settings.ACCOUNT_TYPE |
| + "=?", new String[] { |
| this.getAsString(Settings.ACCOUNT_NAME), |
| this.getAsString(Settings.ACCOUNT_TYPE) |
| }); |
| } else { |
| builder.withSelection(Groups._ID + "=" + this.getId(), null); |
| } |
| builder.withValues(mAfter); |
| return builder.build(); |
| } else if (isInsert() && mUngrouped) { |
| // Only allow inserts for Settings |
| mAfter.remove(mIdColumn); |
| final Builder builder = ContentProviderOperation.newInsert(Settings.CONTENT_URI); |
| builder.withValues(mAfter); |
| return builder.build(); |
| } else { |
| throw new IllegalStateException("Unexpected delete or insert"); |
| } |
| } |
| } |
| |
| private static Uri addCallerIsSyncAdapterParameter(Uri uri) { |
| return uri.buildUpon() |
| .appendQueryParameter(ContactsContract.CALLER_IS_SYNCADAPTER, "true") |
| .build(); |
| } |
| |
| /** |
| * {@link Comparator} to sort by {@link Groups#_ID}. |
| */ |
| private static Comparator<GroupDelta> sIdComparator = new Comparator<GroupDelta>() { |
| public int compare(GroupDelta object1, GroupDelta object2) { |
| final Long id1 = object1.getId(); |
| final Long id2 = object2.getId(); |
| if (id1 == null && id2 == null) { |
| return 0; |
| } else if (id1 == null) { |
| return -1; |
| } else if (id2 == null) { |
| return 1; |
| } else if (id1 < id2) { |
| return -1; |
| } else if (id1 > id2) { |
| return 1; |
| } else { |
| return 0; |
| } |
| } |
| }; |
| |
| /** |
| * Set of all {@link AccountDisplay} entries, one for each source. |
| */ |
| protected static class AccountSet extends ArrayList<AccountDisplay> { |
| public ArrayList<ContentProviderOperation> buildDiff() { |
| final ArrayList<ContentProviderOperation> diff = Lists.newArrayList(); |
| for (AccountDisplay account : this) { |
| account.buildDiff(diff); |
| } |
| return diff; |
| } |
| } |
| |
| /** |
| * {@link GroupDelta} details for a single {@link Account}, usually shown as |
| * children under a single expandable group. |
| */ |
| protected static class AccountDisplay { |
| public String mName; |
| public String mType; |
| |
| public GroupDelta mUngrouped; |
| public ArrayList<GroupDelta> mSyncedGroups = Lists.newArrayList(); |
| public ArrayList<GroupDelta> mUnsyncedGroups = Lists.newArrayList(); |
| |
| /** |
| * Build an {@link AccountDisplay} covering all {@link Groups} under the |
| * given {@link Account}. |
| */ |
| public AccountDisplay(ContentResolver resolver, String accountName, String accountType) { |
| mName = accountName; |
| mType = accountType; |
| |
| final Uri groupsUri = Groups.CONTENT_URI.buildUpon() |
| .appendQueryParameter(Groups.ACCOUNT_NAME, accountName) |
| .appendQueryParameter(Groups.ACCOUNT_TYPE, accountType).build(); |
| EntityIterator iterator = ContactsContract.Groups.newEntityIterator(resolver.query( |
| groupsUri, null, null, null, null)); |
| try { |
| boolean hasGroups = false; |
| |
| // Create entries for each known group |
| while (iterator.hasNext()) { |
| final ContentValues values = iterator.next().getEntityValues(); |
| final GroupDelta group = GroupDelta.fromBefore(values); |
| addGroup(group); |
| hasGroups = true; |
| } |
| // Create single entry handling ungrouped status |
| mUngrouped = GroupDelta.fromSettings(resolver, accountName, accountType, hasGroups); |
| addGroup(mUngrouped); |
| } finally { |
| iterator.close(); |
| } |
| } |
| |
| /** |
| * Add the given {@link GroupDelta} internally, filing based on its |
| * {@link GroupDelta#getShouldSync()} status. |
| */ |
| private void addGroup(GroupDelta group) { |
| if (group.getShouldSync()) { |
| mSyncedGroups.add(group); |
| } else { |
| mUnsyncedGroups.add(group); |
| } |
| } |
| |
| /** |
| * Set the {@link GroupDelta#putShouldSync(boolean)} value for all |
| * children {@link GroupDelta} rows. |
| */ |
| public void setShouldSync(boolean shouldSync) { |
| final Iterator<GroupDelta> oppositeChildren = shouldSync ? |
| mUnsyncedGroups.iterator() : mSyncedGroups.iterator(); |
| while (oppositeChildren.hasNext()) { |
| final GroupDelta child = oppositeChildren.next(); |
| setShouldSync(child, shouldSync, false); |
| oppositeChildren.remove(); |
| } |
| } |
| |
| public void setShouldSync(GroupDelta child, boolean shouldSync) { |
| setShouldSync(child, shouldSync, true); |
| } |
| |
| /** |
| * Set {@link GroupDelta#putShouldSync(boolean)}, and file internally |
| * based on updated state. |
| */ |
| public void setShouldSync(GroupDelta child, boolean shouldSync, boolean attemptRemove) { |
| child.putShouldSync(shouldSync); |
| if (shouldSync) { |
| if (attemptRemove) { |
| mUnsyncedGroups.remove(child); |
| } |
| mSyncedGroups.add(child); |
| Collections.sort(mSyncedGroups, sIdComparator); |
| } else { |
| if (attemptRemove) { |
| mSyncedGroups.remove(child); |
| } |
| mUnsyncedGroups.add(child); |
| } |
| } |
| |
| /** |
| * Build set of {@link ContentProviderOperation} to persist any user |
| * changes to {@link GroupDelta} rows under this {@link Account}. |
| */ |
| public void buildDiff(ArrayList<ContentProviderOperation> diff) { |
| for (GroupDelta group : mSyncedGroups) { |
| final ContentProviderOperation oper = group.buildDiff(); |
| if (oper != null) diff.add(oper); |
| } |
| for (GroupDelta group : mUnsyncedGroups) { |
| final ContentProviderOperation oper = group.buildDiff(); |
| if (oper != null) diff.add(oper); |
| } |
| } |
| } |
| |
| /** |
| * {@link ExpandableListAdapter} that shows {@link GroupDelta} settings, |
| * grouped by {@link Account} source. Shows footer row when any groups are |
| * unsynced, as determined through {@link AccountDisplay#mUnsyncedGroups}. |
| */ |
| protected static class DisplayAdapter extends BaseExpandableListAdapter { |
| private Context mContext; |
| private LayoutInflater mInflater; |
| private Sources mSources; |
| private AccountSet mAccounts; |
| |
| private boolean mChildWithPhones = false; |
| |
| public DisplayAdapter(Context context) { |
| mContext = context; |
| mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
| mSources = Sources.getInstance(context); |
| } |
| |
| public void setAccounts(AccountSet accounts) { |
| mAccounts = accounts; |
| notifyDataSetChanged(); |
| } |
| |
| /** |
| * In group descriptions, show the number of contacts with phone |
| * numbers, in addition to the total contacts. |
| */ |
| public void setChildDescripWithPhones(boolean withPhones) { |
| mChildWithPhones = withPhones; |
| } |
| |
| /** {@inheritDoc} */ |
| public View getChildView(int groupPosition, int childPosition, boolean isLastChild, |
| View convertView, ViewGroup parent) { |
| if (convertView == null) { |
| convertView = mInflater.inflate(R.layout.display_child, parent, false); |
| } |
| |
| final TextView text1 = (TextView)convertView.findViewById(android.R.id.text1); |
| final TextView text2 = (TextView)convertView.findViewById(android.R.id.text2); |
| final CheckBox checkbox = (CheckBox)convertView.findViewById(android.R.id.checkbox); |
| |
| final AccountDisplay account = mAccounts.get(groupPosition); |
| final GroupDelta child = (GroupDelta)this.getChild(groupPosition, childPosition); |
| if (child != null) { |
| // Handle normal group, with title and checkbox |
| final boolean groupVisible = child.getVisible(); |
| checkbox.setVisibility(View.VISIBLE); |
| checkbox.setChecked(groupVisible); |
| |
| final CharSequence groupTitle = child.getTitle(mContext); |
| text1.setText(groupTitle); |
| |
| // final int count = cursor.getInt(GroupsQuery.SUMMARY_COUNT); |
| // final int withPhones = cursor.getInt(GroupsQuery.SUMMARY_WITH_PHONES); |
| |
| // final CharSequence descrip = mContext.getResources().getQuantityString( |
| // mChildWithPhones ? R.plurals.groupDescripPhones : R.plurals.groupDescrip, |
| // count, count, withPhones); |
| |
| // text2.setText(descrip); |
| text2.setVisibility(View.GONE); |
| } else { |
| // When unknown child, this is "more" footer view |
| checkbox.setVisibility(View.GONE); |
| text1.setText(R.string.display_more_groups); |
| text2.setVisibility(View.GONE); |
| } |
| |
| return convertView; |
| } |
| |
| /** {@inheritDoc} */ |
| public View getGroupView(int groupPosition, boolean isExpanded, View convertView, |
| ViewGroup parent) { |
| if (convertView == null) { |
| convertView = mInflater.inflate(R.layout.display_group, parent, false); |
| } |
| |
| final TextView text1 = (TextView)convertView.findViewById(android.R.id.text1); |
| final TextView text2 = (TextView)convertView.findViewById(android.R.id.text2); |
| |
| final AccountDisplay account = (AccountDisplay)this.getGroup(groupPosition); |
| |
| final ContactsSource source = mSources.getInflatedSource(account.mType, |
| ContactsSource.LEVEL_SUMMARY); |
| |
| text1.setText(account.mName); |
| text2.setText(source.getDisplayLabel(mContext)); |
| text2.setVisibility(account.mName == null ? View.GONE : View.VISIBLE); |
| |
| return convertView; |
| } |
| |
| /** {@inheritDoc} */ |
| public Object getChild(int groupPosition, int childPosition) { |
| final AccountDisplay account = mAccounts.get(groupPosition); |
| final boolean validChild = childPosition >= 0 |
| && childPosition < account.mSyncedGroups.size(); |
| if (validChild) { |
| return account.mSyncedGroups.get(childPosition); |
| } else { |
| return null; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| public long getChildId(int groupPosition, int childPosition) { |
| final GroupDelta child = (GroupDelta)getChild(groupPosition, childPosition); |
| if (child != null) { |
| final Long childId = child.getId(); |
| return childId != null ? childId : Long.MIN_VALUE; |
| } else { |
| return Long.MIN_VALUE; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| public int getChildrenCount(int groupPosition) { |
| // Count is any synced groups, plus possible footer |
| final AccountDisplay account = mAccounts.get(groupPosition); |
| final boolean anyHidden = account.mUnsyncedGroups.size() > 0; |
| return account.mSyncedGroups.size() + (anyHidden ? 1 : 0); |
| } |
| |
| /** {@inheritDoc} */ |
| public Object getGroup(int groupPosition) { |
| return mAccounts.get(groupPosition); |
| } |
| |
| /** {@inheritDoc} */ |
| public int getGroupCount() { |
| if (mAccounts == null) { |
| return 0; |
| } |
| return mAccounts.size(); |
| } |
| |
| /** {@inheritDoc} */ |
| public long getGroupId(int groupPosition) { |
| return groupPosition; |
| } |
| |
| /** {@inheritDoc} */ |
| public boolean hasStableIds() { |
| return true; |
| } |
| |
| /** {@inheritDoc} */ |
| public boolean isChildSelectable(int groupPosition, int childPosition) { |
| return true; |
| } |
| } |
| |
| /** |
| * Handle any clicks on header views added to our {@link #mAdapter}, which |
| * are usually the global modifier checkboxes. |
| */ |
| public void onItemClick(AdapterView<?> parent, View view, int position, long id) { |
| Log.d(TAG, "OnItemClick, position=" + position + ", id=" + id); |
| if (view == mHeaderPhones) { |
| mDisplayPhones.toggle(); |
| return; |
| } |
| if (view == mDisplayOrderView) { |
| Log.d(TAG, "Showing Display Order dialog"); |
| showDialog(DIALOG_DISPLAY_ORDER); |
| return; |
| } |
| if (view == mSortOrderView) { |
| Log.d(TAG, "Showing Sort Order dialog"); |
| showDialog(DIALOG_SORT_ORDER); |
| return; |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| public void onClick(View view) { |
| switch (view.getId()) { |
| case R.id.btn_done: { |
| this.doSaveAction(); |
| break; |
| } |
| case R.id.btn_discard: { |
| this.finish(); |
| break; |
| } |
| } |
| } |
| |
| /** |
| * Assign a specific value to {@link Prefs#DISPLAY_ONLY_PHONES}, refreshing |
| * the visible list as needed. |
| */ |
| protected void setDisplayOnlyPhones(boolean displayOnlyPhones) { |
| mDisplayPhones.setChecked(displayOnlyPhones); |
| |
| Editor editor = mPrefs.edit(); |
| editor.putBoolean(Prefs.DISPLAY_ONLY_PHONES, displayOnlyPhones); |
| editor.apply(); |
| |
| mAdapter.setChildDescripWithPhones(displayOnlyPhones); |
| mAdapter.notifyDataSetChanged(); |
| } |
| |
| /** |
| * Handle any clicks on {@link ExpandableListAdapter} children, which |
| * usually mean toggling its visible state. |
| */ |
| @Override |
| public boolean onChildClick(ExpandableListView parent, View view, int groupPosition, |
| int childPosition, long id) { |
| final CheckBox checkbox = (CheckBox)view.findViewById(android.R.id.checkbox); |
| |
| final AccountDisplay account = (AccountDisplay)mAdapter.getGroup(groupPosition); |
| final GroupDelta child = (GroupDelta)mAdapter.getChild(groupPosition, childPosition); |
| if (child != null) { |
| checkbox.toggle(); |
| child.putVisible(checkbox.isChecked()); |
| } else { |
| // Open context menu for bringing back unsynced |
| this.openContextMenu(view); |
| } |
| return true; |
| } |
| |
| // TODO: move these definitions to framework constants when we begin |
| // defining this mode through <sync-adapter> tags |
| private static final int SYNC_MODE_UNSUPPORTED = 0; |
| private static final int SYNC_MODE_UNGROUPED = 1; |
| private static final int SYNC_MODE_EVERYTHING = 2; |
| |
| protected int getSyncMode(AccountDisplay account) { |
| // TODO: read sync mode through <sync-adapter> definition |
| if (GoogleSource.ACCOUNT_TYPE.equals(account.mType)) { |
| return SYNC_MODE_EVERYTHING; |
| } else { |
| return SYNC_MODE_UNSUPPORTED; |
| } |
| } |
| |
| @Override |
| public void onCreateContextMenu(ContextMenu menu, View view, |
| ContextMenu.ContextMenuInfo menuInfo) { |
| super.onCreateContextMenu(menu, view, menuInfo); |
| |
| // Bail if not working with expandable long-press, or if not child |
| if (!(menuInfo instanceof ExpandableListContextMenuInfo)) return; |
| |
| final ExpandableListContextMenuInfo info = (ExpandableListContextMenuInfo) menuInfo; |
| final int groupPosition = ExpandableListView.getPackedPositionGroup(info.packedPosition); |
| final int childPosition = ExpandableListView.getPackedPositionChild(info.packedPosition); |
| |
| // Skip long-press on expandable parents |
| if (childPosition == -1) return; |
| |
| final AccountDisplay account = (AccountDisplay)mAdapter.getGroup(groupPosition); |
| final GroupDelta child = (GroupDelta)mAdapter.getChild(groupPosition, childPosition); |
| |
| // Ignore when selective syncing unsupported |
| final int syncMode = getSyncMode(account); |
| if (syncMode == SYNC_MODE_UNSUPPORTED) return; |
| |
| if (child != null) { |
| showRemoveSync(menu, account, child, syncMode); |
| } else { |
| showAddSync(menu, account, syncMode); |
| } |
| } |
| |
| protected void showRemoveSync(ContextMenu menu, final AccountDisplay account, |
| final GroupDelta child, final int syncMode) { |
| final CharSequence title = child.getTitle(this); |
| |
| menu.setHeaderTitle(title); |
| menu.add(R.string.menu_sync_remove).setOnMenuItemClickListener( |
| new OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| handleRemoveSync(account, child, syncMode, title); |
| return true; |
| } |
| }); |
| } |
| |
| protected void handleRemoveSync(final AccountDisplay account, final GroupDelta child, |
| final int syncMode, CharSequence title) { |
| final boolean shouldSyncUngrouped = account.mUngrouped.getShouldSync(); |
| if (syncMode == SYNC_MODE_EVERYTHING && shouldSyncUngrouped |
| && !child.equals(account.mUngrouped)) { |
| // Warn before removing this group when it would cause ungrouped to stop syncing |
| final AlertDialog.Builder builder = new AlertDialog.Builder(this); |
| final CharSequence removeMessage = this.getString( |
| R.string.display_warn_remove_ungrouped, title); |
| builder.setTitle(R.string.menu_sync_remove); |
| builder.setMessage(removeMessage); |
| builder.setNegativeButton(android.R.string.cancel, null); |
| builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() { |
| public void onClick(DialogInterface dialog, int which) { |
| // Mark both this group and ungrouped to stop syncing |
| account.setShouldSync(account.mUngrouped, false); |
| account.setShouldSync(child, false); |
| mAdapter.notifyDataSetChanged(); |
| } |
| }); |
| builder.show(); |
| } else { |
| // Mark this group to not sync |
| account.setShouldSync(child, false); |
| mAdapter.notifyDataSetChanged(); |
| } |
| } |
| |
| protected void showAddSync(ContextMenu menu, final AccountDisplay account, final int syncMode) { |
| menu.setHeaderTitle(R.string.dialog_sync_add); |
| |
| // Create item for each available, unsynced group |
| for (final GroupDelta child : account.mUnsyncedGroups) { |
| if (!child.getShouldSync()) { |
| final CharSequence title = child.getTitle(this); |
| menu.add(title).setOnMenuItemClickListener(new OnMenuItemClickListener() { |
| public boolean onMenuItemClick(MenuItem item) { |
| // Adding specific group for syncing |
| if (child.mUngrouped && syncMode == SYNC_MODE_EVERYTHING) { |
| account.setShouldSync(true); |
| } else { |
| account.setShouldSync(child, true); |
| } |
| mAdapter.notifyDataSetChanged(); |
| return true; |
| } |
| }); |
| } |
| } |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| public void onBackPressed() { |
| doSaveAction(); |
| } |
| |
| private void doSaveAction() { |
| mContactsPrefs.setSortOrder(mSortOrder); |
| mContactsPrefs.setDisplayOrder(mDisplayOrder); |
| |
| if (mAdapter == null || mAdapter.mAccounts == null) { |
| return; |
| } |
| setDisplayOnlyPhones(mDisplayPhones.isChecked()); |
| new UpdateTask(this).execute(mAdapter.mAccounts); |
| } |
| |
| /** |
| * Background task that persists changes to {@link Groups#GROUP_VISIBLE}, |
| * showing spinner dialog to user while updating. |
| */ |
| public static class UpdateTask extends |
| WeakAsyncTask<AccountSet, Void, Void, Activity> { |
| private WeakReference<ProgressDialog> mProgress; |
| |
| public UpdateTask(Activity target) { |
| super(target); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| protected void onPreExecute(Activity target) { |
| final Context context = target; |
| |
| mProgress = new WeakReference<ProgressDialog>(ProgressDialog.show(context, null, |
| context.getText(R.string.savingDisplayGroups))); |
| |
| // Before starting this task, start an empty service to protect our |
| // process from being reclaimed by the system. |
| context.startService(new Intent(context, EmptyService.class)); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| protected Void doInBackground(Activity target, AccountSet... params) { |
| final Context context = target; |
| final ContentValues values = new ContentValues(); |
| final ContentResolver resolver = context.getContentResolver(); |
| |
| try { |
| // Build changes and persist in transaction |
| final AccountSet set = params[0]; |
| final ArrayList<ContentProviderOperation> diff = set.buildDiff(); |
| resolver.applyBatch(ContactsContract.AUTHORITY, diff); |
| } catch (RemoteException e) { |
| Log.e(TAG, "Problem saving display groups", e); |
| } catch (OperationApplicationException e) { |
| Log.e(TAG, "Problem saving display groups", e); |
| } |
| |
| return null; |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| protected void onPostExecute(Activity target, Void result) { |
| final Context context = target; |
| |
| final ProgressDialog dialog = mProgress.get(); |
| if (dialog != null) { |
| try { |
| dialog.dismiss(); |
| } catch (Exception e) { |
| Log.e(TAG, "Error dismissing progress dialog", e); |
| } |
| } |
| |
| target.finish(); |
| |
| // Stop the service that was protecting us |
| context.stopService(new Intent(context, EmptyService.class)); |
| } |
| } |
| |
| @Override |
| public void startSearch(String initialQuery, boolean selectInitialQuery, Bundle appSearchData, |
| boolean globalSearch) { |
| if (globalSearch) { |
| super.startSearch(initialQuery, selectInitialQuery, appSearchData, globalSearch); |
| } else { |
| ContactsSearchManager.startSearch(this, initialQuery); |
| } |
| } |
| } |
