PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Hide the 5G opiton when 5G has been disallowed

Browse Source 
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
This commit is contained in:
calvinpan
2020-02-24 16:50:01 +08:00
committed by Calvin Pan
parent e5110e9388
commit 75867d8f63
4 changed files with 647 additions and 722 deletions
Download Patch File Download Diff File Expand all files Collapse all files

83
res/values/arrays.xml
View File

@@ -1375,89 +1375,6 @@
<item>"1"</item> <item>"1"</item>
</string-array> </string-array>
<string-array name="enabled_networks_except_gsm_choices" translatable="false">
<item>@string/network_lte</item>
<item>@string/network_3G</item>
</string-array>
<string-array name="enabled_networks_except_gsm_4g_choices" translatable="false">
<item>@string/network_4G</item>
<item>@string/network_3G</item>
</string-array>
<string-array name="enabled_networks_except_gsm_values" translatable="false">
<item>"9"</item>
<item>"0"</item>
</string-array>
<string-array name="enabled_networks_except_lte_choices" translatable="false">
<item>@string/network_3G</item>
<item>@string/network_2G</item>
</string-array>
<string-array name="enabled_networks_except_lte_values" translatable="false">
<item>"0"</item>
<item>"1"</item>
</string-array>
<string-array name="enabled_networks_except_gsm_lte_choices" translatable="false">
<item>@string/network_3G</item>
</string-array>
<string-array name="enabled_networks_except_gsm_lte_values" translatable="false">
<item>"0"</item>
</string-array>
<string-array name="enabled_networks_cdma_choices" translatable="false">
<item>@string/network_lte</item>
<item>@string/network_3G</item>
<item>@string/network_1x</item>
<item>@string/network_global</item>
</string-array>
<string-array name="enabled_networks_cdma_values" translatable="false">
<item>"8"</item>
<item>"4"</item>
<item>"5"</item>
<item>"10"</item>
</string-array>
<string-array name="enabled_networks_cdma_no_lte_choices" translatable="false">
<item>@string/network_3G</item>
<item>@string/network_1x</item>
</string-array>
<string-array name="enabled_networks_cdma_no_lte_values" translatable="false">
<item>"4"</item>
<item>"5"</item>
</string-array>
<string-array name="enabled_networks_cdma_only_lte_choices" translatable="false">
<item>@string/network_lte</item>
<item>@string/network_global</item>
</string-array>
<string-array name="enabled_networks_cdma_only_lte_values" translatable="false">
<item>"8"</item>
<item>"10"</item>
</string-array>
<string-array name="enabled_networks_tdscdma_choices" translatable="false">
<item>@string/network_lte</item>
<item>@string/network_3G</item>
<item>@string/network_2G</item>
</string-array>
<string-array name="enabled_networks_tdscdma_values" translatable="false">
<item>"22"</item>
<item>"18"</item>
<item>"1"</item>
</string-array>
<!--String arrays for World preferred netwrok modes -->
<string-array name="preferred_network_mode_choices_world_mode">
<item>Global</item>
<item>LTE / CDMA</item>
<item>LTE / GSM / UMTS</item>
</string-array>
<string-array name="preferred_network_mode_values_world_mode" translatable="false">
<item>"10"</item>
<item>"8"</item>
<item>"9"</item>
</string-array>
<!-- WiFi calling mode array --> <!-- WiFi calling mode array -->
<string-array name="wifi_calling_mode_summaries" translatable="false"> <string-array name="wifi_calling_mode_summaries" translatable="false">

6
res/values/strings.xml
View File

