[Settings] Hidden API remove - WFC mode settings

Change API from getWfcMode/setWfcMode into APIs within ImsMmTelManager. Bug: 140542283 Test: make RunSettingsRoboTests -j ROBOTEST_FILTER=WifiCallingPreferenceControllerTest make RunSettingsRoboTests -j ROBOTEST_FILTER=WifiCallingSettingsForSubTest make RunSettingsRoboTests -j ROBOTEST_FILTER=WifiCallingSliceHelperTest atest WifiCallingSettingUiTest Change-Id: I2ee01852cb4ee90fe9db256d3333f461cc070da5
2019-11-06 10:57:01 +08:00
parent 5243629d25
commit c3b94292ea
7 changed files with 183 additions and 139 deletions
--- a/src/com/android/settings/network/telephony/WifiCallingPreferenceController.java
+++ b/src/com/android/settings/network/telephony/WifiCallingPreferenceController.java
@@ -29,12 +29,12 @@ import android.telephony.CarrierConfigManager;
 import android.telephony.PhoneStateListener;
 import android.telephony.SubscriptionManager;
 import android.telephony.TelephonyManager;
+import android.telephony.ims.ImsMmTelManager;

 import androidx.annotation.VisibleForTesting;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceScreen;

-import com.android.ims.ImsConfig;
 import com.android.ims.ImsManager;
 import com.android.settings.R;
 import com.android.settingslib.core.lifecycle.LifecycleObserver;
@@ -54,6 +54,7 @@ public class WifiCallingPreferenceController extends TelephonyBasePreferenceCont
    CarrierConfigManager mCarrierConfigManager;
    @VisibleForTesting
    ImsManager mImsManager;
+    private ImsMmTelManager mImsMmTelManager;
    @VisibleForTesting
    PhoneAccountHandle mSimCallManager;
    private PhoneCallStateListener mPhoneStateListener;
