intl-tel-input 18.2.1 → 18.3.1

package/third_party/libphonenumber/java/demoapp/app/src/main/java/com/google/phonenumbers/demoapp/contacts/ContactsRead.java

@@ -0,0 +1,62 @@
+package com.google.phonenumbers.demoapp.contacts;
+
+import android.content.ContentResolver;
+import android.content.Context;
+import android.database.Cursor;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import com.google.phonenumbers.demoapp.phonenumbers.PhoneNumberInApp;
+import java.util.ArrayList;
+import java.util.Collections;
+
+/** Handles everything related to reading the device contacts. */
+public class ContactsRead {
+
+  private ContactsRead() {}
+
+  /**
+   * Reads all phone numbers in the device's contacts and return them as a list of {@link
+   * PhoneNumberInApp}s ascending sorted by the contact name. An empty list is also returned if the
+   * app has no permission to read contacts or an error occurred while doing so
+   *
+   * @param context Context of the app
+   * @return ArrayList of all phone numbers in the device's contacts, also empty if the app has no
+   *     permission to read contacts or an error occurred while doing so
+   */
+  public static ArrayList<PhoneNumberInApp> getAllPhoneNumbersSorted(Context context) {
+    ArrayList<PhoneNumberInApp> phoneNumbers = new ArrayList<>();
+
+    if (!ContactsPermissionManagement.isGranted(context)) {
+      return phoneNumbers;
+    }
+
+    ContentResolver cr = context.getContentResolver();
+    // Only query for contacts with phone number(s).
+    Cursor cursor =
+        cr.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null, null, null, null);
+    // If query doesn't work as intended.
+    if (cursor == null) {
+      return phoneNumbers;
+    }
+
+    while (cursor.moveToNext()) {
+      // ID to identify the phone number entry in the contacts (can be used to update in contacts).
+      int idIndex = cursor.getColumnIndex(Phone._ID);
+      String id = idIndex != -1 ? cursor.getString(idIndex) : "";
+
+      int contactNameIndex = cursor.getColumnIndex(Phone.DISPLAY_NAME);
+      String contactName = contactNameIndex != -1 ? cursor.getString(contactNameIndex) : "";
+
+      int originalPhoneNumberIndex = cursor.getColumnIndex(Phone.NUMBER);
+      String originalPhoneNumber =
+          originalPhoneNumberIndex != -1 ? cursor.getString(originalPhoneNumberIndex) : "";
+
+      PhoneNumberInApp phoneNumberInApp =
+          new PhoneNumberInApp(id, contactName, originalPhoneNumber);
+      phoneNumbers.add(phoneNumberInApp);
+    }
+    cursor.close();
+    Collections.sort(phoneNumbers);
+    return phoneNumbers;
+  }
+}

package/third_party/libphonenumber/java/demoapp/app/src/main/java/com/google/phonenumbers/demoapp/contacts/ContactsWrite.java

@@ -0,0 +1,59 @@
+package com.google.phonenumbers.demoapp.contacts;
+
+import android.content.ContentProviderOperation;
+import android.content.Context;
+import android.content.OperationApplicationException;
+import android.os.RemoteException;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import com.google.phonenumbers.demoapp.phonenumbers.PhoneNumberInApp;
+import java.util.ArrayList;
+
+/** Handles everything related to writing the device contacts. */
+public class ContactsWrite {
+
+  private ContactsWrite() {}
+
+  /**
+   * Attempts to update all phone numbers in param {@code phoneNumbers} in the device's contacts.
+   * {@link PhoneNumberInApp#shouldContactBeUpdated()} is not called in this method and should be
+   * checked while creating the param {@code phoneNumbers}.
+   *
+   * @param phoneNumbers ArrayList of all phone numbers to update
+   * @param context Context of the app
+   * @return boolean whether operation was successful
+   */
+  public static boolean updatePhoneNumbers(
+      ArrayList<PhoneNumberInApp> phoneNumbers, Context context) {
+    if (!ContactsPermissionManagement.isGranted(context)) {
+      return false;
+    }
+
+    // Create a list of operations to only have to apply one batch.
+    ArrayList<ContentProviderOperation> contentProviderOperations = new ArrayList<>();
+
+    for (PhoneNumberInApp phoneNumber : phoneNumbers) {
+      // Identify the exact phone number entry to update.
+      String whereConditionBase = Phone._ID + " = ? AND " + ContactsContract.Data.MIMETYPE + " = ?";
+      String[] whereConditionParams =
+          new String[] {
+            phoneNumber.getId(), ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE
+          };
+
+      contentProviderOperations.add(
+          ContentProviderOperation.newUpdate(ContactsContract.Data.CONTENT_URI)
+              .withSelection(whereConditionBase, whereConditionParams)
+              .withValue(Phone.NUMBER, phoneNumber.getFormattedPhoneNumber())
+              .build());
+    }
+
+    try {
+      context
+          .getContentResolver()
+          .applyBatch(ContactsContract.AUTHORITY, contentProviderOperations);
+    } catch (OperationApplicationException | RemoteException e) {
+      return false;
+    }
+    return true;
+  }
+}

