diff --git a/res/layout/locale_drag_cell.xml b/res/layout/locale_drag_cell.xml index 7b932f39a02..47bf70a473e 100644 --- a/res/layout/locale_drag_cell.xml +++ b/res/layout/locale_drag_cell.xml @@ -56,6 +56,17 @@ android:layout_toStartOf="@+id/dragHandle" android:layout_below="@id/label"/> + + Languages + + Preferred language order + + + System language + Remove @@ -414,13 +420,13 @@ Preferred Language - App Languages + App languages Set the language for each app - App Language + App language Suggested languages @@ -443,6 +449,18 @@ Only apps that support language selection are shown here. + + Your system, apps, and websites use the first supported language from your preferred languages. + + + To select a language for each app, go to app language settings. + + + Learn more about languages + + + https://support.google.com/android?p=per_language_app_settings + Remove selected language? @@ -458,7 +476,7 @@ Keep at least one preferred language - May not be available in some apps + Not available as system language Move up @@ -1064,11 +1082,11 @@ Fingerprint added - Fingerprint Unlock improves the more you use it to unlock your tablet or verify it\u2019s you in apps + Now you can use your fingerprint to unlock your tablet or verify it\u2019s you, like when you sign in to apps - Fingerprint Unlock improves the more you use it to unlock your device or verify it\u2019s you in apps + Now you can use your fingerprint to unlock your device or verify it\u2019s you, like when you sign in to apps - Fingerprint Unlock improves the more you use it to unlock your phone or verify it\u2019s you in apps + Now you can use your fingerprint to unlock your phone or verify it\u2019s you, like when you sign in to apps Do it later @@ -1870,6 +1888,21 @@ Increase NFC stack logging level + + NFC verbose vendor debug log + + Include additional device-specific vendor logs in bugreports, which may contain private information. + + NFC NCI unfiltered snoop log + + Capture detail NFC packets, which may contain private information. + + Restart Device? + + Detail NFC logging is intended for development purposes only. Additional NFC data is included in bug reports, which may contain private information. Restart your device to change this setting. + + Restart + Cast diff --git a/res/xml/development_settings.xml b/res/xml/development_settings.xml index 19c12091400..a0640f5be70 100644 --- a/res/xml/development_settings.xml +++ b/res/xml/development_settings.xml @@ -402,6 +402,16 @@ android:title="@string/nfc_stack_debuglog_title" android:summary="@string/nfc_stack_debuglog_summary" /> + + + + + + + + + + + + + + + + + diff --git a/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragmentForSetupWizard.java b/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragmentForSetupWizard.java index cb5ca759df1..12a988603d8 100644 --- a/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragmentForSetupWizard.java +++ b/src/com/android/settings/accessibility/ToggleScreenMagnificationPreferenceFragmentForSetupWizard.java @@ -52,11 +52,17 @@ public class ToggleScreenMagnificationPreferenceFragmentForSetupWizard */ private void hidePreferenceSettingComponents() { // Intro - mTopIntroPreference.setVisible(false); + if (mTopIntroPreference != null) { + mTopIntroPreference.setVisible(false); + } // Setting of magnification type - mSettingsPreference.setVisible(false); + if (mSettingsPreference != null) { + mSettingsPreference.setVisible(false); + } // Setting of following typing - mFollowingTypingSwitchPreference.setVisible(false); + if (mFollowingTypingSwitchPreference != null) { + mFollowingTypingSwitchPreference.setVisible(false); + } } @Override diff --git a/src/com/android/settings/applications/AppLocaleUtil.java b/src/com/android/settings/applications/AppLocaleUtil.java index 8c3671ed943..79406f05224 100644 --- a/src/com/android/settings/applications/AppLocaleUtil.java +++ b/src/com/android/settings/applications/AppLocaleUtil.java @@ -100,8 +100,8 @@ public class AppLocaleUtil { */ public static boolean isAppLocaleSupported(Context context, String packageName) { LocaleList localeList = getPackageLocales(context, packageName); - if (localeList != null && localeList.size() > 0) { - return true; + if (localeList != null) { + return localeList.size() > 0; } if (FeatureFlagUtils.isEnabled( diff --git a/src/com/android/settings/applications/appinfo/AppLocalePreferenceController.java b/src/com/android/settings/applications/appinfo/AppLocalePreferenceController.java index f406d8763ff..6bf94a61200 100644 --- a/src/com/android/settings/applications/appinfo/AppLocalePreferenceController.java +++ b/src/com/android/settings/applications/appinfo/AppLocalePreferenceController.java @@ -22,7 +22,6 @@ import android.content.pm.PackageManager; import android.content.pm.ResolveInfo; import android.net.Uri; import android.text.TextUtils; -import android.util.FeatureFlagUtils; import android.util.Log; import androidx.annotation.VisibleForTesting; @@ -51,9 +50,7 @@ public class AppLocalePreferenceController extends AppInfoPreferenceControllerBa @Override public int getAvailabilityStatus() { - boolean isFeatureOn = FeatureFlagUtils - .isEnabled(mContext, FeatureFlagUtils.SETTINGS_APP_LANGUAGE_SELECTION); - return isFeatureOn && canDisplayLocaleUi() ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; + return canDisplayLocaleUi() ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; } @Override diff --git a/src/com/android/settings/applications/appinfo/ManageAppLocalePreferenceController.java b/src/com/android/settings/applications/appinfo/ManageAppLocalePreferenceController.java deleted file mode 100644 index aa12b626eb7..00000000000 --- a/src/com/android/settings/applications/appinfo/ManageAppLocalePreferenceController.java +++ /dev/null @@ -1,40 +0,0 @@ -/* - * Copyright (C) 2021 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.applications.appinfo; - -import android.content.Context; -import android.util.FeatureFlagUtils; - -import com.android.settings.core.BasePreferenceController; - -/** - * A controller to update current locale information of application - * and a entry to launch {@link ManageApplications}. - * TODO(209775925) After feature release, this class may be removed. - */ -public class ManageAppLocalePreferenceController extends BasePreferenceController { - public ManageAppLocalePreferenceController(Context context, String key) { - super(context, key); - } - - @Override - public int getAvailabilityStatus() { - return FeatureFlagUtils - .isEnabled(mContext, FeatureFlagUtils.SETTINGS_APP_LANGUAGE_SELECTION) - ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; - } -} diff --git a/src/com/android/settings/biometrics/fingerprint/SetupFingerprintEnrollFindSensor.java b/src/com/android/settings/biometrics/fingerprint/SetupFingerprintEnrollFindSensor.java index 7256511d2e6..1ae5daee348 100644 --- a/src/com/android/settings/biometrics/fingerprint/SetupFingerprintEnrollFindSensor.java +++ b/src/com/android/settings/biometrics/fingerprint/SetupFingerprintEnrollFindSensor.java @@ -77,7 +77,7 @@ public class SetupFingerprintEnrollFindSensor extends FingerprintEnrollFindSenso @NonNull public AlertDialog.Builder onCreateDialogBuilder() { - return new AlertDialog.Builder(getContext()) + return new AlertDialog.Builder(getActivity(), R.style.GlifV2ThemeAlertDialog) .setTitle(R.string.setup_fingerprint_enroll_skip_title) .setPositiveButton(R.string.skip_anyway_button_label, this) .setNegativeButton(R.string.go_back_button_label, this) diff --git a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java index d92fb7fd99b..210d0115334 100644 --- a/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java +++ b/src/com/android/settings/development/DevelopmentSettingsDashboardFragment.java @@ -81,7 +81,8 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra implements OnMainSwitchChangeListener, OemUnlockDialogHost, AdbDialogHost, AdbClearKeysDialogHost, LogPersistDialogHost, BluetoothRebootDialog.OnRebootDialogListener, - AbstractBluetoothPreferenceController.Callback { + AbstractBluetoothPreferenceController.Callback, + NfcRebootDialog.OnNfcRebootDialogConfirmedListener { private static final String TAG = "DevSettingsDashboard"; @@ -299,10 +300,19 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra final BluetoothLeAudioHwOffloadPreferenceController leAudioController = getDevelopmentOptionsController( BluetoothLeAudioHwOffloadPreferenceController.class); + final NfcSnoopLogPreferenceController nfcSnoopLogController = + getDevelopmentOptionsController( + NfcSnoopLogPreferenceController.class); + final NfcVerboseVendorLogPreferenceController nfcVerboseLogController = + getDevelopmentOptionsController( + NfcVerboseVendorLogPreferenceController.class); // If hardware offload isn't default value, we must reboot after disable // developer options. Show a dialog for the user to confirm. if ((a2dpController == null || a2dpController.isDefaultValue()) - && (leAudioController == null || leAudioController.isDefaultValue())) { + && (leAudioController == null || leAudioController.isDefaultValue()) + && (nfcSnoopLogController == null || nfcSnoopLogController.isDefaultValue()) + && (nfcVerboseLogController == null + || nfcVerboseLogController.isDefaultValue())) { disableDeveloperOptions(); } else { DisableDevSettingsDialogFragment.show(this /* host */); @@ -395,6 +405,28 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra leAudioFeatureController.onRebootDialogCanceled(); } + @Override + public void onNfcRebootDialogConfirmed() { + final NfcSnoopLogPreferenceController controller = + getDevelopmentOptionsController(NfcSnoopLogPreferenceController.class); + controller.onNfcRebootDialogConfirmed(); + + final NfcVerboseVendorLogPreferenceController vendorLogController = + getDevelopmentOptionsController(NfcVerboseVendorLogPreferenceController.class); + vendorLogController.onNfcRebootDialogConfirmed(); + } + + @Override + public void onNfcRebootDialogCanceled() { + final NfcSnoopLogPreferenceController controller = + getDevelopmentOptionsController(NfcSnoopLogPreferenceController.class); + controller.onNfcRebootDialogCanceled(); + + final NfcVerboseVendorLogPreferenceController vendorLogController = + getDevelopmentOptionsController(NfcVerboseVendorLogPreferenceController.class); + vendorLogController.onNfcRebootDialogCanceled(); + } + @Override public void onActivityResult(int requestCode, int resultCode, Intent data) { boolean handledResult = false; @@ -555,6 +587,8 @@ public class DevelopmentSettingsDashboardFragment extends RestrictedDashboardFra controllers.add(new BluetoothLeAudioHwOffloadPreferenceController(context, fragment)); controllers.add(new BluetoothMaxConnectedAudioDevicesPreferenceController(context)); controllers.add(new NfcStackDebugLogPreferenceController(context)); + controllers.add(new NfcSnoopLogPreferenceController(context, fragment)); + controllers.add(new NfcVerboseVendorLogPreferenceController(context, fragment)); controllers.add(new ShowTapsPreferenceController(context)); controllers.add(new PointerLocationPreferenceController(context)); controllers.add(new ShowSurfaceUpdatesPreferenceController(context)); diff --git a/src/com/android/settings/development/NfcRebootDialog.java b/src/com/android/settings/development/NfcRebootDialog.java new file mode 100644 index 00000000000..7d9890ee07c --- /dev/null +++ b/src/com/android/settings/development/NfcRebootDialog.java @@ -0,0 +1,99 @@ +/* + * Copyright 2022 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.development; + +import android.app.Dialog; +import android.app.settings.SettingsEnums; +import android.content.DialogInterface; +import android.os.Bundle; +import android.os.PowerManager; + +import androidx.appcompat.app.AlertDialog; +import androidx.fragment.app.FragmentManager; + +import com.android.settings.R; +import com.android.settings.core.instrumentation.InstrumentedDialogFragment; + +/** + * The NFC log type switch should reboot the device to take effect, + * the dialog is to ask the user to reboot the device. + */ +public class NfcRebootDialog extends InstrumentedDialogFragment + implements DialogInterface.OnClickListener { + + public static final String TAG = "NfcRebootDialog"; + + /** + * The function to show the Dialog. + */ + public static void show(DevelopmentSettingsDashboardFragment host) { + final FragmentManager manager = host.getActivity().getSupportFragmentManager(); + if (manager.findFragmentByTag(TAG) == null) { + final NfcRebootDialog dialog = new NfcRebootDialog(); + dialog.setTargetFragment(host, 0 /* requestCode */); + dialog.show(manager, TAG); + } + } + + @Override + public int getMetricsCategory() { + return SettingsEnums.DIALOG_NFC_ENABLE_DETAIL_LOG; + } + + @Override + public Dialog onCreateDialog(Bundle savedInstanceState) { + return new AlertDialog.Builder(getActivity()) + .setMessage(R.string.nfc_reboot_dialog_message) + .setTitle(R.string.nfc_reboot_dialog_title) + .setPositiveButton( + R.string.nfc_reboot_dialog_confirm, this) + .setNegativeButton( + android.R.string.cancel, this) + .create(); + } + + @Override + public void onClick(DialogInterface dialog, int which) { + final OnNfcRebootDialogConfirmedListener host = + (OnNfcRebootDialogConfirmedListener) getTargetFragment(); + if (host == null) { + return; + } + if (which == DialogInterface.BUTTON_POSITIVE) { + host.onNfcRebootDialogConfirmed(); + PowerManager pm = getContext().getSystemService(PowerManager.class); + pm.reboot(null); + } else { + host.onNfcRebootDialogCanceled(); + } + } + + /** + * Interface for EnableAdbWarningDialog callbacks. + */ + public interface OnNfcRebootDialogConfirmedListener { + /** + * Called when the user presses enable on the warning dialog. + */ + void onNfcRebootDialogConfirmed(); + + /** + * Called when the user presses cancel on the warning dialog. + */ + void onNfcRebootDialogCanceled(); + } +} diff --git a/src/com/android/settings/development/NfcSnoopLogPreferenceController.java b/src/com/android/settings/development/NfcSnoopLogPreferenceController.java new file mode 100644 index 00000000000..10cfee00ba4 --- /dev/null +++ b/src/com/android/settings/development/NfcSnoopLogPreferenceController.java @@ -0,0 +1,129 @@ +/* + * Copyright (C) 2022 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.development; + +import android.content.Context; +import android.os.SystemProperties; +import android.util.Log; + +import androidx.annotation.VisibleForTesting; +import androidx.preference.Preference; +import androidx.preference.SwitchPreference; + +import com.android.settingslib.development.DeveloperOptionsPreferenceController; + +/** + * Preference controller to control NFCSNOOP data payload + */ +public class NfcSnoopLogPreferenceController extends + DeveloperOptionsPreferenceController implements Preference.OnPreferenceChangeListener { + private static final String TAG = "NfcSnoopLog"; + private static final String NFC_NFCSNOOP_LOG_KEY = + "nfc_snoop_log"; + @VisibleForTesting + static final String NFC_NFCSNOOP_LOG_MODE_PROPERTY = + "persist.nfc.nfcsnooplogmode"; + @VisibleForTesting + static final String NFCSNOOP_MODE_FILTERED = "filtered"; + @VisibleForTesting + static final String NFCSNOOP_MODE_FULL = "full"; + + @VisibleForTesting + boolean mChanged = false; + + private final DevelopmentSettingsDashboardFragment mFragment; + + public NfcSnoopLogPreferenceController(Context context, + DevelopmentSettingsDashboardFragment fragment) { + super(context); + mFragment = fragment; + } + + @Override + public String getPreferenceKey() { + return NFC_NFCSNOOP_LOG_KEY; + } + + @Override + public boolean onPreferenceChange(Preference preference, Object newValue) { + NfcRebootDialog.show(mFragment); + mChanged = true; + return false; + } + + @Override + public void updateState(Preference preference) { + try { + final String currentValue = SystemProperties.get(NFC_NFCSNOOP_LOG_MODE_PROPERTY); + ((SwitchPreference) mPreference).setChecked(currentValue.equals(NFCSNOOP_MODE_FULL)); + } catch (RuntimeException e) { + Log.e(TAG, "Fail to get nfc system property: " + e.getMessage()); + } + } + + @Override + protected void onDeveloperOptionsSwitchDisabled() { + super.onDeveloperOptionsSwitchDisabled(); + try { + SystemProperties.set(NFC_NFCSNOOP_LOG_MODE_PROPERTY, NFCSNOOP_MODE_FILTERED); + ((SwitchPreference) mPreference).setChecked(false); + } catch (RuntimeException e) { + Log.e(TAG, "Fail to set nfc system property: " + e.getMessage()); + } + } + + /** + * Check whether the current setting is the default value or not. + */ + public boolean isDefaultValue() { + try { + final String currentValue = SystemProperties.get(NFC_NFCSNOOP_LOG_MODE_PROPERTY); + return !currentValue.equals(NFCSNOOP_MODE_FULL); + } catch (RuntimeException e) { + Log.e(TAG, "Fail to get nfc system property: " + e.getMessage()); + } + return true; + } + + /** + * Called when the NfcRebootDialog confirm is clicked. + */ + public void onNfcRebootDialogConfirmed() { + if (!mChanged) { + return; + } + try { + final String currentValue = + SystemProperties.get(NFC_NFCSNOOP_LOG_MODE_PROPERTY, NFCSNOOP_MODE_FILTERED); + if (currentValue.equals(NFCSNOOP_MODE_FILTERED)) { + SystemProperties.set(NFC_NFCSNOOP_LOG_MODE_PROPERTY, NFCSNOOP_MODE_FULL); + } else { + SystemProperties.set(NFC_NFCSNOOP_LOG_MODE_PROPERTY, NFCSNOOP_MODE_FILTERED); + } + } catch (RuntimeException e) { + Log.e(TAG, "Fail to set nfc system property: " + e.getMessage()); + } + + } + + /** + * Called when the NfcRebootDialog cancel is clicked. + */ + public void onNfcRebootDialogCanceled() { + mChanged = false; + } +} diff --git a/src/com/android/settings/development/NfcVerboseVendorLogPreferenceController.java b/src/com/android/settings/development/NfcVerboseVendorLogPreferenceController.java new file mode 100644 index 00000000000..8b3cab076b4 --- /dev/null +++ b/src/com/android/settings/development/NfcVerboseVendorLogPreferenceController.java @@ -0,0 +1,130 @@ +/* + * Copyright (C) 2022 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.development; + +import android.content.Context; +import android.os.SystemProperties; +import android.util.Log; + +import androidx.annotation.VisibleForTesting; +import androidx.preference.Preference; +import androidx.preference.SwitchPreference; + +import com.android.settingslib.development.DeveloperOptionsPreferenceController; + +/** + * Preference controller to control NFC vendor verbose logging enable and disable + */ +public class NfcVerboseVendorLogPreferenceController + extends DeveloperOptionsPreferenceController + implements Preference.OnPreferenceChangeListener { + private static final String TAG = "NfcVerboseVendorLog"; + private static final String NFC_VERBOSE_VENDOR_LOG_KEY = "nfc_verbose_vendor_log"; + @VisibleForTesting + static final String NFC_VERBOSE_VENDOR_LOG_PROPERTY = + "persist.nfc.verbosevendorlog"; + @VisibleForTesting + static final String VERBOSE_VENDOR_LOG_ENABLED = "enabled"; + @VisibleForTesting + static final String VERBOSE_VENDOR_LOG_DISABLED = "disabled"; + + @VisibleForTesting + boolean mChanged = false; + + private final DevelopmentSettingsDashboardFragment mFragment; + + public NfcVerboseVendorLogPreferenceController(Context context, + DevelopmentSettingsDashboardFragment fragment) { + super(context); + mFragment = fragment; + } + + @Override + public String getPreferenceKey() { + return NFC_VERBOSE_VENDOR_LOG_KEY; + } + + @Override + public boolean onPreferenceChange(Preference preference, Object newValue) { + NfcRebootDialog.show(mFragment); + mChanged = true; + return false; + } + + @Override + public void updateState(Preference preference) { + try { + final String currentValue = SystemProperties.get(NFC_VERBOSE_VENDOR_LOG_PROPERTY); + ((SwitchPreference) mPreference) + .setChecked(currentValue.equals(VERBOSE_VENDOR_LOG_ENABLED)); + } catch (RuntimeException e) { + Log.e(TAG, "Fail to get nfc system property: " + e.getMessage()); + } + } + + @Override + protected void onDeveloperOptionsSwitchDisabled() { + super.onDeveloperOptionsSwitchDisabled(); + try { + SystemProperties.set(NFC_VERBOSE_VENDOR_LOG_PROPERTY, VERBOSE_VENDOR_LOG_DISABLED); + ((SwitchPreference) mPreference).setChecked(false); + } catch (RuntimeException e) { + Log.e(TAG, "Fail to set nfc system property: " + e.getMessage()); + } + } + + /** + * Check whether the current setting is the default value or not. + */ + public boolean isDefaultValue() { + try { + final String currentValue = SystemProperties.get(NFC_VERBOSE_VENDOR_LOG_PROPERTY); + return !currentValue.equals(VERBOSE_VENDOR_LOG_ENABLED); + } catch (RuntimeException e) { + Log.e(TAG, "Fail to get nfc system property: " + e.getMessage()); + } + return true; + } + + /** + * Called when the NfcRebootDialog confirm is clicked. + */ + public void onNfcRebootDialogConfirmed() { + if (!mChanged) { + return; + } + try { + final String currentValue = SystemProperties + .get(NFC_VERBOSE_VENDOR_LOG_PROPERTY, VERBOSE_VENDOR_LOG_DISABLED); + if (currentValue.equals(VERBOSE_VENDOR_LOG_DISABLED)) { + SystemProperties.set(NFC_VERBOSE_VENDOR_LOG_PROPERTY, VERBOSE_VENDOR_LOG_ENABLED); + } else { + SystemProperties.set(NFC_VERBOSE_VENDOR_LOG_PROPERTY, VERBOSE_VENDOR_LOG_DISABLED); + } + updateState(mPreference); + } catch (RuntimeException e) { + Log.e(TAG, "Fail to set nfc system property: " + e.getMessage()); + } + } + + /** + * Called when the NfcRebootDialog cancel is clicked. + */ + public void onNfcRebootDialogCanceled() { + mChanged = false; + } +} diff --git a/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceController.java b/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceController.java index 45ae8c595bf..f3fec8e1973 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceController.java +++ b/src/com/android/settings/fuelgauge/batteryusage/BatteryChartPreferenceController.java @@ -697,12 +697,13 @@ public class BatteryChartPreferenceController extends AbstractPreferenceControll final Map> batteryUsageData = DataProcessor.getBatteryUsageData(context, batteryHistoryMap); - return batteryUsageData == null - ? null - : batteryUsageData - .get(BatteryChartViewModel.SELECTED_INDEX_ALL) - .get(BatteryChartViewModel.SELECTED_INDEX_ALL) - .getAppDiffEntryList(); + if (batteryUsageData == null) { + return null; + } + BatteryDiffData allBatteryDiffData = batteryUsageData.get( + BatteryChartViewModel.SELECTED_INDEX_ALL).get( + BatteryChartViewModel.SELECTED_INDEX_ALL); + return allBatteryDiffData == null ? null : allBatteryDiffData.getAppDiffEntryList(); } /** Used for {@link AppBatteryPreferenceController}. */ diff --git a/src/com/android/settings/fuelgauge/batteryusage/BatteryChartView.java b/src/com/android/settings/fuelgauge/batteryusage/BatteryChartView.java index e668b37c24e..1a009eaa436 100644 --- a/src/com/android/settings/fuelgauge/batteryusage/BatteryChartView.java +++ b/src/com/android/settings/fuelgauge/batteryusage/BatteryChartView.java @@ -595,11 +595,13 @@ public class BatteryChartView extends AppCompatImageView implements View.OnClick // Searches the corresponding trapezoid index from x location. private int getTrapezoidIndex(float x) { - for (int index = 0; index < mTrapezoidSlots.length; index++) { - final TrapezoidSlot slot = mTrapezoidSlots[index]; - if (x >= slot.mLeft - mTrapezoidHOffset - && x <= slot.mRight + mTrapezoidHOffset) { - return index; + if (mTrapezoidSlots != null) { + for (int index = 0; index < mTrapezoidSlots.length; index++) { + final TrapezoidSlot slot = mTrapezoidSlots[index]; + if (x >= slot.mLeft - mTrapezoidHOffset + && x <= slot.mRight + mTrapezoidHOffset) { + return index; + } } } return BatteryChartViewModel.SELECTED_INDEX_INVALID; diff --git a/src/com/android/settings/localepicker/LocaleDragAndDropAdapter.java b/src/com/android/settings/localepicker/LocaleDragAndDropAdapter.java index ab9110d01ab..b3c2e3071af 100644 --- a/src/com/android/settings/localepicker/LocaleDragAndDropAdapter.java +++ b/src/com/android/settings/localepicker/LocaleDragAndDropAdapter.java @@ -43,7 +43,6 @@ import java.util.ArrayList; import java.util.List; import java.util.Locale; - class LocaleDragAndDropAdapter extends RecyclerView.Adapter { @@ -154,8 +153,10 @@ class LocaleDragAndDropAdapter final LocaleDragCell dragCell = holder.getLocaleDragCell(); final String label = feedItem.getFullNameNative(); final String description = feedItem.getFullNameInUiLanguage(); + dragCell.setLabelAndDescription(label, description); dragCell.setLocalized(feedItem.isTranslated()); + dragCell.setCurrentDefault(feedItem.getLocale().equals(Locale.getDefault())); dragCell.setMiniLabel(mNumberFormatter.format(i + 1)); dragCell.setShowCheckbox(mRemoveMode); dragCell.setShowMiniLabel(!mRemoveMode); diff --git a/src/com/android/settings/localepicker/LocaleDragCell.java b/src/com/android/settings/localepicker/LocaleDragCell.java index ea86189b018..2f4cfefefb1 100644 --- a/src/com/android/settings/localepicker/LocaleDragCell.java +++ b/src/com/android/settings/localepicker/LocaleDragCell.java @@ -33,6 +33,7 @@ class LocaleDragCell extends RelativeLayout { private CheckBox mCheckbox; private TextView mMiniLabel; private TextView mLocalized; + private TextView mCurrentDefault; private ImageView mDragHandle; public LocaleDragCell(Context context, AttributeSet attrs) { @@ -44,6 +45,7 @@ class LocaleDragCell extends RelativeLayout { super.onFinishInflate(); mLabel = (TextView) findViewById(R.id.label); mLocalized = (TextView) findViewById(R.id.l10nWarn); + mCurrentDefault = (TextView) findViewById(R.id.default_locale); mMiniLabel = (TextView) findViewById(R.id.miniLabel); mCheckbox = (CheckBox) findViewById(R.id.checkbox); mDragHandle = (ImageView) findViewById(R.id.dragHandle); @@ -100,6 +102,14 @@ class LocaleDragCell extends RelativeLayout { invalidate(); } + /** + * Indicate current locale is system default. + */ + public void setCurrentDefault(boolean isCurrentDefault) { + mCurrentDefault.setVisibility(isCurrentDefault ? VISIBLE : GONE); + invalidate(); + } + public ImageView getDragHandle() { return mDragHandle; } diff --git a/src/com/android/settings/localepicker/LocaleHelperPreferenceController.java b/src/com/android/settings/localepicker/LocaleHelperPreferenceController.java new file mode 100644 index 00000000000..05c740139cc --- /dev/null +++ b/src/com/android/settings/localepicker/LocaleHelperPreferenceController.java @@ -0,0 +1,74 @@ +/* + * Copyright (C) 2022 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 androidx.annotation.VisibleForTesting; +import androidx.preference.PreferenceScreen; + +import com.android.settings.R; +import com.android.settingslib.HelpUtils; +import com.android.settingslib.core.AbstractPreferenceController; +import com.android.settingslib.widget.FooterPreference; + +/** + * A controller to update current locale information of application. + */ +public class LocaleHelperPreferenceController extends AbstractPreferenceController { + private static final String TAG = LocaleHelperPreferenceController.class.getSimpleName(); + + private static final String KEY_FOOTER_LANGUAGE_PICKER = "footer_languages_picker"; + + public LocaleHelperPreferenceController(Context context) { + super(context); + } + + @Override + public boolean isAvailable() { + return true; + } + + @Override + public String getPreferenceKey() { + return KEY_FOOTER_LANGUAGE_PICKER; + } + + @Override + public void displayPreference(PreferenceScreen screen) { + super.displayPreference(screen); + FooterPreference footerPreference = screen.findPreference(getPreferenceKey()); + updateFooterPreference(footerPreference); + } + + @VisibleForTesting + void updateFooterPreference(FooterPreference footerPreference) { + if (footerPreference != null) { + footerPreference.setLearnMoreAction(v -> openLocaleLearnMoreLink()); + footerPreference.setLearnMoreText(mContext.getString( + R.string.desc_locale_helper_footer_general)); + } + } + + private void openLocaleLearnMoreLink() { + mContext.startActivity( + HelpUtils.getHelpIntent( + mContext, + mContext.getString(R.string.link_locale_picker_footer_learn_more), + /*backupContext=*/"")); + } +} diff --git a/src/com/android/settings/localepicker/LocaleListEditor.java b/src/com/android/settings/localepicker/LocaleListEditor.java index eac2dd1df3c..9db3468c9e1 100644 --- a/src/com/android/settings/localepicker/LocaleListEditor.java +++ b/src/com/android/settings/localepicker/LocaleListEditor.java @@ -36,6 +36,7 @@ import android.widget.TextView; import androidx.annotation.VisibleForTesting; import androidx.appcompat.app.AlertDialog; +import androidx.preference.PreferenceScreen; import androidx.recyclerview.widget.RecyclerView; import com.android.internal.app.LocalePicker; @@ -46,6 +47,7 @@ import com.android.settings.overlay.FeatureFactory; import com.android.settings.search.BaseSearchIndexProvider; import com.android.settingslib.search.SearchIndexable; import com.android.settingslib.search.SearchIndexableRaw; +import com.android.settingslib.widget.LayoutPreference; import java.util.ArrayList; import java.util.List; @@ -64,6 +66,7 @@ public class LocaleListEditor extends RestrictedSettingsFragment { private static final int REQUEST_LOCALE_PICKER = 0; private static final String INDEX_KEY_ADD_LANGUAGE = "add_language"; + private static final String KEY_LANGUAGES_PICKER = "languages_picker"; private LocaleDragAndDropAdapter mAdapter; private Menu mMenu; @@ -72,6 +75,9 @@ public class LocaleListEditor extends RestrictedSettingsFragment { private boolean mShowingRemoveDialog; private boolean mIsUiRestricted; + private LayoutPreference mLocalePickerPreference; + private LocaleHelperPreferenceController mLocaleHelperPreferenceController; + public LocaleListEditor() { super(DISALLOW_CONFIG_LOCALE); } @@ -86,6 +92,14 @@ public class LocaleListEditor extends RestrictedSettingsFragment { super.onCreate(savedInstanceState); setHasOptionsMenu(true); + addPreferencesFromResource(R.xml.languages); + final Activity activity = getActivity(); + activity.setTitle(R.string.language_picker_title); + mLocaleHelperPreferenceController = new LocaleHelperPreferenceController(activity); + final PreferenceScreen screen = getPreferenceScreen(); + mLocalePickerPreference = screen.findPreference(KEY_LANGUAGES_PICKER); + mLocaleHelperPreferenceController.displayPreference(screen); + LocaleStore.fillCache(this.getContext()); final List feedsList = getUserLocaleList(); mAdapter = new LocaleDragAndDropAdapter(this.getContext(), feedsList); @@ -93,11 +107,8 @@ public class LocaleListEditor extends RestrictedSettingsFragment { @Override public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstState) { - final View result = super.onCreateView(inflater, container, savedInstState); - final View myLayout = inflater.inflate(R.layout.locale_order_list, (ViewGroup) result); - - configureDragAndDrop(myLayout); - return result; + configureDragAndDrop(mLocalePickerPreference); + return super.onCreateView(inflater, container, savedInstState); } @Override @@ -287,8 +298,8 @@ public class LocaleListEditor extends RestrictedSettingsFragment { return result; } - private void configureDragAndDrop(View view) { - final RecyclerView list = view.findViewById(R.id.dragList); + private void configureDragAndDrop(LayoutPreference layout) { + final RecyclerView list = layout.findViewById(R.id.dragList); final LocaleLinearLayoutManager llm = new LocaleLinearLayoutManager(getContext(), mAdapter); llm.setAutoMeasureEnabled(true); list.setLayoutManager(llm); @@ -297,7 +308,7 @@ public class LocaleListEditor extends RestrictedSettingsFragment { mAdapter.setRecyclerView(list); list.setAdapter(mAdapter); - mAddLanguage = view.findViewById(R.id.add_language); + mAddLanguage = layout.findViewById(R.id.add_language); mAddLanguage.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View v) { diff --git a/tests/robotests/src/com/android/settings/biometrics/fingerprint/SetupFingerprintEnrollFindSensorTest.java b/tests/robotests/src/com/android/settings/biometrics/fingerprint/SetupFingerprintEnrollFindSensorTest.java index a198d86a814..54a7fb16eb6 100644 --- a/tests/robotests/src/com/android/settings/biometrics/fingerprint/SetupFingerprintEnrollFindSensorTest.java +++ b/tests/robotests/src/com/android/settings/biometrics/fingerprint/SetupFingerprintEnrollFindSensorTest.java @@ -22,7 +22,6 @@ import static org.robolectric.RuntimeEnvironment.application; import android.content.Intent; import android.hardware.fingerprint.FingerprintManager; -import android.widget.Button; import androidx.appcompat.app.AlertDialog; @@ -66,6 +65,23 @@ public class SetupFingerprintEnrollFindSensorTest { @Test public void fingerprintEnroll_showsAlert_whenClickingSkip() { + final AlertDialog alertDialog = setupAlertDialog(); + final ShadowAlertDialogCompat shadowAlertDialog = ShadowAlertDialogCompat.shadowOf( + alertDialog); + final int titleRes = R.string.setup_fingerprint_enroll_skip_title; + + assertThat(application.getString(titleRes)).isEqualTo(shadowAlertDialog.getTitle()); + } + + @Test + public void fingerprintEnroll_showsAlert_setSudTheme() { + final AlertDialog alertDialog = setupAlertDialog(); + + assertThat(alertDialog.getContext().getThemeResId()).isEqualTo( + R.style.GlifV2ThemeAlertDialog); + } + + private AlertDialog setupAlertDialog() { final Intent intent = new Intent() // Set the challenge token so the confirm screen will not be shown .putExtra(ChooseLockSettingsHelper.EXTRA_KEY_CHALLENGE_TOKEN, new byte[0]); @@ -80,9 +96,6 @@ public class SetupFingerprintEnrollFindSensorTest { final AlertDialog alertDialog = ShadowAlertDialogCompat.getLatestAlertDialog(); assertThat(alertDialog).isNotNull(); - final ShadowAlertDialogCompat shadowAlertDialog = ShadowAlertDialogCompat.shadowOf( - alertDialog); - final int titleRes = R.string.setup_fingerprint_enroll_skip_title; - assertThat(application.getString(titleRes)).isEqualTo(shadowAlertDialog.getTitle()); + return alertDialog; } } diff --git a/tests/robotests/src/com/android/settings/development/NfcSnoopLogPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/NfcSnoopLogPreferenceControllerTest.java new file mode 100644 index 00000000000..4ea5475f02a --- /dev/null +++ b/tests/robotests/src/com/android/settings/development/NfcSnoopLogPreferenceControllerTest.java @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2022 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.development; + +import static com.android.settings.development.NfcSnoopLogPreferenceController + .NFCSNOOP_MODE_FILTERED; +import static com.android.settings.development.NfcSnoopLogPreferenceController + .NFCSNOOP_MODE_FULL; +import static com.android.settings.development.NfcSnoopLogPreferenceController + .NFC_NFCSNOOP_LOG_MODE_PROPERTY; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.os.SystemProperties; + +import androidx.preference.PreferenceScreen; +import androidx.preference.SwitchPreference; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class NfcSnoopLogPreferenceControllerTest { + @Mock + private PreferenceScreen mPreferenceScreen; + @Mock + private DevelopmentSettingsDashboardFragment mFragment; + + private Context mContext; + private SwitchPreference mPreference; + private NfcSnoopLogPreferenceController mController; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mPreference = new SwitchPreference(mContext); + mController = spy(new NfcSnoopLogPreferenceController(mContext, mFragment)); + when(mPreferenceScreen.findPreference(mController.getPreferenceKey())) + .thenReturn(mPreference); + mController.displayPreference(mPreferenceScreen); + } + + @Test + public void onNfcRebootDialogConfirmed_nfcSnoopLogDisabled_shouldChangeProperty() { + SystemProperties.set(NFC_NFCSNOOP_LOG_MODE_PROPERTY, NFCSNOOP_MODE_FILTERED); + mController.mChanged = true; + + mController.onNfcRebootDialogConfirmed(); + + final String currentValue = SystemProperties.get(NFC_NFCSNOOP_LOG_MODE_PROPERTY); + assertThat(currentValue.equals(NFCSNOOP_MODE_FULL)).isTrue(); + } + + @Test + public void onNfcRebootDialogConfirmed_nfcSnoopLogEnabled_shouldChangeProperty() { + SystemProperties.set(NFC_NFCSNOOP_LOG_MODE_PROPERTY, NFCSNOOP_MODE_FULL); + mController.mChanged = true; + + mController.onNfcRebootDialogConfirmed(); + + final String currentValue = SystemProperties.get(NFC_NFCSNOOP_LOG_MODE_PROPERTY); + assertThat(currentValue.equals(NFCSNOOP_MODE_FILTERED)).isTrue(); + } + + @Test + public void onNfcRebootDialogCanceled_shouldNotChangeProperty() { + SystemProperties.set(NFC_NFCSNOOP_LOG_MODE_PROPERTY, NFCSNOOP_MODE_FILTERED); + mController.mChanged = true; + + mController.onNfcRebootDialogCanceled(); + + final String currentValue = SystemProperties.get(NFC_NFCSNOOP_LOG_MODE_PROPERTY); + assertThat(currentValue.equals(NFCSNOOP_MODE_FILTERED)).isTrue(); + } +} diff --git a/tests/robotests/src/com/android/settings/development/NfcVerboseVendorLogPreferenceControllerTest.java b/tests/robotests/src/com/android/settings/development/NfcVerboseVendorLogPreferenceControllerTest.java new file mode 100644 index 00000000000..49ddd30dc35 --- /dev/null +++ b/tests/robotests/src/com/android/settings/development/NfcVerboseVendorLogPreferenceControllerTest.java @@ -0,0 +1,99 @@ +/* + * Copyright (C) 2022 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.development; + +import static com.android.settings.development.NfcVerboseVendorLogPreferenceController + .NFC_VERBOSE_VENDOR_LOG_PROPERTY; +import static com.android.settings.development.NfcVerboseVendorLogPreferenceController + .VERBOSE_VENDOR_LOG_DISABLED; +import static com.android.settings.development.NfcVerboseVendorLogPreferenceController + .VERBOSE_VENDOR_LOG_ENABLED; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.when; + +import android.content.Context; +import android.os.SystemProperties; + +import androidx.preference.PreferenceScreen; +import androidx.preference.SwitchPreference; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RobolectricTestRunner; +import org.robolectric.RuntimeEnvironment; + +@RunWith(RobolectricTestRunner.class) +public class NfcVerboseVendorLogPreferenceControllerTest { + @Mock + private PreferenceScreen mPreferenceScreen; + @Mock + private DevelopmentSettingsDashboardFragment mFragment; + + private Context mContext; + private SwitchPreference mPreference; + private NfcVerboseVendorLogPreferenceController mController; + + @Before + public void setup() { + MockitoAnnotations.initMocks(this); + mContext = RuntimeEnvironment.application; + mPreference = new SwitchPreference(mContext); + mController = spy(new NfcVerboseVendorLogPreferenceController(mContext, mFragment)); + when(mPreferenceScreen.findPreference(mController.getPreferenceKey())) + .thenReturn(mPreference); + mController.displayPreference(mPreferenceScreen); + } + + @Test + public void onNfcRebootDialogConfirmed_nfcVendorLogDisabled_shouldChangeProperty() { + SystemProperties.set(NFC_VERBOSE_VENDOR_LOG_PROPERTY, VERBOSE_VENDOR_LOG_DISABLED); + mController.mChanged = true; + + mController.onNfcRebootDialogConfirmed(); + + final String currentValue = SystemProperties.get(NFC_VERBOSE_VENDOR_LOG_PROPERTY); + assertThat(currentValue.equals(VERBOSE_VENDOR_LOG_ENABLED)).isTrue(); + } + + @Test + public void onNfcRebootDialogConfirmed_nfcVendorLogEnabled_shouldChangeProperty() { + SystemProperties.set(NFC_VERBOSE_VENDOR_LOG_PROPERTY, VERBOSE_VENDOR_LOG_ENABLED); + mController.mChanged = true; + + mController.onNfcRebootDialogConfirmed(); + + final String currentValue = SystemProperties.get(NFC_VERBOSE_VENDOR_LOG_PROPERTY); + assertThat(currentValue.equals(VERBOSE_VENDOR_LOG_DISABLED)).isTrue(); + } + + @Test + public void onNfcRebootDialogCanceled_shouldNotChangeProperty() { + SystemProperties.set(NFC_VERBOSE_VENDOR_LOG_PROPERTY, VERBOSE_VENDOR_LOG_DISABLED); + mController.mChanged = true; + + mController.onNfcRebootDialogCanceled(); + + final String currentValue = SystemProperties.get(NFC_VERBOSE_VENDOR_LOG_PROPERTY); + assertThat(currentValue.equals(VERBOSE_VENDOR_LOG_DISABLED)).isTrue(); + } +} diff --git a/tests/unit/src/com/android/settings/applications/appinfo/AppLocalePreferenceControllerTest.java b/tests/unit/src/com/android/settings/applications/appinfo/AppLocalePreferenceControllerTest.java index 526b6cc9e3e..805041c6736 100644 --- a/tests/unit/src/com/android/settings/applications/appinfo/AppLocalePreferenceControllerTest.java +++ b/tests/unit/src/com/android/settings/applications/appinfo/AppLocalePreferenceControllerTest.java @@ -19,7 +19,6 @@ package com.android.settings.applications.appinfo; import static com.google.common.truth.Truth.assertThat; import android.content.Context; -import android.util.FeatureFlagUtils; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; @@ -49,22 +48,10 @@ public class AppLocalePreferenceControllerTest { return mCanDisplayLocaleUi; } }; - FeatureFlagUtils - .setEnabled(mContext, FeatureFlagUtils.SETTINGS_APP_LANGUAGE_SELECTION, true); } @Test - public void getAvailabilityStatus_canShowUiButFeatureFlagOff_shouldReturnUnavailable() { - mCanDisplayLocaleUi = true; - FeatureFlagUtils - .setEnabled(mContext, FeatureFlagUtils.SETTINGS_APP_LANGUAGE_SELECTION, false); - - assertThat(mController.getAvailabilityStatus()) - .isEqualTo(BasePreferenceController.CONDITIONALLY_UNAVAILABLE); - } - - @Test - public void getAvailabilityStatus_canShowUiAndFeatureFlagOn_shouldReturnAvailable() { + public void getAvailabilityStatus_canShowUi_shouldReturnAvailable() { mCanDisplayLocaleUi = true; assertThat(mController.getAvailabilityStatus()) @@ -72,20 +59,10 @@ public class AppLocalePreferenceControllerTest { } @Test - public void getAvailabilityStatus_featureFlagOnButCanNotShowUi_shouldReturnUnavailable() { + public void getAvailabilityStatus_canNotShowUi_shouldReturnUnavailable() { mCanDisplayLocaleUi = false; assertThat(mController.getAvailabilityStatus()) .isEqualTo(BasePreferenceController.CONDITIONALLY_UNAVAILABLE); } - - @Test - public void getAvailabilityStatus_featureFlagOffAndCanNotShowUi_shouldReturnUnavailable() { - mCanDisplayLocaleUi = false; - FeatureFlagUtils - .setEnabled(mContext, FeatureFlagUtils.SETTINGS_APP_LANGUAGE_SELECTION, false); - - assertThat(mController.getAvailabilityStatus()) - .isEqualTo(BasePreferenceController.CONDITIONALLY_UNAVAILABLE); - } } diff --git a/tests/unit/src/com/android/settings/applications/appinfo/ManageAppLocalePreferenceControllerTest.java b/tests/unit/src/com/android/settings/applications/appinfo/ManageAppLocalePreferenceControllerTest.java deleted file mode 100644 index 648c7570304..00000000000 --- a/tests/unit/src/com/android/settings/applications/appinfo/ManageAppLocalePreferenceControllerTest.java +++ /dev/null @@ -1,66 +0,0 @@ -/* - * Copyright (C) 2021 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.applications.appinfo; - -import static com.google.common.truth.Truth.assertThat; - -import static org.mockito.Mockito.spy; - -import android.content.Context; -import android.util.FeatureFlagUtils; - -import androidx.test.core.app.ApplicationProvider; -import androidx.test.ext.junit.runners.AndroidJUnit4; - - -import com.android.settings.core.BasePreferenceController; - -import org.junit.Before; -import org.junit.Test; -import org.junit.runner.RunWith; -import org.mockito.MockitoAnnotations; - -@RunWith(AndroidJUnit4.class) -public class ManageAppLocalePreferenceControllerTest { - private Context mContext; - private ManageAppLocalePreferenceController mController; - - @Before - public void setUp() { - MockitoAnnotations.initMocks(this); - mContext = spy(ApplicationProvider.getApplicationContext()); - mController = spy(new ManageAppLocalePreferenceController(mContext, "a key")); - - FeatureFlagUtils - .setEnabled(mContext, FeatureFlagUtils.SETTINGS_APP_LANGUAGE_SELECTION, true); - } - - @Test - public void getAvailabilityStatus_featureFlagOff_shouldReturnUnavailable() { - FeatureFlagUtils - .setEnabled(mContext, FeatureFlagUtils.SETTINGS_APP_LANGUAGE_SELECTION, false); - - assertThat(mController.getAvailabilityStatus()) - .isEqualTo(BasePreferenceController.CONDITIONALLY_UNAVAILABLE); - } - - @Test - public void getAvailabilityStatus_featureFlagOn_shouldReturnAvailable() { - assertThat(mController.getAvailabilityStatus()) - .isEqualTo(BasePreferenceController.AVAILABLE); - } -} diff --git a/tests/unit/src/com/android/settings/localepicker/LocaleHelperPreferenceControllerTest.java b/tests/unit/src/com/android/settings/localepicker/LocaleHelperPreferenceControllerTest.java new file mode 100644 index 00000000000..31b8e794480 --- /dev/null +++ b/tests/unit/src/com/android/settings/localepicker/LocaleHelperPreferenceControllerTest.java @@ -0,0 +1,59 @@ +/* + * Copyright (C) 2022 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 org.mockito.Mockito.anyString; +import static org.mockito.Mockito.verify; + +import android.content.Context; +import android.os.Looper; + +import androidx.test.core.app.ApplicationProvider; +import androidx.test.ext.junit.runners.AndroidJUnit4; + +import com.android.settingslib.widget.FooterPreference; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; + +@RunWith(AndroidJUnit4.class) +public class LocaleHelperPreferenceControllerTest { + private Context mContext; + private LocaleHelperPreferenceController mLocaleHelperPreferenceController; + + @Mock + private FooterPreference mMockFooterPreference; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + if (Looper.myLooper() == null) { + Looper.prepare(); + } + mContext = ApplicationProvider.getApplicationContext(); + mLocaleHelperPreferenceController = new LocaleHelperPreferenceController(mContext); + } + + @Test + public void updateFooterPreference_setFooterPreference_hasClickAction() { + mLocaleHelperPreferenceController.updateFooterPreference(mMockFooterPreference); + verify(mMockFooterPreference).setLearnMoreText(anyString()); + } +}