Refactor PreferredNetworkModePreference

Create preference controller for it.

Bug: 114749736
Test: RunSettingsRoboTests
Change-Id: I456b0b954f47a6fb4c03926049b0579fd6488969

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"/>
 
     <ListPreference
         android:key="enabled_networks_key"

src/com/android/settings/network/telephony/MobileNetworkFragment.java

@@ -32,10 +32,8 @@ import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
 import android.os.PersistableBundle;
-import android.os.UserHandle;
 import android.os.UserManager;
 import android.provider.SearchIndexableResource;
-import android.provider.Settings;
 import android.telecom.PhoneAccountHandle;
 import android.telecom.TelecomManager;
 import android.telephony.CarrierConfigManager;
@@ -71,12 +69,9 @@ import com.android.settings.network.telephony.cdma.CdmaSubscriptionPreferenceCon
 import com.android.settings.network.telephony.cdma.CdmaSystemSelectPreferenceController;
 import com.android.settings.search.BaseSearchIndexProvider;
 import com.android.settings.search.Indexable;
-import com.android.settingslib.RestrictedLockUtilsInternal;
-import com.android.settingslib.RestrictedSwitchPreference;
 import com.android.settingslib.search.SearchIndexable;
 
 import java.util.ArrayList;
-import java.util.Iterator;
 import java.util.List;
 
 @SearchIndexable(forTarget = SearchIndexable.ALL & ~SearchIndexable.ARC)
@@ -88,15 +83,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
     private static final boolean DBG = true;
     public static final int REQUEST_CODE_EXIT_ECM = 17;
 
-    // Number of active Subscriptions to show tabs
-    private static final int TAB_THRESHOLD = 2;
-
-    // Number of last phone number digits shown in Euicc Setting tab
-    private static final int NUM_LAST_PHONE_DIGITS = 4;
-
-    // fragment tag for roaming data dialog
-    private static final String ROAMING_TAG = "RoamingDialogFragment";
-
     //String keys for preference lookup
     private static final String BUTTON_PREFERED_NETWORK_MODE = "preferred_network_mode_key";
     private static final String BUTTON_ROAMING_KEY = "button_roaming_key";
@@ -131,27 +117,12 @@ public class MobileNetworkFragment extends DashboardFragment implements
 
     static final int preferredNetworkMode = Phone.PREFERRED_NT_MODE;
 
-    //Information about logical "up" Activity
-    private static final String UP_ACTIVITY_PACKAGE = "com.android.settings";
-    private static final String UP_ACTIVITY_CLASS =
-            "com.android.settings.Settings$WirelessSettingsActivity";
-
-    //Information that needs to save into Bundle.
-    private static final String EXPAND_ADVANCED_FIELDS = "expand_advanced_fields";
-    //Intent extra to indicate expand all fields.
-    private static final String EXPAND_EXTRA = "expandable";
-
-    private enum TabState {
-        NO_TABS, UPDATE, DO_NOTHING
-    }
-
     private SubscriptionManager mSubscriptionManager;
     private TelephonyManager mTelephonyManager;
     private CarrierConfigManager mCarrierConfigManager;
     private int mSubId;
 
     //UI objects
-    private ListPreference mButtonPreferredNetworkMode;
     private ListPreference mButtonEnabledNetworks;
     private SwitchPreference mButton4glte;
     private Preference mLteDataServicePref;
@@ -257,14 +228,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
                         REQUEST_CODE_EXIT_ECM);
             }
             return true;
-        } else if (preference == mButtonPreferredNetworkMode) {
-            //displays the value taken from the Settings.System
-            int settingsNetworkMode = android.provider.Settings.Global.getInt(
-                    getContext().getContentResolver(),
-                    android.provider.Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
-                    preferredNetworkMode);
-            mButtonPreferredNetworkMode.setValue(Integer.toString(settingsNetworkMode));
-            return true;
         } else if (preference == mLteDataServicePref) {
             String tmpl = android.provider.Settings.Global.getString(
                     getContext().getContentResolver(),
@@ -295,14 +258,9 @@ public class MobileNetworkFragment extends DashboardFragment implements
             return true;
         } else if (preference == mWiFiCallingPref || preference == mVideoCallingPref) {
             return false;
-        } else {
-            // if the button is anything but the simple toggle preference,
-            // we'll need to disable all preferences to reject all click
-            // events until the sub-activity's UI comes up.
-            getPreferenceScreen().setEnabled(false);
-            // Let the intents be launched by the Preference manager
-            return false;
         }
+
+        return true;
     }
 
     private final SubscriptionManager.OnSubscriptionsChangedListener
@@ -315,15 +273,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
         }
     };
 
-    private int getSlotIdFromIntent(Intent intent) {
-        Bundle data = intent.getExtras();
-        int subId = -1;
-        if (data != null) {
-            subId = data.getInt(Settings.EXTRA_SUB_ID, -1);
-        }
-        return SubscriptionManager.getSlotIndex(subId);
-    }
-
     private void initializeSubscriptions() {
         final FragmentActivity activity = getActivity();
         if (activity == null) {
@@ -335,39 +284,6 @@ public class MobileNetworkFragment extends DashboardFragment implements
         if (DBG) log("initializeSubscriptions:-");
     }
 
-    private TabState isUpdateTabsNeeded(List<SubscriptionInfo> 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<SubscriptionInfo> 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) {
+        if (preference == mButtonEnabledNetworks) {
-            //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) {
             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
+        } else if (preference == mButtonEnabledNetworks
-                || 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) {

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: <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;
+        }
+    }
+}

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);
+    }
+
+}