Leverage the behavior of showing the searching message in wifi slice

Fixes: 124823973
Test: robotest
Change-Id: Id89ec5ef09f05f83e019a6f4488cacf2ab4e635b

src/com/android/settings/wifi/slice/WifiSlice.java

@@ -118,10 +118,19 @@ public class WifiSlice implements CustomSliceable {
 
         final SliceBackgroundWorker worker = SliceBackgroundWorker.getInstance(getUri());
         final List<AccessPoint> results = worker != null ? worker.getResults() : null;
+        final int apCount = results == null ? 0 : results.size();
 
-        // Need a loading text when results are not ready.
+        // Need a loading text when results are not ready or out of date.
-        boolean needLoadingRow = results == null;
+        boolean needLoadingRow = true;
-        final int apCount = needLoadingRow ? 0 : results.size();
+        int index = apCount > 0 && results.get(0).isActive() ? 1 : 0;
+        // This loop checks the existence of reachable APs to determine the validity of the current
+        // AP list.
+        for (; index < apCount; index++) {
+            if (results.get(index).isReachable()) {
+                needLoadingRow = false;
+                break;
+            }
+        }
 
         // Add AP rows
         final CharSequence placeholder = mContext.getText(R.string.summary_placeholder);

tests/robotests/src/com/android/settings/testutils/SliceTester.java

@@ -253,6 +253,18 @@ public class SliceTester {
         assertThat(hasText(sliceItems, subtitle, null /* hints */)).isTrue();
     }
 
+    /**
+     * Assert no slice item contains subtitle.
+     *
+     * @param sliceItems All slice items of a Slice.
+     * @param subtitle Subtitle for asserting.
+     */
+    public static void assertNoSliceItemContainsSubtitle(List<SliceItem> sliceItems,
+            String subtitle) {
+        // Subtitle has no hints
+        assertThat(hasText(sliceItems, subtitle, null /* hints */)).isFalse();
+    }
+
     private static boolean hasText(List<SliceItem> sliceItems, String text, String hints) {
         boolean hasText = false;
         for (SliceItem item : sliceItems) {

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

@@ -21,6 +21,7 @@ import static android.app.slice.SliceItem.FORMAT_SLICE;
 
 import static com.android.settings.slices.CustomSliceRegistry.WIFI_SLICE_URI;
 import static com.android.settings.wifi.slice.WifiSlice.DEFAULT_EXPANDED_ROW_COUNT;
+import static com.android.settings.wifi.slice.WifiSlice.WifiScanWorker;
 
 import static com.google.common.truth.Truth.assertThat;
 
@@ -32,6 +33,8 @@ import static org.mockito.Mockito.verify;
 import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
+import android.net.NetworkInfo;
+import android.net.Uri;
 import android.net.wifi.WifiManager;
 
 import androidx.core.graphics.drawable.IconCompat;
@@ -44,24 +47,33 @@ import androidx.slice.core.SliceQuery;
 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 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;
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
 
+import java.util.ArrayList;
 import java.util.List;
 
 @RunWith(RobolectricTestRunner.class)
 public class WifiSliceTest {
 
+    private static final String AP1_NAME = "ap1";
+    private static final String AP2_NAME = "ap2";
+
     private Context mContext;
     private ContentResolver mResolver;
     private WifiManager mWifiManager;
     private WifiSlice mWifiSlice;
-    private WifiSlice.WifiScanWorker mWifiScanWorker;
+    private WifiScanWorker mWifiScanWorker;
 
     @Before
     public void setUp() {
@@ -75,7 +87,7 @@ public class WifiSliceTest {
         mWifiManager.setWifiEnabled(true);
 
         mWifiSlice = new WifiSlice(mContext);
-        mWifiScanWorker = new WifiSlice.WifiScanWorker(mContext, WIFI_SLICE_URI);
+        mWifiScanWorker = new WifiScanWorker(mContext, WIFI_SLICE_URI);
     }
 
     @Test
@@ -122,6 +134,107 @@ 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).getConfigName();
+        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 void setWorkerResults(AccessPoint... accessPoints) {
+        final ArrayList<AccessPoint> results = new ArrayList<>();
+        for (AccessPoint ap : accessPoints) {
+            results.add(ap);
+        }
+        final SliceBackgroundWorker worker = SliceBackgroundWorker.getInstance(mWifiSlice.getUri());
+        doReturn(results).when(worker).getResults();
+    }
+
+    @Test
+    @Config(shadows = ShadowSliceBackgroundWorker.class)
+    public void getWifiSlice_noReachableAp_shouldReturnLoadingRow() {
+        setWorkerResults(
+                createAccessPoint(AP1_NAME, false, false),
+                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
+    @Config(shadows = ShadowSliceBackgroundWorker.class)
+    public void getWifiSlice_oneActiveAp_shouldReturnLoadingRow() {
+        setWorkerResults(createAccessPoint(AP1_NAME, true, 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
+    @Config(shadows = ShadowSliceBackgroundWorker.class)
+    public void getWifiSlice_oneActiveApAndOneUnreachableAp_shouldReturnLoadingRow() {
+        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
+    @Config(shadows = ShadowSliceBackgroundWorker.class)
+    public void getWifiSlice_oneReachableAp_shouldNotReturnLoadingRow() {
+        setWorkerResults(createAccessPoint(AP1_NAME, false, true));
+        final Slice wifiSlice = mWifiSlice.getSlice();
+
+        final List<SliceItem> sliceItems = wifiSlice.getItems();
+
+        SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
+        // No scanning text
+        SliceTester.assertNoSliceItemContainsSubtitle(sliceItems,
+                mContext.getString(R.string.wifi_empty_list_wifi_on));
+    }
+
+    @Test
+    @Config(shadows = ShadowSliceBackgroundWorker.class)
+    public void getWifiSlice_allReachableAps_shouldNotReturnLoadingRow() {
+        setWorkerResults(
+                createAccessPoint(AP1_NAME, false, true),
+                createAccessPoint(AP2_NAME, false, true));
+        final Slice wifiSlice = mWifiSlice.getSlice();
+
+        final List<SliceItem> sliceItems = wifiSlice.getItems();
+
+        SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP1_NAME);
+        SliceTester.assertAnySliceItemContainsTitle(sliceItems, AP2_NAME);
+        // No scanning text
+        SliceTester.assertNoSliceItemContainsSubtitle(sliceItems,
+                mContext.getString(R.string.wifi_empty_list_wifi_on));
+    }
+
     @Test
     public void handleUriChange_updatesWifi() {
         final Intent intent = mWifiSlice.getIntent();
@@ -146,4 +259,14 @@ public class WifiSliceTest {
 
         verify(mResolver).notifyChange(WIFI_SLICE_URI, null);
     }
+
+    @Implements(SliceBackgroundWorker.class)
+    public static class ShadowSliceBackgroundWorker {
+        private static WifiScanWorker mWifiScanWorker = mock(WifiScanWorker.class);
+
+        @Implementation
+        public static SliceBackgroundWorker getInstance(Uri uri) {
+            return mWifiScanWorker;
+        }
+    }
 }