Snap for 11265615 from 1a564010bf to 24Q2-release

Change-Id: I0da09b11be3a7ab5a200e540b22c03336ac5af8b

aconfig/settings_display_flag_declarations.aconfig

@@ -0,0 +1,9 @@
+package: "com.android.settings.flags"
+
+flag {
+    name: "protect_screen_timeout_with_auth"
+    namespace: "safety_center"
+    description: "Require an auth challenge for increasing screen timeout."
+    bug: "315937886"
+}
+

res/values/strings.xml

@@ -4254,12 +4254,22 @@
     <string name="add_virtual_keyboard">Manage on-screen keyboards</string>
     <!-- Title for the 'keyboard options' preference category. [CHAR LIMIT=35] -->
     <string name="keyboard_options_category">Options</string>
+    <!-- Title for the 'keyboard accessibility options' preference category. [CHAR LIMIT=35] -->
+    <string name="keyboard_a11y_category">Accessibility</string>
     <!-- Title for the 'physical keyboard' settings screen. [CHAR LIMIT=35] -->
     <string name="physical_keyboard_title">Physical keyboard</string>
     <!-- Title for the 'show virtual keyboard' preference switch. [CHAR LIMIT=35] -->
     <string name="show_ime">Use on-screen keyboard</string>
     <!-- Summary text for the 'add virtual keyboard' preference sub-screen. [CHAR LIMIT=100] -->
     <string name="show_ime_summary">Keep it on screen while physical keyboard is active</string>
+    <!-- Title for the 'Bounce keys' preference switch. [CHAR LIMIT=35] -->
+    <string name="bounce_keys">Bounce keys</string>
+    <!-- Summary text for the 'Bounce keys' preference sub-screen. [CHAR LIMIT=100] -->
+    <string name="bounce_keys_summary">Enable Bounce keys for physical keyboard accessibility</string>
+    <!-- Title for the 'Sticky keys' preference switch. [CHAR LIMIT=35] -->
+    <string name="sticky_keys">Sticky keys</string>
+    <!-- Summary text for the 'Sticky keys' preference sub-screen. [CHAR LIMIT=100] -->
+    <string name="sticky_keys_summary">Enable Sticky keys for physical keyboard accessibility</string>
     <!-- Title for the button to trigger the 'keyboard shortcuts helper' dialog. [CHAR LIMIT=35] -->
     <string name="keyboard_shortcuts_helper">Keyboard shortcuts</string>
     <!-- Summary text for the 'keyboard shortcuts helper' dialog. [CHAR LIMIT=100] -->

res/xml/physical_keyboard_settings.xml

@@ -38,4 +38,22 @@
             android:summary="@string/modifier_keys_settings_summary"
             android:fragment="com.android.settings.inputmethod.ModifierKeysSettings" />
     </PreferenceCategory>
+
+    <PreferenceCategory
+        android:key="keyboard_a11y_category"
+        android:title="@string/keyboard_a11y_category">
+
+        <SwitchPreference
+            android:key="accessibility_bounce_keys"
+            android:title="@string/bounce_keys"
+            android:summary="@string/bounce_keys_summary"
+            android:defaultValue="false" />
+
+        <SwitchPreference
+            android:key="accessibility_sticky_keys"
+            android:title="@string/sticky_keys"
+            android:summary="@string/sticky_keys_summary"
+            android:defaultValue="false" />
+
+    </PreferenceCategory>
 </PreferenceScreen>

src/com/android/settings/display/ScreenTimeoutSettings.java

@@ -37,10 +37,12 @@ import android.util.Log;
 import androidx.preference.PreferenceScreen;
 
 import com.android.settings.R;
+import com.android.settings.flags.Flags;
 import com.android.settings.overlay.FeatureFactory;
 import com.android.settings.search.BaseSearchIndexProvider;
 import com.android.settings.support.actionbar.HelpResourceProvider;
 import com.android.settings.widget.RadioButtonPickerFragment;
+import com.android.settings.wifi.dpp.WifiDppUtils;
 import com.android.settingslib.RestrictedLockUtils;
 import com.android.settingslib.RestrictedLockUtilsInternal;
 import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
@@ -55,13 +57,12 @@ import com.google.common.annotations.VisibleForTesting;
 import java.util.ArrayList;
 import java.util.List;
 
-/**
- * Fragment that is used to control screen timeout.
- */
+/** Fragment that is used to control screen timeout. */
 @SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC)
