Use dropdown list for admin areas in pr form.

chrome/android/java/src/org/chromium/chrome/browser/payments/AddressEditor.java

 // Copyright 2016 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.payments;
 
 import android.os.Handler;
 import android.telephony.PhoneNumberUtils;
 import android.util.Pair;
 
 import org.chromium.base.Callback;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.autofill.PersonalDataManager;
 import org.chromium.chrome.browser.autofill.PersonalDataManager.AutofillProfile;
+import org.chromium.chrome.browser.autofill.PersonalDataManager.GetSubKeysRequestDelegate;
 import org.chromium.chrome.browser.payments.ui.EditorFieldModel;
 import org.chromium.chrome.browser.payments.ui.EditorFieldModel.EditorFieldValidator;
 import org.chromium.chrome.browser.payments.ui.EditorModel;
 import org.chromium.chrome.browser.preferences.autofill.AutofillProfileBridge;
 import org.chromium.chrome.browser.preferences.autofill.AutofillProfileBridge.AddressField;
 import org.chromium.chrome.browser.preferences.autofill.AutofillProfileBridge.AddressUiComponent;
 
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
 import java.util.Set;
 
 import javax.annotation.Nullable;
 
 /**
  * An address editor. Can be used for either shipping or billing address editing.
  */
-public class AddressEditor extends EditorBase<AutofillAddress> {
+public class AddressEditor
+        extends EditorBase<AutofillAddress> implements GetSubKeysRequestDelegate {
     private final Handler mHandler = new Handler();
     private final Map<Integer, EditorFieldModel> mAddressFields = new HashMap<>();
     private final Set<CharSequence> mPhoneNumbers = new HashSet<>();
-    @Nullable private AutofillProfileBridge mAutofillProfileBridge;
-    @Nullable private EditorFieldModel mCountryField;
-    @Nullable private EditorFieldModel mPhoneField;
-    @Nullable private EditorFieldValidator mPhoneValidator;
-    @Nullable private List<AddressUiComponent> mAddressUiComponents;
+    @Nullable
+    private AutofillProfileBridge mAutofillProfileBridge;
+    @Nullable
+    private EditorFieldModel mCountryField;
+    @Nullable
+    private EditorFieldModel mPhoneField;
+    @Nullable
+    private EditorFieldValidator mPhoneValidator;
+    @Nullable
+    private List<AddressUiComponent> mAddressUiComponents;
+    private boolean mAdminAreasLoaded;
+    private boolean mOnCountryChange;
+    private Pair<String, Runnable> mEventData;
+    private AutofillProfile mProfile;
+    private EditorModel mEditor;
 
     /**
      * Adds the given phone number to the autocomplete set, if it's valid.
      *
      * @param phoneNumber The phone number to possibly add.
      */
     public void addPhoneNumberIfValid(@Nullable CharSequence phoneNumber) {
         if (getPhoneValidator().isValid(phoneNumber)) mPhoneNumbers.add(phoneNumber);
     }
 
@@ skipping 12 matching lines @@
     public void edit(
             @Nullable final AutofillAddress toEdit, final Callback<AutofillAddress> callback) {
         super.edit(toEdit, callback);
 
         if (mAutofillProfileBridge == null) mAutofillProfileBridge = new AutofillProfileBridge();
 
         // If |toEdit| is null, we're creating a new autofill profile with the country code of the
         // default locale on this device.
         boolean isNewAddress = toEdit == null;
 
-        // Ensure that |address| and |profile| are always not null.
+        // Ensure that |address| and |mProfile| are always not null.
         final AutofillAddress address =
                 isNewAddress ? new AutofillAddress(mContext, new AutofillProfile()) : toEdit;
-        final AutofillProfile profile = address.getProfile();
+        mProfile = address.getProfile();
 
         // The title of the editor depends on whether we're adding a new address or editing an
         // existing address.
-        final EditorModel editor =
-                new EditorModel(isNewAddress
-                        ? mContext.getString(R.string.autofill_create_profile)
-                        : toEdit.getEditTitle());
+        mEditor =
+                new EditorModel(isNewAddress ? mContext.getString(R.string.autofill_create_profile)
+                                             : toEdit.getEditTitle());
 
         // The country dropdown is always present on the editor.
         if (mCountryField == null) {
             mCountryField = EditorFieldModel.createDropdown(
                     mContext.getString(R.string.autofill_profile_editor_country),
-                    AutofillProfileBridge.getSupportedCountries(),
-                    null /* hint */);
+                    AutofillProfileBridge.getSupportedCountries(), null /* hint */);
         }
 
         // Changing the country will update which fields are in the model. The actual fields are not
         // discarded, so their contents are preserved.
         mCountryField.setDropdownCallback(new Callback<Pair<String, Runnable>>() {
             @Override
             public void onResult(Pair<String, Runnable> eventData) {
-                editor.removeAllFields();
-                editor.addField(mCountryField);
-                addAddressTextFieldsToEditor(editor, eventData.first,
-                        Locale.getDefault().getLanguage());
-                editor.addField(mPhoneField);
-
-                // Notify EditorView that the fields in the model have changed. EditorView should
-                // re-read the model and update the UI accordingly.
-                mHandler.post(eventData.second);
+                mEditor.removeAllFields();
+                mEventData = eventData;
+                mOnCountryChange = true;
+                loadAdminAreas();
             }
         });
 
         // Country dropdown is cached, so the selected item needs to be updated for the new profile
         // that's being edited. This will not fire the dropdown callback.
-        mCountryField.setValue(AutofillAddress.getCountryCode(profile));
-        editor.addField(mCountryField);
+        mCountryField.setValue(AutofillAddress.getCountryCode(mProfile));
 
         // There's a finite number of fields for address editing. Changing the country will re-order
         // and relabel the fields. The meaning of each field remains the same.
         if (mAddressFields.isEmpty()) {
             // City, dependent locality, and organization don't have any special formatting hints.
             mAddressFields.put(AddressField.LOCALITY, EditorFieldModel.createTextInput());
             mAddressFields.put(AddressField.DEPENDENT_LOCALITY, EditorFieldModel.createTextInput());
             mAddressFields.put(AddressField.ORGANIZATION, EditorFieldModel.createTextInput());
 
-            // State should be formatted in all capitals.
-            mAddressFields.put(AddressField.ADMIN_AREA, EditorFieldModel.createTextInput(
-                        EditorFieldModel.INPUT_TYPE_HINT_REGION));
-
             // Sorting code and postal code (a.k.a. ZIP code) should show both letters and digits on
             // the keyboard, if possible.
-            mAddressFields.put(AddressField.SORTING_CODE, EditorFieldModel.createTextInput(
-                    EditorFieldModel.INPUT_TYPE_HINT_ALPHA_NUMERIC));
-            mAddressFields.put(AddressField.POSTAL_CODE, EditorFieldModel.createTextInput(
-                    EditorFieldModel.INPUT_TYPE_HINT_ALPHA_NUMERIC));
+            mAddressFields.put(AddressField.SORTING_CODE,
+                    EditorFieldModel.createTextInput(
+                            EditorFieldModel.INPUT_TYPE_HINT_ALPHA_NUMERIC));
+            mAddressFields.put(AddressField.POSTAL_CODE,
+                    EditorFieldModel.createTextInput(
+                            EditorFieldModel.INPUT_TYPE_HINT_ALPHA_NUMERIC));
 
             // Street line field can contain \n to indicate line breaks.
-            mAddressFields.put(AddressField.STREET_ADDRESS, EditorFieldModel.createTextInput(
-                    EditorFieldModel.INPUT_TYPE_HINT_STREET_LINES));
+            mAddressFields.put(AddressField.STREET_ADDRESS,
+                    EditorFieldModel.createTextInput(
+                            EditorFieldModel.INPUT_TYPE_HINT_STREET_LINES));
 
             // Android has special formatting rules for names.
-            mAddressFields.put(AddressField.RECIPIENT, EditorFieldModel.createTextInput(
-                    EditorFieldModel.INPUT_TYPE_HINT_PERSON_NAME));
+            mAddressFields.put(AddressField.RECIPIENT,
+                    EditorFieldModel.createTextInput(EditorFieldModel.INPUT_TYPE_HINT_PERSON_NAME));
         }
 
-        // Address fields are cached, so their values need to be updated for every new profile
-        // that's being edited.
-        for (Map.Entry<Integer, EditorFieldModel> entry : mAddressFields.entrySet()) {
-            entry.getValue().setValue(AutofillAddress.getProfileField(profile, entry.getKey()));
-        }
-
-        // Both country code and language code dictate which fields should be added to the editor.
-        // For example, "US" will not add dependent locality to the editor. A "JP" address will
-        // start with a person's full name or a with a prefecture name, depending on whether the
-        // language code is "ja-Latn" or "ja".
-        addAddressTextFieldsToEditor(editor, profile.getCountryCode(), profile.getLanguageCode());
-
         // Phone number is present and required for all countries.
         if (mPhoneField == null) {
             mPhoneField = EditorFieldModel.createTextInput(EditorFieldModel.INPUT_TYPE_HINT_PHONE,
                     mContext.getString(R.string.autofill_profile_editor_phone_number),
                     mPhoneNumbers, getPhoneValidator(), null,
                     mContext.getString(R.string.payments_field_required_validation_message),
                     mContext.getString(R.string.payments_phone_invalid_validation_message), null);
         }
 
         // Phone number field is cached, so its value needs to be updated for every new profile
         // that's being edited.
-        mPhoneField.setValue(profile.getPhoneNumber());
-        editor.addField(mPhoneField);
+        mPhoneField.setValue(mProfile.getPhoneNumber());
 
         // If the user clicks [Cancel], send |toEdit| address back to the caller, which was the
         // original state (could be null, a complete address, a partial address).
-        editor.setCancelCallback(new Runnable() {
+        mEditor.setCancelCallback(new Runnable() {
             @Override
             public void run() {
+                mAdminAreasLoaded = true;
+                PersonalDataManager.getInstance().cancelPendingGetSubKeys();
                 callback.onResult(toEdit);
             }
         });
 
         // If the user clicks [Done], save changes on disk, mark the address "complete," and send it
         // back to the caller.
-        editor.setDoneCallback(new Runnable() {
+        mEditor.setDoneCallback(new Runnable() {
             @Override
             public void run() {
-                commitChanges(profile);
-                address.completeAddress(profile);
+                mAdminAreasLoaded = true;
+                PersonalDataManager.getInstance().cancelPendingGetSubKeys();
+                commitChanges(mProfile);
+                address.completeAddress(mProfile);
                 callback.onResult(address);
             }
         });
 
-        mEditorView.show(editor);
+        mOnCountryChange = false;
+        loadAdminAreas();
     }
 
     /** Saves the edited profile on disk. */
     private void commitChanges(AutofillProfile profile) {
         // Country code and phone number are always required and are always collected from the
         // editor model.
         profile.setCountryCode(mCountryField.getValue().toString());
         profile.setPhoneNumber(mPhoneField.getValue().toString());
 
         // Autofill profile bridge normalizes the language code for the autofill profile.
@@ skipping 11 matching lines @@
 
         // Clear the fields that are hidden from the user interface, so
         // AutofillAddress.toPaymentAddress() will send them to the renderer as empty strings.
         for (Map.Entry<Integer, EditorFieldModel> entry : mAddressFields.entrySet()) {
             if (!visibleFields.contains(entry.getKey())) {
                 setProfileField(profile, entry.getKey(), "");
             }
         }
 
         // Save the edited autofill profile locally.
-        profile.setGUID(PersonalDataManager.getInstance().setProfileToLocal(profile));
+        profile.setGUID(PersonalDataManager.getInstance().setProfileToLocal(mProfile));
         profile.setIsLocal(true);
     }
 
     /** Writes the given value into the specified autofill profile field. */
     private static void setProfileField(
             AutofillProfile profile, int field, @Nullable CharSequence value) {
         assert profile != null;
         switch (field) {
             case AddressField.COUNTRY:
                 profile.setCountryCode(ensureNotNull(value));
@@ skipping 24 matching lines @@
                 return;
         }
 
         assert false;
     }
 
     private static String ensureNotNull(@Nullable CharSequence value) {
         return value == null ? "" : value.toString();
     }
 
+    private void setAddressFieldValuesFromCache() {
+        // Address fields are cached, so their values need to be updated for every new profile
+        // that's being edited.
+        for (Map.Entry<Integer, EditorFieldModel> entry : mAddressFields.entrySet()) {
+            entry.getValue().setValue(AutofillAddress.getProfileField(mProfile, entry.getKey()));
+        }
+    }
+    /* Callback of the sub keys request that is called when the sub keys are loaded.
+       Here the sub keys are admin areas (sub keys of the region=country.) */
+    @Override
+    public void onSubKeysReceived(String[] adminAreas) {
+        if (mAdminAreasLoaded) return;
+
+        mAdminAreasLoaded = true;
+
+        // If can't get admin areas from server or there is no admin area on the
+        // server, then use text field. Otherwise, use drop down list.
+        if (adminAreas == null || adminAreas.length == 0) {
+            mAddressFields.put(AddressField.ADMIN_AREA, EditorFieldModel.createTextInput());
+        } else {
+            mAddressFields.put(AddressField.ADMIN_AREA, EditorFieldModel.createDropdown());
+        }
+
+        /* Admin Areas need to be fetched in two cases.
+           1. Initial loading of the form.
+           2. When the selected country is changed in the form.
+           mOnCountryChange is true iff it's the 2nd case. */
+        if (mOnCountryChange) {
+            // Both country code and language code dictate which fields should be added to the
+            // editor.
+            // For example, "US" will not add dependent locality to the editor. A "JP" address will
+            // start with a person's full name or a with a prefecture name, depending on whether the
+            // language code is "ja-Latn" or "ja".
+            addAddressFieldsToEditor(
+                    mEventData.first, Locale.getDefault().getLanguage(), adminAreas);
+            // Notify EditorView that the fields in the model have changed. EditorView should
+            // re-read the model and update the UI accordingly.
+            mHandler.post(mEventData.second);
+        } else {
+            // This should be called when all required fields are put in mAddressField.
+            setAddressFieldValuesFromCache();
+            addAddressFieldsToEditor(
+                    mProfile.getCountryCode(), mProfile.getLanguageCode(), adminAreas);
+            mEditorView.show(mEditor);
+        }
+    }
+
+    /** Requests the list of admin areas. */
+    public void loadAdminAreas() {
+        String countryCode = mOnCountryChange ? mEventData.first : mProfile.getCountryCode();
+
+        // Used to check if the callback is called (for time-out).
+        mAdminAreasLoaded = false;
+
+        // In each rule, admin area keys are saved under sub keys of country.
+        PersonalDataManager.getInstance().loadRulesForSubKeys(countryCode);
+        PersonalDataManager.getInstance().getRegionSubKeys(countryCode, this);
+        onAdminAreasLoading();
+    }
+
+    /* In case the the admin areas are not loaded yet, starts a timer to cancel the request. */
+    public void onAdminAreasLoading() {

[sebsg, 2017/02/28 16:13:59]

General question. Is it possible to query two different countries at the same
time, of sequentially fast enough before the timer runs out? 

If you can have more than one, you will cancel both queries at the same time
with the current implementation.

Also if it's only one at the time, you can simplify how you keep track of the
pending queries in Personal_data_manager_android.

[Parastoo, 2017/03/21 14:30:44]

Done.

+        if (!mAdminAreasLoaded) {
+            new Handler().postDelayed(new Runnable() {
+                @Override
+                public void run() {
+                    if (!mAdminAreasLoaded) onSubKeysReceived(null);
+                    PersonalDataManager.getInstance().cancelPendingGetSubKeys();

[sebsg, 2017/02/28 16:13:59]

You also only need to call this if the rules are not done loading.

[Parastoo, 2017/03/21 14:30:44]

Done.

+                }
+            }, PersonalDataManager.getLoadingTimeoutMS());
+        }
+    }
+
     /**
-     * Adds text fields to the editor model based on the country and language code of the profile
-     * that's being edited.
+     * Adds fields to the editor model based on the country and language code of
+     * the profile that's being edited.
      */
-    private void addAddressTextFieldsToEditor(
-            EditorModel container, String countryCode, String languageCode) {
-        mAddressUiComponents = mAutofillProfileBridge.getAddressUiComponents(countryCode,
-                languageCode);
-
+    private void addAddressFieldsToEditor(
+            String countryCode, String languageCode, String[] adminAreas) {
+        mAddressUiComponents =
+                mAutofillProfileBridge.getAddressUiComponents(countryCode, languageCode);
+        // In terms of order, country must be the first field.

[sebsg, 2017/02/28 16:13:59]

nit: Country must be filled first.

[Parastoo, 2017/03/21 14:30:44]

This means that in terms of order of appearance, country comes before other
ones. So, I am adding the *field* here. (Not about *filling* the field.)

+        mEditor.addField(mCountryField);
         for (int i = 0; i < mAddressUiComponents.size(); i++) {
             AddressUiComponent component = mAddressUiComponents.get(i);
 
-            // The country field is a dropdown, so there's no need to add a text field for it.
-            if (component.id == AddressField.COUNTRY) continue;
-
             EditorFieldModel field = mAddressFields.get(component.id);
             // Labels depend on country, e.g., state is called province in some countries. These are
             // already localized.
             field.setLabel(component.label);
             field.setIsFullLine(component.isFullLine);
 
+            if (component.id == AddressField.ADMIN_AREA && field.isDropdownField()) {
+                field.setDropdownKeyValues(
+                        mAutofillProfileBridge.getAdminAreaDropdownList(adminAreas));
+            }
+
             // Libaddressinput formats do not always require the full name (RECIPIENT), but
             // PaymentRequest does.
             if (component.isRequired || component.id == AddressField.RECIPIENT) {
-                field.setRequiredErrorMessage(mContext.getString(
-                        R.string.payments_field_required_validation_message));
+                field.setRequiredErrorMessage(
+                        mContext.getString(R.string.payments_field_required_validation_message));
             } else {
                 field.setRequiredErrorMessage(null);
             }
-
-            container.addField(field);
+            mEditor.addField(field);
         }
+        // In terms of order, phone number must be the last field.

[sebsg, 2017/02/28 16:13:59]

nit: Phone number must be the last field.

[Parastoo, 2017/03/21 14:30:44]

Done.

+        mEditor.addField(mPhoneField);
     }
 
     private EditorFieldValidator getPhoneValidator() {
         if (mPhoneValidator == null) {
             mPhoneValidator = new EditorFieldValidator() {
                 @Override
                 public boolean isValid(@Nullable CharSequence value) {
                     return value != null
                             && PhoneNumberUtils.isGlobalPhoneNumber(
-                                    PhoneNumberUtils.stripSeparators(value.toString()));
+                                       PhoneNumberUtils.stripSeparators(value.toString()));
                 }
 
                 @Override
                 public boolean isLengthMaximum(@Nullable CharSequence value) {
                     return false;
                 }
             };
         }
         return mPhoneValidator;
     }
 }