Replace allowedNetworkTypes with allowedNetworkTypesForReason

- Replace getAllowedNetworkTypes with
getallowedNetworkTypesForReason(ALLOWED_NETWORK_TYPES_REASON_CARRIER)
- Replace "Settings.Global.PREFERRED_NETWORK_MODE" with
"getAllowedNetworkTypesForReason(USER)"
- Move EnabledNetworkModePreferenceControllerTest from robotests to unit
- Replace KEY_NR_ENABLED_BOOL with KEY_CARRIER_NR_AVAILABILITY_INT
- Rename PreferredNetworkModeContentObserver to AllowedNetworkTypesListener
Bug: 161434786
Test: build pass.
(PASS)atest CdmaSystemSelectPreferenceControllerTest
(PASS)atest PreferredNetworkModePreferenceControllerTest
(PASS)atest AllowedNetworkTypesListenerTest
(PASS)atest EnabledNetworkModePreferenceControllerTest
(PASS)atest MobileNetworkUtilsTest

Change-Id: I2b981569ad11cf70a558c1952cc2e077464328d8
Merged-In: I2b981569ad11cf70a558c1952cc2e077464328d8

src/com/android/settings/network/AllowedNetworkTypesListener.java

@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2020 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;
+
+import android.content.Context;
+import android.telephony.PhoneStateListener;
+import android.telephony.TelephonyManager;
+import android.util.Log;
+
+import androidx.annotation.VisibleForTesting;
+
+import java.util.Map;
+import java.util.concurrent.Executor;
+
+
+/**
+ * {@link PhoneStateListener} to listen to Allowed Network Types changed
+ */
+public class AllowedNetworkTypesListener extends PhoneStateListener implements
+        PhoneStateListener.AllowedNetworkTypesChangedListener {
+    private static final String LOG_TAG = "NetworkModeListener";
+
+    @VisibleForTesting
+    AllowedNetworkTypesListener.OnAllowedNetworkTypesChangedListener mListener;
+    private long mAllowedNetworkType = -1;
+    private Executor mExecutor;
+
+    public AllowedNetworkTypesListener(Executor executor) {
+        super();
+        mExecutor = executor;
+    }
+
+    public void setAllowedNetworkTypesChangedListener(OnAllowedNetworkTypesChangedListener lsn) {
+        mListener = lsn;
+    }
+
+    /**
+     * Register a PhoneStateListener for Allowed Network Types changed.
+     * @param context the Context
+     * @param subId the subscription id.
+     */
+    public void register(Context context, int subId) {
+        TelephonyManager telephonyManager = context.getSystemService(
+                TelephonyManager.class).createForSubscriptionId(subId);
+        telephonyManager.registerPhoneStateListener(mExecutor, this);
+    }
+
+    /**
+     * Unregister a PhoneStateListener for Allowed Network Types changed.
+     * @param context the Context
+     * @param subId the subscription id.
+     */
+    public void unregister(Context context, int subId) {
+        TelephonyManager telephonyManager = context.getSystemService(
+                TelephonyManager.class).createForSubscriptionId(subId);
+        telephonyManager.unregisterPhoneStateListener(this);
+    }
+
+    @Override
+    public void onAllowedNetworkTypesChanged(Map<Integer, Long> allowedNetworkTypesList) {
+        long newAllowedNetworkType = allowedNetworkTypesList.get(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER);
+        if (mListener != null && mAllowedNetworkType != newAllowedNetworkType) {
+            mListener.onAllowedNetworkTypesChanged();
+            Log.d(LOG_TAG, "onAllowedNetworkChanged: " + mAllowedNetworkType);
+        }
+        mAllowedNetworkType = newAllowedNetworkType;
+    }
+
+    /**
+     * Listener for update of Preferred Network Mode change
+     */
+    public interface OnAllowedNetworkTypesChangedListener {
+        /**
+         * Notify the allowed network type changed.
+         */
+        void onAllowedNetworkTypesChanged();
+    }
+}

src/com/android/settings/network/PreferredNetworkModeContentObserver.java

@@ -1,66 +0,0 @@
-/*
- * Copyright (C) 2020 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;
-
-import android.content.Context;
-import android.database.ContentObserver;
-import android.net.Uri;
-import android.os.Handler;
-import android.provider.Settings;
-
-import androidx.annotation.VisibleForTesting;
-
-/**
- * {@link ContentObserver} to listen to Preferred Network Mode change
- */
-public class PreferredNetworkModeContentObserver extends ContentObserver {
-    @VisibleForTesting
-    OnPreferredNetworkModeChangedListener mListener;
-
-    public PreferredNetworkModeContentObserver(Handler handler) {
-        super(handler);
-    }
-
-    public void setPreferredNetworkModeChangedListener(OnPreferredNetworkModeChangedListener lsn) {
-        mListener = lsn;
-    }
-
-    @Override
-    public void onChange(boolean selfChange) {
-        super.onChange(selfChange);
-        if (mListener != null) {
-            mListener.onPreferredNetworkModeChanged();
-        }
-    }
-
-    public void register(Context context, int subId) {
-        final Uri uri = Settings.Global.getUriFor(
-                Settings.Global.PREFERRED_NETWORK_MODE + subId);
-        context.getContentResolver().registerContentObserver(uri, false, this);
-    }
-
-    public void unregister(Context context) {
-        context.getContentResolver().unregisterContentObserver(this);
-    }
-
-    /**
-     * Listener for update of Preferred Network Mode change
-     */
-    public interface OnPreferredNetworkModeChangedListener {
-        void onPreferredNetworkModeChanged();
-    }
-}

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

@@ -20,10 +20,7 @@ import static androidx.lifecycle.Lifecycle.Event.ON_START;
 import static androidx.lifecycle.Lifecycle.Event.ON_STOP;
 
 import android.content.Context;
-import android.os.Handler;
-import android.os.Looper;
 import android.os.PersistableBundle;
-import android.provider.Settings;
 import android.telephony.CarrierConfigManager;
 import android.telephony.SubscriptionManager;
 import android.telephony.TelephonyManager;
@@ -37,7 +34,7 @@ import androidx.preference.Preference;
 import androidx.preference.PreferenceScreen;
 
 import com.android.settings.R;
-import com.android.settings.network.PreferredNetworkModeContentObserver;
+import com.android.settings.network.AllowedNetworkTypesListener;
 import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants;
 
 import java.util.ArrayList;
