From 5e76c02d82bf3caa1a1d1a0ae0625ecb346ea833 Mon Sep 17 00:00:00 2001 From: Weng Su Date: Mon, 4 Jan 2021 21:54:13 +0000 Subject: [PATCH] [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 --- .../NetworkMobileProviderController.java | 7 + .../network/NetworkProviderSettings.java | 54 ++------ .../SubscriptionsPreferenceController.java | 18 ++- .../telephony/MobileDataDialogFragment.java | 11 ++ .../MobileDataPreferenceController.java | 10 ++ .../telephony/MobileNetworkSettings.java | 4 + .../wifi/WifiPickerTrackerHelper.java | 123 +++++++++++++++++ ...SubscriptionsPreferenceControllerTest.java | 24 ++++ .../wifi/WifiPickerTrackerHelperTest.java | 127 ++++++++++++++++++ 9 files changed, 332 insertions(+), 46 deletions(-) create mode 100644 src/com/android/settings/wifi/WifiPickerTrackerHelper.java create mode 100644 tests/unit/src/com/android/settings/wifi/WifiPickerTrackerHelperTest.java diff --git a/src/com/android/settings/network/NetworkMobileProviderController.java b/src/com/android/settings/network/NetworkMobileProviderController.java index 4c292561976..5dc6c0db9c2 100644 --- a/src/com/android/settings/network/NetworkMobileProviderController.java +++ b/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); + } + } } diff --git a/src/com/android/settings/network/NetworkProviderSettings.java b/src/com/android/settings/network/NetworkProviderSettings.java index c2881ac88f1..c4c767b2ba6 100644 --- a/src/com/android/settings/network/NetworkProviderSettings.java +++ b/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(); diff --git a/src/com/android/settings/network/SubscriptionsPreferenceController.java b/src/com/android/settings/network/SubscriptionsPreferenceController.java index a17fc60ad04..6e67543a7e0 100644 --- a/src/com/android/settings/network/SubscriptionsPreferenceController.java +++ b/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(); } diff --git a/src/com/android/settings/network/telephony/MobileDataDialogFragment.java b/src/com/android/settings/network/telephony/MobileDataDialogFragment.java index c8a1e985333..180d5037d80 100644 --- a/src/com/android/settings/network/telephony/MobileDataDialogFragment.java +++ b/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); diff --git a/src/com/android/settings/network/telephony/MobileDataPreferenceController.java b/src/com/android/settings/network/telephony/MobileDataPreferenceController.java index 91c46dfcb56..78bc0a06bd2 100644 --- a/src/com/android/settings/network/telephony/MobileDataPreferenceController.java +++ b/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(); diff --git a/src/com/android/settings/network/telephony/MobileNetworkSettings.java b/src/com/android/settings/network/telephony/MobileNetworkSettings.java index 2a11521e7e0..7c4594986d7 100644 --- a/src/com/android/settings/network/telephony/MobileNetworkSettings.java +++ b/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); diff --git a/src/com/android/settings/wifi/WifiPickerTrackerHelper.java b/src/com/android/settings/wifi/WifiPickerTrackerHelper.java new file mode 100644 index 00000000000..60a4a01e334 --- /dev/null +++ b/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; + } +} diff --git a/tests/unit/src/com/android/settings/network/SubscriptionsPreferenceControllerTest.java b/tests/unit/src/com/android/settings/network/SubscriptionsPreferenceControllerTest.java index 5ee4c4210d0..27dd2aa0795 100644 --- a/tests/unit/src/com/android/settings/network/SubscriptionsPreferenceControllerTest.java +++ b/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); diff --git a/tests/unit/src/com/android/settings/wifi/WifiPickerTrackerHelperTest.java b/tests/unit/src/com/android/settings/wifi/WifiPickerTrackerHelperTest.java new file mode 100644 index 00000000000..851b1155a50 --- /dev/null +++ b/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); + } +}