[Provider Model] Implement the carrner network selection settings

- Add WifiPickerTrackerHelper to reuse the library

- User taps on carrier network preference
  - Calls MergedCarrierEntry#connect()

- User toggles mobile data On/Off
  - Calls MergedCarrierEntry#setEnabled(true/false)

Bug: 175761096
Test:
- Manual Test
- atest NetworkMobileProviderControllerTest \
        SubscriptionsPreferenceControllerTest \
        WifiPickerTrackerHelperTest

Change-Id: Ia311b10ca7a44a536556c1889ee65743af379822

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

@@ -24,6 +24,7 @@ import androidx.preference.PreferenceCategory;
 import androidx.preference.PreferenceScreen;
 
 import com.android.settings.core.BasePreferenceController;
+import com.android.settings.wifi.WifiPickerTrackerHelper;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
 /**
@@ -115,4 +116,10 @@ public class NetworkMobileProviderController extends BasePreferenceController im
         }
         mPreferenceCategory.setVisible(available);
     }
+
+    public void setWifiPickerTrackerHelper(WifiPickerTrackerHelper helper) {
+        if (mSubscriptionsController != null) {
+            mSubscriptionsController.setWifiPickerTrackerHelper(helper);
+        }
+    }
 }

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

@@ -27,19 +27,12 @@ import android.content.ContentResolver;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
-import android.net.ConnectivityManager;
-import android.net.NetworkScoreManager;
 import android.net.NetworkTemplate;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
 import android.os.Bundle;
 import android.os.Handler;
-import android.os.HandlerThread;
-import android.os.Looper;
 import android.os.PowerManager;
-import android.os.Process;
-import android.os.SimpleClock;
-import android.os.SystemClock;
 import android.provider.Settings;
 import android.text.TextUtils;
 import android.util.FeatureFlagUtils;
@@ -74,6 +67,7 @@ import com.android.settings.wifi.LinkablePreference;
 import com.android.settings.wifi.WifiConfigUiBase2;
 import com.android.settings.wifi.WifiConnectListener;
 import com.android.settings.wifi.WifiDialog2;
+import com.android.settings.wifi.WifiPickerTrackerHelper;
 import com.android.settings.wifi.WifiUtils;
 import com.android.settings.wifi.details2.WifiNetworkDetailsFragment2;
 import com.android.settings.wifi.dpp.WifiDppUtils;
@@ -88,8 +82,6 @@ import com.android.wifitrackerlib.WifiEntry;
 import com.android.wifitrackerlib.WifiEntry.ConnectCallback;
 import com.android.wifitrackerlib.WifiPickerTracker;
 
-import java.time.Clock;
-import java.time.ZoneOffset;
 import java.util.List;
 import java.util.Optional;
 
@@ -115,11 +107,6 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment
     static final int MENU_ID_FORGET = Menu.FIRST + 3;
     static final int MENU_ID_MODIFY = Menu.FIRST + 4;
 
-    // Max age of tracked WifiEntries
-    private static final long MAX_SCAN_AGE_MILLIS = 15_000;
-    // Interval between initiating WifiPickerTracker scans
-    private static final long SCAN_INTERVAL_MILLIS = 10_000;
-
     @VisibleForTesting
     static final int ADD_NETWORK_REQUEST = 2;
     static final int CONFIG_NETWORK_REQUEST = 3;
@@ -187,11 +174,9 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment
      */
     private boolean mIsRestricted;
 
-    // Worker thread used for WifiPickerTracker work
-    private HandlerThread mWorkerThread;
-
     @VisibleForTesting
     WifiPickerTracker mWifiPickerTracker;
+    private WifiPickerTrackerHelper mWifiPickerTrackerHelper;
 
     private WifiDialog2 mDialog;
 