@@ -53,7 +50,7 @@ public class EnabledNetworkModePreferenceController extends
         ListPreference.OnPreferenceChangeListener, LifecycleObserver {
 
     private static final String LOG_TAG = "EnabledNetworkMode";
-    private PreferredNetworkModeContentObserver mPreferredNetworkModeObserver;
+    private AllowedNetworkTypesListener mAllowedNetworkTypesListener;
     private Preference mPreference;
     private PreferenceScreen mPreferenceScreen;
     private TelephonyManager mTelephonyManager;
@@ -88,18 +85,18 @@ public class EnabledNetworkModePreferenceController extends
 
     @OnLifecycleEvent(ON_START)
     public void onStart() {
-        if (mPreferredNetworkModeObserver == null) {
+        if (mAllowedNetworkTypesListener == null) {
             return;
         }
-        mPreferredNetworkModeObserver.register(mContext, mSubId);
+        mAllowedNetworkTypesListener.register(mContext, mSubId);
     }
 
     @OnLifecycleEvent(ON_STOP)
     public void onStop() {
-        if (mPreferredNetworkModeObserver == null) {
+        if (mAllowedNetworkTypesListener == null) {
             return;
         }
-        mPreferredNetworkModeObserver.unregister(mContext);
+        mAllowedNetworkTypesListener.unregister(mContext, mSubId);
     }
 
     @Override
@@ -145,10 +142,10 @@ public class EnabledNetworkModePreferenceController extends
         mCarrierConfigManager = mContext.getSystemService(CarrierConfigManager.class);
         mBuilder = new PreferenceEntriesBuilder(mContext, mSubId);
 
-        if (mPreferredNetworkModeObserver == null) {
-            mPreferredNetworkModeObserver = new PreferredNetworkModeContentObserver(
-                    new Handler(Looper.getMainLooper()));
-            mPreferredNetworkModeObserver.setPreferredNetworkModeChangedListener(
+        if (mAllowedNetworkTypesListener == null) {
+            mAllowedNetworkTypesListener = new AllowedNetworkTypesListener(
+                    mContext.getMainExecutor());
+            mAllowedNetworkTypesListener.setAllowedNetworkTypesChangedListener(
                     () -> updatePreference());
         }
 
@@ -205,13 +202,12 @@ public class EnabledNetworkModePreferenceController extends
                     .createForSubscriptionId(mSubId);
 
             final PersistableBundle carrierConfig = mCarrierConfigManager.getConfigForSubId(mSubId);
-            final boolean isNrEnabledFromCarrierConfig = carrierConfig != null
-                    && carrierConfig.getBoolean(CarrierConfigManager.KEY_NR_ENABLED_BOOL);
             mAllowed5gNetworkType = checkSupportedRadioBitmask(
-                    mTelephonyManager.getAllowedNetworkTypes(),
+                    mTelephonyManager.getAllowedNetworkTypesForReason(
+                            TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_CARRIER),
                     TelephonyManager.NETWORK_TYPE_BITMASK_NR);
-            mSupported5gRadioAccessFamily = isNrEnabledFromCarrierConfig
-                    && checkSupportedRadioBitmask(mTelephonyManager.getSupportedRadioAccessFamily(),
+            mSupported5gRadioAccessFamily = checkSupportedRadioBitmask(
+                    mTelephonyManager.getSupportedRadioAccessFamily(),
                     TelephonyManager.NETWORK_TYPE_BITMASK_NR);
             mIsGlobalCdma = mTelephonyManager.isLteCdmaEvdoGsmWcdmaEnabled()
                     && carrierConfig != null
@@ -370,9 +366,9 @@ public class EnabledNetworkModePreferenceController extends
         }
 
         private int getPreferredNetworkMode() {
-            int networkMode = Settings.Global.getInt(mContext.getContentResolver(),
-                    Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
-                    TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE);
+            int networkMode = MobileNetworkUtils.getNetworkTypeFromRaf(
+                    (int) mTelephonyManager.getAllowedNetworkTypesForReason(
+                            TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER));
             if (!showNrList()) {
                 Log.d(LOG_TAG, "Network mode :" + networkMode + " reduce NR");
                 networkMode = reduceNrToLteNetworkType(networkMode);
@@ -452,7 +448,7 @@ public class EnabledNetworkModePreferenceController extends
          * Sets the display string for the network mode choice and selects the corresponding item
          *
          * @param networkMode the current network mode. The current mode might not be an option in
-         *                   the choice list. The nearest choice is selected instead
+         *                    the choice list. The nearest choice is selected instead
          */
         void setPreferenceValueAndSummary(int networkMode) {
             setSelectedEntry(networkMode);
@@ -781,7 +777,7 @@ public class EnabledNetworkModePreferenceController extends
         }
 
         private String[] getEntryValues() {
-            final Integer [] intArr = mEntriesValue.toArray(new Integer[0]);
+            final Integer[] intArr = mEntriesValue.toArray(new Integer[0]);
             return Arrays.stream(intArr)
                     .map(String::valueOf)
                     .toArray(String[]::new);

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

@@ -95,8 +95,9 @@ public class Enhanced4gBasePreferenceController extends TelephonyTogglePreferenc
 
         mShow5gLimitedDialog = carrierConfig.getBoolean(
                 CarrierConfigManager.KEY_VOLTE_5G_LIMITED_ALERT_DIALOG_BOOL);
-        mIsNrEnabledFromCarrierConfig = carrierConfig.getBoolean(
-                CarrierConfigManager.KEY_NR_ENABLED_BOOL);
+        mIsNrEnabledFromCarrierConfig = carrierConfig.getInt(
+                CarrierConfigManager.KEY_CARRIER_NR_AVAILABILITY_INT)
+                != CarrierConfigManager.CARRIER_NR_AVAILABILITY_NONE;
         return this;
     }
 

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

@@ -339,10 +339,10 @@ public class MobileNetworkUtils {
         }
 
         if (isWorldMode(context, subId)) {
-            final int settingsNetworkMode = android.provider.Settings.Global.getInt(
-                    context.getContentResolver(),
-                    android.provider.Settings.Global.PREFERRED_NETWORK_MODE + subId,
-                    TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE);
+            final int settingsNetworkMode = getNetworkTypeFromRaf(
+                    (int) telephonyManager.getAllowedNetworkTypesForReason(
+                            TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER));
+
             if (settingsNetworkMode == NETWORK_MODE_LTE_GSM_WCDMA
                     || settingsNetworkMode == NETWORK_MODE_LTE_CDMA_EVDO
                     || settingsNetworkMode == NETWORK_MODE_NR_LTE_GSM_WCDMA
@@ -368,10 +368,11 @@ public class MobileNetworkUtils {
         if (isGsmBasicOptions(context, subId)) {
             return true;
         }
-        final int networkMode = android.provider.Settings.Global.getInt(
-                context.getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + subId,
-                TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE);
+        final TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class)
+                .createForSubscriptionId(subId);
+        final int networkMode = getNetworkTypeFromRaf(
+                (int) telephonyManager.getAllowedNetworkTypesForReason(
+                        TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER));
         if (isWorldMode(context, subId)) {
             if (networkMode == NETWORK_MODE_LTE_CDMA_EVDO
                     || networkMode == NETWORK_MODE_LTE_GSM_WCDMA
@@ -435,10 +436,9 @@ public class MobileNetworkUtils {
             return false;
         }
 
-        final int networkMode = android.provider.Settings.Global.getInt(
-                context.getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + subId,
-                TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE);
+        final int networkMode = getNetworkTypeFromRaf(
+                (int) telephonyManager.getAllowedNetworkTypesForReason(
+                        TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER));
         if (networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO
                 && isWorldMode(context, subId)) {
             return false;
@@ -550,15 +550,17 @@ public class MobileNetworkUtils {
      */
     @VisibleForTesting
     static boolean shouldSpeciallyUpdateGsmCdma(Context context, int subId) {
-        final int networkMode = android.provider.Settings.Global.getInt(
-                context.getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + subId,
-                TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE);
+        final TelephonyManager telephonyManager = context.getSystemService(TelephonyManager.class)
+                .createForSubscriptionId(subId);
+        final int networkMode = getNetworkTypeFromRaf(
+                (int) telephonyManager.getAllowedNetworkTypesForReason(
+                        TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER));
         if (networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM
                 || networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA
                 || networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA
                 || networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA
-                || networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA
+                || networkMode
+                == TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA
                 || networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA) {
             if (!isTdscdmaSupported(context, subId) && isWorldMode(context, subId)) {
                 return true;

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

@@ -20,8 +20,6 @@ import static androidx.lifecycle.Lifecycle.Event.ON_START;
 import static androidx.lifecycle.Lifecycle.Event.ON_STOP;
 
 import android.content.Context;
-import android.os.Handler;
-import android.os.Looper;
 import android.telephony.SubscriptionManager;
 
 import androidx.lifecycle.Lifecycle;
@@ -29,7 +27,7 @@ import androidx.lifecycle.LifecycleObserver;
 import androidx.lifecycle.OnLifecycleEvent;
 import androidx.preference.PreferenceScreen;
 
-import com.android.settings.network.PreferredNetworkModeContentObserver;
+import com.android.settings.network.AllowedNetworkTypesListener;
 import com.android.settings.widget.PreferenceCategoryController;
 
 /**
@@ -39,15 +37,15 @@ public class NetworkPreferenceCategoryController extends PreferenceCategoryContr
         implements LifecycleObserver {
 
     private PreferenceScreen mPreferenceScreen;
-    private PreferredNetworkModeContentObserver mPreferredNetworkModeObserver;
+    private AllowedNetworkTypesListener mAllowedNetworkTypesListener;
     protected int mSubId;
 
     public NetworkPreferenceCategoryController(Context context, String key) {
         super(context, key);
         mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
-        mPreferredNetworkModeObserver = new PreferredNetworkModeContentObserver(
-                new Handler(Looper.getMainLooper()));
-        mPreferredNetworkModeObserver.setPreferredNetworkModeChangedListener(
+        mAllowedNetworkTypesListener = new AllowedNetworkTypesListener(
+                context.getMainExecutor());
+        mAllowedNetworkTypesListener.setAllowedNetworkTypesChangedListener(
                 () -> updatePreference());
     }
 
@@ -57,12 +55,12 @@ public class NetworkPreferenceCategoryController extends PreferenceCategoryContr
 
     @OnLifecycleEvent(ON_START)
     public void onStart() {
-        mPreferredNetworkModeObserver.register(mContext, mSubId);
+        mAllowedNetworkTypesListener.register(mContext, mSubId);
     }
 
     @OnLifecycleEvent(ON_STOP)
     public void onStop() {
-        mPreferredNetworkModeObserver.unregister(mContext);
+        mAllowedNetworkTypesListener.unregister(mContext, mSubId);
     }
 
     @Override

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

@@ -18,7 +18,6 @@ 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.SubscriptionManager;
 import android.telephony.TelephonyManager;
@@ -80,17 +79,13 @@ public class PreferredNetworkModePreferenceController extends TelephonyBasePrefe
     public boolean onPreferenceChange(Preference preference, Object object) {
         final int newPreferredNetworkMode = Integer.parseInt((String) object);
 
-        if (mTelephonyManager.setPreferredNetworkTypeBitmask(
-                MobileNetworkUtils.getRafFromNetworkType(newPreferredNetworkMode))) {
-            Settings.Global.putInt(mContext.getContentResolver(),
-                    Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
-                    newPreferredNetworkMode);
+        mTelephonyManager.setAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,
+                MobileNetworkUtils.getRafFromNetworkType(newPreferredNetworkMode));
+
             final ListPreference listPreference = (ListPreference) preference;
             listPreference.setSummary(getPreferredNetworkModeSummaryResId(newPreferredNetworkMode));
             return true;
-        }
-
-        return false;
     }
 
     public void init(int subId) {
@@ -104,9 +99,9 @@ public class PreferredNetworkModePreferenceController extends TelephonyBasePrefe
     }
 
     private int getPreferredNetworkMode() {
-        return Settings.Global.getInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
-                TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE);
+        return MobileNetworkUtils.getNetworkTypeFromRaf(
+                (int) mTelephonyManager.getAllowedNetworkTypesForReason(
+                        TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER));
     }
 
     private int getPreferredNetworkModeSummaryResId(int NetworkMode) {

src/com/android/settings/network/telephony/cdma/CdmaBasePreferenceController.java

@@ -17,11 +17,6 @@
 package com.android.settings.network.telephony.cdma;
 
 import android.content.Context;
-import android.database.ContentObserver;
-import android.net.Uri;
-import android.os.Handler;
-import android.os.Looper;
-import android.provider.Settings;
 import android.telephony.SubscriptionManager;
 import android.telephony.TelephonyManager;
 
@@ -29,6 +24,7 @@ import androidx.preference.Preference;
 import androidx.preference.PreferenceManager;
 import androidx.preference.PreferenceScreen;
 
+import com.android.settings.network.AllowedNetworkTypesListener;
 import com.android.settings.network.telephony.MobileNetworkUtils;
 import com.android.settings.network.telephony.TelephonyBasePreferenceController;
 import com.android.settingslib.core.lifecycle.LifecycleObserver;
@@ -44,22 +40,25 @@ public abstract class CdmaBasePreferenceController extends TelephonyBasePreferen
     protected Preference mPreference;
     protected TelephonyManager mTelephonyManager;
     protected PreferenceManager mPreferenceManager;
-    private DataContentObserver mDataContentObserver;
+    private AllowedNetworkTypesListener mAllowedNetworkTypesListener;
 
     public CdmaBasePreferenceController(Context context, String key) {
         super(context, key);
         mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
-        mDataContentObserver = new DataContentObserver(new Handler(Looper.getMainLooper()));
     }
 
     @Override
     public void onStart() {
-        mDataContentObserver.register(mContext, mSubId);
+        if (mAllowedNetworkTypesListener != null) {
+            mAllowedNetworkTypesListener.register(mContext, mSubId);
+        }
     }
 
     @Override
     public void onStop() {
-        mDataContentObserver.unRegister(mContext);
+        if (mAllowedNetworkTypesListener != null) {
+            mAllowedNetworkTypesListener.unregister(mContext, mSubId);
+        }
     }
 
     @Override
@@ -74,12 +73,25 @@ public abstract class CdmaBasePreferenceController extends TelephonyBasePreferen
         mSubId = subId;
         mTelephonyManager = mContext.getSystemService(TelephonyManager.class)
                 .createForSubscriptionId(mSubId);
+
+        if (mAllowedNetworkTypesListener == null) {
+            mAllowedNetworkTypesListener = new AllowedNetworkTypesListener(
+                    mContext.getMainExecutor());
+            mAllowedNetworkTypesListener.setAllowedNetworkTypesChangedListener(
+                    () -> updatePreference());
+        }
     }
 
     public void init(int subId) {
         init(null, subId);
     }
 
+    private void updatePreference() {
+        if (mPreference != null) {
+            updateState(mPreference);
+        }
+    }
+
     @Override
     public void displayPreference(PreferenceScreen screen) {
         super.displayPreference(screen);
@@ -88,30 +100,4 @@ public abstract class CdmaBasePreferenceController extends TelephonyBasePreferen
             ((CdmaListPreference) mPreference).setSubId(mSubId);
         }
     }
-
-    /**
-     * Listener that listens to mobile data state change.
-     */
-    public class DataContentObserver extends ContentObserver {
-
-        public DataContentObserver(Handler handler) {
-            super(handler);
-        }
-
-        @Override
-        public void onChange(boolean selfChange) {
-            super.onChange(selfChange);
-            updateState(mPreference);
-        }
-
-        public void register(Context context, int subId) {
-            final Uri uri = Settings.Global.getUriFor(
-                    Settings.Global.PREFERRED_NETWORK_MODE + subId);
-            context.getContentResolver().registerContentObserver(uri, false, this);
-        }
-
-        public void unRegister(Context context) {
-            context.getContentResolver().unregisterContentObserver(this);
-        }
-    }
 }

src/com/android/settings/network/telephony/cdma/CdmaSystemSelectPreferenceController.java

@@ -26,6 +26,8 @@ import android.telephony.TelephonyManager;
 import androidx.preference.ListPreference;
 import androidx.preference.Preference;
 
+import com.android.settings.network.telephony.MobileNetworkUtils;
+
 /**
  * Preference controller for "System Select"
  */
@@ -50,10 +52,10 @@ public class CdmaSystemSelectPreferenceController extends CdmaBasePreferenceCont
                 resetCdmaRoamingModeToDefault();
             }
         }
-        final int settingsNetworkMode = Settings.Global.getInt(
-                mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + mSubId,
-                TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE);
+
+        final int settingsNetworkMode = MobileNetworkUtils.getNetworkTypeFromRaf(
+                (int) mTelephonyManager.getAllowedNetworkTypesForReason(
+                        TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER));
         final boolean enableList = settingsNetworkMode != NETWORK_MODE_LTE_GSM_WCDMA
                 && settingsNetworkMode != NETWORK_MODE_NR_LTE_GSM_WCDMA;
         listPreference.setEnabled(enableList);

src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.java

@@ -24,6 +24,7 @@ import android.app.settings.SettingsEnums;
 import android.content.Context;
 import android.os.Bundle;
 import android.os.Handler;
+import android.os.HandlerExecutor;
 import android.os.Looper;
 import android.os.PersistableBundle;
 import android.os.SystemClock;
@@ -43,7 +44,7 @@ import androidx.preference.SwitchPreference;
 
 import com.android.settings.R;
 import com.android.settings.core.SubSettingLauncher;
-import com.android.settings.network.PreferredNetworkModeContentObserver;
+import com.android.settings.network.AllowedNetworkTypesListener;
 import com.android.settings.network.telephony.MobileNetworkUtils;
 import com.android.settings.network.telephony.NetworkSelectSettings;
 import com.android.settings.network.telephony.TelephonyTogglePreferenceController;
@@ -62,7 +63,7 @@ public class AutoSelectPreferenceController extends TelephonyTogglePreferenceCon
 
     private final Handler mUiHandler;
     private PreferenceScreen mPreferenceScreen;
-    private PreferredNetworkModeContentObserver mPreferredNetworkModeObserver;
+    private AllowedNetworkTypesListener mAllowedNetworkTypesListener;
     private TelephonyManager mTelephonyManager;
     private boolean mOnlyAutoSelectInHome;
     private List<OnNetworkSelectModeListener> mListeners;
@@ -77,8 +78,9 @@ public class AutoSelectPreferenceController extends TelephonyTogglePreferenceCon
         mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
         mListeners = new ArrayList<>();
         mUiHandler = new Handler(Looper.getMainLooper());
-        mPreferredNetworkModeObserver = new PreferredNetworkModeContentObserver(mUiHandler);
-        mPreferredNetworkModeObserver.setPreferredNetworkModeChangedListener(
+        mAllowedNetworkTypesListener = new AllowedNetworkTypesListener(
+                new HandlerExecutor(mUiHandler));
+        mAllowedNetworkTypesListener.setAllowedNetworkTypesChangedListener(
                 () -> updatePreference());
     }
 
@@ -93,12 +95,12 @@ public class AutoSelectPreferenceController extends TelephonyTogglePreferenceCon
 
     @OnLifecycleEvent(ON_START)
     public void onStart() {
-        mPreferredNetworkModeObserver.register(mContext, mSubId);
+        mAllowedNetworkTypesListener.register(mContext, mSubId);
     }
 
     @OnLifecycleEvent(ON_STOP)
     public void onStop() {
-        mPreferredNetworkModeObserver.unregister(mContext);
+        mAllowedNetworkTypesListener.unregister(mContext, mSubId);
     }
 
     @Override

src/com/android/settings/network/telephony/gsm/OpenNetworkSelectPagePreferenceController.java

@@ -22,8 +22,6 @@ import static androidx.lifecycle.Lifecycle.Event.ON_STOP;
 import android.app.settings.SettingsEnums;
 import android.content.Context;
 import android.os.Bundle;
-import android.os.Handler;
-import android.os.Looper;
 import android.provider.Settings;
 import android.telephony.ServiceState;
 import android.telephony.SubscriptionManager;
@@ -38,7 +36,7 @@ import androidx.preference.PreferenceScreen;
 
 import com.android.settings.R;
 import com.android.settings.core.SubSettingLauncher;
-import com.android.settings.network.PreferredNetworkModeContentObserver;
+import com.android.settings.network.AllowedNetworkTypesListener;
 import com.android.settings.network.telephony.MobileNetworkUtils;
 import com.android.settings.network.telephony.NetworkSelectSettings;
 import com.android.settings.network.telephony.TelephonyBasePreferenceController;
@@ -54,15 +52,15 @@ public class OpenNetworkSelectPagePreferenceController extends
     private TelephonyManager mTelephonyManager;
     private Preference mPreference;
     private PreferenceScreen mPreferenceScreen;
-    private PreferredNetworkModeContentObserver mPreferredNetworkModeObserver;
+    private AllowedNetworkTypesListener mAllowedNetworkTypesListener;
 
     public OpenNetworkSelectPagePreferenceController(Context context, String key) {
         super(context, key);
         mTelephonyManager = context.getSystemService(TelephonyManager.class);
         mSubId = SubscriptionManager.INVALID_SUBSCRIPTION_ID;
-        mPreferredNetworkModeObserver = new PreferredNetworkModeContentObserver(
-                new Handler(Looper.getMainLooper()));
-        mPreferredNetworkModeObserver.setPreferredNetworkModeChangedListener(
+        mAllowedNetworkTypesListener = new AllowedNetworkTypesListener(
+                context.getMainExecutor());
+        mAllowedNetworkTypesListener.setAllowedNetworkTypesChangedListener(
                 () -> updatePreference());
 
     }
@@ -85,12 +83,12 @@ public class OpenNetworkSelectPagePreferenceController extends
 
     @OnLifecycleEvent(ON_START)
     public void onStart() {
-        mPreferredNetworkModeObserver.register(mContext, mSubId);
+        mAllowedNetworkTypesListener.register(mContext, mSubId);
     }
 
     @OnLifecycleEvent(ON_STOP)
     public void onStop() {
-        mPreferredNetworkModeObserver.unregister(mContext);
+        mAllowedNetworkTypesListener.unregister(mContext, mSubId);
     }
 
     @Override

tests/robotests/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java

@@ -18,17 +18,20 @@ 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.android.settings.network.telephony.MobileNetworkUtils.getRafFromNetworkType;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.GSM;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.RAF_TD_SCDMA;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.WCDMA;
 
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
 import android.os.PersistableBundle;
-import android.provider.Settings;
 import android.telephony.CarrierConfigManager;
 import android.telephony.ServiceState;
 import android.telephony.SubscriptionManager;
@@ -127,9 +130,10 @@ public class PreferredNetworkModePreferenceControllerTest {
 
     @Test
     public void updateState_updateByNetworkMode() {
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA);
+        // NETWORK_MODE_TDSCDMA_GSM_WCDMA = RAF_TD_SCDMA | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (RAF_TD_SCDMA | GSM | WCDMA));
 
         mController.updateState(mPreference);
 
@@ -140,28 +144,13 @@ public class PreferredNetworkModePreferenceControllerTest {
     }
 
     @Test
-    public void onPreferenceChange_updateSuccess() {
-        doReturn(true).when(mTelephonyManager).setPreferredNetworkTypeBitmask(
-                getRafFromNetworkType(TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA));
-
+    public void onPreferenceChange_updateNetworkMode() {
         mController.onPreferenceChange(mPreference,
                 String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA));
 
-        assertThat(Settings.Global.getInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, 0)).isEqualTo(
-                TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA);
-    }
-
-    @Test
-    public void onPreferenceChange_updateFail() {
-        doReturn(false).when(mTelephonyManager).setPreferredNetworkTypeBitmask(
-                getRafFromNetworkType(TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA));
-
-        mController.onPreferenceChange(mPreference,
-                String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA));
-
-        assertThat(Settings.Global.getInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, 0)).isNotEqualTo(
-                TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA);
+        verify(mTelephonyManager, times(1)).setAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,
+                MobileNetworkUtils.getRafFromNetworkType(
+                        TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA));
     }
 }

tests/unit/src/com/android/settings/network/AllowedNetworkTypesListenerTest.java

@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2020 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;
+
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.os.HandlerExecutor;
+import android.telephony.PhoneStateListener;
+import android.telephony.RadioAccessFamily;
+import android.telephony.TelephonyManager;
+import android.test.mock.MockContentResolver;
+
+import androidx.test.annotation.UiThreadTest;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import java.util.HashMap;
+import java.util.Map;
+
+@RunWith(AndroidJUnit4.class)
+public class AllowedNetworkTypesListenerTest {
+
+    private static final int SUB_ID = 1;
+
+    private Context mContext;
+    private MockContentResolver mResolver;
+    private AllowedNetworkTypesListener mAllowedNetworkTypesListener;
+
+    @Mock
+    private AllowedNetworkTypesListener.OnAllowedNetworkTypesChangedListener mListener;
+    @Mock
+    private TelephonyManager mTelephonyManager;
+
+
+    @Before
+    @UiThreadTest
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(ApplicationProvider.getApplicationContext());
+        when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager);
+        doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID);
+
+        mAllowedNetworkTypesListener =
+                spy(new AllowedNetworkTypesListener(mContext.getMainExecutor()));
+    }
+
+    @Test
+    public void onChange_shouldCallListener() {
+        mAllowedNetworkTypesListener.mListener = mListener;
+        Map<Integer, Long> allowedNetworkTypesList = new HashMap<>();
+        long networkType = (long) RadioAccessFamily.getRafFromNetworkType(
+                TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO);
+        allowedNetworkTypesList.put(TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER,
+                networkType);
+        mAllowedNetworkTypesListener.onAllowedNetworkTypesChanged(allowedNetworkTypesList);
+
+        verify(mListener).onAllowedNetworkTypesChanged();
+    }
+
+    @Test
+    public void register_shouldRegisterContentObserver() {
+        mAllowedNetworkTypesListener.register(mContext, SUB_ID);
+
+        verify(mTelephonyManager, times(1)).registerPhoneStateListener(any(HandlerExecutor.class),
+                any(PhoneStateListener.class));
+    }
+
+    @Test
+    public void unregister_shouldUnregisterContentObserver() {
+        mAllowedNetworkTypesListener.unregister(mContext, SUB_ID);
+
+        verify(mTelephonyManager).unregisterPhoneStateListener(
+                mAllowedNetworkTypesListener);
+    }
+}

tests/unit/src/com/android/settings/network/EnabledNetworkModePreferenceControllerTest.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2018 The Android Open Source Project
+ * Copyright (C) 2021 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.
@@ -21,21 +21,23 @@ import static androidx.lifecycle.Lifecycle.Event.ON_START;
 import static com.android.settings.core.BasePreferenceController.AVAILABLE;
 import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE;
 import static com.android.settings.network.telephony.MobileNetworkUtils.getRafFromNetworkType;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.CDMA;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.EVDO;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.GSM;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.LTE;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.NR;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.RAF_TD_SCDMA;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.WCDMA;
 
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.junit.Assert.assertEquals;
-import static org.mockito.ArgumentMatchers.anyInt;
-import static org.mockito.ArgumentMatchers.anyString;
 import static org.mockito.Mockito.doReturn;
-import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
-import android.net.Uri;
 import android.os.PersistableBundle;
-import android.provider.Settings;
 import android.telephony.CarrierConfigManager;
 import android.telephony.ServiceState;
 import android.telephony.SubscriptionManager;
@@ -43,9 +45,12 @@ import android.telephony.TelephonyManager;
 
 import androidx.lifecycle.LifecycleOwner;
 import androidx.preference.ListPreference;
+import androidx.preference.PreferenceManager;
 import androidx.preference.PreferenceScreen;
+import androidx.test.annotation.UiThreadTest;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
 
-import com.android.settings.R;
 import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
@@ -54,10 +59,8 @@ import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
-import org.robolectric.RobolectricTestRunner;
-import org.robolectric.RuntimeEnvironment;
 
-@RunWith(RobolectricTestRunner.class)
+@RunWith(AndroidJUnit4.class)
 public class EnabledNetworkModePreferenceControllerTest {
     private static final int SUB_ID = 2;
     public static final String KEY = "enabled_network";
@@ -81,19 +84,21 @@ public class EnabledNetworkModePreferenceControllerTest {
     private LifecycleOwner mLifecycleOwner;
     private Lifecycle mLifecycle;
 
+    @UiThreadTest
     @Before
     public void setUp() throws Exception {
         MockitoAnnotations.initMocks(this);
         mLifecycleOwner = () -> mLifecycle;
         mLifecycle = new Lifecycle(mLifecycleOwner);
-        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);
+        mContext = spy(ApplicationProvider.getApplicationContext());
+
+        when(mContext.getSystemService(CarrierConfigManager.class)).thenReturn(
+                mCarrierConfigManager);
+        when(mContext.getSystemService(Context.TELEPHONY_SERVICE)).thenReturn(mTelephonyManager);
+        when(mContext.getSystemService(TelephonyManager.class)).thenReturn(mTelephonyManager);
         doReturn(mTelephonyManager).when(mTelephonyManager).createForSubscriptionId(SUB_ID);
         doReturn(mInvalidTelephonyManager).when(mTelephonyManager).createForSubscriptionId(
                 SubscriptionManager.INVALID_SUBSCRIPTION_ID);
-        doReturn(mContext).when(mContext).createPackageContext(anyString(), anyInt());
         doReturn(mServiceState).when(mTelephonyManager).getServiceState();
         mPersistableBundle = new PersistableBundle();
         doReturn(mPersistableBundle).when(mCarrierConfigManager).getConfig();
@@ -106,6 +111,7 @@ public class EnabledNetworkModePreferenceControllerTest {
         mPreference.setKey(mController.getPreferenceKey());
     }
 
+    @UiThreadTest
     @Test
     public void getAvailabilityStatus_hideCarrierNetworkSettings_returnUnavailable() {
         mPersistableBundle.putBoolean(
@@ -115,6 +121,7 @@ public class EnabledNetworkModePreferenceControllerTest {
         assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
     }
 
+    @UiThreadTest
     @Test
     public void getAvailabilityStatus_hidePreferredNetworkType_returnUnavailable() {
         mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_PREFERRED_NETWORK_TYPE_BOOL,
@@ -135,6 +142,7 @@ public class EnabledNetworkModePreferenceControllerTest {
         assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
     }
 
+    @UiThreadTest
     @Test
     public void getAvailabilityStatus_notWorldPhone_returnAvailable() {
         mPersistableBundle.putBoolean(CarrierConfigManager.KEY_HIDE_CARRIER_NETWORK_SETTINGS_BOOL,
@@ -144,6 +152,7 @@ public class EnabledNetworkModePreferenceControllerTest {
         assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
     }
 
+    @UiThreadTest
     @Test
     public void updateState_LteWorldPhone_GlobalHasLte() {
         mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
@@ -155,9 +164,10 @@ public class EnabledNetworkModePreferenceControllerTest {
                 .contains(String.valueOf(TelephonyManager.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void updateState_5gWorldPhone_GlobalHasNr() {
-        mPersistableBundle.putBoolean(CarrierConfigManager.KEY_NR_ENABLED_BOOL, true);
+        mockAllowedNetworkTypes(ALLOWED_ALL_NETWORK_TYPE);
         mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA);
         mController.init(mLifecycle, SUB_ID);
         mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
@@ -169,15 +179,18 @@ public class EnabledNetworkModePreferenceControllerTest {
                 .contains(String.valueOf(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void updateState_selectedOn5gItem() {
-        mPersistableBundle.putBoolean(CarrierConfigManager.KEY_NR_ENABLED_BOOL, true);
+        mockAllowedNetworkTypes(ALLOWED_ALL_NETWORK_TYPE);
         mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA);
         mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA);
         mController.init(mLifecycle, SUB_ID);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA);
+
+        // NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA = NR | LTE | RAF_TD_SCDMA | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (NR | LTE | RAF_TD_SCDMA | GSM | WCDMA));
 
         mController.updateState(mPreference);
 
@@ -186,16 +199,18 @@ public class EnabledNetworkModePreferenceControllerTest {
                         TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void updateState_disAllowed5g_5gOptionHidden() {
         mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA);
         mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA);
         mockAllowedNetworkTypes(DISABLED_5G_NETWORK_TYPE);
         mController.init(mLifecycle, SUB_ID);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA);
 
+        // NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA = NR | LTE | RAF_TD_SCDMA | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (NR | LTE | RAF_TD_SCDMA | GSM | WCDMA));
         mController.updateState(mPreference);
 
         assertThat(mPreference.getEntryValues())
@@ -204,16 +219,18 @@ public class EnabledNetworkModePreferenceControllerTest {
                         String.valueOf(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void updateState_disAllowed5g_selectOn4gOption() {
         mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA);
         mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA);
         mockAllowedNetworkTypes(DISABLED_5G_NETWORK_TYPE);
         mController.init(mLifecycle, SUB_ID);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA);
 
+        // NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA = NR | LTE | RAF_TD_SCDMA | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (NR | LTE | RAF_TD_SCDMA | GSM | WCDMA));
         mController.updateState(mPreference);
 
         assertThat(mPreference.getValue()).isEqualTo(
@@ -221,38 +238,43 @@ public class EnabledNetworkModePreferenceControllerTest {
                         TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void updateState_NrEnableBoolFalse_5gOptionHidden() {
         mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_NR_LTE_GSM_WCDMA);
         mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA);
-        mPersistableBundle.putBoolean(CarrierConfigManager.KEY_NR_ENABLED_BOOL, false);
+        mockAllowedNetworkTypes(DISABLED_5G_NETWORK_TYPE);
 
         mController.init(mLifecycle, SUB_ID);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_NR_LTE_GSM_WCDMA);
+
+        // NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA = LTE | CDMA | EVDO | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (LTE | CDMA | EVDO | GSM | WCDMA));
 
         mController.updateState(mPreference);
 
         assertThat(mPreference.getValue()).isEqualTo(
                 String.valueOf(
-                        TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
+                        TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
         assertThat(mPreference.getEntryValues())
                 .asList()
                 .doesNotContain(
                         String.valueOf(TelephonyManager.NETWORK_MODE_NR_LTE_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void updateState_GlobalDisAllowed5g_GlobalWithoutNR() {
         mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA);
         mockAllowedNetworkTypes(DISABLED_5G_NETWORK_TYPE);
         mController.init(mLifecycle, SUB_ID);
         mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA);
 
+        // NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA = NR | LTE | CDMA | EVDO | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (NR | LTE | CDMA | EVDO | GSM | WCDMA));
         mController.updateState(mPreference);
 
         assertThat(mPreference.getEntryValues())
@@ -261,16 +283,18 @@ public class EnabledNetworkModePreferenceControllerTest {
                         String.valueOf(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void updateState_GlobalDisAllowed5g_SelectOnGlobal() {
         mockAccessFamily(TelephonyManager.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA);
         mockAllowedNetworkTypes(DISABLED_5G_NETWORK_TYPE);
         mController.init(mLifecycle, SUB_ID);
         mPersistableBundle.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA);
 
+        // NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA = NR | LTE | CDMA | EVDO | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (NR | LTE | CDMA | EVDO | GSM | WCDMA));
         mController.updateState(mPreference);
 
         assertThat(mPreference.getValue()).isEqualTo(
@@ -278,13 +302,15 @@ public class EnabledNetworkModePreferenceControllerTest {
                         TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void updateState_updateByNetworkMode() {
         mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA);
 
+        // NETWORK_MODE_TDSCDMA_GSM_WCDMA = RAF_TD_SCDMA | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (RAF_TD_SCDMA | GSM | WCDMA));
         mController.updateState(mPreference);
 
         assertThat(mPreference.getValue()).isEqualTo(
@@ -292,33 +318,38 @@ public class EnabledNetworkModePreferenceControllerTest {
         assertThat(mPreference.getSummary()).isEqualTo("3G");
     }
 
+    @UiThreadTest
     @Test
     public void updateState_updateByNetworkMode_useDefaultValue() {
         mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
 
+        // NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA = LTE | CDMA | EVDO | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (LTE | CDMA | EVDO | GSM | WCDMA));
         mController.updateState(mPreference);
 
         assertThat(mPreference.getValue()).isEqualTo(
-                String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
+                String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void onPreferenceChange_updateSuccess() {
         mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
         doReturn(true).when(mTelephonyManager).setPreferredNetworkTypeBitmask(
-                getRafFromNetworkType(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
+                getRafFromNetworkType(
+                        TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
 
         mController.updateState(mPreference);
         mController.onPreferenceChange(mPreference,
-                String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
+                String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
 
         assertThat(mPreference.getValue()).isEqualTo(
-                String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
+                String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void onPreferenceChange_updateFail() {
         mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
@@ -333,14 +364,21 @@ public class EnabledNetworkModePreferenceControllerTest {
                 String.valueOf(TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA));
     }
 
+    @UiThreadTest
     @Test
     public void preferredNetworkModeNotification_preferenceUpdates() {
-        PreferenceScreen screen = mock(PreferenceScreen.class);
+
+        final PreferenceManager preferenceManager = new PreferenceManager(mContext);
+        PreferenceScreen screen = preferenceManager.createPreferenceScreen(mContext);
+        mPreference.setKey(KEY);
+        screen.addPreference(mPreference);
         mockEnabledNetworkMode(TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA);
-        doReturn(mPreference).when(screen).findPreference(KEY);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA);
+
+        // NETWORK_MODE_TDSCDMA_GSM_WCDMA = RAF_TD_SCDMA | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (RAF_TD_SCDMA | GSM | WCDMA));
+
         mController.displayPreference(screen);
         mController.updateState(mPreference);
         mLifecycle.handleLifecycleEvent(ON_START);
@@ -348,59 +386,59 @@ public class EnabledNetworkModePreferenceControllerTest {
         assertThat(Integer.parseInt(mPreference.getValue())).isEqualTo(
                 TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA);
         assertThat(mPreference.getSummary()).isEqualTo("3G");
-
-
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY);
-        final Uri uri = Settings.Global.getUriFor(Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID);
-        mContext.getContentResolver().notifyChange(uri, null);
-
-        assertThat(Integer.parseInt(mPreference.getValue())).isEqualTo(
-                TelephonyManagerConstants.NETWORK_MODE_GSM_ONLY);
-        assertThat(mPreference.getSummary()).isEqualTo("2G");
     }
 
+    @UiThreadTest
     @Test
     public void checkResource_stringArrayLength() {
-        String[] entryValues = mController.getResourcesForSubId().getStringArray(
-                R.array.enabled_networks_cdma_values);
+        int id = mController.getResourcesForSubId().getIdentifier("enabled_networks_cdma_values",
+                "array", mContext.getPackageName());
+        String[] entryValues = mController.getResourcesForSubId().getStringArray(id);
         assertEquals(4, entryValues.length);
 
-        entryValues = mController.getResourcesForSubId().getStringArray(
-                R.array.enabled_networks_cdma_no_lte_values);
+        id = mController.getResourcesForSubId().getIdentifier("enabled_networks_cdma_no_lte_values",
+                "array", mContext.getPackageName());
+        entryValues = mController.getResourcesForSubId().getStringArray(id);
         assertEquals(2, entryValues.length);
 
-        entryValues = mController.getResourcesForSubId().getStringArray(
-                R.array.enabled_networks_cdma_only_lte_values);
+        id = mController.getResourcesForSubId().getIdentifier(
+                "enabled_networks_cdma_only_lte_values", "array", mContext.getPackageName());
+        entryValues = mController.getResourcesForSubId().getStringArray(id);
         assertEquals(2, entryValues.length);
 
-        entryValues = mController.getResourcesForSubId().getStringArray(
-                R.array.enabled_networks_tdscdma_values);
+        id = mController.getResourcesForSubId().getIdentifier("enabled_networks_tdscdma_values",
+                "array", mContext.getPackageName());
+        entryValues = mController.getResourcesForSubId().getStringArray(id);
         assertEquals(3, entryValues.length);
 
-        entryValues = mController.getResourcesForSubId().getStringArray(
-                R.array.enabled_networks_except_gsm_lte_values);
+        id = mController.getResourcesForSubId().getIdentifier(
+                "enabled_networks_except_gsm_lte_values", "array", mContext.getPackageName());
+        entryValues = mController.getResourcesForSubId().getStringArray(id);
         assertEquals(1, entryValues.length);
 
-        entryValues = mController.getResourcesForSubId().getStringArray(
-                R.array.enabled_networks_except_gsm_values);
+        id = mController.getResourcesForSubId().getIdentifier("enabled_networks_except_gsm_values",
+                "array", mContext.getPackageName());
+        entryValues = mController.getResourcesForSubId().getStringArray(id);
         assertEquals(2, entryValues.length);
 
-        entryValues = mController.getResourcesForSubId().getStringArray(
-                R.array.enabled_networks_except_lte_values);
+        id = mController.getResourcesForSubId().getIdentifier("enabled_networks_except_lte_values",
+                "array", mContext.getPackageName());
+        entryValues = mController.getResourcesForSubId().getStringArray(id);
         assertEquals(2, entryValues.length);
 
-        entryValues = mController.getResourcesForSubId().getStringArray(
-                R.array.enabled_networks_values);
+        id = mController.getResourcesForSubId().getIdentifier("enabled_networks_values", "array",
+                mContext.getPackageName());
+        entryValues = mController.getResourcesForSubId().getStringArray(id);
         assertEquals(3, entryValues.length);
 
-        entryValues = mController.getResourcesForSubId().getStringArray(
-                R.array.enabled_networks_values);
+        id = mController.getResourcesForSubId().getIdentifier("enabled_networks_values", "array",
+                mContext.getPackageName());
+        entryValues = mController.getResourcesForSubId().getStringArray(id);
         assertEquals(3, entryValues.length);
 
-        entryValues = mController.getResourcesForSubId().getStringArray(
-                R.array.preferred_network_mode_values_world_mode);
+        id = mController.getResourcesForSubId().getIdentifier(
+                "preferred_network_mode_values_world_mode", "array", mContext.getPackageName());
+        entryValues = mController.getResourcesForSubId().getStringArray(id);
         assertEquals(3, entryValues.length);
     }
 
@@ -408,15 +446,17 @@ public class EnabledNetworkModePreferenceControllerTest {
         if (networkMode == TelephonyManagerConstants.NETWORK_MODE_TDSCDMA_GSM_WCDMA) {
             mockPhoneType(TelephonyManager.PHONE_TYPE_GSM);
             mPersistableBundle.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, true);
-        } else if (networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA) {
+        } else if (networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA
+                || networkMode == TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA) {
             mockPhoneType(TelephonyManager.PHONE_TYPE_GSM);
             mPersistableBundle.putBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL, true);
             mPersistableBundle.putBoolean(CarrierConfigManager.KEY_LTE_ENABLED_BOOL, true);
         } else if (networkMode == TelephonyManagerConstants.NETWORK_MODE_NR_LTE_TDSCDMA_GSM_WCDMA) {
             mockPhoneType(TelephonyManager.PHONE_TYPE_GSM);
             mPersistableBundle.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, true);
-        } else if (networkMode
-                == TelephonyManagerConstants.NETWORK_MODE_NR_LTE_GSM_WCDMA) {
+        } else if (networkMode == TelephonyManagerConstants.NETWORK_MODE_NR_LTE_GSM_WCDMA
+                || networkMode
+                == TelephonyManagerConstants.NETWORK_MODE_NR_LTE_CDMA_EVDO_GSM_WCDMA) {
             mockPhoneType(TelephonyManager.PHONE_TYPE_GSM);
             mPersistableBundle.putBoolean(CarrierConfigManager.KEY_PREFER_2G_BOOL, true);
             mPersistableBundle.putBoolean(CarrierConfigManager.KEY_LTE_ENABLED_BOOL, true);
@@ -424,7 +464,8 @@ public class EnabledNetworkModePreferenceControllerTest {
     }
 
     private void mockAllowedNetworkTypes(long allowedNetworkType) {
-        doReturn(allowedNetworkType).when(mTelephonyManager).getAllowedNetworkTypes();
+        doReturn(allowedNetworkType).when(mTelephonyManager).getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_CARRIER);
     }
 
     private void mockAccessFamily(int networkMode) {

tests/unit/src/com/android/settings/network/PreferredNetworkModeContentObserverTest.java

@@ -1,83 +0,0 @@
-/*
- * Copyright (C) 2020 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;
-
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.when;
-
-import android.content.Context;
-import android.provider.Settings;
-import android.test.mock.MockContentResolver;
-
-import androidx.test.core.app.ApplicationProvider;
-import androidx.test.ext.junit.runners.AndroidJUnit4;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-
-@RunWith(AndroidJUnit4.class)
-public class PreferredNetworkModeContentObserverTest {
-
-    private static final int SUB_ID = 1;
-
-    private Context mContext;
-    private MockContentResolver mResolver;
-    private PreferredNetworkModeContentObserver mPreferredNetworkModeContentObserver;
-
-    @Mock
-    private PreferredNetworkModeContentObserver.OnPreferredNetworkModeChangedListener mListener;
-
-
-    @Before
-    public void setUp() {
-        MockitoAnnotations.initMocks(this);
-        mContext = spy(ApplicationProvider.getApplicationContext());
-
-        mResolver = spy(new MockContentResolver(mContext));
-        when(mContext.getContentResolver()).thenReturn(mResolver);
-        mPreferredNetworkModeContentObserver =
-                spy(new PreferredNetworkModeContentObserver(null));
-    }
-
-    @Test
-    public void onChange_shouldCallListener() {
-        mPreferredNetworkModeContentObserver.mListener = mListener;
-        mPreferredNetworkModeContentObserver.onChange(true);
-
-        verify(mListener).onPreferredNetworkModeChanged();
-    }
-
-    @Test
-    public void register_shouldRegisterContentObserver() {
-        mPreferredNetworkModeContentObserver.register(mContext, SUB_ID);
-
-        verify(mResolver).registerContentObserver(
-                Settings.Global.getUriFor(Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID), false,
-                mPreferredNetworkModeContentObserver);
-    }
-
-    @Test
-    public void unregister_shouldUnregisterContentObserver() {
-        mPreferredNetworkModeContentObserver.unregister(mContext);
-
-        verify(mResolver).unregisterContentObserver(mPreferredNetworkModeContentObserver);
-    }
-}

tests/unit/src/com/android/settings/network/telephony/MobileNetworkUtilsTest.java

@@ -16,6 +16,13 @@
 
 package com.android.settings.network.telephony;
 
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.CDMA;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.EVDO;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.GSM;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.LTE;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.RAF_TD_SCDMA;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.WCDMA;
+
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.anyBoolean;
@@ -32,7 +39,6 @@ import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
 import android.os.PersistableBundle;
-import android.provider.Settings;
 import android.telecom.PhoneAccountHandle;
 import android.telephony.CarrierConfigManager;
 import android.telephony.SubscriptionInfo;
@@ -42,8 +48,6 @@ import android.telephony.TelephonyManager;
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 
-import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants;
-
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -177,10 +181,10 @@ public class MobileNetworkUtilsTest {
     public void isCdmaOptions_worldModeWithGsmWcdma_returnTrue() {
         when(mTelephonyManager.getPhoneType()).thenReturn(TelephonyManager.PHONE_TYPE_GSM);
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
-
-        Settings.Global.putInt(mContext.getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID_1,
-                TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
+        // NETWORK_MODE_LTE_GSM_WCDMA = LTE | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (LTE | GSM | WCDMA));
 
         assertThat(MobileNetworkUtils.isCdmaOptions(mContext, SUB_ID_1)).isTrue();
     }
@@ -252,9 +256,10 @@ public class MobileNetworkUtilsTest {
     public void shouldSpeciallyUpdateGsmCdma_ModeLteTdscdmaGsm_returnTrue() {
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, false);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID_1,
-                TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM);
+        // NETWORK_MODE_LTE_TDSCDMA_GSM = LTE | RAF_TD_SCDMA | GSM
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (LTE | RAF_TD_SCDMA | GSM));
 
         assertThat(MobileNetworkUtils.shouldSpeciallyUpdateGsmCdma(mContext, SUB_ID_1)).isTrue();
     }
@@ -263,9 +268,10 @@ public class MobileNetworkUtilsTest {
     public void shouldSpeciallyUpdateGsmCdma_ModeLteTdscdmaGsmWcdma_returnTrue() {
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, false);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID_1,
-                TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA);
+        // NETWORK_MODE_LTE_TDSCDMA_GSM_WCDMA = LTE | RAF_TD_SCDMA | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (LTE | RAF_TD_SCDMA | GSM | WCDMA));
 
         assertThat(MobileNetworkUtils.shouldSpeciallyUpdateGsmCdma(mContext, SUB_ID_1)).isTrue();
     }
@@ -274,9 +280,10 @@ public class MobileNetworkUtilsTest {
     public void shouldSpeciallyUpdateGsmCdma_ModeLteTdscdma_returnTrue() {
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, false);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID_1,
-                TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA);
+        // NETWORK_MODE_LTE_TDSCDMA = LTE | RAF_TD_SCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (LTE | RAF_TD_SCDMA));
 
         assertThat(MobileNetworkUtils.shouldSpeciallyUpdateGsmCdma(mContext, SUB_ID_1)).isTrue();
     }
@@ -285,9 +292,10 @@ public class MobileNetworkUtilsTest {
     public void shouldSpeciallyUpdateGsmCdma_ModeLteTdscdmaWcdma_returnTrue() {
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, false);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID_1,
-                TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_WCDMA);
+        // NETWORK_MODE_LTE_TDSCDMA_WCDMA = LTE | RAF_TD_SCDMA | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (LTE | RAF_TD_SCDMA | WCDMA));
 
         assertThat(MobileNetworkUtils.shouldSpeciallyUpdateGsmCdma(mContext, SUB_ID_1)).isTrue();
     }
@@ -296,9 +304,11 @@ public class MobileNetworkUtilsTest {
     public void shouldSpeciallyUpdateGsmCdma_ModeLteTdscdmaCdmaEvdoGsmWcdma_returnTrue() {
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, false);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID_1,
-                TelephonyManagerConstants.NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA);
+        // NETWORK_MODE_LTE_TDSCDMA_CDMA_EVDO_GSM_WCDMA
+        //     = LTE | RAF_TD_SCDMA | CDMA | EVDO | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (LTE | RAF_TD_SCDMA | CDMA | EVDO | GSM | WCDMA));
 
         assertThat(MobileNetworkUtils.shouldSpeciallyUpdateGsmCdma(mContext, SUB_ID_1)).isTrue();
     }
@@ -307,9 +317,10 @@ public class MobileNetworkUtilsTest {
     public void shouldSpeciallyUpdateGsmCdma_ModeLteCdmaEvdoGsmWcdma_returnTrue() {
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_WORLD_MODE_ENABLED_BOOL, true);
         mCarrierConfig.putBoolean(CarrierConfigManager.KEY_SUPPORT_TDSCDMA_BOOL, false);
-        Settings.Global.putInt(mContext.getContentResolver(),
-                android.provider.Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID_1,
-                TelephonyManagerConstants.NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA);
+        // NETWORK_MODE_LTE_CDMA_EVDO_GSM_WCDMA = LTE | CDMA | EVDO | GSM | WCDMA
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (LTE | CDMA | EVDO | GSM | WCDMA));
 
         assertThat(MobileNetworkUtils.shouldSpeciallyUpdateGsmCdma(mContext, SUB_ID_1)).isTrue();
     }

tests/unit/src/com/android/settings/network/telephony/cdma/CdmaSystemSelectPreferenceControllerTest.java

@@ -16,6 +16,10 @@
 
 package com.android.settings.network.telephony.cdma;
 
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.GSM;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.LTE;
+import static com.android.settings.network.telephony.TelephonyConstants.RadioAccessFamily.WCDMA;
+
 import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.anyInt;
@@ -29,11 +33,10 @@ import android.telephony.TelephonyManager;
 
 import androidx.preference.ListPreference;
 import androidx.preference.PreferenceManager;
+import androidx.test.annotation.UiThreadTest;
 import androidx.test.core.app.ApplicationProvider;
 import androidx.test.ext.junit.runners.AndroidJUnit4;
 
-import com.android.settings.network.telephony.TelephonyConstants.TelephonyManagerConstants;
-
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
@@ -54,8 +57,8 @@ public class CdmaSystemSelectPreferenceControllerTest {
     private ListPreference mPreference;
     private Context mContext;
     private int mCdmaRoamingMode;
-    private int mSettingsNetworkMode;
 
+    @UiThreadTest
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
@@ -73,20 +76,12 @@ public class CdmaSystemSelectPreferenceControllerTest {
         mCdmaRoamingMode = Settings.Global.getInt(mContext.getContentResolver(),
             Settings.Global.CDMA_ROAMING_MODE,
             TelephonyManager.CDMA_ROAMING_MODE_ANY);
-
-        mSettingsNetworkMode = Settings.Global.getInt(
-            mContext.getContentResolver(),
-            Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-            TelephonyManager.DEFAULT_PREFERRED_NETWORK_MODE);
     }
 
     @After
     public void tearDown() {
         Settings.Global.putInt(mContext.getContentResolver(),
             Settings.Global.CDMA_ROAMING_MODE, mCdmaRoamingMode);
-
-        Settings.Global.putInt(mContext.getContentResolver(),
-            Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID, mSettingsNetworkMode);
     }
 
     @Test
@@ -120,9 +115,9 @@ public class CdmaSystemSelectPreferenceControllerTest {
     public void updateState_LteGSMWcdma_disabled() {
         doReturn(TelephonyManager.CDMA_ROAMING_MODE_HOME).when(
                 mTelephonyManager).getCdmaRoamingMode();
-        Settings.Global.putInt(mContext.getContentResolver(),
-                Settings.Global.PREFERRED_NETWORK_MODE + SUB_ID,
-                TelephonyManagerConstants.NETWORK_MODE_LTE_GSM_WCDMA);
+        when(mTelephonyManager.getAllowedNetworkTypesForReason(
+                TelephonyManager.ALLOWED_NETWORK_TYPES_REASON_USER)).thenReturn(
+                (long) (LTE | GSM | WCDMA));
 
         mController.updateState(mPreference);