Merge "Refactor another network mode preference"

2018-10-19 02:00:03 +00:00
parent 0ff2f2d4d2 9132ab5533
commit c294ce437e
7 changed files with 508 additions and 390 deletions
--- a/res/values/config.xml
+++ b/res/values/config.xml
@@ -143,6 +143,5 @@
    <!-- Show enabled tdscdma option for device -->
    <bool name="config_support_tdscdma" translatable="false">false</bool>
    <!-- Show enabled tdscdma option for device when connect roaming network -->
-    <string-array name="config_support_tdscdma_roaming_on_networks"
-                  translatable="false"></string-array>
+    <string-array name="config_support_tdscdma_roaming_on_networks" translatable="false"></string-array>
 </resources>
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -10261,6 +10261,8 @@

    <!-- Title for mobile data preference, to display the mobile data usage for each app. [CHAR LIMIT=NONE]-->
    <string name="mobile_data_usage_title">App data usage</string>
+    <!-- Summary to show the current network mode is invalid. [CHAR LIMIT=NONE]-->
+    <string name="mobile_network_mode_error">Invalid Network Mode <xliff:g id="networkModeId" example="0">%1$d</xliff:g>. Ignore.</string>

    <!-- Available networks screen, summary when button disallowed due to permanent automatic mode [CHAR LIMIT=NONE] -->
    <string name="manual_mode_disallowed_summary">Unavailable when connected to <xliff:g id="carrier" example="verizon">%1$s</xliff:g></string>
--- a/res/xml/network_setting_fragment.xml
+++ b/res/xml/network_setting_fragment.xml
@@ -66,7 +66,8 @@
        android:summary="@string/preferred_network_mode_summary"
        android:entries="@array/enabled_networks_choices"
        android:entryValues="@array/enabled_networks_values"
-        android:dialogTitle="@string/preferred_network_mode_dialogtitle" />
+        android:dialogTitle="@string/preferred_network_mode_dialogtitle"
+        settings:controller="com.android.settings.network.telephony.EnabledNetworkModePreferenceController"/>

    <Preference
        android:key="carrier_settings_euicc_key"
