Merge "Move writable Google accounts up and move default account at the top" (1178a592) · Commits · e / os / android_packages_apps_Contacts

TestCommon/src/com/android/contacts/common/test/mocks/MockAccountTypeManager.java

+3 −0

Original line number	Diff line number	Diff line
		@@ -65,6 +65,9 @@ public class MockAccountTypeManager extends AccountTypeManager {
		return Arrays.asList(mAccounts);
		}

		@Override
		public void sortAccounts(AccountWithDataSet account) {}

		@Override
		public List<AccountWithDataSet> getGroupWritableAccounts() {
		return Arrays.asList(mAccounts);

src/com/android/contacts/common/model/AccountTypeManager.java

+67 −34

Original line number	Diff line number	Diff line
		@@ -115,6 +115,11 @@ public abstract class AccountTypeManager {
		// TODO: Consider splitting this into getContactWritableAccounts() and getAllAccounts()
		public abstract List<AccountWithDataSet> getAccounts(boolean contactWritableOnly);

		/**
		* Sort accounts based on default account.
		*/
		public abstract void sortAccounts(AccountWithDataSet defaultAccount);

		/**
		* Returns the list of accounts that are group writable.
		*/
		@@ -178,6 +183,54 @@ public abstract class AccountTypeManager {
		}
		}

		class AccountComparator implements Comparator<AccountWithDataSet> {
		private AccountWithDataSet mDefaultAccount;

		public AccountComparator(AccountWithDataSet defaultAccount) {
		mDefaultAccount = defaultAccount;
		}

		@Override
		public int compare(AccountWithDataSet a, AccountWithDataSet b) {
		if (Objects.equal(a.name, b.name) && Objects.equal(a.type, b.type)
		&& Objects.equal(a.dataSet, b.dataSet)) {
		return 0;
		} else if (b.name == null \|\| b.type == null) {
		return -1;
		} else if (a.name == null \|\| a.type == null) {
		return 1;
		} else if (isWritableGoogleAccount(a) && a.equals(mDefaultAccount)) {
		return -1;
		} else if (isWritableGoogleAccount(b) && b.equals(mDefaultAccount)) {
		return 1;
		} else if (isWritableGoogleAccount(a) && !isWritableGoogleAccount(b)) {
		return -1;
		} else if (isWritableGoogleAccount(b) && !isWritableGoogleAccount(a)) {
		return 1;
		} else {
		int diff = a.name.compareToIgnoreCase(b.name);
		if (diff != 0) {
		return diff;
		}
		diff = a.type.compareToIgnoreCase(b.type);
		if (diff != 0) {
		return diff;
		}

		// Accounts without data sets get sorted before those that have them.
		if (a.dataSet != null) {
		return b.dataSet == null ? 1 : a.dataSet.compareToIgnoreCase(b.dataSet);
		} else {
		return -1;
		}
		}
		}

		private static boolean isWritableGoogleAccount(AccountWithDataSet account) {
		return GoogleAccountType.ACCOUNT_TYPE.equals(account.type) && account.dataSet == null;
		}
		}

		class AccountTypeManagerImpl extends AccountTypeManager
		implements OnAccountsUpdateListener, SyncStatusObserver {

		@@ -247,37 +300,6 @@ class AccountTypeManagerImpl extends AccountTypeManager
		/* A latch that ensures that asynchronous initialization completes before data is used */
		private volatile CountDownLatch mInitializationLatch = new CountDownLatch(1);

		private static final Comparator<AccountWithDataSet> ACCOUNT_COMPARATOR =
		new Comparator<AccountWithDataSet>() {
		@Override
		public int compare(AccountWithDataSet a, AccountWithDataSet b) {
		if (Objects.equal(a.name, b.name) && Objects.equal(a.type, b.type)
		&& Objects.equal(a.dataSet, b.dataSet)) {
		return 0;
		} else if (b.name == null \|\| b.type == null) {
		return -1;
		} else if (a.name == null \|\| a.type == null) {
		return 1;
		} else {
		int diff = a.name.compareToIgnoreCase(b.name);
		if (diff != 0) {
		return diff;
		}
		diff = a.type.compareToIgnoreCase(b.type);
		if (diff != 0) {
		return diff;
		}

		// Accounts without data sets get sorted before those that have them.
		if (a.dataSet != null) {
		return b.dataSet == null ? 1 : a.dataSet.compareToIgnoreCase(b.dataSet);
		} else {
		return -1;
		}
		}
		}
		};

		/**
		* Internal constructor that only performs initial parsing.
		*/
		@@ -499,9 +521,10 @@ class AccountTypeManagerImpl extends AccountTypeManager
		}
		}

		Collections.sort(allAccounts, ACCOUNT_COMPARATOR);
		Collections.sort(contactWritableAccounts, ACCOUNT_COMPARATOR);
		Collections.sort(groupWritableAccounts, ACCOUNT_COMPARATOR);
		final AccountComparator accountComparator = new AccountComparator(null);
		Collections.sort(allAccounts, accountComparator);
		Collections.sort(contactWritableAccounts, accountComparator);
		Collections.sort(groupWritableAccounts, accountComparator);

		timings.addSplit("Loaded accounts");

		@@ -571,6 +594,16 @@ class AccountTypeManagerImpl extends AccountTypeManager
		return contactWritableOnly ? mContactWritableAccounts : mAccounts;
		}

		/**
		* Sort accounts based on default account.
		*/
		@Override
		public void sortAccounts(AccountWithDataSet defaultAccount) {
		Collections.sort(mAccounts, new AccountComparator(defaultAccount));
		Collections.sort(mContactWritableAccounts, new AccountComparator(defaultAccount));
		Collections.sort(mGroupWritableAccounts, new AccountComparator(defaultAccount));
		}

		/**
		* Return the list of all known, group writable {@link AccountWithDataSet}'s.
		*/

