Merge "[Panlingual] Add device default language to suggested group"

res/values/strings.xml

@@ -491,6 +491,12 @@
     <!-- Category for the app's locale picker activity. [CHAR LIMIT=50]-->
     <string name="all_supported_app_locales_title">All languages</string>
 
+    <!-- Title for preference of the system default locale. [CHAR LIMIT=50]-->
+    <string name="preference_of_system_locale_title">System language</string>
+
+    <!-- Summary for preference of the system default locale. [CHAR LIMIT=50]-->
+    <string name="preference_of_system_locale_summary">System default - <xliff:g id="default_language" example="English (United States)">%1$s</xliff:g></string>
+
     <!-- Description for the app without any supported languages. [CHAR LIMIT=NONE]-->
     <string name="no_multiple_language_supported">The app is set to <xliff:g id="default_language" example="English (United States)">%1$s</xliff:g> by default and doesn\u2019t support multiple languages.</string>
     <!-- The title of the confirmation dialog shown when the user selects one / several languages and tries to remove them [CHAR LIMIT=60] -->

res/xml/app_locale_details.xml

@@ -28,7 +28,14 @@
 
     <PreferenceCategory
         android:key="category_key_suggested_languages"
-        android:title="@string/suggested_app_locales_title" />
+        android:title="@string/suggested_app_locales_title" >
+
+        <com.android.settingslib.widget.RadioButtonPreference
+            android:key="system_default_locale"
+            android:title="@string/preference_of_system_locale_title"
+            android:order="-10000"/>
+
+    </PreferenceCategory>
 
     <PreferenceCategory
         android:key="category_key_all_languages"

src/com/android/settings/applications/appinfo/AppLocaleDetails.java

@@ -38,8 +38,6 @@ import androidx.appcompat.app.AlertDialog;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceGroup;
 
-import com.android.internal.app.LocalePicker;
-import com.android.internal.app.LocalePicker.LocaleInfo;
 import com.android.settings.R;
 import com.android.settings.Utils;
 import com.android.settings.applications.AppInfoBase;
@@ -48,11 +46,8 @@ import com.android.settingslib.applications.AppUtils;
 import com.android.settingslib.widget.LayoutPreference;
 import com.android.settingslib.widget.RadioButtonPreference;
 
-import com.google.common.collect.Iterables;
-
 import java.util.ArrayList;
 import java.util.Collection;