--- a/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java
+++ b/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java
@@ -0,0 +1,334 @@
+/*
+ * 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.content.res.Resources;
+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.annotation.VisibleForTesting;
+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 "Enabled network mode"
+ */
+public class EnabledNetworkModePreferenceController extends BasePreferenceController implements
+        ListPreference.OnPreferenceChangeListener {
+
+    private CarrierConfigManager mCarrierConfigManager;
+    private TelephonyManager mTelephonyManager;
+    private PersistableBundle mPersistableBundle;
+    private int mSubId;
+    private boolean mIsGlobalCdma;
+    private boolean mShow4GForLTE;
+
+    public EnabledNetworkModePreferenceController(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 = false;
+        } else {
+            visible = true;
+        }
+
+        return visible ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        super.updateState(preference);
+        final ListPreference listPreference = (ListPreference) preference;
+        final int networkMode = getPreferredNetworkMode();
+        updatePreferenceEntries(listPreference);
+        updatePreferenceValueAndSummary(listPreference, 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);
+            updatePreferenceValueAndSummary((ListPreference) preference, 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);
+        initShow4GForLTE();
+    }
+
+    @VisibleForTesting
+    void initShow4GForLTE() {
+        mShow4GForLTE = MobileNetworkUtils.isShow4GForLTE(mContext);
+    }
+
+    private int getPreferredNetworkMode() {
+        return Settings.Global.getInt(mContext.getContentResolver(),
+                Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
+                Phone.PREFERRED_NT_MODE);
+    }
+
+    private void updatePreferenceEntries(ListPreference preference) {
+        final int phoneType = mTelephonyManager.getPhoneType();
+        final Resources resources = mContext.getResources();
+        final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId);
+        if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
+            final int lteForced = android.provider.Settings.Global.getInt(
+                    mContext.getContentResolver(),
+                    android.provider.Settings.Global.LTE_SERVICE_FORCED + mSubId,
+                    0);
+            final boolean isLteOnCdma = mTelephonyManager.getLteOnCdmaMode()
+                    == PhoneConstants.LTE_ON_CDMA_TRUE;
+            final int settingsNetworkMode = android.provider.Settings.Global.getInt(
+                    mContext.getContentResolver(),
+                    android.provider.Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
+                    Phone.PREFERRED_NT_MODE);
+            if (isLteOnCdma) {
+                if (lteForced == 0) {
+                    preference.setEntries(
+                            R.array.enabled_networks_cdma_choices);
+                    preference.setEntryValues(
+                            R.array.enabled_networks_cdma_values);
+                } else {
+                    switch (settingsNetworkMode) {
+                        case TelephonyManager.NETWORK_MODE_CDMA_EVDO:
+                        case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO:
+                        case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA:
+                            preference.setEntries(
+                                    R.array.enabled_networks_cdma_no_lte_choices);
+                            preference.setEntryValues(
+                                    R.array.enabled_networks_cdma_no_lte_values);
+                            break;
+                        case TelephonyManager.NETWORK_MODE_GLOBAL:
+                        case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO:
+                        case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA:
+                        case TelephonyManager.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 == PhoneConstants.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.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL)
+                    && !resources.getBoolean(R.bool.config_enabled_lte)) {
+                preference.setEntries(R.array.enabled_networks_except_gsm_lte_choices);
+                preference.setEntryValues(R.array.enabled_networks_except_gsm_lte_values);
+            } else if (!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 (!resources.getBoolean(R.bool.config_enabled_lte)) {
+                preference.setEntries(
+                        R.array.enabled_networks_except_lte_choices);
+                preference.setEntryValues(
+                        R.array.enabled_networks_except_lte_values);
+            } else if (mIsGlobalCdma) {
+                preference.setEntries(R.array.enabled_networks_cdma_choices);
+                preference.setEntryValues(R.array.enabled_networks_cdma_values);
+            } else {
+                int select = mShow4GForLTE ? R.array.enabled_networks_4g_choices
+                        : R.array.enabled_networks_choices;
+                preference.setEntries(select);
+                preference.setEntryValues(R.array.enabled_networks_values);
+            }
+        }
+        //TODO(b/117881708): figure out what world mode is, then we can optimize code. Otherwise
+        // I prefer to keep this old code
+        if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) {
+            preference.setEntries(
+                    R.array.preferred_network_mode_choices_world_mode);
+            preference.setEntryValues(
+                    R.array.preferred_network_mode_values_world_mode);
+        }
+    }
+
+    private void updatePreferenceValueAndSummary(ListPreference preference, int networkMode) {
+        switch (networkMode) {
+            case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA:
+            case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA:
+            case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM:
+                preference.setValue(
+                        Integer.toString(TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA));
+                preference.setSummary(R.string.network_3G);
+                break;
+            case TelephonyManager.NETWORK_MODE_WCDMA_ONLY:
+            case TelephonyManager.NETWORK_MODE_GSM_UMTS:
+            case TelephonyManager.NETWORK_MODE_WCDMA_PREF:
+                if (!mIsGlobalCdma) {
+                    preference.setValue(Integer.toString(TelephonyManager.NETWORK_MODE_WCDMA_PREF));
+                    preference.setSummary(R.string.network_3G);
+                } else {
+                    preference.setValue(Integer.toString(TelephonyManager
+                            .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
+                    preference.setSummary(R.string.network_global);
+                }
+                break;
+            case TelephonyManager.NETWORK_MODE_GSM_ONLY:
+                if (!mIsGlobalCdma) {
+                    preference.setValue(
+                            Integer.toString(TelephonyManager.NETWORK_MODE_GSM_ONLY));
+                    preference.setSummary(R.string.network_2G);
+                } else {
+                    preference.setValue(
+                            Integer.toString(TelephonyManager
+                                    .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
+                    preference.setSummary(R.string.network_global);
+                }
+                break;
+            case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA:
+                if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) {
+                    preference.setSummary(
+                            R.string.preferred_network_mode_lte_gsm_umts_summary);
+                    break;
+                }
+            case TelephonyManager.NETWORK_MODE_LTE_ONLY:
+            case TelephonyManager.NETWORK_MODE_LTE_WCDMA:
+                if (!mIsGlobalCdma) {
+                    preference.setValue(
+                            Integer.toString(TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA));
+                    preference.setSummary(
+                            mShow4GForLTE ? R.string.network_4G : R.string.network_lte);
+                } else {
+                    preference.setValue(
+                            Integer.toString(TelephonyManager
+                                    .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
+                    preference.setSummary(R.string.network_global);
+                }
+                break;
+            case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO:
+                if (MobileNetworkUtils.isWorldMode(mContext, mSubId)) {
+                    preference.setSummary(
+                            R.string.preferred_network_mode_lte_cdma_summary);
+                } else {
+                    preference.setValue(
+                            Integer.toString(TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO));
+                    preference.setSummary(R.string.network_lte);
+                }
+                break;
+            case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA:
+                preference.setValue(Integer.toString(TelephonyManager
+                        .NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA));
+                preference.setSummary(R.string.network_3G);
+                break;
+            case TelephonyManager.NETWORK_MODE_CDMA_EVDO:
+            case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA:
+            case TelephonyManager.NETWORK_MODE_GLOBAL:
+                preference.setValue(
+                        Integer.toString(TelephonyManager.NETWORK_MODE_CDMA_EVDO));
+                preference.setSummary(R.string.network_3G);
+                break;
+            case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO:
+                preference.setValue(
+                        Integer.toString(TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO));
+                preference.setSummary(R.string.network_1x);
+                break;
+            case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY:
+                preference.setValue(
+                        Integer.toString(TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY));
+                preference.setSummary(R.string.network_3G);
+                break;
+            case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM:
+            case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA:
+            case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA:
+            case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA:
+            case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA:
+            case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA:
+                if (MobileNetworkUtils.isTdscdmaSupported(mContext, mSubId)) {
+                    preference.setValue(
+                            Integer.toString(TelephonyManager
+                                    .NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA));
+                    preference.setSummary(R.string.network_lte);
+                } else {
+                    preference.setValue(
+                            Integer.toString(TelephonyManager
+                                    .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
+                    if (mTelephonyManager.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA
+                            || mIsGlobalCdma
+                            || MobileNetworkUtils.isWorldMode(mContext, mSubId)) {
+                        preference.setSummary(R.string.network_global);
+                    } else {
+                        preference.setSummary(mShow4GForLTE
+                                ? R.string.network_4G : R.string.network_lte);
+                    }
+                }
+                break;
+            default:
+                preference.setSummary(
+                        mContext.getString(R.string.mobile_network_mode_error, networkMode));
+        }
+    }
+}
--- a/src/com/android/settings/network/telephony/MobileNetworkFragment.java
+++ b/src/com/android/settings/network/telephony/MobileNetworkFragment.java
@@ -29,7 +29,6 @@ import android.database.ContentObserver;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Bundle;
-import android.os.Handler;
 import android.os.Message;
 import android.os.PersistableBundle;
 import android.os.UserManager;
@@ -48,7 +47,6 @@ import android.util.Log;
 import android.view.MenuItem;

 import androidx.fragment.app.FragmentActivity;
-import androidx.preference.ListPreference;
 import androidx.preference.Preference;
 import androidx.preference.PreferenceCategory;
 import androidx.preference.PreferenceFragmentCompat;
@@ -123,7 +121,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
    private int mSubId;

    //UI objects
-    private ListPreference mButtonEnabledNetworks;
    private SwitchPreference mButton4glte;
    private Preference mLteDataServicePref;
    private Preference mEuiccSettingsPref;
@@ -140,7 +137,6 @@ public class MobileNetworkFragment extends DashboardFragment implements

    private UserManager mUm;
    private ImsManager mImsMgr;
-    private MyHandler mHandler;
    private boolean mOkClicked;

    //GsmUmts options and Cdma options
@@ -245,13 +241,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
                android.util.Log.e(LOG_TAG, "Missing SETUP_PREPAID_DATA_SERVICE_URL");
            }
            return true;
-        }  else if (preference == mButtonEnabledNetworks) {
-            int settingsNetworkMode = android.provider.Settings.Global.getInt(
-                    getContext().getContentResolver(),
-                    android.provider.Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
-                    preferredNetworkMode);
-            mButtonEnabledNetworks.setValue(Integer.toString(settingsNetworkMode));
-            return true;
        } else if (preference == mEuiccSettingsPref) {
            Intent intent = new Intent(EuiccManager.ACTION_MANAGE_EMBEDDED_SUBSCRIPTIONS);
            startActivity(intent);
@@ -306,6 +295,7 @@ public class MobileNetworkFragment extends DashboardFragment implements
        use(CarrierPreferenceController.class).init(mSubId);
        use(DataUsagePreferenceController.class).init(mSubId);
        use(PreferredNetworkModePreferenceController.class).init(mSubId);
+        use(EnabledNetworkModePreferenceController.class).init(mSubId);

        mCdmaSystemSelectPreferenceController = use(CdmaSystemSelectPreferenceController.class);
        mCdmaSystemSelectPreferenceController.init(getPreferenceManager(), mSubId);
@@ -324,7 +314,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
            return;
        }

-        mHandler = new MyHandler();
        mUm = (UserManager) context.getSystemService(Context.USER_SERVICE);
        mSubscriptionManager = SubscriptionManager.from(context);
        mTelephonyManager = (TelephonyManager) context.getSystemService(
@@ -350,8 +339,6 @@ public class MobileNetworkFragment extends DashboardFragment implements

        //get UI object references
        PreferenceScreen prefSet = getPreferenceScreen();
-        mButtonEnabledNetworks = (ListPreference) prefSet.findPreference(
-                BUTTON_ENABLED_NETWORKS_KEY);

        mLteDataServicePref = prefSet.findPreference(BUTTON_CDMA_LTE_DATA_SERVICE_KEY);

@@ -363,9 +350,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
        mActiveSubInfos = mSubscriptionManager.getActiveSubscriptionInfoList();

        updatePhone();
-        if (hasActiveSubscriptions()) {
-            updateEnabledNetworksEntries();
-        }
        Log.i(LOG_TAG, "onCreate:-");
    }

@@ -424,11 +408,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
        // preferences.
        getPreferenceScreen().setEnabled(true);

-        if (getPreferenceScreen().findPreference(BUTTON_PREFERED_NETWORK_MODE) != null
-                || getPreferenceScreen().findPreference(BUTTON_ENABLED_NETWORKS_KEY) != null)  {
-            updatePreferredNetworkUIFromDb();
-        }
-
        mTelephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);

        // NOTE: Buttons will be enabled/disabled in mPhoneStateListener
@@ -511,7 +490,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
        if (DBG) {
            log("updateBody: isLteOnCdma=" + isLteOnCdma + " phoneSubId=" + phoneSubId);
        }
-        prefSet.addPreference(mButtonEnabledNetworks);
        prefSet.addPreference(mButton4glte);

        if (MobileNetworkUtils.showEuiccSettings(getContext())) {
@@ -534,14 +512,12 @@ 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(mButtonEnabledNetworks);
            prefSet.removePreference(mLteDataServicePref);
        } else if (carrierConfig.getBoolean(CarrierConfigManager
                .KEY_HIDE_PREFERRED_NETWORK_TYPE_BOOL)
                && !mTelephonyManager.getServiceState().getRoaming()
                && mTelephonyManager.getServiceState().getDataRegState()
                == ServiceState.STATE_IN_SERVICE) {
-            prefSet.removePreference(mButtonEnabledNetworks);

            final int phoneType = mTelephonyManager.getPhoneType();
            if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
@@ -557,16 +533,11 @@ public class MobileNetworkFragment extends DashboardFragment implements
            settingsNetworkMode = preferredNetworkMode;
        } else if (carrierConfig.getBoolean(
                CarrierConfigManager.KEY_WORLD_PHONE_BOOL) == true) {
-            prefSet.removePreference(mButtonEnabledNetworks);
            // set the listener for the mButtonPreferredNetworkMode list preference so we can issue
            // change Preferred Network Mode.

            updateCdmaOptions(this, prefSet, mSubId);
            updateGsmUmtsOptions(this, prefSet, phoneSubId);
-        } else {
-            updateEnabledNetworksEntries();
-            mButtonEnabledNetworks.setOnPreferenceChangeListener(this);
-            if (DBG) log("settingsNetworkMode: " + settingsNetworkMode);
        }

        final boolean missingDataServiceUrl = TextUtils.isEmpty(
@@ -594,17 +565,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
            }
        }

-        // Get the networkMode from Settings.System and displays it
-        mButtonEnabledNetworks.setValue(Integer.toString(settingsNetworkMode));
-        UpdateEnabledNetworksValueAndSummary(settingsNetworkMode);
-        // Display preferred network type based on what modem returns b/18676277
-        new SetPreferredNetworkAsyncTask(
-                mTelephonyManager,
-                mSubId,
-                settingsNetworkMode,
-                mHandler.obtainMessage(MyHandler.MESSAGE_SET_PREFERRED_NETWORK_TYPE))
-                .executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
-
        /**
         * Enable/disable depending upon if there are any active subscriptions.
         *
@@ -665,105 +625,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
        }
    }

-    // Requires that mSubId is up to date
-    void updateEnabledNetworksEntries() {
-        final int phoneType = mTelephonyManager.getPhoneType();
-        final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId);
-        if (phoneType == PhoneConstants.PHONE_TYPE_CDMA) {
-            final int lteForced = android.provider.Settings.Global.getInt(
-                    getContext().getContentResolver(),
-                    android.provider.Settings.Global.LTE_SERVICE_FORCED + mSubId,
-                    0);
-            final boolean isLteOnCdma = mTelephonyManager.getLteOnCdmaMode()
-                    == PhoneConstants.LTE_ON_CDMA_TRUE;
-            final int settingsNetworkMode = android.provider.Settings.Global.getInt(
-                    getContext().getContentResolver(),
-                    android.provider.Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
-                    preferredNetworkMode);
-            if (isLteOnCdma) {
-                if (lteForced == 0) {
-                    mButtonEnabledNetworks.setEntries(
-                            R.array.enabled_networks_cdma_choices);
-                    mButtonEnabledNetworks.setEntryValues(
-                            R.array.enabled_networks_cdma_values);
-                } else {
-                    switch (settingsNetworkMode) {
-                        case TelephonyManager.NETWORK_MODE_CDMA_EVDO:
-                        case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO:
-                        case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA:
-                            mButtonEnabledNetworks.setEntries(
-                                    R.array.enabled_networks_cdma_no_lte_choices);
-                            mButtonEnabledNetworks.setEntryValues(
-                                    R.array.enabled_networks_cdma_no_lte_values);
-                            break;
-                        case TelephonyManager.NETWORK_MODE_GLOBAL:
-                        case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO:
-                        case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA:
-                        case TelephonyManager.NETWORK_MODE_LTE_ONLY:
-                            mButtonEnabledNetworks.setEntries(
-                                    R.array.enabled_networks_cdma_only_lte_choices);
-                            mButtonEnabledNetworks.setEntryValues(
-                                    R.array.enabled_networks_cdma_only_lte_values);
-                            break;
-                        default:
-                            mButtonEnabledNetworks.setEntries(
-                                    R.array.enabled_networks_cdma_choices);
-                            mButtonEnabledNetworks.setEntryValues(
-                                    R.array.enabled_networks_cdma_values);
-                            break;
-                    }
-                }
-            }
-            updateCdmaOptions(this, getPreferenceScreen(), mSubId);
-
-        } else if (phoneType == PhoneConstants.PHONE_TYPE_GSM) {
-            if (isSupportTdscdma()) {
-                mButtonEnabledNetworks.setEntries(
-                        R.array.enabled_networks_tdscdma_choices);
-                mButtonEnabledNetworks.setEntryValues(
-                        R.array.enabled_networks_tdscdma_values);
-            } else if (!carrierConfig.getBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL)
-                    && !getResources().getBoolean(R.bool.config_enabled_lte)) {
-                mButtonEnabledNetworks.setEntries(
-                        R.array.enabled_networks_except_gsm_lte_choices);
-                mButtonEnabledNetworks.setEntryValues(
-                        R.array.enabled_networks_except_gsm_lte_values);
-            } else if (!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;
-                mButtonEnabledNetworks.setEntries(select);
-                mButtonEnabledNetworks.setEntryValues(
-                        R.array.enabled_networks_except_gsm_values);
-            } else if (!getResources().getBoolean(R.bool.config_enabled_lte)) {
-                mButtonEnabledNetworks.setEntries(
-                        R.array.enabled_networks_except_lte_choices);
-                mButtonEnabledNetworks.setEntryValues(
-                        R.array.enabled_networks_except_lte_values);
-            } else if (mIsGlobalCdma) {
-                mButtonEnabledNetworks.setEntries(
-                        R.array.enabled_networks_cdma_choices);
-                mButtonEnabledNetworks.setEntryValues(
-                        R.array.enabled_networks_cdma_values);
-            } else {
-                int select = mShow4GForLTE ? R.array.enabled_networks_4g_choices
-                        : R.array.enabled_networks_choices;
-                mButtonEnabledNetworks.setEntries(select);
-                mButtonEnabledNetworks.setEntryValues(
-                        R.array.enabled_networks_values);
-            }
-            updateGsmUmtsOptions(this, getPreferenceScreen(), mSubId);
-        } else {
-            throw new IllegalStateException("Unexpected phone type: " + phoneType);
-        }
-        if (isWorldMode()) {
-            mButtonEnabledNetworks.setEntries(
-                    R.array.preferred_network_mode_choices_world_mode);
-            mButtonEnabledNetworks.setEntryValues(
-                    R.array.preferred_network_mode_values_world_mode);
-        }
-    }
-
    @Override
    public void onPause() {
        super.onPause();
@@ -792,59 +653,7 @@ public class MobileNetworkFragment extends DashboardFragment implements
        sendMetricsEventPreferenceChanged(getPreferenceScreen(), preference, objValue);

        final int phoneSubId = mSubId;
-        if (preference == mButtonEnabledNetworks) {
-            mButtonEnabledNetworks.setValue((String) objValue);
-            int buttonNetworkMode;
-            buttonNetworkMode = Integer.parseInt((String) objValue);
-            if (DBG) log("buttonNetworkMode: " + buttonNetworkMode);
-            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_LTE_GSM_WCDMA:
-                    case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA:
-                    case TelephonyManager.NETWORK_MODE_CDMA_EVDO:
-                    case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO:
-                    case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO:
-                    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;
-                }
-
-                UpdateEnabledNetworksValueAndSummary(buttonNetworkMode);
-
-                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 == mButton4glte) {
+        if (preference == mButton4glte) {
            boolean enhanced4gMode = !mButton4glte.isChecked();
            mButton4glte.setChecked(enhanced4gMode);
            mImsMgr.setEnhanced4gLteModeSetting(mButton4glte.isChecked());
@@ -875,189 +684,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
                CarrierConfigManager.KEY_EDITABLE_ENHANCED_4G_LTE_BOOL);
    }

-    private class MyHandler extends Handler {
-
-        static final int MESSAGE_SET_PREFERRED_NETWORK_TYPE = 0;
-
-        @Override
-        public void handleMessage(Message msg) {
-            switch (msg.what) {
-                case MESSAGE_SET_PREFERRED_NETWORK_TYPE:
-                    handleSetPreferredNetworkTypeResponse(msg);
-                    break;
-            }
-        }
-
-        private void handleSetPreferredNetworkTypeResponse(Message msg) {
-            final FragmentActivity activity = getActivity();
-            if (activity == null || activity.isDestroyed()) {
-                // Access preferences of activity only if it is not destroyed
-                // or if fragment is not attached to an activity.
-                return;
-            }
-
-            boolean success = (boolean) msg.obj;
-
-            if (success) {
-                int networkMode;
-                if (getPreferenceScreen().findPreference(BUTTON_ENABLED_NETWORKS_KEY) != null) {
-                    networkMode = Integer.parseInt(mButtonEnabledNetworks.getValue());
-                    android.provider.Settings.Global.putInt(
-                            getContext().getContentResolver(),
-                            android.provider.Settings.Global.PREFERRED_NETWORK_MODE
-                                    + mSubId,
-                            networkMode );
-                }
-            } else {
-                Log.i(LOG_TAG, "handleSetPreferredNetworkTypeResponse:" +
-                        "exception in setting network mode.");
-                updatePreferredNetworkUIFromDb();
-            }
-        }
-    }
-
-    private void updatePreferredNetworkUIFromDb() {
-        int settingsNetworkMode = android.provider.Settings.Global.getInt(
-                getContext().getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
-                preferredNetworkMode);
-
-        if (DBG) {
-            log("updatePreferredNetworkUIFromDb: settingsNetworkMode = " +
-                    settingsNetworkMode);
-        }
-
-        UpdateEnabledNetworksValueAndSummary(settingsNetworkMode);
-    }
-
-    private void UpdateEnabledNetworksValueAndSummary(int NetworkMode) {
-        switch (NetworkMode) {
-            case TelephonyManager.NETWORK_MODE_TDSCDMA_WCDMA:
-            case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA:
-            case TelephonyManager.NETWORK_MODE_TDSCDMA_GSM:
-                mButtonEnabledNetworks.setValue(
-                        Integer.toString(TelephonyManager.NETWORK_MODE_TDSCDMA_GSM_WCDMA));
-                mButtonEnabledNetworks.setSummary(R.string.network_3G);
-                break;
-            case TelephonyManager.NETWORK_MODE_WCDMA_ONLY:
-            case TelephonyManager.NETWORK_MODE_GSM_UMTS:
-            case TelephonyManager.NETWORK_MODE_WCDMA_PREF:
-                if (!mIsGlobalCdma) {
-                    mButtonEnabledNetworks.setValue(
-                            Integer.toString(TelephonyManager.NETWORK_MODE_WCDMA_PREF));
-                    mButtonEnabledNetworks.setSummary(R.string.network_3G);
-                } else {
-                    mButtonEnabledNetworks.setValue(
-                            Integer.toString(TelephonyManager
-                                    .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
-                    mButtonEnabledNetworks.setSummary(R.string.network_global);
-                }
-                break;
-            case TelephonyManager.NETWORK_MODE_GSM_ONLY:
-                if (!mIsGlobalCdma) {
-                    mButtonEnabledNetworks.setValue(
-                            Integer.toString(TelephonyManager.NETWORK_MODE_GSM_ONLY));
-                    mButtonEnabledNetworks.setSummary(R.string.network_2G);
-                } else {
-                    mButtonEnabledNetworks.setValue(
-                            Integer.toString(TelephonyManager
-                                    .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
-                    mButtonEnabledNetworks.setSummary(R.string.network_global);
-                }
-                break;
-            case TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA:
-                if (isWorldMode()) {
-                    mButtonEnabledNetworks.setSummary(
-                            R.string.preferred_network_mode_lte_gsm_umts_summary);
-                    controlCdmaOptions(false);
-                    controlGsmOptions(true);
-                    break;
-                }
-            case TelephonyManager.NETWORK_MODE_LTE_ONLY:
-            case TelephonyManager.NETWORK_MODE_LTE_WCDMA:
-                if (!mIsGlobalCdma) {
-                    mButtonEnabledNetworks.setValue(
-                            Integer.toString(TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA));
-                    mButtonEnabledNetworks.setSummary((mShow4GForLTE == true)
-                            ? R.string.network_4G : R.string.network_lte);
-                } else {
-                    mButtonEnabledNetworks.setValue(
-                            Integer.toString(TelephonyManager
-                                    .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
-                    mButtonEnabledNetworks.setSummary(R.string.network_global);
-                }
-                break;
-            case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO:
-                if (isWorldMode()) {
-                    mButtonEnabledNetworks.setSummary(
-                            R.string.preferred_network_mode_lte_cdma_summary);
-                    controlCdmaOptions(true);
-                    controlGsmOptions(false);
-                } else {
-                    mButtonEnabledNetworks.setValue(
-                            Integer.toString(TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO));
-                    mButtonEnabledNetworks.setSummary(R.string.network_lte);
-                }
-                break;
-            case TelephonyManager.NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA:
-                mButtonEnabledNetworks.setValue(
-                        Integer.toString(TelephonyManager
-                                .NETWORK_MODE_TDSCDMA_CDMA_EVDO_GSM_WCDMA));
-                mButtonEnabledNetworks.setSummary(R.string.network_3G);
-                break;
-            case TelephonyManager.NETWORK_MODE_CDMA_EVDO:
-            case TelephonyManager.NETWORK_MODE_EVDO_NO_CDMA:
-            case TelephonyManager.NETWORK_MODE_GLOBAL:
-                mButtonEnabledNetworks.setValue(
-                        Integer.toString(TelephonyManager.NETWORK_MODE_CDMA_EVDO));
-                mButtonEnabledNetworks.setSummary(R.string.network_3G);
-                break;
-            case TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO:
-                mButtonEnabledNetworks.setValue(
-                        Integer.toString(TelephonyManager.NETWORK_MODE_CDMA_NO_EVDO));
-                mButtonEnabledNetworks.setSummary(R.string.network_1x);
-                break;
-            case TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY:
-                mButtonEnabledNetworks.setValue(
-                        Integer.toString(TelephonyManager.NETWORK_MODE_TDSCDMA_ONLY));
-                mButtonEnabledNetworks.setSummary(R.string.network_3G);
-                break;
-            case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM:
-            case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA:
-            case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA:
-            case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_WCDMA:
-            case TelephonyManager.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA:
-            case TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA:
-                if (isSupportTdscdma()) {
-                    mButtonEnabledNetworks.setValue(
-                            Integer.toString(TelephonyManager
-                                    .NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA));
-                    mButtonEnabledNetworks.setSummary(R.string.network_lte);
-                } else {
-                    if (isWorldMode()) {
-                        controlCdmaOptions(true);
-                        controlGsmOptions(false);
-                    }
-                    mButtonEnabledNetworks.setValue(
-                            Integer.toString(TelephonyManager
-                                    .NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
-                    if (mTelephonyManager.getPhoneType() == PhoneConstants.PHONE_TYPE_CDMA
-                            || mIsGlobalCdma
-                            || isWorldMode()) {
-                        mButtonEnabledNetworks.setSummary(R.string.network_global);
-                    } else {
-                        mButtonEnabledNetworks.setSummary((mShow4GForLTE == true)
-                                ? R.string.network_4G : R.string.network_lte);
-                    }
-                }
-                break;
-            default:
-                String errMsg = "Invalid Network Mode (" + NetworkMode + "). Ignore.";
-                loge(errMsg);
-                mButtonEnabledNetworks.setSummary(errMsg);
-        }
-    }
-
    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        switch (requestCode) {
@@ -1192,12 +818,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
                mSubId) == TelephonyManager.CALL_STATE_IDLE
                && hasActiveSubscriptions();
        Log.i(LOG_TAG, "updatePreferredNetworkType: " + enabled);
-        // TODO: Disentangle enabled networks vs preferred network mode, it looks like
-        // both buttons are shown to the user as "Preferred network type" and the options change
-        // based on what looks like World mode.
-        if (mButtonEnabledNetworks != null) {
-            mButtonEnabledNetworks.setEnabled(enabled);
-        }
    }

    private void updateCallingCategory() {
@@ -1341,7 +961,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
        if (preference == mLteDataServicePref
                || preference == mEuiccSettingsPref
                || preference == mWiFiCallingPref
-                || preference == mButtonEnabledNetworks
                || preference == preferenceScreen.findPreference(BUTTON_CDMA_SYSTEM_SELECT_KEY)
                || preference == preferenceScreen.findPreference(BUTTON_CDMA_SUBSCRIPTION_KEY)
                || preference == preferenceScreen.findPreference(BUTTON_GSM_APN_EXPAND_KEY)
@@ -1361,8 +980,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 == mButtonEnabledNetworks
-                || preference == preferenceScreen
+        } else if (preference == preferenceScreen
                .findPreference(BUTTON_CDMA_SYSTEM_SELECT_KEY)
                || preference == preferenceScreen
                .findPreference(BUTTON_CDMA_SUBSCRIPTION_KEY)) {
@@ -1380,8 +998,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 == mButtonEnabledNetworks) {
-            return MetricsProto.MetricsEvent.ACTION_MOBILE_NETWORK_SELECT_ENABLED_NETWORK;
        } else if (preference == mEuiccSettingsPref) {
            return MetricsProto.MetricsEvent.ACTION_MOBILE_NETWORK_EUICC_SETTING;
        } else if (preference == mWiFiCallingPref) {
--- a/src/com/android/settings/network/telephony/MobileNetworkUtils.java
+++ b/src/com/android/settings/network/telephony/MobileNetworkUtils.java
@@ -318,6 +318,27 @@ public class MobileNetworkUtils {
        return worldModeOn;
    }

+    public static boolean isShow4GForLTE(Context context) {
+        //TODO(b/117882862): move this to framework
+        try {
+            Context con = context.createPackageContext("com.android.systemui", 0);
+            int id = con.getResources().getIdentifier("config_show4GForLTE",
+                    "bool", "com.android.systemui");
+             return con.getResources().getBoolean(id);
+        } catch (PackageManager.NameNotFoundException e) {
+            Log.e(TAG, "NameNotFoundException for show4GFotLTE");
+            return false;
+        }
+    }
+
+    /**
+     * Return {@code true} if Tdscdma is supported in current subscription
+     */
+    public static boolean isTdscdmaSupported(Context context, int subId) {
+        return isTdscdmaSupported(context,
+                TelephonyManager.from(context).createForSubscriptionId(subId));
+    }
+
    //TODO(b/117651939): move it to telephony
    private static boolean isTdscdmaSupported(Context context, TelephonyManager telephonyManager) {
        if (context.getResources().getBoolean(R.bool.config_support_tdscdma)) {
--- a/tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java
@@ -0,0 +1,145 @@
+/*
+ * 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.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.anyString;
+import static org.mockito.Mockito.doNothing;
+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.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 EnabledNetworkModePreferenceControllerTest {
+    private static final int SUB_ID = 2;
+
+    @Mock
+    private TelephonyManager mTelephonyManager;
+    @Mock
+    private TelephonyManager mInvalidTelephonyManager;
+    @Mock
+    private CarrierConfigManager mCarrierConfigManager;
+
+    private PersistableBundle mPersistableBundle;
+    private EnabledNetworkModePreferenceController mController;
+    private ListPreference mPreference;
+    private Context mContext;
+
+    @Before
+    public void setUp() throws Exception {
+        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);
+        doReturn(mContext).when(mContext).createPackageContext(anyString(), anyInt());
+        mPersistableBundle = new PersistableBundle();
+        doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfigForSubId(SUB_ID);
+
+        mPreference = new ListPreference(mContext);
+        mPreference.setEntries(R.array.enabled_networks_choices);
+        mPreference.setEntryValues(R.array.enabled_networks_values);
+        mController = spy(new EnabledNetworkModePreferenceController(mContext, "enabled_network"));
+        doNothing().when(mController).initShow4GForLTE();
+        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_notWorldPhone_returnAvailable() {
+        mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL,
+                false);
+        mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_PHONE_BOOL, false);
+
+        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("3G");
+    }
+
+    @Test
+    public void onPreferenceChange_updateSuccess() {
+        doReturn(true).when(mTelephonyManager).setPreferredNetworkType(SUB_ID,
+                TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA);
+
+        mController.onPreferenceChange(mPreference,
+                String.valueOf(TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA));
+
+        assertThat(Settings.Global.getInt(mContext.getContentResolver(),
+                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, 0)).isEqualTo(
+                TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA);
+    }
+
+    @Test
+    public void onPreferenceChange_updateFail() {
+        doReturn(false).when(mTelephonyManager).setPreferredNetworkType(SUB_ID,
+                TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA);
+
+        mController.onPreferenceChange(mPreference,
+                String.valueOf(TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA));
+
+        assertThat(Settings.Global.getInt(mContext.getContentResolver(),
+                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, 0)).isNotEqualTo(
+                TelephonyManager.NETWORK_MODE_LTE_GSM_WCDMA);
+    }
+
+}