diff --git a/res/values/arrays.xml b/res/values/arrays.xml index f45495433fc..01a8126a3e3 100644 --- a/res/values/arrays.xml +++ b/res/values/arrays.xml @@ -1465,14 +1465,13 @@ @string/battery_app_item_hint_in_fg - - + + fr-CA - - - en-XA - ar-XB + + + fr diff --git a/res/xml/languages.xml b/res/xml/languages.xml index 5269d99523d..844b7fa7b77 100644 --- a/res/xml/languages.xml +++ b/res/xml/languages.xml @@ -32,6 +32,17 @@ android:layout="@layout/locale_order_list" /> + + + + feedsList = getUserLocaleList(); diff --git a/src/com/android/settings/localepicker/TermsOfAddressCategoryController.java b/src/com/android/settings/localepicker/TermsOfAddressCategoryController.java new file mode 100644 index 00000000000..518f670c372 --- /dev/null +++ b/src/com/android/settings/localepicker/TermsOfAddressCategoryController.java @@ -0,0 +1,99 @@ +/** + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settings.localepicker; + +import static com.android.settings.flags.Flags.termsOfAddressEnabled; + +import android.content.Context; +import android.os.LocaleList; +import android.text.TextUtils; +import android.util.Log; + +import androidx.preference.PreferenceCategory; +import androidx.preference.PreferenceScreen; + +import com.android.internal.app.LocaleStore; +import com.android.settings.R; +import com.android.settings.widget.PreferenceCategoryController; + +import java.util.Arrays; +import java.util.List; +import java.util.Locale; + +public class TermsOfAddressCategoryController extends PreferenceCategoryController { + + private static final String TAG = "TermsOfAddressCategoryController"; + private static final String KEY_CATEGORY_TERMS_OF_ADDRESS = "key_category_terms_of_address"; + private static final String KEY_TERMS_OF_ADDRESS = "key_terms_of_address"; + + public TermsOfAddressCategoryController(Context context, String key) { + super(context, key); + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + PreferenceCategory category = screen.findPreference(KEY_CATEGORY_TERMS_OF_ADDRESS); + if (category == null) { + Log.d(TAG, "displayPreference(), can not find the category."); + return; + } + + boolean isAvailable = isAvailable(); + if (isAvailable) { + TermsOfAddressController termsOfAddressController = new TermsOfAddressController( + mContext, KEY_TERMS_OF_ADDRESS); + termsOfAddressController.displayPreference(screen); + } + } + + @Override + public int getAvailabilityStatus() { + + if (!termsOfAddressEnabled()) { + return CONDITIONALLY_UNAVAILABLE; + } + + // If language is not available for system language, or if ToA does not apply to + // system language, we will hide it. + final Locale defaultLocale = Locale.getDefault(); + LocaleStore.LocaleInfo localeInfo = LocaleStore.getLocaleInfo(defaultLocale); + final List supportedLanguageList = Arrays.asList( + mContext.getResources().getStringArray( + R.array.terms_of_address_supported_languages)); + final List notSupportedLocaleList = Arrays.asList( + mContext.getResources().getStringArray( + R.array.terms_of_address_unsupported_locales)); + + final Locale locale = localeInfo.getLocale(); + final String language = locale.getLanguage(); + final String localeTag = locale.toLanguageTag(); + Log.d(TAG, "current language: " + language); + Log.d(TAG, "current locale tag: " + localeTag); + + // Supported locales: + // 1. All French is supported except fr-CA. + // 2. QA language en-XA (LTR pseudo locale), ar_XB (RTL pseudo locale). + if ((supportedLanguageList.contains(language) + && !notSupportedLocaleList.contains(localeTag)) + || LocaleList.isPseudoLocale(locale)) { + return AVAILABLE; + } + + return CONDITIONALLY_UNAVAILABLE; + } +} diff --git a/src/com/android/settings/localepicker/TermsOfAddressController.java b/src/com/android/settings/localepicker/TermsOfAddressController.java new file mode 100644 index 00000000000..18fa3ef101f --- /dev/null +++ b/src/com/android/settings/localepicker/TermsOfAddressController.java @@ -0,0 +1,61 @@ +/** + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settings.localepicker; + +import android.content.Context; +import android.text.TextUtils; +import android.util.Log; + +import androidx.preference.Preference; +import androidx.preference.PreferenceScreen; + +import com.android.internal.app.LocaleStore; +import com.android.settings.R; +import com.android.settings.core.BasePreferenceController; + +import java.util.Arrays; +import java.util.List; +import java.util.Locale; + +public class TermsOfAddressController extends BasePreferenceController { + + private static final String TAG = "TermsOfAddressController"; + private static final String KEY = "key_terms_of_address"; + + private Preference mPreference; + + public TermsOfAddressController(Context context, String preferenceKey) { + super(context, preferenceKey); + } + + @Override + public String getPreferenceKey() { + return KEY; + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + mPreference = screen.findPreference(getPreferenceKey()); + mPreference.setFragment(TermsOfAddressFragment.class.getCanonicalName()); + } + + @Override + public int getAvailabilityStatus() { + return AVAILABLE; + } +} diff --git a/src/com/android/settings/localepicker/TermsOfAddressFragment.java b/src/com/android/settings/localepicker/TermsOfAddressFragment.java new file mode 100644 index 00000000000..9484846affb --- /dev/null +++ b/src/com/android/settings/localepicker/TermsOfAddressFragment.java @@ -0,0 +1,65 @@ +/** + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settings.localepicker; + +import android.app.settings.SettingsEnums; +import android.content.Context; + +import com.android.settings.R; +import com.android.settings.dashboard.DashboardFragment; +import com.android.settings.search.BaseSearchIndexProvider; +import com.android.settingslib.core.AbstractPreferenceController; + +import java.util.ArrayList; +import java.util.List; + +public class TermsOfAddressFragment extends DashboardFragment { + + private static final String LOG_TAG = "TermsOfAddressFragment"; + private static final String KEY_NOT_SPECIFIED = "key_terms_of_address_not_specified"; + private static final String KEY_FEMININE = "key_terms_of_address_feminine"; + private static final String KEY_MASCULINE = "key_terms_of_address_masculine"; + private static final String KEY_NEUTRAL = "key_terms_of_address_neutral"; + + @Override + protected String getLogTag() { + return LOG_TAG; + } + + @Override + public int getMetricsCategory() { + return SettingsEnums.TERMS_OF_ADDRESS; + } + + @Override + protected int getPreferenceScreenResId() { + return R.xml.terms_of_address; + } + + @Override + protected List createPreferenceControllers(Context context) { + final List controllers = new ArrayList<>(); + controllers.add(new TermsOfAddressNotSpecifiedController(context, KEY_NOT_SPECIFIED)); + controllers.add(new TermsOfAddressFeminineController(context, KEY_FEMININE)); + controllers.add(new TermsOfAddressMasculineController(context, KEY_MASCULINE)); + controllers.add(new TermsOfAddressNeutralController(context, KEY_NEUTRAL)); + return controllers; + } + + public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER = + new BaseSearchIndexProvider(R.xml.terms_of_address); +} diff --git a/tests/unit/src/com/android/settings/localepicker/TermsOfAddressCategoryControllerTest.java b/tests/unit/src/com/android/settings/localepicker/TermsOfAddressCategoryControllerTest.java new file mode 100644 index 00000000000..e316b2556c6 --- /dev/null +++ b/tests/unit/src/com/android/settings/localepicker/TermsOfAddressCategoryControllerTest.java @@ -0,0 +1,84 @@ +/* + * Copyright (C) 2023 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settings.localepicker; + +import static com.android.settings.core.BasePreferenceController.AVAILABLE; +import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.spy; + +import android.app.settings.SettingsEnums; +import android.content.Context; +import android.os.Looper; + +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import org.junit.After; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.MockitoAnnotations; + +import java.util.Locale; + +@RunWith(AndroidJUnit4.class) +public class TermsOfAddressCategoryControllerTest { + + private static final String KEY_CATEGORY_TERMS_OF_ADDRESS = "key_category_terms_of_address"; + + private Context mContext; + private TermsOfAddressCategoryController mTermsOfAddressCategoryController; + private Locale mCacheLocale; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + mContext = spy(ApplicationProvider.getApplicationContext()); + + if (Looper.myLooper() == null) { + Looper.prepare(); + } + + mTermsOfAddressCategoryController = new TermsOfAddressCategoryController(mContext, + KEY_CATEGORY_TERMS_OF_ADDRESS); + mCacheLocale = Locale.getDefault(Locale.Category.FORMAT); + } + + @After + public void tearDown() throws Exception { + Locale.setDefault(mCacheLocale); + } + + @Test + public void getAvailabilityStatus_returnUnavailable() { + Locale.setDefault(Locale.forLanguageTag("fr-CA")); + + assertThat(mTermsOfAddressCategoryController.getAvailabilityStatus()).isEqualTo( + CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void getAvailabilityStatus_returnAvailable() { + Locale.setDefault(Locale.forLanguageTag("fr-FR")); + + assertThat(mTermsOfAddressCategoryController.getAvailabilityStatus()).isEqualTo( + AVAILABLE); + } +}