diff --git a/res/values/arrays.xml b/res/values/arrays.xml index 04557b1b6f1..1649cb2ae0a 100644 --- a/res/values/arrays.xml +++ b/res/values/arrays.xml @@ -1375,89 +1375,6 @@ "1" - - @string/network_lte - @string/network_3G - - - @string/network_4G - @string/network_3G - - - "9" - "0" - - - - @string/network_3G - @string/network_2G - - - "0" - "1" - - - - @string/network_3G - - - "0" - - - - @string/network_lte - @string/network_3G - @string/network_1x - @string/network_global - - - "8" - "4" - "5" - "10" - - - - @string/network_3G - @string/network_1x - - - "4" - "5" - - - - @string/network_lte - @string/network_global - - - "8" - "10" - - - - @string/network_lte - @string/network_3G - @string/network_2G - - - "22" - "18" - "1" - - - - - Global - LTE / CDMA - LTE / GSM / UMTS - - - - "10" - "8" - "9" - diff --git a/res/values/strings.xml b/res/values/strings.xml index 0d8f22a1756..5dcab3ef4b6 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -11301,7 +11301,11 @@ 1x - Global + Global + + LTE / CDMA + + LTE / GSM / UMTS Available networks diff --git a/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java b/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java index d633b39635b..c0df8513281 100644 --- a/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java +++ b/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java @@ -28,10 +28,8 @@ import android.provider.Settings; import android.telephony.CarrierConfigManager; import android.telephony.SubscriptionManager; import android.telephony.TelephonyManager; -import android.text.TextUtils; import android.util.Log; -import androidx.annotation.VisibleForTesting; import androidx.lifecycle.Lifecycle; import androidx.lifecycle.LifecycleObserver; import androidx.lifecycle.OnLifecycleEvent; @@ -43,6 +41,7 @@ import com.android.settings.R; import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; /** @@ -53,19 +52,14 @@ public class EnabledNetworkModePreferenceController extends ListPreference.OnPreferenceChangeListener, LifecycleObserver { private static final String LOG_TAG = "EnabledNetworkMode"; - private CarrierConfigManager mCarrierConfigManager; private ContentObserver mPreferredNetworkModeObserver; - private TelephonyManager mTelephonyManager; - private boolean mIsGlobalCdma; - @VisibleForTesting - boolean mShow4GForLTE; private Preference mPreference; - @VisibleForTesting - boolean mDisplay5gList = false; + private TelephonyManager mTelephonyManager; + private CarrierConfigManager mCarrierConfigManager; + private PreferenceEntriesBuilder mBuilder; public EnabledNetworkModePreferenceController(Context context, String key) { super(context, key); - mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); mPreferredNetworkModeObserver = new ContentObserver(new Handler(Looper.getMainLooper())) { @Override public void onChange(boolean selfChange) { @@ -101,7 +95,8 @@ public class EnabledNetworkModePreferenceController extends @OnLifecycleEvent(ON_START) public void onStart() { mContext.getContentResolver().registerContentObserver( - Settings.Global.getUriFor(Settings.Global.PREFERRED_NETWORK_MODE + mSubId), true, + Settings.Global.getUriFor(Settings.Global.PREFERRED_NETWORK_MODE + mSubId), + true, mPreferredNetworkModeObserver); } @@ -120,444 +115,539 @@ public class EnabledNetworkModePreferenceController extends public void updateState(Preference preference) { super.updateState(preference); final ListPreference listPreference = (ListPreference) preference; - final int networkMode = getPreferredNetworkMode(); - Log.d(LOG_TAG, "updateState networkMode: " + networkMode); - updatePreferenceEntries(listPreference); - updatePreferenceValueAndSummary(listPreference, networkMode); + mBuilder.setPreferenceEntries(); + mBuilder.setPreferenceValueAndSummary(); + + listPreference.setEntries(mBuilder.getEntries()); + listPreference.setEntryValues(mBuilder.getEntryValues()); + listPreference.setValue(Integer.toString(mBuilder.getSelectedEntryValue())); + listPreference.setSummary(mBuilder.getSummary()); } @Override public boolean onPreferenceChange(Preference preference, Object object) { final int newPreferredNetworkMode = Integer.parseInt((String) object); + final ListPreference listPreference = (ListPreference) preference; if (mTelephonyManager.setPreferredNetworkTypeBitmask( MobileNetworkUtils.getRafFromNetworkType(newPreferredNetworkMode))) { - updatePreferenceValueAndSummary((ListPreference) preference, newPreferredNetworkMode); + mBuilder.setPreferenceValueAndSummary(newPreferredNetworkMode); + listPreference.setValue(Integer.toString(mBuilder.getSelectedEntryValue())); + listPreference.setSummary(mBuilder.getSummary()); return true; } - return false; } public void init(Lifecycle lifecycle, int subId) { mSubId = subId; - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); mTelephonyManager = mContext.getSystemService(TelephonyManager.class) .createForSubscriptionId(mSubId); + mCarrierConfigManager = mContext.getSystemService(CarrierConfigManager.class); + mBuilder = new PreferenceEntriesBuilder(mContext, mSubId); - mIsGlobalCdma = mTelephonyManager.isLteCdmaEvdoGsmWcdmaEnabled() - && carrierConfig.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); - mShow4GForLTE = carrierConfig != null - ? carrierConfig.getBoolean( - CarrierConfigManager.KEY_SHOW_4G_FOR_LTE_DATA_ICON_BOOL) - : false; - - final long supportedRadioBitmask = mTelephonyManager.getSupportedRadioAccessFamily(); - final boolean is5gEnabledByCarrier = (mTelephonyManager.getAllowedNetworkTypes() - & TelephonyManager.NETWORK_TYPE_BITMASK_NR) > 0; - mDisplay5gList = checkSupportedRadioBitmask( - supportedRadioBitmask, mTelephonyManager.NETWORK_TYPE_BITMASK_NR) - && is5gEnabledByCarrier; lifecycle.addObserver(this); } - private int getPreferredNetworkMode() { - long preferredNetworkBitMask = MobileNetworkUtils.getRafFromNetworkType( - Settings.Global.getInt(mContext.getContentResolver(), - Settings.Global.PREFERRED_NETWORK_MODE + mSubId, - TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE)); - return MobileNetworkUtils.getNetworkTypeFromRaf((int) - (preferredNetworkBitMask & mTelephonyManager.getAllowedNetworkTypes())); - } + private final static class PreferenceEntriesBuilder { + private CarrierConfigManager mCarrierConfigManager; + private Context mContext; + private TelephonyManager mTelephonyManager; - private void updatePreferenceEntries(ListPreference preference) { - final int phoneType = mTelephonyManager.getPhoneType(); - final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); - if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) { - final int lteForced = android.provider.Settings.Global.getInt( - mContext.getContentResolver(), - android.provider.Settings.Global.LTE_SERVICE_FORCED + mSubId, - 0); - final int settingsNetworkMode = getPreferredNetworkMode(); - if (mTelephonyManager.isLteCdmaEvdoGsmWcdmaEnabled()) { - if (lteForced == 0) { - preference.setEntries( - R.array.enabled_networks_cdma_choices); - preference.setEntryValues( - R.array.enabled_networks_cdma_values); - } else { - switch (settingsNetworkMode) { - case TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO: - case TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO: - case TelephonyManagerConstants.NETWORK_MODE_EVDO_NO_CDMA: - preference.setEntries( - R.array.enabled_networks_cdma_no_lte_choices); - preference.setEntryValues( - R.array.enabled_networks_cdma_no_lte_values); - break; - case TelephonyManagerConstants.NETWORK_MODE_GLOBAL: - case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO: - case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: - case TelephonyManagerConstants.NETWORK_MODE_LTE_ONLY: - preference.setEntries( - R.array.enabled_networks_cdma_only_lte_choices); - preference.setEntryValues( - R.array.enabled_networks_cdma_only_lte_values); - break; - default: - preference.setEntries( - R.array.enabled_networks_cdma_choices); - preference.setEntryValues( - R.array.enabled_networks_cdma_values); - break; - } - } - } - } else if (phoneType == TelephonyManager.PHONE_TYPE_GSM) { - if (MobileNetworkUtils.isTdscdmaSupported(mContext, mSubId)) { - preference.setEntries( - R.array.enabled_networks_tdscdma_choices); - preference.setEntryValues( - R.array.enabled_networks_tdscdma_values); - } else if (carrierConfig != null - && !carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL) - && !carrierConfig.getBoolean(CarrierConfigManager.KEY_LTE_ENABLED_BOOL)) { - preference.setEntries(R.array.enabled_networks_except_gsm_lte_choices); - preference.setEntryValues(R.array.enabled_networks_except_gsm_lte_values); - } else if (carrierConfig != null - && !carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL)) { - int select = mShow4GForLTE - ? R.array.enabled_networks_except_gsm_4g_choices - : R.array.enabled_networks_except_gsm_choices; - preference.setEntries(select); - preference.setEntryValues( - R.array.enabled_networks_except_gsm_values); - } else if (carrierConfig != null - && !carrierConfig.getBoolean(CarrierConfigManager.KEY_LTE_ENABLED_BOOL)) { - preference.setEntries( - R.array.enabled_networks_except_lte_choices); - preference.setEntryValues( - R.array.enabled_networks_except_lte_values); - } else if (mIsGlobalCdma) { - preference.setEntries(R.array.enabled_networks_cdma_choices); - preference.setEntryValues(R.array.enabled_networks_cdma_values); - } else { - int select = mShow4GForLTE ? R.array.enabled_networks_4g_choices - : R.array.enabled_networks_choices; - preference.setEntries(select); - preference.setEntryValues(R.array.enabled_networks_values); - } - } - //TODO(b/117881708): figure out what world mode is, then we can optimize code. Otherwise - // I prefer to keep this old code - if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) { - preference.setEntries( - R.array.preferred_network_mode_choices_world_mode); - preference.setEntryValues( - R.array.preferred_network_mode_values_world_mode); + private boolean mAllowed5gNetworkType; + private boolean mIsGlobalCdma; + private boolean mIs5gEntryDisplayed; + private boolean mShow4gForLTE; + private boolean mSupported5gRadioAccessFamily; + private int mSelectedEntry; + private int mSubId; + private String mSummary; + + private List mEntries = new ArrayList<>(); + private List mEntriesValue = new ArrayList<>(); + + enum EnabledNetworks { + ENABLED_NETWORKS_UNKNOWN, + ENABLED_NETWORKS_CDMA_CHOICES, + ENABLED_NETWORKS_CDMA_NO_LTE_CHOICES, + ENABLED_NETWORKS_CDMA_ONLY_LTE_CHOICES, + ENABLED_NETWORKS_TDSCDMA_CHOICES, + ENABLED_NETWORKS_EXCEPT_GSM_LTE_CHOICES, + ENABLED_NETWORKS_EXCEPT_GSM_4G_CHOICES, + ENABLED_NETWORKS_EXCEPT_GSM_CHOICES, + ENABLED_NETWORKS_EXCEPT_LTE_CHOICES, + ENABLED_NETWORKS_4G_CHOICES, + ENABLED_NETWORKS_CHOICES, + PREFERRED_NETWORK_MODE_CHOICES_WORLD_MODE } - if (mDisplay5gList) { - add5gListItem(preference); - } - } + PreferenceEntriesBuilder(Context context, int subId) { + this.mContext = context; + this.mSubId = subId; - @VisibleForTesting - boolean checkSupportedRadioBitmask(long supportedRadioBitmask, long targetBitmask) { - Log.d(LOG_TAG, "supportedRadioBitmask: " + supportedRadioBitmask); - if ((targetBitmask & supportedRadioBitmask) > 0) { - return true; - } - return false; - } + mCarrierConfigManager = mContext.getSystemService(CarrierConfigManager.class); + mTelephonyManager = mContext.getSystemService(TelephonyManager.class) + .createForSubscriptionId(mSubId); - /*** - * Generate preferred network choices list for 5G - * - * @string/enabled_networks_cdma_choices - * Before | After - * @string/network_lte , 8 |@string/network_5G + @string/network_recommended , 25 - * @string/network_3G , 4 |@string/network_lte_pure, 8 - * @string/network_1x , 5 |@string/network_3G , 4 - * @string/network_global, 10|@string/network_1x , 5 - * |@string/network_global , 27 - * - * @string/enabled_networks_cdma_only_lte_choices - * Before | After - * @string/network_lte , 8 |@string/network_5G + @string/network_recommended , 25 - * @string/network_global, 10|@string/network_lte_pure, 8 - * |@string/network_global , 27 - * - * @string/enabled_networks_tdscdma_choices - * Before | After - * @string/network_lte, 22|@string/network_5G + @string/network_recommended , 33 - * @string/network_3G , 18|@string/network_lte_pure, 22 - * @string/network_2G , 1 |@string/network_3G , 18 - * |@string/network_2G , 1 - * - * @string/enabled_networks_except_gsm_4g_choices - * Before | After - * @string/network_4G , 9 |@string/network_5G + @string/network_recommended , 26 - * @string/network_3G , 0 |@string/network_4G_pure , 9 - * |@string/network_3G , 0 - * - * @string/enabled_networks_except_gsm_choices - * Before | After - * @string/network_lte, 9 |@string/network_5G + @string/network_recommended , 26 - * @string/network_3G , 0 |@string/network_lte_pure, 9 - * |@string/network_3G , 0 - * - * @string/enabled_networks_4g_choices - * Before | After - * @string/network_4G , 9 |@string/network_5G + @string/network_recommended , 26 - * @string/network_3G , 0 |@string/network_4G_pure , 9 - * @string/network_2G , 1 |@string/network_3G , 0 - * |@string/network_2G , 1 - * - * @string/enabled_networks_choices - * Before | After - * @string/network_lte, 9 |@string/network_5G + @string/network_recommended , 26 - * @string/network_3G , 0 |@string/network_lte_pure, 9 - * @string/network_2G , 1 |@string/network_3G , 0 - * |@string/network_2G , 1 - * - * @string/preferred_network_mode_choices_world_mode - * Before | After - * "Global" , 10|@string/network_global , 27 - * "LTE / CDMA" , 8 |"LTE / CDMA" , 8 - * "LTE / GSM / UMTS" , 9 |"LTE / GSM / UMTS" , 9 - */ - @VisibleForTesting - void add5gListItem(ListPreference preference) { - final CharSequence[] oldEntries = preference.getEntries(); - final CharSequence[] oldEntryValues = preference.getEntryValues(); - List newEntries = new ArrayList<>(); - List newEntryValues = new ArrayList<>(); - - CharSequence oldEntry; - CharSequence oldEntryValue; - CharSequence new5gEntry; - CharSequence new5gEntryValue; - - for (int i = 0; i < oldEntries.length; i++) { - oldEntry = oldEntries[i]; - oldEntryValue = oldEntryValues[i]; - new5gEntry = ""; - new5gEntryValue = ""; - - if (mContext.getString(R.string.network_lte).equals(oldEntry)) { - oldEntry = mContext.getString(R.string.network_lte_pure); - new5gEntry = mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended); - new5gEntryValue = transformLteEntryValueTo5gEntryValue(oldEntryValue); - } else if (mContext.getString(R.string.network_4G).equals(oldEntry)) { - oldEntry = mContext.getString(R.string.network_4G_pure); - new5gEntry = mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended); - new5gEntryValue = transformLteEntryValueTo5gEntryValue(oldEntryValue); - } else if (mContext.getString(R.string.network_global).equals(oldEntry)) { - //oldEntry: network_global - //oldEntryValue: TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA - oldEntryValue = Integer.toString( - TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA); - } - - if (!TextUtils.isEmpty(new5gEntry)) { - newEntries.add(new5gEntry); - newEntryValues.add(new5gEntryValue); - } - newEntries.add(oldEntry); - newEntryValues.add(oldEntryValue); + final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); + mAllowed5gNetworkType = checkSupportedRadioBitmask( + mTelephonyManager.getAllowedNetworkTypes(), + TelephonyManager.NETWORK_TYPE_BITMASK_NR); + mSupported5gRadioAccessFamily = checkSupportedRadioBitmask( + mTelephonyManager.getSupportedRadioAccessFamily(), + TelephonyManager.NETWORK_TYPE_BITMASK_NR); + mIsGlobalCdma = mTelephonyManager.isLteCdmaEvdoGsmWcdmaEnabled() + && carrierConfig.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); + mShow4gForLTE = carrierConfig != null && carrierConfig.getBoolean( + CarrierConfigManager.KEY_SHOW_4G_FOR_LTE_DATA_ICON_BOOL); } - preference.setEntries(newEntries.toArray(new CharSequence[newEntries.size()])); - preference.setEntryValues(newEntryValues.toArray(new CharSequence[newEntryValues.size()])); - } - - /** - * transform LTE network mode to 5G network mode. - * - * @param networkMode an LTE network mode without 5G. - * @return the corresponding network mode with 5G. - */ - private CharSequence transformLteEntryValueTo5gEntryValue(CharSequence networkMode) { - int networkModeInt = Integer.valueOf(networkMode.toString()); - return Integer.toString(addNrToLteNetworkType(networkModeInt)); - } - private int addNrToLteNetworkType(int networkType) { - switch(networkType) { - case TelephonyManagerConstants.NETWORK_MODE_LTE_ONLY: - return TelephonyManagerConstants.NETWORK_MODE_NR_LTE; - case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO: - return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO; - case TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA: - return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_GSM_WCDMA; - case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: - return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA; - case TelephonyManagerConstants.NETWORK_MODE_LTE_WCDMA: - return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_WCDMA; - case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA: - return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA; - case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM: - return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM; - case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA: - return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA; - case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: - return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA; - case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA; - default: - return networkType; // not LTE - } - } - - /** - * Sets the display string for the network mode choice and selects the corresponding item - * - * @param preference ListPreference for selecting the preferred network mode. - * @param networkMode the current network mode. The current mode might not be an option in the - * choice list. The nearest choice is selected instead - */ - private void updatePreferenceValueAndSummary(ListPreference preference, int networkMode) { - preference.setValue(Integer.toString(networkMode)); - switch (networkMode) { - case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_WCDMA: - case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA: - case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM: - preference.setValue( - Integer.toString(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA)); - preference.setSummary(R.string.network_3G); - break; - case TelephonyManagerConstants.NETWORK_MODE_WCDMA_ONLY: - case TelephonyManagerConstants.NETWORK_MODE_GSM_UMTS: - case TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF: - if (!mIsGlobalCdma) { - preference.setValue(Integer.toString(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF)); - preference.setSummary(R.string.network_3G); - } else { - preference.setValue(Integer.toString(TelephonyManagerConstants - .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); - preference.setSummary(R.string.network_global); - } - break; - case TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY: - if (!mIsGlobalCdma) { - preference.setValue( - Integer.toString(TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY)); - preference.setSummary(R.string.network_2G); - } else { - preference.setValue( - Integer.toString(TelephonyManagerConstants - .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); - preference.setSummary(R.string.network_global); - } - break; - case TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA: - if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) { - preference.setSummary( - R.string.preferred_network_mode_lte_gsm_umts_summary); + void setPreferenceEntries() { + switch (getEnabledNetworkType()) { + case ENABLED_NETWORKS_CDMA_CHOICES: + add5gEntry(addNrToLteNetworkType( + TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO)); + addLteEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO); + add3gEntry(TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO); + add1xEntry(TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO); + addGlobalEntry(); break; - } - case TelephonyManagerConstants.NETWORK_MODE_LTE_ONLY: - case TelephonyManagerConstants.NETWORK_MODE_LTE_WCDMA: - if (!mIsGlobalCdma) { - preference.setValue( - Integer.toString(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); - preference.setSummary( - mShow4GForLTE ? R.string.network_4G : R.string.network_lte); - } else { - preference.setValue( - Integer.toString(TelephonyManagerConstants - .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); - preference.setSummary(R.string.network_global); - } - break; - case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO: - if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) { - preference.setSummary( - R.string.preferred_network_mode_lte_cdma_summary); - } else { - preference.setValue( - Integer.toString(TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO)); - preference.setSummary( - mDisplay5gList ? R.string.network_lte_pure : R.string.network_lte); - } - break; - case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - preference.setValue(Integer.toString(TelephonyManagerConstants - .NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); - preference.setSummary(R.string.network_3G); - break; - case TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO: - case TelephonyManagerConstants.NETWORK_MODE_EVDO_NO_CDMA: - case TelephonyManagerConstants.NETWORK_MODE_GLOBAL: - preference.setValue( - Integer.toString(TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO)); - preference.setSummary(R.string.network_3G); - break; - case TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO: - preference.setValue( - Integer.toString(TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO)); - preference.setSummary(R.string.network_1x); - break; - case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_ONLY: - preference.setValue( - Integer.toString(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_ONLY)); - preference.setSummary(R.string.network_3G); - break; - case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM: - case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: - case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA: - case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA: - case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: - if (MobileNetworkUtils.isTdscdmaSupported(mContext, mSubId)) { - preference.setValue( - Integer.toString(TelephonyManagerConstants - .NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); - preference.setSummary( - mDisplay5gList ? R.string.network_lte_pure : R.string.network_lte); - } else { - preference.setValue( - Integer.toString(TelephonyManagerConstants - .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); - if (mTelephonyManager.getPhoneType() == TelephonyManager.PHONE_TYPE_CDMA - || mIsGlobalCdma - || MobileNetworkUtils.isWorldMode(mContext, mSubId)) { - preference.setSummary(R.string.network_global); + case ENABLED_NETWORKS_CDMA_NO_LTE_CHOICES: + add3gEntry(TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO); + add1xEntry(TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO); + break; + case ENABLED_NETWORKS_CDMA_ONLY_LTE_CHOICES: + addLteEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO); + addGlobalEntry(); + break; + case ENABLED_NETWORKS_TDSCDMA_CHOICES: + add5gEntry(addNrToLteNetworkType( + TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); + addLteEntry( + TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA); + add3gEntry(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA); + add2gEntry(TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY); + break; + case ENABLED_NETWORKS_EXCEPT_GSM_LTE_CHOICES: + add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF); + break; + case ENABLED_NETWORKS_EXCEPT_GSM_4G_CHOICES: + add5gEntry(addNrToLteNetworkType( + TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); + add4gEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); + add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF); + break; + case ENABLED_NETWORKS_EXCEPT_GSM_CHOICES: + add5gEntry(addNrToLteNetworkType( + TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); + addLteEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); + add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF); + break; + case ENABLED_NETWORKS_EXCEPT_LTE_CHOICES: + add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF); + add2gEntry(TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY); + break; + case ENABLED_NETWORKS_4G_CHOICES: + add5gEntry(addNrToLteNetworkType( + TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); + add4gEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); + add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF); + add2gEntry(TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY); + break; + case ENABLED_NETWORKS_CHOICES: + add5gEntry(addNrToLteNetworkType( + TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); + addLteEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); + add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF); + add2gEntry(TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY); + break; + case PREFERRED_NETWORK_MODE_CHOICES_WORLD_MODE: + addGlobalEntry(); + addCustomEntry(mContext.getString(R.string.network_world_mode_cdma_lte), + TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO); + addCustomEntry(mContext.getString(R.string.network_world_mode_gsm_lte), + TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); + break; + default: + throw new IllegalArgumentException("Not supported enabled network types."); + } + } + + private int getPreferredNetworkMode() { + return Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + mSubId, + TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE); + } + + private EnabledNetworks getEnabledNetworkType() { + EnabledNetworks enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_UNKNOWN; + final int phoneType = mTelephonyManager.getPhoneType(); + final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); + + if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) { + final int lteForced = android.provider.Settings.Global.getInt( + mContext.getContentResolver(), + android.provider.Settings.Global.LTE_SERVICE_FORCED + mSubId, + 0); + final int settingsNetworkMode = getPreferredNetworkMode(); + if (mTelephonyManager.isLteCdmaEvdoGsmWcdmaEnabled()) { + if (lteForced == 0) { + enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_CDMA_CHOICES; } else { - if (mDisplay5gList) { - preference.setSummary(mShow4GForLTE - ? R.string.network_4G_pure : R.string.network_lte_pure); - } else { - preference.setSummary(mShow4GForLTE - ? R.string.network_4G : R.string.network_lte); + switch (settingsNetworkMode) { + case TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO: + case TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO: + case TelephonyManagerConstants.NETWORK_MODE_EVDO_NO_CDMA: + enabledNetworkType = + EnabledNetworks.ENABLED_NETWORKS_CDMA_NO_LTE_CHOICES; + break; + case TelephonyManagerConstants.NETWORK_MODE_GLOBAL: + case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO: + case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: + case TelephonyManagerConstants.NETWORK_MODE_LTE_ONLY: + enabledNetworkType = + EnabledNetworks.ENABLED_NETWORKS_CDMA_ONLY_LTE_CHOICES; + break; + default: + enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_CDMA_CHOICES; + break; } } } - break; - case TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO: - case TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - preference.setValue(Integer.toString(networkMode)); - preference.setSummary(mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended)); - break; - case TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA: - preference.setValue( - Integer.toString(TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA)); - if (mTelephonyManager.getPhoneType() == TelephonyManager.PHONE_TYPE_CDMA - || mIsGlobalCdma - || MobileNetworkUtils.isWorldMode(mContext, mSubId)) { - preference.setSummary(R.string.network_global); + } else if (phoneType == TelephonyManager.PHONE_TYPE_GSM) { + if (MobileNetworkUtils.isTdscdmaSupported(mContext, mSubId)) { + enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_TDSCDMA_CHOICES; + } else if (carrierConfig != null + && !carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL) + && !carrierConfig.getBoolean(CarrierConfigManager.KEY_LTE_ENABLED_BOOL)) { + enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_EXCEPT_GSM_LTE_CHOICES; + } else if (carrierConfig != null + && !carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL)) { + enabledNetworkType = mShow4gForLTE + ? EnabledNetworks.ENABLED_NETWORKS_EXCEPT_GSM_4G_CHOICES + : EnabledNetworks.ENABLED_NETWORKS_EXCEPT_GSM_CHOICES; + } else if (carrierConfig != null + && !carrierConfig.getBoolean(CarrierConfigManager.KEY_LTE_ENABLED_BOOL)) { + enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_EXCEPT_LTE_CHOICES; + } else if (mIsGlobalCdma) { + enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_CDMA_CHOICES; } else { - preference.setSummary(mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended)); + enabledNetworkType = mShow4gForLTE ? EnabledNetworks.ENABLED_NETWORKS_4G_CHOICES + : EnabledNetworks.ENABLED_NETWORKS_CHOICES; } - break; - default: - preference.setSummary( - mContext.getString(R.string.mobile_network_mode_error, networkMode)); + } + //TODO(b/117881708): figure out what world mode is, then we can optimize code. Otherwise + // I prefer to keep this old code + if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + enabledNetworkType = EnabledNetworks.PREFERRED_NETWORK_MODE_CHOICES_WORLD_MODE; + } + + Log.d(LOG_TAG, "enabledNetworkType: " + enabledNetworkType); + return enabledNetworkType; } + + /** + * Sets the display string for the network mode choice and selects the corresponding item + * + * @param networkMode the current network mode. The current mode might not be an option in + * the choice list. The nearest choice is selected instead + */ + void setPreferenceValueAndSummary(int networkMode) { + setSelectedEntry(networkMode); + switch (networkMode) { + case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_WCDMA: + case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA: + case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM: + setSelectedEntry( + TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA); + setSummary(R.string.network_3G); + break; + case TelephonyManagerConstants.NETWORK_MODE_WCDMA_ONLY: + case TelephonyManagerConstants.NETWORK_MODE_GSM_UMTS: + case TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF: + if (!mIsGlobalCdma) { + setSelectedEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF); + setSummary(R.string.network_3G); + } else { + setSelectedEntry( + TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA); + setSummary(R.string.network_global); + } + break; + case TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY: + if (!mIsGlobalCdma) { + setSelectedEntry(TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY); + setSummary(R.string.network_2G); + } else { + setSelectedEntry( + TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA); + setSummary(R.string.network_global); + } + break; + case TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA: + if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + setSummary( + R.string.preferred_network_mode_lte_gsm_umts_summary); + break; + } + case TelephonyManagerConstants.NETWORK_MODE_LTE_ONLY: + case TelephonyManagerConstants.NETWORK_MODE_LTE_WCDMA: + if (!mIsGlobalCdma) { + setSelectedEntry( + TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); + setSummary( + mShow4gForLTE ? R.string.network_4G : R.string.network_lte); + } else { + setSelectedEntry( + TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA); + setSummary(R.string.network_global); + } + break; + case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO: + if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + setSummary( + R.string.preferred_network_mode_lte_cdma_summary); + } else { + setSelectedEntry( + TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO); + setSummary(is5gEntryDisplayed() + ? R.string.network_lte_pure : R.string.network_lte); + } + break; + case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: + setSelectedEntry( + TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA); + setSummary(R.string.network_3G); + break; + case TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO: + case TelephonyManagerConstants.NETWORK_MODE_EVDO_NO_CDMA: + case TelephonyManagerConstants.NETWORK_MODE_GLOBAL: + setSelectedEntry(TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO); + setSummary(R.string.network_3G); + break; + case TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO: + setSelectedEntry(TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO); + setSummary(R.string.network_1x); + break; + case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_ONLY: + setSelectedEntry(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_ONLY); + setSummary(R.string.network_3G); + break; + case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM: + case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: + case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA: + case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA: + case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: + case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: + if (MobileNetworkUtils.isTdscdmaSupported(mContext, mSubId)) { + setSelectedEntry( + TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA); + setSummary(is5gEntryDisplayed() + ? R.string.network_lte_pure : R.string.network_lte); + } else { + setSelectedEntry( + TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA); + if (mTelephonyManager.getPhoneType() == TelephonyManager.PHONE_TYPE_CDMA + || mIsGlobalCdma + || MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + setSummary(R.string.network_global); + } else { + if (is5gEntryDisplayed()) { + setSummary(mShow4gForLTE + ? R.string.network_4G_pure : R.string.network_lte_pure); + } else { + setSummary(mShow4gForLTE + ? R.string.network_4G : R.string.network_lte); + } + } + } + break; + case TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO: + case TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: + setSelectedEntry(networkMode); + setSummary(mContext.getString(R.string.network_5G) + + mContext.getString(R.string.network_recommended)); + break; + case TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA: + setSelectedEntry( + TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA); + if (mTelephonyManager.getPhoneType() == TelephonyManager.PHONE_TYPE_CDMA + || mIsGlobalCdma + || MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + setSummary(R.string.network_global); + } else { + setSummary(mContext.getString(R.string.network_5G) + + mContext.getString(R.string.network_recommended)); + } + break; + default: + setSummary( + mContext.getString(R.string.mobile_network_mode_error, networkMode)); + } + } + + /** + * Transform LTE network mode to 5G network mode. + * + * @param networkType an LTE network mode without 5G. + * @return the corresponding network mode with 5G. + */ + private static int addNrToLteNetworkType(int networkType) { + switch(networkType) { + case TelephonyManagerConstants.NETWORK_MODE_LTE_ONLY: + return TelephonyManagerConstants.NETWORK_MODE_NR_LTE; + case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO: + return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO; + case TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA: + return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_GSM_WCDMA; + case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: + return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA; + case TelephonyManagerConstants.NETWORK_MODE_LTE_WCDMA: + return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_WCDMA; + case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA: + return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA; + case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM: + return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM; + case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA: + return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_WCDMA; + case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: + return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA; + case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: + return TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA; + default: + return networkType; // not LTE + } + } + + private void setPreferenceValueAndSummary() { + setPreferenceValueAndSummary(getPreferredNetworkMode()); + } + + private boolean checkSupportedRadioBitmask(long supportedRadioBitmask, long targetBitmask) { + return (targetBitmask & supportedRadioBitmask) > 0; + } + + /** + * Add 5G option. Only show the UI when device supported 5G and allowed 5G. + */ + private void add5gEntry(int value) { + boolean isNRValue = value >= TelephonyManagerConstants.NETWORK_MODE_NR_ONLY; + if (mSupported5gRadioAccessFamily && mAllowed5gNetworkType && isNRValue) { + mEntries.add(mContext.getString(R.string.network_5G) + + mContext.getString(R.string.network_recommended)); + mEntriesValue.add(value); + mIs5gEntryDisplayed = true; + } else { + Log.d(LOG_TAG, "Hide 5G option. " + + " supported5GRadioAccessFamily: " + mSupported5gRadioAccessFamily + + " allowed5GNetworkType: " + mAllowed5gNetworkType + + " isNRValue: " + isNRValue); + } + } + + private void addGlobalEntry() { + Log.d(LOG_TAG, "addGlobalEntry. " + + " supported5GRadioAccessFamily: " + mSupported5gRadioAccessFamily + + " allowed5GNetworkType: " + mAllowed5gNetworkType); + mEntries.add(mContext.getString(R.string.network_global)); + if (mSupported5gRadioAccessFamily & mAllowed5gNetworkType) { + mEntriesValue.add( + TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA); + } else { + mEntriesValue.add( + TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA); + } + } + + /** + * Add LTE entry. If device supported 5G, show "LTE" instead of "LTE (recommended)". + */ + private void addLteEntry(int value) { + if (mSupported5gRadioAccessFamily) { + mEntries.add(mContext.getString(R.string.network_lte_pure)); + } else { + mEntries.add(mContext.getString(R.string.network_lte)); + } + mEntriesValue.add(value); + } + + /** + * Add 4G entry. If device supported 5G, show "4G" instead of "4G (recommended)". + */ + private void add4gEntry(int value) { + if (mSupported5gRadioAccessFamily) { + mEntries.add(mContext.getString(R.string.network_4G_pure)); + } else { + mEntries.add(mContext.getString(R.string.network_4G)); + } + mEntriesValue.add(value); + } + + private void add3gEntry(int value) { + mEntries.add(mContext.getString(R.string.network_3G)); + mEntriesValue.add(value); + } + + private void add2gEntry(int value) { + mEntries.add(mContext.getString(R.string.network_2G)); + mEntriesValue.add(value); + } + + private void add1xEntry(int value) { + mEntries.add(mContext.getString(R.string.network_1x)); + mEntriesValue.add(value); + } + + private void addCustomEntry(String name, int value) { + mEntries.add(name); + mEntriesValue.add(value); + } + + private String[] getEntries() { + return mEntries.toArray(new String[0]); + } + + private String[] getEntryValues() { + Integer intArr[] = mEntriesValue.toArray(new Integer[0]); + return Arrays.stream(intArr) + .map(String::valueOf) + .toArray(String[]::new); + } + + private int getSelectedEntryValue() { + return mSelectedEntry; + } + + private void setSelectedEntry(int value) { + boolean isInEntriesValue = mEntriesValue.stream() + .anyMatch(v -> v == value); + + if (isInEntriesValue) { + mSelectedEntry = value; + } else if (mEntriesValue.size() > 0) { + // if the value isn't in entriesValue, select on the first one. + mSelectedEntry = mEntriesValue.get(0); + } else { + Log.e(LOG_TAG, "entriesValue is empty"); + } + } + + private String getSummary() { + return mSummary; + } + + private void setSummary(int summaryResId) { + setSummary(mContext.getString(summaryResId)); + } + + private void setSummary(String summary) { + this.mSummary = summary; + } + + private boolean is5gEntryDisplayed() { + return mIs5gEntryDisplayed; + } + } } diff --git a/tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java index 2f3aeccb883..57729ea78ea 100644 --- a/tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java +++ b/tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java @@ -44,7 +44,6 @@ import androidx.lifecycle.LifecycleOwner; import androidx.preference.ListPreference; import androidx.preference.PreferenceScreen; -import com.android.settings.R; import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants; import com.android.settingslib.core.lifecycle.Lifecycle; @@ -61,6 +60,9 @@ public class EnabledNetworkModePreferenceControllerTest { private static final int SUB_ID = 2; public static final String KEY = "enabled_network"; + private static final long ALLOWED_ALL_NETWORK_TYPE = -1; + private static final long DISABLED_5G_NETWORK_TYPE = ~TelephonyManager.NETWORK_TYPE_BITMASK_NR; + @Mock private TelephonyManager mTelephonyManager; @Mock @@ -92,19 +94,20 @@ public class EnabledNetworkModePreferenceControllerTest { doReturn(mContext).when(mContext).createPackageContext(anyString(), anyInt()); doReturn(mServiceState).when(mTelephonyManager).getServiceState(); mPersistableBundle = new PersistableBundle(); + doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfig(); doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); - mPreference = new ListPreference(mContext); - mPreference.setEntries(R.array.enabled_networks_choices); - mPreference.setEntryValues(R.array.enabled_networks_values); mController = new EnabledNetworkModePreferenceController(mContext, KEY); + mockAllowedNetworkTypes(ALLOWED_ALL_NETWORK_TYPE); + mockAccessFamily(TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA); mController.init(mLifecycle, SUB_ID); mPreference.setKey(mController.getPreferenceKey()); } @Test public void getAvailabilityStatus_hideCarrierNetworkSettings_returnUnavailable() { - mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, + mPersistableBundle.putBoolean( + CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, true); assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); @@ -140,40 +143,118 @@ public class EnabledNetworkModePreferenceControllerTest { } @Test - public void init_initShow4GForLTE() { - mPersistableBundle.putBoolean(CarrierConfigManager.KEY_SHOW_4G_FOR_LTE_DATA_ICON_BOOL, - true); + public void updateState_LteWorldPhone_GlobalHasLte() { + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true); - mController.init(mLifecycle, SUB_ID); + mController.updateState(mPreference); - assertThat(mController.mShow4GForLTE).isTrue(); + assertThat(mPreference.getEntryValues()) + .asList() + .contains(String.valueOf(TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); } @Test - public void init_initDisplay5gList_returnTrue() { - long testBitmask = TelephonyManager.NETWORK_TYPE_BITMASK_NR - | TelephonyManager.NETWORK_TYPE_BITMASK_LTE; - long allowedNetworkTypes = -1; - doReturn(testBitmask).when(mTelephonyManager).getSupportedRadioAccessFamily(); - doReturn(allowedNetworkTypes).when(mTelephonyManager).getAllowedNetworkTypes(); + public void updateState_5gWorldPhone_GlobalHasNr() { + mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA); mController.init(mLifecycle, SUB_ID); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true); - assertThat(mController.mDisplay5gList).isTrue(); + mController.updateState(mPreference); + + assertThat(mPreference.getEntryValues()) + .asList() + .contains(String.valueOf(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA)); } @Test - public void checkSupportedRadioBitmask_nrBitmask_returnTrue() { - long testBitmask = TelephonyManager.NETWORK_TYPE_BITMASK_NR - | TelephonyManager.NETWORK_TYPE_BITMASK_LTE; + public void updateState_selectedOn5gItem() { + mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA); + mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA); + mController.init(mLifecycle, SUB_ID); + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, + TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA); - assertThat(mController.checkSupportedRadioBitmask(testBitmask, - TelephonyManager.NETWORK_TYPE_BITMASK_NR)).isTrue(); + mController.updateState(mPreference); + + assertThat(mPreference.getValue()).isEqualTo( + String.valueOf( + TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); + } + + @Test + public void updateState_disAllowed5g_5gOptionHidden() { + mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA); + mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA); + mockAllowedNetworkTypes(DISABLED_5G_NETWORK_TYPE); + mController.init(mLifecycle, SUB_ID); + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, + TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA); + + mController.updateState(mPreference); + + assertThat(mPreference.getEntryValues()) + .asList() + .doesNotContain( + String.valueOf(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA)); + } + + @Test + public void updateState_disAllowed5g_selectOn4gOption() { + mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA); + mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA); + mockAllowedNetworkTypes(DISABLED_5G_NETWORK_TYPE); + mController.init(mLifecycle, SUB_ID); + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, + TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA); + + mController.updateState(mPreference); + + assertThat(mPreference.getValue()).isEqualTo( + String.valueOf( + TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); + } + + @Test + public void updateState_GlobalDisAllowed5g_GlobalWithoutNR() { + mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA); + mockAllowedNetworkTypes(DISABLED_5G_NETWORK_TYPE); + mController.init(mLifecycle, SUB_ID); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true); + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, + TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA); + + mController.updateState(mPreference); + + assertThat(mPreference.getEntryValues()) + .asList() + .doesNotContain( + String.valueOf(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA)); + } + + @Test + public void updateState_GlobalDisAllowed5g_SelectOnGlobal() { + mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA); + mockAllowedNetworkTypes(DISABLED_5G_NETWORK_TYPE); + mController.init(mLifecycle, SUB_ID); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true); + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, + TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA); + + mController.updateState(mPreference); + + assertThat(mPreference.getValue()).isEqualTo( + String.valueOf( + TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); } @Test public void updateState_updateByNetworkMode() { - long allowedNetworkTypes = -1; - doReturn(allowedNetworkTypes).when(mTelephonyManager).getAllowedNetworkTypes(); + mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA); Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA); @@ -187,8 +268,7 @@ public class EnabledNetworkModePreferenceControllerTest { @Test public void updateState_updateByNetworkMode_useDefaultValue() { - long allowedNetworkTypes = -1; - doReturn(allowedNetworkTypes).when(mTelephonyManager).getAllowedNetworkTypes(); + mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); @@ -199,208 +279,13 @@ public class EnabledNetworkModePreferenceControllerTest { String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); } - /** - * @string/enabled_networks_cdma_choices - * Before | After - * @string/network_lte , 8 |@string/network_5G + @string/network_recommended , 25 - * @string/network_3G , 4 |@string/network_lte_pure, 8 - * @string/network_1x , 5 |@string/network_3G , 4 - * @string/network_global, 10|@string/network_1x , 5 - * |@string/network_global , 27 - * - * @string/enabled_networks_cdma_only_lte_choices - * Before | After - * @string/network_lte , 8 |@string/network_5G + @string/network_recommended , 25 - * @string/network_global, 10|@string/network_lte_pure, 8 - * |@string/network_global , 27 - */ - @Test - public void add5gListItem_lteCdma_5gLteCdma() { - //case#1 - mPreference.setEntries(R.array.enabled_networks_cdma_choices); - mPreference.setEntryValues(R.array.enabled_networks_cdma_values); - CharSequence[] testEntries = {mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended) - , mContext.getString(R.string.network_lte_pure) - , mContext.getString(R.string.network_3G) - , mContext.getString(R.string.network_1x) - , mContext.getString(R.string.network_global)}; - CharSequence[] testEntryValues = {"25", "8", "4", "5", "27"}; - - mController.add5gListItem(mPreference); - - assertThat(mPreference.getEntries()).isEqualTo(testEntries); - assertThat(mPreference.getEntryValues()).isEqualTo(testEntryValues); - - //case#2 - mPreference.setEntries(R.array.enabled_networks_cdma_only_lte_choices); - mPreference.setEntryValues(R.array.enabled_networks_cdma_only_lte_values); - CharSequence[] testEntries1 = {mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended) - , mContext.getString(R.string.network_lte_pure) - , mContext.getString(R.string.network_global)}; - CharSequence[] testEntryValues1 = {"25", "8", "27"}; - - mController.add5gListItem(mPreference); - - assertThat(mPreference.getEntries()).isEqualTo(testEntries1); - assertThat(mPreference.getEntryValues()).isEqualTo(testEntryValues1); - } - - /** - * @string/enabled_networks_except_gsm_4g_choices - * Before | After - * @string/network_4G , 9 |@string/network_5G + @string/network_recommended , 26 - * @string/network_3G , 0 |@string/network_4G_pure , 9 - * |@string/network_3G , 0 - * - * @string/enabled_networks_except_gsm_choices - * Before | After - * @string/network_lte, 9 |@string/network_5G + @string/network_recommended , 26 - * @string/network_3G , 0 |@string/network_lte_pure, 9 - * |@string/network_3G , 0 - * - * @string/enabled_networks_4g_choices - * Before | After - * @string/network_4G , 9 |@string/network_5G + @string/network_recommended , 26 - * @string/network_3G , 0 |@string/network_4G_pure , 9 - * @string/network_2G , 1 |@string/network_3G , 0 - * |@string/network_2G , 1 - * - * @string/enabled_networks_choices - * Before | After - * @string/network_lte, 9 |@string/network_5G + @string/network_recommended , 26 - * @string/network_3G , 0 |@string/network_lte_pure, 9 - * @string/network_2G , 1 |@string/network_3G , 0 - * |@string/network_2G , 1 - */ - @Test - public void add5gListItem_lteGsm_5gLteGsm() { - //csae#1 - mPreference.setEntries(R.array.enabled_networks_except_gsm_4g_choices); - mPreference.setEntryValues(R.array.enabled_networks_except_gsm_values); - CharSequence[] testEntries = {mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended) - , mContext.getString(R.string.network_4G_pure) - , mContext.getString(R.string.network_3G)}; - CharSequence[] testEntryValues = {"26", "9", "0"}; - - mController.add5gListItem(mPreference); - - assertThat(mPreference.getEntries()).isEqualTo(testEntries); - assertThat(mPreference.getEntryValues()).isEqualTo(testEntryValues); - - //case#2 - mPreference.setEntries(R.array.enabled_networks_except_gsm_choices); - mPreference.setEntryValues(R.array.enabled_networks_except_gsm_values); - CharSequence[] testEntries1 = {mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended) - , mContext.getString(R.string.network_lte_pure) - , mContext.getString(R.string.network_3G)}; - CharSequence[] testEntryValues1 = {"26", "9", "0"}; - - mController.add5gListItem(mPreference); - - assertThat(mPreference.getEntries()).isEqualTo(testEntries1); - assertThat(mPreference.getEntryValues()).isEqualTo(testEntryValues1); - - //case#3 - mPreference.setEntries(R.array.enabled_networks_4g_choices); - mPreference.setEntryValues(R.array.enabled_networks_values); - CharSequence[] testEntries2 = {mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended) - , mContext.getString(R.string.network_4G_pure) - , mContext.getString(R.string.network_3G) - , mContext.getString(R.string.network_2G)}; - CharSequence[] testEntryValues2 = {"26", "9", "0", "1"}; - - mController.add5gListItem(mPreference); - - assertThat(mPreference.getEntries()).isEqualTo(testEntries2); - assertThat(mPreference.getEntryValues()).isEqualTo(testEntryValues2); - - //case#4 - mPreference.setEntries(R.array.enabled_networks_choices); - mPreference.setEntryValues(R.array.enabled_networks_values); - CharSequence[] testEntries3 = {mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended) - , mContext.getString(R.string.network_lte_pure) - , mContext.getString(R.string.network_3G) - , mContext.getString(R.string.network_2G)}; - CharSequence[] testEntryValues3 = {"26", "9", "0", "1"}; - - mController.add5gListItem(mPreference); - - assertThat(mPreference.getEntries()).isEqualTo(testEntries3); - assertThat(mPreference.getEntryValues()).isEqualTo(testEntryValues3); - } - - /** - * @string/preferred_network_mode_choices_world_mode - * Before | After - * "Global" , 10|@string/network_global , 27 - * "LTE / CDMA" , 8 |"LTE / CDMA" , 8 - * "LTE / GSM / UMTS" , 9 |"LTE / GSM / UMTS" , 9 - */ - @Test - public void add5gListItem_worldPhone_Global() { - mPreference.setEntries(R.array.preferred_network_mode_choices_world_mode); - mPreference.setEntryValues(R.array.preferred_network_mode_values_world_mode); - CharSequence[] testEntries = {mContext.getString(R.string.network_global) - , "LTE / CDMA" - , "LTE / GSM / UMTS"}; - CharSequence[] testEntryValues = {"27", "8", "9"}; - - mController.add5gListItem(mPreference); - - assertThat(mPreference.getEntries()).isEqualTo(testEntries); - assertThat(mPreference.getEntryValues()).isEqualTo(testEntryValues); - } - - /** - * @string/enabled_networks_tdscdma_choices - * Before | After - * @string/network_lte, 22|@string/network_5G + @string/network_recommended , 33 - * @string/network_3G , 18|@string/network_lte_pure, 22 - * @string/network_2G , 1 |@string/network_3G , 18 - * |@string/network_2G , 1 - */ - @Test - public void add5gListItem_td_5gTd() { - mPreference.setEntries(R.array.enabled_networks_tdscdma_choices); - mPreference.setEntryValues(R.array.enabled_networks_tdscdma_values); - CharSequence[] testEntries = {mContext.getString(R.string.network_5G) - + mContext.getString(R.string.network_recommended) - , mContext.getString(R.string.network_lte_pure) - , mContext.getString(R.string.network_3G) - , mContext.getString(R.string.network_2G)}; - CharSequence[] testEntryValues = {"33", "22", "18", "1"}; - - mController.add5gListItem(mPreference); - - assertThat(mPreference.getEntries()).isEqualTo(testEntries); - assertThat(mPreference.getEntryValues()).isEqualTo(testEntryValues); - } - - @Test - public void add5gListItem_noLte_no5g() { - mPreference.setEntries(R.array.enabled_networks_except_lte_choices); - mPreference.setEntryValues(R.array.enabled_networks_except_lte_values); - CharSequence[] testEntries = {mContext.getString(R.string.network_3G) - , mContext.getString(R.string.network_2G)}; - CharSequence[] testEntryValues = {"0", "1"}; - - mController.add5gListItem(mPreference); - - assertThat(mPreference.getEntries()).isEqualTo(testEntries); - assertThat(mPreference.getEntryValues()).isEqualTo(testEntryValues); - } - @Test public void onPreferenceChange_updateSuccess() { + mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); doReturn(true).when(mTelephonyManager).setPreferredNetworkTypeBitmask( getRafFromNetworkType(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); + mController.updateState(mPreference); mController.onPreferenceChange(mPreference, String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); @@ -410,9 +295,11 @@ public class EnabledNetworkModePreferenceControllerTest { @Test public void onPreferenceChange_updateFail() { + mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); doReturn(false).when(mTelephonyManager).setPreferredNetworkTypeBitmask( getRafFromNetworkType(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); + mController.updateState(mPreference); mController.onPreferenceChange(mPreference, String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); @@ -423,8 +310,7 @@ public class EnabledNetworkModePreferenceControllerTest { @Test public void preferredNetworkModeNotification_preferenceUpdates() { PreferenceScreen screen = mock(PreferenceScreen.class); - long allowedNetworkTypes = -1; - doReturn(allowedNetworkTypes).when(mTelephonyManager).getAllowedNetworkTypes(); + mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA); doReturn(mPreference).when(screen).findPreference(KEY); Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, @@ -448,4 +334,32 @@ public class EnabledNetworkModePreferenceControllerTest { TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY); assertThat(mPreference.getSummary()).isEqualTo("2G"); } + + private void mockEnabledNetworkMode(int networkMode) { + if (networkMode == TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA) { + mockPhoneType(TelephonyManager.PHONE_TYPE_GSM); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, true); + } else if (networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA) { + mockPhoneType(TelephonyManager.PHONE_TYPE_GSM); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL, true); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_LTE_ENABLED_BOOL, true); + } else if (networkMode == TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA) { + mockPhoneType(TelephonyManager.PHONE_TYPE_GSM); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, true); + } + } + + private void mockAllowedNetworkTypes(long allowedNetworkType) { + doReturn(allowedNetworkType).when(mTelephonyManager).getAllowedNetworkTypes(); + } + + private void mockAccessFamily(int networkMode) { + doReturn(MobileNetworkUtils.getRafFromNetworkType(networkMode)) + .when(mTelephonyManager) + .getSupportedRadioAccessFamily(); + } + + private void mockPhoneType(int phoneType) { + doReturn(TelephonyManager.PHONE_TYPE_GSM).when(mTelephonyManager).getPhoneType(); + } }