Adjust UX for toggles when active scorer is not set.

This change fixes two issues: when wakeup is not available, update the
number of items to show above the fold in wifi preferences. When scorer
is not set, grey out wakeup toggle and set summary to reflect the
status.

Bug: 62410973
Bug: 62343859
Test: make RunSettingsRoboTests -j40

Change-Id: I5f4131c6a86eab6c0fb03ea2b5101ba107a9189f

res/values/strings.xml

@@ -1708,6 +1708,7 @@
     <string name="wifi_wakeup_summary">Wi\u2011Fi will turn back on near high\u2011quality saved networks, like your home network</string>
     <!-- Checkbox summary for Wi-Fi wakeup option to explain that Wi-Fi wakeup is disabled because Wi-Fi scanning is turned off -->
     <string name="wifi_wakeup_summary_scanning_disabled">Unavailable because Wi\u2011Fi scanning is turned off</string>
+    <string name="wifi_wakeup_summary_scoring_disabled">Unavailable because network rating provider is set to none</string>
     <!-- Checkbox title for option to toggle poor network detection -->
     <string name="wifi_poor_network_detection">Avoid poor connections</string>
     <!-- Checkbox summary for option to toggle poor network detection -->
@@ -1718,6 +1719,8 @@
     <string name="use_open_wifi_automatically_title">Connect to open networks</string>
     <!-- Checkbox summary for option to connect to open Wi-Fi automatically  [CHAR LIMIT=100] -->
     <string name="use_open_wifi_automatically_summary">Automatically connect to high\u2011quality public networks</string>
+    <string name="use_open_wifi_automatically_summary_scoring_disabled">Unavailable because network rating provider is set to none</string>
+    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled">Unavailable because the network rating provider does not support this feature</string>
     <!-- Preference title for option to install certificates -->
     <string name="wifi_install_credentials">Install certificates</string>
     <!-- Message to describe "Wi-Fi scan always available feature" when Wi-Fi is off and Wi-Fi

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

@@ -25,7 +25,6 @@ import android.provider.SearchIndexableResource;
 
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 import com.android.settings.R;
-import com.android.settings.SettingsActivity;
 import com.android.settings.dashboard.DashboardFragment;
 import com.android.settings.network.NetworkScoreManagerWrapper;
 import com.android.settings.network.NetworkScorerPickerPreferenceController;
