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>
</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 -->
<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] -->
<string name="network_1x" translatable="false">1x</string>
<!-- 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] -->
<string name="label_available">Available networks</string>

778
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.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,60 +115,176 @@ 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 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<String> mEntries = new ArrayList<>();
private List<Integer> 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
}
private void updatePreferenceEntries(ListPreference preference) {
PreferenceEntriesBuilder(Context context, int subId) {
this.mContext = context;
this.mSubId = subId;
mCarrierConfigManager = mContext.getSystemService(CarrierConfigManager.class);
mTelephonyManager = mContext.getSystemService(TelephonyManager.class)
.createForSubscriptionId(mSubId);
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);
}
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 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(),
@@ -182,210 +293,207 @@ public class EnabledNetworkModePreferenceController extends
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);
enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_CDMA_CHOICES;
} 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);
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:
preference.setEntries(
R.array.enabled_networks_cdma_only_lte_choices);
preference.setEntryValues(
R.array.enabled_networks_cdma_only_lte_values);
enabledNetworkType =
EnabledNetworks.ENABLED_NETWORKS_CDMA_ONLY_LTE_CHOICES;
break;
default:
preference.setEntries(
R.array.enabled_networks_cdma_choices);
preference.setEntryValues(
R.array.enabled_networks_cdma_values);
enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_CDMA_CHOICES;
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);
enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_TDSCDMA_CHOICES;
} 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);
enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_EXCEPT_GSM_LTE_CHOICES;
} 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);
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)) {
preference.setEntries(
R.array.enabled_networks_except_lte_choices);
preference.setEntryValues(
R.array.enabled_networks_except_lte_values);
enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_EXCEPT_LTE_CHOICES;
} else if (mIsGlobalCdma) {
preference.setEntries(R.array.enabled_networks_cdma_choices);
preference.setEntryValues(R.array.enabled_networks_cdma_values);
enabledNetworkType = EnabledNetworks.ENABLED_NETWORKS_CDMA_CHOICES;
} 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);
enabledNetworkType = mShow4gForLTE ? EnabledNetworks.ENABLED_NETWORKS_4G_CHOICES
: EnabledNetworks.ENABLED_NETWORKS_CHOICES;
}
}
//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);
enabledNetworkType = EnabledNetworks.PREFERRED_NETWORK_MODE_CHOICES_WORLD_MODE;
}
if (mDisplay5gList) {
add5gListItem(preference);
}
}
@VisibleForTesting
boolean checkSupportedRadioBitmask(long supportedRadioBitmask, long targetBitmask) {
Log.d(LOG_TAG, "supportedRadioBitmask: " + supportedRadioBitmask);
if ((targetBitmask & supportedRadioBitmask) > 0) {
return true;
}
return false;
}
/***
* 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<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()]));
preference.setEntryValues(newEntryValues.toArray(new CharSequence[newEntryValues.size()]));
Log.d(LOG_TAG, "enabledNetworkType: " + enabledNetworkType);
return enabledNetworkType;
}
/**
* transform LTE network mode to 5G network mode.
* Sets the display string for the network mode choice and selects the corresponding item
*
* @param networkMode an LTE network mode without 5G.
* @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 CharSequence transformLteEntryValueTo5gEntryValue(CharSequence networkMode) {
int networkModeInt = Integer.valueOf(networkMode.toString());
return Integer.toString(addNrToLteNetworkType(networkModeInt));
}
private int addNrToLteNetworkType(int networkType) {
private static int addNrToLteNetworkType(int networkType) {
switch(networkType) {
case TelephonyManagerConstants.NETWORK_MODE_LTE_ONLY:
return TelephonyManagerConstants.NETWORK_MODE_NR_LTE;
@@ -412,152 +520,134 @@ public class EnabledNetworkModePreferenceController extends
}
}
private void setPreferenceValueAndSummary() {
setPreferenceValueAndSummary(getPreferredNetworkMode());
}
private boolean checkSupportedRadioBitmask(long supportedRadioBitmask, long targetBitmask) {
return (targetBitmask & supportedRadioBitmask) > 0;
}
/**
* 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
* Add 5G option. Only show the UI when device supported 5G and allowed 5G.
*/
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;
}
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);
} 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);
}
}
}
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)
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));
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);
mEntriesValue.add(value);
mIs5gEntryDisplayed = true;
} else {
preference.setSummary(mContext.getString(R.string.network_5G)
+ mContext.getString(R.string.network_recommended));
Log.d(LOG_TAG, "Hide 5G option. "
+ " supported5GRadioAccessFamily: " + mSupported5gRadioAccessFamily
+ " allowed5GNetworkType: " + mAllowed5gNetworkType
+ " isNRValue: " + isNRValue);
}
break;
default:
preference.setSummary(
mContext.getString(R.string.mobile_network_mode_error, networkMode));
}
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.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();
}
}