package/third_party/libphonenumber/java/demoapp/app/src/main/java/com/google/phonenumbers/demoapp/main/CountryDropdown.java

@@ -0,0 +1,203 @@
+package com.google.phonenumbers.demoapp.main;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.KeyEvent;
+import android.widget.ArrayAdapter;
+import android.widget.AutoCompleteTextView;
+import android.widget.LinearLayout;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.material.textfield.TextInputLayout;
+import com.google.i18n.phonenumbers.PhoneNumberUtil;
+import com.google.phonenumbers.demoapp.R;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A component containing a searchable dropdown input populated with all regions {@link
+ * PhoneNumberUtil} supports. Dropdown items are of format {@code [countryName] ([nameCode]) -
+ * +[callingCode]} (e.g. {@code Switzerland (CH) - +41}). Method provides access to the name code
+ * (e.g. {@code CH}) of the current input. Name code: <a
+ * href="https://www.iso.org/glossary-for-iso-3166.html">ISO 3166-1 alpha-2 country code</a> (e.g.
+ * {@code CH}). Calling code: <a
+ * href="https://www.itu.int/dms_pub/itu-t/opb/sp/T-SP-E.164D-2016-PDF-E.pdf">ITU-T E.164 assigned
+ * country code</a> (e.g. {@code 41}).
+ */
+public class CountryDropdown extends LinearLayout {
+
+  /**
+   * Map containing keys of format {@code [countryName] ([nameCode]) - +[callingCode]} (e.g. {@code
+   * Switzerland (CH) - +41}), and name codes (e.g. {@code CH}) as values.
+   */
+  private static final Map<String, String> countryLabelMapNameCode = new HashMap<>();
+  /** Ascending sorted list of the keys in {@link CountryDropdown#countryLabelMapNameCode}. */
+  private static final List<String> countryLabelSorted = new ArrayList<>();
+
+  private final TextInputLayout input;
+  private final AutoCompleteTextView inputEditText;
+
+  /** The name code of the current input. */
+  private String nameCode;
+
+  public CountryDropdown(@NonNull Context context, @Nullable AttributeSet attrs) {
+    super(context, attrs);
+    inflate(getContext(), R.layout.country_dropdown, this);
+    input = findViewById(R.id.country_dropdown_input);
+    inputEditText = findViewById(R.id.country_dropdown_input_edit_text);
+
+    inputEditText.setOnKeyListener(
+        (v, keyCode, event) -> {
+          // If the DEL key is used and the input was a valid dropdown option, clear the input
+          // completely
+          if (keyCode == KeyEvent.KEYCODE_DEL && setNameCodeForInput()) {
+            inputEditText.setText("");
+          }
+          // Disable the error state when editing the input after the validation revealed an error
+          if (input.isErrorEnabled()) {
+            disableInputError();
+          }
+          return false;
+        });
+
+    populateCountryLabelMapNameCode();
+    setAdapter();
+  }
+
+  /**
+   * Populates {@link CountryDropdown#countryLabelMapNameCode} with all regions {@link
+   * PhoneNumberUtil} supports if not populated yet.
+   */
+  private void populateCountryLabelMapNameCode() {
+    if (!countryLabelMapNameCode.isEmpty()) {
+      return;
+    }
+
+    Set<String> supportedNameCodes = PhoneNumberUtil.getInstance().getSupportedRegions();
+    for (String nameCode : supportedNameCodes) {
+      String countryLabel = getCountryLabelForNameCode(nameCode);
+      countryLabelMapNameCode.put(countryLabel, nameCode);
+    }
+  }
+
+  /**
+   * Returns the label of format {@code [countryName] ([nameCode]) - +[callingCode]} (e.g. {@code
+   * Switzerland (CH) - +41}) for the param {@code nameCode}.
+   *
+   * @param nameCode String in format of a name code (e.g. {@code CH})
+   * @return String label of format {@code [countryName] ([nameCode]) - +[callingCode]} (e.g. {@code
+   *     Switzerland (CH) - +41})
+   */
+  private String getCountryLabelForNameCode(String nameCode) {
+    Locale locale = new Locale("en", nameCode);
+    String countryName = locale.getDisplayCountry();
+    int callingCode =
+        PhoneNumberUtil.getInstance().getCountryCodeForRegion(nameCode.toUpperCase(Locale.ROOT));
+
+    return countryName + " (" + nameCode.toUpperCase(Locale.ROOT) + ") - +" + callingCode;
+  }
+
+  /**
+   * Populates {@link CountryDropdown#countryLabelSorted} with the ascending sorted keys of {@link
+   * CountryDropdown#countryLabelMapNameCode} if not populated yet. Then sets an {@link
+   * ArrayAdapter} with {@link CountryDropdown#countryLabelSorted} for the dropdown to show the
+   * list.
+   */
+  private void setAdapter() {
+    if (countryLabelSorted.isEmpty()) {
+      countryLabelSorted.addAll(countryLabelMapNameCode.keySet());
+      Collections.sort(countryLabelSorted);
+    }
+
+    ArrayAdapter<String> arrayAdapter =
+        new ArrayAdapter<>(getContext(), R.layout.country_dropdown_item, countryLabelSorted);
+    inputEditText.setAdapter(arrayAdapter);
+  }
+
+  /**
+   * Returns whether the current input is a valid dropdown option. Also updates the input error
+   * accordingly.
+   *
+   * @return boolean whether the current input is a valid dropdown option
+   */
+  public boolean validateInput() {
+    if (!setNameCodeForInput()) {
+      enableInputError();
+      return false;
+    }
+
+    disableInputError();
+    return true;
+  }
+
+  /**
+   * Sets the {@link CountryDropdown#nameCode} to the name code of the current input if that's a
+   * valid dropdown option. Else set's it to an empty String.
+   *
+   * @return boolean whether the current input is a valid dropdown option
+   */
+  private boolean setNameCodeForInput() {
+    String nameCodeForInput = countryLabelMapNameCode.get(getInput());
+    if (nameCodeForInput == null) {
+      nameCode = "";
+      return false;
+    }
+
+    nameCode = nameCodeForInput;
+    return true;
+  }
+
+  /** Shows the error message on the input component. */
+  private void enableInputError() {
+    input.setErrorEnabled(true);
+    input.setError(getResources().getString(R.string.main_activity_country_dropdown_error));
+  }
+
+  /** Hides the error message on the input component. */
+  private void disableInputError() {
+    input.setError(null);
+    input.setErrorEnabled(false);
+  }
+
+  private String getInput() {
+    return inputEditText.getText().toString();
+  }
+
+  /**
+   * Returns the name code of the current input if it's a valid dropdown option, else returns an
+   * empty String.
+   *
+   * @return String name code of the current input if it's a valid dropdown option, else returns an
+   *     empty String
+   */
+  public String getNameCodeForInput() {
+    setNameCodeForInput();
+    return nameCode;
+  }
+
+  /**
+   * Sets the label of the country with the name code param {@code nameCode} on the input if it's
+   * valid. Else the input is not changed.
+   *
+   * @param nameCode String in format of a name code (e.g. {@code CH})
+   */
+  public void setInputForNameCode(String nameCode) {
+    String countryLabel = getCountryLabelForNameCode(nameCode);
+    if (!countryLabelSorted.contains(countryLabel)) {
+      return;
+    }
+
+    inputEditText.setText(countryLabel);
+    validateInput();
+  }
+
+  @Override
+  public void setEnabled(boolean enabled) {
+    input.setEnabled(enabled);
+  }
+}