@@ -279,27 +264,9 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment
     public void onActivityCreated(Bundle savedInstanceState) {
         super.onActivityCreated(savedInstanceState);
 
-        final Context context = getContext();
-        mWorkerThread = new HandlerThread(TAG
-                + "{" + Integer.toHexString(System.identityHashCode(this)) + "}",
-                Process.THREAD_PRIORITY_BACKGROUND);
-        mWorkerThread.start();
-        final Clock elapsedRealtimeClock = new SimpleClock(ZoneOffset.UTC) {
-            @Override
-            public long millis() {
-                return SystemClock.elapsedRealtime();
-            }
-        };
-        mWifiPickerTracker = new WifiPickerTracker(getSettingsLifecycle(), context,
-                context.getSystemService(WifiManager.class),
-                context.getSystemService(ConnectivityManager.class),
-                context.getSystemService(NetworkScoreManager.class),
-                new Handler(Looper.getMainLooper()),
-                mWorkerThread.getThreadHandler(),
-                elapsedRealtimeClock,
-                MAX_SCAN_AGE_MILLIS,
-                SCAN_INTERVAL_MILLIS,
-                this);
+        mWifiPickerTrackerHelper =
+                new WifiPickerTrackerHelper(getSettingsLifecycle(), getContext(), this);
+        mWifiPickerTracker = mWifiPickerTrackerHelper.getWifiPickerTracker();
 
         final Activity activity = getActivity();
 
@@ -356,6 +323,10 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment
         if (intent.hasExtra(EXTRA_START_CONNECT_SSID)) {
             mOpenSsid = intent.getStringExtra(EXTRA_START_CONNECT_SSID);
         }
+
+        if (mNetworkMobileProviderController != null) {
+            mNetworkMobileProviderController.setWifiPickerTrackerHelper(mWifiPickerTrackerHelper);
+        }
     }
 
     @Override
@@ -364,13 +335,6 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment
 
     }
 
-    @Override
-    public void onDestroyView() {
-        mWorkerThread.quit();
-
-        super.onDestroyView();
-    }
-
     @Override
     public void onStart() {
         super.onStart();

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

@@ -50,6 +50,7 @@ import com.android.settings.network.telephony.MobileNetworkActivity;
 import com.android.settings.network.telephony.MobileNetworkUtils;
 import com.android.settings.network.telephony.SignalStrengthListener;
 import com.android.settings.widget.GearPreference;
+import com.android.settings.wifi.WifiPickerTrackerHelper;
 import com.android.settingslib.core.AbstractPreferenceController;
 import com.android.settingslib.net.SignalStrengthUtil;
 
@@ -84,6 +85,7 @@ public class SubscriptionsPreferenceController extends AbstractPreferenceControl
     private MobileDataEnabledListener mDataEnabledListener;
     private DataConnectivityListener mConnectivityListener;
     private SignalStrengthListener mSignalStrengthListener;
+    private WifiPickerTrackerHelper mWifiPickerTrackerHelper;
 
     @VisibleForTesting
     final BroadcastReceiver mDataSubscriptionChangedReceiver = new BroadcastReceiver() {
@@ -215,7 +217,7 @@ public class SubscriptionsPreferenceController extends AbstractPreferenceControl
             mPreferenceGroup.removeAll();
             mSubsGearPref = new GearPreference(mContext, null);
             mSubsGearPref.setOnPreferenceClickListener(preference -> {
-                //TODO(b/176141379) Wait for wifiManager#selectCarrier(int subscriptionId)
+                connectCarrierNetwork();
                 return true;
             });
             mSubsGearPref.setOnGearClickListener(p ->
@@ -466,6 +468,20 @@ public class SubscriptionsPreferenceController extends AbstractPreferenceControl
                 ProxySubscriptionManager.getInstance(context), subId) != null);
     }
 
+    public void setWifiPickerTrackerHelper(WifiPickerTrackerHelper helper) {
+        mWifiPickerTrackerHelper = helper;
+    }
+
+    @VisibleForTesting
+    public void connectCarrierNetwork() {
+        if (mTelephonyManager == null || !mTelephonyManager.isDataEnabled()) {
+            return;
+        }
+        if (mWifiPickerTrackerHelper != null) {
+            mWifiPickerTrackerHelper.connectCarrierNetwork(null /* ConnectCallback */);
+        }
+    }
+
     SubsPrefCtrlInjector createSubsPrefCtrlInjector() {
         return new SubsPrefCtrlInjector();
     }

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