@@ -43,6 +42,7 @@ public class ConfigureWifiSettings extends DashboardFragment {
 
     private static final String TAG = "ConfigureWifiSettings";
 
+    private WifiWakeupPreferenceController mWifiWakeupPreferenceController;
     private UseOpenWifiPreferenceController mUseOpenWifiPreferenceController;
 
     @Override
@@ -58,8 +58,14 @@ public class ConfigureWifiSettings extends DashboardFragment {
     @Override
     public void onAttach(Context context) {
         super.onAttach(context);
-        mProgressiveDisclosureMixin.setTileLimit(
+        int tileLimit = 1;
-            mUseOpenWifiPreferenceController.isAvailable() ? 3 : 2);
+        if (mWifiWakeupPreferenceController.isAvailable()) {
+            tileLimit++;
+        }
+        if (mUseOpenWifiPreferenceController.isAvailable()) {
+            tileLimit++;
+        }
+        mProgressiveDisclosureMixin.setTileLimit(tileLimit);
     }
 
     @Override
@@ -71,11 +77,13 @@ public class ConfigureWifiSettings extends DashboardFragment {
     protected List<AbstractPreferenceController> getPreferenceControllers(Context context) {
         final NetworkScoreManagerWrapper networkScoreManagerWrapper =
                 new NetworkScoreManagerWrapper(context.getSystemService(NetworkScoreManager.class));
+        mWifiWakeupPreferenceController = new WifiWakeupPreferenceController(
+                context, getLifecycle(), networkScoreManagerWrapper);
         mUseOpenWifiPreferenceController = new UseOpenWifiPreferenceController(context, this,
                 networkScoreManagerWrapper, getLifecycle());
         final WifiManager wifiManager = (WifiManager) getSystemService(WIFI_SERVICE);
         final List<AbstractPreferenceController> controllers = new ArrayList<>();
-        controllers.add(new WifiWakeupPreferenceController(context, getLifecycle()));
+        controllers.add(mWifiWakeupPreferenceController);
         controllers.add(new NetworkScorerPickerPreferenceController(context,
                 networkScoreManagerWrapper));
         controllers.add(new NotifyOpenNetworksPreferenceController(context, getLifecycle()));

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

@@ -8,7 +8,6 @@ import android.content.Context;
 import android.content.Intent;
 import android.database.ContentObserver;
 import android.net.NetworkScoreManager;
-
 import android.net.NetworkScorerAppData;
 import android.net.Uri;
 import android.os.Handler;
@@ -20,14 +19,17 @@ import android.support.v7.preference.Preference;
 import android.support.v7.preference.PreferenceScreen;
 import android.text.TextUtils;
 
-import com.android.settings.network.NetworkScoreManagerWrapper;
+import com.android.settings.R;
 import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settings.network.NetworkScoreManagerWrapper;
 import com.android.settingslib.core.AbstractPreferenceController;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 import com.android.settingslib.core.lifecycle.LifecycleObserver;
 import com.android.settingslib.core.lifecycle.events.OnPause;
 import com.android.settingslib.core.lifecycle.events.OnResume;
 
+import java.util.List;
+
 /**
  * {@link AbstractPreferenceController} that controls whether a user wants to enable the "use open
  * networks automatically" feature provider by the current network recommendation provider.
@@ -45,6 +47,7 @@ public class UseOpenWifiPreferenceController extends AbstractPreferenceControlle
 
     private Preference mPreference;
     private ComponentName mEnableUseWifiComponentName;
+    private boolean mDoFeatureSupportedScorersExist;
 
     public UseOpenWifiPreferenceController(Context context, Fragment fragment,
             NetworkScoreManagerWrapper networkScoreManagerWrapper, Lifecycle lifecycle) {
@@ -54,6 +57,7 @@ public class UseOpenWifiPreferenceController extends AbstractPreferenceControlle
         mNetworkScoreManagerWrapper = networkScoreManagerWrapper;
         mSettingObserver = new SettingObserver();
         updateEnableUseWifiComponentName();
+        checkForFeatureSupportedScorers();
         lifecycle.addObserver(this);
     }
 
@@ -63,6 +67,21 @@ public class UseOpenWifiPreferenceController extends AbstractPreferenceControlle
                 appData == null ? null : appData.getEnableUseOpenWifiActivity();
     }
 
+    private void checkForFeatureSupportedScorers() {
+        if (mEnableUseWifiComponentName != null) {
+            mDoFeatureSupportedScorersExist = true;
+            return;
+        }
+        List<NetworkScorerAppData> scorers = mNetworkScoreManagerWrapper.getAllValidScorers();
+        for (NetworkScorerAppData scorer : scorers) {
+            if (scorer.getEnableUseOpenWifiActivity() != null) {
+                mDoFeatureSupportedScorersExist = true;
+                return;
+            }
+        }
+        mDoFeatureSupportedScorersExist = false;
+    }
+
     @Override
     public void displayPreference(PreferenceScreen screen) {
         super.displayPreference(screen);
@@ -81,7 +100,7 @@ public class UseOpenWifiPreferenceController extends AbstractPreferenceControlle
 
     @Override
     public boolean isAvailable() {
-        return mEnableUseWifiComponentName != null;
+        return mDoFeatureSupportedScorersExist;
     }
 
     @Override
@@ -95,8 +114,23 @@ public class UseOpenWifiPreferenceController extends AbstractPreferenceControlle
             return;
         }
         final SwitchPreference useOpenWifiPreference = (SwitchPreference) preference;
-        useOpenWifiPreference.setVisible(isAvailable());
+
+        boolean isScorerSet = mNetworkScoreManagerWrapper.getActiveScorerPackage() != null;
+        boolean doesActiveScorerSupportFeature = mEnableUseWifiComponentName != null;
+
         useOpenWifiPreference.setChecked(isSettingEnabled());
+        useOpenWifiPreference.setVisible(isAvailable());
+        useOpenWifiPreference.setEnabled(isScorerSet && doesActiveScorerSupportFeature);
+
+        if (!isScorerSet) {
+            useOpenWifiPreference.setSummary(
+                    R.string.use_open_wifi_automatically_summary_scoring_disabled);
+        } else if (!doesActiveScorerSupportFeature) {
+            useOpenWifiPreference.setSummary(
+                    R.string.use_open_wifi_automatically_summary_scorer_unsupported_disabled);
+        } else {
+            useOpenWifiPreference.setSummary(R.string.use_open_wifi_automatically_summary);
+        }
     }
 
     @Override

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

@@ -26,9 +26,10 @@ import android.support.v14.preference.SwitchPreference;
 import android.support.v7.preference.Preference;
 import android.support.v7.preference.PreferenceScreen;
 import android.text.TextUtils;
-import com.android.settings.R;
 
+import com.android.settings.R;
 import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settings.network.NetworkScoreManagerWrapper;
 import com.android.settingslib.core.AbstractPreferenceController;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 import com.android.settingslib.core.lifecycle.LifecycleObserver;
@@ -43,10 +44,13 @@ public class WifiWakeupPreferenceController extends AbstractPreferenceController
         implements PreferenceControllerMixin, LifecycleObserver, OnResume, OnPause {
 
     private static final String KEY_ENABLE_WIFI_WAKEUP = "enable_wifi_wakeup";
+    private final NetworkScoreManagerWrapper mNetworkScoreManager;
     private SettingObserver mSettingObserver;
 
-    public WifiWakeupPreferenceController(Context context, Lifecycle lifecycle) {
+    public WifiWakeupPreferenceController(
+            Context context, Lifecycle lifecycle, NetworkScoreManagerWrapper networkScoreManager) {
         super(context);
+        mNetworkScoreManager = networkScoreManager;
         lifecycle.addObserver(this);
     }
 
@@ -112,11 +116,17 @@ public class WifiWakeupPreferenceController extends AbstractPreferenceController
         boolean networkRecommendationsEnabled = Settings.Global.getInt(
                 mContext.getContentResolver(),
                 Settings.Global.NETWORK_RECOMMENDATIONS_ENABLED, 0) == 1;
-        enableWifiWakeup.setEnabled(networkRecommendationsEnabled && wifiScanningEnabled);
+        boolean activeScorerSet = mNetworkScoreManager.getActiveScorerPackage() != null;
+        enableWifiWakeup.setEnabled(
+                networkRecommendationsEnabled && wifiScanningEnabled && activeScorerSet);
 
-        enableWifiWakeup.setSummary(wifiScanningEnabled ?
+        if (!activeScorerSet) {
-                R.string.wifi_wakeup_summary :
+            enableWifiWakeup.setSummary(R.string.wifi_wakeup_summary_scoring_disabled);
-                R.string.wifi_wakeup_summary_scanning_disabled);
+        } else if (!wifiScanningEnabled) {
+            enableWifiWakeup.setSummary(R.string.wifi_wakeup_summary_scanning_disabled);
+        } else {
+            enableWifiWakeup.setSummary(R.string.wifi_wakeup_summary);
+        }
     }
 
     class SettingObserver extends ContentObserver {

tests/robotests/src/com/android/settings/wifi/UseOpenWifiPreferenceControllerTest.java

@@ -19,12 +19,12 @@ package com.android.settings.wifi;
 import static android.provider.Settings.Global.USE_OPEN_WIFI_PACKAGE;
 import static com.android.settings.wifi.UseOpenWifiPreferenceController.REQUEST_CODE_OPEN_WIFI_AUTOMATICALLY;
 import static com.google.common.truth.Truth.assertThat;
-
 import static org.mockito.Matchers.eq;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import android.annotation.NonNull;
 import android.app.Activity;
 import android.app.Fragment;
 import android.content.ComponentName;
@@ -36,11 +36,13 @@ import android.provider.Settings;
 import android.support.v14.preference.SwitchPreference;
 import android.support.v7.preference.Preference;
 
+import com.android.settings.R;
+import com.android.settings.TestConfig;
 import com.android.settings.network.NetworkScoreManagerWrapper;
 import com.android.settings.testutils.SettingsRobolectricTestRunner;
-import com.android.settings.TestConfig;
 import com.android.settingslib.core.lifecycle.Lifecycle;
 
+import com.google.common.collect.Lists;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -51,10 +53,14 @@ import org.mockito.MockitoAnnotations;
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
 
+import java.util.ArrayList;
+import java.util.List;
+
 @RunWith(SettingsRobolectricTestRunner.class)
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public class UseOpenWifiPreferenceControllerTest {
-    private static ComponentName ENABLE_ACTIVITY_COMPONENT = new ComponentName("package", "activityClass");
+    private static ComponentName ENABLE_ACTIVITY_COMPONENT =
+            new ComponentName("package", "activityClass");
     private static NetworkScorerAppData APP_DATA =
             new NetworkScorerAppData(0, null, null, ENABLE_ACTIVITY_COMPONENT, null);
     private static NetworkScorerAppData APP_DATA_NO_ACTIVITY =
@@ -79,28 +85,45 @@ public class UseOpenWifiPreferenceControllerTest {
                 mContext, mFragment, mNetworkScoreManagerWrapper, mLifecycle);
     }
 
-    @Test
+    /**
-    public void testIsAvailable_noScorer() {
+     * Sets the scorers.
-        when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(null);
+     * @param scorers list of scorers returned by {@link NetworkScoreManager#getAllValidScorers()}.
+     *                First scorer in the list is the active scorer.
+     */
+    private void setupScorers(@NonNull List<NetworkScorerAppData> scorers) {
+        when(mNetworkScoreManagerWrapper.getActiveScorerPackage()).thenReturn(
+                ENABLE_ACTIVITY_COMPONENT.getPackageName());
+        when(mNetworkScoreManagerWrapper.getAllValidScorers()).thenReturn(scorers);
+        when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(scorers.get(0));
+    }
 
+    @Test
+    public void testIsAvailable_returnsFalseWhenNoScorerSet() {
         createController();
 
         assertThat(mController.isAvailable()).isFalse();
     }
 
     @Test
-    public void testIsAvailable_noEnableActivity() {
+    public void testIsAvailable_returnsFalseWhenScorersNotSupported() {
+        setupScorers(Lists.newArrayList(APP_DATA_NO_ACTIVITY));
+        createController();
+
+        assertThat(mController.isAvailable()).isFalse();
+    }
+
+    @Test
+    public void testIsAvailable_returnsTrueIfActiveScorerSupported() {
+        setupScorers(Lists.newArrayList(APP_DATA, APP_DATA_NO_ACTIVITY));
+        createController();
+
+        assertThat(mController.isAvailable()).isTrue();
+    }
+
+    @Test
+    public void testIsAvailable_returnsTrueIfNonActiveScorerSupported() {
+        setupScorers(Lists.newArrayList(APP_DATA_NO_ACTIVITY, APP_DATA));
         when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA_NO_ACTIVITY);
-
-        createController();
-
-        assertThat(mController.isAvailable()).isFalse();
-    }
-
-    @Test
-    public void testIsAvailable_enableActivityExists() {
-        when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA);
-
         createController();
 
         assertThat(mController.isAvailable()).isTrue();
@@ -117,8 +140,6 @@ public class UseOpenWifiPreferenceControllerTest {
 
     @Test
     public void onPreferenceChange_notAvailable_shouldDoNothing() {
-        when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA_NO_ACTIVITY);
-
         createController();
 
         final Preference pref = new Preference(mContext);
@@ -129,7 +150,7 @@ public class UseOpenWifiPreferenceControllerTest {
 
     @Test
     public void onPreferenceChange_matchingKeyAndAvailable_enableShouldStartEnableActivity() {
-        when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA);
+        setupScorers(Lists.newArrayList(APP_DATA, APP_DATA_NO_ACTIVITY));
         createController();
 
         final SwitchPreference pref = new SwitchPreference(mContext);
@@ -145,7 +166,7 @@ public class UseOpenWifiPreferenceControllerTest {
 
     @Test
     public void onPreferenceChange_matchingKeyAndAvailable_disableShouldUpdateSetting() {
-        when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA);
+        setupScorers(Lists.newArrayList(APP_DATA, APP_DATA_NO_ACTIVITY));
         Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,
                 ENABLE_ACTIVITY_COMPONENT.getPackageName());
 
@@ -161,6 +182,7 @@ public class UseOpenWifiPreferenceControllerTest {
 
     @Test
     public void onActivityResult_nonmatchingRequestCode_shouldDoNothing() {
+        setupScorers(Lists.newArrayList(APP_DATA, APP_DATA_NO_ACTIVITY));
         createController();
 
         assertThat(mController.onActivityResult(234 /* requestCode */ , Activity.RESULT_OK))
@@ -171,6 +193,7 @@ public class UseOpenWifiPreferenceControllerTest {
 
     @Test
     public void onActivityResult_matchingRequestCode_nonOkResult_shouldDoNothing() {
+        setupScorers(Lists.newArrayList(APP_DATA, APP_DATA_NO_ACTIVITY));
         createController();
 
         assertThat(mController
@@ -182,7 +205,7 @@ public class UseOpenWifiPreferenceControllerTest {
 
     @Test
     public void onActivityResult_matchingRequestCode_okResult_updatesSetting() {
-        when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA);
+        setupScorers(Lists.newArrayList(APP_DATA, APP_DATA_NO_ACTIVITY));
         createController();
 
         assertThat(mController
@@ -193,8 +216,8 @@ public class UseOpenWifiPreferenceControllerTest {
     }
 
     @Test
-    public void updateState_preferenceSetCheckedAndSetVisibleWhenSettingsAreEnabled() {
+    public void updateState_noEnableActivity_preferenceDisabled_summaryChanged() {
-        when(mNetworkScoreManagerWrapper.getActiveScorer()).thenReturn(APP_DATA);
+        setupScorers(Lists.newArrayList(APP_DATA_NO_ACTIVITY));
         createController();
 
         final SwitchPreference preference = mock(SwitchPreference.class);
@@ -203,19 +226,39 @@ public class UseOpenWifiPreferenceControllerTest {
 
         mController.updateState(preference);
 
-        verify(preference).setVisible(true);
+        verify(preference).setChecked(false);
-        verify(preference).setChecked(true);
+        verify(preference).setSummary(
+                R.string.use_open_wifi_automatically_summary_scorer_unsupported_disabled);
     }
 
     @Test
-    public void updateState_preferenceSetCheckedAndSetVisibleWhenSettingsAreDisabled() {
+    public void updateState_noScorer_preferenceDisabled_summaryChanged() {
-        final SwitchPreference preference = mock(SwitchPreference.class);
+        when(mNetworkScoreManagerWrapper.getAllValidScorers()).thenReturn(new ArrayList<>());
-        Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE, "");
         createController();
 
+        final SwitchPreference preference = mock(SwitchPreference.class);
+        Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,
+                ENABLE_ACTIVITY_COMPONENT.getPackageName());
+
         mController.updateState(preference);
 
-        verify(preference).setVisible(false);
         verify(preference).setChecked(false);
+        verify(preference).setSummary(
+                R.string.use_open_wifi_automatically_summary_scoring_disabled);
+    }
+
+    @Test
+    public void updateState_enableActivityExists_preferenceEnabled() {
+        setupScorers(Lists.newArrayList(APP_DATA, APP_DATA_NO_ACTIVITY));
+        createController();
+
+        final SwitchPreference preference = mock(SwitchPreference.class);
+        Settings.Global.putString(mContext.getContentResolver(), USE_OPEN_WIFI_PACKAGE,
+                ENABLE_ACTIVITY_COMPONENT.getPackageName());
+
+        mController.updateState(preference);
+
+        verify(preference).setChecked(true);
+        verify(preference).setSummary(R.string.use_open_wifi_automatically_summary);
     }
 }

tests/robotests/src/com/android/settings/wifi/WifiWakeupPreferenceControllerTest.java

@@ -23,6 +23,7 @@ import static android.provider.Settings.Global.WIFI_WAKEUP_ENABLED;
 import static com.google.common.truth.Truth.assertThat;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
 
 import android.content.Context;
 import android.provider.Settings;
@@ -30,6 +31,7 @@ import android.support.v14.preference.SwitchPreference;
 import android.support.v7.preference.Preference;
 
 import com.android.settings.R;
+import com.android.settings.network.NetworkScoreManagerWrapper;
 import com.android.settings.testutils.SettingsRobolectricTestRunner;
 import com.android.settings.TestConfig;
 import com.android.settings.testutils.shadow.SettingsShadowResources;
@@ -39,6 +41,7 @@ import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RuntimeEnvironment;
 import org.robolectric.annotation.Config;
@@ -50,17 +53,23 @@ import org.robolectric.annotation.Config;
         shadows = { SettingsShadowResources.class })
 public class WifiWakeupPreferenceControllerTest {
 
+    private static final String TEST_SCORER_PACKAGE_NAME = "Test Scorer";
+
     private Context mContext;
+    @Mock
+    private NetworkScoreManagerWrapper mNetworkScorer;
     private WifiWakeupPreferenceController mController;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         mContext = RuntimeEnvironment.application;
-        mController = new WifiWakeupPreferenceController(mContext, mock(Lifecycle.class));
+        mController = new WifiWakeupPreferenceController(
+                mContext, mock(Lifecycle.class), mNetworkScorer);
         Settings.System.putInt(mContext.getContentResolver(), WIFI_SCAN_ALWAYS_AVAILABLE, 1);
         SettingsShadowResources.overrideResource(
                 com.android.internal.R.integer.config_wifi_wakeup_available, 0);
+        when(mNetworkScorer.getActiveScorerPackage()).thenReturn(TEST_SCORER_PACKAGE_NAME);
     }
 
     @After
@@ -145,4 +154,18 @@ public class WifiWakeupPreferenceControllerTest {
         verify(preference).setEnabled(false);
         verify(preference).setSummary(R.string.wifi_wakeup_summary_scanning_disabled);
     }
+
+    @Test
+    public void updateState_preferenceSetUncheckedAndSetDisabledWhenScoringDisabled() {
+        final SwitchPreference preference = mock(SwitchPreference.class);
+        Settings.System.putInt(mContext.getContentResolver(), NETWORK_RECOMMENDATIONS_ENABLED, 1);
+        Settings.System.putInt(mContext.getContentResolver(), WIFI_WAKEUP_ENABLED, 1);
+        when(mNetworkScorer.getActiveScorerPackage()).thenReturn(null);
+
+        mController.updateState(preference);
+
+        verify(preference).setChecked(true);
+        verify(preference).setEnabled(false);
+        verify(preference).setSummary(R.string.wifi_wakeup_summary_scoring_disabled);
+    }
 }