src/com/android/contacts/common/util/AccountFilterUtil.java

+20 −2

Original line number	Diff line number	Diff line
		@@ -20,10 +20,10 @@ import android.app.Activity;
		import android.content.AsyncTaskLoader;
		import android.content.Context;
		import android.content.Intent;
		import android.content.SharedPreferences;
		import android.graphics.drawable.Drawable;
		import android.text.TextUtils;
		import android.util.Log;
		import android.view.View;
		import android.widget.TextView;

		import com.android.contacts.common.R;
		import com.android.contacts.common.list.ContactListFilter;
		@@ -100,6 +100,7 @@ public class AccountFilterUtil {
		private static List<ContactListFilter> loadAccountFilters(Context context) {
		final ArrayList<ContactListFilter> accountFilters = Lists.newArrayList();
		final AccountTypeManager accountTypeManager = AccountTypeManager.getInstance(context);
		accountTypeManager.sortAccounts(/* defaultAccount */ getDefaultAccount(context));
		final List<AccountWithDataSet> accounts =
		accountTypeManager.getAccounts(/* contactWritableOnly */ false);
		final List<AccountWithDataSet> writableAccounts =
		@@ -132,4 +133,21 @@ public class AccountFilterUtil {
		result.addAll(accountFilters);
		return result;
		}

		private static AccountWithDataSet getDefaultAccount(Context context) {
		final SharedPreferences prefs =
		context.getSharedPreferences(context.getPackageName(), Context.MODE_PRIVATE);
		final String defaultAccountKey =
		context.getResources().getString(R.string.contact_editor_default_account_key);
		final String defaultAccountString = prefs.getString(defaultAccountKey, null);
		if (TextUtils.isEmpty(defaultAccountString)) {
		return null;
		}
		try {
		return AccountWithDataSet.unstringify(defaultAccountString);
		} catch (IllegalArgumentException exception) {
		Log.e(TAG, "Error with retrieving default account " + exception.toString(), exception);
		return null;
		}
		}
		}