WFC roaming mode setting can not be used with a fixed value

WFC roaming mode setting can not be used with a fixed value because it
is changed as WFC home mode changes if
KEY_EDITABLE_WFC_ROAMING_MODE_BOOL is false.

To solve this issue, separate the WFC mode setting of home and roaming.
These can switch behavior by new carrier config
KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL.

Test: manual - Checked that WFC roaming mode is hidden if new config is
true.
Test: manual - Checked that WFC roaming mode is also changed when
change the WFC home mode if new config is true.
Test: auto - Passed WifiCallingSettingsForSubTest.
Bug: 79666081

Change-Id: Ib2363c5d50f5231cc89f287d760ca8728b02b249

src/com/android/settings/wifi/calling/WifiCallingSettingsForSub.java

@@ -90,6 +90,7 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
     private boolean mValidListener = false;
     private boolean mEditableWfcMode = true;
     private boolean mEditableWfcRoamingMode = true;
+    private boolean mUseWfcHomeModeForRoaming = false;
 
     private int mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
     private ImsManager mImsManager;
@@ -317,6 +318,9 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
                         CarrierConfigManager.KEY_EDITABLE_WFC_MODE_BOOL);
                 mEditableWfcRoamingMode = b.getBoolean(
                         CarrierConfigManager.KEY_EDITABLE_WFC_ROAMING_MODE_BOOL);
+                mUseWfcHomeModeForRoaming = b.getBoolean(
+                        CarrierConfigManager.KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL,
+                        false);
                 isWifiOnlySupported = b.getBoolean(
                         CarrierConfigManager.KEY_CARRIER_WFC_SUPPORTS_WIFI_ONLY_BOOL, true);
             }
@@ -499,7 +503,7 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
                 // Don't show WFC (home) preference if it's not editable.
                 preferenceScreen.removePreference(mButtonWfcMode);
             }
