diff --git a/res/xml/network_setting_fragment.xml b/res/xml/network_setting_fragment.xml index 74e03ed9f15..6cfa0a3aefa 100644 --- a/res/xml/network_setting_fragment.xml +++ b/res/xml/network_setting_fragment.xml @@ -57,7 +57,8 @@ android:summary="@string/preferred_network_mode_summary" android:entries="@array/preferred_network_mode_choices" android:entryValues="@array/preferred_network_mode_values" - android:dialogTitle="@string/preferred_network_mode_dialogtitle" /> + android:dialogTitle="@string/preferred_network_mode_dialogtitle" + settings:controller="com.android.settings.network.telephony.PreferredNetworkModePreferenceController"/> newSil) { - TabState state = TabState.DO_NOTHING; - if (newSil == null) { - if (mActiveSubInfos.size() >= TAB_THRESHOLD) { - if (DBG) log("isUpdateTabsNeeded: NO_TABS, size unknown and was tabbed"); - state = TabState.NO_TABS; - } - } else if (newSil.size() < TAB_THRESHOLD && mActiveSubInfos.size() >= TAB_THRESHOLD) { - if (DBG) log("isUpdateTabsNeeded: NO_TABS, size went to small"); - state = TabState.NO_TABS; - } else if (newSil.size() >= TAB_THRESHOLD && mActiveSubInfos.size() < TAB_THRESHOLD) { - if (DBG) log("isUpdateTabsNeeded: UPDATE, size changed"); - state = TabState.UPDATE; - } else if (newSil.size() >= TAB_THRESHOLD) { - Iterator siIterator = mActiveSubInfos.iterator(); - for(SubscriptionInfo newSi : newSil) { - SubscriptionInfo curSi = siIterator.next(); - if (!newSi.getDisplayName().equals(curSi.getDisplayName())) { - if (DBG) log("isUpdateTabsNeeded: UPDATE, new name=" - + newSi.getDisplayName()); - state = TabState.UPDATE; - break; - } - } - } - if (DBG) { - Log.i(LOG_TAG, "isUpdateTabsNeeded:- " + state - + " newSil.size()=" + ((newSil != null) ? newSil.size() : 0) - + " mActiveSubInfos.size()=" + mActiveSubInfos.size()); - } - return state; - } - private void updatePhone() { if (mSubId != SubscriptionManager.INVALID_SUBSCRIPTION_ID) { mImsMgr = ImsManager.getInstance(getContext(), @@ -389,6 +305,7 @@ public class MobileNetworkFragment extends DashboardFragment implements use(CdmaApnPreferenceController.class).init(mSubId); use(CarrierPreferenceController.class).init(mSubId); use(DataUsagePreferenceController.class).init(mSubId); + use(PreferredNetworkModePreferenceController.class).init(mSubId); mCdmaSystemSelectPreferenceController = use(CdmaSystemSelectPreferenceController.class); mCdmaSystemSelectPreferenceController.init(getPreferenceManager(), mSubId); @@ -433,9 +350,6 @@ public class MobileNetworkFragment extends DashboardFragment implements //get UI object references PreferenceScreen prefSet = getPreferenceScreen(); - - mButtonPreferredNetworkMode = (ListPreference) prefSet.findPreference( - BUTTON_PREFERED_NETWORK_MODE); mButtonEnabledNetworks = (ListPreference) prefSet.findPreference( BUTTON_ENABLED_NETWORKS_KEY); @@ -597,8 +511,6 @@ public class MobileNetworkFragment extends DashboardFragment implements if (DBG) { log("updateBody: isLteOnCdma=" + isLteOnCdma + " phoneSubId=" + phoneSubId); } - - prefSet.addPreference(mButtonPreferredNetworkMode); prefSet.addPreference(mButtonEnabledNetworks); prefSet.addPreference(mButton4glte); @@ -622,7 +534,6 @@ public class MobileNetworkFragment extends DashboardFragment implements && carrierConfig.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); if (carrierConfig.getBoolean( CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL)) { - prefSet.removePreference(mButtonPreferredNetworkMode); prefSet.removePreference(mButtonEnabledNetworks); prefSet.removePreference(mLteDataServicePref); } else if (carrierConfig.getBoolean(CarrierConfigManager @@ -630,7 +541,6 @@ public class MobileNetworkFragment extends DashboardFragment implements && !mTelephonyManager.getServiceState().getRoaming() && mTelephonyManager.getServiceState().getDataRegState() == ServiceState.STATE_IN_SERVICE) { - prefSet.removePreference(mButtonPreferredNetworkMode); prefSet.removePreference(mButtonEnabledNetworks); final int phoneType = mTelephonyManager.getPhoneType(); @@ -650,12 +560,10 @@ public class MobileNetworkFragment extends DashboardFragment implements prefSet.removePreference(mButtonEnabledNetworks); // set the listener for the mButtonPreferredNetworkMode list preference so we can issue // change Preferred Network Mode. - mButtonPreferredNetworkMode.setOnPreferenceChangeListener(this); updateCdmaOptions(this, prefSet, mSubId); updateGsmUmtsOptions(this, prefSet, phoneSubId); } else { - prefSet.removePreference(mButtonPreferredNetworkMode); updateEnabledNetworksEntries(); mButtonEnabledNetworks.setOnPreferenceChangeListener(this); if (DBG) log("settingsNetworkMode: " + settingsNetworkMode); @@ -688,8 +596,6 @@ public class MobileNetworkFragment extends DashboardFragment implements // Get the networkMode from Settings.System and displays it mButtonEnabledNetworks.setValue(Integer.toString(settingsNetworkMode)); - mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); - UpdatePreferredNetworkModeSummary(settingsNetworkMode); UpdateEnabledNetworksValueAndSummary(settingsNetworkMode); // Display preferred network type based on what modem returns b/18676277 new SetPreferredNetworkAsyncTask( @@ -886,64 +792,7 @@ public class MobileNetworkFragment extends DashboardFragment implements sendMetricsEventPreferenceChanged(getPreferenceScreen(), preference, objValue); final int phoneSubId = mSubId; - if (preference == mButtonPreferredNetworkMode) { - //NOTE onPreferenceChange seems to be called even if there is no change - //Check if the button value is changed from the System.Setting - mButtonPreferredNetworkMode.setValue((String) objValue); - int buttonNetworkMode; - buttonNetworkMode = Integer.parseInt((String) objValue); - int settingsNetworkMode = android.provider.Settings.Global.getInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, - preferredNetworkMode); - if (buttonNetworkMode != settingsNetworkMode) { - int modemNetworkMode; - // if new mode is invalid ignore it - switch (buttonNetworkMode) { - case TelephonyManager.NETWORK_MODE_WCDMA_PREF: - case TelephonyManager.NETWORK_MODE_GSM_ONLY: - case TelephonyManager.NETWORK_MODE_WCDMA_ONLY: - case TelephonyManager.NETWORK_MODE_GSM_UMTS: - case TelephonyManager.NETWORK_MODE_CDMA_EVDO: - case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: - case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA: - case TelephonyManager.NETWORK_MODE_GLOBAL: - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: - case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_ONLY: - case TelephonyManager.NETWORK_MODE_LTE_WCDMA: - case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY: - case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA: - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM: - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - // This is one of the modes we recognize - modemNetworkMode = buttonNetworkMode; - break; - default: - loge("Invalid Network Mode (" +buttonNetworkMode+ ") chosen. Ignore."); - return true; - } - - android.provider.Settings.Global.putInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE + phoneSubId, - buttonNetworkMode ); - //Set the modem network mode - new SetPreferredNetworkAsyncTask( - mTelephonyManager, - mSubId, - modemNetworkMode, - mHandler.obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE)) - .executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR); - } - } else if (preference == mButtonEnabledNetworks) { + if (preference == mButtonEnabledNetworks) { mButtonEnabledNetworks.setValue((String) objValue); int buttonNetworkMode; buttonNetworkMode = Integer.parseInt((String) objValue); @@ -1051,15 +900,6 @@ public class MobileNetworkFragment extends DashboardFragment implements if (success) { int networkMode; - if (getPreferenceScreen().findPreference( - BUTTON_PREFERED_NETWORK_MODE) != null) { - networkMode = Integer.parseInt(mButtonPreferredNetworkMode.getValue()); - android.provider.Settings.Global.putInt( - getContext().getContentResolver(), - android.provider.Settings.Global.PREFERRED_NETWORK_MODE - + mSubId, - networkMode ); - } if (getPreferenceScreen().findPreference(BUTTON_ENABLED_NETWORKS_KEY) != null) { networkMode = Integer.parseInt(mButtonEnabledNetworks.getValue()); android.provider.Settings.Global.putInt( @@ -1087,126 +927,7 @@ public class MobileNetworkFragment extends DashboardFragment implements settingsNetworkMode); } - UpdatePreferredNetworkModeSummary(settingsNetworkMode); UpdateEnabledNetworksValueAndSummary(settingsNetworkMode); - // changes the mButtonPreferredNetworkMode accordingly to settingsNetworkMode - mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode)); - } - - private void UpdatePreferredNetworkModeSummary(int NetworkMode) { - switch(NetworkMode) { - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_tdscdma_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_tdscdma_gsm_summary); - break; - case TelephonyManager.NETWORK_MODE_WCDMA_PREF: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_wcdma_perf_summary); - break; - case TelephonyManager.NETWORK_MODE_GSM_ONLY: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_gsm_only_summary); - break; - case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_tdscdma_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_WCDMA_ONLY: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_wcdma_only_summary); - break; - case TelephonyManager.NETWORK_MODE_GSM_UMTS: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_CDMA_EVDO: - switch (mTelephonyManager.getLteOnCdmaMode()) { - case PhoneConstants.LTE_ON_CDMA_TRUE: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_cdma_summary); - break; - case PhoneConstants.LTE_ON_CDMA_FALSE: - default: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_cdma_evdo_summary); - break; - } - break; - case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_cdma_only_summary); - break; - case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_evdo_only_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_tdscdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_ONLY: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_tdscdma_gsm_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_tdscdma_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_cdma_evdo_summary); - break; - case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_tdscdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: - if (mTelephonyManager.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA - || mIsGlobalCdma - || isWorldMode()) { - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_global_summary); - } else { - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_summary); - } - break; - case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_GLOBAL: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_cdma_evdo_gsm_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_tdscdma_wcdma_summary); - break; - case TelephonyManager.NETWORK_MODE_LTE_WCDMA: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_lte_wcdma_summary); - break; - default: - mButtonPreferredNetworkMode.setSummary( - R.string.preferred_network_mode_global_summary); - } } private void UpdateEnabledNetworksValueAndSummary(int NetworkMode) { @@ -1477,9 +1198,6 @@ public class MobileNetworkFragment extends DashboardFragment implements if (mButtonEnabledNetworks != null) { mButtonEnabledNetworks.setEnabled(enabled); } - if (mButtonPreferredNetworkMode != null) { - mButtonPreferredNetworkMode.setEnabled(enabled); - } } private void updateCallingCategory() { @@ -1622,7 +1340,7 @@ public class MobileNetworkFragment extends DashboardFragment implements // new value in onPreferenceChange. if (preference == mLteDataServicePref || preference == mEuiccSettingsPref - || preference == mWiFiCallingPref || preference == mButtonPreferredNetworkMode + || preference == mWiFiCallingPref || preference == mButtonEnabledNetworks || preference == preferenceScreen.findPreference(BUTTON_CDMA_SYSTEM_SELECT_KEY) || preference == preferenceScreen.findPreference(BUTTON_CDMA_SUBSCRIPTION_KEY) @@ -1643,8 +1361,7 @@ public class MobileNetworkFragment extends DashboardFragment implements // MetricsEvent logging with new value, for SwitchPreferences and ListPreferences. if (preference == mButton4glte || preference == mVideoCallingPref) { MetricsLogger.action(getContext(), category, (Boolean) newValue); - } else if (preference == mButtonPreferredNetworkMode - || preference == mButtonEnabledNetworks + } else if (preference == mButtonEnabledNetworks || preference == preferenceScreen .findPreference(BUTTON_CDMA_SYSTEM_SELECT_KEY) || preference == preferenceScreen @@ -1663,8 +1380,6 @@ public class MobileNetworkFragment extends DashboardFragment implements return MetricsProto.MetricsEvent.ACTION_MOBILE_NETWORK_SET_UP_DATA_SERVICE; } else if (preference == mButton4glte) { return MetricsProto.MetricsEvent.ACTION_MOBILE_ENHANCED_4G_LTE_MODE_TOGGLE; - } else if (preference == mButtonPreferredNetworkMode) { - return MetricsProto.MetricsEvent.ACTION_MOBILE_NETWORK_SELECT_PREFERRED_NETWORK; } else if (preference == mButtonEnabledNetworks) { return MetricsProto.MetricsEvent.ACTION_MOBILE_NETWORK_SELECT_ENABLED_NETWORK; } else if (preference == mEuiccSettingsPref) { diff --git a/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java b/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java new file mode 100644 index 00000000000..f60f927a32e --- /dev/null +++ b/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java @@ -0,0 +1,183 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settings.network.telephony; + +import android.content.Context; +import android.os.PersistableBundle; +import android.provider.Settings; +import android.telephony.CarrierConfigManager; +import android.telephony.ServiceState; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.preference.ListPreference; +import androidx.preference.Preference; + +import com.android.internal.telephony.Phone; +import com.android.internal.telephony.PhoneConstants; +import com.android.settings.R; +import com.android.settings.core.BasePreferenceController; + +/** + * Preference controller for "Preferred network mode" + */ +public class PreferredNetworkModePreferenceController extends BasePreferenceController implements + ListPreference.OnPreferenceChangeListener { + + private CarrierConfigManager mCarrierConfigManager; + private TelephonyManager mTelephonyManager; + private PersistableBundle mPersistableBundle; + private int mSubId; + private boolean mIsGlobalCdma; + + public PreferredNetworkModePreferenceController(Context context, String key) { + super(context, key); + mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class); + mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID; + } + + @Override + public int getAvailabilityStatus() { + boolean visible; + if (mSubId == SubscriptionManager.INVALID_SUBSCRIPTION_ID) { + visible = false; + } else if (mPersistableBundle == null) { + visible = false; + } else if (mPersistableBundle.getBoolean( + CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL)) { + visible = false; + } else if (mPersistableBundle.getBoolean( + CarrierConfigManager.KEY_HIDE_PREFERRED_NETWORK_TYPE_BOOL) + && !mTelephonyManager.getServiceState().getRoaming() + && mTelephonyManager.getServiceState().getDataRegState() + == ServiceState.STATE_IN_SERVICE) { + visible = false; + } else if (mPersistableBundle.getBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL)) { + visible = true; + } else { + visible = false; + } + + return visible ? AVAILABLE : CONDITIONALLY_UNAVAILABLE; + } + + @Override + public void updateState(Preference preference) { + super.updateState(preference); + final ListPreference listPreference = (ListPreference) preference; + final int networkMode = getPreferredNetworkMode(); + listPreference.setValue(Integer.toString(networkMode)); + listPreference.setSummary(getPreferredNetworkModeSummaryResId(networkMode)); + } + + @Override + public boolean onPreferenceChange(Preference preference, Object object) { + final int settingsMode = Integer.parseInt((String) object); + + if (mTelephonyManager.setPreferredNetworkType(mSubId, settingsMode)) { + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + mSubId, + settingsMode); + return true; + } + + return false; + } + + public void init(int subId) { + mSubId = subId; + mPersistableBundle = mCarrierConfigManager.getConfigForSubId(mSubId); + mTelephonyManager = TelephonyManager.from(mContext).createForSubscriptionId(mSubId); + + final boolean isLteOnCdma = + mTelephonyManager.getLteOnCdmaMode() == PhoneConstants.LTE_ON_CDMA_TRUE; + mIsGlobalCdma = isLteOnCdma + && mPersistableBundle.getBoolean(CarrierConfigManager.KEY_SHOW_CDMA_CHOICES_BOOL); + } + + private int getPreferredNetworkMode() { + return Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + mSubId, + Phone.PREFERRED_NT_MODE); + } + + private int getPreferredNetworkModeSummaryResId(int NetworkMode) { + //TODO(b/114749736): refactor it to "Preferred network mode: ", instead of building + // string for each type... + switch (NetworkMode) { + case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA: + return R.string.preferred_network_mode_tdscdma_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM: + return R.string.preferred_network_mode_tdscdma_gsm_summary; + case TelephonyManager.NETWORK_MODE_WCDMA_PREF: + return R.string.preferred_network_mode_wcdma_perf_summary; + case TelephonyManager.NETWORK_MODE_GSM_ONLY: + return R.string.preferred_network_mode_gsm_only_summary; + case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA: + return R.string.preferred_network_mode_tdscdma_wcdma_summary; + case TelephonyManager.NETWORK_MODE_WCDMA_ONLY: + return R.string.preferred_network_mode_wcdma_only_summary; + case TelephonyManager.NETWORK_MODE_GSM_UMTS: + return R.string.preferred_network_mode_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_CDMA_EVDO: + switch (mTelephonyManager.getLteOnCdmaMode()) { + case PhoneConstants.LTE_ON_CDMA_TRUE: + return R.string.preferred_network_mode_cdma_summary; + default: + return R.string.preferred_network_mode_cdma_evdo_summary; + } + case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO: + return R.string.preferred_network_mode_cdma_only_summary; + case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA: + return R.string.preferred_network_mode_evdo_only_summary; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA: + return R.string.preferred_network_mode_lte_tdscdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_ONLY: + return R.string.preferred_network_mode_lte_summary; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM: + return R.string.preferred_network_mode_lte_tdscdma_gsm_summary; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA: + return R.string.preferred_network_mode_lte_tdscdma_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA: + return R.string.preferred_network_mode_lte_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO: + return R.string.preferred_network_mode_lte_cdma_evdo_summary; + case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY: + return R.string.preferred_network_mode_tdscdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: + return R.string.preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA: + if (mTelephonyManager.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA + || mIsGlobalCdma + || MobileNetworkUtils.isWorldMode(mContext, mSubId)) { + return R.string.preferred_network_mode_global_summary; + } else { + return R.string.preferred_network_mode_lte_summary; + } + case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA: + return R.string.preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_GLOBAL: + return R.string.preferred_network_mode_cdma_evdo_gsm_wcdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA: + return R.string.preferred_network_mode_lte_tdscdma_wcdma_summary; + case TelephonyManager.NETWORK_MODE_LTE_WCDMA: + return R.string.preferred_network_mode_lte_wcdma_summary; + default: + return R.string.preferred_network_mode_global_summary; + } + } +} diff --git a/tests/robotests/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java b/tests/robotests/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java new file mode 100644 index 00000000000..d11e11c185b --- /dev/null +++ b/tests/robotests/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java @@ -0,0 +1,144 @@ +/* + * Copyright (C) 2018 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.settings.network.telephony; + +import static com.android.settings.core.BasePreferenceController.AVAILABLE; +import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE; + +import static com.google.common.truth.Truth.assertThat; + +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.spy; + +import android.content.Context; +import android.os.PersistableBundle; +import android.provider.Settings; +import android.telephony.CarrierConfigManager; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; + +import androidx.fragment.app.FragmentManager; +import androidx.preference.ListPreference; + +import com.android.settings.R; +import com.android.settings.testutils.SettingsRobolectricTestRunner; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.MockitoAnnotations; +import org.robolectric.RuntimeEnvironment; + +@RunWith(SettingsRobolectricTestRunner.class) +public class PreferredNetworkModePreferenceControllerTest { + private static final int SUB_ID = 2; + + @Mock + private FragmentManager mFragmentManager; + @Mock + private TelephonyManager mTelephonyManager; + @Mock + private TelephonyManager mInvalidTelephonyManager; + @Mock + private CarrierConfigManager mCarrierConfigManager; + + private PersistableBundle mPersistableBundle; + private PreferredNetworkModePreferenceController mController; + private ListPreference mPreference; + private Context mContext; + + @Before + public void setUp() { + MockitoAnnotations.initMocks(this); + + mContext = spy(RuntimeEnvironment.application); + doReturn(mTelephonyManager).when(mContext).getSystemService(Context.TELEPHONY_SERVICE); + doReturn(mTelephonyManager).when(mContext).getSystemService(TelephonyManager.class); + doReturn(mCarrierConfigManager).when(mContext).getSystemService(CarrierConfigManager.class); + doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID); + doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId( + SubscriptionManager.INVALID_SUBSCRIPTION_ID); + mPersistableBundle = new PersistableBundle(); + doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID); + + mPreference = new ListPreference(mContext); + mPreference.setEntries(R.array.preferred_network_mode_choices); + mPreference.setEntryValues(R.array.preferred_network_mode_values); + mController = new PreferredNetworkModePreferenceController(mContext, "mobile_data"); + mController.init(SUB_ID); + mPreference.setKey(mController.getPreferenceKey()); + } + + @Test + public void getAvailabilityStatus_hideCarrierNetworkSettings_returnUnavailable() { + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, + true); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE); + } + + @Test + public void getAvailabilityStatus_worldPhone_returnAvailable() { + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL, + false); + mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL, true); + + assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE); + } + + @Test + public void updateState_updateByNetworkMode() { + Settings.Global.putInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, + TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA); + + mController.updateState(mPreference); + + assertThat(mPreference.getValue()).isEqualTo( + String.valueOf(TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA)); + assertThat(mPreference.getSummary()).isEqualTo( + mContext.getString(R.string.preferred_network_mode_tdscdma_gsm_wcdma_summary)); + } + + @Test + public void onPreferenceChange_updateSuccess() { + doReturn(true).when(mTelephonyManager).setPreferredNetworkType(SUB_ID, + TelephonyManager.NETWORK_MODE_LTE_TDSCDMA); + + mController.onPreferenceChange(mPreference, + String.valueOf(TelephonyManager.NETWORK_MODE_LTE_TDSCDMA)); + + assertThat(Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, 0)).isEqualTo( + TelephonyManager.NETWORK_MODE_LTE_TDSCDMA); + } + + @Test + public void onPreferenceChange_updateFail() { + doReturn(false).when(mTelephonyManager).setPreferredNetworkType(SUB_ID, + TelephonyManager.NETWORK_MODE_LTE_TDSCDMA); + + mController.onPreferenceChange(mPreference, + String.valueOf(TelephonyManager.NETWORK_MODE_LTE_TDSCDMA)); + + assertThat(Settings.Global.getInt(mContext.getContentResolver(), + Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, 0)).isNotEqualTo( + TelephonyManager.NETWORK_MODE_LTE_TDSCDMA); + } + +}