Use PreferenceCategory instead of manual preference ordering

chrome/android/java/src/org/chromium/chrome/browser/signin/AccountManagementFragment.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.signin;
 
 import android.accounts.Account;
 import android.annotation.TargetApi;
 import android.app.Activity;
 import android.app.Dialog;
@@ skipping 10 matching lines @@
 import android.graphics.PorterDuff;
 import android.graphics.PorterDuffXfermode;
 import android.graphics.Rect;
 import android.graphics.drawable.BitmapDrawable;
 import android.graphics.drawable.Drawable;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.UserManager;
 import android.preference.Preference;
 import android.preference.Preference.OnPreferenceClickListener;
+import android.preference.PreferenceCategory;
 import android.preference.PreferenceFragment;
 import android.preference.PreferenceScreen;
 import android.support.annotation.Nullable;
 import android.text.TextUtils;
 import android.util.Pair;
 import android.widget.ListView;
 
 import org.chromium.base.ApiCompatibilityUtils;
 import org.chromium.base.ContextUtils;
 import org.chromium.base.metrics.RecordUserAction;
@@ skipping 10 matching lines @@
 import org.chromium.chrome.browser.profiles.ProfileDownloader;
 import org.chromium.chrome.browser.signin.SignOutDialogFragment.SignOutDialogListener;
 import org.chromium.chrome.browser.signin.SigninManager.SignInStateObserver;
 import org.chromium.chrome.browser.sync.ProfileSyncService;
 import org.chromium.chrome.browser.sync.ProfileSyncService.SyncStateChangedListener;
 import org.chromium.chrome.browser.sync.ui.SyncCustomizationFragment;
 import org.chromium.chrome.browser.util.IntentUtils;
 import org.chromium.components.signin.AccountManagerHelper;
 import org.chromium.components.signin.ChromeSigninController;
 
-import java.util.ArrayList;
 import java.util.HashMap;
 
 /**
  * The settings screen with information and settings related to the user's accounts.
  *
  * This shows which accounts the user is signed in with, allows the user to sign out of Chrome,
  * links to sync settings, has links to add accounts and go incognito, and shows parental settings
  * if a child account is in use.
  *
  * Note: This can be triggered from a web page, e.g. a GAIA sign-in page.
  */
 public class AccountManagementFragment extends PreferenceFragment
         implements SignOutDialogListener, ProfileDownloader.Observer,
                 SyncStateChangedListener, SignInStateObserver,
                 ConfirmManagedSyncDataDialog.Listener {
     private static final String TAG = "AcctManagementPref";
 
     public static final String SIGN_OUT_DIALOG_TAG = "sign_out_dialog_tag";
     private static final String CLEAR_DATA_PROGRESS_DIALOG_TAG = "clear_data_progress";
 
     /**
      * The key for an integer value in
      * {@link Preferences#EXTRA_SHOW_FRAGMENT_ARGUMENTS} bundle to
      * specify the correct GAIA service that has triggered the dialog.
      * If the argument is not set, GAIA_SERVICE_TYPE_NONE is used as the origin of the dialog.
      */
     public static final String SHOW_GAIA_SERVICE_TYPE_EXTRA = "ShowGAIAServiceType";
 
     /**
-     * Account name preferences will be ordered sequentially, starting with this "order" value.
-     * This ensures that the account name preferences appear in the correct location in the
-     * preference fragment. See account_management_preferences.xml for details.
-     */
-    private static final int FIRST_ACCOUNT_PREF_ORDER = 100;
-
-    /**
      * SharedPreference name for the preference that disables signing out of Chrome.
      * Signing out is forever disabled once Chrome signs the user in automatically
      * if the device has a child account or if the device is an Android EDU device.
      */
     private static final String SIGN_OUT_ALLOWED = "auto_signed_in_school_account";
 
     private static final HashMap<String, Pair<String, Bitmap>> sToNamePicture = new HashMap<>();
 
     private static String sChildAccountId;
     private static Bitmap sCachedBadgedPicture;
 
-    public static final String PREF_ADD_ACCOUNT = "add_account";
+    public static final String PREF_ACCOUNTS_CATEGORY = "accounts_category";
     public static final String PREF_PARENTAL_SETTINGS = "parental_settings";
     public static final String PREF_PARENT_ACCOUNTS = "parent_accounts";
     public static final String PREF_CHILD_CONTENT = "child_content";
     public static final String PREF_CHILD_CONTENT_DIVIDER = "child_content_divider";
     public static final String PREF_GOOGLE_ACTIVITY_CONTROLS = "google_activity_controls";
     public static final String PREF_SYNC_SETTINGS = "sync_settings";
     public static final String PREF_SIGN_OUT = "sign_out";
     public static final String PREF_SIGN_OUT_DIVIDER = "sign_out_divider";
 
     private static final String ACCOUNT_SETTINGS_ACTION = "android.settings.ACCOUNT_SYNC_SETTINGS";
     private static final String ACCOUNT_SETTINGS_ACCOUNT_KEY = "account";
 
     private int mGaiaServiceType;
 
-    private ArrayList<Preference> mAccountsListPreferences = new ArrayList<>();
-
     private Profile mProfile;
     private String mSignedInAccountName;
 
     @Override
     public void onCreate(Bundle savedState) {
         super.onCreate(savedState);
 
         // Prevent sync from starting if it hasn't already to give the user a chance to change
         // their sync settings.
         ProfileSyncService syncService = ProfileSyncService.get();
@@ skipping 90 matching lines @@
 
         String fullName = getCachedUserName(mSignedInAccountName);
         if (TextUtils.isEmpty(fullName)) {
             fullName = ProfileDownloader.getCachedFullName(mProfile);
         }
         if (TextUtils.isEmpty(fullName)) fullName = mSignedInAccountName;
 
         getActivity().setTitle(fullName);
 
         configureSignOutSwitch();
-        configureAddAccountPreference();
         configureChildAccountPreferences();
         configureSyncSettings();
         configureGoogleActivityControls();
 
         updateAccountsList();
     }
 
     @TargetApi(Build.VERSION_CODES.LOLLIPOP)
     private boolean canAddAccounts() {
         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) return true;
@@ skipping 77 matching lines @@
             public boolean onPreferenceClick(Preference preference) {
                 Activity activity = getActivity();
                 AppHooks.get().createGoogleActivityController().openWebAndAppActivitySettings(
                         activity, mSignedInAccountName);
                 RecordUserAction.record("Signin_AccountSettings_GoogleActivityControlsClicked");
                 return true;
             }
         });
     }
 