@@ -28,6 +28,7 @@ import androidx.appcompat.app.AlertDialog;
 
 import com.android.settings.R;
 import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
+import com.android.settings.wifi.WifiPickerTrackerHelper;
 
 
 /**
@@ -50,6 +51,8 @@ public class MobileDataDialogFragment extends InstrumentedDialogFragment impleme
     private int mType;
     private int mSubId;
 
+    private WifiPickerTrackerHelper mWifiPickerTrackerHelper;
+
     public static MobileDataDialogFragment newInstance(int type, int subId) {
         final MobileDataDialogFragment dialogFragment = new MobileDataDialogFragment();
 
@@ -65,6 +68,8 @@ public class MobileDataDialogFragment extends InstrumentedDialogFragment impleme
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         mSubscriptionManager = getContext().getSystemService(SubscriptionManager.class);
+        mWifiPickerTrackerHelper = new WifiPickerTrackerHelper(getSettingsLifecycle(), getContext(),
+                null /* WifiPickerTrackerCallback */);
     }
 
     @Override
@@ -124,11 +129,17 @@ public class MobileDataDialogFragment extends InstrumentedDialogFragment impleme
             case TYPE_DISABLE_DIALOG:
                 MobileNetworkUtils.setMobileDataEnabled(getContext(), mSubId, false /* enabled */,
                         false /* disableOtherSubscriptions */);
+                if (mWifiPickerTrackerHelper != null) {
+                    mWifiPickerTrackerHelper.setCarrierNetworkEnabled(false);
+                }
                 break;
             case TYPE_MULTI_SIM_DIALOG:
                 mSubscriptionManager.setDefaultDataSubId(mSubId);
                 MobileNetworkUtils.setMobileDataEnabled(getContext(), mSubId, true /* enabled */,
                         true /* disableOtherSubscriptions */);
+                if (mWifiPickerTrackerHelper != null) {
+                    mWifiPickerTrackerHelper.setCarrierNetworkEnabled(true);
+                }
                 break;
             default:
                 throw new IllegalArgumentException("unknown type " + mType);

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

@@ -32,6 +32,7 @@ import androidx.preference.SwitchPreference;
 
 import com.android.settings.R;
 import com.android.settings.network.MobileDataContentObserver;
+import com.android.settings.wifi.WifiPickerTrackerHelper;
 import com.android.settingslib.core.lifecycle.LifecycleObserver;
 import com.android.settingslib.core.lifecycle.events.OnStart;
 import com.android.settingslib.core.lifecycle.events.OnStop;
@@ -54,6 +55,8 @@ public class MobileDataPreferenceController extends TelephonyTogglePreferenceCon
     @VisibleForTesting
     boolean mNeedDialog;
 
+    private WifiPickerTrackerHelper mWifiPickerTrackerHelper;
+
     public MobileDataPreferenceController(Context context, String key) {
         super(context, key);
         mSubscriptionManager = context.getSystemService(SubscriptionManager.class);
@@ -107,6 +110,9 @@ 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) {
+                mWifiPickerTrackerHelper.setCarrierNetworkEnabled(isChecked);
+            }
             return true;
         }
 
@@ -149,6 +155,10 @@ public class MobileDataPreferenceController extends TelephonyTogglePreferenceCon
                 .createForSubscriptionId(mSubId);
     }
 
