[Wi-Fi] Apply WifiTrackerLib objects in Wi-Fi Slice

This change uses WifiTrackerLib's WifiPickerTracker & WifiEntry
to replace SettingLib's WifiTracker & AccessPoint.

This change includes

1. WifiScanWorker has the callbacks similar to a lifecycle component
   but it's not a lifecycle component. Let WifiScanWorker implements
   LifecycleOwner and provides #getLifecycle() for WifiPickerTracker.

2. Remove captive portal related code because WifiEntry#connect will
   handle captive portal login if it's necessary.

3. Create WifiSliceItem to wrap WifiEntry because WifiEntry is an
   abstract object and it does not provide copy constructor.
   Without copy construcor, Wi-Fi Slice may show unexpected information
   when a WifiEntry is updated.

4. Use WifiTrackerLib's NetworkDetailsTracker & WifiEntry in
   WifiDialogActivity because it gets a WifiEntry key from Wi-Fi Slice.
   NetworkDetailsTracker can get the WifiEntry of th key.

Bug: 155613549
Bug: 152571756
Test: make RunSettingsRoboTests ROBOTEST_FILTER=com.android.settings.wifi.slice
      make RunSettingsRoboTests ROBOTEST_FILTER=com.android.settings.wifi
Change-Id: I0718f4647cea007a9b701922f3121a388dd43918

tests/robotests/src/com/android/settings/wifi/slice/ConnectToWifiHandlerTest.java

@@ -26,95 +26,69 @@ import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
-import android.net.wifi.WifiConfiguration;
-import android.net.wifi.WifiConfiguration.NetworkSelectionStatus;
-import android.net.wifi.WifiManager;
+import android.content.Intent;
 
-import com.android.settings.testutils.shadow.ShadowWifiManager;
-import com.android.settingslib.wifi.AccessPoint;
+import com.android.settings.wifi.WifiDialogActivity;
+import com.android.wifitrackerlib.WifiEntry;
+import com.android.wifitrackerlib.WifiEntry.ConnectCallback;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
+import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
 import org.robolectric.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
-import org.robolectric.annotation.Config;
 
 @RunWith(RobolectricTestRunner.class)
-@Config(shadows = ShadowWifiManager.class)
 public class ConnectToWifiHandlerTest {
 
     private static final String AP_SSID = "\"ap\"";
     private Context mContext;
     private ConnectToWifiHandler mHandler;
-    private WifiConfiguration mWifiConfig;
     @Mock
-    private AccessPoint mAccessPoint;
+    private WifiScanWorker mWifiScanWorker;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
 
-        mContext = RuntimeEnvironment.application;
-        mHandler = new ConnectToWifiHandler();
-        mWifiConfig = spy(new WifiConfiguration());
-        mWifiConfig.SSID = AP_SSID;
-        doReturn(mWifiConfig).when(mAccessPoint).getConfig();
+        mContext = spy(RuntimeEnvironment.application);
+        mHandler = spy(new ConnectToWifiHandler());
+        doReturn(mWifiScanWorker).when(mHandler).getWifiScanWorker(any());
     }
 
     @Test