-public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
-        HelpResourceProvider {
+public class ScreenTimeoutSettings extends RadioButtonPickerFragment
+        implements HelpResourceProvider {
     private static final String TAG = "ScreenTimeout";
+
     /** If there is no setting in the provider, use this. */
     public static final int FALLBACK_SCREEN_TIMEOUT_VALUE = 30000;
 
@@ -72,7 +73,8 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
     private FooterPreference mPrivacyPreference;
     private final MetricsFeatureProvider mMetricsFeatureProvider;
     private SensorPrivacyManager mPrivacyManager;
-    private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
+    private final BroadcastReceiver mReceiver =
+            new BroadcastReceiver() {
                 @Override
                 public void onReceive(Context context, Intent intent) {
                     mAdaptiveSleepBatterySaverPreferenceController.updateVisibility();
@@ -82,15 +84,13 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
 
     private DevicePolicyManager mDevicePolicyManager;
     private SensorPrivacyManager.OnSensorPrivacyChangedListener mPrivacyChangedListener;
+    private boolean mIsUserAuthenticated = false;
 
-    @VisibleForTesting
-    Context mContext;
+    @VisibleForTesting Context mContext;
 
-    @VisibleForTesting
-    RestrictedLockUtils.EnforcedAdmin mAdmin;
+    @VisibleForTesting RestrictedLockUtils.EnforcedAdmin mAdmin;
 
-    @VisibleForTesting
-    FooterPreference mDisableOptionsPreference;
+    @VisibleForTesting FooterPreference mDisableOptionsPreference;
 
     @VisibleForTesting
     FooterPreference mPowerConsumptionPreference;
@@ -101,16 +101,14 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
     @VisibleForTesting
     AdaptiveSleepCameraStatePreferenceController mAdaptiveSleepCameraStatePreferenceController;
 
-    @VisibleForTesting
-    AdaptiveSleepPreferenceController mAdaptiveSleepController;
+    @VisibleForTesting AdaptiveSleepPreferenceController mAdaptiveSleepController;
 
     @VisibleForTesting
     AdaptiveSleepBatterySaverPreferenceController mAdaptiveSleepBatterySaverPreferenceController;
 
     public ScreenTimeoutSettings() {
         super();
-        mMetricsFeatureProvider = FeatureFactory.getFeatureFactory()
-                .getMetricsFeatureProvider();
+        mMetricsFeatureProvider = FeatureFactory.getFeatureFactory().getMetricsFeatureProvider();
     }
 
     @Override
@@ -121,8 +119,8 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
         mInitialEntries = getResources().getStringArray(R.array.screen_timeout_entries);
         mInitialValues = getResources().getStringArray(R.array.screen_timeout_values);
         mAdaptiveSleepController = new AdaptiveSleepPreferenceController(context);
-        mAdaptiveSleepPermissionController = new AdaptiveSleepPermissionPreferenceController(
-                context);
+        mAdaptiveSleepPermissionController =
+                new AdaptiveSleepPermissionPreferenceController(context);
         mAdaptiveSleepCameraStatePreferenceController =
                 new AdaptiveSleepCameraStatePreferenceController(context, getLifecycle());
         mAdaptiveSleepBatterySaverPreferenceController =
@@ -144,8 +142,9 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
         if (mInitialValues != null) {
             for (int i = 0; i < mInitialValues.length; ++i) {
                 if (Long.parseLong(mInitialValues[i].toString()) <= maxTimeout) {
-                    candidates.add(new TimeoutCandidateInfo(mInitialEntries[i],
-                            mInitialValues[i].toString(), true));
+                    candidates.add(
+                            new TimeoutCandidateInfo(
+                                    mInitialEntries[i], mInitialValues[i].toString(), true));
                 }
             }
         } else {
@@ -161,9 +160,10 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
         mAdaptiveSleepCameraStatePreferenceController.updateVisibility();
         mAdaptiveSleepBatterySaverPreferenceController.updateVisibility();
         mAdaptiveSleepController.updatePreference();
-        mContext.registerReceiver(mReceiver,
-                new IntentFilter(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED));
+        mContext.registerReceiver(
+                mReceiver, new IntentFilter(PowerManager.ACTION_POWER_SAVE_MODE_CHANGED));
         mPrivacyManager.addSensorPrivacyListener(CAMERA, mPrivacyChangedListener);
+        mIsUserAuthenticated = false;
     }
 
     @Override
@@ -185,19 +185,21 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
         }
 
         for (CandidateInfo info : candidateList) {
-            SelectorWithWidgetPreference pref =
-                    new SelectorWithWidgetPreference(getPrefContext());
+            ProtectedSelectorWithWidgetPreference pref =
+                    new ProtectedSelectorWithWidgetPreference(
+                            getPrefContext(), info.getKey(), this);
             bindPreference(pref, info.getKey(), info, defaultKey);
             screen.addPreference(pref);
         }
 
-        final long selectedTimeout = Long.parseLong(defaultKey);
+        final long selectedTimeout = getTimeoutFromKey(defaultKey);
         final long maxTimeout = getMaxScreenTimeout(getContext());
         if (!candidateList.isEmpty() && (selectedTimeout > maxTimeout)) {
             // The selected time out value is longer than the max timeout allowed by the admin.
             // Select the largest value from the list by default.
-            final SelectorWithWidgetPreference preferenceWithLargestTimeout =
-                    (SelectorWithWidgetPreference) screen.getPreference(candidateList.size() - 1);
+            final ProtectedSelectorWithWidgetPreference preferenceWithLargestTimeout =
+                    (ProtectedSelectorWithWidgetPreference)
+                            screen.getPreference(candidateList.size() - 1);
             preferenceWithLargestTimeout.setChecked(true);
         }
 
@@ -225,18 +227,32 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
         }
     }
 
+    boolean isUserAuthenticated() {
+        return mIsUserAuthenticated;
+    }
+
+    void setUserAuthenticated(boolean isUserAuthenticated) {
+        mIsUserAuthenticated = isUserAuthenticated;
+    }
+
     @VisibleForTesting
     void setupDisabledFooterPreference() {
-        final String textDisabledByAdmin = mDevicePolicyManager.getResources().getString(
-                OTHER_OPTIONS_DISABLED_BY_ADMIN, () -> getResources().getString(
-                        R.string.admin_disabled_other_options));
+        final String textDisabledByAdmin =
+                mDevicePolicyManager
+                        .getResources()
+                        .getString(
+                                OTHER_OPTIONS_DISABLED_BY_ADMIN,
+                                () ->
+                                        getResources()
+                                                .getString(R.string.admin_disabled_other_options));
         final String textMoreDetails = getResources().getString(R.string.admin_more_details);
 
         mDisableOptionsPreference = new FooterPreference(getContext());
         mDisableOptionsPreference.setTitle(textDisabledByAdmin);
         mDisableOptionsPreference.setSelectable(false);
         mDisableOptionsPreference.setLearnMoreText(textMoreDetails);
-        mDisableOptionsPreference.setLearnMoreAction(v -> {
+        mDisableOptionsPreference.setLearnMoreAction(
+                v -> {
                     RestrictedLockUtils.sendShowAdminSupportDetailsIntent(getContext(), mAdmin);
                 });
         mDisableOptionsPreference.setIcon(R.drawable.ic_info_outline_24dp);
@@ -303,17 +319,20 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
         if (context == null) {
             return Long.toString(FALLBACK_SCREEN_TIMEOUT_VALUE);
         } else {
-            return Long.toString(Settings.System.getLong(context.getContentResolver(),
-                    SCREEN_OFF_TIMEOUT, FALLBACK_SCREEN_TIMEOUT_VALUE));
+            return Long.toString(
+                    Settings.System.getLong(
+                            context.getContentResolver(),
+                            SCREEN_OFF_TIMEOUT,
+                            FALLBACK_SCREEN_TIMEOUT_VALUE));
         }
     }
 
     private void setCurrentSystemScreenTimeout(Context context, String key) {
         try {
             if (context != null) {
-                final long value = Long.parseLong(key);
-                mMetricsFeatureProvider.action(context, SettingsEnums.ACTION_SCREEN_TIMEOUT_CHANGED,
-                        (int) value);
+                final long value = getTimeoutFromKey(key);
+                mMetricsFeatureProvider.action(
+                        context, SettingsEnums.ACTION_SCREEN_TIMEOUT_CHANGED, (int) value);
                 Settings.System.putLong(context.getContentResolver(), SCREEN_OFF_TIMEOUT, value);
             }
         } catch (NumberFormatException e) {
@@ -325,7 +344,12 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
         return AdaptiveSleepPreferenceController.isAdaptiveSleepSupported(context);
     }
 
-    private static class TimeoutCandidateInfo extends CandidateInfo {
+    private static long getTimeoutFromKey(String key) {
+        return Long.parseLong(key);
+    }
+
+    @VisibleForTesting
+    static class TimeoutCandidateInfo extends CandidateInfo {
         private final CharSequence mLabel;
         private final String mKey;
 
@@ -351,10 +375,42 @@ public class ScreenTimeoutSettings extends RadioButtonPickerFragment implements
         }
     }
 
+    @VisibleForTesting
+    static class ProtectedSelectorWithWidgetPreference
+            extends SelectorWithWidgetPreference {
+
+        private final long mTimeoutMs;
+        private final ScreenTimeoutSettings mScreenTimeoutSettings;
+
+        ProtectedSelectorWithWidgetPreference(
+                Context context, String key, ScreenTimeoutSettings screenTimeoutSettings) {
+            super(context);
+            mTimeoutMs = getTimeoutFromKey(key);
+            mScreenTimeoutSettings = screenTimeoutSettings;
+        }
+
+        @Override
+        public void onClick() {
+            if (Flags.protectScreenTimeoutWithAuth()
+                    && !mScreenTimeoutSettings.isUserAuthenticated()
+                    && !isChecked()
+                    && mTimeoutMs > getTimeoutFromKey(mScreenTimeoutSettings.getDefaultKey())) {
+                WifiDppUtils.showLockScreen(
+                        getContext(),
+                        () -> {
+                            mScreenTimeoutSettings.setUserAuthenticated(true);
+                            super.onClick();
+                        });
+            } else {
+                super.onClick();
+            }
+        }
+    }
+
     public static final BaseSearchIndexProvider SEARCH_INDEX_DATA_PROVIDER =
             new BaseSearchIndexProvider(R.xml.screen_timeout_settings) {
-                public List<SearchIndexableRaw> getRawDataToIndex(Context context,
-                        boolean enabled) {
+                public List<SearchIndexableRaw> getRawDataToIndex(
+                        Context context, boolean enabled) {
                     if (!isScreenAttentionAvailable(context)) {
                         return null;
                     }

src/com/android/settings/fuelgauge/batteryusage/BootBroadcastReceiver.java

@@ -71,7 +71,7 @@ public final class BootBroadcastReceiver extends BroadcastReceiver {
                 break;
             case Intent.ACTION_TIME_CHANGED:
                 Log.d(TAG, "refresh job and clear all data from action=" + action);
-                DatabaseUtils.clearDataAfterTimeChangedIfNeeded(context);
+                DatabaseUtils.clearDataAfterTimeChangedIfNeeded(context, intent);
                 break;
             default:
                 Log.w(TAG, "receive unsupported action=" + action);

src/com/android/settings/fuelgauge/batteryusage/DatabaseUtils.java

@@ -16,6 +16,8 @@
 
 package com.android.settings.fuelgauge.batteryusage;
 
+import static android.content.Intent.FLAG_RECEIVER_REPLACE_PENDING;
+
 import static com.android.settings.fuelgauge.batteryusage.ConvertUtils.utcToLocalTimeForLogging;
 
 import android.app.usage.IUsageStatsManager;
@@ -150,6 +152,7 @@ public final class DatabaseUtils {
                     .authority(AUTHORITY)
                     .appendPath(BATTERY_USAGE_SLOT_TABLE)
                     .build();
+
     /** A list of level record event types to access battery usage data. */
     public static final List<BatteryEventType> BATTERY_LEVEL_RECORD_EVENTS =
             List.of(BatteryEventType.FULL_CHARGED, BatteryEventType.EVEN_HOUR);
@@ -454,30 +457,56 @@ public final class DatabaseUtils {
     }
 
     /** Clears all data and jobs if current timestamp is out of the range of last recorded job. */
-    public static void clearDataAfterTimeChangedIfNeeded(Context context) {
-        AsyncTask.execute(() -> {
+    public static void clearDataAfterTimeChangedIfNeeded(Context context, Intent intent) {
+        AsyncTask.execute(
+                () -> {
                     try {
+                        if ((intent.getFlags() & FLAG_RECEIVER_REPLACE_PENDING) != 0) {
+                            BatteryUsageLogUtils.writeLog(
+                                    context,
+                                    Action.TIME_UPDATED,
+                                    "Database is not cleared because the time change intent is only"
+                                            + " for the existing pending receiver.");
+                            return;
+                        }
                         final List<BatteryEvent> batteryLevelRecordEvents =
-                        DatabaseUtils.getBatteryEvents(context, Calendar.getInstance(),
-                                getLastFullChargeTime(context), BATTERY_LEVEL_RECORD_EVENTS);
-                final long lastRecordTimestamp = batteryLevelRecordEvents.isEmpty()
-                        ? INVALID_TIMESTAMP : batteryLevelRecordEvents.get(0).getTimestamp();
+                                DatabaseUtils.getBatteryEvents(
+                                        context,
+                                        Calendar.getInstance(),
+                                        getLastFullChargeTime(context),
+                                        BATTERY_LEVEL_RECORD_EVENTS);
+                        final long lastRecordTimestamp =
+                                batteryLevelRecordEvents.isEmpty()
+                                        ? INVALID_TIMESTAMP
+                                        : batteryLevelRecordEvents.get(0).getTimestamp();
                         final long nextRecordTimestamp =
                                 TimestampUtils.getNextEvenHourTimestamp(lastRecordTimestamp);
                         final long currentTime = System.currentTimeMillis();
-                final boolean isOutOfTimeRange = lastRecordTimestamp == INVALID_TIMESTAMP
-                        || currentTime < lastRecordTimestamp || currentTime > nextRecordTimestamp;
-                final String logInfo = String.format(Locale.ENGLISH,
-                        "clear database = %b, current time = %d, last record time = %d",
-                        isOutOfTimeRange, currentTime, lastRecordTimestamp);
+                        final boolean isOutOfTimeRange =
+                                lastRecordTimestamp == INVALID_TIMESTAMP
+                                        || currentTime < lastRecordTimestamp
+                                        || currentTime > nextRecordTimestamp;
+                        final String logInfo =
+                                String.format(
+                                        Locale.ENGLISH,
+                                        "clear database = %b, current time = %d, "
+                                                + "last record time = %d",
+                                        isOutOfTimeRange,
+                                        currentTime,
+                                        lastRecordTimestamp);
                         Log.d(TAG, logInfo);
                         BatteryUsageLogUtils.writeLog(context, Action.TIME_UPDATED, logInfo);
                         if (isOutOfTimeRange) {
                             DatabaseUtils.clearAll(context);
-                    PeriodicJobManager.getInstance(context).refreshJob(/* fromBoot= */ false);
+                            PeriodicJobManager.getInstance(context)
+                                    .refreshJob(/* fromBoot= */ false);
                         }
                     } catch (RuntimeException e) {
                         Log.e(TAG, "refreshDataAndJobIfNeededAfterTimeChanged() failed", e);
+                        BatteryUsageLogUtils.writeLog(
+                                context,
+                                Action.TIME_UPDATED,
+                                "refreshDataAndJobIfNeededAfterTimeChanged() failed" + e);
                     }
                 });
     }

src/com/android/settings/inputmethod/PhysicalKeyboardFragment.java

@@ -24,7 +24,9 @@ import android.content.Intent;
 import android.database.ContentObserver;
 import android.hardware.input.InputDeviceIdentifier;
 import android.hardware.input.InputManager;
+import android.hardware.input.InputSettings;
 import android.hardware.input.KeyboardLayout;
+import android.net.Uri;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.UserHandle;
@@ -65,10 +67,19 @@ public final class PhysicalKeyboardFragment extends SettingsPreferenceFragment
         KeyboardLayoutDialogFragment.OnSetupKeyboardLayoutsListener {
 
     private static final String KEYBOARD_OPTIONS_CATEGORY = "keyboard_options_category";
+    private static final String KEYBOARD_A11Y_CATEGORY = "keyboard_a11y_category";
     private static final String SHOW_VIRTUAL_KEYBOARD_SWITCH = "show_virtual_keyboard_switch";
+    private static final String ACCESSIBILITY_BOUNCE_KEYS = "accessibility_bounce_keys";
+    private static final String ACCESSIBILITY_STICKY_KEYS = "accessibility_sticky_keys";
     private static final String KEYBOARD_SHORTCUTS_HELPER = "keyboard_shortcuts_helper";
     private static final String MODIFIER_KEYS_SETTINGS = "modifier_keys_settings";
     private static final String EXTRA_AUTO_SELECTION = "auto_selection";
+    private static final Uri sVirtualKeyboardSettingsUri = Secure.getUriFor(
+            Secure.SHOW_IME_WITH_HARD_KEYBOARD);
+    private static final Uri sAccessibilityBounceKeysUri = Secure.getUriFor(
+            Secure.ACCESSIBILITY_BOUNCE_KEYS);
+    private static final Uri sAccessibilityStickyKeysUri = Secure.getUriFor(
+            Secure.ACCESSIBILITY_STICKY_KEYS);
 
     @NonNull
     private final ArrayList<HardKeyboardDeviceInfo> mLastHardKeyboards = new ArrayList<>();
@@ -80,7 +91,14 @@ public final class PhysicalKeyboardFragment extends SettingsPreferenceFragment
     @NonNull
     private PreferenceCategory mKeyboardAssistanceCategory;
     @Nullable
+    private PreferenceCategory mKeyboardA11yCategory = null;
+    @Nullable
     private TwoStatePreference mShowVirtualKeyboardSwitch = null;
+    @Nullable
+    private TwoStatePreference mAccessibilityBounceKeys = null;
+    @Nullable
+    private TwoStatePreference mAccessibilityStickyKeys = null;
+
 
     private Intent mIntentWaitingForResult;
     private boolean mIsNewKeyboardSettings;
@@ -102,10 +120,15 @@ public final class PhysicalKeyboardFragment extends SettingsPreferenceFragment
         mIm = Preconditions.checkNotNull(activity.getSystemService(InputManager.class));
         mImm = Preconditions.checkNotNull(activity.getSystemService(InputMethodManager.class));
         mKeyboardAssistanceCategory = Preconditions.checkNotNull(
-                (PreferenceCategory) findPreference(KEYBOARD_OPTIONS_CATEGORY));
-        mShowVirtualKeyboardSwitch = Preconditions.checkNotNull(
-                (TwoStatePreference) mKeyboardAssistanceCategory.findPreference(
-                        SHOW_VIRTUAL_KEYBOARD_SWITCH));
+                findPreference(KEYBOARD_OPTIONS_CATEGORY));
+        mShowVirtualKeyboardSwitch = Objects.requireNonNull(
+                mKeyboardAssistanceCategory.findPreference(SHOW_VIRTUAL_KEYBOARD_SWITCH));
+
+        mKeyboardA11yCategory = Objects.requireNonNull(findPreference(KEYBOARD_A11Y_CATEGORY));
+        mAccessibilityBounceKeys = Objects.requireNonNull(
+                mKeyboardA11yCategory.findPreference(ACCESSIBILITY_BOUNCE_KEYS));
+        mAccessibilityStickyKeys = Objects.requireNonNull(
+                mKeyboardA11yCategory.findPreference(ACCESSIBILITY_STICKY_KEYS));
 
         FeatureFactory featureFactory = FeatureFactory.getFeatureFactory();
         mMetricsFeatureProvider = featureFactory.getMetricsFeatureProvider();
@@ -121,6 +144,12 @@ public final class PhysicalKeyboardFragment extends SettingsPreferenceFragment
         if (!isModifierKeySettingsEnabled) {
             mKeyboardAssistanceCategory.removePreference(findPreference(MODIFIER_KEYS_SETTINGS));
         }
+        if (!InputSettings.isAccessibilityBounceKeysFeatureEnabled()) {
+            mKeyboardA11yCategory.removePreference(mAccessibilityBounceKeys);
+        }
+        if (!InputSettings.isAccessibilityStickyKeysFeatureEnabled()) {
+            mKeyboardA11yCategory.removePreference(mAccessibilityStickyKeys);
+        }
         InputDeviceIdentifier inputDeviceIdentifier = activity.getIntent().getParcelableExtra(
                 KeyboardLayoutPickerFragment.EXTRA_INPUT_DEVICE_IDENTIFIER);
         int intentFromWhere =
@@ -161,9 +190,13 @@ public final class PhysicalKeyboardFragment extends SettingsPreferenceFragment
         mLastHardKeyboards.clear();
         scheduleUpdateHardKeyboards();
         mIm.registerInputDeviceListener(this, null);
-        mShowVirtualKeyboardSwitch.setOnPreferenceChangeListener(
+        Objects.requireNonNull(mShowVirtualKeyboardSwitch).setOnPreferenceChangeListener(
                 mShowVirtualKeyboardSwitchPreferenceChangeListener);
-        registerShowVirtualKeyboardSettingsObserver();
+        Objects.requireNonNull(mAccessibilityBounceKeys).setOnPreferenceChangeListener(
+                mAccessibilityBounceKeysSwitchPreferenceChangeListener);
+        Objects.requireNonNull(mAccessibilityStickyKeys).setOnPreferenceChangeListener(
+                mAccessibilityStickyKeysSwitchPreferenceChangeListener);
+        registerSettingsObserver();
     }
 
     @Override
@@ -171,8 +204,10 @@ public final class PhysicalKeyboardFragment extends SettingsPreferenceFragment
         super.onPause();
         mLastHardKeyboards.clear();
         mIm.unregisterInputDeviceListener(this);
-        mShowVirtualKeyboardSwitch.setOnPreferenceChangeListener(null);
-        unregisterShowVirtualKeyboardSettingsObserver();
+        Objects.requireNonNull(mShowVirtualKeyboardSwitch).setOnPreferenceChangeListener(null);
+        Objects.requireNonNull(mAccessibilityBounceKeys).setOnPreferenceChangeListener(null);
+        Objects.requireNonNull(mAccessibilityStickyKeys).setOnPreferenceChangeListener(null);
+        unregisterSettingsObserver();
     }
 
     @Override
@@ -276,6 +311,14 @@ public final class PhysicalKeyboardFragment extends SettingsPreferenceFragment
             mFeatureProvider.addFirmwareUpdateCategory(getPrefContext(), preferenceScreen);
         }
         updateShowVirtualKeyboardSwitch();
+
+        if (InputSettings.isAccessibilityBounceKeysFeatureEnabled()
+                || InputSettings.isAccessibilityStickyKeysFeatureEnabled()) {
+            Objects.requireNonNull(mKeyboardA11yCategory).setOrder(2);
+            preferenceScreen.addPreference(mKeyboardA11yCategory);
+            updateAccessibilityBounceKeysSwitch();
+            updateAccessibilityStickyKeysSwitch();
+        }
     }
 
     private void showKeyboardLayoutDialog(InputDeviceIdentifier inputDeviceIdentifier) {
@@ -296,25 +339,58 @@ public final class PhysicalKeyboardFragment extends SettingsPreferenceFragment
                 .launch();
     }
 
-    private void registerShowVirtualKeyboardSettingsObserver() {
-        unregisterShowVirtualKeyboardSettingsObserver();
-        getActivity().getContentResolver().registerContentObserver(
-                Secure.getUriFor(Secure.SHOW_IME_WITH_HARD_KEYBOARD),
+    private void registerSettingsObserver() {
+        unregisterSettingsObserver();
+        ContentResolver contentResolver = getActivity().getContentResolver();
+        contentResolver.registerContentObserver(
+                sVirtualKeyboardSettingsUri,
                 false,
                 mContentObserver,
                 UserHandle.myUserId());
+        if (InputSettings.isAccessibilityBounceKeysFeatureEnabled()) {
+            contentResolver.registerContentObserver(
+                    sAccessibilityBounceKeysUri,
+                    false,
+                    mContentObserver,
+                    UserHandle.myUserId());
+        }
+        if (InputSettings.isAccessibilityStickyKeysFeatureEnabled()) {
+            contentResolver.registerContentObserver(
+                    sAccessibilityStickyKeysUri,
+                    false,
+                    mContentObserver,
+                    UserHandle.myUserId());
+        }
         updateShowVirtualKeyboardSwitch();
+        updateAccessibilityBounceKeysSwitch();
+        updateAccessibilityStickyKeysSwitch();
     }
 
-    private void unregisterShowVirtualKeyboardSettingsObserver() {
+    private void unregisterSettingsObserver() {
         getActivity().getContentResolver().unregisterContentObserver(mContentObserver);
     }
 
     private void updateShowVirtualKeyboardSwitch() {
-        mShowVirtualKeyboardSwitch.setChecked(
+        Objects.requireNonNull(mShowVirtualKeyboardSwitch).setChecked(
                 Secure.getInt(getContentResolver(), Secure.SHOW_IME_WITH_HARD_KEYBOARD, 0) != 0);
     }
 
+    private void updateAccessibilityBounceKeysSwitch() {
+        if (!InputSettings.isAccessibilityBounceKeysFeatureEnabled()) {
+            return;
+        }
+        Objects.requireNonNull(mAccessibilityBounceKeys).setChecked(
+                InputSettings.isAccessibilityBounceKeysEnabled(getContext()));
+    }
+
+    private void updateAccessibilityStickyKeysSwitch() {
+        if (!InputSettings.isAccessibilityStickyKeysFeatureEnabled()) {
+            return;
+        }
+        Objects.requireNonNull(mAccessibilityStickyKeys).setChecked(
+                InputSettings.isAccessibilityStickyKeysEnabled(getContext()));
+    }
+
     private void toggleKeyboardShortcutsMenu() {
         getActivity().requestShowKeyboardShortcuts();
     }
@@ -328,10 +404,29 @@ public final class PhysicalKeyboardFragment extends SettingsPreferenceFragment
                 return true;
             };
 
+    private final OnPreferenceChangeListener
+            mAccessibilityBounceKeysSwitchPreferenceChangeListener = (preference, newValue) -> {
+                InputSettings.setAccessibilityBounceKeysThreshold(getContext(),
+                        ((Boolean) newValue) ? 500 : 0);
+                return true;
+            };
+
+    private final OnPreferenceChangeListener
+            mAccessibilityStickyKeysSwitchPreferenceChangeListener = (preference, newValue) -> {
+                InputSettings.setAccessibilityStickyKeysEnabled(getContext(), (Boolean) newValue);
+                return true;
+            };
+
     private final ContentObserver mContentObserver = new ContentObserver(new Handler(true)) {
         @Override
-        public void onChange(boolean selfChange) {
+        public void onChange(boolean selfChange, Uri uri) {
+            if (sVirtualKeyboardSettingsUri.equals(uri)) {
                 updateShowVirtualKeyboardSwitch();
+            } else if (sAccessibilityBounceKeysUri.equals(uri)) {
+                updateAccessibilityBounceKeysSwitch();
+            } else if (sAccessibilityStickyKeysUri.equals(uri)) {
+                updateAccessibilityStickyKeysSwitch();
+            }
         }
     };
 

src/com/android/settings/network/telephony/CallingPreferenceCategoryController.java

@@ -1,31 +0,0 @@
-/*
- * Copyright (C) 2019 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.network.telephony;
-
-import android.content.Context;
-
-import com.android.settings.widget.PreferenceCategoryController;
-
-/**
- * Preference controller for "Calling" category
- */
-public class CallingPreferenceCategoryController extends PreferenceCategoryController {
-
-    public CallingPreferenceCategoryController(Context context, String key) {
-        super(context, key);
-    }
-}

src/com/android/settings/network/telephony/CallingPreferenceCategoryController.kt

@@ -0,0 +1,48 @@
+/*
+ * 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.network.telephony
+
+import android.content.Context
+import androidx.preference.Preference
+import androidx.preference.PreferenceScreen
+import com.android.settings.core.BasePreferenceController
+
+/**
+ * Preference controller for "Calling" category
+ */
+class CallingPreferenceCategoryController(context: Context, key: String) :
+    BasePreferenceController(context, key) {
+
+    private val visibleChildren = mutableSetOf<String>()
+    private var preference: Preference? = null
+
+    override fun getAvailabilityStatus() = AVAILABLE
+
+    override fun displayPreference(screen: PreferenceScreen) {
+        // Not call super here, to avoid preference.isVisible changed unexpectedly
+        preference = screen.findPreference(preferenceKey)
+    }
+
+    fun updateChildVisible(key: String, isVisible: Boolean) {
+        if (isVisible) {
+            visibleChildren.add(key)
+        } else {
+            visibleChildren.remove(key)
+        }
+        preference?.isVisible = visibleChildren.isNotEmpty()
+    }
+}

src/com/android/settings/network/telephony/MobileNetworkSettings.java

@@ -269,8 +269,10 @@ public class MobileNetworkSettings extends AbstractMobileNetworkSettings impleme
         use(Enable2gPreferenceController.class).init(mSubId);
         use(CarrierWifiTogglePreferenceController.class).init(getLifecycle(), mSubId);
 
-        final WifiCallingPreferenceController wifiCallingPreferenceController =
-                use(WifiCallingPreferenceController.class).init(mSubId);
+        final CallingPreferenceCategoryController callingPreferenceCategoryController =
+                use(CallingPreferenceCategoryController.class);
+        use(WifiCallingPreferenceController.class)
+                .init(mSubId, callingPreferenceCategoryController);
 
         final OpenNetworkSelectPagePreferenceController openNetworkSelectPagePreferenceController =
                 use(OpenNetworkSelectPagePreferenceController.class).init(mSubId);
@@ -286,9 +288,8 @@ public class MobileNetworkSettings extends AbstractMobileNetworkSettings impleme
         mCdmaSubscriptionPreferenceController.init(getPreferenceManager(), mSubId);
 
         final VideoCallingPreferenceController videoCallingPreferenceController =
-                use(VideoCallingPreferenceController.class).init(mSubId);
-        use(CallingPreferenceCategoryController.class).setChildren(
-                Arrays.asList(wifiCallingPreferenceController, videoCallingPreferenceController));
+                use(VideoCallingPreferenceController.class)
+                        .init(mSubId, callingPreferenceCategoryController);
         use(Enhanced4gLtePreferenceController.class).init(mSubId)
                 .addListener(videoCallingPreferenceController);
         use(Enhanced4gCallingPreferenceController.class).init(mSubId)

src/com/android/settings/network/telephony/VideoCallingPreferenceController.java

@@ -54,6 +54,7 @@ public class VideoCallingPreferenceController extends TelephonyTogglePreferenceC
     @VisibleForTesting
     Integer mCallState;
     private MobileDataEnabledListener mDataContentObserver;
+    private CallingPreferenceCategoryController mCallingPreferenceCategoryController;
 
     public VideoCallingPreferenceController(Context context, String key) {
         super(context, key);
@@ -97,6 +98,8 @@ public class VideoCallingPreferenceController extends TelephonyTogglePreferenceC
         final TwoStatePreference switchPreference = (TwoStatePreference) preference;
         final boolean videoCallEnabled = isVideoCallEnabled(mSubId);
         switchPreference.setVisible(videoCallEnabled);
+        mCallingPreferenceCategoryController
+                .updateChildVisible(getPreferenceKey(), videoCallEnabled);
         if (videoCallEnabled) {
             final boolean videoCallEditable = queryVoLteState(mSubId).isEnabledByUser()
                     && queryImsState(mSubId).isAllowUserControl();
@@ -136,8 +139,13 @@ public class VideoCallingPreferenceController extends TelephonyTogglePreferenceC
                 PackageManager.FEATURE_TELEPHONY_IMS);
     }
 
-    public VideoCallingPreferenceController init(int subId) {
+    /**
+     * Init instance of VideoCallingPreferenceController.
+     */
+    public VideoCallingPreferenceController init(
+            int subId, CallingPreferenceCategoryController callingPreferenceCategoryController) {
         mSubId = subId;
+        mCallingPreferenceCategoryController = callingPreferenceCategoryController;
 
         return this;
     }

src/com/android/settings/network/telephony/WifiCallingPreferenceController.java

@@ -1,230 +0,0 @@
-/*
- * Copyright (C) 2018 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.network.telephony;
-
-import android.content.Context;
-import android.content.Intent;
-import android.content.pm.PackageManager;
-import android.content.pm.ResolveInfo;
-import android.os.PersistableBundle;
-import android.provider.Settings;
-import android.telecom.PhoneAccountHandle;
-import android.telecom.TelecomManager;
-import android.telephony.CarrierConfigManager;
-import android.telephony.SubscriptionManager;
-import android.telephony.TelephonyCallback;
-import android.telephony.TelephonyManager;
-import android.telephony.ims.ImsMmTelManager;
-import android.util.Log;
-
-import androidx.annotation.VisibleForTesting;
-import androidx.preference.Preference;
-import androidx.preference.PreferenceScreen;
-
-import com.android.settings.R;
-import com.android.settings.network.ims.WifiCallingQueryImsState;
-import com.android.settingslib.core.lifecycle.LifecycleObserver;
-import com.android.settingslib.core.lifecycle.events.OnStart;
-import com.android.settingslib.core.lifecycle.events.OnStop;
-
-import java.util.List;
-
-/**
- * Preference controller for "Wifi Calling"
- */
-//TODO: Remove the class once Provider Model is always enabled in the future.
-public class WifiCallingPreferenceController extends TelephonyBasePreferenceController implements
-        LifecycleObserver, OnStart, OnStop {
-
-    private static final String TAG = "WifiCallingPreference";
-
-    @VisibleForTesting
-    Integer mCallState;
-    @VisibleForTesting
-    CarrierConfigManager mCarrierConfigManager;
-    private ImsMmTelManager mImsMmTelManager;
-    @VisibleForTesting
-    PhoneAccountHandle mSimCallManager;
-    private PhoneTelephonyCallback mTelephonyCallback;
-    private Preference mPreference;
-    private boolean mHasException;
-
-    public WifiCallingPreferenceController(Context context, String key) {
-        super(context, key);
-        mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class);
-        mTelephonyCallback = new PhoneTelephonyCallback();
-    }
-
-    @Override
-    public int getAvailabilityStatus(int subId) {
-        return SubscriptionManager.isValidSubscriptionId(subId)
-                && MobileNetworkUtils.isWifiCallingEnabled(mContext, subId, null)
-                ? AVAILABLE
-                : UNSUPPORTED_ON_DEVICE;
-    }
-
-    @Override
-    public void onStart() {
-        mTelephonyCallback.register(mContext, mSubId);
-    }
-
-    @Override
-    public void onStop() {
-        mTelephonyCallback.unregister();
-    }
-
-    @Override
-    public void displayPreference(PreferenceScreen screen) {
-        super.displayPreference(screen);
-        mPreference = screen.findPreference(getPreferenceKey());
-        final Intent intent = mPreference.getIntent();
-        if (intent != null) {
-            intent.putExtra(Settings.EXTRA_SUB_ID, mSubId);
-        }
-    }
-
-    @Override
-    public void updateState(Preference preference) {
-        super.updateState(preference);
-        if ((mCallState == null) || (preference == null)) {
-            Log.d(TAG, "Skip update under mCallState=" + mCallState);
-            return;
-        }
-        mHasException = false;
-        CharSequence summaryText = null;
-        if (mSimCallManager != null) {
-            final Intent intent = MobileNetworkUtils.buildPhoneAccountConfigureIntent(mContext,
-                    mSimCallManager);
-            if (intent == null) {
-                // Do nothing in this case since preference is invisible
-                return;
-            }
-            final PackageManager pm = mContext.getPackageManager();
-            final List<ResolveInfo> resolutions = pm.queryIntentActivities(intent, 0);
-            preference.setTitle(resolutions.get(0).loadLabel(pm));
-            preference.setIntent(intent);
-        } else {
-            final String title = SubscriptionManager.getResourcesForSubId(mContext, mSubId)
-                    .getString(R.string.wifi_calling_settings_title);
-            preference.setTitle(title);
-            summaryText = getResourceIdForWfcMode(mSubId);
-        }
-        preference.setSummary(summaryText);
-        preference.setEnabled(mCallState == TelephonyManager.CALL_STATE_IDLE && !mHasException);
-    }
-
-    private CharSequence getResourceIdForWfcMode(int subId) {
-        int resId = com.android.internal.R.string.wifi_calling_off_summary;
-        if (queryImsState(subId).isEnabledByUser()) {
-            boolean useWfcHomeModeForRoaming = false;
-            if (mCarrierConfigManager != null) {
-                final PersistableBundle carrierConfig =
-                        mCarrierConfigManager.getConfigForSubId(subId);
-                if (carrierConfig != null) {
-                    useWfcHomeModeForRoaming = carrierConfig.getBoolean(
-                            CarrierConfigManager
-                                    .KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL);
-                }
-            }
-            final boolean isRoaming = getTelephonyManager(mContext, subId)
-                    .isNetworkRoaming();
-            int wfcMode = ImsMmTelManager.WIFI_MODE_UNKNOWN;
-            try {
-                wfcMode = (isRoaming && !useWfcHomeModeForRoaming)
-                        ? mImsMmTelManager.getVoWiFiRoamingModeSetting() :
-                        mImsMmTelManager.getVoWiFiModeSetting();
-            } catch (IllegalArgumentException e) {
-                mHasException = true;
-                Log.e(TAG, "getResourceIdForWfcMode: Exception", e);
-            }
-
-            switch (wfcMode) {
-                case ImsMmTelManager.WIFI_MODE_WIFI_ONLY:
-                    resId = com.android.internal.R.string.wfc_mode_wifi_only_summary;
-                    break;
-                case ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED:
-                    resId = com.android.internal.R.string
-                            .wfc_mode_cellular_preferred_summary;
-                    break;
-                case ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED:
-                    resId = com.android.internal.R.string.wfc_mode_wifi_preferred_summary;
-                    break;
-                default:
-                    break;
-            }
-        }
-        return SubscriptionManager.getResourcesForSubId(mContext, subId).getText(resId);
-    }
-
-    public WifiCallingPreferenceController init(int subId) {
-        mSubId = subId;
-        mImsMmTelManager = getImsMmTelManager(mSubId);
-        mSimCallManager = mContext.getSystemService(TelecomManager.class)
-                .getSimCallManagerForSubscription(mSubId);
-
-        return this;
-    }
-
-    @VisibleForTesting
-    WifiCallingQueryImsState queryImsState(int subId) {
-        return new WifiCallingQueryImsState(mContext, subId);
-    }
-
-    protected ImsMmTelManager getImsMmTelManager(int subId) {
-        if (!SubscriptionManager.isValidSubscriptionId(subId)) {
-            return null;
-        }
-        return ImsMmTelManager.createForSubscriptionId(subId);
-    }
-
-    @VisibleForTesting
-    TelephonyManager getTelephonyManager(Context context, int subId) {
-        final TelephonyManager telephonyMgr = context.getSystemService(TelephonyManager.class);
-        if (!SubscriptionManager.isValidSubscriptionId(subId)) {
-            return telephonyMgr;
-        }
-        final TelephonyManager subscriptionTelephonyMgr =
-                telephonyMgr.createForSubscriptionId(subId);
-        return (subscriptionTelephonyMgr == null) ? telephonyMgr : subscriptionTelephonyMgr;
-    }
-
-
-    private class PhoneTelephonyCallback extends TelephonyCallback implements
-            TelephonyCallback.CallStateListener {
-
-        private TelephonyManager mTelephonyManager;
-
-        @Override
-        public void onCallStateChanged(int state) {
-            mCallState = state;
-            updateState(mPreference);
-        }
-
-        public void register(Context context, int subId) {
-            mTelephonyManager = getTelephonyManager(context, subId);
-            // assign current call state so that it helps to show correct preference state even
-            // before first onCallStateChanged() by initial registration.
-            mCallState = mTelephonyManager.getCallStateForSubscription();
-            mTelephonyManager.registerTelephonyCallback(context.getMainExecutor(), this);
-        }
-
-        public void unregister() {
-            mCallState = null;
-            mTelephonyManager.unregisterTelephonyCallback(this);
-        }
-    }
-}

src/com/android/settings/network/telephony/WifiCallingPreferenceController.kt

@@ -0,0 +1,140 @@
+/*
+ * 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.network.telephony
+
+import android.content.Context
+import android.provider.Settings
+import android.telecom.TelecomManager
+import android.telephony.SubscriptionManager
+import android.telephony.TelephonyManager
+import android.telephony.ims.ImsMmTelManager
+import androidx.lifecycle.Lifecycle
+import androidx.lifecycle.LifecycleOwner
+import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.repeatOnLifecycle
+import androidx.preference.Preference
+import androidx.preference.PreferenceScreen
+import com.android.settings.R
+import com.android.settings.network.telephony.ims.ImsMmTelRepository
+import com.android.settings.network.telephony.ims.ImsMmTelRepositoryImpl
+import com.android.settingslib.spa.framework.util.collectLatestWithLifecycle
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+
+/**
+ * Preference controller for "Wifi Calling".
+ *
+ * TODO: Remove the class once Provider Model is always enabled in the future.
+ */
+open class WifiCallingPreferenceController @JvmOverloads constructor(
+    context: Context,
+    key: String,
+    private val callStateFlowFactory: (subId: Int) -> Flow<Int> = context::callStateFlow,
+    private val imsMmTelRepositoryFactory: (subId: Int) -> ImsMmTelRepository = { subId ->
+        ImsMmTelRepositoryImpl(context, subId)
+    },
+) : TelephonyBasePreferenceController(context, key) {
+
+    private lateinit var preference: Preference
+    private lateinit var callingPreferenceCategoryController: CallingPreferenceCategoryController
+
+    private val resourcesForSub by lazy {
+        SubscriptionManager.getResourcesForSubId(mContext, mSubId)
+    }
+
+    fun init(
+        subId: Int,
+        callingPreferenceCategoryController: CallingPreferenceCategoryController,
+    ): WifiCallingPreferenceController {
+        mSubId = subId
+        this.callingPreferenceCategoryController = callingPreferenceCategoryController
+        return this
+    }
+
+    /**
+     * Note: Visibility also controlled by [onViewCreated].
+     */
+    override fun getAvailabilityStatus(subId: Int) =
+        if (SubscriptionManager.isValidSubscriptionId(subId)) AVAILABLE
+        else CONDITIONALLY_UNAVAILABLE
+
+    override fun displayPreference(screen: PreferenceScreen) {
+        // Not call super here, to avoid preference.isVisible changed unexpectedly
+        preference = screen.findPreference(preferenceKey)!!
+        preference.intent?.putExtra(Settings.EXTRA_SUB_ID, mSubId)
+    }
+
+    override fun onViewCreated(viewLifecycleOwner: LifecycleOwner) {
+        viewLifecycleOwner.lifecycleScope.launch {
+            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                val isVisible = withContext(Dispatchers.Default) {
+                    MobileNetworkUtils.isWifiCallingEnabled(mContext, mSubId, null)
+                }
+                preference.isVisible = isVisible
+                callingPreferenceCategoryController.updateChildVisible(preferenceKey, isVisible)
+            }
+        }
+
+        viewLifecycleOwner.lifecycleScope.launch {
+            viewLifecycleOwner.repeatOnLifecycle(Lifecycle.State.STARTED) {
+                update()
+            }
+        }
+
+        callStateFlowFactory(mSubId).collectLatestWithLifecycle(viewLifecycleOwner) {
+            preference.isEnabled = (it == TelephonyManager.CALL_STATE_IDLE)
+        }
+    }
+
+    private suspend fun update() {
+        val simCallManager = mContext.getSystemService(TelecomManager::class.java)
+            ?.getSimCallManagerForSubscription(mSubId)
+        if (simCallManager != null) {
+            val intent = withContext(Dispatchers.Default) {
+                MobileNetworkUtils.buildPhoneAccountConfigureIntent(mContext, simCallManager)
+            } ?: return // Do nothing in this case since preference is invisible
+            val title = withContext(Dispatchers.Default) {
+                mContext.packageManager.resolveActivity(intent, 0)
+                    ?.loadLabel(mContext.packageManager)
+            } ?: return
+            preference.intent = intent
+            preference.title = title
+            preference.summary = null
+        } else {
+            preference.title = resourcesForSub.getString(R.string.wifi_calling_settings_title)
+            preference.summary = withContext(Dispatchers.Default) { getSummaryForWfcMode() }
+        }
+    }
+
+    private fun getSummaryForWfcMode(): String {
+        val resId = when (imsMmTelRepositoryFactory(mSubId).getWiFiCallingMode()) {
+            ImsMmTelManager.WIFI_MODE_WIFI_ONLY ->
+                com.android.internal.R.string.wfc_mode_wifi_only_summary
+
+            ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED ->
+                com.android.internal.R.string.wfc_mode_cellular_preferred_summary
+
+            ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED ->
+                com.android.internal.R.string.wfc_mode_wifi_preferred_summary
+
+            else -> com.android.internal.R.string.wifi_calling_off_summary
+        }
+        return resourcesForSub.getString(resId)
+    }
+}

src/com/android/settings/network/telephony/ims/ImsMmTelRepository.kt

@@ -0,0 +1,57 @@
+/*
+ * 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.network.telephony.ims
+
+import android.content.Context
+import android.telephony.CarrierConfigManager
+import android.telephony.CarrierConfigManager.KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL
+import android.telephony.TelephonyManager
+import android.telephony.ims.ImsManager
+import android.telephony.ims.ImsMmTelManager
+import android.telephony.ims.ImsMmTelManager.WiFiCallingMode
+
+interface ImsMmTelRepository {
+    @WiFiCallingMode
+    fun getWiFiCallingMode(): Int
+}
+
+class ImsMmTelRepositoryImpl(
+    context: Context,
+    private val subId: Int,
+    private val imsMmTelManager: ImsMmTelManager = ImsManager(context).getImsMmTelManager(subId),
+) : ImsMmTelRepository {
+
+    private val telephonyManager = context.getSystemService(TelephonyManager::class.java)!!
+        .createForSubscriptionId(subId)
+
+    private val carrierConfigManager = context.getSystemService(CarrierConfigManager::class.java)!!
+
+    @WiFiCallingMode
+    override fun getWiFiCallingMode(): Int = when {
+        !imsMmTelManager.isVoWiFiSettingEnabled -> ImsMmTelManager.WIFI_MODE_UNKNOWN
+
+        telephonyManager.isNetworkRoaming && !useWfcHomeModeForRoaming() ->
+            imsMmTelManager.getVoWiFiRoamingModeSetting()
+
+        else -> imsMmTelManager.getVoWiFiModeSetting()
+    }
+
+    private fun useWfcHomeModeForRoaming(): Boolean =
+        carrierConfigManager
+            .getConfigForSubId(subId, KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL)
+            .getBoolean(KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL)
+}

src/com/android/settings/notification/RemoteVolumeGroupController.java

@@ -16,6 +16,8 @@
 
 package com.android.settings.notification;
 
+import android.annotation.NonNull;
+import android.annotation.Nullable;
 import android.content.Context;
 import android.content.Intent;
 import android.media.MediaRouter2Manager;
@@ -53,6 +55,7 @@ public class RemoteVolumeGroupController extends BasePreferenceController implem
     @VisibleForTesting
     static final String SWITCHER_PREFIX = "OUTPUT_SWITCHER";
 
+    @Nullable
     private PreferenceCategory mPreferenceCategory;
     private final List<RoutingSessionInfo> mRoutingSessionInfos = new ArrayList<>();
 
@@ -61,6 +64,7 @@ public class RemoteVolumeGroupController extends BasePreferenceController implem
     @VisibleForTesting
     MediaRouter2Manager mRouterManager;
 
+    // Called via reflection from BasePreferenceController#createInstance().
     public RemoteVolumeGroupController(Context context, String preferenceKey) {
         super(context, preferenceKey);
         if (mLocalMediaManager == null) {
@@ -71,6 +75,19 @@ public class RemoteVolumeGroupController extends BasePreferenceController implem
         mRouterManager = MediaRouter2Manager.getInstance(context);
     }
 
+    @VisibleForTesting
+    /* package */ RemoteVolumeGroupController(
+            @NonNull Context context,
+            @NonNull String preferenceKey,
+            @NonNull LocalMediaManager localMediaManager,
+            @NonNull MediaRouter2Manager mediaRouter2Manager) {
+        super(context, preferenceKey);
+        mLocalMediaManager = localMediaManager;
+        mRouterManager = mediaRouter2Manager;
+        mLocalMediaManager.registerCallback(this);
+        mLocalMediaManager.startScan();
+    }
+
     @Override
     public int getAvailabilityStatus() {
         if (mRoutingSessionInfos.isEmpty()) {

tests/robotests/src/com/android/settings/accounts/WorkModePreferenceControllerTest.java

@@ -41,13 +41,12 @@ import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.ParameterizedRobolectricTestRunner;
-import org.robolectric.RobolectricTestRunner;
 
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
-@RunWith(RobolectricTestRunner.class)
+@RunWith(ParameterizedRobolectricTestRunner.class)
 public class WorkModePreferenceControllerTest {
 
     private static final String PREF_KEY = "work_mode";

tests/robotests/src/com/android/settings/display/ScreenTimeoutSettingsTest.java

@@ -33,6 +33,7 @@ import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.app.KeyguardManager;
 import android.app.admin.DevicePolicyManager;
 import android.content.ContentResolver;
 import android.content.Context;
@@ -41,31 +42,44 @@ import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.content.pm.ServiceInfo;
 import android.content.res.Resources;
+import android.platform.test.annotations.RequiresFlagsEnabled;
+import android.platform.test.flag.junit.CheckFlagsRule;
+import android.platform.test.flag.junit.DeviceFlagsValueProvider;
 import android.provider.SearchIndexableResource;
 import android.provider.Settings;
 
 import androidx.preference.PreferenceScreen;
 
 import com.android.settings.R;
+import com.android.settings.flags.Flags;
 import com.android.settings.testutils.FakeFeatureFactory;
 import com.android.settingslib.RestrictedLockUtils;
+import com.android.settingslib.widget.CandidateInfo;
 import com.android.settingslib.widget.FooterPreference;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
+import org.robolectric.Shadows;
 import org.robolectric.annotation.Config;
+import org.robolectric.shadows.ShadowKeyguardManager;
 
 import java.util.List;
 
 @RunWith(RobolectricTestRunner.class)
 @Config(shadows = {
         com.android.settings.testutils.shadow.ShadowFragment.class,
+        ShadowKeyguardManager.class
 })
 public class ScreenTimeoutSettingsTest {
+
+    @Rule
+    public final CheckFlagsRule mCheckFlagsRule = DeviceFlagsValueProvider.createCheckFlagsRule();
+
     private static final String[] TIMEOUT_ENTRIES = new String[]{"15 secs", "30 secs"};
     private static final String[] TIMEOUT_VALUES = new String[]{"15000", "30000"};
 
@@ -218,4 +232,85 @@ public class ScreenTimeoutSettingsTest {
 
         assertThat(Long.toString(timeout)).isEqualTo(TIMEOUT_VALUES[0]);
     }
+
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_PROTECT_SCREEN_TIMEOUT_WITH_AUTH)
+    public void onClick_whenUserAlreadyAuthenticated_buttonChecked() {
+        String key = "222";
+        String defaultKey = "1";
+        mSettings.setDefaultKey(defaultKey);
+        CandidateInfo info = new ScreenTimeoutSettings.TimeoutCandidateInfo("label", key, false);
+        ScreenTimeoutSettings.ProtectedSelectorWithWidgetPreference pref =
+                new ScreenTimeoutSettings.ProtectedSelectorWithWidgetPreference(
+                        mContext, info.getKey(), mSettings);
+        mSettings.bindPreference(pref, info.getKey(), info, defaultKey);
+        mSettings.setUserAuthenticated(true);
+
+        pref.onClick();
+
+        assertThat(mSettings.getDefaultKey()).isEqualTo(key);
+    }
+
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_PROTECT_SCREEN_TIMEOUT_WITH_AUTH)
+    public void onClick_whenButtonAlreadyChecked_noAuthNeeded() {
+        String key = "222";
+        mSettings.setDefaultKey(key);
+        CandidateInfo info = new ScreenTimeoutSettings.TimeoutCandidateInfo("label", key, false);
+        ScreenTimeoutSettings.ProtectedSelectorWithWidgetPreference pref =
+                new ScreenTimeoutSettings.ProtectedSelectorWithWidgetPreference(
+                        mContext, info.getKey(), mSettings);
+        mSettings.bindPreference(pref, info.getKey(), info, key);
+        mSettings.setUserAuthenticated(false);
+        setAuthPassesAutomatically();
+
+        pref.onClick();
+
+        assertThat(mSettings.isUserAuthenticated()).isFalse();
+    }
+
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_PROTECT_SCREEN_TIMEOUT_WITH_AUTH)
+    public void onClick_whenReducingTimeout_noAuthNeeded() {
+        String key = "1";
+        String defaultKey = "222";
+        mSettings.setDefaultKey(defaultKey);
+        CandidateInfo info = new ScreenTimeoutSettings.TimeoutCandidateInfo("label", key, false);
+        ScreenTimeoutSettings.ProtectedSelectorWithWidgetPreference pref =
+                new ScreenTimeoutSettings.ProtectedSelectorWithWidgetPreference(
+                        mContext, info.getKey(), mSettings);
+        mSettings.bindPreference(pref, info.getKey(), info, defaultKey);
+        mSettings.setUserAuthenticated(false);
+        setAuthPassesAutomatically();
+
+        pref.onClick();
+
+        assertThat(mSettings.isUserAuthenticated()).isFalse();
+        assertThat(mSettings.getDefaultKey()).isEqualTo(key);
+    }
+
+    @Test
+    @RequiresFlagsEnabled(Flags.FLAG_PROTECT_SCREEN_TIMEOUT_WITH_AUTH)
+    public void onClick_whenIncreasingTimeout_authNeeded() {
+        String key = "222";
+        String defaultKey = "1";
+        mSettings.setDefaultKey(defaultKey);
+        CandidateInfo info = new ScreenTimeoutSettings.TimeoutCandidateInfo("label", key, false);
+        ScreenTimeoutSettings.ProtectedSelectorWithWidgetPreference pref =
+                new ScreenTimeoutSettings.ProtectedSelectorWithWidgetPreference(
+                        mContext, info.getKey(), mSettings);
+        mSettings.bindPreference(pref, info.getKey(), info, defaultKey);
+        mSettings.setUserAuthenticated(false);
+        setAuthPassesAutomatically();
+
+        pref.onClick();
+
+        assertThat(mSettings.getDefaultKey()).isEqualTo(key);
+        assertThat(mSettings.isUserAuthenticated()).isTrue();
+    }
+
+    private void setAuthPassesAutomatically() {
+        Shadows.shadowOf(mContext.getSystemService(KeyguardManager.class))
+                .setIsKeyguardSecure(false);
+    }
 }

tests/robotests/src/com/android/settings/network/telephony/VideoCallingPreferenceControllerTest.java

@@ -86,7 +86,8 @@ public class VideoCallingPreferenceControllerTest {
 
         mPreference = new SwitchPreference(mContext);
         mController = spy(new VideoCallingPreferenceController(mContext, "wifi_calling"));
-        mController.init(SUB_ID);
+        mController.init(
+                SUB_ID, new CallingPreferenceCategoryController(mContext, "calling_category"));
         doReturn(mQueryImsState).when(mController).queryImsState(anyInt());
         doReturn(mQueryVoLteState).when(mController).queryVoLteState(anyInt());
         doReturn(true).when(mController).isImsSupported();

tests/robotests/src/com/android/settings/notification/RemoteVolumeGroupControllerTest.java

@@ -103,9 +103,9 @@ public class RemoteVolumeGroupControllerTest {
         mContext = spy(RuntimeEnvironment.application);
         doReturn(mMediaSessionManager).when(mContext).getSystemService(
                 Context.MEDIA_SESSION_SERVICE);
-        mController = new RemoteVolumeGroupController(mContext, KEY_REMOTE_VOLUME_GROUP);
-        mController.mLocalMediaManager = mLocalMediaManager;
-        mController.mRouterManager = mRouterManager;
+        mController =
+                new RemoteVolumeGroupController(
+                        mContext, KEY_REMOTE_VOLUME_GROUP, mLocalMediaManager, mRouterManager);
         mPreferenceCategory = spy(new PreferenceCategory(mContext));
         mPreferenceCategory.setKey(mController.getPreferenceKey());
 

tests/spa_unit/src/com/android/settings/network/telephony/CallingPreferenceCategoryControllerTest.kt

@@ -0,0 +1,80 @@
+/*
+ * 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.network.telephony
+
+import android.content.Context
+import androidx.preference.PreferenceManager
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.settings.spa.preference.ComposePreference
+import com.google.common.truth.Truth.assertThat
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class CallingPreferenceCategoryControllerTest {
+
+    private val context: Context = ApplicationProvider.getApplicationContext()
+
+    private val preference = ComposePreference(context).apply { key = TEST_KEY }
+    private val preferenceScreen = PreferenceManager(context).createPreferenceScreen(context)
+
+    private val controller = CallingPreferenceCategoryController(context, TEST_KEY)
+
+    @Before
+    fun setUp() {
+        preferenceScreen.addPreference(preference)
+        controller.displayPreference(preferenceScreen)
+    }
+
+    @Test
+    fun updateChildVisible_singleChildVisible_categoryVisible() {
+        controller.updateChildVisible(CHILD_A_KEY, true)
+
+        assertThat(preference.isVisible).isTrue()
+    }
+
+    @Test
+    fun updateChildVisible_singleChildNotVisible_categoryNotVisible() {
+        controller.updateChildVisible(CHILD_A_KEY, false)
+
+        assertThat(preference.isVisible).isFalse()
+    }
+
+    @Test
+    fun updateChildVisible_oneChildVisible_categoryVisible() {
+        controller.updateChildVisible(CHILD_A_KEY, true)
+        controller.updateChildVisible(CHILD_B_KEY, false)
+
+        assertThat(preference.isVisible).isTrue()
+    }
+
+    @Test
+    fun updateChildVisible_nonChildNotVisible_categoryNotVisible() {
+        controller.updateChildVisible(CHILD_A_KEY, false)
+        controller.updateChildVisible(CHILD_B_KEY, false)
+
+        assertThat(preference.isVisible).isFalse()
+    }
+
+    private companion object {
+        const val TEST_KEY = "test_key"
+        const val CHILD_A_KEY = "a"
+        const val CHILD_B_KEY = "b"
+    }
+}

tests/spa_unit/src/com/android/settings/network/telephony/WifiCallingPreferenceControllerTest.kt

@@ -0,0 +1,140 @@
+/*
+ * 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.network.telephony
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.provider.Settings
+import android.telecom.PhoneAccountHandle
+import android.telecom.TelecomManager
+import android.telephony.TelephonyManager
+import android.telephony.ims.ImsMmTelManager
+import androidx.lifecycle.testing.TestLifecycleOwner
+import androidx.preference.Preference
+import androidx.preference.PreferenceManager
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.android.settings.network.telephony.ims.ImsMmTelRepository
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.runBlocking
+import org.junit.Before
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.spy
+import org.mockito.kotlin.stub
+
+@RunWith(AndroidJUnit4::class)
+class WifiCallingPreferenceControllerTest {
+    private val mockTelecomManager = mock<TelecomManager>()
+
+    private val context: Context = spy(ApplicationProvider.getApplicationContext()) {
+        on { getSystemService(TelecomManager::class.java) } doReturn mockTelecomManager
+    }
+
+    private val preferenceIntent = Intent()
+
+    private val preference = Preference(context).apply {
+        key = TEST_KEY
+        intent = preferenceIntent
+    }
+    private val preferenceScreen = PreferenceManager(context).createPreferenceScreen(context)
+
+    private var callState = TelephonyManager.CALL_STATE_IDLE
+
+    private object FakeImsMmTelRepository : ImsMmTelRepository {
+        var wiFiMode = ImsMmTelManager.WIFI_MODE_UNKNOWN
+        override fun getWiFiCallingMode() = wiFiMode
+    }
+
+    private val callingPreferenceCategoryController =
+        CallingPreferenceCategoryController(context, "calling_category")
+
+    private val controller = WifiCallingPreferenceController(
+        context = context,
+        key = TEST_KEY,
+        callStateFlowFactory = { flowOf(callState) },
+        imsMmTelRepositoryFactory = { FakeImsMmTelRepository },
+    ).init(subId = SUB_ID, callingPreferenceCategoryController)
+
+    @Before
+    fun setUp() {
+        preferenceScreen.addPreference(preference)
+        controller.displayPreference(preferenceScreen)
+    }
+
+    @Test
+    fun summary_noSimCallManager_setCorrectSummary() = runBlocking {
+        mockTelecomManager.stub {
+            on { getSimCallManagerForSubscription(SUB_ID) } doReturn null
+        }
+        FakeImsMmTelRepository.wiFiMode = ImsMmTelManager.WIFI_MODE_WIFI_ONLY
+
+        controller.onViewCreated(TestLifecycleOwner())
+        delay(100)
+
+        assertThat(preference.summary)
+            .isEqualTo(context.getString(com.android.internal.R.string.wfc_mode_wifi_only_summary))
+    }
+
+    @Test
+    fun summary_hasSimCallManager_summaryIsNull() = runBlocking {
+        mockTelecomManager.stub {
+            on { getSimCallManagerForSubscription(SUB_ID) } doReturn
+                PhoneAccountHandle(ComponentName("", ""), "")
+        }
+
+        controller.onViewCreated(TestLifecycleOwner())
+        delay(100)
+
+        assertThat(preference.summary).isNull()
+    }
+
+    @Test
+    fun isEnabled_callIdle_enabled() = runBlocking {
+        callState = TelephonyManager.CALL_STATE_IDLE
+
+        controller.onViewCreated(TestLifecycleOwner())
+        delay(100)
+
+        assertThat(preference.isEnabled).isTrue()
+    }
+
+    @Test
+    fun isEnabled_notCallIdle_disabled() = runBlocking {
+        callState = TelephonyManager.CALL_STATE_RINGING
+
+        controller.onViewCreated(TestLifecycleOwner())
+        delay(100)
+
+        assertThat(preference.isEnabled).isFalse()
+    }
+
+    @Test
+    fun displayPreference_setsSubscriptionIdOnIntent() = runBlocking {
+        assertThat(preference.intent!!.getIntExtra(Settings.EXTRA_SUB_ID, 0)).isEqualTo(SUB_ID)
+    }
+
+    private companion object {
+        const val TEST_KEY = "test_key"
+        const val SUB_ID = 2
+    }
+}

tests/spa_unit/src/com/android/settings/network/telephony/ims/ImsMmTelRepositoryTest.kt

@@ -0,0 +1,115 @@
+/*
+ * 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.network.telephony.ims
+
+import android.content.Context
+import android.telephony.CarrierConfigManager
+import android.telephony.CarrierConfigManager.KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL
+import android.telephony.TelephonyManager
+import android.telephony.ims.ImsMmTelManager
+import androidx.core.os.persistableBundleOf
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.kotlin.doReturn
+import org.mockito.kotlin.mock
+import org.mockito.kotlin.spy
+import org.mockito.kotlin.stub
+
+@RunWith(AndroidJUnit4::class)
+class ImsMmTelRepositoryTest {
+    private val mockTelephonyManager = mock<TelephonyManager> {
+        on { createForSubscriptionId(SUB_ID) } doReturn mock
+    }
+
+    private val mockCarrierConfigManager = mock<CarrierConfigManager>()
+
+    private val context: Context = spy(ApplicationProvider.getApplicationContext()) {
+        on { getSystemService(TelephonyManager::class.java) } doReturn mockTelephonyManager
+        on { getSystemService(CarrierConfigManager::class.java) } doReturn mockCarrierConfigManager
+    }
+
+    private val mockImsMmTelManager = mock<ImsMmTelManager> {
+        on { isVoWiFiSettingEnabled } doReturn true
+        on { getVoWiFiRoamingModeSetting() } doReturn ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED
+        on { getVoWiFiModeSetting() } doReturn ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED
+    }
+
+    private val repository = ImsMmTelRepositoryImpl(context, SUB_ID, mockImsMmTelManager)
+
+    @Test
+    fun getWiFiCallingMode_voWiFiSettingNotEnabled_returnUnknown() {
+        mockImsMmTelManager.stub {
+            on { isVoWiFiSettingEnabled } doReturn false
+        }
+
+        val wiFiCallingMode = repository.getWiFiCallingMode()
+
+        assertThat(wiFiCallingMode).isEqualTo(ImsMmTelManager.WIFI_MODE_UNKNOWN)
+    }
+
+    @Test
+    fun getWiFiCallingMode_roamingAndNotUseWfcHomeModeForRoaming_returnRoamingSetting() {
+        mockTelephonyManager.stub {
+            on { isNetworkRoaming } doReturn true
+        }
+        mockUseWfcHomeModeForRoaming(false)
+
+        val wiFiCallingMode = repository.getWiFiCallingMode()
+
+        assertThat(wiFiCallingMode).isEqualTo(mockImsMmTelManager.getVoWiFiRoamingModeSetting())
+    }
+
+    @Test
+    fun getWiFiCallingMode_roamingAndUseWfcHomeModeForRoaming_returnHomeSetting() {
+        mockTelephonyManager.stub {
+            on { isNetworkRoaming } doReturn true
+        }
+        mockUseWfcHomeModeForRoaming(true)
+
+        val wiFiCallingMode = repository.getWiFiCallingMode()
+
+        assertThat(wiFiCallingMode).isEqualTo(mockImsMmTelManager.getVoWiFiModeSetting())
+    }
+
+    @Test
+    fun getWiFiCallingMode_notRoaming_returnHomeSetting() {
+        mockTelephonyManager.stub {
+            on { isNetworkRoaming } doReturn false
+        }
+
+        val wiFiCallingMode = repository.getWiFiCallingMode()
+
+        assertThat(wiFiCallingMode).isEqualTo(mockImsMmTelManager.getVoWiFiModeSetting())
+    }
+
+    private fun mockUseWfcHomeModeForRoaming(config: Boolean) {
+        mockCarrierConfigManager.stub {
+            on {
+                getConfigForSubId(SUB_ID, KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL)
+            } doReturn persistableBundleOf(
+                KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL to config,
+            )
+        }
+    }
+
+    private companion object {
+        const val SUB_ID = 1
+    }
+}

tests/unit/src/com/android/settings/network/telephony/WifiCallingPreferenceControllerTest.java

@@ -1,227 +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.network.telephony;
-
-import static com.google.common.truth.Truth.assertThat;
-
-import static org.junit.Assert.assertNull;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.when;
-
-import android.content.Context;
-import android.content.Intent;
-import android.os.PersistableBundle;
-import android.provider.Settings;
-import android.telecom.PhoneAccountHandle;
-import android.telephony.CarrierConfigManager;
-import android.telephony.SubscriptionManager;
-import android.telephony.TelephonyManager;
-import android.telephony.ims.ImsMmTelManager;
-
-import androidx.preference.Preference;
-import androidx.preference.PreferenceManager;
-import androidx.preference.PreferenceScreen;
-import androidx.test.annotation.UiThreadTest;
-import androidx.test.core.app.ApplicationProvider;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-
-import com.android.internal.R;
-import com.android.settings.core.BasePreferenceController;
-import com.android.settings.network.ims.MockWifiCallingQueryImsState;
-import com.android.settings.network.ims.WifiCallingQueryImsState;
-
-import org.junit.Before;
-import org.junit.Ignore;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-@RunWith(AndroidJUnit4.class)
-public class WifiCallingPreferenceControllerTest {
-    private static final int SUB_ID = 2;
-    @Mock
-    private SubscriptionManager mSubscriptionManager;
-    @Mock
-    private CarrierConfigManager mCarrierConfigManager;
-    @Mock
-    private TelephonyManager mTelephonyManager;
-    @Mock
-    private ImsMmTelManager mImsMmTelManager;
-
-    private PreferenceScreen mScreen;
-    private PreferenceManager mPreferenceManager;
-
-    private MockWifiCallingQueryImsState mQueryImsState;
-
-    private TestWifiCallingPreferenceController mController;
-    private Preference mPreference;
-    private Context mContext;
-    private PersistableBundle mCarrierConfig;
-
-    @Before
-    @UiThreadTest
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-
-        mContext = spy(ApplicationProvider.getApplicationContext());
-        when(mContext.getSystemService(SubscriptionManager.class)).thenReturn(mSubscriptionManager);
-
-        mQueryImsState = new MockWifiCallingQueryImsState(mContext, SUB_ID);
-        mQueryImsState.setIsEnabledByUser(true);
-        mQueryImsState.setIsProvisionedOnDevice(true);
-
-        mController = new TestWifiCallingPreferenceController(mContext, "wifi_calling");
-        mController.mCarrierConfigManager = mCarrierConfigManager;
-        mController.init(SUB_ID);
-        mController.mCallState = TelephonyManager.CALL_STATE_IDLE;
-        mCarrierConfig = new PersistableBundle();
-        when(mCarrierConfigManager.getConfigForSubId(SUB_ID)).thenReturn(mCarrierConfig);
-
-        mPreferenceManager = new PreferenceManager(mContext);
-        mScreen = mPreferenceManager.createPreferenceScreen(mContext);
-        mPreference = new Preference(mContext);
-        mPreference.setKey(mController.getPreferenceKey());
-        mScreen.addPreference(mPreference);
-    }
-
-    @Test
-    @UiThreadTest
-    public void updateState_noSimCallManager_setCorrectSummary() {
-        mController.mSimCallManager = null;
-        mQueryImsState.setIsEnabledByUser(true);
-        when(mImsMmTelManager.getVoWiFiRoamingModeSetting()).thenReturn(
-                ImsMmTelManager.WIFI_MODE_WIFI_ONLY);
-        when(mImsMmTelManager.getVoWiFiModeSetting()).thenReturn(
-                ImsMmTelManager.WIFI_MODE_WIFI_ONLY);
-
-        mController.updateState(mPreference);
-
-        assertThat(mPreference.getSummary()).isEqualTo(
-                mContext.getString(com.android.internal.R.string.wfc_mode_wifi_only_summary));
-    }
-
-    @Test
-    @UiThreadTest
-    public void updateState_notCallIdle_disable() {
-        mController.mCallState = TelephonyManager.CALL_STATE_RINGING;
-
-        mController.updateState(mPreference);
-
-        assertThat(mPreference.isEnabled()).isFalse();
-    }
-
-    @Test
-    @UiThreadTest
-    public void updateState_invalidPhoneAccountHandle_shouldNotCrash() {
-        mController.mSimCallManager = new PhoneAccountHandle(null /* invalid */, "");
-
-        //Should not crash
-        mController.updateState(mPreference);
-    }
-
-    @Test
-    @UiThreadTest
-    public void updateState_wfcNonRoamingByConfig() {
-        assertNull(mController.mSimCallManager);
-        mCarrierConfig.putBoolean(
-                CarrierConfigManager.KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL, true);
-        mController.init(SUB_ID);
-
-        when(mImsMmTelManager.getVoWiFiRoamingModeSetting()).thenReturn(
-                ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED);
-        when(mImsMmTelManager.getVoWiFiModeSetting()).thenReturn(
-                ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED);
-        mQueryImsState.setIsEnabledByUser(true);
-        when(mTelephonyManager.isNetworkRoaming()).thenReturn(true);
-
-        mController.updateState(mPreference);
-        assertThat(mPreference.getSummary())
-                .isEqualTo(mContext.getString(R.string.wfc_mode_cellular_preferred_summary));
-    }
-
-    @Test
-    @UiThreadTest
-    public void updateState_wfcRoamingByConfig() {
-        assertNull(mController.mSimCallManager);
-        // useWfcHomeModeForRoaming is false by default. In order to check wfc in roaming mode. We
-        // need the device roaming, and not using home mode in roaming network.
-        when(mImsMmTelManager.getVoWiFiRoamingModeSetting()).thenReturn(
-                ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED);
-        when(mImsMmTelManager.getVoWiFiModeSetting()).thenReturn(
-                ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED);
-        mQueryImsState.setIsEnabledByUser(true);
-        when(mTelephonyManager.isNetworkRoaming()).thenReturn(true);
-
-        mController.updateState(mPreference);
-        assertThat(mPreference.getSummary())
-                .isEqualTo(mContext.getString(R.string.wfc_mode_wifi_preferred_summary));
-    }
-
-    @Test
-    @UiThreadTest
-    public void displayPreference_notAvailable_setPreferenceInvisible() {
-        mController.init(SubscriptionManager.INVALID_SUBSCRIPTION_ID);
-        when(mSubscriptionManager.getActiveSubscriptionInfoList()).thenReturn(null);
-
-        mController.displayPreference(mScreen);
-
-        assertThat(mController.getPreferenceKey()).isEqualTo("wifi_calling");
-        assertThat(mScreen.findPreference(mController.getPreferenceKey()).isVisible()).isFalse();
-    }
-
-    @Test
-    @Ignore
-    public void displayPreference_available_setsSubscriptionIdOnIntent() {
-        final Intent intent = new Intent();
-        mPreference.setIntent(intent);
-        mController.displayPreference(mScreen);
-        assertThat(intent.getIntExtra(Settings.EXTRA_SUB_ID,
-                SubscriptionManager.INVALID_SUBSCRIPTION_ID)).isEqualTo(SUB_ID);
-    }
-
-    @Test
-    @UiThreadTest
-    public void getAvailabilityStatus_noWiFiCalling_shouldReturnUnsupported() {
-        mController.init(SubscriptionManager.INVALID_SUBSCRIPTION_ID);
-        when(mSubscriptionManager.getActiveSubscriptionInfoList()).thenReturn(null);
-
-        assertThat(mController.getAvailabilityStatus()).isEqualTo(
-                BasePreferenceController.UNSUPPORTED_ON_DEVICE);
-    }
-
-    private class TestWifiCallingPreferenceController extends WifiCallingPreferenceController {
-        TestWifiCallingPreferenceController(Context context, String preferenceKey) {
-            super(context, preferenceKey);
-        }
-
-        @Override
-        protected ImsMmTelManager getImsMmTelManager(int subId) {
-            return mImsMmTelManager;
-        }
-
-        @Override
-        protected TelephonyManager getTelephonyManager(Context context, int subId) {
-            return mTelephonyManager;
-        }
-
-        @Override
-        protected WifiCallingQueryImsState queryImsState(int subId) {
-            return mQueryImsState;
-        }
-    }
-}