+    public void setWifiPickerTrackerHelper(WifiPickerTrackerHelper helper) {
+        mWifiPickerTrackerHelper = helper;
+    }
+
     @VisibleForTesting
     boolean isDialogNeeded() {
         final boolean enableData = !isChecked();

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

@@ -43,6 +43,7 @@ import com.android.settings.network.telephony.cdma.CdmaSystemSelectPreferenceCon
 import com.android.settings.network.telephony.gsm.AutoSelectPreferenceController;
 import com.android.settings.network.telephony.gsm.OpenNetworkSelectPagePreferenceController;
 import com.android.settings.search.BaseSearchIndexProvider;
+import com.android.settings.wifi.WifiPickerTrackerHelper;
 import com.android.settingslib.core.AbstractPreferenceController;
 import com.android.settingslib.search.SearchIndexable;
 import com.android.settingslib.utils.ThreadUtils;
@@ -147,6 +148,9 @@ public class MobileNetworkSettings extends AbstractMobileNetworkSettings {
         use(DisableSimFooterPreferenceController.class).init(mSubId);
         use(NrDisabledInDsdsFooterPreferenceController.class).init(mSubId);
         use(MobileDataPreferenceController.class).init(getFragmentManager(), mSubId);
+        use(MobileDataPreferenceController.class).setWifiPickerTrackerHelper(
+                new WifiPickerTrackerHelper(getSettingsLifecycle(), context,
+                        null /* WifiPickerTrackerCallback */));
         use(RoamingPreferenceController.class).init(getFragmentManager(), mSubId);
         use(ApnPreferenceController.class).init(mSubId);
         use(CarrierPreferenceController.class).init(mSubId);

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

@@ -0,0 +1,123 @@
+/*
+ * 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.wifi;
+
+import android.content.Context;
+import android.net.ConnectivityManager;
+import android.net.NetworkScoreManager;
+import android.net.wifi.WifiManager;
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Process;
+import android.os.SimpleClock;
+import android.os.SystemClock;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.lifecycle.Lifecycle;
+import androidx.lifecycle.LifecycleObserver;
+import androidx.lifecycle.OnLifecycleEvent;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.wifitrackerlib.MergedCarrierEntry;
+import com.android.wifitrackerlib.WifiEntry;
+import com.android.wifitrackerlib.WifiPickerTracker;
+
+import java.time.Clock;
+import java.time.ZoneOffset;
+
+public class WifiPickerTrackerHelper implements LifecycleObserver {
+
+    private static final String TAG = "WifiPickerTrackerHelper";
+
+    // Max age of tracked WifiEntries
+    private static final long MAX_SCAN_AGE_MILLIS = 15_000;
+    // Interval between initiating WifiPickerTracker scans
+    private static final long SCAN_INTERVAL_MILLIS = 10_000;
+    // Clock used for evaluating the age of scans
+    private static final Clock ELAPSED_REALTIME_CLOCK = new SimpleClock(ZoneOffset.UTC) {
+        @Override
+        public long millis() {
+            return SystemClock.elapsedRealtime();
+        }
+    };
+
+    private WifiPickerTracker mWifiPickerTracker;
+    // Worker thread used for WifiPickerTracker work
+    private HandlerThread mWorkerThread;
+
+    public WifiPickerTrackerHelper(@NonNull Lifecycle lifecycle, @NonNull Context context,
+            @Nullable WifiPickerTracker.WifiPickerTrackerCallback listener) {
+        if (lifecycle == null) {
+            throw new IllegalArgumentException("lifecycle must be non-null.");
+        }
+        lifecycle.addObserver(this);
+        mWorkerThread = new HandlerThread(TAG
+                + "{" + Integer.toHexString(System.identityHashCode(this)) + "}",
+                Process.THREAD_PRIORITY_BACKGROUND);
+        mWorkerThread.start();
+
+        mWifiPickerTracker = new WifiPickerTracker(lifecycle, context,
+                context.getSystemService(WifiManager.class),
+                context.getSystemService(ConnectivityManager.class),
+                context.getSystemService(NetworkScoreManager.class),
+                new Handler(Looper.getMainLooper()),
+                mWorkerThread.getThreadHandler(),
+                ELAPSED_REALTIME_CLOCK,
+                MAX_SCAN_AGE_MILLIS,
+                SCAN_INTERVAL_MILLIS,
+                listener);
+    }
+
+    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
+    public void onDestroy() {
+        mWorkerThread.quit();
+    }
+
+    public @NonNull WifiPickerTracker getWifiPickerTracker() {
+        return mWifiPickerTracker;
+    }
+
+    public boolean setCarrierNetworkEnabled(boolean enable) {
+        final MergedCarrierEntry mergedCarrierEntry = mWifiPickerTracker.getMergedCarrierEntry();
+        if (mergedCarrierEntry == null) {
+            return false;
+        }
+        mergedCarrierEntry.setEnabled(enable);
+        return true;
+    }
+
+    public boolean connectCarrierNetwork(@Nullable WifiEntry.ConnectCallback callback) {
+        final MergedCarrierEntry mergedCarrierEntry = mWifiPickerTracker.getMergedCarrierEntry();
+        if (mergedCarrierEntry == null || !mergedCarrierEntry.canConnect()) {
+            return false;
+        }
+        mergedCarrierEntry.connect(callback);
+        return true;
+    }
+
+    @VisibleForTesting
+    void setWifiPickerTracker(@NonNull WifiPickerTracker wifiPickerTracker) {
+        mWifiPickerTracker = wifiPickerTracker;
+    }
+
+    @VisibleForTesting
+    void setWorkerThread(@NonNull HandlerThread workerThread) {
+        mWorkerThread = workerThread;
+    }
+}

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

@@ -28,6 +28,7 @@ import static org.mockito.ArgumentMatchers.anyInt;
 import static org.mockito.ArgumentMatchers.eq;;
 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;
@@ -59,6 +60,7 @@ import androidx.test.ext.junit.runners.AndroidJUnit4;
 import com.android.settings.Utils;
 import com.android.settings.network.SubscriptionsPreferenceController.SubsPrefCtrlInjector;
 import com.android.settings.testutils.ResourcesUtils;
+import com.android.settings.wifi.WifiPickerTrackerHelper;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
 import org.junit.After;
@@ -90,6 +92,8 @@ public class SubscriptionsPreferenceControllerTest {
     private Lifecycle mLifecycle;
     @Mock
     private LifecycleOwner mLifecycleOwner;
+    @Mock
+    private WifiPickerTrackerHelper mWifiPickerTrackerHelper;
     private LifecycleRegistry mLifecycleRegistry;
     private int mOnChildUpdatedCount;
     private Context mContext;
@@ -529,6 +533,26 @@ public class SubscriptionsPreferenceControllerTest {
         assertThat(icon).isEqualTo(actualIcon);
     }
 
+    @Test
+    public void connectCarrierNetwork_isDataEnabled_helperConnect() {
+        when(mTelephonyManager.isDataEnabled()).thenReturn(true);
+        mController.setWifiPickerTrackerHelper(mWifiPickerTrackerHelper);
+
+        mController.connectCarrierNetwork();
+
+        verify(mWifiPickerTrackerHelper).connectCarrierNetwork(any());
+    }
+
+    @Test
+    public void connectCarrierNetwork_isNotDataEnabled_helperNeverConnect() {
+        when(mTelephonyManager.isDataEnabled()).thenReturn(false);
+        mController.setWifiPickerTrackerHelper(mWifiPickerTrackerHelper);
+
+        mController.connectCarrierNetwork();
+
+        verify(mWifiPickerTrackerHelper, never()).connectCarrierNetwork(any());
+    }
+
     private void setupGetIconConditions(int subId, boolean isActiveCellularNetwork,
             boolean isDataEnable, int dataState, int servicestate) {
         doReturn(mTelephonyManagerForSub).when(mTelephonyManager).createForSubscriptionId(subId);

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

@@ -0,0 +1,127 @@
+/*
+ * 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.wifi;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.os.HandlerThread;
+
+import androidx.lifecycle.Lifecycle;
+import androidx.test.core.app.ApplicationProvider;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import com.android.wifitrackerlib.MergedCarrierEntry;
+import com.android.wifitrackerlib.WifiEntry;
+import com.android.wifitrackerlib.WifiPickerTracker;
+
+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 WifiPickerTrackerHelperTest {
+
+    @Rule
+    public final MockitoRule mMockitoRule = MockitoJUnit.rule();
+    @Mock
+    public WifiPickerTracker mWifiPickerTracker;
+    @Mock
+    public MergedCarrierEntry mMergedCarrierEntry;
+    @Mock
+    public WifiEntry.ConnectCallback mConnectCallback;
+
+    private WifiPickerTrackerHelper mWifiPickerTrackerHelper;
+
+    @Before
+    public void setUp() {
+        mWifiPickerTrackerHelper = new WifiPickerTrackerHelper(mock(Lifecycle.class),
+                ApplicationProvider.getApplicationContext(), null);
+    }
+
+    @Test
+    public void getWifiPickerTracker_returnNonNull() {
+        assertThat(mWifiPickerTrackerHelper.getWifiPickerTracker()).isNotNull();
+    }
+
+    @Test
+    public void onDestroy_workerThreadQuit() {
+        final HandlerThread workerThread = mock(HandlerThread.class);
+        mWifiPickerTrackerHelper.setWorkerThread(workerThread);
+
+        mWifiPickerTrackerHelper.onDestroy();
+
+        verify(workerThread).quit();
+    }
+
+    @Test
+    public void setCarrierNetworkEnabled_returnTrueAndSetEnabled() {
+        mWifiPickerTrackerHelper.setWifiPickerTracker(mWifiPickerTracker);
+        when(mWifiPickerTracker.getMergedCarrierEntry()).thenReturn(mMergedCarrierEntry);
+
+        assertThat(mWifiPickerTrackerHelper.setCarrierNetworkEnabled(true)).isTrue();
+        verify(mMergedCarrierEntry).setEnabled(true);
+
+        assertThat(mWifiPickerTrackerHelper.setCarrierNetworkEnabled(false)).isTrue();
+        verify(mMergedCarrierEntry).setEnabled(false);
+    }
+
+    @Test
+    public void setCarrierNetworkEnabled_mergedCarrierEntryIsNull_returnFalse() {
+        mWifiPickerTrackerHelper.setWifiPickerTracker(mWifiPickerTracker);
+        when(mWifiPickerTracker.getMergedCarrierEntry()).thenReturn(null);
+
+        assertThat(mWifiPickerTrackerHelper.setCarrierNetworkEnabled(true)).isFalse();
+        assertThat(mWifiPickerTrackerHelper.setCarrierNetworkEnabled(false)).isFalse();
+    }
+
+    @Test
+    public void connectCarrierNetwork_returnTrueAndConnect() {
+        mWifiPickerTrackerHelper.setWifiPickerTracker(mWifiPickerTracker);
+        when(mWifiPickerTracker.getMergedCarrierEntry()).thenReturn(mMergedCarrierEntry);
+        when(mMergedCarrierEntry.canConnect()).thenReturn(true);
+
+        assertThat(mWifiPickerTrackerHelper.connectCarrierNetwork(mConnectCallback)).isTrue();
+        verify(mMergedCarrierEntry).connect(mConnectCallback);
+    }
+
+    @Test
+    public void connectCarrierNetwork_mergedCarrierEntryIsNull_returnFalse() {
+        mWifiPickerTrackerHelper.setWifiPickerTracker(mWifiPickerTracker);
+        when(mWifiPickerTracker.getMergedCarrierEntry()).thenReturn(null);
+
+        assertThat(mWifiPickerTrackerHelper.connectCarrierNetwork(mConnectCallback)).isFalse();
+    }
+
+    @Test
+    public void connectCarrierNetwork_canConnectIsFalse_returnFalseAndNeverConnect() {
+        mWifiPickerTrackerHelper.setWifiPickerTracker(mWifiPickerTracker);
+        when(mWifiPickerTracker.getMergedCarrierEntry()).thenReturn(mMergedCarrierEntry);
+        when(mMergedCarrierEntry.canConnect()).thenReturn(false);
+
+        assertThat(mWifiPickerTrackerHelper.connectCarrierNetwork(mConnectCallback)).isFalse();
+        verify(mMergedCarrierEntry, never()).connect(mConnectCallback);
+    }
+}