Use respectful terms (#1905)

Author: samtstern

auth/README.md

@@ -263,15 +263,15 @@ To use email link sign in, you will first need to enable it in the Firebase Cons
 also have to enable Firebase Dynamic Links.
 
 You can enable email link sign in by calling the `enableEmailLinkSignIn` on an `EmailBuilder` instance. You will also need
-to provide a valid `ActionCodeSettings` object with `setHandleCodeInApp` set to true. Additionally, you need to whitelist the
+to provide a valid `ActionCodeSettings` object with `setHandleCodeInApp` set to true. Additionally, you need to allowlist the
 URL you pass to `setUrl`; you can do so in the Firebase Console (Authentication -> Sign in Methods -> Authorized domains).
 
 ```java
 
 ActionCodeSettings actionCodeSettings = ActionCodeSettings.newBuilder()
         .setAndroidPackageName(/*yourPackageName*/, /*installIfNotAvailable*/true, /*minimumVersion*/null)
         .setHandleCodeInApp(true)
-        .setUrl("https://google.com") // This URL needs to be whitelisted
+        .setUrl("https://google.com") // This URL needs to be allowlisted
         .build();
 
 startActivityForResult(
@@ -409,37 +409,37 @@ IdpConfig phoneConfigWithDefaultNumber = new IdpConfig.PhoneBuilder()
 
 You can limit the countries shown in the country selector list. By default, all countries are shown.
 
-You can provide a list of countries to whitelist or blacklist. You can populate these lists with
+You can provide a list of countries to allowlist or blocklist. You can populate these lists with
 ISO (alpha-2) and E164 formatted country codes.
 
 ```java
-List<String> whitelistedCountries = new ArrayList<String>();
-whitelistedCountries.add("+1");
-whitelistedCountries.add("gr");
+List<String> allowedCountries = new ArrayList<String>();
+allowedCountries.add("+1");
+allowedCountries.add("gr");
 
-IdpConfig phoneConfigWithWhitelistedCountries = new IdpConfig.PhoneBuilder()
-        .setWhitelistedCountries(whitelistedCountries)
+IdpConfig phoneConfigWithAllowedCountries = new IdpConfig.PhoneBuilder()
+        .setWhitelistedCountries(allowedCountries)
         .build();
 ```
 All countries with the country code +1 will be present in the selector as well as Greece ('gr').
 
-You may want to exclude a few countries from the list and avoid creating a whitelist with
-many countries. You can instead provide a list of countries to blacklist. By doing so, all countries
+You may want to exclude a few countries from the list and avoid creating a allowlist with
+many countries. You can instead provide a list of countries to blocklist. By doing so, all countries
 excluding the ones you provide will be in the selector.
 
 ```java
-List<String> blacklistedCountries = new ArrayList<String>();
-blacklistedCountries.add("+1");
-blacklistedCountries.add("gr");
+List<String> blockedCountries = new ArrayList<String>();
+blockedCountries.add("+1");
+blockedCountries.add("gr");
 
-IdpConfig phoneConfigWithBlacklistedCountries = new IdpConfig.PhoneBuilder()
-        .setBlacklistedCountries(blacklistedCountries)
+IdpConfig phoneConfigWithBlockedCountries = new IdpConfig.PhoneBuilder()
+        .setBlacklistedCountries(blockedCountries)
         .build();
 ```
 
 The country code selector will exclude all countries with a country code of +1 and Greece ('gr').
 
-Note: You can't provide both a list of countries to whitelist and blacklist. If you do, a runtime
+Note: You can't provide both a list of countries to allowlist and blocklist. If you do, a runtime
 exception will be thrown.
 
 This change is purely UI based. We do not restrict users from signing in with their phone number.

auth/src/main/java/com/firebase/ui/auth/AuthUI.java

@@ -736,7 +736,7 @@ public EmailBuilder enableEmailLinkSignIn() {
              * <p>
              * {@link ActionCodeSettings#canHandleCodeInApp()} must be set to true, and a valid
              * continueUrl must be passed via {@link ActionCodeSettings.Builder#setUrl(String)}.
-             * This URL must be whitelisted in the Firebase Console.
+             * This URL must be allowlisted in the Firebase Console.
              *
              * @throws IllegalStateException if canHandleCodeInApp is set to false
              * @throws NullPointerException  if ActionCodeSettings is null
@@ -878,26 +878,26 @@ public PhoneBuilder setDefaultCountryIso(@NonNull String iso) {
              * https://en.wikipedia.org/wiki/ISO_3166-1
              * and e-164 codes here: https://en.wikipedia.org/wiki/List_of_country_calling_codes
              *
-             * @param whitelistedCountries a non empty case insensitive list of country codes
-             *                             and/or isos to be whitelisted
-             * @throws IllegalArgumentException if an empty whitelist is provided.
-             * @throws NullPointerException     if a null whitelist is provided.
+             * @param countries a non empty case insensitive list of country codes
+             *                  and/or isos to be allowlisted
+             * @throws IllegalArgumentException if an empty allowlist is provided.
+             * @throws NullPointerException     if a null allowlist is provided.
              */
             public PhoneBuilder setWhitelistedCountries(
-                    @NonNull List<String> whitelistedCountries) {
-                if (getParams().containsKey(ExtraConstants.BLACKLISTED_COUNTRIES)) {
+                    @NonNull List<String> countries) {
+                if (getParams().containsKey(ExtraConstants.BLOCKLISTED_COUNTRIES)) {
                     throw new IllegalStateException(
-                            "You can either whitelist or blacklist country codes for phone " +
+                            "You can either allowlist or blocklist country codes for phone " +
                                     "authentication.");
                 }
 
-                String message = "Invalid argument: Only non-%s whitelists are valid. " +
-                        "To specify no whitelist, do not call this method.";
-                Preconditions.checkNotNull(whitelistedCountries, String.format(message, "null"));
-                Preconditions.checkArgument(!whitelistedCountries.isEmpty(), String.format
+                String message = "Invalid argument: Only non-%s allowlists are valid. " +
+                        "To specify no allowlist, do not call this method.";
+                Preconditions.checkNotNull(countries, String.format(message, "null"));
+                Preconditions.checkArgument(!countries.isEmpty(), String.format
                         (message, "empty"));
 
-                addCountriesToBundle(whitelistedCountries, ExtraConstants.WHITELISTED_COUNTRIES);
+                addCountriesToBundle(countries, ExtraConstants.ALLOWLISTED_COUNTRIES);
                 return this;
             }
 
@@ -915,26 +915,26 @@ public PhoneBuilder setWhitelistedCountries(
              * https://en.wikipedia.org/wiki/ISO_3166-1
              * and e-164 codes here: https://en.wikipedia.org/wiki/List_of_country_calling_codes
              *
-             * @param blacklistedCountries a non empty case insensitive list of country codes
-             *                             and/or isos to be blacklisted
-             * @throws IllegalArgumentException if an empty blacklist is provided.
-             * @throws NullPointerException     if a null blacklist is provided.
+             * @param countries a non empty case insensitive list of country codes
+             *                  and/or isos to be blocklisted
+             * @throws IllegalArgumentException if an empty blocklist is provided.
+             * @throws NullPointerException     if a null blocklist is provided.
              */
             public PhoneBuilder setBlacklistedCountries(
-                    @NonNull List<String> blacklistedCountries) {
-                if (getParams().containsKey(ExtraConstants.WHITELISTED_COUNTRIES)) {
+                    @NonNull List<String> countries) {
+                if (getParams().containsKey(ExtraConstants.ALLOWLISTED_COUNTRIES)) {
                     throw new IllegalStateException(
-                            "You can either whitelist or blacklist country codes for phone " +
+                            "You can either allowlist or blocklist country codes for phone " +
                                     "authentication.");
                 }
 
-                String message = "Invalid argument: Only non-%s blacklists are valid. " +
+                String message = "Invalid argument: Only non-%s blocklists are valid. " +
                         "To specify no blacklist, do not call this method.";
-                Preconditions.checkNotNull(blacklistedCountries, String.format(message, "null"));
-                Preconditions.checkArgument(!blacklistedCountries.isEmpty(), String.format
+                Preconditions.checkNotNull(countries, String.format(message, "null"));
+                Preconditions.checkArgument(!countries.isEmpty(), String.format
                         (message, "empty"));
 
-                addCountriesToBundle(blacklistedCountries, ExtraConstants.BLACKLISTED_COUNTRIES);
+                addCountriesToBundle(countries, ExtraConstants.BLOCKLISTED_COUNTRIES);
                 return this;
             }
 
@@ -954,27 +954,26 @@ private void addCountriesToBundle(List<String> CountryIsos, String CountryIsoTyp
             }
 
             private void validateInputs() {
-                List<String> whitelistedCountries = getParams().getStringArrayList(
-                        ExtraConstants.WHITELISTED_COUNTRIES);
-                List<String> blacklistedCountries = getParams().getStringArrayList(
-                        ExtraConstants.BLACKLISTED_COUNTRIES);
+                List<String> allowedCountries = getParams().getStringArrayList(
+                        ExtraConstants.ALLOWLISTED_COUNTRIES);
+                List<String> blockedCountries = getParams().getStringArrayList(
+                        ExtraConstants.BLOCKLISTED_COUNTRIES);
 
-                if (whitelistedCountries != null &&
-                        blacklistedCountries != null) {
+                if (allowedCountries != null && blockedCountries != null) {
                     throw new IllegalStateException(
-                            "You can either whitelist or blacklist country codes for phone " +
+                            "You can either allowlist or blocked country codes for phone " +
                                     "authentication.");
-                } else if (whitelistedCountries != null) {
-                    validateInputs(whitelistedCountries, true);
+                } else if (allowedCountries != null) {
+                    validateInputs(allowedCountries, true);
 
-                } else if (blacklistedCountries != null) {
-                    validateInputs(blacklistedCountries, false);
+                } else if (blockedCountries != null) {
+                    validateInputs(blockedCountries, false);
                 }
             }
 
-            private void validateInputs(List<String> countries, boolean whitelisted) {
+            private void validateInputs(List<String> countries, boolean allowed) {
                 validateCountryInput(countries);
-                validateDefaultCountryInput(countries, whitelisted);
+                validateDefaultCountryInput(countries, allowed);
             }
 
             private void validateCountryInput(List<String> codes) {
@@ -986,40 +985,40 @@ private void validateCountryInput(List<String> codes) {
                 }
             }
 
-            private void validateDefaultCountryInput(List<String> codes, boolean whitelisted) {
+            private void validateDefaultCountryInput(List<String> codes, boolean allowed) {
                 // A default iso/code can be set via #setDefaultCountryIso() or #setDefaultNumber()
                 if (getParams().containsKey(ExtraConstants.COUNTRY_ISO) ||
                         getParams().containsKey(ExtraConstants.PHONE)) {
 
-                    if (!validateDefaultCountryIso(codes, whitelisted)
-                            || !validateDefaultPhoneIsos(codes, whitelisted)) {
+                    if (!validateDefaultCountryIso(codes, allowed)
+                            || !validateDefaultPhoneIsos(codes, allowed)) {
                         throw new IllegalArgumentException("Invalid default country iso. Make " +
-                                "sure it is either part of the whitelisted list or that you "
-                                + "haven't blacklisted it.");
+                                "sure it is either part of the allowed list or that you "
+                                + "haven't blocked it.");
                     }
                 }
 
             }
 
-            private boolean validateDefaultCountryIso(List<String> codes, boolean whitelisted) {
+            private boolean validateDefaultCountryIso(List<String> codes, boolean allowed) {
                 String defaultIso = getDefaultIso();
-                return isValidDefaultIso(codes, defaultIso, whitelisted);
+                return isValidDefaultIso(codes, defaultIso, allowed);
             }
 
-            private boolean validateDefaultPhoneIsos(List<String> codes, boolean whitelisted) {
+            private boolean validateDefaultPhoneIsos(List<String> codes, boolean allowed) {
                 List<String> phoneIsos = getPhoneIsosFromCode();
                 for (String iso : phoneIsos) {
-                    if (isValidDefaultIso(codes, iso, whitelisted)) {
+                    if (isValidDefaultIso(codes, iso, allowed)) {
                         return true;
                     }
                 }
                 return phoneIsos.isEmpty();
             }
 
-            private boolean isValidDefaultIso(List<String> codes, String iso, boolean whitelisted) {
+            private boolean isValidDefaultIso(List<String> codes, String iso, boolean allowed) {
                 if (iso == null) return true;
                 boolean containsIso = containsCountryIso(codes, iso);
-                return containsIso && whitelisted || !containsIso && !whitelisted;
+                return containsIso && allowed || !containsIso && !allowed;
 
             }
 

auth/src/main/java/com/firebase/ui/auth/ui/phone/CountryListSpinner.java

@@ -55,8 +55,8 @@ public final class CountryListSpinner extends AppCompatEditText implements View.
     private String mSelectedCountryName;
     private CountryInfo mSelectedCountryInfo;
 
-    private Set<String> mWhitelistedCountryIsos = new HashSet<>();
-    private Set<String> mBlacklistedCountryIsos = new HashSet<>();
+    private Set<String> mAllowedCountryIsos = new HashSet<>();
+    private Set<String> mBlockedCountryIsos = new HashSet<>();
 
     public CountryListSpinner(Context context) {
         this(context, null, android.R.attr.spinnerStyle);
@@ -88,25 +88,25 @@ private List<CountryInfo> getCountriesToDisplayInSpinner(Bundle params) {
         initCountrySpinnerIsosFromParams(params);
         Map<String, Integer> countryInfoMap = PhoneNumberUtils.getImmutableCountryIsoMap();
 
-        // We consider all countries to be whitelisted if there are no whitelisted
-        // or blacklisted countries given as input.
-        if (mWhitelistedCountryIsos.isEmpty() && mBlacklistedCountryIsos.isEmpty()) {
-            this.mWhitelistedCountryIsos = new HashSet<>(countryInfoMap.keySet());
+        // We consider all countries to be allowed if there are no allowed
+        // or blocked countries given as input.
+        if (mAllowedCountryIsos.isEmpty() && mBlockedCountryIsos.isEmpty()) {
+            this.mAllowedCountryIsos = new HashSet<>(countryInfoMap.keySet());
         }
 
         List<CountryInfo> countryInfoList = new ArrayList<>();
 
-        // At this point either mWhitelistedCountryIsos or mBlacklistedCountryIsos is null.
+        // At this point either mAllowedCountryIsos or mBlockedCountryIsos is null.
         // We assume no countries are to be excluded. Here, we correct this assumption based on the
         // contents of either lists.
         Set<String> excludedCountries = new HashSet<>();
-        if (!mBlacklistedCountryIsos.isEmpty()) {
-            // Exclude all countries in the mBlacklistedCountryIsos list.
-            excludedCountries.addAll(mBlacklistedCountryIsos);
+        if (!mBlockedCountryIsos.isEmpty()) {
+            // Exclude all countries in the mBlockedCountryIsos list.
+            excludedCountries.addAll(mBlockedCountryIsos);
         } else {
-            // Exclude all countries that are not present in the mWhitelistedCountryIsos list.
+            // Exclude all countries that are not present in the mAllowedCountryIsos list.
             excludedCountries.addAll(countryInfoMap.keySet());
-            excludedCountries.removeAll(mWhitelistedCountryIsos);
+            excludedCountries.removeAll(mAllowedCountryIsos);
         }
 
         // Once we know which countries need to be excluded, we loop through the country isos,
@@ -122,17 +122,17 @@ private List<CountryInfo> getCountriesToDisplayInSpinner(Bundle params) {
     }
 
     private void initCountrySpinnerIsosFromParams(@NonNull Bundle params) {
-        List<String> whitelistedCountries =
-                params.getStringArrayList(ExtraConstants.WHITELISTED_COUNTRIES);
-        List<String> blacklistedCountries =
-                params.getStringArrayList(ExtraConstants.BLACKLISTED_COUNTRIES);
+        List<String> allowedCountries =
+                params.getStringArrayList(ExtraConstants.ALLOWLISTED_COUNTRIES);
+        List<String> blockedCountries =
+                params.getStringArrayList(ExtraConstants.BLOCKLISTED_COUNTRIES);
 
-        if (whitelistedCountries != null) {
-            mWhitelistedCountryIsos = convertCodesToIsos(whitelistedCountries);
+        if (allowedCountries != null) {
+            mAllowedCountryIsos = convertCodesToIsos(allowedCountries);
         }
 
-        if (blacklistedCountries != null) {
-            mBlacklistedCountryIsos = convertCodesToIsos(blacklistedCountries);
+        if (blockedCountries != null) {
+            mBlockedCountryIsos = convertCodesToIsos(blockedCountries);
         }
     }
 
@@ -167,12 +167,12 @@ private void setDefaultCountryForSpinner(List<CountryInfo> countries) {
     public boolean isValidIso(String iso) {
         iso = iso.toUpperCase(Locale.getDefault());
         boolean valid = true;
-        if (!mWhitelistedCountryIsos.isEmpty()) {
-            valid = valid && mWhitelistedCountryIsos.contains(iso);
+        if (!mAllowedCountryIsos.isEmpty()) {
+            valid = valid && mAllowedCountryIsos.contains(iso);
         }
 
-        if (!mBlacklistedCountryIsos.isEmpty()) {
-            valid = valid && !mBlacklistedCountryIsos.contains(iso);
+        if (!mBlockedCountryIsos.isEmpty()) {
+            valid = valid && !mBlockedCountryIsos.contains(iso);
         }
 
         return valid;

auth/src/main/java/com/firebase/ui/auth/util/ExtraConstants.java

@@ -40,8 +40,8 @@ public final class ExtraConstants {
     public static final String COUNTRY_ISO = "extra_country_iso";
     public static final String NATIONAL_NUMBER = "extra_national_number";
 
-    public static final String WHITELISTED_COUNTRIES = "whitelisted_countries";
-    public static final String BLACKLISTED_COUNTRIES = "blacklisted_countries";
+    public static final String ALLOWLISTED_COUNTRIES = "allowlisted_countries";
+    public static final String BLOCKLISTED_COUNTRIES = "blocklisted_countries";
 
     public static final String EMAIL_LINK_SIGN_IN = "email_link_sign_in";
     public static final String ACTION_CODE_SETTINGS = "action_code_settings";