[Provider Model] Carrie Wi-Fi offload toggle request

- Remove the Advanced expandable list pattern and expose the items

- Add Carrie Wi-Fi offload toggle preference

- Add Carrier Wi-Fi network preference

- Do not set Carrier Network together when setting Mobile Data, if
carrner network provision enabled.

- Screenshot:
  https://screenshot.googleplex.com/8vMow53cvGfUAoj

Bug: 182324921
Test: manual test
atest -c CarrierWifiTogglePreferenceControllerTest \
         MobileDataPreferenceControllerTest \
	 WifiPickerTrackerHelperTest

Change-Id: I5a7f4cc6850fe76c0efee392c0c0c23cb41f5e1e

res/values/strings.xml

@@ -13092,6 +13092,12 @@
     <string name="to_switch_networks_disconnect_ethernet">To switch networks, disconnect ethernet</string>
     <!-- Panel subtitle for Wi-Fi turned on. [CHAR LIMIT=60] -->
     <string name="wifi_is_turned_on_subtitle">Wi\u2011Fi is turned on</string>
+    <!-- Title for merged carrier Wi-Fi offload toggle. [CHAR LIMIT=NONE] -->
+    <string name="carrier_wifi_offload_title">W+ connections</string>
+    <!-- Summary for merged carrier Wi-Fi offload toggle. [CHAR LIMIT=NONE] -->
+    <string name="carrier_wifi_offload_summary">Allow Google Fi to use W+ networks to improve speed and coverage</string>
+    <!-- Title for merged carrier Wi-Fi network information. [CHAR LIMIT=NONE] -->
+    <string name="carrier_wifi_network_title">W+ network</string>
 
     <!-- Summary text separator for preferences including a short description
          (eg. "Connected / 5G"). [CHAR LIMIT=50] -->

res/xml/mobile_network_settings.xml

@@ -16,8 +16,7 @@
 <PreferenceScreen
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:settings="http://schemas.android.com/apk/res-auto"
-    android:key="mobile_network_pref_screen"
+    android:key="mobile_network_pref_screen">
-    settings:initialExpandedChildrenCount="8">
 
     <com.android.settings.widget.SettingsMainSwitchPreference
         android:key="use_sim_switch"
@@ -78,6 +77,16 @@
             android:title="@string/billing_cycle"
             settings:controller="com.android.settings.datausage.BillingCyclePreferenceController"/>
 
+        <SwitchPreference
+            android:key="carrier_wifi_toggle"
+            android:title="@string/carrier_wifi_offload_title"
+            android:summary="@string/carrier_wifi_offload_summary"
+            settings:controller="com.android.settings.network.CarrierWifiTogglePreferenceController"/>
+
+        <Preference
+            android:key="carrier_wifi_network"
+            android:title="@string/carrier_wifi_network_title"/>
+
         <SwitchPreference
             android:key="mms_message"
             android:title="@string/mms_message_title"

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

