From 75867d8f634ce62f4787dbf2aef71312308dd415 Mon Sep 17 00:00:00 2001 From: calvinpan Date: Mon, 24 Feb 2020 16:50:01 +0800 Subject: [PATCH] Hide the 5G opiton when 5G has been disallowed 1. Create PreferenceEntriesBuilder for 5G entry. In the past, the preferred network type entries was based on CarrierConfigManger value but 5G option is based on allowed netowork type and device access family, so include 4G and 5G logic in PreferenceEntriesBuilder. 2. If user selected item not in preferred network option, settings will auto selected on the first item. For example, if user selected on 5G and device disallowed 5G(5G option will be hide), so settings will selected on first item(4G). Bug: 149721842 Test: EnabledNetworkModePreferenceControllerTest Change-Id: Ic447a137f9db4cf1a0048a8e58487c29b402bb48 --- res/values/arrays.xml | 83 -- res/values/strings.xml | 6 +- ...nabledNetworkModePreferenceController.java | 916 ++++++++++-------- ...edNetworkModePreferenceControllerTest.java | 364 +++---- 4 files changed, 647 insertions(+), 722 deletions(-) diff --git a/res/values/arrays.xml b/res/values/arrays.xml index c19b948d38f..591a96572cf 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 608eac8b73e..71dfa79962c 100644 --- a/res/values/strings.xml +++ b/res/values/strings.xml @@ -11287,7 +11287,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(); + } }