-import java.util.List;
 import java.util.Locale;
 
 /**
@@ -66,13 +61,17 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
     private static final String CATEGORY_KEY_ALL_LANGUAGES =
             "category_key_all_languages";
     private static final String KEY_APP_DESCRIPTION = "app_locale_description";
+    @VisibleForTesting
+    static final String KEY_SYSTEM_DEFAULT_LOCALE = "system_default_locale";
 
     private boolean mCreated = false;
-    private AppLocaleDetailsHelper mAppLocaleDetailsHelper;
+    @VisibleForTesting
+    AppLocaleDetailsHelper mAppLocaleDetailsHelper;
 
     private PreferenceGroup mGroupOfSuggestedLocales;
     private PreferenceGroup mGroupOfSupportedLocales;
     private LayoutPreference mPrefOfDescription;
+    private RadioButtonPreference mDefaultPreference;
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
@@ -85,6 +84,10 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
         mGroupOfSupportedLocales =
                 getPreferenceScreen().findPreference(CATEGORY_KEY_ALL_LANGUAGES);
         mPrefOfDescription = getPreferenceScreen().findPreference(KEY_APP_DESCRIPTION);
+
+        mDefaultPreference = (RadioButtonPreference) getPreferenceScreen()
+                .findPreference(KEY_SYSTEM_DEFAULT_LOCALE);
+        mDefaultPreference.setOnClickListener(this);
     }
 
     // Override here so we don't have an empty screen
@@ -104,30 +107,43 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
         // Update Locales first, before refresh ui.
         mAppLocaleDetailsHelper.handleAllLocalesData();
         super.onResume();
+        mDefaultPreference.setSummary(Locale.getDefault().getDisplayName(Locale.getDefault()));
     }
 
     @Override
     protected boolean refreshUi() {
+        refreshUiInternal();
+        return true;
+    }
+
+    @VisibleForTesting
+    void refreshUiInternal() {
         if (mAppLocaleDetailsHelper.getSupportedLocales().isEmpty()) {
             Log.d(TAG, "No supported language.");
             mGroupOfSuggestedLocales.setVisible(false);
             mGroupOfSupportedLocales.setVisible(false);
             mPrefOfDescription.setVisible(true);
             TextView description = (TextView) mPrefOfDescription.findViewById(R.id.description);
-            Locale locale = mAppLocaleDetailsHelper.getCurrentSystemLocales().get(0);
             description.setText(getContext().getString(R.string.no_multiple_language_supported,
-                    locale.getDisplayName(locale)));
+                    Locale.getDefault().getDisplayName(Locale.getDefault())));
-            return true;
+            return;
         }
-
+        resetLocalePreferences();
-        mGroupOfSuggestedLocales.removeAll();
-        mGroupOfSupportedLocales.removeAll();
         Locale appLocale = AppLocaleDetailsHelper.getAppDefaultLocale(getContext(), mPackageName);
+        // Sets up default locale preference.
+        mGroupOfSuggestedLocales.addPreference(mDefaultPreference);
+        mDefaultPreference.setChecked(appLocale == null);
+        // Sets up suggested locales of per app.
         setLanguagesPreference(mGroupOfSuggestedLocales,
                 mAppLocaleDetailsHelper.getSuggestedLocales(), appLocale);
+        // Sets up supported locales of per app.
         setLanguagesPreference(mGroupOfSupportedLocales,
                 mAppLocaleDetailsHelper.getSupportedLocales(), appLocale);
-        return true;
+    }
+
+    private void resetLocalePreferences() {
+        mGroupOfSuggestedLocales.removeAll();
+        mGroupOfSupportedLocales.removeAll();
     }
 
     @Override
@@ -142,7 +158,12 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
 
     @Override
     public void onRadioButtonClicked(RadioButtonPreference pref) {
-        mAppLocaleDetailsHelper.setAppDefaultLocale(pref.getKey());
+        String key = pref.getKey();
+        if (KEY_SYSTEM_DEFAULT_LOCALE.equals(key)) {
+            mAppLocaleDetailsHelper.setAppDefaultLocale(LocaleList.forLanguageTags(""));
+        } else {
+            mAppLocaleDetailsHelper.setAppDefaultLocale(key);
+        }
         refreshUi();
     }
 
@@ -180,7 +201,13 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
     public static CharSequence getSummary(Context context, String packageName) {
         Locale appLocale =
                 AppLocaleDetailsHelper.getAppDefaultLocale(context, packageName);
-        return appLocale == null ? "" : appLocale.getDisplayName(appLocale);
+        if (appLocale == null) {
+            Locale systemLocale = Locale.getDefault();
+            return context.getString(R.string.preference_of_system_locale_summary,
+                    systemLocale.getDisplayName(systemLocale));
+        } else {
+            return appLocale.getDisplayName(appLocale);
+        }
     }
 
     private void setLanguagesPreference(PreferenceGroup group,
@@ -190,9 +217,15 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
         }
 
         for (Locale locale : locales) {
+            if (locale == null) {
+                continue;
+            }
+
             RadioButtonPreference pref = new RadioButtonPreference(getContext());
             pref.setTitle(locale.getDisplayName(locale));
             pref.setKey(locale.toLanguageTag());
+            // Will never be checked if appLocale is null
+            // aka if there is no per-app locale
             pref.setChecked(locale.equals(appLocale));
             pref.setOnClickListener(this);
             group.addPreference(pref);
@@ -206,14 +239,17 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
         private TelephonyManager mTelephonyManager;
         private LocaleManager mLocaleManager;
 
-        private Collection<Locale> mSuggestedLocales = new ArrayList<>();
+        private Collection<Locale> mProcessedSuggestedLocales = new ArrayList<>();
-        private Collection<Locale> mSupportedLocales = new ArrayList<>();
+        private Collection<Locale> mProcessedSupportedLocales = new ArrayList<>();
+
+        private Collection<Locale> mAppSupportedLocales = new ArrayList<>();
 
         AppLocaleDetailsHelper(Context context, String packageName) {
             mContext = context;
             mPackageName = packageName;
             mTelephonyManager = context.getSystemService(TelephonyManager.class);
             mLocaleManager = context.getSystemService(LocaleManager.class);
+            mAppSupportedLocales = getAppSupportedLocales();
         }
 
         /** Handle suggested and supported locales for UI display. */
