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

Merge "Hide the 5G opiton when 5G has been disallowed" into rvc-dev

Browse Source
This commit is contained in:
Calvin Pan
2020-03-12 06:25:11 +00:00
committed by Android (Google) Code Review
parent 873b50a46a 75867d8f63
commit 59f5eb638e
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

@@ -11301,7 +11301,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();
}
} }