| /* |
| * 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.list; |
| |
| import com.android.contacts.ContactsActivity; |
| import com.android.contacts.R; |
| import com.android.contacts.model.AccountType; |
| import com.android.contacts.model.AccountTypeManager; |
| import com.android.contacts.model.AccountWithDataSet; |
| import com.android.contacts.model.EntityDelta.ValuesDelta; |
| import com.android.contacts.model.GoogleAccountType; |
| import com.android.contacts.util.EmptyService; |
| import com.android.contacts.util.LocalizedNameResolver; |
| import com.android.contacts.util.WeakAsyncTask; |
| import com.google.android.collect.Lists; |
| |
| import android.app.ActionBar; |
| import android.app.Activity; |
| import android.app.AlertDialog; |
| import android.app.LoaderManager.LoaderCallbacks; |
| import android.app.ProgressDialog; |
| import android.content.AsyncTaskLoader; |
| 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.Loader; |
| import android.content.OperationApplicationException; |
| import android.content.SharedPreferences; |
| 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.MenuItem.OnMenuItemClickListener; |
| import android.view.View; |
| import android.view.ViewGroup; |
| import android.widget.BaseExpandableListAdapter; |
| import android.widget.CheckBox; |
| import android.widget.ExpandableListAdapter; |
| import android.widget.ExpandableListView; |
| import android.widget.ExpandableListView.ExpandableListContextMenuInfo; |
| import android.widget.TextView; |
| |
| 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 class CustomContactListFilterActivity extends ContactsActivity |
| implements View.OnClickListener, ExpandableListView.OnChildClickListener, |
| LoaderCallbacks<CustomContactListFilterActivity.AccountSet> |
| { |
| private static final String TAG = "CustomContactListFilterActivity"; |
| |
| private static final int ACCOUNT_SET_LOADER_ID = 1; |
| |
| private ExpandableListView mList; |
| private DisplayAdapter mAdapter; |
| |
| private SharedPreferences mPrefs; |
| |
| @Override |
| protected void onCreate(Bundle icicle) { |
| super.onCreate(icicle); |
| setContentView(R.layout.contact_list_filter_custom); |
| |
| mList = (ExpandableListView) findViewById(com.android.internal.R.id.list); |
| mList.setOnChildClickListener(this); |
| mList.setHeaderDividersEnabled(true); |
| mPrefs = PreferenceManager.getDefaultSharedPreferences(this); |
| mAdapter = new DisplayAdapter(this); |
| |
| final LayoutInflater inflater = getLayoutInflater(); |
| |
| findViewById(R.id.btn_done).setOnClickListener(this); |
| findViewById(R.id.btn_discard).setOnClickListener(this); |
| |
| mList.setOnCreateContextMenuListener(this); |
| |
| mList.setAdapter(mAdapter); |
| |
| ActionBar actionBar = getActionBar(); |
| if (actionBar != null) { |
| // android.R.id.home will be triggered in onOptionsItemSelected() |
| actionBar.setDisplayHomeAsUpEnabled(true); |
| } |
| } |
| |
| public static class CustomFilterConfigurationLoader extends AsyncTaskLoader<AccountSet> { |
| |
| private AccountSet mAccountSet; |
| |
| public CustomFilterConfigurationLoader(Context context) { |
| super(context); |
| } |
| |
| @Override |
| public AccountSet loadInBackground() { |
| Context context = getContext(); |
| final AccountTypeManager accountTypes = AccountTypeManager.getInstance(context); |
| final ContentResolver resolver = context.getContentResolver(); |
| |
| final AccountSet accounts = new AccountSet(); |
| for (AccountWithDataSet account : accountTypes.getAccounts(false)) { |
| final AccountType accountType = accountTypes.getAccountTypeForAccount(account); |
| if (accountType.isExtension() && !account.hasData(context)) { |
| // Extension with no data -- skip. |
| continue; |
| } |
| |
| AccountDisplay accountDisplay = |
| new AccountDisplay(resolver, account.name, account.type, account.dataSet); |
| |
| final Uri.Builder groupsUri = Groups.CONTENT_URI.buildUpon() |
| .appendQueryParameter(Groups.ACCOUNT_NAME, account.name) |
| .appendQueryParameter(Groups.ACCOUNT_TYPE, account.type); |
| if (account.dataSet != null) { |
| groupsUri.appendQueryParameter(Groups.DATA_SET, account.dataSet).build(); |
| } |
| EntityIterator iterator = ContactsContract.Groups.newEntityIterator(resolver.query( |
| groupsUri.build(), 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); |
| accountDisplay.addGroup(group); |
| hasGroups = true; |
| } |
| // Create single entry handling ungrouped status |
| accountDisplay.mUngrouped = |
| GroupDelta.fromSettings(resolver, account.name, account.type, |
| account.dataSet, hasGroups); |
| accountDisplay.addGroup(accountDisplay.mUngrouped); |
| } finally { |
| iterator.close(); |
| } |
| |
| accounts.add(accountDisplay); |
| } |
| |
| return accounts; |
| } |
| |
| @Override |
| public void deliverResult(AccountSet cursor) { |
| if (isReset()) { |
| return; |
| } |
| |
| mAccountSet = cursor; |
| |
| if (isStarted()) { |
| super.deliverResult(cursor); |
| } |
| } |
| |
| @Override |
| protected void onStartLoading() { |
| if (mAccountSet != null) { |
| deliverResult(mAccountSet); |
| } |
| if (takeContentChanged() || mAccountSet == null) { |
| forceLoad(); |
| } |
| } |
| |
| @Override |
| protected void onStopLoading() { |
| cancelLoad(); |
| } |
| |
| @Override |
| protected void onReset() { |
| super.onReset(); |
| onStopLoading(); |
| mAccountSet = null; |
| } |
| } |
| |
| @Override |
| protected void onStart() { |
| getLoaderManager().initLoader(ACCOUNT_SET_LOADER_ID, null, this); |
| super.onStart(); |
| } |
| |
| @Override |
| public Loader<AccountSet> onCreateLoader(int id, Bundle args) { |
| return new CustomFilterConfigurationLoader(this); |
| } |
| |
| @Override |
| public void onLoadFinished(Loader<AccountSet> loader, AccountSet data) { |
| mAdapter.setAccounts(data); |
| } |
| |
| @Override |
| public void onLoaderReset(Loader<AccountSet> loader) { |
| mAdapter.setAccounts(null); |
| } |
| |
| 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}, {@link Settings#ACCOUNT_TYPE}, and |
| * {@link Settings#DATA_SET}. |
| */ |
| public static GroupDelta fromSettings(ContentResolver resolver, String accountName, |
| String accountType, String dataSet, boolean accountHasGroups) { |
| final Uri.Builder settingsUri = Settings.CONTENT_URI.buildUpon() |
| .appendQueryParameter(Settings.ACCOUNT_NAME, accountName) |
| .appendQueryParameter(Settings.ACCOUNT_TYPE, accountType); |
| if (dataSet != null) { |
| settingsUri.appendQueryParameter(Settings.DATA_SET, dataSet); |
| } |
| final Cursor cursor = resolver.query(settingsUri.build(), 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); |
| values.put(Settings.DATA_SET, dataSet); |
| |
| 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); |
| } |
| |
| private String getAccountType() { |
| return (mBefore == null ? mAfter : mBefore).getAsString(Settings.ACCOUNT_TYPE); |
| } |
| |
| public CharSequence getTitle(Context context) { |
| if (mUngrouped) { |
| final String customAllContactsName = |
| LocalizedNameResolver.getAllContactsName(context, getAccountType()); |
| if (customAllContactsName != null) { |
| return customAllContactsName; |
| } |
| 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 (isInsert()) { |
| // Only allow inserts for Settings |
| if (mUngrouped) { |
| mAfter.remove(mIdColumn); |
| return ContentProviderOperation.newInsert(Settings.CONTENT_URI) |
| .withValues(mAfter) |
| .build(); |
| } |
| else { |
| throw new IllegalStateException("Unexpected diff"); |
| } |
| } else if (isUpdate()) { |
| if (mUngrouped) { |
| String accountName = this.getAsString(Settings.ACCOUNT_NAME); |
| String accountType = this.getAsString(Settings.ACCOUNT_TYPE); |
| String dataSet = this.getAsString(Settings.DATA_SET); |
| StringBuilder selection = new StringBuilder(Settings.ACCOUNT_NAME + "=? AND " |
| + Settings.ACCOUNT_TYPE + "=?"); |
| String[] selectionArgs; |
| if (dataSet == null) { |
| selection.append(" AND " + Settings.DATA_SET + " IS NULL"); |
| selectionArgs = new String[] {accountName, accountType}; |
| } else { |
| selection.append(" AND " + Settings.DATA_SET + "=?"); |
| selectionArgs = new String[] {accountName, accountType, dataSet}; |
| } |
| return ContentProviderOperation.newUpdate(Settings.CONTENT_URI) |
| .withSelection(selection.toString(), selectionArgs) |
| .withValues(mAfter) |
| .build(); |
| } else { |
| return ContentProviderOperation.newUpdate( |
| addCallerIsSyncAdapterParameter(Groups.CONTENT_URI)) |
| .withSelection(Groups._ID + "=" + this.getId(), null) |
| .withValues(mAfter) |
| .build(); |
| } |
| } else { |
| return null; |
| } |
| } |
| } |
| |
| 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 AccountWithDataSet}, usually shown as |
| * children under a single expandable group. |
| */ |
| protected static class AccountDisplay { |
| public final String mName; |
| public final String mType; |
| public final String mDataSet; |
| |
| 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 AccountWithDataSet}. |
| */ |
| public AccountDisplay(ContentResolver resolver, String accountName, String accountType, |
| String dataSet) { |
| mName = accountName; |
| mType = accountType; |
| mDataSet = dataSet; |
| } |
| |
| /** |
| * 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 AccountWithDataSet}. |
| */ |
| 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 AccountWithDataSet} type. 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 AccountTypeManager mAccountTypes; |
| private AccountSet mAccounts; |
| |
| private boolean mChildWithPhones = false; |
| |
| public DisplayAdapter(Context context) { |
| mContext = context; |
| mInflater = (LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE); |
| mAccountTypes = AccountTypeManager.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; |
| } |
| |
| @Override |
| public View getGroupView(int groupPosition, boolean isExpanded, View convertView, |
| ViewGroup parent) { |
| if (convertView == null) { |
| convertView = mInflater.inflate( |
| R.layout.custom_contact_list_filter_account, 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 AccountType accountType = mAccountTypes.getAccountType( |
| account.mType, account.mDataSet); |
| |
| text1.setText(account.mName); |
| text1.setVisibility(account.mName == null ? View.GONE : View.VISIBLE); |
| text2.setText(accountType.getDisplayLabel(mContext)); |
| |
| return convertView; |
| } |
| |
| @Override |
| public View getChildView(int groupPosition, int childPosition, boolean isLastChild, |
| View convertView, ViewGroup parent) { |
| if (convertView == null) { |
| convertView = mInflater.inflate( |
| R.layout.custom_contact_list_filter_group, 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); |
| 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; |
| } |
| |
| @Override |
| 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; |
| } |
| } |
| |
| @Override |
| 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; |
| } |
| } |
| |
| @Override |
| 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); |
| } |
| |
| @Override |
| public Object getGroup(int groupPosition) { |
| return mAccounts.get(groupPosition); |
| } |
| |
| @Override |
| public int getGroupCount() { |
| if (mAccounts == null) { |
| return 0; |
| } |
| return mAccounts.size(); |
| } |
| |
| @Override |
| public long getGroupId(int groupPosition) { |
| return groupPosition; |
| } |
| |
| @Override |
| public boolean hasStableIds() { |
| return true; |
| } |
| |
| @Override |
| public boolean isChildSelectable(int groupPosition, int childPosition) { |
| return true; |
| } |
| } |
| |
| /** {@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; |
| } |
| } |
| } |
| |
| /** |
| * 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 (GoogleAccountType.ACCOUNT_TYPE.equals(account.mType) && account.mDataSet == null) { |
| 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; |
| } |
| }); |
| } |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| private void doSaveAction() { |
| if (mAdapter == null || mAdapter.mAccounts == null) { |
| finish(); |
| return; |
| } |
| |
| setResult(RESULT_OK); |
| |
| final ArrayList<ContentProviderOperation> diff = mAdapter.mAccounts.buildDiff(); |
| if (diff.isEmpty()) { |
| finish(); |
| return; |
| } |
| |
| new UpdateTask(this).execute(diff); |
| } |
| |
| /** |
| * Background task that persists changes to {@link Groups#GROUP_VISIBLE}, |
| * showing spinner dialog to user while updating. |
| */ |
| public static class UpdateTask extends |
| WeakAsyncTask<ArrayList<ContentProviderOperation>, Void, Void, Activity> { |
| private ProgressDialog mProgress; |
| |
| public UpdateTask(Activity target) { |
| super(target); |
| } |
| |
| /** {@inheritDoc} */ |
| @Override |
| protected void onPreExecute(Activity target) { |
| final Context context = target; |
| |
| mProgress = 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, ArrayList<ContentProviderOperation>... params) { |
| final Context context = target; |
| final ContentValues values = new ContentValues(); |
| final ContentResolver resolver = context.getContentResolver(); |
| |
| try { |
| final ArrayList<ContentProviderOperation> diff = params[0]; |
| 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; |
| |
| try { |
| mProgress.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 boolean onOptionsItemSelected(MenuItem item) { |
| switch (item.getItemId()) { |
| case android.R.id.home: |
| // Pretend cancel. |
| setResult(Activity.RESULT_CANCELED); |
| finish(); |
| return true; |
| default: |
| break; |
| } |
| return super.onOptionsItemSelected(item); |
| } |
| } |