@@ -225,49 +261,47 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
 
         /** Gets suggested locales in the app. */
         public Collection<Locale> getSuggestedLocales() {
-            return mSuggestedLocales;
+            return mProcessedSuggestedLocales;
         }
 
         /** Gets supported locales in the app. */
         public Collection<Locale> getSupportedLocales() {
-            return mSupportedLocales;
+            return mProcessedSupportedLocales;
         }
 
         @VisibleForTesting
         void handleSuggestedLocales() {
-            LocaleList currentSystemLocales = getCurrentSystemLocales();
             Locale appLocale = getAppDefaultLocale(mContext, mPackageName);
+            // 1st locale in suggested languages group.
+            for (Locale supportedlocale : mAppSupportedLocales) {
+                if (compareLocale(supportedlocale, appLocale)) {
+                    mProcessedSuggestedLocales.add(appLocale);
+                    break;
+                }
+            }
+
+            // 2nd and 3rd locale in suggested languages group.
             String simCountry = mTelephonyManager.getSimCountryIso().toUpperCase(Locale.US);
             String networkCountry = mTelephonyManager.getNetworkCountryIso().toUpperCase(Locale.US);
-            // 1st locale in suggested languages group.
+            mAppSupportedLocales.forEach(supportedlocale -> {
-            if (appLocale != null) {
+                String localeCountry = supportedlocale.getCountry().toUpperCase(Locale.US);
-                mSuggestedLocales.add(appLocale);
+                if (!compareLocale(supportedlocale, appLocale)
-            }
-            // 2nd locale in suggested languages group.
-            final List<LocaleInfo> localeInfos = LocalePicker.getAllAssetLocales(mContext, false);
-            for (LocaleInfo localeInfo : localeInfos) {
-                Locale locale = localeInfo.getLocale();
-                String localeCountry = locale.getCountry().toUpperCase(Locale.US);
-                if (!compareLocale(locale, appLocale)
                         && isCountrySuggestedLocale(localeCountry, simCountry, networkCountry)) {
-                    mSuggestedLocales.add(locale);
+                    mProcessedSuggestedLocales.add(supportedlocale);
                 }
-            }
+            });
+
             // Other locales in suggested languages group.
-            for (int i = 0; i < currentSystemLocales.size(); i++) {
+            Collection<Locale> supportedSystemLocales = new ArrayList<>();
-                Locale locale = currentSystemLocales.get(i);
+            getCurrentSystemLocales().forEach(systemLocale -> {
-                boolean isInSuggestedLocales = false;
+                mAppSupportedLocales.forEach(supportedLocale -> {
-                for (int j = 0; j < mSuggestedLocales.size(); j++) {
+                    if (compareLocale(systemLocale, supportedLocale)) {
-                    Locale suggestedLocale = Iterables.get(mSuggestedLocales, j);
+                        supportedSystemLocales.add(supportedLocale);
-                    if (compareLocale(locale, suggestedLocale)) {
-                        isInSuggestedLocales = true;
-                        break;
                     }
-                }
+                });
-                if (!isInSuggestedLocales) {
+            });
-                    mSuggestedLocales.add(locale);
+            supportedSystemLocales.removeAll(mProcessedSuggestedLocales);
-                }
+            mProcessedSuggestedLocales.addAll(supportedSystemLocales);
-            }
         }
 
         @VisibleForTesting
@@ -290,26 +324,34 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
 
         @VisibleForTesting
         void handleSupportedLocales() {
-            LocaleList localeList = getPackageLocales();
+            mProcessedSupportedLocales.addAll(mAppSupportedLocales);
-            if (localeList == null) {
-                String[] languages = getAssetSystemLocales();
-                for (String language : languages) {
-                    mSupportedLocales.add(Locale.forLanguageTag(language));
-                }
-            } else {
-                for (int i = 0; i < localeList.size(); i++) {
-                    mSupportedLocales.add(localeList.get(i));
-                }
-            }
 
-            if (mSuggestedLocales != null || !mSuggestedLocales.isEmpty()) {
+            if (mProcessedSuggestedLocales != null || !mProcessedSuggestedLocales.isEmpty()) {
-                mSupportedLocales.removeAll(mSuggestedLocales);
+                mProcessedSuggestedLocales.retainAll(mProcessedSupportedLocales);
+                mProcessedSupportedLocales.removeAll(mProcessedSuggestedLocales);
             }
         }
 
         private void clearLocalesData() {
-            mSuggestedLocales.clear();
+            mProcessedSuggestedLocales.clear();
-            mSupportedLocales.clear();
+            mProcessedSupportedLocales.clear();
+        }
+
+        private Collection<Locale> getAppSupportedLocales() {
+            Collection<Locale> appSupportedLocales = new ArrayList<>();
+            LocaleList localeList = getPackageLocales();
+
+            if (localeList != null && localeList.size() > 0) {
+                for (int i = 0; i < localeList.size(); i++) {
+                    appSupportedLocales.add(localeList.get(i));
+                }
+            } else {
+                String[] languages = getAssetLocales();
+                for (String language : languages) {
+                    appSupportedLocales.add(Locale.forLanguageTag(language));
+                }
+            }
+            return appSupportedLocales;
         }
 
         /** Gets per app's default locale */
@@ -317,8 +359,8 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
             LocaleManager localeManager = context.getSystemService(LocaleManager.class);
             try {
                 LocaleList localeList = (localeManager == null)
-                        ? new LocaleList() : localeManager.getApplicationLocales(packageName);
+                        ? null : localeManager.getApplicationLocales(packageName);
-                return localeList.isEmpty() ? null : localeList.get(0);
+                return localeList == null ? null : localeList.get(0);
             } catch (IllegalArgumentException e) {
                 Log.w(TAG, "package name : " + packageName + " is not correct. " + e);
             }
@@ -344,12 +386,17 @@ public class AppLocaleDetails extends AppInfoBase implements RadioButtonPreferen
         }
 
         @VisibleForTesting
-        LocaleList getCurrentSystemLocales() {
+        Collection<Locale> getCurrentSystemLocales() {
-            return Resources.getSystem().getConfiguration().getLocales();
+            LocaleList localeList = Resources.getSystem().getConfiguration().getLocales();
+            Collection<Locale> systemLocales = new ArrayList<>();
+            for (int i = 0; i < localeList.size(); i++) {
+                systemLocales.add(localeList.get(i));
+            }
+            return systemLocales;
         }
 
         @VisibleForTesting
-        String[] getAssetSystemLocales() {
+        String[] getAssetLocales() {
             try {
                 PackageManager packageManager = mContext.getPackageManager();
                 return packageManager.getResourcesForApplication(

tests/unit/src/com/android/settings/applications/appinfo/AppLocaleDetailsTest.java

@@ -20,6 +20,7 @@ import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.app.LocaleManager;
@@ -32,7 +33,7 @@ import androidx.test.annotation.UiThreadTest;
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 
-import com.google.common.collect.Iterables;
+import com.android.settingslib.widget.RadioButtonPreference;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -40,8 +41,14 @@ import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 
+import java.util.ArrayList;
+import java.util.Collection;
 import java.util.Locale;
 
+/**
+ * Unittest for ApplocaleDetails
+ * TODO Need to add a unittest for the UI preference component.
+ */
 @RunWith(AndroidJUnit4.class)
 public class AppLocaleDetailsTest {
     private static final String APP_PACKAGE_NAME = "app_package_name";
@@ -52,7 +59,7 @@ public class AppLocaleDetailsTest {
     private LocaleManager mLocaleManager;
 
     private Context mContext;
-    private LocaleList mSystemLocales;
+    private Collection<Locale> mSystemLocales;
     private LocaleList mAppLocale;
     private String[] mAssetLocales;
     private LocaleList mPackageLocales;
@@ -69,12 +76,48 @@ public class AppLocaleDetailsTest {
         when(mContext.getSystemService(LocaleManager.class)).thenReturn(mLocaleManager);
 
         setupInitialLocales(
-                /* appLocale= */ "en",
+                /* appLocale= */ "en-gb",
                 /* simCountry= */ "tw",
                 /* networkCountry= */ "jp",
-                /* systemLocales= */ "en, uk, jp, ne",
+                /* systemLocales= */ "en-gb, ru, ja-jp, ne, zh-tw",
-                /* packageLocales= */ "pa, cn, tw, en",
+                /* packageLocales= */ "pa, cn, zh-tw, en-gb, ja-jp",
-                /* assetLocales= */ new String[]{"en", "ne", "ms", "pa"});
+                /* assetLocales= */ new String[]{"en-gb", "ne", "ms", "pa", "zh-tw", "ja-jp"});
+    }
+
+    @Test
+    @UiThreadTest
+    public void onRadioButtonClicked_setCurrentLocaleToSystem() {
+        AppLocaleDetails appLocaleDetails = new AppLocaleDetails() {
+            @Override
+            void refreshUiInternal() {}
+        };
+        DummyAppLocaleDetailsHelper helper =
+                spy(new DummyAppLocaleDetailsHelper(mContext, APP_PACKAGE_NAME));
+        appLocaleDetails.mAppLocaleDetailsHelper = helper;
+        RadioButtonPreference pref = new RadioButtonPreference(mContext);
+        pref.setKey(AppLocaleDetails.KEY_SYSTEM_DEFAULT_LOCALE);
+
+        appLocaleDetails.onRadioButtonClicked(pref);
+
+        verify(helper).setAppDefaultLocale(LocaleList.forLanguageTags(""));
+    }
+
+    @Test
+    @UiThreadTest
+    public void onRadioButtonClicked_setCurrentLocaleForUserSelected() {
+        AppLocaleDetails appLocaleDetails = new AppLocaleDetails() {
+            @Override
+            void refreshUiInternal() {}
+        };
+        DummyAppLocaleDetailsHelper helper =
+                spy(new DummyAppLocaleDetailsHelper(mContext, APP_PACKAGE_NAME));
+        appLocaleDetails.mAppLocaleDetailsHelper = helper;
+        RadioButtonPreference pref = new RadioButtonPreference(mContext);
+        pref.setKey("en");
+
+        appLocaleDetails.onRadioButtonClicked(pref);
+
+        verify(helper).setAppDefaultLocale("en");
     }
 
     @Test
@@ -90,7 +133,7 @@ public class AppLocaleDetailsTest {
 
     @Test
     @UiThreadTest
-    public void handleAllLocalesData_1stLocaleOfSuggestedLocaleListIsAppLocale() {
+    public void handleAllLocalesData_1stLocaleIsAppLocaleAndHasSimAndNetwork() {
         Locale simCountryLocale = new Locale("zh", "TW");
         Locale networkCountryLocale = new Locale("ja", "JP");
         DummyAppLocaleDetailsHelper helper =
@@ -98,36 +141,122 @@ public class AppLocaleDetailsTest {
 
         helper.handleAllLocalesData();
 
-        Locale locale = Iterables.get(helper.getSuggestedLocales(), 0);
+        Collection<Locale> suggestedLocales = helper.getSuggestedLocales();
+        Locale locale = suggestedLocales.iterator().next();
         assertTrue(locale.equals(mAppLocale.get(0)));
-        assertTrue(helper.getSuggestedLocales().contains(simCountryLocale));
+        assertTrue(suggestedLocales.contains(simCountryLocale));
-        assertTrue(helper.getSuggestedLocales().contains(networkCountryLocale));
+        assertTrue(suggestedLocales.contains(networkCountryLocale));
     }
 
     @Test
     @UiThreadTest
-    public void handleAllLocalesData_withoutAppLocale_1stSuggestedLocaleIsSimCountryLocale() {
+    public void
-        Locale simCountryLocale = new Locale("zh", "TW");
+            handleAllLocalesData_noAppAndNoSupportedSimLocale_1stSuggestedLocaleIsAssetLocale() {
+        Locale firstAssetLocale = new Locale("en", "GB");
         setupInitialLocales(
                 /* appLocale= */ "",
                 /* simCountry= */ "tw",
                 /* networkCountry= */ "",
-                /* systemLocales= */ "en, uk, jp, ne",
+                /* systemLocales= */ "en-gb, ru, ja-jp, ne, zh-tw",
                 /* packageLocales= */ "",
-                /* assetLocales= */ new String[]{});
+                /* assetLocales= */ new String[]{"en-gb", "ne", "ms", "pa", "ja-jp"});
         DummyAppLocaleDetailsHelper helper =
                 new DummyAppLocaleDetailsHelper(mContext, APP_PACKAGE_NAME);
 
         helper.handleAllLocalesData();
 
-        Locale locale = Iterables.get(helper.getSuggestedLocales(), 0);
+        Collection<Locale> suggestedLocales = helper.getSuggestedLocales();
-        assertTrue(locale.equals(simCountryLocale));
+        Locale locale = suggestedLocales.iterator().next();
-        assertFalse(helper.getSuggestedLocales().contains(mAppLocale.get(0)));
+        assertTrue(locale.equals(firstAssetLocale));
     }
 
     @Test
     @UiThreadTest
-    public void handleAllLocalesData_withoutAppLocale_1stSuggestedLocaleIsNetworkCountryLocale() {
+    public void handleAllLocalesData_noAppButHasSupportedSimLocale_1stSuggestedLocaleIsSim() {
+        Locale simLocale = new Locale("zh", "tw");
+        setupInitialLocales(
+                /* appLocale= */ "",
+                /* simCountry= */ "tw",
+                /* networkCountry= */ "",
+                /* systemLocales= */ "en-gb, ru, ja-jp, ne, zh-tw",
+                /* packageLocales= */ "",
+                /* assetLocales= */ new String[]{"en-gb", "ne", "ms", "pa", "ja-jp", "zh-tw"});
+        DummyAppLocaleDetailsHelper helper =
+                new DummyAppLocaleDetailsHelper(mContext, APP_PACKAGE_NAME);
+
+        helper.handleAllLocalesData();
+
+        Collection<Locale> suggestedLocales = helper.getSuggestedLocales();
+        Locale locale = suggestedLocales.iterator().next();
+        assertTrue(locale.equals(simLocale));
+    }
+
+    @Test
+    @UiThreadTest
+    public void
+            handleAllLocalesData_noAppButHasSupportedNetworkLocale_1stSuggestedLocaleIsNetwork() {
+        Locale networkLocale = new Locale("ja", "JP");
+        setupInitialLocales(
+                /* appLocale= */ "",
+                /* simCountry= */ "",
+                /* networkCountry= */ "jp",
+                /* systemLocales= */ "en-gb, ru, ja-jp, ne, zh-tw",
+                /* packageLocales= */ "",
+                /* assetLocales= */ new String[]{"en-gb", "ne", "ms", "pa", "ja-jp"});
+        DummyAppLocaleDetailsHelper helper =
+                new DummyAppLocaleDetailsHelper(mContext, APP_PACKAGE_NAME);
+
+        helper.handleAllLocalesData();
+
+        Collection<Locale> suggestedLocales = helper.getSuggestedLocales();
+        Locale locale = suggestedLocales.iterator().next();
+        assertTrue(locale.equals(networkLocale));
+    }
+
+    @Test
+    @UiThreadTest
+    public void handleAllLocalesData_noAppSimOrNetworkLocale_suggestedLocalesHasSystemLocale() {
+        setupInitialLocales(
+                /* appLocale= */ "",
+                /* simCountry= */ "",
+                /* networkCountry= */ "",
+                /* systemLocales= */ "en-gb, ru, ja-jp, ne, zh-tw",
+                /* packageLocales= */ "",
+                /* assetLocales= */ new String[]{"en-gb", "ne", "ms", "pa", "zh-tw", "ja-jp"});
+        DummyAppLocaleDetailsHelper helper =
+                new DummyAppLocaleDetailsHelper(mContext, APP_PACKAGE_NAME);
+        helper.handleAllLocalesData();
+
+        Collection<Locale> suggestedLocales = helper.getSuggestedLocales();
+        assertTrue(suggestedLocales.contains(Locale.forLanguageTag("ne")));
+        // ru language is not present in the asset locales
+        assertFalse(suggestedLocales.contains(Locale.forLanguageTag("ru")));
+    }
+
+    @Test
+    @UiThreadTest
+    public void handleAllLocalesData_noAppButHasSimAndNetworkLocale_1stLocaleIsSimLocale() {
+        Locale simCountryLocale = new Locale("zh", "TW");
+        setupInitialLocales(
+                /* appLocale= */ "",
+                /* simCountry= */ "tw",
+                /* networkCountry= */ "jp",
+                /* systemLocales= */ "en-gb, ru, ja-jp, ne, zh-tw",
+                /* packageLocales= */ "",
+                /* assetLocales= */ new String[]{"en-gb", "ne", "ms", "pa", "zh-tw", "ja-jp"});
+
+        DummyAppLocaleDetailsHelper helper =
+                new DummyAppLocaleDetailsHelper(mContext, APP_PACKAGE_NAME);
+        helper.handleAllLocalesData();
+
+        Collection<Locale> suggestedLocales = helper.getSuggestedLocales();
+        Locale locale = suggestedLocales.iterator().next();
+        assertTrue(locale.equals(simCountryLocale));
+    }
+
+    @Test
+    @UiThreadTest
+    public void handleAllLocalesData_noSupportedLocale_noSuggestedLocales() {
         Locale networkCountryLocale = new Locale("en", "GB");
         setupInitialLocales(
                 /* appLocale= */ "",
@@ -141,28 +270,8 @@ public class AppLocaleDetailsTest {
 
         helper.handleAllLocalesData();
 
-        Locale locale = Iterables.get(helper.getSuggestedLocales(), 0);
+        Collection<Locale> suggestedLocales = helper.getSuggestedLocales();
-        assertTrue(locale.equals(networkCountryLocale));
+        assertTrue(suggestedLocales.size() == 0);
-        assertFalse(helper.getSuggestedLocales().contains(mAppLocale.get(0)));
-    }
-
-    @Test
-    @UiThreadTest
-    public void handleAllLocalesData_noAppAndSimNetworkLocale_1stLocaleIsFirstOneInSystemLocales() {
-        setupInitialLocales(
-                /* appLocale= */ "",
-                /* simCountry= */ "",
-                /* networkCountry= */ "",
-                /* systemLocales= */ "en, uk, jp, ne",
-                /* packageLocales= */ "",
-                /* assetLocales= */ new String[]{});
-        DummyAppLocaleDetailsHelper helper =
-                new DummyAppLocaleDetailsHelper(mContext, APP_PACKAGE_NAME);
-
-        helper.handleAllLocalesData();
-
-        Locale locale = Iterables.get(helper.getSuggestedLocales(), 0);
-        assertTrue(locale.equals(mSystemLocales.get(0)));
     }
 
     @Test
@@ -180,8 +289,10 @@ public class AppLocaleDetailsTest {
 
         helper.handleAllLocalesData();
 
-        Locale locale = Iterables.get(helper.getSuggestedLocales(), 0);
+        Collection<Locale> suggestedLocales = helper.getSuggestedLocales();
-        assertTrue(locale.equals(mSystemLocales.get(0)));
+        Locale locale = suggestedLocales.iterator().next();
+        Locale systemLocale = mSystemLocales.iterator().next();
+        assertTrue(locale.equals(systemLocale));
     }
 
     @Test
@@ -248,15 +359,23 @@ public class AppLocaleDetailsTest {
             String packageLocales,
             String[] assetLocales) {
         mAppLocale = LocaleList.forLanguageTags(appLocale);
-        mSystemLocales = LocaleList.forLanguageTags(systemLocales);
+        // forLanguageTags does not filter space to the input string. If there is any space included
+        // in string, this will make locale fail to generate.
+        systemLocales = systemLocales.replaceAll("\\s+", "");
+        LocaleList listOfSystemLocales = LocaleList.forLanguageTags(systemLocales);
+        mSystemLocales = new ArrayList<>();
+        for (int i = 0; i < listOfSystemLocales.size(); i++) {
+            mSystemLocales.add(listOfSystemLocales.get(i));
+        }
         mAssetLocales = assetLocales;
+        packageLocales = packageLocales.replaceAll("\\s+", "");
         mPackageLocales = LocaleList.forLanguageTags(packageLocales);
         when(mTelephonyManager.getSimCountryIso()).thenReturn(simCountry);
         when(mTelephonyManager.getNetworkCountryIso()).thenReturn(networkCountry);
         when(mLocaleManager.getApplicationLocales(anyString())).thenReturn(mAppLocale);
     }
 
-    private class DummyAppLocaleDetailsHelper
+    public class DummyAppLocaleDetailsHelper
             extends AppLocaleDetails.AppLocaleDetailsHelper {
 
         DummyAppLocaleDetailsHelper(Context context, String packageName) {
@@ -264,12 +383,12 @@ public class AppLocaleDetailsTest {
         }
 
         @Override
-        String[] getAssetSystemLocales() {
+        String[] getAssetLocales() {
             return mAssetLocales;
         }
 
         @Override
-        LocaleList getCurrentSystemLocales() {
+        Collection<Locale> getCurrentSystemLocales() {
             return mSystemLocales;
         }