package/third_party/libphonenumber/java/demoapp/app/src/main/java/com/google/phonenumbers/demoapp/main/MainActivity.java

@@ -0,0 +1,226 @@
+package com.google.phonenumbers.demoapp.main;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Bundle;
+import android.telephony.TelephonyManager;
+import android.view.View;
+import android.widget.Button;
+import android.widget.CheckBox;
+import android.widget.TextView;
+import androidx.annotation.NonNull;
+import androidx.appcompat.app.ActionBar;
+import androidx.appcompat.app.AppCompatActivity;
+import com.google.android.material.snackbar.Snackbar;
+import com.google.phonenumbers.demoapp.R;
+import com.google.phonenumbers.demoapp.contacts.ContactsPermissionManagement;
+import com.google.phonenumbers.demoapp.contacts.ContactsRead;
+import com.google.phonenumbers.demoapp.phonenumbers.PhoneNumberFormatting;
+import com.google.phonenumbers.demoapp.phonenumbers.PhoneNumberInApp;
+import com.google.phonenumbers.demoapp.result.ResultActivity;
+import java.util.ArrayList;
+
+/** Used to handle and process interactions from/with the main page UI of the app. */
+public class MainActivity extends AppCompatActivity {
+
+  private CountryDropdown countryDropdown;
+  private Button btnCountryDropdownReset;
+  private CheckBox cbIgnoreWhitespace;
+  private TextView tvError;
+  private Button btnError;
+  private Button btnStart;
+
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    setContentView(R.layout.activity_main);
+
+    ActionBar actionBar = getSupportActionBar();
+    if (actionBar != null) {
+      actionBar.setTitle(R.string.app_name_long);
+    }
+
+    countryDropdown = findViewById(R.id.country_dropdown);
+    btnCountryDropdownReset = findViewById(R.id.btn_country_dropdown_reset);
+    cbIgnoreWhitespace = findViewById(R.id.cb_ignore_whitespace);
+    tvError = findViewById(R.id.tv_error);
+    btnError = findViewById(R.id.btn_error);
+    btnStart = findViewById(R.id.btn_start);
+
+    btnCountryDropdownReset.setOnClickListener(v -> setSimCountryOnCountryDropdown());
+    btnStart.setOnClickListener(v -> btnStartClicked());
+  }
+
+  @Override
+  protected void onStart() {
+    super.onStart();
+    // Reset all UI elements to default state
+    updateUiState(UiState.SELECT_COUNTRY_CODE);
+    setSimCountryOnCountryDropdown();
+    cbIgnoreWhitespace.setChecked(true);
+  }
+
+  @Override
+  public void onRequestPermissionsResult(
+      int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+
+    // Return of the permission result is not about the requested contacts permission
+    if (requestCode != ContactsPermissionManagement.CONTACTS_PERMISSION_REQUEST_CODE) {
+      return;
+    }
+
+    if (grantResults.length == 2
+        && grantResults[0] == PackageManager.PERMISSION_GRANTED
+        && grantResults[1] == PackageManager.PERMISSION_GRANTED) {
+      updateUiState(UiState.PROCESSING);
+      startProcess();
+    } else {
+      ContactsPermissionManagement.addOneToNumberOfDenials(this);
+      switch (ContactsPermissionManagement.getState(this)) {
+          // NEED_REQUEST is specifically to handle the case where the user dismisses the first
+          // permission dialog shown since the app's installation.
+        case NEEDS_REQUEST:
+        case SHOW_RATIONALE:
+          updateUiState(UiState.PERMISSION_ERROR_GRANT_IN_APP);
+          break;
+        case NEEDS_GRANT_IN_SETTINGS:
+        default:
+          updateUiState(UiState.PERMISSION_ERROR_GRANT_IN_SETTINGS);
+          break;
+      }
+    }
+  }
+
+  /**
+   * Updates the UI to represent the param {@code uiState}.
+   *
+   * @param uiState State the UI should be changed to
+   */
+  private void updateUiState(UiState uiState) {
+    // Specifically: countryDropdown, btnCountryDropdownReset, cbIgnoreWhitespace, and btnStart
+    boolean mainInteractionsEnabled = false;
+    // Specifically: tvError, and btnError
+    boolean showError = false;
+
+    switch (uiState) {
+      case SELECT_COUNTRY_CODE:
+      default:
+        mainInteractionsEnabled = true;
+        btnStart.setText(getText(R.string.main_activity_start_text_default));
+        break;
+      case PROCESSING:
+        btnStart.setText(getText(R.string.main_activity_start_text_processing));
+        break;
+      case PERMISSION_ERROR_GRANT_IN_APP:
+        showError = true;
+        tvError.setText(getText(R.string.main_activity_error_text_grant_in_app));
+        btnError.setText(getText(R.string.main_activity_error_cta_grant_in_app));
+        btnError.setOnClickListener(v -> ContactsPermissionManagement.request(this));
+        btnStart.setText(getText(R.string.main_activity_start_text_processing));
+        break;
+      case PERMISSION_ERROR_GRANT_IN_SETTINGS:
+        showError = true;
+        tvError.setText(getText(R.string.main_activity_error_text_grant_in_settings));
+        btnError.setText(getText(R.string.main_activity_error_cta_grant_in_settings));
+        btnError.setOnClickListener(v -> ContactsPermissionManagement.openSystemSettings(this));
+        btnStart.setText(getText(R.string.main_activity_start_text_default));
+        break;
+    }
+
+    countryDropdown.setEnabled(mainInteractionsEnabled);
+    btnCountryDropdownReset.setEnabled(mainInteractionsEnabled);
+    cbIgnoreWhitespace.setEnabled(mainInteractionsEnabled);
+    tvError.setVisibility(showError ? View.VISIBLE : View.INVISIBLE);
+    btnError.setVisibility(showError ? View.VISIBLE : View.INVISIBLE);
+    btnStart.setEnabled(mainInteractionsEnabled);
+  }
+
+  /** Sets the SIM's country as selected item in the country dropdown. */
+  private void setSimCountryOnCountryDropdown() {
+    TelephonyManager telephonyManager =
+        (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
+    countryDropdown.setInputForNameCode(telephonyManager.getSimCountryIso());
+  }
+
+  /**
+   * Called when the start button is clicked. If contacts permissions are granted, starts reading
+   * the contacts. If permissions are not granted, handle that appropriately based on the current
+   * state in the process.
+   */
+  private void btnStartClicked() {
+    updateUiState(UiState.PROCESSING);
+
+    if (!countryDropdown.validateInput()) {
+      updateUiState(UiState.SELECT_COUNTRY_CODE);
+      return;
+    }
+
+    switch (ContactsPermissionManagement.getState(this)) {
+      case ALREADY_GRANTED:
+        startProcess();
+        break;
+      case NEEDS_REQUEST:
+        ContactsPermissionManagement.request(this);
+        break;
+      case SHOW_RATIONALE:
+        updateUiState(UiState.PERMISSION_ERROR_GRANT_IN_APP);
+        break;
+      case NEEDS_GRANT_IN_SETTINGS:
+      default:
+        updateUiState(UiState.PERMISSION_ERROR_GRANT_IN_SETTINGS);
+        break;
+    }
+  }
+
+  /**
+   * Starts the process of reading the contacts, formatting the numbers and starting a {@link
+   * ResultActivity} to show the results.
+   */
+  private void startProcess() {
+    ArrayList<PhoneNumberInApp> phoneNumbersSorted = ContactsRead.getAllPhoneNumbersSorted(this);
+
+    if (phoneNumbersSorted.isEmpty()) {
+      showNoContactsExistSnackbar();
+      updateUiState(UiState.SELECT_COUNTRY_CODE);
+      return;
+    }
+
+    // Format each phone number.
+    for (PhoneNumberInApp phoneNumber : phoneNumbersSorted) {
+      PhoneNumberFormatting.formatPhoneNumberInApp(
+          phoneNumber, countryDropdown.getNameCodeForInput(), cbIgnoreWhitespace.isChecked());
+    }
+
+    // Start new activity to show results.
+    Intent intent = new Intent(this, ResultActivity.class);
+    intent.putExtra(ResultActivity.PHONE_NUMBERS_SORTED_SERIALIZABLE_EXTRA_KEY, phoneNumbersSorted);
+    startActivity(intent);
+  }
+
+  /** Shows a Snackbar informing that no contacts exist. */
+  private void showNoContactsExistSnackbar() {
+    Snackbar.make(
+            countryDropdown, R.string.main_activity_no_contacts_exist_text, Snackbar.LENGTH_LONG)
+        .show();
+  }
+
+  /** Represents the different states the UI of this activity can become. */
+  enum UiState {
+    /** The user should select a country from the dropdown. */
+    SELECT_COUNTRY_CODE,
+    /** Used when loading or processing. The UI is disabled for the user during this time. */
+    PROCESSING,
+    /**
+     * Shows a text explaining that the app needs contacts permission to work, and a button to grant
+     * the permission directly in the app.
+     */
+    PERMISSION_ERROR_GRANT_IN_APP,
+    /**
+     * Shows a text explaining that the app does not have contacts permission, and a button to go to
+     * the system settings to grant the permission.
+     */
+    PERMISSION_ERROR_GRANT_IN_SETTINGS
+  }
+}