-    public void connect_shouldConnectToUnsavedOpenNetwork() {
-        when(mAccessPoint.isSaved()).thenReturn(false);
-        when(mAccessPoint.getSecurity()).thenReturn(AccessPoint.SECURITY_NONE);
+    public void onReceive_nonNullKeyAndUri_shouldConnectWifintry() {
+        final Intent intent = new Intent();
+        final String key = "key";
+        intent.putExtra(ConnectToWifiHandler.KEY_CHOSEN_WIFIENTRY_KEY, key);
+        intent.putExtra(ConnectToWifiHandler.KEY_WIFI_SLICE_URI,
+                com.android.settings.slices.CustomSliceRegistry.WIFI_SLICE_URI);
+        final WifiEntry wifiEntry = mock(WifiEntry.class);
+        when(mWifiScanWorker.getWifiEntry(key)).thenReturn(wifiEntry);
 
-        mHandler.connect(mContext, mAccessPoint);
+        mHandler.onReceive(mContext, intent);
 
-        assertThat(ShadowWifiManager.get().savedWifiConfig.SSID).isEqualTo(AP_SSID);
+        verify(wifiEntry).connect(any());
     }
 
     @Test
-    public void connect_shouldStartOsuProvisioning() {
-        when(mAccessPoint.isSaved()).thenReturn(false);
-        when(mAccessPoint.isOsuProvider()).thenReturn(true);
+    public void onConnectResult_failNoConfig_shouldStartActivity() {
+        final String key = "key";
+        final WifiEntry wifiEntry = mock(WifiEntry.class);
+        when(wifiEntry.getKey()).thenReturn(key);
+        final ConnectToWifiHandler.WifiEntryConnectCallback callback =
+                spy(new ConnectToWifiHandler.WifiEntryConnectCallback(mContext, wifiEntry));
 
-        mHandler.connect(mContext, mAccessPoint);
+        callback.onConnectResult(ConnectCallback.CONNECT_STATUS_FAILURE_NO_CONFIG);
 
-        verify(mAccessPoint).startOsuProvisioning(any(WifiManager.ActionListener.class));
-    }
-
-
-    @Test
-    public void connect_shouldConnectWithPasspointProvider() {
-        when(mAccessPoint.isSaved()).thenReturn(false);
-        when(mAccessPoint.isPasspoint()).thenReturn(true);
-
-        mHandler.connect(mContext, mAccessPoint);
-
-        assertThat(ShadowWifiManager.get().savedWifiConfig.SSID).isEqualTo(AP_SSID);
-    }
-
-    @Test
-    public void connect_shouldConnectToSavedSecuredNetwork() {
-        when(mAccessPoint.isSaved()).thenReturn(true);
-        when(mAccessPoint.getSecurity()).thenReturn(AccessPoint.SECURITY_PSK);
-        final NetworkSelectionStatus status = mock(NetworkSelectionStatus.class);
-        when(status.hasEverConnected()).thenReturn(true);
-        when(mWifiConfig.getNetworkSelectionStatus()).thenReturn(status);
-
-        mHandler.connect(mContext, mAccessPoint);
-
-        assertThat(ShadowWifiManager.get().savedWifiConfig.SSID).isEqualTo(AP_SSID);
-    }
-
-    @Test
-    public void connect_shouldNotConnectToUnsavedSecuredNetwork() {
-        when(mAccessPoint.isSaved()).thenReturn(false);
-        when(mAccessPoint.getSecurity()).thenReturn(AccessPoint.SECURITY_PSK);
-
-        mHandler.connect(mContext, mAccessPoint);
-
-        assertThat(ShadowWifiManager.get().savedWifiConfig).isNull();
+        final ArgumentCaptor<Intent> argument = ArgumentCaptor.forClass(Intent.class);
+        verify(mContext).startActivity(argument.capture());
+        assertThat(argument.getValue().getStringExtra(WifiDialogActivity.KEY_CHOSEN_WIFIENTRY_KEY))
+                .isEqualTo(key);
+        assertThat(argument.getValue().getFlags() & Intent.FLAG_ACTIVITY_NEW_TASK)
+                .isEqualTo(Intent.FLAG_ACTIVITY_NEW_TASK);
     }
 }

tests/robotests/src/com/android/settings/wifi/slice/ContextualWifiScanWorkerTest.java

@@ -1,105 +0,0 @@
-/*
- * Copyright (C) 2019 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.slice;
-
-import static com.android.settings.slices.CustomSliceRegistry.CONTEXTUAL_WIFI_SLICE_URI;
-
-import static org.mockito.ArgumentMatchers.any;
-import static org.mockito.ArgumentMatchers.eq;
-import static org.mockito.Mockito.never;
-import static org.mockito.Mockito.spy;
-import static org.mockito.Mockito.verify;
-
-import android.content.Context;
-import android.content.Intent;
-import android.net.ConnectivityManager;
-import android.net.ConnectivityManager.NetworkCallback;
-import android.net.Network;
-import android.net.wifi.WifiManager;
-import android.os.UserHandle;
-
-import com.android.settings.testutils.shadow.ShadowWifiManager;
-
-import org.junit.After;
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.robolectric.RobolectricTestRunner;
-import org.robolectric.RuntimeEnvironment;
-import org.robolectric.annotation.Config;
-
-@RunWith(RobolectricTestRunner.class)
-@Config(shadows = {
-        ShadowWifiManager.class,
-        WifiScanWorkerTest.ShadowWifiTracker.class,
-})
-public class ContextualWifiScanWorkerTest {
-
-    private Context mContext;
-    private WifiManager mWifiManager;
-    private ConnectivityManager mConnectivityManager;
-    private ContextualWifiScanWorker mWifiScanWorker;
-    private ConnectToWifiHandler mConnectToWifiHandler;
-
-    @Before
-    public void setUp() {
-        mContext = spy(RuntimeEnvironment.application);
-        mWifiManager = mContext.getSystemService(WifiManager.class);
-        mWifiManager.setWifiEnabled(true);
-
-        mConnectivityManager = mContext.getSystemService(ConnectivityManager.class);
-        mWifiScanWorker = new ContextualWifiScanWorker(mContext, CONTEXTUAL_WIFI_SLICE_URI);
-        mConnectToWifiHandler = new ConnectToWifiHandler();
-    }
-
-    @After
-    public void tearDown() {
-        mWifiScanWorker.clearClickedWifi();
-    }
-
-    @Test
-    public void NetworkCallback_onCapabilitiesChanged_sliceIsUnpinned_shouldSendBroadcast() {
-        final Intent intent = WifiScanWorkerTest.getIntentWithAccessPoint("ap1");
-        WifiScanWorkerTest.setConnectionInfoSSID("ap1");
-        final Network network = mConnectivityManager.getActiveNetwork();
-        mWifiScanWorker.registerNetworkCallback(network);
-        final NetworkCallback callback = mWifiScanWorker.mNetworkCallback;
-
-        mWifiScanWorker.onSlicePinned();
-        mConnectToWifiHandler.onReceive(mContext, intent);
-        mWifiScanWorker.onSliceUnpinned();
-        callback.onCapabilitiesChanged(network,
-                WifiSliceTest.makeCaptivePortalNetworkCapabilities());
-
-        verify(mContext).sendBroadcastAsUser(any(Intent.class), eq(UserHandle.CURRENT));
-    }
-
-    @Test
-    public void NetworkCallback_onCapabilitiesChanged_newSession_shouldNotSendBroadcast() {
-        final Intent intent = WifiScanWorkerTest.getIntentWithAccessPoint("ap1");
-        WifiScanWorkerTest.setConnectionInfoSSID("ap1");
-        final Network network = mConnectivityManager.getActiveNetwork();
-        mWifiScanWorker.registerNetworkCallback(network);
-
-        mConnectToWifiHandler.onReceive(mContext, intent);
-        ContextualWifiScanWorker.newVisibleUiSession();
-        mWifiScanWorker.mNetworkCallback.onCapabilitiesChanged(network,
-                WifiSliceTest.makeCaptivePortalNetworkCapabilities());
-
-        verify(mContext, never()).sendBroadcastAsUser(any(Intent.class), eq(UserHandle.CURRENT));
-    }
-}

tests/robotests/src/com/android/settings/wifi/slice/WifiScanWorkerTest.java

@@ -17,216 +17,89 @@
 package com.android.settings.wifi.slice;
 
 import static com.android.settings.slices.CustomSliceRegistry.WIFI_SLICE_URI;
-import static com.android.settings.wifi.WifiDialogActivity.KEY_ACCESS_POINT_STATE;
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.ArgumentMatchers.any;
-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;
 
-import android.content.ContentResolver;
-import android.content.Context;
-import android.content.Intent;
-import android.net.ConnectivityManager;
-import android.net.ConnectivityManager.NetworkCallback;
-import android.net.Network;
-import android.net.NetworkInfo;
-import android.net.NetworkInfo.DetailedState;
-import android.net.wifi.WifiInfo;
-import android.net.wifi.WifiManager;
-import android.os.Bundle;
-import android.os.UserHandle;
+import androidx.lifecycle.Lifecycle;
 
-import com.android.settings.slices.ShadowSliceBackgroundWorker;
-import com.android.settings.testutils.shadow.ShadowWifiManager;
-import com.android.settingslib.wifi.AccessPoint;
-import com.android.settingslib.wifi.WifiTracker;
+import com.android.wifitrackerlib.WifiEntry;
+import com.android.wifitrackerlib.WifiPickerTracker;
 
-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.RobolectricTestRunner;
 import org.robolectric.RuntimeEnvironment;
-import org.robolectric.annotation.Config;
-import org.robolectric.annotation.Implementation;
-import org.robolectric.annotation.Implements;
-import org.robolectric.shadows.ShadowNetworkInfo;
 
-import java.util.ArrayList;
 import java.util.Arrays;
-import java.util.List;
 
 @RunWith(RobolectricTestRunner.class)
-@Config(shadows = {ShadowSliceBackgroundWorker.class, ShadowWifiManager.class,
-        WifiScanWorkerTest.ShadowWifiTracker.class})
 public class WifiScanWorkerTest {
 
-    private Context mContext;
-    private ContentResolver mResolver;
-    private WifiManager mWifiManager;
-    private ConnectivityManager mConnectivityManager;
     private WifiScanWorker mWifiScanWorker;
-    private ConnectToWifiHandler mConnectToWifiHandler;
+    @Mock
+    WifiPickerTracker mWifiPickerTracker;
 
     @Before
     public void setUp() {
-        mContext = spy(RuntimeEnvironment.application);
-        mResolver = mock(ContentResolver.class);
-        doReturn(mResolver).when(mContext).getContentResolver();
-        mWifiManager = mContext.getSystemService(WifiManager.class);
-        mWifiManager.setWifiEnabled(true);
+        MockitoAnnotations.initMocks(this);
 
-        mConnectivityManager = mContext.getSystemService(ConnectivityManager.class);
-        mWifiScanWorker = new WifiScanWorker(mContext, WIFI_SLICE_URI);
-        mConnectToWifiHandler = new ConnectToWifiHandler();
-    }
-
-    @After
-    public void tearDown() {
-        mWifiScanWorker.clearClickedWifi();
+        mWifiScanWorker = new WifiScanWorker(RuntimeEnvironment.application, WIFI_SLICE_URI);
+        mWifiScanWorker.mWifiPickerTracker = mWifiPickerTracker;
     }
 
     @Test
-    public void onWifiStateChanged_shouldNotifyChange() {
-        mWifiScanWorker.onWifiStateChanged(WifiManager.WIFI_STATE_DISABLED);
-
-        verify(mResolver).notifyChange(WIFI_SLICE_URI, null);
+    public void onConstructor_shouldBeInCreatedState() {
+        assertThat(mWifiScanWorker.getLifecycle().getCurrentState())
+                .isEqualTo(Lifecycle.State.CREATED);
     }
 
     @Test
-    public void AccessPointList_sameState_shouldBeTheSame() {
-        final AccessPoint ap1 = createAccessPoint(DetailedState.CONNECTED);
-        final AccessPoint ap2 = createAccessPoint(DetailedState.CONNECTED);
-
-        assertThat(mWifiScanWorker.areListsTheSame(Arrays.asList(ap1), Arrays.asList(ap2)))
-                .isTrue();
-    }
-
-    @Test
-    public void AccessPointList_differentState_shouldBeDifferent() {
-        final AccessPoint ap1 = createAccessPoint(DetailedState.CONNECTING);
-        final AccessPoint ap2 = createAccessPoint(DetailedState.CONNECTED);
-
-        assertThat(mWifiScanWorker.areListsTheSame(Arrays.asList(ap1), Arrays.asList(ap2)))
-                .isFalse();
-    }
-
-    @Test
-    public void AccessPointList_differentListLength_shouldBeDifferent() {
-        final AccessPoint ap1 = createAccessPoint(DetailedState.CONNECTED);
-        final AccessPoint ap2 = createAccessPoint(DetailedState.CONNECTED);
-        final List<AccessPoint> list = new ArrayList<>();
-        list.add(ap1);
-        list.add(ap2);
-
-        assertThat(mWifiScanWorker.areListsTheSame(list, Arrays.asList(ap1))).isFalse();
-    }
-
-    @Test
-    public void NetworkCallback_onCapabilitiesChanged_shouldNotifyChange() {
-        final Network network = mConnectivityManager.getActiveNetwork();
-        mWifiScanWorker.registerNetworkCallback(network);
-
-        mWifiScanWorker.mNetworkCallback.onCapabilitiesChanged(network,
-                WifiSliceTest.makeCaptivePortalNetworkCapabilities());
-
-        verify(mResolver).notifyChange(WIFI_SLICE_URI, null);
-    }
-
-    @Test
-    public void NetworkCallback_onCapabilitiesChanged_isClickedWifi_shouldSendBroadcast() {
-        final Intent intent = getIntentWithAccessPoint("ap1");
-        setConnectionInfoSSID("ap1");
-        final Network network = mConnectivityManager.getActiveNetwork();
-        mWifiScanWorker.registerNetworkCallback(network);
-
-        mConnectToWifiHandler.onReceive(mContext, intent);
-        mWifiScanWorker.mNetworkCallback.onCapabilitiesChanged(network,
-                WifiSliceTest.makeCaptivePortalNetworkCapabilities());
-
-        verify(mContext).sendBroadcastAsUser(any(Intent.class), eq(UserHandle.CURRENT));
-    }
-
-    @Test
-    public void NetworkCallback_onCapabilitiesChanged_isNotClickedWifi_shouldNotSendBroadcast() {
-        final Intent intent = getIntentWithAccessPoint("ap1");
-        setConnectionInfoSSID("ap2");
-        final Network network = mConnectivityManager.getActiveNetwork();
-        mWifiScanWorker.registerNetworkCallback(network);
-
-        mConnectToWifiHandler.onReceive(mContext, intent);
-        mWifiScanWorker.mNetworkCallback.onCapabilitiesChanged(network,
-                WifiSliceTest.makeCaptivePortalNetworkCapabilities());
-
-        verify(mContext, never()).sendBroadcastAsUser(any(Intent.class), eq(UserHandle.CURRENT));
-    }
-
-    @Test
-    public void NetworkCallback_onCapabilitiesChanged_neverClickWifi_shouldNotSendBroadcast() {
-        setConnectionInfoSSID("ap1");
-        final Network network = mConnectivityManager.getActiveNetwork();
-        mWifiScanWorker.registerNetworkCallback(network);
-
-        mWifiScanWorker.mNetworkCallback.onCapabilitiesChanged(network,
-                WifiSliceTest.makeCaptivePortalNetworkCapabilities());
-
-        verify(mContext, never()).sendBroadcastAsUser(any(Intent.class), eq(UserHandle.CURRENT));
-    }
-
-    @Test
-    public void NetworkCallback_onCapabilitiesChanged_sliceIsUnpinned_shouldNotSendBroadcast() {
-        final Intent intent = getIntentWithAccessPoint("ap1");
-        setConnectionInfoSSID("ap1");
-        final Network network = mConnectivityManager.getActiveNetwork();
-        mWifiScanWorker.registerNetworkCallback(network);
-        final NetworkCallback callback = mWifiScanWorker.mNetworkCallback;
-
+    public void onSlicePinned_shouldBeInResumedState() {
         mWifiScanWorker.onSlicePinned();
-        mConnectToWifiHandler.onReceive(mContext, intent);
+
+        assertThat(mWifiScanWorker.getLifecycle().getCurrentState())
+                .isEqualTo(Lifecycle.State.RESUMED);
+    }
+
+    @Test
+    public void onSliceUnpinned_shouldBeInCreatedState() {
         mWifiScanWorker.onSliceUnpinned();
-        callback.onCapabilitiesChanged(network,
-                WifiSliceTest.makeCaptivePortalNetworkCapabilities());
 
-        verify(mContext, never()).sendBroadcastAsUser(any(Intent.class), eq(UserHandle.CURRENT));
+        assertThat(mWifiScanWorker.getLifecycle().getCurrentState())
+                .isEqualTo(Lifecycle.State.CREATED);
     }
 
-    static Intent getIntentWithAccessPoint(String ssid) {
-        final Bundle savedState = new Bundle();
-        savedState.putString("key_ssid", ssid);
-        return new Intent().putExtra(KEY_ACCESS_POINT_STATE, savedState);
+    @Test
+    public void close_shouldBeInDestroyedState() {
+        mWifiScanWorker.close();
+
+        assertThat(mWifiScanWorker.getLifecycle().getCurrentState())
+                .isEqualTo(Lifecycle.State.DESTROYED);
     }
 
-    static void setConnectionInfoSSID(String ssid) {
-        final WifiInfo wifiInfo = mock(WifiInfo.class);
-        when(wifiInfo.getSSID()).thenReturn(ssid);
-        ShadowWifiManager.get().setConnectionInfo(wifiInfo);
+    @Test
+    public void getWifiEntry_connectedWifiKey_shouldGetConnectedWifi() {
+        final String key = "key";
+        final WifiEntry connectedWifiEntry = mock(WifiEntry.class);
+        when(connectedWifiEntry.getKey()).thenReturn(key);
+        when(mWifiPickerTracker.getConnectedWifiEntry()).thenReturn(connectedWifiEntry);
+
+        assertThat(mWifiScanWorker.getWifiEntry(key)).isEqualTo(connectedWifiEntry);
     }
 
-    private AccessPoint createAccessPoint(String ssid, DetailedState detailedState) {
-        final NetworkInfo info = ShadowNetworkInfo.newInstance(detailedState, 1 /* type */,
-                0 /*subType */, true /* isAvailable */, true /* isConnected */);
-        final Bundle savedState = new Bundle();
-        savedState.putString("key_ssid", ssid);
-        savedState.putParcelable("key_networkinfo", info);
-        return new AccessPoint(mContext, savedState);
-    }
+    @Test
+    public void getWifiEntry_reachableWifiKey_shouldGetReachableWifi() {
+        final String key = "key";
+        final WifiEntry reachableWifiEntry = mock(WifiEntry.class);
+        when(reachableWifiEntry.getKey()).thenReturn(key);
+        when(mWifiPickerTracker.getWifiEntries()).thenReturn(Arrays.asList(reachableWifiEntry));
 
-    private AccessPoint createAccessPoint(DetailedState detailedState) {
-        return createAccessPoint("ap", detailedState);
-    }
-
-    @Implements(WifiTracker.class)
-    public static class ShadowWifiTracker {
-        @Implementation
-        public void onStart() {
-            // do nothing
-        }
+        assertThat(mWifiScanWorker.getWifiEntry(key)).isEqualTo(reachableWifiEntry);
     }
 }