-    private void configureAddAccountPreference() {
-        ChromeBasePreference addAccount = (ChromeBasePreference) findPreference(PREF_ADD_ACCOUNT);
-
-        if (mProfile.isChild()) {
-            getPreferenceScreen().removePreference(addAccount);
-        } else {
-            addAccount.setTitle(getResources().getString(
-                    R.string.account_management_add_account_title));
-            addAccount.setOnPreferenceClickListener(new OnPreferenceClickListener() {
-                @Override
-                public boolean onPreferenceClick(Preference preference) {
-                    if (!isVisible() || !isResumed()) return false;
-
-                    AccountManagementScreenHelper.logEvent(
-                            ProfileAccountManagementMetrics.ADD_ACCOUNT,
-                            mGaiaServiceType);
-
-                    AccountAdder.getInstance().addAccount(
-                            getActivity(), AccountAdder.ADD_ACCOUNT_RESULT);
-
-                    // Return to the last opened tab if triggered from the content area.
-                    if (mGaiaServiceType != AccountManagementScreenHelper.GAIA_SERVICE_TYPE_NONE) {
-                        if (isAdded()) getActivity().finish();
-                    }
-
-                    return true;
-                }
-            });
-            addAccount.setManagedPreferenceDelegate(new ManagedPreferenceDelegate() {
-                @Override
-                public boolean isPreferenceControlledByPolicy(Preference preference) {
-                    return !canAddAccounts();
-                }
-            });
-        }
-    }
-
     private void configureChildAccountPreferences() {
         Preference parentAccounts = findPreference(PREF_PARENT_ACCOUNTS);
         Preference childContent = findPreference(PREF_CHILD_CONTENT);
         if (mProfile.isChild()) {
             Resources res = getActivity().getResources();
             PrefServiceBridge prefService = PrefServiceBridge.getInstance();
 
             String firstParent = prefService.getSupervisedUserCustodianEmail();
             String secondParent = prefService.getSupervisedUserSecondCustodianEmail();
             String parentText;
@@ skipping 32 matching lines @@
         } else {
             PreferenceScreen prefScreen = getPreferenceScreen();
             prefScreen.removePreference(findPreference(PREF_PARENTAL_SETTINGS));
             prefScreen.removePreference(parentAccounts);
             prefScreen.removePreference(childContent);
             prefScreen.removePreference(findPreference(PREF_CHILD_CONTENT_DIVIDER));
         }
     }
 
     private void updateAccountsList() {
-        PreferenceScreen prefScreen = getPreferenceScreen();
-        if (prefScreen == null) return;
+        PreferenceCategory accountsCategory =
+                (PreferenceCategory) findPreference(PREF_ACCOUNTS_CATEGORY);
+        if (accountsCategory == null) return;
 
-        for (int i = 0; i < mAccountsListPreferences.size(); i++) {
-            prefScreen.removePreference(mAccountsListPreferences.get(i));
-        }
-        mAccountsListPreferences.clear();
+        accountsCategory.removeAll();
 
+        boolean isChildAccount = mProfile.isChild();
         Account[] accounts = AccountManagerHelper.get().getGoogleAccounts();
-        int nextPrefOrder = FIRST_ACCOUNT_PREF_ORDER;
-
         for (final Account account : accounts) {
             ChromeBasePreference pref = new ChromeBasePreference(getActivity());
             pref.setTitle(account.name);
 
-            boolean isChildAccount = mProfile.isChild();
             pref.setUseReducedPadding(isChildAccount);
             pref.setIcon(new BitmapDrawable(getResources(),
                     isChildAccount ? getBadgedUserPicture(account.name, getResources()) :
                         getUserPicture(account.name, getResources())));
 
             pref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
                 @Override
                 public boolean onPreferenceClick(Preference preference) {
                     Intent intent = new Intent(ACCOUNT_SETTINGS_ACTION);
                     intent.putExtra(ACCOUNT_SETTINGS_ACCOUNT_KEY, account);
                     return IntentUtils.safeStartActivity(getActivity(), intent);
                 }
             });
 
