Merge "Replace allowedNetworkTypes with allowedNetworkTypesForReason" am: 6775f40664

Original change: https://android-review.googlesource.com/c/platform/packages/apps/Settings/+/1614990 MUST ONLY BE SUBMITTED BY AUTOMERGER Change-Id: Ieb1dc1653e5d33d4f21760aabb203cf40adcbdba
2021-03-05 05:00:14 +00:00
parent c4f1bd9675 6775f40664
commit 29594edb70
17 changed files with 478 additions and 417 deletions
--- a/src/com/android/settings/network/AllowedNetworkTypesListener.java
+++ b/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();
+    }
+}
--- a/src/com/android/settings/network/PreferredNetworkModeContentObserver.java
+++ b/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();
-    }
-}
--- a/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceController.java
+++ b/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);
--- a/src/com/android/settings/network/telephony/Enhanced4gBasePreferenceController.java
+++ b/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;
    }

--- a/src/com/android/settings/network/telephony/MobileNetworkUtils.java
+++ b/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;
--- a/src/com/android/settings/network/telephony/NetworkPreferenceCategoryController.java
+++ b/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
--- a/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceController.java
+++ b/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) {
--- a/src/com/android/settings/network/telephony/cdma/CdmaBasePreferenceController.java
+++ b/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);
-        }
-    }
 }
--- a/src/com/android/settings/network/telephony/cdma/CdmaSystemSelectPreferenceController.java
+++ b/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);
--- a/src/com/android/settings/network/telephony/gsm/AutoSelectPreferenceController.java
+++ b/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
--- a/src/com/android/settings/network/telephony/gsm/OpenNetworkSelectPagePreferenceController.java
+++ b/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
--- a/tests/robotests/src/com/android/settings/network/telephony/PreferredNetworkModePreferenceControllerTest.java
+++ b/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));
    }
 }
--- a/tests/unit/src/com/android/settings/network/AllowedNetworkTypesListenerTest.java
+++ b/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);
+    }
+}
--- a/tests/robotests/src/com/android/settings/network/telephony/EnabledNetworkModePreferenceControllerTest.java
+++ b/tests/robotests/src/com/android/settings/network/telephony/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) {
--- a/tests/unit/src/com/android/settings/network/PreferredNetworkModeContentObserverTest.java
+++ b/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);
-    }
-}
--- a/tests/unit/src/com/android/settings/network/telephony/MobileNetworkUtilsTest.java
+++ b/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();
    }
--- a/tests/unit/src/com/android/settings/network/telephony/cdma/CdmaSystemSelectPreferenceControllerTest.java
+++ b/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);