tests/robotests/src/com/android/settings/wifi/slice/WifiSliceTest.java

@@ -23,17 +23,14 @@ import static com.android.settings.wifi.slice.WifiSlice.DEFAULT_EXPANDED_ROW_COU
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.doReturn;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
 
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
-import android.net.ConnectivityManager;
-import android.net.NetworkCapabilities;
-import android.net.NetworkInfo;
 import android.net.Uri;
 import android.net.wifi.WifiManager;
 
@@ -49,7 +46,8 @@ import androidx.slice.widget.SliceLiveData;
 import com.android.settings.R;
 import com.android.settings.slices.SliceBackgroundWorker;
 import com.android.settings.testutils.SliceTester;
-import com.android.settingslib.wifi.AccessPoint;
+import com.android.wifitrackerlib.WifiEntry;
+import com.android.wifitrackerlib.WifiEntry.ConnectedState;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -74,7 +72,6 @@ public class WifiSliceTest {
     private Context mContext;
     private ContentResolver mResolver;
     private WifiManager mWifiManager;
-    private ConnectivityManager mConnectivityManager;
     private WifiSlice mWifiSlice;
 
     @Before
@@ -88,9 +85,6 @@ public class WifiSliceTest {
         SliceProvider.setSpecs(SliceLiveData.SUPPORTED_SPECS);
         mWifiManager.setWifiEnabled(true);
 
-        mConnectivityManager = spy(mContext.getSystemService(ConnectivityManager.class));
-        doReturn(mConnectivityManager).when(mContext).getSystemService(ConnectivityManager.class);
-
         mWifiSlice = new WifiSlice(mContext);
     }
 
@@ -138,33 +132,42 @@ public class WifiSliceTest {
                 mContext.getString(R.string.wifi_empty_list_wifi_on));
     }
 