-            if (mEditableWfcRoamingMode) {
+            if (mEditableWfcRoamingMode && !mUseWfcHomeModeForRoaming) {
                 preferenceScreen.addPreference(mButtonWfcRoamingMode);
             } else {
                 // Don't show WFC roaming preference if it's not editable.
@@ -528,10 +532,8 @@ public class WifiCallingSettingsForSub extends SettingsPreferenceFragment
                 mImsManager.setWfcMode(buttonMode, false);
                 mButtonWfcMode.setSummary(getWfcModeSummary(buttonMode));
                 mMetricsFeatureProvider.action(getActivity(), getMetricsCategory(), buttonMode);
-            }
+
-            if (!mEditableWfcRoamingMode) {
+                if (mUseWfcHomeModeForRoaming) {
-                int currentWfcRoamingMode = mImsManager.getWfcMode(true);
-                if (buttonMode != currentWfcRoamingMode) {
                     mImsManager.setWfcMode(buttonMode, true);
                     // mButtonWfcRoamingMode.setSummary is not needed; summary is selected value
                 }

tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSettingsForSubTest.java

@@ -19,18 +19,23 @@ package com.android.settings.wifi.calling;
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.Matchers.any;
+import static org.mockito.Matchers.anyBoolean;
 import static org.mockito.Matchers.anyInt;
 import static org.mockito.Mockito.doNothing;
 import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
 import android.content.Intent;
 import android.os.Bundle;
+import android.os.PersistableBundle;
+import android.telephony.CarrierConfigManager;
 import android.telephony.TelephonyManager;
 import android.telephony.ims.ProvisioningManager;
 import android.view.View;
@@ -58,10 +63,15 @@ import org.robolectric.util.ReflectionHelpers;
 
 @RunWith(RobolectricTestRunner.class)
 public class WifiCallingSettingsForSubTest {
+    private static final String BUTTON_WFC_MODE = "wifi_calling_mode";
+    private static final String BUTTON_WFC_ROAMING_MODE = "wifi_calling_roaming_mode";
+
     private TestFragment mFragment;
     private Context mContext;
     private TextView mEmptyView;
+    private final PersistableBundle mBundle = new PersistableBundle();
 
+    @Mock private static CarrierConfigManager sCarrierConfigManager;
     @Mock private ImsManager mImsManager;
     @Mock private TelephonyManager mTelephonyManager;
     @Mock private PreferenceScreen mPreferenceScreen;
@@ -70,6 +80,8 @@ public class WifiCallingSettingsForSubTest {
     @Mock private ToggleSwitch mToggleSwitch;
     @Mock private View mView;
     @Mock private ImsConfig mImsConfig;
+    @Mock private ListPreference mButtonWfcMode;
+    @Mock private ListPreference mButtonWfcRoamingMode;
 
     @Before
     public void setUp() throws NoSuchFieldException, ImsException {
@@ -89,6 +101,8 @@ public class WifiCallingSettingsForSubTest {
         when(mFragment.getArguments()).thenReturn(bundle);
         doNothing().when(mFragment).addPreferencesFromResource(anyInt());
         doReturn(mock(ListPreference.class)).when(mFragment).findPreference(any());
+        doReturn(mButtonWfcMode).when(mFragment).findPreference(BUTTON_WFC_MODE);
+        doReturn(mButtonWfcRoamingMode).when(mFragment).findPreference(BUTTON_WFC_ROAMING_MODE);
         doNothing().when(mFragment).finish();
         doReturn(mView).when(mFragment).getView();
 
@@ -101,12 +115,26 @@ public class WifiCallingSettingsForSubTest {
         doReturn(mImsManager).when(mFragment).getImsManager();
         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(mBundle).when(sCarrierConfigManager).getConfigForSubId(anyInt());
+        setDefaultCarrierConfigValues();
 
         mFragment.onAttach(mContext);
         mFragment.onCreate(null);
         mFragment.onActivityCreated(null);
     }
 
+    private void setDefaultCarrierConfigValues() {
+        mBundle.putBoolean(
+                CarrierConfigManager.KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL, false);
+        mBundle.putBoolean(CarrierConfigManager.KEY_EDITABLE_WFC_MODE_BOOL, true);
+        mBundle.putBoolean(CarrierConfigManager.KEY_EDITABLE_WFC_ROAMING_MODE_BOOL, true);
+    }
+
     @Test
     public void getHelpResource_shouldReturn0() {
         assertThat(mFragment.getHelpResource()).isEqualTo(0);
@@ -142,13 +170,108 @@ public class WifiCallingSettingsForSubTest {
         verify(mImsConfig).removeConfigCallback(any());
     }
 
+    @Test
+    public void onResume_useWfcHomeModeConfigFalseAndEditable_shouldShowWfcRoaming() {
+        // Call onResume to update the WFC roaming preference.
+        mFragment.onResume();
+
+        // Check that WFC roaming preference is shown.
+        verify(mPreferenceScreen, times(1)).addPreference(mButtonWfcRoamingMode);
+        verify(mPreferenceScreen, never()).removePreference(mButtonWfcRoamingMode);
+    }
+
+    @Test
+    public void onResume_useWfcHomeModeConfigTrueAndEditable_shouldHideWfcRoaming() {
+        mBundle.putBoolean(
+                CarrierConfigManager.KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL, true);
+        mBundle.putBoolean(CarrierConfigManager.KEY_EDITABLE_WFC_ROAMING_MODE_BOOL, true);
+
+        // Call onResume to update the WFC roaming preference.
+        mFragment.onResume();
+
+        // Check that WFC roaming preference is hidden.
+        verify(mPreferenceScreen, never()).addPreference(mButtonWfcRoamingMode);
+        verify(mPreferenceScreen, times(1)).removePreference(mButtonWfcRoamingMode);
+    }
+
+    @Test
+    public void onResume_useWfcHomeModeConfigFalseAndNotEditable_shouldHideWfcRoaming() {
+        mBundle.putBoolean(
+                CarrierConfigManager.KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL, false);
+        mBundle.putBoolean(CarrierConfigManager.KEY_EDITABLE_WFC_ROAMING_MODE_BOOL, false);
+
+        // Call onResume to update the WFC roaming preference.
+        mFragment.onResume();
+
+        // Check that WFC roaming preference is hidden.
+        verify(mPreferenceScreen, never()).addPreference(mButtonWfcRoamingMode);
+        verify(mPreferenceScreen, times(1)).removePreference(mButtonWfcRoamingMode);
+    }
+
+    @Test
+    public void onResume_useWfcHomeModeConfigTrueAndNotEditable_shouldHideWfcRoaming() {
+        mBundle.putBoolean(
+                CarrierConfigManager.KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL, true);
+        mBundle.putBoolean(CarrierConfigManager.KEY_EDITABLE_WFC_ROAMING_MODE_BOOL, false);
+
+        // Call onResume to update the WFC roaming preference.
+        mFragment.onResume();
+
+        // Check that WFC roaming preference is hidden.
+        verify(mPreferenceScreen, never()).addPreference(mButtonWfcRoamingMode);
+        verify(mPreferenceScreen, times(1)).removePreference(mButtonWfcRoamingMode);
+    }
+
+    @Test
+    public void onPreferenceChange_useWfcHomeModeConfigFalse_shouldNotSetWfcRoaming() {
+        // Call onResume to update carrier config values.
+        mFragment.onResume();
+
+        // Set the WFC home mode.
+        mFragment.onPreferenceChange(mButtonWfcMode,
+                String.valueOf(ImsConfig.WfcModeFeatureValueConstants.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));
+    }
+
+    @Test
+    public void onPreferenceChange_useWfcHomeModeConfigTrue_shouldSetWfcRoaming() {
+        mBundle.putBoolean(
+                CarrierConfigManager.KEY_USE_WFC_HOME_NETWORK_MODE_IN_ROAMING_NETWORK_BOOL, true);
+
+        // Call onResume to update carrier config values.
+        mFragment.onResume();
+
+        // Set the WFC home mode.
+        mFragment.onPreferenceChange(mButtonWfcMode,
+                String.valueOf(ImsConfig.WfcModeFeatureValueConstants.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));
+    }
+
     protected class TestFragment extends WifiCallingSettingsForSub {
         @Override
         protected Object getSystemService(final String name) {
-            if (Context.TELEPHONY_SERVICE.equals(name)) {
+            switch (name) {
+                case Context.TELEPHONY_SERVICE:
                     return mTelephonyManager;
-            }
+                case Context.CARRIER_CONFIG_SERVICE:
+                    return sCarrierConfigManager;
+                default:
                     return null;
             }
         }
     }
+}