package/third_party/libphonenumber/java/demoapp/app/src/main/java/com/google/phonenumbers/demoapp/phonenumbers/PhoneNumberFormatting.java

@@ -0,0 +1,74 @@
+package com.google.phonenumbers.demoapp.phonenumbers;
+
+import com.google.i18n.phonenumbers.NumberParseException;
+import com.google.i18n.phonenumbers.PhoneNumberUtil;
+import com.google.i18n.phonenumbers.PhoneNumberUtil.PhoneNumberFormat;
+import com.google.i18n.phonenumbers.Phonenumber.PhoneNumber;
+import com.google.i18n.phonenumbers.ShortNumberInfo;
+import com.google.phonenumbers.demoapp.phonenumbers.PhoneNumberInApp.FormattingState;
+
+/**
+ * Handles everything related to the formatting {@link PhoneNumberInApp}s to E.164 format (e.g.
+ * {@code +41446681800}) using LibPhoneNumber ({@link PhoneNumberUtil}).
+ */
+public class PhoneNumberFormatting {
+
+  private static final PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance();
+  private static final ShortNumberInfo shortNumberInfo = ShortNumberInfo.getInstance();
+
+  private PhoneNumberFormatting() {}
+
+  /**
+   * Attempts to format the param {@code phoneNumberInApp} in E.164 format (e.g. {@code
+   * +41446681800}) using the country from param {@code nameCodeToUse} (e.g. {@code CH}).
+   *
+   * @param phoneNumberInApp PhoneNumberInApp to format to E.164 format
+   * @param nameCodeToUse String in format of a name code (e.g. {@code CH})
+   * @param ignoreWhitespace boolean whether a phone number should be treated as {@link
+   *     FormattingState#NUMBER_IS_ALREADY_IN_E164} instead of suggesting to remove whitespace if
+   *     that whitespace is the only difference
+   */
+  public static void formatPhoneNumberInApp(
+      PhoneNumberInApp phoneNumberInApp, String nameCodeToUse, boolean ignoreWhitespace) {
+    PhoneNumber originalPhoneNumberParsed;
+
+    // Check PARSING_ERROR
+    try {
+      originalPhoneNumberParsed =
+          phoneNumberUtil.parse(phoneNumberInApp.getOriginalPhoneNumber(), nameCodeToUse);
+    } catch (NumberParseException e) {
+      phoneNumberInApp.setFormattingState(FormattingState.PARSING_ERROR);
+      return;
+    }
+
+    // Check NUMBER_IS_SHORT_NUMBER
+    if (shortNumberInfo.isValidShortNumber(originalPhoneNumberParsed)) {
+      phoneNumberInApp.setFormattingState(FormattingState.NUMBER_IS_SHORT_NUMBER);
+      return;
+    }
+
+    // Check NUMBER_IS_NOT_VALID
+    if (!phoneNumberUtil.isValidNumber(originalPhoneNumberParsed)) {
+      phoneNumberInApp.setFormattingState(FormattingState.NUMBER_IS_NOT_VALID);
+      return;
+    }
+
+    String formattedPhoneNumber =
+        phoneNumberUtil.format(originalPhoneNumberParsed, PhoneNumberFormat.E164);
+
+    // Check NUMBER_IS_ALREADY_IN_E164
+    if (ignoreWhitespace
+        ? phoneNumberInApp
+            .getOriginalPhoneNumber()
+            .replaceAll("\\s+", "")
+            .equals(formattedPhoneNumber)
+        : phoneNumberInApp.getOriginalPhoneNumber().equals(formattedPhoneNumber)) {
+      phoneNumberInApp.setFormattingState(FormattingState.NUMBER_IS_ALREADY_IN_E164);
+      return;
+    }
+
+    phoneNumberInApp.setFormattedPhoneNumber(formattedPhoneNumber);
+    phoneNumberInApp.setFormattingState(FormattingState.COMPLETED);
+    phoneNumberInApp.setShouldContactBeUpdated(true);
+  }
+}