From 728a59199b7a63829d1296ccdeb31e2ea64c1102 Mon Sep 17 00:00:00 2001 From: Weng Su Date: Sat, 19 Nov 2022 05:59:15 +0800 Subject: [PATCH] Keep "Resetting your internet" when screen rotates - The fragment of Internet Settings will be destroyed and recreated when screen rotates - Move connectivity recovery class into singleton class to avoid service being killed when fragment context is destroyed - Check if connectivity is recovering when fragment is recreated and show resettings message if necessary Bug: 202802736 Test: manual test atest -c InternetResetHelperTest make RunSettingsRoboTests ROBOTEST_FILTER=NetworkProviderSettingsTest Change-Id: Iae9585ff8366b8b71b4c39dc0ec7e87a0320fa5a --- .../settings/network/InternetResetHelper.java | 212 ++++++++++-------- .../network/NetworkProviderSettings.java | 23 +- .../network/InternetResetHelperTest.java | 134 +++++------ 3 files changed, 183 insertions(+), 186 deletions(-) diff --git a/src/com/android/settings/network/InternetResetHelper.java b/src/com/android/settings/network/InternetResetHelper.java index 086ef1b1c5d..7920cca8f61 100644 --- a/src/com/android/settings/network/InternetResetHelper.java +++ b/src/com/android/settings/network/InternetResetHelper.java @@ -21,14 +21,9 @@ import android.content.Context; import android.content.Intent; import android.content.IntentFilter; import android.net.wifi.WifiManager; -import android.os.HandlerThread; -import android.os.Process; -import android.text.TextUtils; import android.util.Log; -import androidx.annotation.UiThread; import androidx.annotation.VisibleForTesting; -import androidx.annotation.WorkerThread; import androidx.lifecycle.Lifecycle; import androidx.lifecycle.LifecycleObserver; import androidx.lifecycle.OnLifecycleEvent; @@ -38,14 +33,14 @@ import androidx.preference.PreferenceCategory; import com.android.settingslib.connectivity.ConnectivitySubsystemsRecoveryManager; import com.android.settingslib.utils.HandlerInjector; +import java.lang.ref.WeakReference; import java.util.ArrayList; import java.util.List; /** * Helper class to restart connectivity for all requested subsystems. */ -public class InternetResetHelper implements LifecycleObserver, - ConnectivitySubsystemsRecoveryManager.RecoveryStatusCallback { +public class InternetResetHelper implements LifecycleObserver { protected static final String TAG = "InternetResetHelper"; public static final long RESTART_TIMEOUT_MS = 15_000; // 15 seconds @@ -61,41 +56,40 @@ public class InternetResetHelper implements LifecycleObserver, protected final IntentFilter mWifiStateFilter; protected final BroadcastReceiver mWifiStateReceiver = new BroadcastReceiver() { @Override - @WorkerThread public void onReceive(Context context, Intent intent) { - if (intent != null && TextUtils.equals(intent.getAction(), - WifiManager.NETWORK_STATE_CHANGED_ACTION)) { - updateWifiStateChange(); - } + updateWifiStateChange(); } }; - protected ConnectivitySubsystemsRecoveryManager mConnectivitySubsystemsRecoveryManager; - protected HandlerThread mWorkerThread; - protected boolean mIsRecoveryReady; - protected boolean mIsWifiReady; + protected RecoveryWorker mRecoveryWorker; + protected boolean mIsWifiReady = true; protected HandlerInjector mHandlerInjector; - protected final Runnable mResumeRunnable = () -> { - resumePreferences(); - }; protected final Runnable mTimeoutRunnable = () -> { - mIsRecoveryReady = true; + Log.w(TAG, "Resume preferences due to connectivity subsystems recovery timed out."); + mRecoveryWorker.clearRecovering(); mIsWifiReady = true; resumePreferences(); }; - public InternetResetHelper(Context context, Lifecycle lifecycle) { + public InternetResetHelper(Context context, Lifecycle lifecycle, + NetworkMobileProviderController mobileNetworkController, + Preference wifiTogglePreferences, + PreferenceCategory connectedWifiEntryPreferenceCategory, + PreferenceCategory firstWifiEntryPreferenceCategory, + PreferenceCategory wifiEntryPreferenceCategory, + Preference resettingPreference) { mContext = context; + mMobileNetworkController = mobileNetworkController; + mWifiTogglePreferences = wifiTogglePreferences; + mWifiNetworkPreferences.add(connectedWifiEntryPreferenceCategory); + mWifiNetworkPreferences.add(firstWifiEntryPreferenceCategory); + mWifiNetworkPreferences.add(wifiEntryPreferenceCategory); + mResettingPreference = resettingPreference; + mHandlerInjector = new HandlerInjector(context.getMainThreadHandler()); mWifiManager = mContext.getSystemService(WifiManager.class); mWifiStateFilter = new IntentFilter(WifiManager.NETWORK_STATE_CHANGED_ACTION); - - mWorkerThread = new HandlerThread(TAG - + "{" + Integer.toHexString(System.identityHashCode(this)) + "}", - Process.THREAD_PRIORITY_BACKGROUND); - mWorkerThread.start(); - mConnectivitySubsystemsRecoveryManager = new ConnectivitySubsystemsRecoveryManager( - mContext, mWorkerThread.getThreadHandler()); + mRecoveryWorker = RecoveryWorker.getInstance(mContext, this); if (lifecycle != null) { lifecycle.addObserver(this); @@ -118,72 +112,18 @@ public class InternetResetHelper implements LifecycleObserver, /** @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY) */ @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY) public void onDestroy() { - mHandlerInjector.removeCallbacks(mResumeRunnable); mHandlerInjector.removeCallbacks(mTimeoutRunnable); - mWorkerThread.quit(); - } - - @Override - @WorkerThread - public void onSubsystemRestartOperationBegin() { - Log.d(TAG, "The connectivity subsystem is starting for recovery."); - } - - @Override - @WorkerThread - public void onSubsystemRestartOperationEnd() { - Log.d(TAG, "The connectivity subsystem is done for recovery."); - if (!mIsRecoveryReady) { - mIsRecoveryReady = true; - mHandlerInjector.postDelayed(mResumeRunnable, 0 /* delayMillis */); - } } @VisibleForTesting - @WorkerThread protected void updateWifiStateChange() { if (!mIsWifiReady && mWifiManager.isWifiEnabled()) { Log.d(TAG, "The Wi-Fi subsystem is done for recovery."); mIsWifiReady = true; - mHandlerInjector.postDelayed(mResumeRunnable, 0 /* delayMillis */); + resumePreferences(); } } - /** - * Sets the resetting preference. - */ - @UiThread - public void setResettingPreference(Preference preference) { - mResettingPreference = preference; - } - - /** - * Sets the mobile network controller. - */ - @UiThread - public void setMobileNetworkController(NetworkMobileProviderController controller) { - mMobileNetworkController = controller; - } - - /** - * Sets the Wi-Fi toggle preference. - */ - @UiThread - public void setWifiTogglePreference(Preference preference) { - mWifiTogglePreferences = preference; - } - - /** - * Adds the Wi-Fi network preference. - */ - @UiThread - public void addWifiNetworkPreference(PreferenceCategory preference) { - if (preference != null) { - mWifiNetworkPreferences.add(preference); - } - } - - @UiThread protected void suspendPreferences() { Log.d(TAG, "Suspend the subsystem preferences"); if (mMobileNetworkController != null) { @@ -201,9 +141,9 @@ public class InternetResetHelper implements LifecycleObserver, } } - @UiThread protected void resumePreferences() { - if (mIsRecoveryReady && mMobileNetworkController != null) { + boolean isRecoveryReady = !mRecoveryWorker.isRecovering(); + if (isRecoveryReady && mMobileNetworkController != null) { Log.d(TAG, "Resume the Mobile Network controller"); mMobileNetworkController.hidePreference(false /* hide */, true /* immediately */); } @@ -214,7 +154,7 @@ public class InternetResetHelper implements LifecycleObserver, pref.setVisible(true); } } - if (mIsRecoveryReady && mIsWifiReady) { + if (isRecoveryReady && mIsWifiReady) { mHandlerInjector.removeCallbacks(mTimeoutRunnable); if (mResettingPreference != null) { Log.d(TAG, "Resume the Resetting preference"); @@ -223,21 +163,99 @@ public class InternetResetHelper implements LifecycleObserver, } } - /** - * Restart connectivity for all requested subsystems. - */ - @UiThread + protected void showResettingAndSendTimeoutChecks() { + suspendPreferences(); + mHandlerInjector.postDelayed(mTimeoutRunnable, RESTART_TIMEOUT_MS); + } + + /** Restart connectivity for all requested subsystems. */ public void restart() { - if (!mConnectivitySubsystemsRecoveryManager.isRecoveryAvailable()) { + if (!mRecoveryWorker.isRecoveryAvailable()) { Log.e(TAG, "The connectivity subsystem is not available to restart."); return; } - - Log.d(TAG, "The connectivity subsystem is restarting for recovery."); - suspendPreferences(); - mIsRecoveryReady = false; + showResettingAndSendTimeoutChecks(); mIsWifiReady = !mWifiManager.isWifiEnabled(); - mHandlerInjector.postDelayed(mTimeoutRunnable, RESTART_TIMEOUT_MS); - mConnectivitySubsystemsRecoveryManager.triggerSubsystemRestart(null /* reason */, this); + mRecoveryWorker.triggerRestart(); + } + + /** Check if the connectivity subsystem is under recovering. */ + public void checkRecovering() { + if (!mRecoveryWorker.isRecovering()) return; + mIsWifiReady = false; + showResettingAndSendTimeoutChecks(); + } + + /** + * This is a singleton class for ConnectivitySubsystemsRecoveryManager worker. + */ + @VisibleForTesting + public static class RecoveryWorker implements + ConnectivitySubsystemsRecoveryManager.RecoveryStatusCallback { + private static final String TAG = "RecoveryWorker"; + private static RecoveryWorker sInstance; + private static WeakReference sCallback; + private static ConnectivitySubsystemsRecoveryManager sRecoveryManager; + private static boolean sIsRecovering; + + /** + * Create a singleton class for ConnectivitySubsystemsRecoveryManager. + * + * @param context The context to use for the content resolver. + * @param callback The callback of {@link InternetResetHelper} object. + * @return an instance of {@link RecoveryWorker} object. + */ + public static RecoveryWorker getInstance(Context context, InternetResetHelper callback) { + sCallback = new WeakReference<>(callback); + if (sInstance != null) return sInstance; + + sInstance = new RecoveryWorker(); + Context appContext = context.getApplicationContext(); + sRecoveryManager = new ConnectivitySubsystemsRecoveryManager(appContext, + appContext.getMainThreadHandler()); + return sInstance; + } + + /** Returns true, If the subsystem service is recovering. */ + public boolean isRecovering() { + return sIsRecovering; + } + + /** Clear the recovering flag. */ + public void clearRecovering() { + sIsRecovering = false; + } + + /** Returns true, If the subsystem service is recovery available. */ + public boolean isRecoveryAvailable() { + return sRecoveryManager.isRecoveryAvailable(); + } + + /** Trigger connectivity recovery for all requested technologies. */ + public boolean triggerRestart() { + if (!isRecoveryAvailable()) { + Log.e(TAG, "The connectivity subsystem is not available to restart."); + return false; + } + sIsRecovering = true; + sRecoveryManager.triggerSubsystemRestart(null /* reason */, sInstance); + Log.d(TAG, "The connectivity subsystem is restarting for recovery."); + return true; + } + + @Override + public void onSubsystemRestartOperationBegin() { + Log.d(TAG, "The connectivity subsystem is starting for recovery."); + sIsRecovering = true; + } + + @Override + public void onSubsystemRestartOperationEnd() { + Log.d(TAG, "The connectivity subsystem is done for recovery."); + sIsRecovering = false; + InternetResetHelper callback = sCallback.get(); + if (callback == null) return; + callback.resumePreferences(); + } } } diff --git a/src/com/android/settings/network/NetworkProviderSettings.java b/src/com/android/settings/network/NetworkProviderSettings.java index b622a3c308d..7b7cdca37d1 100644 --- a/src/com/android/settings/network/NetworkProviderSettings.java +++ b/src/com/android/settings/network/NetworkProviderSettings.java @@ -337,6 +337,8 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment addConnectedEthernetNetworkController(); addWifiSwitchPreferenceController(); mWifiStatusMessagePreference = findPreference(PREF_KEY_WIFI_STATUS_MESSAGE); + + checkConnectivityRecovering(); } private void updateAirplaneModeMsgPreference(boolean visible) { @@ -382,6 +384,17 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment mWifiSwitchPreferenceController.displayPreference(getPreferenceScreen()); } + private void checkConnectivityRecovering() { + mInternetResetHelper = new InternetResetHelper(getContext(), getLifecycle(), + mNetworkMobileProviderController, + findPreference(WifiSwitchPreferenceController.KEY), + mConnectedWifiEntryPreferenceCategory, + mFirstWifiEntryPreferenceCategory, + mWifiEntryPreferenceCategory, + mResetInternetPreference); + mInternetResetHelper.checkRecovering(); + } + @Override public void onActivityCreated(Bundle savedInstanceState) { super.onActivityCreated(savedInstanceState); @@ -1455,16 +1468,6 @@ public class NetworkProviderSettings extends RestrictedSettingsFragment EventLog.writeEvent(0x534e4554, "252995826", UserHandle.myUserId(), "User is a guest"); return; } - if (mInternetResetHelper == null) { - mInternetResetHelper = new InternetResetHelper(getContext(), getLifecycle()); - mInternetResetHelper.setResettingPreference(mResetInternetPreference); - mInternetResetHelper.setMobileNetworkController(mNetworkMobileProviderController); - mInternetResetHelper.setWifiTogglePreference( - findPreference(WifiSwitchPreferenceController.KEY)); - mInternetResetHelper.addWifiNetworkPreference(mConnectedWifiEntryPreferenceCategory); - mInternetResetHelper.addWifiNetworkPreference(mFirstWifiEntryPreferenceCategory); - mInternetResetHelper.addWifiNetworkPreference(mWifiEntryPreferenceCategory); - } mInternetResetHelper.restart(); } diff --git a/tests/unit/src/com/android/settings/network/InternetResetHelperTest.java b/tests/unit/src/com/android/settings/network/InternetResetHelperTest.java index e6df8a06451..3fe688273d8 100644 --- a/tests/unit/src/com/android/settings/network/InternetResetHelperTest.java +++ b/tests/unit/src/com/android/settings/network/InternetResetHelperTest.java @@ -16,6 +16,8 @@ package com.android.settings.network; +import static com.android.settings.network.InternetResetHelper.RESTART_TIMEOUT_MS; + import static com.google.common.truth.Truth.assertThat; import static org.mockito.ArgumentMatchers.any; @@ -29,8 +31,6 @@ import android.content.BroadcastReceiver; import android.content.Context; import android.content.IntentFilter; import android.net.wifi.WifiManager; -import android.os.Handler; -import android.os.HandlerThread; import android.os.Looper; import androidx.lifecycle.Lifecycle; @@ -39,7 +39,6 @@ import androidx.preference.PreferenceCategory; import androidx.test.core.app.ApplicationProvider; import androidx.test.ext.junit.runners.AndroidJUnit4; -import com.android.settingslib.connectivity.ConnectivitySubsystemsRecoveryManager; import com.android.settingslib.utils.HandlerInjector; import org.junit.Before; @@ -47,6 +46,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.runner.RunWith; import org.mockito.Mock; +import org.mockito.Spy; import org.mockito.junit.MockitoJUnit; import org.mockito.junit.MockitoRule; @@ -55,66 +55,46 @@ public class InternetResetHelperTest { @Rule public final MockitoRule mMockitoRule = MockitoJUnit.rule(); + @Spy + private final Context mContext = ApplicationProvider.getApplicationContext(); @Mock private WifiManager mWifiManager; @Mock - public HandlerThread mWorkerThread; + InternetResetHelper.RecoveryWorker mRecoveryWorker; @Mock - public ConnectivitySubsystemsRecoveryManager mConnectivitySubsystemsRecoveryManager; + HandlerInjector mHandlerInjector; @Mock public NetworkMobileProviderController mMobileNetworkController; - private Context mContext; private InternetResetHelper mInternetResetHelper; private Preference mResettingPreference; private Preference mWifiTogglePreferences; private PreferenceCategory mConnectedWifiEntryPreferences; + private PreferenceCategory mFirstWifiEntryPreference; private PreferenceCategory mWifiEntryPreferences; - private FakeHandlerInjector mFakeHandlerInjector; - - private static class FakeHandlerInjector extends HandlerInjector { - - private Runnable mRunnable; - - FakeHandlerInjector(Handler handler) { - super(handler); - } - - @Override - public void postDelayed(Runnable runnable, long delayMillis) { - mRunnable = runnable; - } - - public Runnable getRunnable() { - return mRunnable; - } - } - @Before public void setUp() { - mContext = spy(ApplicationProvider.getApplicationContext()); when(mContext.getSystemService(WifiManager.class)).thenReturn(mWifiManager); + when(mRecoveryWorker.isRecovering()).thenReturn(false); if (Looper.myLooper() == null) { Looper.prepare(); } - mResettingPreference = new Preference(mContext); + mResettingPreference = spy(new Preference(mContext)); mWifiTogglePreferences = new Preference(mContext); mConnectedWifiEntryPreferences = spy(new PreferenceCategory(mContext)); + mFirstWifiEntryPreference = spy(new PreferenceCategory(mContext)); mWifiEntryPreferences = spy(new PreferenceCategory(mContext)); - final Lifecycle lifecycle = mock(Lifecycle.class); - mInternetResetHelper = new InternetResetHelper(mContext, lifecycle); - mInternetResetHelper.mWorkerThread = mWorkerThread; - mFakeHandlerInjector = new FakeHandlerInjector(mContext.getMainThreadHandler()); - mInternetResetHelper.mHandlerInjector = mFakeHandlerInjector; - mInternetResetHelper.mConnectivitySubsystemsRecoveryManager = - mConnectivitySubsystemsRecoveryManager; - mInternetResetHelper.setResettingPreference(mResettingPreference); - mInternetResetHelper.setMobileNetworkController(mMobileNetworkController); - mInternetResetHelper.setWifiTogglePreference(mWifiTogglePreferences); - mInternetResetHelper.addWifiNetworkPreference(mConnectedWifiEntryPreferences); - mInternetResetHelper.addWifiNetworkPreference(mWifiEntryPreferences); + mInternetResetHelper = new InternetResetHelper(mContext, mock(Lifecycle.class), + mMobileNetworkController, + mWifiTogglePreferences, + mConnectedWifiEntryPreferences, + mFirstWifiEntryPreference, + mWifiEntryPreferences, + mResettingPreference); + mInternetResetHelper.mHandlerInjector = mHandlerInjector; + mInternetResetHelper.mRecoveryWorker = mRecoveryWorker; } @Test @@ -135,30 +115,10 @@ public class InternetResetHelperTest { } @Test - public void onDestroy_quitWorkerThread() { + public void onDestroy_removeCallbacks() { mInternetResetHelper.onDestroy(); - verify(mWorkerThread).quit(); - } - - @Test - public void onSubsystemRestartOperationEnd_recoveryIsNotReady_postResumeRunnable() { - mInternetResetHelper.mIsRecoveryReady = false; - - mInternetResetHelper.onSubsystemRestartOperationEnd(); - - assertThat(mInternetResetHelper.mIsRecoveryReady).isTrue(); - assertThat(mFakeHandlerInjector.getRunnable()) - .isEqualTo(mInternetResetHelper.mResumeRunnable); - } - - @Test - public void onSubsystemRestartOperationEnd_recoveryIsReady_doNothing() { - mInternetResetHelper.mIsRecoveryReady = true; - - mInternetResetHelper.onSubsystemRestartOperationEnd(); - - assertThat(mFakeHandlerInjector.getRunnable()).isNull(); + verify(mHandlerInjector).removeCallbacks(any()); } @Test @@ -169,19 +129,16 @@ public class InternetResetHelperTest { mInternetResetHelper.updateWifiStateChange(); assertThat(mInternetResetHelper.mIsWifiReady).isFalse(); - assertThat(mFakeHandlerInjector.getRunnable()).isNull(); } @Test - public void updateWifiStateChange_wifiIsNotReadyAndWifiEnabled_postResumeRunnable() { + public void updateWifiStateChange_wifiIsNotReadyAndWifiEnabled_updateWifiIsReady() { mInternetResetHelper.mIsWifiReady = false; when(mWifiManager.isWifiEnabled()).thenReturn(true); mInternetResetHelper.updateWifiStateChange(); assertThat(mInternetResetHelper.mIsWifiReady).isTrue(); - assertThat(mFakeHandlerInjector.getRunnable()) - .isEqualTo(mInternetResetHelper.mResumeRunnable); } @Test @@ -191,7 +148,6 @@ public class InternetResetHelperTest { mInternetResetHelper.updateWifiStateChange(); assertThat(mInternetResetHelper.mIsWifiReady).isTrue(); - assertThat(mFakeHandlerInjector.getRunnable()).isNull(); } @Test @@ -203,16 +159,15 @@ public class InternetResetHelperTest { // Hide subsystem preferences verify(mMobileNetworkController).hidePreference(true /* hide */, true /* immediately*/); assertThat(mWifiTogglePreferences.isVisible()).isFalse(); - verify(mConnectedWifiEntryPreferences).removeAll(); assertThat(mConnectedWifiEntryPreferences.isVisible()).isFalse(); - verify(mWifiEntryPreferences).removeAll(); + assertThat(mFirstWifiEntryPreference.isVisible()).isFalse(); assertThat(mWifiEntryPreferences.isVisible()).isFalse(); } @Test public void resumePreferences_onlyRecoveryReady_shouldShowSubSysHideResetting() { mInternetResetHelper.suspendPreferences(); - mInternetResetHelper.mIsRecoveryReady = true; + when(mRecoveryWorker.isRecovering()).thenReturn(false); mInternetResetHelper.mIsWifiReady = false; mInternetResetHelper.resumePreferences(); @@ -224,13 +179,14 @@ public class InternetResetHelperTest { // Hide Wi-Fi preferences assertThat(mWifiTogglePreferences.isVisible()).isFalse(); assertThat(mConnectedWifiEntryPreferences.isVisible()).isFalse(); + assertThat(mFirstWifiEntryPreference.isVisible()).isFalse(); assertThat(mWifiEntryPreferences.isVisible()).isFalse(); } @Test public void resumePreferences_onlyWifiReady_shouldShowSubSysHideResetting() { mInternetResetHelper.suspendPreferences(); - mInternetResetHelper.mIsRecoveryReady = false; + when(mRecoveryWorker.isRecovering()).thenReturn(true); mInternetResetHelper.mIsWifiReady = true; mInternetResetHelper.resumePreferences(); @@ -240,6 +196,7 @@ public class InternetResetHelperTest { // Show Wi-Fi preferences assertThat(mWifiTogglePreferences.isVisible()).isTrue(); assertThat(mConnectedWifiEntryPreferences.isVisible()).isTrue(); + assertThat(mFirstWifiEntryPreference.isVisible()).isTrue(); assertThat(mWifiEntryPreferences.isVisible()).isTrue(); // Hide Mobile Network controller verify(mMobileNetworkController, never()) @@ -249,14 +206,16 @@ public class InternetResetHelperTest { @Test public void resumePreferences_allReady_shouldShowSubSysHideResetting() { mInternetResetHelper.suspendPreferences(); - mInternetResetHelper.mIsRecoveryReady = true; + when(mRecoveryWorker.isRecovering()).thenReturn(false); mInternetResetHelper.mIsWifiReady = true; + mInternetResetHelper.resumePreferences(); // Show subsystem preferences verify(mMobileNetworkController).hidePreference(false, true); assertThat(mWifiTogglePreferences.isVisible()).isTrue(); assertThat(mConnectedWifiEntryPreferences.isVisible()).isTrue(); + assertThat(mFirstWifiEntryPreference.isVisible()).isTrue(); assertThat(mWifiEntryPreferences.isVisible()).isTrue(); // Hide resetting preference assertThat(mResettingPreference.isVisible()).isFalse(); @@ -264,22 +223,39 @@ public class InternetResetHelperTest { @Test public void restart_recoveryNotAvailable_shouldDoTriggerSubsystemRestart() { - when(mConnectivitySubsystemsRecoveryManager.isRecoveryAvailable()).thenReturn(false); + when(mRecoveryWorker.isRecoveryAvailable()).thenReturn(false); mInternetResetHelper.restart(); - verify(mConnectivitySubsystemsRecoveryManager, never()) - .triggerSubsystemRestart(any(), any()); + verify(mRecoveryWorker, never()).triggerRestart(); } @Test public void restart_recoveryAvailable_triggerSubsystemRestart() { - when(mConnectivitySubsystemsRecoveryManager.isRecoveryAvailable()).thenReturn(true); + when(mRecoveryWorker.isRecoveryAvailable()).thenReturn(true); mInternetResetHelper.restart(); - assertThat(mFakeHandlerInjector.getRunnable()) - .isEqualTo(mInternetResetHelper.mTimeoutRunnable); - verify(mConnectivitySubsystemsRecoveryManager).triggerSubsystemRestart(any(), any()); + verify(mHandlerInjector) + .postDelayed(mInternetResetHelper.mTimeoutRunnable, RESTART_TIMEOUT_MS); + verify(mRecoveryWorker).triggerRestart(); + } + + @Test + public void checkRecovering_isRecovering_showResetting() { + when(mRecoveryWorker.isRecovering()).thenReturn(true); + + mInternetResetHelper.checkRecovering(); + + verify(mResettingPreference).setVisible(true); + } + + @Test + public void checkRecovering_isNotRecovering_doNotShowResetting() { + when(mRecoveryWorker.isRecovering()).thenReturn(false); + + mInternetResetHelper.checkRecovering(); + + verify(mResettingPreference, never()).setVisible(true); } }