-            pref.setOrder(nextPrefOrder++);
-            prefScreen.addPreference(pref);
-            mAccountsListPreferences.add(pref);
+            accountsCategory.addPreference(pref);
         }
+
+        if (!isChildAccount) {
+            accountsCategory.addPreference(createAddAccountPreference());
+        }
+    }
+
+    private ChromeBasePreference createAddAccountPreference() {
+        ChromeBasePreference addAccountPreference = new ChromeBasePreference(getActivity());
+        addAccountPreference.setIcon(R.drawable.add_circle_blue);
+        addAccountPreference.setTitle(R.string.account_management_add_account_title);
+        addAccountPreference.setOnPreferenceClickListener(new OnPreferenceClickListener() {
+            @Override
+            public boolean onPreferenceClick(Preference preference) {
+                if (!isVisible() || !isResumed()) return false;
+
+                AccountManagementScreenHelper.logEvent(
+                        ProfileAccountManagementMetrics.ADD_ACCOUNT, mGaiaServiceType);
+
+                AccountAdder.getInstance().addAccount(
+                        getActivity(), AccountAdder.ADD_ACCOUNT_RESULT);
+
+                // Return to the last opened tab if triggered from the content area.
+                if (mGaiaServiceType != AccountManagementScreenHelper.GAIA_SERVICE_TYPE_NONE) {
+                    if (isAdded()) getActivity().finish();
+                }
+
+                return true;
+            }
+        });
+        addAccountPreference.setManagedPreferenceDelegate(new ManagedPreferenceDelegate() {
+            @Override
+            public boolean isPreferenceControlledByPolicy(Preference preference) {
+                return !canAddAccounts();
+            }
+        });
+        return addAccountPreference;
     }
 
     // ProfileDownloader.Observer implementation:
 
     @Override
     public void onProfileDownloaded(String accountId, String fullName, String givenName,
             Bitmap bitmap) {
         updateUserNamePictureCache(accountId, fullName, bitmap);
         updateAccountsList();
     }
@@ skipping 255 matching lines @@
      *
      * @param isAllowed True if the sign out is not disabled due to a child/EDU account
      */
     public static void setSignOutAllowedPreferenceValue(boolean isAllowed) {
         ContextUtils.getAppSharedPreferences()
                 .edit()
                 .putBoolean(SIGN_OUT_ALLOWED, isAllowed)
                 .apply();
     }
 }