@@ -11287,7 +11287,11 @@
<!-- Text for Network 1x [CHAR LIMIT=NONE] --> <!-- Text for Network 1x [CHAR LIMIT=NONE] -->
<string name="network_1x" translatable="false">1x</string> <string name="network_1x" translatable="false">1x</string>
<!-- Text for Network global [CHAR LIMIT=NONE] --> <!-- Text for Network global [CHAR LIMIT=NONE] -->
<string name="network_global">Global</string> <string name="network_global" translatable="false">Global</string>
<!-- Text for Network world mode CDMA LTE [CHAR LIMIT=NONE] -->
<string name="network_world_mode_cdma_lte" translatable="false">LTE / CDMA</string>
<!-- Text for Network world mode GSM LTE [CHAR LIMIT=NONE] -->
<string name="network_world_mode_gsm_lte" translatable="false">LTE / GSM / UMTS</string>
<!-- Available networks screen title/heading [CHAR LIMIT=NONE] --> <!-- Available networks screen title/heading [CHAR LIMIT=NONE] -->
<string name="label_available">Available networks</string> <string name="label_available">Available networks</string>

916
src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java
View File

@@ -28,10 +28,8 @@ import android.provider.Settings;
import android.telephony.CarrierConfigManager; import android.telephony.CarrierConfigManager;
import android.telephony.SubscriptionManager; import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager; import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log; import android.util.Log;
import androidx.annotation.VisibleForTesting;
import androidx.lifecycle.Lifecycle; import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver; import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent; import androidx.lifecycle.OnLifecycleEvent;
@@ -43,6 +41,7 @@ import com.android.settings.R;
import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants; import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.Arrays;
import java.util.List; import java.util.List;
/** /**
@@ -53,19 +52,14 @@ public class EnabledNetworkModePreferenceController extends
ListPreference.OnPreferenceChangeListener, LifecycleObserver { ListPreference.OnPreferenceChangeListener, LifecycleObserver {
private static final String LOG_TAG = "EnabledNetworkMode"; private static final String LOG_TAG = "EnabledNetworkMode";
private CarrierConfigManager mCarrierConfigManager;
private ContentObserver mPreferredNetworkModeObserver; private ContentObserver mPreferredNetworkModeObserver;
private TelephonyManager mTelephonyManager;
private boolean mIsGlobalCdma;
@VisibleForTesting
boolean mShow4GForLTE;
private Preference mPreference; private Preference mPreference;
@VisibleForTesting private TelephonyManager mTelephonyManager;
boolean mDisplay5gList = false; private CarrierConfigManager mCarrierConfigManager;
private PreferenceEntriesBuilder mBuilder;
public EnabledNetworkModePreferenceController(Context context, String key) { public EnabledNetworkModePreferenceController(Context context, String key) {
super(context, key); super(context, key);
mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class);
mPreferredNetworkModeObserver = new ContentObserver(new Handler(Looper.getMainLooper())) { mPreferredNetworkModeObserver = new ContentObserver(new Handler(Looper.getMainLooper())) {
@Override @Override
public void onChange(boolean selfChange) { public void onChange(boolean selfChange) {
@@ -101,7 +95,8 @@ public class EnabledNetworkModePreferenceController extends
@OnLifecycleEvent(ON_START) @OnLifecycleEvent(ON_START)
public void onStart() { public void onStart() {
mContext.getContentResolver().registerContentObserver( mContext.getContentResolver().registerContentObserver(
Settings.Global.getUriFor(Settings.Global.PREFERRED_NETWORK_MODE + mSubId), true, Settings.Global.getUriFor(Settings.Global.PREFERRED_NETWORK_MODE + mSubId),
true,
mPreferredNetworkModeObserver); mPreferredNetworkModeObserver);
} }
@@ -120,444 +115,539 @@ public class EnabledNetworkModePreferenceController extends
public void updateState(Preference preference) { public void updateState(Preference preference) {
super.updateState(preference); super.updateState(preference);
final ListPreference listPreference = (ListPreference) preference; final ListPreference listPreference = (ListPreference) preference;
final int networkMode = getPreferredNetworkMode();
Log.d(LOG_TAG, "updateState networkMode: " + networkMode);
updatePreferenceEntries(listPreference); mBuilder.setPreferenceEntries();
updatePreferenceValueAndSummary(listPreference, networkMode); mBuilder.setPreferenceValueAndSummary();
listPreference.setEntries(mBuilder.getEntries());
listPreference.setEntryValues(mBuilder.getEntryValues());
listPreference.setValue(Integer.toString(mBuilder.getSelectedEntryValue()));
listPreference.setSummary(mBuilder.getSummary());
} }
@Override @Override
public boolean onPreferenceChange(Preference preference, Object object) { public boolean onPreferenceChange(Preference preference, Object object) {
final int newPreferredNetworkMode = Integer.parseInt((String) object); final int newPreferredNetworkMode = Integer.parseInt((String) object);
final ListPreference listPreference = (ListPreference) preference;
if (mTelephonyManager.setPreferredNetworkTypeBitmask( if (mTelephonyManager.setPreferredNetworkTypeBitmask(
MobileNetworkUtils.getRafFromNetworkType(newPreferredNetworkMode))) { MobileNetworkUtils.getRafFromNetworkType(newPreferredNetworkMode))) {
updatePreferenceValueAndSummary((ListPreference) preference, newPreferredNetworkMode); mBuilder.setPreferenceValueAndSummary(newPreferredNetworkMode);
listPreference.setValue(Integer.toString(mBuilder.getSelectedEntryValue()));
listPreference.setSummary(mBuilder.getSummary());
return true; return true;
} }
return false; return false;
} }
public void init(Lifecycle lifecycle, int subId) { public void init(Lifecycle lifecycle, int subId) {
mSubId = subId; mSubId = subId;
final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId);
mTelephonyManager = mContext.getSystemService(TelephonyManager.class) mTelephonyManager = mContext.getSystemService(TelephonyManager.class)
.createForSubscriptionId(mSubId); .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); lifecycle.addObserver(this);
} }
private int getPreferredNetworkMode() { private final static class PreferenceEntriesBuilder {
long preferredNetworkBitMask = MobileNetworkUtils.getRafFromNetworkType( private CarrierConfigManager mCarrierConfigManager;
Settings.Global.getInt(mContext.getContentResolver(), private Context mContext;
Settings.Global.PREFERRED_NETWORK_MODE + mSubId, private TelephonyManager mTelephonyManager;
TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE));
return MobileNetworkUtils.getNetworkTypeFromRaf((int)
(preferredNetworkBitMask & mTelephonyManager.getAllowedNetworkTypes()));
}
private void updatePreferenceEntries(ListPreference preference) { private boolean mAllowed5gNetworkType;
final int phoneType = mTelephonyManager.getPhoneType(); private boolean mIsGlobalCdma;
final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId); private boolean mIs5gEntryDisplayed;
if (phoneType == TelephonyManager.PHONE_TYPE_CDMA) { private boolean mShow4gForLTE;
final int lteForced = android.provider.Settings.Global.getInt( private boolean mSupported5gRadioAccessFamily;
mContext.getContentResolver(), private int mSelectedEntry;
android.provider.Settings.Global.LTE_SERVICE_FORCED + mSubId, private int mSubId;
0); private String mSummary;
final int settingsNetworkMode = getPreferredNetworkMode();
if (mTelephonyManager.isLteCdmaEvdoGsmWcdmaEnabled()) { private List<String> mEntries = new ArrayList<>();
if (lteForced == 0) { private List<Integer> mEntriesValue = new ArrayList<>();
preference.setEntries(
R.array.enabled_networks_cdma_choices); enum EnabledNetworks {
preference.setEntryValues( ENABLED_NETWORKS_UNKNOWN,
R.array.enabled_networks_cdma_values); ENABLED_NETWORKS_CDMA_CHOICES,
} else { ENABLED_NETWORKS_CDMA_NO_LTE_CHOICES,
switch (settingsNetworkMode) { ENABLED_NETWORKS_CDMA_ONLY_LTE_CHOICES,
case TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO: ENABLED_NETWORKS_TDSCDMA_CHOICES,
case TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO: ENABLED_NETWORKS_EXCEPT_GSM_LTE_CHOICES,
case TelephonyManagerConstants.NETWORK_MODE_EVDO_NO_CDMA: ENABLED_NETWORKS_EXCEPT_GSM_4G_CHOICES,
preference.setEntries( ENABLED_NETWORKS_EXCEPT_GSM_CHOICES,
R.array.enabled_networks_cdma_no_lte_choices); ENABLED_NETWORKS_EXCEPT_LTE_CHOICES,
preference.setEntryValues( ENABLED_NETWORKS_4G_CHOICES,
R.array.enabled_networks_cdma_no_lte_values); ENABLED_NETWORKS_CHOICES,
break; PREFERRED_NETWORK_MODE_CHOICES_WORLD_MODE
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);
} }
if (mDisplay5gList) { PreferenceEntriesBuilder(Context context, int subId) {
add5gListItem(preference); this.mContext = context;
} this.mSubId = subId;
}
@VisibleForTesting mCarrierConfigManager = mContext.getSystemService(CarrierConfigManager.class);
boolean checkSupportedRadioBitmask(long supportedRadioBitmask, long targetBitmask) { mTelephonyManager = mContext.getSystemService(TelephonyManager.class)
Log.d(LOG_TAG, "supportedRadioBitmask: " + supportedRadioBitmask); .createForSubscriptionId(mSubId);
if ((targetBitmask & supportedRadioBitmask) > 0) {
return true;
}
return false;
}
/*** final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId);
* Generate preferred network choices list for 5G mAllowed5gNetworkType = checkSupportedRadioBitmask(
* mTelephonyManager.getAllowedNetworkTypes(),
* @string/enabled_networks_cdma_choices TelephonyManager.NETWORK_TYPE_BITMASK_NR);
* Before | After mSupported5gRadioAccessFamily = checkSupportedRadioBitmask(
* @string/network_lte , 8 |@string/network_5G + @string/network_recommended , 25 mTelephonyManager.getSupportedRadioAccessFamily(),
* @string/network_3G , 4 |@string/network_lte_pure, 8 TelephonyManager.NETWORK_TYPE_BITMASK_NR);
* @string/network_1x , 5 |@string/network_3G , 4 mIsGlobalCdma = mTelephonyManager.isLteCdmaEvdoGsmWcdmaEnabled()
* @string/network_global, 10|@string/network_1x , 5 && carrierConfig.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL);
* |@string/network_global , 27 mShow4gForLTE = carrierConfig != null && carrierConfig.getBoolean(
* CarrierConfigManager.KEY_SHOW_4G_FOR_LTE_DATA_ICON_BOOL);
* @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<CharSequence> newEntries = new ArrayList<>();
List<CharSequence> 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);
} }
preference.setEntries(newEntries.toArray(new CharSequence[newEntries.size()])); void setPreferenceEntries() {
preference.setEntryValues(newEntryValues.toArray(new CharSequence[newEntryValues.size()])); switch (getEnabledNetworkType()) {
} case ENABLED_NETWORKS_CDMA_CHOICES:
add5gEntry(addNrToLteNetworkType(
/** TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO));
* transform LTE network mode to 5G network mode. addLteEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO);
* add3gEntry(TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO);
* @param networkMode an LTE network mode without 5G. add1xEntry(TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO);
* @return the corresponding network mode with 5G. addGlobalEntry();
*/
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);
break; break;
} case ENABLED_NETWORKS_CDMA_NO_LTE_CHOICES:
case TelephonyManagerConstants.NETWORK_MODE_LTE_ONLY: add3gEntry(TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO);
case TelephonyManagerConstants.NETWORK_MODE_LTE_WCDMA: add1xEntry(TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO);
if (!mIsGlobalCdma) { break;
preference.setValue( case ENABLED_NETWORKS_CDMA_ONLY_LTE_CHOICES:
Integer.toString(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); addLteEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO);
preference.setSummary( addGlobalEntry();
mShow4GForLTE ? R.string.network_4G : R.string.network_lte); break;
} else { case ENABLED_NETWORKS_TDSCDMA_CHOICES:
preference.setValue( add5gEntry(addNrToLteNetworkType(
Integer.toString(TelephonyManagerConstants TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA));
.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); addLteEntry(
preference.setSummary(R.string.network_global); TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA);
} add3gEntry(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA);
break; add2gEntry(TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY);
case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO: break;
if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) { case ENABLED_NETWORKS_EXCEPT_GSM_LTE_CHOICES:
preference.setSummary( add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF);
R.string.preferred_network_mode_lte_cdma_summary); break;
} else { case ENABLED_NETWORKS_EXCEPT_GSM_4G_CHOICES:
preference.setValue( add5gEntry(addNrToLteNetworkType(
Integer.toString(TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO)); TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
preference.setSummary( add4gEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
mDisplay5gList ? R.string.network_lte_pure : R.string.network_lte); add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF);
} break;
break; case ENABLED_NETWORKS_EXCEPT_GSM_CHOICES:
case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: add5gEntry(addNrToLteNetworkType(
preference.setValue(Integer.toString(TelephonyManagerConstants TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); addLteEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
preference.setSummary(R.string.network_3G); add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF);
break; break;
case TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO: case ENABLED_NETWORKS_EXCEPT_LTE_CHOICES:
case TelephonyManagerConstants.NETWORK_MODE_EVDO_NO_CDMA: add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF);
case TelephonyManagerConstants.NETWORK_MODE_GLOBAL: add2gEntry(TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY);
preference.setValue( break;
Integer.toString(TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO)); case ENABLED_NETWORKS_4G_CHOICES:
preference.setSummary(R.string.network_3G); add5gEntry(addNrToLteNetworkType(
break; TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
case TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO: add4gEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
preference.setValue( add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF);
Integer.toString(TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO)); add2gEntry(TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY);
preference.setSummary(R.string.network_1x); break;
break; case ENABLED_NETWORKS_CHOICES:
case TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_ONLY: add5gEntry(addNrToLteNetworkType(
preference.setValue( TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
Integer.toString(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_ONLY)); addLteEntry(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
preference.setSummary(R.string.network_3G); add3gEntry(TelephonyManagerConstants.NETWORK_MODE_WCDMA_PREF);
break; add2gEntry(TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY);
case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM: break;
case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: case PREFERRED_NETWORK_MODE_CHOICES_WORLD_MODE:
case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA: addGlobalEntry();
case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA: addCustomEntry(mContext.getString(R.string.network_world_mode_cdma_lte),
case TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO);
case TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: addCustomEntry(mContext.getString(R.string.network_world_mode_gsm_lte),
if (MobileNetworkUtils.isTdscdmaSupported(mContext, mSubId)) { TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
preference.setValue( break;
Integer.toString(TelephonyManagerConstants default:
.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA)); throw new IllegalArgumentException("Not supported enabled network types.");
preference.setSummary( }
mDisplay5gList ? R.string.network_lte_pure : R.string.network_lte); }
} else {
preference.setValue( private int getPreferredNetworkMode() {
Integer.toString(TelephonyManagerConstants return Settings.Global.getInt(mContext.getContentResolver(),
.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA)); Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
if (mTelephonyManager.getPhoneType() == TelephonyManager.PHONE_TYPE_CDMA TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE);
|| mIsGlobalCdma }
|| MobileNetworkUtils.isWorldMode(mContext, mSubId)) {
preference.setSummary(R.string.network_global); 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 { } else {
if (mDisplay5gList) { switch (settingsNetworkMode) {
preference.setSummary(mShow4GForLTE case TelephonyManagerConstants.NETWORK_MODE_CDMA_EVDO:
? R.string.network_4G_pure : R.string.network_lte_pure); case TelephonyManagerConstants.NETWORK_MODE_CDMA_NO_EVDO:
} else { case TelephonyManagerConstants.NETWORK_MODE_EVDO_NO_CDMA:
preference.setSummary(mShow4GForLTE enabledNetworkType =
? R.string.network_4G : R.string.network_lte); 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; } else if (phoneType == TelephonyManager.PHONE_TYPE_GSM) {
case TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO: if (MobileNetworkUtils.isTdscdmaSupported(mContext, mSubId)) {
case TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_TDSCDMA_CHOICES;
preference.setValue(Integer.toString(networkMode)); } else if (carrierConfig != null
preference.setSummary(mContext.getString(R.string.network_5G) && !carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL)
+ mContext.getString(R.string.network_recommended)); && !carrierConfig.getBoolean(CarrierConfigManager.KEY_LTE_ENABLED_BOOL)) {
break; enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_EXCEPT_GSM_LTE_CHOICES;
case TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA: } else if (carrierConfig != null
preference.setValue( && !carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL)) {
Integer.toString(TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA)); enabledNetworkType = mShow4gForLTE
if (mTelephonyManager.getPhoneType() == TelephonyManager.PHONE_TYPE_CDMA ? EnabledNetworks.ENABLED_NETWORKS_EXCEPT_GSM_4G_CHOICES
|| mIsGlobalCdma : EnabledNetworks.ENABLED_NETWORKS_EXCEPT_GSM_CHOICES;
|| MobileNetworkUtils.isWorldMode(mContext, mSubId)) { } else if (carrierConfig != null
preference.setSummary(R.string.network_global); && !carrierConfig.getBoolean(CarrierConfigManager.KEY_LTE_ENABLED_BOOL)) {
enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_EXCEPT_LTE_CHOICES;
} else if (mIsGlobalCdma) {
enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_CDMA_CHOICES;
} else { } else {
preference.setSummary(mContext.getString(R.string.network_5G) enabledNetworkType = mShow4gForLTE ? EnabledNetworks.ENABLED_NETWORKS_4G_CHOICES
+ mContext.getString(R.string.network_recommended)); : EnabledNetworks.ENABLED_NETWORKS_CHOICES;
} }
break; }
default: //TODO(b/117881708): figure out what world mode is, then we can optimize code. Otherwise
preference.setSummary( // I prefer to keep this old code
mContext.getString(R.string.mobile_network_mode_error, networkMode)); 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;
}
} }
} }

364
tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java
View File

@@ -44,7 +44,6 @@ import androidx.lifecycle.LifecycleOwner;
import androidx.preference.ListPreference; import androidx.preference.ListPreference;
import androidx.preference.PreferenceScreen; import androidx.preference.PreferenceScreen;
import com.android.settings.R;
import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants; import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants;
import com.android.settingslib.core.lifecycle.Lifecycle; import com.android.settingslib.core.lifecycle.Lifecycle;
@@ -61,6 +60,9 @@ public class EnabledNetworkModePreferenceControllerTest {
private static final int SUB_ID = 2; private static final int SUB_ID = 2;
public static final String KEY = "enabled_network"; 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 @Mock
private TelephonyManager mTelephonyManager; private TelephonyManager mTelephonyManager;
@Mock @Mock
@@ -92,19 +94,20 @@ public class EnabledNetworkModePreferenceControllerTest {
doReturn(mContext).when(mContext).createPackageContext(anyString(), anyInt()); doReturn(mContext).when(mContext).createPackageContext(anyString(), anyInt());
doReturn(mServiceState).when(mTelephonyManager).getServiceState(); doReturn(mServiceState).when(mTelephonyManager).getServiceState();
mPersistableBundle = new PersistableBundle(); mPersistableBundle = new PersistableBundle();
doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfig();
doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID);
mPreference = new ListPreference(mContext); mPreference = new ListPreference(mContext);
mPreference.setEntries(R.array.enabled_networks_choices);
mPreference.setEntryValues(R.array.enabled_networks_values);
mController = new EnabledNetworkModePreferenceController(mContext, KEY); mController = new EnabledNetworkModePreferenceController(mContext, KEY);
mockAllowedNetworkTypes(ALLOWED_ALL_NETWORK_TYPE);
mockAccessFamily(TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA);
mController.init(mLifecycle, SUB_ID); mController.init(mLifecycle, SUB_ID);
mPreference.setKey(mController.getPreferenceKey()); mPreference.setKey(mController.getPreferenceKey());
} }
@Test @Test
public void getAvailabilityStatus_hideCarrierNetworkSettings_returnUnavailable() { public void getAvailabilityStatus_hideCarrierNetworkSettings_returnUnavailable() {
mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, mPersistableBundle.putBoolean(
CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL,
true); true);
assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
@@ -140,40 +143,118 @@ public class EnabledNetworkModePreferenceControllerTest {
} }
@Test @Test
public void init_initShow4GForLTE() { public void updateState_LteWorldPhone_GlobalHasLte() {
mPersistableBundle.putBoolean(CarrierConfigManager.KEY_SHOW_4G_FOR_LTE_DATA_ICON_BOOL, mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
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 @Test
public void init_initDisplay5gList_returnTrue() { public void updateState_5gWorldPhone_GlobalHasNr() {
long testBitmask = TelephonyManager.NETWORK_TYPE_BITMASK_NR mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA);
| TelephonyManager.NETWORK_TYPE_BITMASK_LTE;
long allowedNetworkTypes = -1;
doReturn(testBitmask).when(mTelephonyManager).getSupportedRadioAccessFamily();
doReturn(allowedNetworkTypes).when(mTelephonyManager).getAllowedNetworkTypes();
mController.init(mLifecycle, SUB_ID); 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 @Test
public void checkSupportedRadioBitmask_nrBitmask_returnTrue() { public void updateState_selectedOn5gItem() {
long testBitmask = TelephonyManager.NETWORK_TYPE_BITMASK_NR mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA);
| TelephonyManager.NETWORK_TYPE_BITMASK_LTE; 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, mController.updateState(mPreference);
TelephonyManager.NETWORK_TYPE_BITMASK_NR)).isTrue();
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 @Test
public void updateState_updateByNetworkMode() { public void updateState_updateByNetworkMode() {
long allowedNetworkTypes = -1; mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA);
doReturn(allowedNetworkTypes).when(mTelephonyManager).getAllowedNetworkTypes();
Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA); TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA);
@@ -187,8 +268,7 @@ public class EnabledNetworkModePreferenceControllerTest {
@Test @Test
public void updateState_updateByNetworkMode_useDefaultValue() { public void updateState_updateByNetworkMode_useDefaultValue() {
long allowedNetworkTypes = -1; mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
doReturn(allowedNetworkTypes).when(mTelephonyManager).getAllowedNetworkTypes();
Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA); TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
@@ -199,208 +279,13 @@ public class EnabledNetworkModePreferenceControllerTest {
String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); 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 @Test
public void onPreferenceChange_updateSuccess() { public void onPreferenceChange_updateSuccess() {
mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
doReturn(true).when(mTelephonyManager).setPreferredNetworkTypeBitmask( doReturn(true).when(mTelephonyManager).setPreferredNetworkTypeBitmask(
getRafFromNetworkType(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); getRafFromNetworkType(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
mController.updateState(mPreference);
mController.onPreferenceChange(mPreference, mController.onPreferenceChange(mPreference,
String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
@@ -410,9 +295,11 @@ public class EnabledNetworkModePreferenceControllerTest {
@Test @Test
public void onPreferenceChange_updateFail() { public void onPreferenceChange_updateFail() {
mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
doReturn(false).when(mTelephonyManager).setPreferredNetworkTypeBitmask( doReturn(false).when(mTelephonyManager).setPreferredNetworkTypeBitmask(
getRafFromNetworkType(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); getRafFromNetworkType(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
mController.updateState(mPreference);
mController.onPreferenceChange(mPreference, mController.onPreferenceChange(mPreference,
String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA)); String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
@@ -423,8 +310,7 @@ public class EnabledNetworkModePreferenceControllerTest {
@Test @Test
public void preferredNetworkModeNotification_preferenceUpdates() { public void preferredNetworkModeNotification_preferenceUpdates() {
PreferenceScreen screen = mock(PreferenceScreen.class); PreferenceScreen screen = mock(PreferenceScreen.class);
long allowedNetworkTypes = -1; mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA);
doReturn(allowedNetworkTypes).when(mTelephonyManager).getAllowedNetworkTypes();
doReturn(mPreference).when(screen).findPreference(KEY); doReturn(mPreference).when(screen).findPreference(KEY);
Settings.Global.putInt(mContext.getContentResolver(), Settings.Global.putInt(mContext.getContentResolver(),
Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
@@ -448,4 +334,32 @@ public class EnabledNetworkModePreferenceControllerTest {
TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY); TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY);
assertThat(mPreference.getSummary()).isEqualTo("2G"); 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();
}
} }