@@ -88,7 +89,7 @@ public class WifiCallingPreferenceController extends TelephonyBasePreferenceCont
    public void displayPreference(PreferenceScreen screen) {
        super.displayPreference(screen);
        mPreference = screen.findPreference(getPreferenceKey());
-        Intent intent = mPreference.getIntent();
+        final Intent intent = mPreference.getIntent();
        if (intent != null) {
            intent.putExtra(Settings.EXTRA_SUB_ID, mSubId);
        }
@@ -98,14 +99,14 @@ public class WifiCallingPreferenceController extends TelephonyBasePreferenceCont
    public void updateState(Preference preference) {
        super.updateState(preference);
        if (mSimCallManager != null) {
-            Intent intent = MobileNetworkUtils.buildPhoneAccountConfigureIntent(mContext,
+            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();
-            List<ResolveInfo> resolutions = pm.queryIntentActivities(intent, 0);
+            final List<ResolveInfo> resolutions = pm.queryIntentActivities(intent, 0);
            preference.setTitle(resolutions.get(0).loadLabel(pm));
            preference.setSummary(null);
            preference.setIntent(intent);
@@ -126,16 +127,18 @@ public class WifiCallingPreferenceController extends TelephonyBasePreferenceCont
                    }
                }
                final boolean isRoaming = mTelephonyManager.isNetworkRoaming();
-                int wfcMode = mImsManager.getWfcMode(isRoaming && !useWfcHomeModeForRoaming);
+                final int wfcMode = (isRoaming && !useWfcHomeModeForRoaming)
+                        ? mImsMmTelManager.getVoWiFiRoamingModeSetting() :
+                        mImsMmTelManager.getVoWiFiModeSetting();
                switch (wfcMode) {
-                    case ImsConfig.WfcModeFeatureValueConstants.WIFI_ONLY:
+                    case ImsMmTelManager.WIFI_MODE_WIFI_ONLY:
                        resId = com.android.internal.R.string.wfc_mode_wifi_only_summary;
                        break;
-                    case ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED:
+                    case ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED:
                        resId = com.android.internal.R.string
                                .wfc_mode_cellular_preferred_summary;
                        break;
-                    case ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED:
+                    case ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED:
                        resId = com.android.internal.R.string.wfc_mode_wifi_preferred_summary;
                        break;
                    default:
@@ -150,14 +153,20 @@ public class WifiCallingPreferenceController extends TelephonyBasePreferenceCont

    public WifiCallingPreferenceController init(int subId) {
        mSubId = subId;
-        mTelephonyManager = TelephonyManager.from(mContext).createForSubscriptionId(mSubId);
+        mTelephonyManager = mContext.getSystemService(TelephonyManager.class)
+                .createForSubscriptionId(mSubId);
        mImsManager = ImsManager.getInstance(mContext, SubscriptionManager.getPhoneId(mSubId));
+        mImsMmTelManager = getImsMmTelManager(mSubId);
        mSimCallManager = mContext.getSystemService(TelecomManager.class)
                .getSimCallManagerForSubscription(mSubId);

        return this;
    }

+    protected ImsMmTelManager getImsMmTelManager(int subId) {
+        return ImsMmTelManager.createForSubscriptionId(subId);
+    }
+
    private class PhoneCallStateListener extends PhoneStateListener {

        public PhoneCallStateListener(Looper looper) {
--- a/src/com/android/settings/wifi/calling/WifiCallingSettingsForSub.java
+++ b/src/com/android/settings/wifi/calling/WifiCallingSettingsForSub.java
@@ -30,6 +30,7 @@ import android.telephony.CarrierConfigManager;
 import android.telephony.PhoneStateListener;
 import android.telephony.SubscriptionManager;
 import android.telephony.TelephonyManager;
+import android.telephony.ims.ImsMmTelManager;
 import android.telephony.ims.ProvisioningManager;
 import android.text.TextUtils;
 import android.util.Log;
@@ -98,6 +99,7 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment

    private int mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
    private ImsManager mImsManager;
+    private ImsMmTelManager mImsMmTelManager;
    private TelephonyManager mTelephonyManager;

    private final PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
@@ -110,8 +112,8 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
        @Override
        public void onCallStateChanged(int state, String incomingNumber) {
            final SettingsActivity activity = (SettingsActivity) getActivity();
-            boolean isNonTtyOrTtyOnVolteEnabled = mImsManager.isNonTtyOrTtyOnVolteEnabled();
-            boolean isWfcEnabled = mSwitchBar.isChecked()
+            final boolean isNonTtyOrTtyOnVolteEnabled = mImsManager.isNonTtyOrTtyOnVolteEnabled();
+            final boolean isWfcEnabled = mSwitchBar.isChecked()
                    && isNonTtyOrTtyOnVolteEnabled;

            mSwitchBar.setEnabled((state == TelephonyManager.CALL_STATE_IDLE)
@@ -132,12 +134,12 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
                }
            }

-            Preference pref = getPreferenceScreen().findPreference(BUTTON_WFC_MODE);
+            final Preference pref = getPreferenceScreen().findPreference(BUTTON_WFC_MODE);
            if (pref != null) {
                pref.setEnabled(isWfcEnabled && isWfcModeEditable
                        && (state == TelephonyManager.CALL_STATE_IDLE));
            }
-            Preference pref_roam =
+            final Preference pref_roam =
                    getPreferenceScreen().findPreference(BUTTON_WFC_ROAMING_MODE);
            if (pref_roam != null) {
                pref_roam.setEnabled(isWfcEnabled && isWfcRoamingModeEditable
@@ -151,7 +153,7 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
     */
    private final OnPreferenceClickListener mUpdateAddressListener =
            preference -> {
-                Intent carrierAppIntent = getCarrierActivityIntent();
+                final Intent carrierAppIntent = getCarrierActivityIntent();
                if (carrierAppIntent != null) {
                    carrierAppIntent.putExtra(EXTRA_LAUNCH_CARRIER_APP, LAUCH_APP_UPDATE);
                    startActivity(carrierAppIntent);
@@ -179,7 +181,7 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
        mEmptyView = getView().findViewById(android.R.id.empty);
        setEmptyView(mEmptyView);
        final Resources res = getResourcesForSubId();
-        String emptyViewText = res.getString(R.string.wifi_calling_off_explanation,
+        final String emptyViewText = res.getString(R.string.wifi_calling_off_explanation,
                res.getString(R.string.wifi_calling_off_explanation_2));
        mEmptyView.setText(emptyViewText);

@@ -195,17 +197,17 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
    }

    private void showAlert(Intent intent) {
-        Context context = getActivity();
+        final Context context = getActivity();

-        CharSequence title = intent.getCharSequenceExtra(Phone.EXTRA_KEY_ALERT_TITLE);
-        CharSequence message = intent.getCharSequenceExtra(Phone.EXTRA_KEY_ALERT_MESSAGE);
+        final CharSequence title = intent.getCharSequenceExtra(Phone.EXTRA_KEY_ALERT_TITLE);
+        final CharSequence message = intent.getCharSequenceExtra(Phone.EXTRA_KEY_ALERT_MESSAGE);

-        AlertDialog.Builder builder = new AlertDialog.Builder(context);
+        final AlertDialog.Builder builder = new AlertDialog.Builder(context);
        builder.setMessage(message)
                .setTitle(title)
                .setIcon(android.R.drawable.ic_dialog_alert)
                .setPositiveButton(android.R.string.ok, null);
-        AlertDialog dialog = builder.create();
+        final AlertDialog dialog = builder.create();
        dialog.show();
    }

@@ -214,7 +216,7 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
    private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
-            String action = intent.getAction();
+            final String action = intent.getAction();
            if (action.equals(ImsManager.ACTION_IMS_REGISTRATION_ERROR)) {
                // If this fragment is active then we are immediately
                // showing alert on screen. There is no need to add
@@ -245,6 +247,11 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
        return ImsManager.getInstance(getActivity(), SubscriptionManager.getPhoneId(mSubId));
    }

+    @VisibleForTesting
+    ImsMmTelManager getImsMmTelManager() {
+        return ImsMmTelManager.createForSubscriptionId(mSubId);
+    }
+
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
@@ -261,6 +268,7 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
        }

        mImsManager = getImsManager();
+        mImsMmTelManager = getImsMmTelManager();

        mTelephonyManager = ((TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE))
                .createForSubscriptionId(mSubId);
@@ -288,12 +296,12 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {

-        View view = inflater.inflate(
+        final View view = inflater.inflate(
                R.layout.wifi_calling_settings_preferences, container, false);

        final ViewGroup prefs_container = view.findViewById(R.id.prefs_container);
        Utils.prepareCustomPreferencesList(container, view, prefs_container, false);
-        View prefs = super.onCreateView(inflater, prefs_container, savedInstanceState);
+        final View prefs = super.onCreateView(inflater, prefs_container, savedInstanceState);
        prefs_container.addView(prefs);

        return view;
@@ -307,12 +315,12 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
            return;
        }

-        CarrierConfigManager configManager = (CarrierConfigManager)
+        final CarrierConfigManager configManager = (CarrierConfigManager)
                getSystemService(Context.CARRIER_CONFIG_SERVICE);
        boolean isWifiOnlySupported = true;

        if (configManager != null) {
-            PersistableBundle b = configManager.getConfigForSubId(mSubId);
+            final PersistableBundle b = configManager.getConfigForSubId(mSubId);
            if (b != null) {
                mEditableWfcMode = b.getBoolean(
                        CarrierConfigManager.KEY_EDITABLE_WFC_MODE_BOOL);
@@ -341,11 +349,11 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment


        // NOTE: Buttons will be enabled/disabled in mPhoneStateListener
-        boolean wfcEnabled = mImsManager.isWfcEnabledByUser()
+        final boolean wfcEnabled = mImsManager.isWfcEnabledByUser()
                && mImsManager.isNonTtyOrTtyOnVolteEnabled();
        mSwitch.setChecked(wfcEnabled);
-        int wfcMode = mImsManager.getWfcMode(false);
-        int wfcRoamingMode = mImsManager.getWfcMode(true);
+        final int wfcMode = mImsMmTelManager.getVoWiFiModeSetting();
+        final int wfcRoamingMode = mImsMmTelManager.getVoWiFiRoamingModeSetting();
        mButtonWfcMode.setValue(Integer.toString(wfcMode));
        mButtonWfcRoamingMode.setValue(Integer.toString(wfcRoamingMode));
        updateButtonWfcMode(wfcEnabled, wfcMode, wfcRoamingMode);
@@ -369,7 +377,7 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment

        context.registerReceiver(mIntentReceiver, mIntentFilter);

-        Intent intent = getActivity().getIntent();
+        final Intent intent = getActivity().getIntent();
        if (intent.getBooleanExtra(Phone.EXTRA_KEY_ALERT_SHOW, false)) {
            showAlert(intent);
        }
@@ -392,7 +400,8 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
        if (mValidListener) {
            mValidListener = false;

-            TelephonyManager tm = (TelephonyManager) getSystemService(Context.TELEPHONY_SERVICE);
+            final TelephonyManager tm = (TelephonyManager)
+                    getSystemService(Context.TELEPHONY_SERVICE);
            tm.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);

            mSwitchBar.removeOnSwitchChangeListener(this);
@@ -441,22 +450,22 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
     */
    private Intent getCarrierActivityIntent() {
        // Retrive component name from carrier config
-        CarrierConfigManager configManager =
+        final CarrierConfigManager configManager =
                getActivity().getSystemService(CarrierConfigManager.class);
        if (configManager == null) return null;

-        PersistableBundle bundle = configManager.getConfigForSubId(mSubId);
+        final PersistableBundle bundle = configManager.getConfigForSubId(mSubId);
        if (bundle == null) return null;

-        String carrierApp = bundle.getString(
+        final String carrierApp = bundle.getString(
                CarrierConfigManager.KEY_WFC_EMERGENCY_ADDRESS_CARRIER_APP_STRING);
        if (TextUtils.isEmpty(carrierApp)) return null;

-        ComponentName componentName = ComponentName.unflattenFromString(carrierApp);
+        final ComponentName componentName = ComponentName.unflattenFromString(carrierApp);
        if (componentName == null) return null;

        // Build and return intent
-        Intent intent = new Intent();
+        final Intent intent = new Intent();
        intent.setComponent(componentName);
        intent.putExtra(SubscriptionManager.EXTRA_SUBSCRIPTION_INDEX, mSubId);
        return intent;
@@ -469,8 +478,8 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
        Log.i(TAG, "updateWfcMode(" + wfcEnabled + ")");
        mImsManager.setWfcSetting(wfcEnabled);

-        int wfcMode = mImsManager.getWfcMode(false);
-        int wfcRoamingMode = mImsManager.getWfcMode(true);
+        final int wfcMode = mImsMmTelManager.getVoWiFiModeSetting();
+        final int wfcRoamingMode = mImsMmTelManager.getVoWiFiRoamingModeSetting();
        updateButtonWfcMode(wfcEnabled, wfcMode, wfcRoamingMode);
        if (wfcEnabled) {
            mMetricsFeatureProvider.action(getActivity(), getMetricsCategory(), wfcMode);
@@ -496,7 +505,7 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
            case REQUEST_CHECK_WFC_DISCLAIMER:
                if (resultCode == Activity.RESULT_OK) {
                    // Call address management activity before turning on WFC
-                    Intent carrierAppIntent = getCarrierActivityIntent();
+                    final Intent carrierAppIntent = getCarrierActivityIntent();
                    if (carrierAppIntent != null) {
                        carrierAppIntent.putExtra(EXTRA_LAUNCH_CARRIER_APP, LAUCH_APP_ACTIVATE);
                        startActivityForResult(carrierAppIntent,
@@ -520,7 +529,7 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
        mButtonWfcRoamingMode.setEnabled(wfcEnabled && mEditableWfcRoamingMode);

        final PreferenceScreen preferenceScreen = getPreferenceScreen();
-        boolean updateAddressEnabled = (getCarrierActivityIntent() != null);
+        final boolean updateAddressEnabled = (getCarrierActivityIntent() != null);
        if (wfcEnabled) {
            if (mEditableWfcMode) {
                preferenceScreen.addPreference(mButtonWfcMode);
@@ -551,24 +560,24 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
        if (preference == mButtonWfcMode) {
            Log.d(TAG, "onPreferenceChange mButtonWfcMode " + newValue);
            mButtonWfcMode.setValue((String) newValue);
-            int buttonMode = Integer.valueOf((String) newValue);
-            int currentWfcMode = mImsManager.getWfcMode(false);
+            final int buttonMode = Integer.valueOf((String) newValue);
+            final int currentWfcMode = mImsMmTelManager.getVoWiFiModeSetting();
            if (buttonMode != currentWfcMode) {
-                mImsManager.setWfcMode(buttonMode, false);
+                mImsMmTelManager.setVoWiFiModeSetting(buttonMode);
                mButtonWfcMode.setSummary(getWfcModeSummary(buttonMode));
                mMetricsFeatureProvider.action(getActivity(), getMetricsCategory(), buttonMode);

                if (mUseWfcHomeModeForRoaming) {
-                    mImsManager.setWfcMode(buttonMode, true);
+                    mImsMmTelManager.setVoWiFiRoamingModeSetting(buttonMode);
                    // mButtonWfcRoamingMode.setSummary is not needed; summary is selected value
                }
            }
        } else if (preference == mButtonWfcRoamingMode) {
            mButtonWfcRoamingMode.setValue((String) newValue);
-            int buttonMode = Integer.valueOf((String) newValue);
-            int currentMode = mImsManager.getWfcMode(true);
+            final int buttonMode = Integer.valueOf((String) newValue);
+            final int currentMode = mImsMmTelManager.getVoWiFiRoamingModeSetting();
            if (buttonMode != currentMode) {
-                mImsManager.setWfcMode(buttonMode, true);
+                mImsMmTelManager.setVoWiFiRoamingModeSetting(buttonMode);
                // mButtonWfcRoamingMode.setSummary is not needed; summary is just selected value.
                mMetricsFeatureProvider.action(getActivity(), getMetricsCategory(), buttonMode);
            }
@@ -580,13 +589,13 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
        int resId = com.android.internal.R.string.wifi_calling_off_summary;
        if (mImsManager.isWfcEnabledByUser()) {
            switch (wfcMode) {
-                case ImsConfig.WfcModeFeatureValueConstants.WIFI_ONLY:
+                case ImsMmTelManager.WIFI_MODE_WIFI_ONLY:
                    resId = com.android.internal.R.string.wfc_mode_wifi_only_summary;
                    break;
-                case ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED:
+                case ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED:
                    resId = com.android.internal.R.string.wfc_mode_cellular_preferred_summary;
                    break;
-                case ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED:
+                case ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED:
                    resId = com.android.internal.R.string.wfc_mode_wifi_preferred_summary;
                    break;
                default:
--- a/src/com/android/settings/wifi/calling/WifiCallingSliceHelper.java
+++ b/src/com/android/settings/wifi/calling/WifiCallingSliceHelper.java
@@ -30,6 +30,7 @@ import android.os.PersistableBundle;
 import android.provider.Settings;
 import android.telephony.CarrierConfigManager;
 import android.telephony.SubscriptionManager;
+import android.telephony.ims.ImsMmTelManager;
 import android.text.TextUtils;
 import android.util.Log;

@@ -233,6 +234,7 @@ public class WifiCallingSliceHelper {
        final boolean isWifiOnlySupported = isCarrierConfigManagerKeyEnabled(
                CarrierConfigManager.KEY_CARRIER_WFC_SUPPORTS_WIFI_ONLY_BOOL, subId, true);
        final ImsManager imsManager = getImsManager(subId);
+        final ImsMmTelManager imsMmTelManager = getImsMmTelManager(subId);

        if (!imsManager.isWfcEnabledByPlatform()
                || !imsManager.isWfcProvisionedOnDevice()) {
@@ -249,7 +251,7 @@ public class WifiCallingSliceHelper {
        int wfcMode = -1;
        try {
            isWifiCallingEnabled = isWifiCallingEnabled(imsManager);
-            wfcMode = getWfcMode(imsManager);
+            wfcMode = getWfcMode(imsMmTelManager);
        } catch (InterruptedException | ExecutionException | TimeoutException e) {
            Log.e(TAG, "Unable to get wifi calling preferred mode", e);
            return null;
@@ -279,7 +281,7 @@ public class WifiCallingSliceHelper {
            Uri sliceUri) {
        final IconCompat icon = IconCompat.createWithResource(mContext, R.drawable.wifi_signal);
        // Top row shows information on current preference state
-        ListBuilder listBuilder = new ListBuilder(mContext, sliceUri, ListBuilder.INFINITY)
+        final ListBuilder listBuilder = new ListBuilder(mContext, sliceUri, ListBuilder.INFINITY)
                .setAccentColor(Utils.getColorAccentDefaultColor(mContext));
        listBuilder.setHeader(new ListBuilder.HeaderBuilder()
                .setTitle(mContext.getText(R.string.wifi_calling_mode_title))
@@ -294,18 +296,18 @@ public class WifiCallingSliceHelper {
            listBuilder.addRow(wifiPreferenceRowBuilder(listBuilder,
                    com.android.internal.R.string.wfc_mode_wifi_only_summary,
                    ACTION_WIFI_CALLING_PREFERENCE_WIFI_ONLY,
-                    currentWfcPref == ImsConfig.WfcModeFeatureValueConstants.WIFI_ONLY));
+                    currentWfcPref == ImsMmTelManager.WIFI_MODE_WIFI_ONLY));
        }

        listBuilder.addRow(wifiPreferenceRowBuilder(listBuilder,
                com.android.internal.R.string.wfc_mode_wifi_preferred_summary,
                ACTION_WIFI_CALLING_PREFERENCE_WIFI_PREFERRED,
-                currentWfcPref == ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED));
+                currentWfcPref == ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED));

        listBuilder.addRow(wifiPreferenceRowBuilder(listBuilder,
                com.android.internal.R.string.wfc_mode_cellular_preferred_summary,
                ACTION_WIFI_CALLING_PREFERENCE_CELLULAR_PREFERRED,
-                currentWfcPref == ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED));
+                currentWfcPref == ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED));

        return listBuilder.build();
    }
@@ -337,13 +339,13 @@ public class WifiCallingSliceHelper {
     */
    private CharSequence getWifiCallingPreferenceSummary(int wfcMode) {
        switch (wfcMode) {
-            case ImsConfig.WfcModeFeatureValueConstants.WIFI_ONLY:
+            case ImsMmTelManager.WIFI_MODE_WIFI_ONLY:
                return mContext.getText(
                        com.android.internal.R.string.wfc_mode_wifi_only_summary);
-            case ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED:
+            case ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED:
                return mContext.getText(
                        com.android.internal.R.string.wfc_mode_wifi_preferred_summary);
-            case ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED:
+            case ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED:
                return mContext.getText(
                        com.android.internal.R.string.wfc_mode_cellular_preferred_summary);
            default:
@@ -355,15 +357,19 @@ public class WifiCallingSliceHelper {
        return ImsManager.getInstance(mContext, SubscriptionManager.getPhoneId(subId));
    }

-    private int getWfcMode(ImsManager imsManager)
+    protected ImsMmTelManager getImsMmTelManager(int subId) {
+        return ImsMmTelManager.createForSubscriptionId(subId);
+    }
+
+    private int getWfcMode(ImsMmTelManager imsMmTelManager)
            throws InterruptedException, ExecutionException, TimeoutException {
-        FutureTask<Integer> wfcModeTask = new FutureTask<>(new Callable<Integer>() {
+        final FutureTask<Integer> wfcModeTask = new FutureTask<>(new Callable<Integer>() {
            @Override
            public Integer call() {
-                return imsManager.getWfcMode(false);
+                return imsMmTelManager.getVoWiFiModeSetting();
            }
        });
-        ExecutorService executor = Executors.newSingleThreadExecutor();
+        final ExecutorService executor = Executors.newSingleThreadExecutor();
        executor.execute(wfcModeTask);
        return wfcModeTask.get(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS);
    }
@@ -420,7 +426,7 @@ public class WifiCallingSliceHelper {
            final boolean isWifiOnlySupported = isCarrierConfigManagerKeyEnabled(
                    CarrierConfigManager.KEY_CARRIER_WFC_SUPPORTS_WIFI_ONLY_BOOL, subId, true);

-            ImsManager imsManager = getImsManager(subId);
+            final ImsManager imsManager = getImsManager(subId);
            if (isWifiCallingPrefEditable
                    && imsManager.isWfcEnabledByPlatform()
                    && imsManager.isWfcProvisionedOnDevice()
@@ -428,25 +434,26 @@ public class WifiCallingSliceHelper {
                    && imsManager.isNonTtyOrTtyOnVolteEnabled()) {
                // Change the preference only when wifi calling is enabled
                // And when wifi calling preference is editable for the current carrier
-                final int currentValue = imsManager.getWfcMode(false);
+                final ImsMmTelManager imsMmTelManager = getImsMmTelManager(subId);
+                final int currentValue = imsMmTelManager.getVoWiFiModeSetting();
                int newValue = errorValue;
                switch (intent.getAction()) {
                    case ACTION_WIFI_CALLING_PREFERENCE_WIFI_ONLY:
                        if (isWifiOnlySupported) {
                            // change to wifi_only when wifi_only is enabled.
-                            newValue = ImsConfig.WfcModeFeatureValueConstants.WIFI_ONLY;
+                            newValue = ImsMmTelManager.WIFI_MODE_WIFI_ONLY;
                        }
                        break;
                    case ACTION_WIFI_CALLING_PREFERENCE_WIFI_PREFERRED:
-                        newValue = ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED;
+                        newValue = ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED;
                        break;
                    case ACTION_WIFI_CALLING_PREFERENCE_CELLULAR_PREFERRED:
-                        newValue = ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED;
+                        newValue = ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED;
                        break;
                }
                if (newValue != errorValue && newValue != currentValue) {
                    // Update the setting only when there is a valid update
-                    imsManager.setWfcMode(newValue, false);
+                    imsMmTelManager.setVoWiFiModeSetting(newValue);
                }
            }
        }
--- a/tests/robotests/src/com/android/settings/network/telephony/WifiCallingPreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/network/telephony/WifiCallingPreferenceControllerTest.java
@@ -19,7 +19,6 @@ package com.android.settings.network.telephony;
 import static com.google.common.truth.Truth.assertThat;

 import static org.junit.Assert.assertNull;
-import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;

@@ -31,12 +30,11 @@ 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.PreferenceCategory;
 import androidx.preference.PreferenceScreen;

-import com.android.ims.ImsConfig;
 import com.android.ims.ImsManager;
 import com.android.internal.R;
 import com.android.settings.core.BasePreferenceController;
@@ -60,6 +58,8 @@ public class WifiCallingPreferenceControllerTest {
    @Mock
    private ImsManager mImsManager;
    @Mock
+    private ImsMmTelManager mImsMmTelManager;
+    @Mock
    private PreferenceScreen mPreferenceScreen;

    private WifiCallingPreferenceController mController;
@@ -77,7 +77,12 @@ public class WifiCallingPreferenceControllerTest {
        when(mTelephonyManager.createForSubscriptionId(SUB_ID)).thenReturn(mTelephonyManager);

        mPreference = new Preference(mContext);
-        mController = new WifiCallingPreferenceController(mContext, "wifi_calling");
+        mController = new WifiCallingPreferenceController(mContext, "wifi_calling") {
+            @Override
+            protected ImsMmTelManager getImsMmTelManager(int subId) {
+                return mImsMmTelManager;
+            }
+        };
        mController.mCarrierConfigManager = mCarrierConfigManager;
        mController.init(SUB_ID);
        mController.mImsManager = mImsManager;
@@ -94,8 +99,10 @@ public class WifiCallingPreferenceControllerTest {
    public void updateState_noSimCallManager_setCorrectSummary() {
        mController.mSimCallManager = null;
        when(mImsManager.isWfcEnabledByUser()).thenReturn(true);
-        when(mImsManager.getWfcMode(anyBoolean())).thenReturn(
-                ImsConfig.WfcModeFeatureValueConstants.WIFI_ONLY);
+        when(mImsMmTelManager.getVoWiFiRoamingModeSetting()).thenReturn(
+                ImsMmTelManager.WIFI_MODE_WIFI_ONLY);
+        when(mImsMmTelManager.getVoWiFiModeSetting()).thenReturn(
+                ImsMmTelManager.WIFI_MODE_WIFI_ONLY);

        mController.updateState(mPreference);

@@ -129,10 +136,10 @@ public class WifiCallingPreferenceControllerTest {
        mController.init(SUB_ID);
        mController.mImsManager = mImsManager;

-        when(mImsManager.getWfcMode(true)).thenReturn(
-                ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED);
-        when(mImsManager.getWfcMode(false)).thenReturn(
-                ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED);
+        when(mImsMmTelManager.getVoWiFiRoamingModeSetting()).thenReturn(
+                ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED);
+        when(mImsMmTelManager.getVoWiFiModeSetting()).thenReturn(
+                ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED);
        when(mImsManager.isWfcEnabledByUser()).thenReturn(true);
        when(mTelephonyManager.isNetworkRoaming()).thenReturn(true);

@@ -146,10 +153,10 @@ public class WifiCallingPreferenceControllerTest {
        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(mImsManager.getWfcMode(true)).thenReturn(
-                ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED);
-        when(mImsManager.getWfcMode(false)).thenReturn(
-                ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED);
+        when(mImsMmTelManager.getVoWiFiRoamingModeSetting()).thenReturn(
+                ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED);
+        when(mImsMmTelManager.getVoWiFiModeSetting()).thenReturn(
+                ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED);
        when(mImsManager.isWfcEnabledByUser()).thenReturn(true);
        when(mTelephonyManager.isNetworkRoaming()).thenReturn(true);

@@ -169,7 +176,7 @@ public class WifiCallingPreferenceControllerTest {

    @Test
    public void displayPreference_available_setsSubscriptionIdOnIntent() {
-        Intent intent = new Intent();
+        final Intent intent = new Intent();
        mPreference.setIntent(intent);
        mController.displayPreference(mPreferenceScreen);
        assertThat(intent.getIntExtra(Settings.EXTRA_SUB_ID,
--- a/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSettingsForSubTest.java
+++ b/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSettingsForSubTest.java
@@ -17,11 +17,12 @@
 package com.android.settings.wifi.calling;

 import static com.android.settings.SettingsActivity.EXTRA_SHOW_FRAGMENT;
+
 import static com.google.common.truth.Truth.assertThat;

 import static junit.framework.Assert.assertEquals;
+
 import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyBoolean;
 import static org.mockito.Matchers.anyInt;
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.doNothing;
@@ -42,6 +43,7 @@ import android.os.Bundle;
 import android.os.PersistableBundle;
 import android.telephony.CarrierConfigManager;
 import android.telephony.TelephonyManager;
+import android.telephony.ims.ImsMmTelManager;
 import android.telephony.ims.ProvisioningManager;
 import android.view.View;
 import android.widget.TextView;
@@ -53,8 +55,6 @@ import com.android.ims.ImsConfig;
 import com.android.ims.ImsManager;
 import com.android.settings.R;
 import com.android.settings.SettingsActivity;
-import com.android.settings.testutils.FakeFeatureFactory;
-import com.android.settings.testutils.shadow.SettingsShadowResources;
 import com.android.settings.testutils.shadow.ShadowFragment;
 import com.android.settings.widget.SwitchBar;
 import com.android.settings.widget.ToggleSwitch;
@@ -67,8 +67,8 @@ import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
-import org.robolectric.util.ReflectionHelpers;
 import org.robolectric.annotation.Config;
+import org.robolectric.util.ReflectionHelpers;

@Config(shadows = ShadowFragment.class)
@RunWith(RobolectricTestRunner.class)
@@ -86,6 +86,7 @@ public class WifiCallingSettingsForSubTest {
    @Mock private static CarrierConfigManager sCarrierConfigManager;
    @Mock private CarrierConfigManager mMockConfigManager;
    @Mock private ImsManager mImsManager;
+    @Mock private ImsMmTelManager mImsMmTelManager;
    @Mock private TelephonyManager mTelephonyManager;
    @Mock private PreferenceScreen mPreferenceScreen;
    @Mock private SettingsActivity mActivity;
@@ -127,12 +128,15 @@ public class WifiCallingSettingsForSubTest {
        doReturn(mSwitchBar).when(mView).findViewById(R.id.switch_bar);

        doReturn(mImsManager).when(mFragment).getImsManager();
+        doReturn(mImsMmTelManager).when(mFragment).getImsMmTelManager();
        doReturn(mImsConfig).when(mImsManager).getConfigInterface();
        doReturn(true).when(mImsManager).isWfcProvisionedOnDevice();
        doReturn(true).when(mImsManager).isWfcEnabledByUser();
        doReturn(true).when(mImsManager).isNonTtyOrTtyOnVolteEnabled();
-        doReturn(ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED)
-                .when(mImsManager).getWfcMode(anyBoolean());
+        doReturn(ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED)
+                .when(mImsMmTelManager).getVoWiFiModeSetting();
+        doReturn(ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED)
+                .when(mImsMmTelManager).getVoWiFiRoamingModeSetting();

        doReturn(mBundle).when(sCarrierConfigManager).getConfigForSubId(anyInt());
        setDefaultCarrierConfigValues();
@@ -251,15 +255,13 @@ public class WifiCallingSettingsForSubTest {

        // Set the WFC home mode.
        mFragment.onPreferenceChange(mButtonWfcMode,
-                String.valueOf(ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED));
+                String.valueOf(ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED));

        // Check that only WFC home mode is set.
-        verify(mImsManager, times(1)).setWfcMode(
-                eq(ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED),
-                eq(false));
-        verify(mImsManager, never()).setWfcMode(
-                eq(ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED),
-                eq(true));
+        verify(mImsMmTelManager, times(1)).setVoWiFiModeSetting(
+                eq(ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED));
+        verify(mImsMmTelManager, never()).setVoWiFiRoamingModeSetting(
+                eq(ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED));
    }

    @Test
@@ -272,34 +274,32 @@ public class WifiCallingSettingsForSubTest {

        // Set the WFC home mode.
        mFragment.onPreferenceChange(mButtonWfcMode,
-                String.valueOf(ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED));
+                String.valueOf(ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED));

        // Check that both WFC home mode and roaming mode are set.
-        verify(mImsManager, times(1)).setWfcMode(
-                eq(ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED),
-                eq(false));
-        verify(mImsManager, times(1)).setWfcMode(
-                eq(ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED),
-                eq(true));
+        verify(mImsMmTelManager, times(1)).setVoWiFiModeSetting(
+                eq(ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED));
+        verify(mImsMmTelManager, times(1)).setVoWiFiRoamingModeSetting(
+                eq(ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED));
    }

    @Test
    public void onSwitchChanged_enableSetting_shouldLaunchWfcDisclaimerFragment() {
-        ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class);
+        final ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class);

        mFragment.onSwitchChanged(null, true);

        // Check the WFC disclaimer fragment is launched.
        verify(mFragment).startActivityForResult(intentCaptor.capture(),
                eq(WifiCallingSettingsForSub.REQUEST_CHECK_WFC_DISCLAIMER));
-        Intent intent = intentCaptor.getValue();
+        final Intent intent = intentCaptor.getValue();
        assertThat(intent.getStringExtra(EXTRA_SHOW_FRAGMENT))
                .isEqualTo(WifiCallingDisclaimerFragment.class.getName());
    }

    @Test
    public void onActivityResult_finishWfcDisclaimerFragment_shouldLaunchCarrierActivity() {
-        ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class);
+        final ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class);

        // Emulate the WfcDisclaimerActivity finish.
        mFragment.onActivityResult(WifiCallingSettingsForSub.REQUEST_CHECK_WFC_DISCLAIMER,
@@ -308,7 +308,7 @@ public class WifiCallingSettingsForSubTest {
        // Check the WFC emergency address activity is launched.
        verify(mFragment).startActivityForResult(intentCaptor.capture(),
                eq(WifiCallingSettingsForSub.REQUEST_CHECK_WFC_EMERGENCY_ADDRESS));
-        Intent intent = intentCaptor.getValue();
+        final Intent intent = intentCaptor.getValue();
        assertEquals(intent.getComponent(), ComponentName.unflattenFromString(
                TEST_EMERGENCY_ADDRESS_CARRIER_APP));
    }
--- a/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSliceHelperTest.java
+++ b/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSliceHelperTest.java
@@ -22,7 +22,6 @@ import static android.app.slice.SliceItem.FORMAT_TEXT;

 import static com.google.common.truth.Truth.assertThat;

-import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
@@ -32,6 +31,7 @@ import android.app.PendingIntent;
 import android.content.Context;
 import android.content.Intent;
 import android.telephony.CarrierConfigManager;
+import android.telephony.ims.ImsMmTelManager;

 import androidx.slice.Slice;
 import androidx.slice.SliceItem;
@@ -44,7 +44,6 @@ import androidx.slice.widget.RowContent;
 import androidx.slice.widget.SliceContent;
 import androidx.slice.widget.SliceLiveData;

-import com.android.ims.ImsConfig;
 import com.android.ims.ImsManager;
 import com.android.settings.R;
 import com.android.settings.slices.CustomSliceRegistry;
@@ -76,6 +75,9 @@ public class WifiCallingSliceHelperTest {
    @Mock
    private ImsManager mMockImsManager;

+    @Mock
+    private ImsMmTelManager mMockImsMmTelManager;
+
    private FakeWifiCallingSliceHelper mWfcSliceHelper;
    private SettingsSliceProvider mProvider;
    private SliceBroadcastReceiver mReceiver;
@@ -189,10 +191,10 @@ public class WifiCallingSliceHelperTest {
                .thenReturn(mWfcSliceHelper);
        mWfcSliceHelper.setActivationAppIntent(null);

-        ArgumentCaptor<Boolean> mWfcSettingCaptor = ArgumentCaptor.forClass(Boolean.class);
+        final ArgumentCaptor<Boolean> mWfcSettingCaptor = ArgumentCaptor.forClass(Boolean.class);

        // turn on Wifi calling setting
-        Intent intent = new Intent(WifiCallingSliceHelper.ACTION_WIFI_CALLING_CHANGED);
+        final Intent intent = new Intent(WifiCallingSliceHelper.ACTION_WIFI_CALLING_CHANGED);
        intent.putExtra(EXTRA_TOGGLE_STATE, true);

        // change the setting
@@ -242,8 +244,8 @@ public class WifiCallingSliceHelperTest {
        when(mMockImsManager.isWfcProvisionedOnDevice()).thenReturn(true);
        when(mMockImsManager.isWfcEnabledByUser()).thenReturn(true);
        when(mMockImsManager.isNonTtyOrTtyOnVolteEnabled()).thenReturn(true);
-        when(mMockImsManager.getWfcMode(false)).thenReturn(
-                ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED);
+        when(mMockImsMmTelManager.getVoWiFiModeSetting()).thenReturn(
+                ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED);
        mWfcSliceHelper.setIsWifiCallingPrefEditable(true);

        final Slice slice = mWfcSliceHelper.createWifiCallingPreferenceSlice(
@@ -260,8 +262,8 @@ public class WifiCallingSliceHelperTest {
        when(mMockImsManager.isWfcProvisionedOnDevice()).thenReturn(true);
        when(mMockImsManager.isWfcEnabledByUser()).thenReturn(true);
        when(mMockImsManager.isNonTtyOrTtyOnVolteEnabled()).thenReturn(true);
-        when(mMockImsManager.getWfcMode(false)).thenReturn(
-                ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED);
+        when(mMockImsMmTelManager.getVoWiFiModeSetting()).thenReturn(
+                ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED);
        when(mSlicesFeatureProvider.getNewWifiCallingSliceHelper(mContext))
                .thenReturn(mWfcSliceHelper);
        mWfcSliceHelper.setIsWifiCallingPrefEditable(true);
@@ -279,25 +281,26 @@ public class WifiCallingSliceHelperTest {
        when(mMockImsManager.isWfcProvisionedOnDevice()).thenReturn(true);
        when(mMockImsManager.isWfcEnabledByUser()).thenReturn(true);
        when(mMockImsManager.isNonTtyOrTtyOnVolteEnabled()).thenReturn(true);
-        when(mMockImsManager.getWfcMode(false)).thenReturn(
-                ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED);
+        when(mMockImsMmTelManager.getVoWiFiModeSetting()).thenReturn(
+                ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED);
        when(mSlicesFeatureProvider.getNewWifiCallingSliceHelper(mContext))
                .thenReturn(mWfcSliceHelper);
        mWfcSliceHelper.setIsWifiCallingPrefEditable(true);

-        ArgumentCaptor<Integer> mWfcPreferenceCaptor = ArgumentCaptor.forClass(Integer.class);
+        final ArgumentCaptor<Integer> mWfcPreferenceCaptor =
+                ArgumentCaptor.forClass(Integer.class);

        // Change preference to Cellular pref
-        Intent intent = new Intent(
+        final Intent intent = new Intent(
                WifiCallingSliceHelper.ACTION_WIFI_CALLING_PREFERENCE_CELLULAR_PREFERRED);

        mReceiver.onReceive(mContext, intent);

-        verify((mMockImsManager)).setWfcMode(mWfcPreferenceCaptor.capture(), eq(false));
+        verify((mMockImsMmTelManager)).setVoWiFiModeSetting(mWfcPreferenceCaptor.capture());

        // assert the change
        assertThat(mWfcPreferenceCaptor.getValue()).isEqualTo(
-                ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED);
+                ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED);
    }

    private void testWifiCallingSettingsUnavailableSlice(Slice slice,
@@ -400,7 +403,7 @@ public class WifiCallingSliceHelperTest {
    private void assertTitle(List<SliceItem> sliceItems, String title) {
        boolean hasTitle = false;
        for (SliceItem item : sliceItems) {
-            List<SliceItem> titleItems = SliceQuery.findAll(item, FORMAT_TEXT, HINT_TITLE,
+            final List<SliceItem> titleItems = SliceQuery.findAll(item, FORMAT_TEXT, HINT_TITLE,
                    null /* non-hints */);
            if (titleItems == null) {
                continue;
@@ -434,6 +437,11 @@ public class WifiCallingSliceHelperTest {
            return mMockImsManager;
        }

+        @Override
+        protected ImsMmTelManager getImsMmTelManager(int subId) {
+            return mMockImsMmTelManager;
+        }
+
        protected int getDefaultVoiceSubId() {
            return mSubId;
        }
--- a/tests/unit/src/com/android/settings/wifi/WifiCallingSettingUiTest.java
+++ b/tests/unit/src/com/android/settings/wifi/WifiCallingSettingUiTest.java
@@ -28,7 +28,6 @@ import static org.hamcrest.CoreMatchers.allOf;
 import static org.hamcrest.CoreMatchers.anything;
 import static org.junit.Assert.assertEquals;
 import static org.junit.matchers.JUnitMatchers.containsString;
-import static org.mockito.ArgumentMatchers.anyBoolean;
 import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doReturn;

@@ -38,13 +37,13 @@ import android.content.Context;
 import android.content.Intent;
 import android.support.test.uiautomator.UiDevice;
 import android.telephony.SubscriptionInfo;
+import android.telephony.ims.ImsMmTelManager;

 import androidx.test.InstrumentationRegistry;
 import androidx.test.espresso.NoMatchingViewException;
 import androidx.test.espresso.ViewInteraction;
 import androidx.test.runner.AndroidJUnit4;

-import com.android.ims.ImsConfig;
 import com.android.ims.ImsManager;
 import com.android.internal.telephony.SubscriptionController;
 import com.android.settings.testutils.MockedServiceManager;
@@ -87,6 +86,10 @@ public class WifiCallingSettingUiTest {
    ImsManager mImsManager0;
    @Mock
    ImsManager mImsManager1;
+    @Mock
+    ImsMmTelManager mImsMmTelManager0;
+    @Mock
+    ImsMmTelManager mImsMmTelManager1;

    @Before
    public void setUp() throws Exception {
@@ -134,10 +137,10 @@ public class WifiCallingSettingUiTest {
    public void testSingleSimUi() throws InterruptedException {
        configureSingleSim();
        doReturn(true).when(mImsManager0).isWfcEnabledByUser();
-        doReturn(ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED)
-                .when(mImsManager0).getWfcMode();
-        doReturn(ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED)
-                .when(mImsManager0).getWfcMode(anyBoolean());
+        doReturn(ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED)
+                .when(mImsMmTelManager0).getVoWiFiModeSetting();
+        doReturn(ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED)
+                .when(mImsMmTelManager0).getVoWiFiRoamingModeSetting();

        mInstrumentation.startActivitySync(createActivityIntent());

@@ -179,10 +182,10 @@ public class WifiCallingSettingUiTest {
        doReturn(false).when(mImsManager1).isWfcEnabledByPlatform();
        doReturn(false).when(mImsManager1).isNonTtyOrTtyOnVolteEnabled();
        doReturn(false).when(mImsManager0).isWfcEnabledByUser();
-        doReturn(ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED)
-                .when(mImsManager0).getWfcMode();
-        doReturn(ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED)
-                .when(mImsManager0).getWfcMode(anyBoolean());
+        doReturn(ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED)
+                .when(mImsMmTelManager0).getVoWiFiModeSetting();
+        doReturn(ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED)
+                .when(mImsMmTelManager0).getVoWiFiRoamingModeSetting();

        Activity activity = mInstrumentation.startActivitySync(createActivityIntent());

@@ -198,10 +201,10 @@ public class WifiCallingSettingUiTest {
    public void testWfcDisabled() throws InterruptedException {
        configureSingleSim();
        doReturn(false).when(mImsManager0).isWfcEnabledByUser();
-        doReturn(ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED)
-                .when(mImsManager0).getWfcMode();
-        doReturn(ImsConfig.WfcModeFeatureValueConstants.WIFI_PREFERRED)
-                .when(mImsManager0).getWfcMode(anyBoolean());
+        doReturn(ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED)
+                .when(mImsMmTelManager0).getVoWiFiModeSetting();
+        doReturn(ImsMmTelManager.WIFI_MODE_WIFI_PREFERRED)
+                .when(mImsMmTelManager0).getVoWiFiRoamingModeSetting();

        Activity activity = mInstrumentation.startActivitySync(createActivityIntent());

@@ -218,10 +221,10 @@ public class WifiCallingSettingUiTest {
        configureDualSim();
        doReturn(true).when(mImsManager0).isWfcEnabledByUser();
        doReturn(false).when(mImsManager1).isWfcEnabledByUser();
-        doReturn(ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED)
-                .when(mImsManager0).getWfcMode();
-        doReturn(ImsConfig.WfcModeFeatureValueConstants.CELLULAR_PREFERRED)
-                .when(mImsManager0).getWfcMode(anyBoolean());
+        doReturn(ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED)
+                .when(mImsMmTelManager0).getVoWiFiModeSetting();
+        doReturn(ImsMmTelManager.WIFI_MODE_CELLULAR_PREFERRED)
+                .when(mImsMmTelManager0).getVoWiFiRoamingModeSetting();

        mInstrumentation.startActivitySync(createActivityIntent());

@@ -256,6 +259,7 @@ public class WifiCallingSettingUiTest {
                com.android.settings.Settings.WifiCallingSettingsActivity.class);
        intent.setPackage("com.android.settings");
        intent.setAction("android.intent.action.MAIN");
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        return intent;
    }