-    private AccessPoint createAccessPoint(String name, boolean active, boolean reachable) {
-        final AccessPoint accessPoint = mock(AccessPoint.class);
-        doReturn(name).when(accessPoint).getTitle();
-        doReturn(active).when(accessPoint).isActive();
-        doReturn(reachable).when(accessPoint).isReachable();
-        if (active) {
-            final NetworkInfo networkInfo = mock(NetworkInfo.class);
-            doReturn(networkInfo).when(accessPoint).getNetworkInfo();
-            doReturn(NetworkInfo.State.CONNECTED).when(networkInfo).getState();
-        }
-        return accessPoint;
+    private WifiSliceItem createWifiSliceItem(String title, @ConnectedState int connectedState) {
+        final WifiEntry wifiEntry = mock(WifiEntry.class);
+        when(wifiEntry.getTitle()).thenReturn(title);
+        when(wifiEntry.getKey()).thenReturn("key");
+        when(wifiEntry.getConnectedState()).thenReturn(connectedState);
+        when(wifiEntry.getLevel()).thenReturn(WifiEntry.WIFI_LEVEL_MAX);
+        return new WifiSliceItem(mContext, wifiEntry);
     }
 
-    private void setWorkerResults(AccessPoint... accessPoints) {
-        final ArrayList<AccessPoint> results = new ArrayList<>();
-        for (AccessPoint ap : accessPoints) {
-            results.add(ap);
+    private void setWorkerResults(WifiSliceItem... wifiSliceItems) {
+        final ArrayList<WifiSliceItem> results = new ArrayList<>();
+        for (WifiSliceItem wifiSliceItem : wifiSliceItems) {
+            results.add(wifiSliceItem);
         }
         final SliceBackgroundWorker worker = SliceBackgroundWorker.getInstance(mWifiSlice.getUri());
         doReturn(results).when(worker).getResults();
     }
 
     @Test
-    public void getWifiSlice_noReachableAp_shouldReturnLoadingRow() {
+    public void getWifiSlice_oneConnectedAp_shouldReturnLoadingRow() {
+        setWorkerResults(createWifiSliceItem(AP1_NAME, WifiEntry.CONNECTED_STATE_CONNECTED));
+
+        final Slice wifiSlice = mWifiSlice.getSlice();
+        final List<SliceItem> sliceItems = wifiSlice.getItems();
+
+        SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
+        // Has scanning text
+        SliceTester.assertAnySliceItemContainsSubtitle(sliceItems,
+                mContext.getString(R.string.wifi_empty_list_wifi_on));
+    }
+
+    @Test
+    public void getWifiSlice_oneConnectedApAndOneDisconnectedAp_shouldReturnLoadingRow() {
         setWorkerResults(
-                createAccessPoint(AP1_NAME, false, false),
-                createAccessPoint(AP2_NAME, false, false));
+                createWifiSliceItem(AP1_NAME, WifiEntry.CONNECTED_STATE_CONNECTED),
+                createWifiSliceItem(AP2_NAME, WifiEntry.CONNECTED_STATE_DISCONNECTED));
 
         final Slice wifiSlice = mWifiSlice.getSlice();
         final List<SliceItem> sliceItems = wifiSlice.getItems();
@@ -177,8 +180,8 @@ public class WifiSliceTest {
     }
 
     @Test
-    public void getWifiSlice_oneActiveAp_shouldReturnLoadingRow() {
-        setWorkerResults(createAccessPoint(AP1_NAME, true, true));
+    public void getWifiSlice_oneDisconnectedAp_shouldReturnLoadingRow() {
+        setWorkerResults(createWifiSliceItem(AP1_NAME, WifiEntry.CONNECTED_STATE_DISCONNECTED));
 
         final Slice wifiSlice = mWifiSlice.getSlice();
         final List<SliceItem> sliceItems = wifiSlice.getItems();
@@ -190,40 +193,11 @@ public class WifiSliceTest {
     }
 
     @Test
-    public void getWifiSlice_oneActiveApAndOneUnreachableAp_shouldReturnLoadingRow() {
+    public void getWifiSlice_apReachExpandedCount_shouldNotReturnLoadingRow() {
         setWorkerResults(
-                createAccessPoint(AP1_NAME, true, true),
-                createAccessPoint(AP2_NAME, false, false));
-
-        final Slice wifiSlice = mWifiSlice.getSlice();
-        final List<SliceItem> sliceItems = wifiSlice.getItems();
-
-        SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
-        SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP2_NAME);
-        // Has scanning text
-        SliceTester.assertAnySliceItemContainsSubtitle(sliceItems,
-                mContext.getString(R.string.wifi_empty_list_wifi_on));
-    }
-
-    @Test
-    public void getWifiSlice_oneReachableAp_shouldReturnLoadingRow() {
-        setWorkerResults(createAccessPoint(AP1_NAME, false, true));
-
-        final Slice wifiSlice = mWifiSlice.getSlice();
-        final List<SliceItem> sliceItems = wifiSlice.getItems();
-
-        SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
-        // Has scanning text
-        SliceTester.assertAnySliceItemContainsSubtitle(sliceItems,
-                mContext.getString(R.string.wifi_empty_list_wifi_on));
-    }
-
-    @Test
-    public void getWifiSlice_allReachableAps_shouldNotReturnLoadingRow() {
-        setWorkerResults(
-                createAccessPoint(AP1_NAME, false, true),
-                createAccessPoint(AP2_NAME, false, true),
-                createAccessPoint(AP3_NAME, false, true));
+                createWifiSliceItem(AP1_NAME, WifiEntry.CONNECTED_STATE_DISCONNECTED),
+                createWifiSliceItem(AP2_NAME, WifiEntry.CONNECTED_STATE_DISCONNECTED),
+                createWifiSliceItem(AP3_NAME, WifiEntry.CONNECTED_STATE_DISCONNECTED));
 
         final Slice wifiSlice = mWifiSlice.getSlice();
         final List<SliceItem> sliceItems = wifiSlice.getItems();
@@ -236,29 +210,6 @@ public class WifiSliceTest {
                 mContext.getString(R.string.wifi_empty_list_wifi_on));
     }
 
-    @Test
-    public void getWifiSlice_isCaptivePortal_shouldHaveCaptivePortalItems() {
-        setWorkerResults(createAccessPoint(AP1_NAME, true, true));
-        doReturn(makeCaptivePortalNetworkCapabilities()).when(mConnectivityManager)
-                .getNetworkCapabilities(any());
-        final IconCompat expectedIcon = IconCompat.createWithResource(mContext,
-                R.drawable.ic_settings_accent);
-
-        final Slice wifiSlice = mWifiSlice.getSlice();
-        final List<SliceItem> sliceItems = wifiSlice.getItems();
-
-        SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
-        SliceTester.assertAnySliceItemContainsIcon(sliceItems, expectedIcon);
-    }
-
-    static NetworkCapabilities makeCaptivePortalNetworkCapabilities() {
-        final NetworkCapabilities nc = new NetworkCapabilities();
-        nc.clearAll();
-        nc.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);
-        nc.addCapability(NetworkCapabilities.NET_CAPABILITY_CAPTIVE_PORTAL);
-        return nc;
-    }
-
     @Test
     public void handleUriChange_updatesWifi() {
         final Intent intent = mWifiSlice.getIntent();