@@ -0,0 +1,134 @@
+/*
+ * 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.
+ * 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 androidx.lifecycle.Lifecycle;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceScreen;
+
+import com.android.settings.Utils;
+import com.android.settings.core.TogglePreferenceController;
+import com.android.settings.wifi.WifiPickerTrackerHelper;
+import com.android.wifitrackerlib.WifiPickerTracker;
+
+/**
+ * Preference controller for "Carrier Wi-Fi network"
+ */
+public class CarrierWifiTogglePreferenceController extends TogglePreferenceController implements
+        WifiPickerTracker.WifiPickerTrackerCallback {
+
+    private static final String TAG = "CarrierWifiTogglePreferenceController";
+    protected static final String CARRIER_WIFI_TOGGLE_PREF_KEY = "carrier_wifi_toggle";
+    protected static final String CARRIER_WIFI_NETWORK_PREF_KEY = "carrier_wifi_network";
+
+    protected final Context mContext;
+    protected boolean mIsProviderModelEnabled;
+    protected int mSubId;
+    protected WifiPickerTrackerHelper mWifiPickerTrackerHelper;
+    protected boolean mIsCarrierProvisionWifiEnabled;
+    protected Preference mCarrierNetworkPreference;
+
+    public CarrierWifiTogglePreferenceController(Context context,
+            String preferenceKey) {
+        super(context, preferenceKey);
+        mContext = context;
+        mIsProviderModelEnabled = Utils.isProviderModelEnabled(context);
+    }
+
+    /** Initialize related properties */
+    public void init(Lifecycle lifecycle, int subId) {
+        mSubId = subId;
+        mWifiPickerTrackerHelper = new WifiPickerTrackerHelper(lifecycle, mContext, this);
+        mIsCarrierProvisionWifiEnabled =
+                mWifiPickerTrackerHelper.isCarrierNetworkProvisionEnabled(mSubId);
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        if (!mIsProviderModelEnabled) {
+            return CONDITIONALLY_UNAVAILABLE;
+        }
+        return mIsCarrierProvisionWifiEnabled ? AVAILABLE : CONDITIONALLY_UNAVAILABLE;
+    }
+
+    @Override
+    public boolean isChecked() {
+        return mWifiPickerTrackerHelper.isCarrierNetworkEnabled(mSubId);
+    }
+
+    @Override
+    public boolean setChecked(boolean isChecked) {
+        if (mWifiPickerTrackerHelper == null) {
+            return false;
+        }
+        mWifiPickerTrackerHelper.setCarrierNetworkEnabled(isChecked);
+        updateCarrierNetworkPreference(isChecked);
+        return true;
+    }
+
+    @Override
+    public void displayPreference(PreferenceScreen screen) {
+        super.displayPreference(screen);
+        mCarrierNetworkPreference = screen.findPreference(CARRIER_WIFI_NETWORK_PREF_KEY);
+        updateCarrierNetworkPreference(isChecked());
+    }
+
+    @Override
+    public void onWifiStateChanged() {
+        if (mCarrierNetworkPreference != null && mCarrierNetworkPreference.isVisible()) {
+            mCarrierNetworkPreference.setSummary(getCarrierNetworkSsid());
+        }
+    }
+
+    @Override
+    public void onWifiEntriesChanged() {
+        if (mCarrierNetworkPreference != null && mCarrierNetworkPreference.isVisible()) {
+            mCarrierNetworkPreference.setSummary(getCarrierNetworkSsid());
+        }
+    }
+
+    @Override
+    public void onNumSavedNetworksChanged() {
+        // Do nothing
+    }
+
+    @Override
+    public void onNumSavedSubscriptionsChanged() {
+        // Do nothing
+    }
+
+    protected void updateCarrierNetworkPreference(boolean isCarrierNetworkEnabled) {
+        if (mCarrierNetworkPreference == null) {
+            return;
+        }
+        if (!isCarrierNetworkEnabled || getAvailabilityStatus() != AVAILABLE) {
+            mCarrierNetworkPreference.setVisible(false);
+            return;
+        }
+        mCarrierNetworkPreference.setVisible(true);
+        mCarrierNetworkPreference.setSummary(getCarrierNetworkSsid());
+    }
+
+    protected String getCarrierNetworkSsid() {
+        if (mWifiPickerTrackerHelper == null) {
+            return null;
+        }
+        return mWifiPickerTrackerHelper.getCarrierNetworkSsid();
+    }
+}

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

@@ -131,7 +131,8 @@ public class MobileDataDialogFragment extends InstrumentedDialogFragment impleme
             case TYPE_DISABLE_DIALOG:
                 MobileNetworkUtils.setMobileDataEnabled(getContext(), mSubId, false /* enabled */,
                         false /* disableOtherSubscriptions */);
