From: Kitta Koutarou Date: Thu, 14 Feb 2019 10:16:40 +0000 (+0900) Subject: WFC roaming mode setting can not be used with a fixed value X-Git-Url: http://git.osdn.net/view?a=commitdiff_plain;h=994d27a2a5;p=android-x86%2Fpackages-apps-Settings.git 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 --- diff --git a/src/com/android/settings/wifi/calling/WifiCallingSettingsForSub.java b/src/com/android/settings/wifi/calling/WifiCallingSettingsForSub.java index 79112c74be..6fe179516a 100644 --- a/src/com/android/settings/wifi/calling/WifiCallingSettingsForSub.java +++ b/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) { - int currentWfcRoamingMode = mImsManager.getWfcMode(true); - if (buttonMode != currentWfcRoamingMode) { + + if (mUseWfcHomeModeForRoaming) { mImsManager.setWfcMode(buttonMode, true); // mButtonWfcRoamingMode.setSummary is not needed; summary is selected value } diff --git a/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSettingsForSubTest.java b/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSettingsForSubTest.java index c8b3920877..39de254b84 100644 --- a/tests/robotests/src/com/android/settings/wifi/calling/WifiCallingSettingsForSubTest.java +++ b/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)) { - return mTelephonyManager; + switch (name) { + case Context.TELEPHONY_SERVICE: + return mTelephonyManager; + case Context.CARRIER_CONFIG_SERVICE: + return sCarrierConfigManager; + default: + return null; } - return null; } } }