-                if (mWifiPickerTrackerHelper != null) {
+                if (mWifiPickerTrackerHelper != null
+                        && !mWifiPickerTrackerHelper.isCarrierNetworkProvisionEnabled(mSubId)) {
                     mWifiPickerTrackerHelper.setCarrierNetworkEnabled(false);
                 }
                 break;
@@ -139,7 +140,8 @@ public class MobileDataDialogFragment extends InstrumentedDialogFragment impleme
                 mSubscriptionManager.setDefaultDataSubId(mSubId);
                 MobileNetworkUtils.setMobileDataEnabled(getContext(), mSubId, true /* enabled */,
                         true /* disableOtherSubscriptions */);
-                if (mWifiPickerTrackerHelper != null) {
+                if (mWifiPickerTrackerHelper != null
+                        && !mWifiPickerTrackerHelper.isCarrierNetworkProvisionEnabled(mSubId)) {
                     mWifiPickerTrackerHelper.setCarrierNetworkEnabled(true);
                 }
                 break;

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

@@ -110,7 +110,8 @@ public class MobileDataPreferenceController extends TelephonyTogglePreferenceCon
         if (!mNeedDialog) {
             // Update data directly if we don't need dialog
             MobileNetworkUtils.setMobileDataEnabled(mContext, mSubId, isChecked, false);
-            if (mWifiPickerTrackerHelper != null) {
+            if (mWifiPickerTrackerHelper != null
+                    && !mWifiPickerTrackerHelper.isCarrierNetworkProvisionEnabled(mSubId)) {
                 mWifiPickerTrackerHelper.setCarrierNetworkEnabled(isChecked);
             }
             return true;

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

@@ -38,6 +38,7 @@ import com.android.settings.R;
 import com.android.settings.datausage.BillingCyclePreferenceController;
 import com.android.settings.datausage.DataUsageSummaryPreferenceController;
 import com.android.settings.network.ActiveSubsciptionsListener;
+import com.android.settings.network.CarrierWifiTogglePreferenceController;
 import com.android.settings.network.telephony.cdma.CdmaSubscriptionPreferenceController;
 import com.android.settings.network.telephony.cdma.CdmaSystemSelectPreferenceController;
 import com.android.settings.network.telephony.gsm.AutoSelectPreferenceController;
@@ -159,6 +160,7 @@ public class MobileNetworkSettings extends AbstractMobileNetworkSettings {
         use(EnabledNetworkModePreferenceController.class).init(getLifecycle(), mSubId);
         use(DataServiceSetupPreferenceController.class).init(mSubId);
         use(Enable2gPreferenceController.class).init(mSubId);
+        use(CarrierWifiTogglePreferenceController.class).init(getLifecycle(), mSubId);
 
         final WifiCallingPreferenceController wifiCallingPreferenceController =
                 use(WifiCallingPreferenceController.class).init(mSubId);

src/com/android/settings/wifi/WifiPickerTrackerHelper.java

@@ -17,12 +17,16 @@
 package com.android.settings.wifi;
 
 import android.content.Context;
+import android.net.wifi.WifiManager;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
+import android.os.PersistableBundle;
 import android.os.Process;
 import android.os.SimpleClock;
 import android.os.SystemClock;
+import android.telephony.CarrierConfigManager;
+import android.util.Log;
 
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
@@ -55,9 +59,12 @@ public class WifiPickerTrackerHelper implements LifecycleObserver {
         }
     };
 
-    private WifiPickerTracker mWifiPickerTracker;
+    protected WifiPickerTracker mWifiPickerTracker;
     // Worker thread used for WifiPickerTracker work
-    private HandlerThread mWorkerThread;
+    protected HandlerThread mWorkerThread;
+
+    protected final WifiManager mWifiManager;
+    protected final CarrierConfigManager mCarrierConfigManager;
 
     public WifiPickerTrackerHelper(@NonNull Lifecycle lifecycle, @NonNull Context context,
             @Nullable WifiPickerTracker.WifiPickerTrackerCallback listener) {
@@ -80,26 +87,49 @@ public class WifiPickerTrackerHelper implements LifecycleObserver {
                 SCAN_INTERVAL_MILLIS,
                 listener);
 
+        mWifiManager = context.getSystemService(WifiManager.class);
+        mCarrierConfigManager = context.getSystemService(CarrierConfigManager.class);
     }
 
+    /** @OnLifecycleEvent(ON_DESTROY) */
     @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
     public void onDestroy() {
         mWorkerThread.quit();
     }
 
+    /** Return the WifiPickerTracker class */
     public @NonNull WifiPickerTracker getWifiPickerTracker() {
         return mWifiPickerTracker;
     }
 
-    public boolean setCarrierNetworkEnabled(boolean enable) {
+    /** Return the enabled/disabled state of the carrier network provision */
-        final MergedCarrierEntry mergedCarrierEntry = mWifiPickerTracker.getMergedCarrierEntry();
+    public boolean isCarrierNetworkProvisionEnabled(int subId) {
-        if (mergedCarrierEntry == null) {
+        final PersistableBundle config = mCarrierConfigManager.getConfigForSubId(subId);
+        if (config == null) {
+            Log.e(TAG, "Could not get carrier config, subId:" + subId);
             return false;
         }
-        mergedCarrierEntry.setEnabled(enable);
+        final boolean enabled = config.getBoolean(
-        return true;
+                CarrierConfigManager.KEY_CARRIER_PROVISIONS_WIFI_MERGED_NETWORKS_BOOL);
+        Log.i(TAG, "isCarrierNetworkProvisionEnabled:" + enabled);
+        return enabled;
     }
 
+    /** Return the enabled/disabled state of the carrier network */
+    public boolean isCarrierNetworkEnabled(int subId) {
+        return mWifiManager.isCarrierNetworkOffloadEnabled(subId, true /* merged */);
+    }
+
+    /** Enables/disables the carrier network */
+    public void setCarrierNetworkEnabled(boolean enabled) {
+        final MergedCarrierEntry mergedCarrierEntry = mWifiPickerTracker.getMergedCarrierEntry();
+        if (mergedCarrierEntry == null) {
+            return;
+        }
+        mergedCarrierEntry.setEnabled(enabled);
+    }
+
+    /** Connect to the carrier network */
     public boolean connectCarrierNetwork(@Nullable WifiEntry.ConnectCallback callback) {
         final MergedCarrierEntry mergedCarrierEntry = mWifiPickerTracker.getMergedCarrierEntry();
         if (mergedCarrierEntry == null || !mergedCarrierEntry.canConnect()) {
@@ -109,6 +139,15 @@ public class WifiPickerTrackerHelper implements LifecycleObserver {
         return true;
     }
 
+    /** Return the carrier network ssid */
+    public String getCarrierNetworkSsid() {
+        final MergedCarrierEntry mergedCarrierEntry = mWifiPickerTracker.getMergedCarrierEntry();
+        if (mergedCarrierEntry == null) {
+            return null;
+        }
+        return mergedCarrierEntry.getSsid();
+    }
+
     @VisibleForTesting
     void setWifiPickerTracker(@NonNull WifiPickerTracker wifiPickerTracker) {
         mWifiPickerTracker = wifiPickerTracker;

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

@@ -0,0 +1,183 @@
+/*
+ * 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.
+ * 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 com.android.settings.core.BasePreferenceController.AVAILABLE;
+import static com.android.settings.core.BasePreferenceController.CONDITIONALLY_UNAVAILABLE;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.doReturn;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+import android.content.Context;
+import android.os.Looper;
+
+import androidx.lifecycle.Lifecycle;
+import androidx.preference.Preference;
+import androidx.preference.PreferenceManager;
+import androidx.preference.PreferenceScreen;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.settings.wifi.WifiPickerTrackerHelper;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.junit.MockitoJUnit;
+import org.mockito.junit.MockitoRule;
+
+@RunWith(AndroidJUnit4.class)
+public class CarrierWifiTogglePreferenceControllerTest {
+
+    private static final int SUB_ID = 2;
+    private static final String SSID = "ssid";
+
+    @Rule
+    public final MockitoRule mMockitoRule = MockitoJUnit.rule();
+    @Mock
+    public WifiPickerTrackerHelper mWifiPickerTrackerHelper;
+
+    private Context mContext;
+    private CarrierWifiTogglePreferenceController mController;
+    private PreferenceScreen mScreen;
+    private Preference mTogglePreference;
+    private Preference mNetworkPreference;
+
+    @Before
+    public void setUp() {
+        mContext = spy(ApplicationProvider.getApplicationContext());
+
+        mController = new CarrierWifiTogglePreferenceController(mContext,
+                CarrierWifiTogglePreferenceController.CARRIER_WIFI_TOGGLE_PREF_KEY);
+        mController.init(mock(Lifecycle.class), SUB_ID);
+        mController.mIsProviderModelEnabled = true;
+        mController.mIsCarrierProvisionWifiEnabled = true;
+        doReturn(SSID).when(mWifiPickerTrackerHelper).getCarrierNetworkSsid();
+        mController.mWifiPickerTrackerHelper = mWifiPickerTrackerHelper;
+        if (Looper.myLooper() == null) {
+            Looper.prepare();
+        }
+        final PreferenceManager preferenceManager = new PreferenceManager(mContext);
+        mScreen = preferenceManager.createPreferenceScreen(mContext);
+        mTogglePreference = new Preference(mContext);
+        mTogglePreference.setKey(
+                CarrierWifiTogglePreferenceController.CARRIER_WIFI_TOGGLE_PREF_KEY);
+        mScreen.addPreference(mTogglePreference);
+        mNetworkPreference = new Preference(mContext);
+        mNetworkPreference.setKey(
+                CarrierWifiTogglePreferenceController.CARRIER_WIFI_NETWORK_PREF_KEY);
+        mScreen.addPreference(mNetworkPreference);
+    }
+
+    @Test
+    public void getAvailabilityStatus_providerModelDisable_returnUnavailable() {
+        mController.mIsProviderModelEnabled = false;
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
+    }
+
+    @Test
+    public void getAvailabilityStatus_carrierProvisionWifiEnabled_returnAvailable() {
+        mController.mIsCarrierProvisionWifiEnabled = true;
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(AVAILABLE);
+    }
+
+    @Test
+    public void getAvailabilityStatus_carrierProvisionWifiDisabled_returnUnavailable() {
+        mController.mIsCarrierProvisionWifiEnabled = false;
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(CONDITIONALLY_UNAVAILABLE);
+    }
+
+    @Test
+    public void isChecked_carrierNetworkEnabled_returnTrue() {
+        doReturn(true).when(mWifiPickerTrackerHelper).isCarrierNetworkEnabled(SUB_ID);
+
+        assertThat(mController.isChecked()).isEqualTo(true);
+    }
+
+    @Test
+    public void isChecked_carrierNetworkDisabled_returnFalse() {
+        doReturn(false).when(mWifiPickerTrackerHelper).isCarrierNetworkEnabled(SUB_ID);
+
+        assertThat(mController.isChecked()).isEqualTo(false);
+    }
+
+    @Test
+    public void setChecked_checked_shouldSetCarrierNetworkEnabled() {
+        mController.setChecked(true);
+
+        verify(mWifiPickerTrackerHelper).setCarrierNetworkEnabled(true);
+    }
+
+    @Test
+    public void setChecked_unchecked_shouldSetCarrierNetworkDisabled() {
+        mController.setChecked(false);
+
+        verify(mWifiPickerTrackerHelper).setCarrierNetworkEnabled(false);
+    }
+
+    @Test
+    public void displayPreference_carrierNetworkEnabled_showCarrierNetwork() {
+        doReturn(true).when(mWifiPickerTrackerHelper).isCarrierNetworkEnabled(SUB_ID);
+
+        mController.displayPreference(mScreen);
+
+        assertThat(mController.mCarrierNetworkPreference).isEqualTo(mNetworkPreference);
+        assertThat(mNetworkPreference.isVisible()).isTrue();
+        assertThat(mNetworkPreference.getSummary()).isEqualTo(SSID);
+    }
+
+    @Test
+    public void displayPreference_carrierNetworkDisabled_hideCarrierNetwork() {
+        doReturn(false).when(mWifiPickerTrackerHelper).isCarrierNetworkEnabled(SUB_ID);
+
+        mController.displayPreference(mScreen);
+
+        assertThat(mController.mCarrierNetworkPreference).isEqualTo(mNetworkPreference);
+        assertThat(mNetworkPreference.isVisible()).isFalse();
+    }
+
+    @Test
+    public void onWifiStateChanged_carrierNetworkVisible_shouldSetSummary() {
+        mController.mCarrierNetworkPreference = mNetworkPreference;
+        mNetworkPreference.setVisible(true);
+        mNetworkPreference.setSummary(null);
+
+        mController.onWifiEntriesChanged();
+
+        assertThat(mNetworkPreference.getSummary()).isEqualTo(SSID);
+    }
+
+    @Test
+    public void onWifiEntriesChanged_carrierNetworkVisible_shouldSetSummary() {
+        mController.mCarrierNetworkPreference = mNetworkPreference;
+        mNetworkPreference.setVisible(true);
+        mNetworkPreference.setSummary(null);
+
+        mController.onWifiEntriesChanged();
+
+        assertThat(mNetworkPreference.getSummary()).isEqualTo(SSID);
+    }
+}

tests/unit/src/com/android/settings/wifi/WifiPickerTrackerHelperTest.java

@@ -20,12 +20,18 @@ import static com.google.common.truth.Truth.assertThat;
 
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.ArgumentMatchers.anyLong;
+import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.content.Context;
+import android.net.wifi.WifiManager;
 import android.os.HandlerThread;
+import android.os.PersistableBundle;
+import android.telephony.CarrierConfigManager;
 
 import androidx.lifecycle.Lifecycle;
 import androidx.test.core.app.ApplicationProvider;
@@ -47,9 +53,15 @@ import org.mockito.junit.MockitoRule;
 @RunWith(AndroidJUnit4.class)
 public class WifiPickerTrackerHelperTest {
 
+    private static final int SUB_ID = 2;
+
     @Rule
     public final MockitoRule mMockitoRule = MockitoJUnit.rule();
     @Mock
+    public WifiManager mWifiManager;
+    @Mock
+    public CarrierConfigManager mCarrierConfigManager;
+    @Mock
     public WifiPickerTracker mWifiPickerTracker;
     @Mock
     public MergedCarrierEntry mMergedCarrierEntry;
@@ -59,16 +71,24 @@ public class WifiPickerTrackerHelperTest {
     private WifiPickerTrackerHelper mWifiPickerTrackerHelper;
 
     private FakeFeatureFactory mFeatureFactory;
+    private PersistableBundle mCarrierConfig;
 
     @Before
     public void setUp() {
+        final Context context = spy(ApplicationProvider.getApplicationContext());
+        when(context.getSystemService(WifiManager.class)).thenReturn(mWifiManager);
+        when(context.getSystemService(CarrierConfigManager.class))
+                .thenReturn(mCarrierConfigManager);
+        mCarrierConfig = new PersistableBundle();
+        doReturn(mCarrierConfig).when(mCarrierConfigManager).getConfigForSubId(SUB_ID);
+
         mFeatureFactory = FakeFeatureFactory.setupForTest();
         when(mFeatureFactory.wifiTrackerLibProvider
                 .createWifiPickerTracker(
                         any(), any(), any(), any(), any(), anyLong(), anyLong(), any()))
                 .thenReturn(mWifiPickerTracker);
         mWifiPickerTrackerHelper = new WifiPickerTrackerHelper(mock(Lifecycle.class),
-                ApplicationProvider.getApplicationContext(), null);
+                context, null);
     }
 
     @Test
@@ -87,24 +107,63 @@ public class WifiPickerTrackerHelperTest {
     }
 
     @Test
-    public void setCarrierNetworkEnabled_returnTrueAndSetEnabled() {
+    public void isCarrierNetworkProvisionEnabled_getNullConfig_returnFalse() {
+        doReturn(null).when(mCarrierConfigManager).getConfigForSubId(SUB_ID);
+
+        assertThat(mWifiPickerTrackerHelper.isCarrierNetworkProvisionEnabled(SUB_ID)).isFalse();
+    }
+
+    @Test
+    public void isCarrierNetworkProvisionEnabled_returnCorrect() {
+        mCarrierConfig.putBoolean(
+                CarrierConfigManager.KEY_CARRIER_PROVISIONS_WIFI_MERGED_NETWORKS_BOOL, true);
+
+        assertThat(mWifiPickerTrackerHelper.isCarrierNetworkProvisionEnabled(SUB_ID)).isTrue();
+
+        mCarrierConfig.putBoolean(
+                CarrierConfigManager.KEY_CARRIER_PROVISIONS_WIFI_MERGED_NETWORKS_BOOL, false);
+
+        assertThat(mWifiPickerTrackerHelper.isCarrierNetworkProvisionEnabled(SUB_ID)).isFalse();
+    }
+
+    @Test
+    public void isCarrierNetworkEnabled_returnCorrect() {
+        doReturn(true).when(mWifiManager).isCarrierNetworkOffloadEnabled(SUB_ID, true /* merged */);
+
+        assertThat(mWifiPickerTrackerHelper.isCarrierNetworkEnabled(SUB_ID)).isTrue();
+
+        doReturn(false).when(mWifiManager)
+                .isCarrierNetworkOffloadEnabled(SUB_ID, true /* merged */);
+
+        assertThat(mWifiPickerTrackerHelper.isCarrierNetworkEnabled(SUB_ID)).isFalse();
+    }
+
+    @Test
+    public void setCarrierNetworkEnabled_shouldSetCorrect() {
         mWifiPickerTrackerHelper.setWifiPickerTracker(mWifiPickerTracker);
         when(mWifiPickerTracker.getMergedCarrierEntry()).thenReturn(mMergedCarrierEntry);
 
-        assertThat(mWifiPickerTrackerHelper.setCarrierNetworkEnabled(true)).isTrue();
+        mWifiPickerTrackerHelper.setCarrierNetworkEnabled(true);
+
         verify(mMergedCarrierEntry).setEnabled(true);
 
-        assertThat(mWifiPickerTrackerHelper.setCarrierNetworkEnabled(false)).isTrue();
+        mWifiPickerTrackerHelper.setCarrierNetworkEnabled(false);
+
         verify(mMergedCarrierEntry).setEnabled(false);
     }
 
     @Test
-    public void setCarrierNetworkEnabled_mergedCarrierEntryIsNull_returnFalse() {
+    public void setCarrierNetworkEnabled_mergedCarrierEntryIsNull_shouldNotSet() {
         mWifiPickerTrackerHelper.setWifiPickerTracker(mWifiPickerTracker);
         when(mWifiPickerTracker.getMergedCarrierEntry()).thenReturn(null);
 
-        assertThat(mWifiPickerTrackerHelper.setCarrierNetworkEnabled(true)).isFalse();
+        mWifiPickerTrackerHelper.setCarrierNetworkEnabled(true);
-        assertThat(mWifiPickerTrackerHelper.setCarrierNetworkEnabled(false)).isFalse();
+
+        verify(mMergedCarrierEntry, never()).setEnabled(true);
+
+        mWifiPickerTrackerHelper.setCarrierNetworkEnabled(false);
+
+        verify(mMergedCarrierEntry, never()).setEnabled(true);
     }
 
     @Test