Merge "[Wi-Fi] Add Wifitracker mechanism to update the signal icon."

src/com/android/settings/wifi/addappnetworks/AddAppNetworksFragment.java

@@ -53,15 +53,20 @@ import com.android.internal.annotations.VisibleForTesting;
 import com.android.settings.R;
 import com.android.settings.Utils;
 import com.android.settings.core.InstrumentedFragment;
+import com.android.settingslib.wifi.AccessPoint;
+import com.android.settingslib.wifi.WifiTracker;
+import com.android.settingslib.wifi.WifiTrackerFactory;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Optional;
 
 /**
  * The Fragment list those networks, which is proposed by other app, to user, and handle user's
  * choose on either saving those networks or rejecting the request.
  */
-public class AddAppNetworksFragment extends InstrumentedFragment {
+public class AddAppNetworksFragment extends InstrumentedFragment implements
+        WifiTracker.WifiListener {
     public static final String TAG = "AddAppNetworksFragment";
 
     // Possible result values in each item of the returned result list, which is used
@@ -78,8 +83,9 @@ public class AddAppNetworksFragment extends InstrumentedFragment {
     private static final int MESSAGE_SHOW_SAVE_FAILED = 3;
     private static final int MESSAGE_FINISH = 4;
 
-    // Signal level for the constant signal icon.
+    // Signal level for the initial signal icon.
-    private static final int MAX_RSSI_SIGNAL_LEVEL = 4;
+    @VisibleForTesting
+    static final int INITIAL_RSSI_SIGNAL_LEVEL = 0;
     // Max networks count within one request
     private static final int MAX_SPECIFIC_NETWORKS_COUNT = 5;
 
@@ -103,6 +109,8 @@ public class AddAppNetworksFragment extends InstrumentedFragment {
     List<UiConfigurationItem> mUiToRequestedList;
     @VisibleForTesting
     List<Integer> mResultCodeArrayList;
+    @VisibleForTesting
+    WifiTracker mWifiTracker;
 
     private boolean mIsSingleNetwork;
     private boolean mAnyNetworkSavedSuccess;
@@ -156,6 +164,8 @@ public class AddAppNetworksFragment extends InstrumentedFragment {
             @Nullable Bundle savedInstanceState) {
         mActivity = getActivity();
         mWifiManager = mActivity.getSystemService(WifiManager.class);
+        mWifiTracker = WifiTrackerFactory.create(mActivity.getApplication(), this,
+                getSettingsLifecycle(), true /* includeSaved */, true /* includeScans */);
 
         return inflater.inflate(R.layout.wifi_add_app_networks, container, false);
     }
@@ -223,7 +233,7 @@ public class AddAppNetworksFragment extends InstrumentedFragment {
             mLayoutView.findViewById(R.id.single_network).setVisibility(View.VISIBLE);
 
             // Show signal icon for single network case.
-            setSingleNetworkSignalIcon();
+            updateSingleNetworkSignalIcon(INITIAL_RSSI_SIGNAL_LEVEL);
             // Show the SSID of the proposed network.
             ((TextView) mLayoutView.findViewById(R.id.single_ssid)).setText(
                     mUiToRequestedList.get(0).mDisplayedSsid);
@@ -366,18 +376,18 @@ public class AddAppNetworksFragment extends InstrumentedFragment {
                 mResultCodeArrayList.set(networkPositionInBundle, RESULT_NETWORK_ALREADY_EXISTS);
             } else {
                 // Prepare to add to UI list to show to user
-                UiConfigurationItem uiConfigurationIcon = new UiConfigurationItem(displayedName,
+                UiConfigurationItem uiConfigurationItem = new UiConfigurationItem(displayedName,
-                        suggestion, networkPositionInBundle);
+                        suggestion, networkPositionInBundle, INITIAL_RSSI_SIGNAL_LEVEL);
-                mUiToRequestedList.add(uiConfigurationIcon);
+                mUiToRequestedList.add(uiConfigurationItem);
             }
             networkPositionInBundle++;
         }
     }
 
-    private void setSingleNetworkSignalIcon() {
+    private void updateSingleNetworkSignalIcon(int level) {
         // TODO: Check level of the network to show signal icon.
         final Drawable wifiIcon = mActivity.getDrawable(
-                Utils.getWifiIconResource(MAX_RSSI_SIGNAL_LEVEL)).mutate();
+                Utils.getWifiIconResource(level)).mutate();
         final Drawable wifiIconDark = wifiIcon.getConstantState().newDrawable().mutate();
         wifiIconDark.setTintList(
                 Utils.getColorAttr(mActivity, android.R.attr.colorControlNormal));
@@ -472,12 +482,14 @@ public class AddAppNetworksFragment extends InstrumentedFragment {
         public final String mDisplayedSsid;
         public final WifiNetworkSuggestion mWifiNetworkSuggestion;
         public final int mIndex;
+        public int mLevel;
 
         UiConfigurationItem(String displayedSsid, WifiNetworkSuggestion wifiNetworkSuggestion,
-                int index) {
+                int index, int level) {
             mDisplayedSsid = displayedSsid;
             mWifiNetworkSuggestion = wifiNetworkSuggestion;
             mIndex = index;
+            mLevel = level;
         }
     }
 
@@ -515,7 +527,8 @@ public class AddAppNetworksFragment extends InstrumentedFragment {
             final PreferenceImageView imageView = view.findViewById(android.R.id.icon);
             if (imageView != null) {
                 final Drawable drawable = getContext().getDrawable(
-                        com.android.settingslib.Utils.getWifiIconResource(MAX_RSSI_SIGNAL_LEVEL));
+                        com.android.settingslib.Utils.getWifiIconResource(
+                                uiConfigurationItem.mLevel));
                 drawable.setTintList(
                         com.android.settingslib.Utils.getColorAttr(getContext(),
                                 android.R.attr.colorControlNormal));
@@ -700,4 +713,46 @@ public class AddAppNetworksFragment extends InstrumentedFragment {
                 break;
         }
     }
+
+    @Override
+    public void onWifiStateChanged(int state) {
+        // Do nothing
+    }
+
+    @Override
+    public void onConnectedChanged() {
+        // Do nothing
+    }
+
+    @VisibleForTesting
+    void updateScanResults(List<AccessPoint> allAccessPoints) {
+        if (mUiToRequestedList == null) {
+            // Nothing need to be updated.
+            return;
+        }
+
+        // Update the signal level of the UI networks.
+        for (UiConfigurationItem uiConfigurationItem : mUiToRequestedList) {
+            final Optional<AccessPoint> matchedAccessPoint = allAccessPoints
+                    .stream()
+                    .filter(accesspoint -> accesspoint.matches(
+                            uiConfigurationItem.mWifiNetworkSuggestion.wifiConfiguration))
+                    .findFirst();
+            uiConfigurationItem.mLevel =
+                    matchedAccessPoint.isPresent() ? matchedAccessPoint.get().getLevel() : 0;
+        }
+
+        if (mIsSingleNetwork) {
+            updateSingleNetworkSignalIcon(mUiToRequestedList.get(0).mLevel);
+        } else {
+            if (mUiConfigurationItemAdapter != null) {
+                mUiConfigurationItemAdapter.notifyDataSetChanged();
+            }
+        }
+    }
+
+    @Override
+    public void onAccessPointsChanged() {
+        updateScanResults(mWifiTracker.getAccessPoints());
+    }
 }

tests/robotests/src/com/android/settings/wifi/addappnetworks/AddAppNetworksFragmentTest.java

@@ -18,8 +18,11 @@ package com.android.settings.wifi.addappnetworks;
 
 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.spy;
+import static org.mockito.Mockito.when;
 
 import android.app.settings.SettingsEnums;
 import android.net.wifi.WifiConfiguration;
@@ -32,10 +35,15 @@ import android.widget.TextView;
 import androidx.annotation.NonNull;
 
 import com.android.settings.R;
+import com.android.settingslib.wifi.AccessPoint;
+import com.android.settingslib.wifi.WifiTracker;
+import com.android.settingslib.wifi.WifiTrackerFactory;
 
 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.shadows.androidx.fragment.FragmentController;
 
@@ -49,6 +57,9 @@ public class AddAppNetworksFragmentTest {
     private static final String FAKE_NEW_OPEN_SSID = "fake_new_open_ssid";
     private static final String FAKE_NEW_OPEN_SSID_WITH_QUOTE = "\"fake_new_open_ssid\"";
     private static final String FAKE_NEW_SAVED_WPA_SSID = "\"fake_new_wpa_ssid\"";
+    private static final String KEY_SSID = "key_ssid";
+    private static final String KEY_SECURITY = "key_security";
+    private static final int SCANED_LEVEL = 4;
 
     private AddAppNetworksFragment mAddAppNetworksFragment;
     private List<WifiNetworkSuggestion> mFakedSpecifiedNetworksList;
@@ -59,8 +70,15 @@ public class AddAppNetworksFragmentTest {
     private Bundle mBundle;
     private ArrayList<Integer> mFakedResultArrayList = new ArrayList<>();
 
+    @Mock
+    private AccessPoint mMockAccessPoint;
+
+    @Mock
+    private WifiTracker mMockWifiTracker;
+
     @Before
     public void setUp() {
+        MockitoAnnotations.initMocks(this);
         mAddAppNetworksFragment = spy(new AddAppNetworksFragment());
         mNewWpaSuggestionEntry = generateRegularWifiSuggestion(FAKE_NEW_WPA_SSID,
                 WifiConfiguration.KeyMgmt.WPA_PSK, "1234567890");
@@ -68,6 +86,10 @@ public class AddAppNetworksFragmentTest {
                 WifiConfiguration.KeyMgmt.NONE, null);
         mSavedWpaConfigurationEntry = generateRegularWifiConfiguration(FAKE_NEW_SAVED_WPA_SSID,
                 WifiConfiguration.KeyMgmt.WPA_PSK, "\"1234567890\"");
+        mAddAppNetworksFragment.mWifiTracker = mMockWifiTracker;
+        WifiTrackerFactory.setTestingWifiTracker(mMockWifiTracker);
+
+        setUpOneScannedNetworkWithScanedLevel();
     }
 
     @Test
@@ -165,6 +187,52 @@ public class AddAppNetworksFragmentTest {
         assertThat(mAddAppNetworksFragment.mUiToRequestedList).hasSize(3);
     }
 
+    @Test
+    public void withOneSuggestion_uiElementShouldHaveInitLevel() {
+        // Arrange
+        // Setup a fake saved network list and assign to fragment.
+        addOneSavedNetworkConfiguration(mSavedWpaConfigurationEntry);
+        // Setup one specified networks and its results and assign to fragment.
+        addOneSpecifiedRegularNetworkSuggestion(mNewOpenSuggestionEntry);
+        mAddAppNetworksFragment.mAllSpecifiedNetworksList = mFakedSpecifiedNetworksList;
+
+        // Act
+        mAddAppNetworksFragment.filterSavedNetworks(mFakeSavedNetworksList);
+
+        // Assert
+        assertThat(mAddAppNetworksFragment.mUiToRequestedList).hasSize(1);
+        assertThat(mAddAppNetworksFragment.mUiToRequestedList.get(0).mLevel).isEqualTo(
+                mAddAppNetworksFragment.INITIAL_RSSI_SIGNAL_LEVEL);
+    }
+
+    @Test
+    public void withOneSuggestion_whenScanResultChanged_uiListShouldHaveNewLevel() {
+        // Arrange
+        // Setup a fake saved network list and assign to fragment.
+        addOneSavedNetworkConfiguration(mSavedWpaConfigurationEntry);
+        // Setup one specified networks and its results and assign to fragment.
+        addOneSpecifiedRegularNetworkSuggestion(mNewOpenSuggestionEntry);
+        mAddAppNetworksFragment.mAllSpecifiedNetworksList = mFakedSpecifiedNetworksList;
+        // Call filterSavedNetworks to generate necessary objects.
+        mAddAppNetworksFragment.filterSavedNetworks(mFakeSavedNetworksList);
+
+        // Act
+        mAddAppNetworksFragment.onAccessPointsChanged();
+
+        // Assert
+        assertThat(mAddAppNetworksFragment.mUiToRequestedList.get(0).mLevel).isEqualTo(
+                SCANED_LEVEL);
+    }
+
+    private void setUpOneScannedNetworkWithScanedLevel() {
+        final ArrayList list = new ArrayList<>();
+        list.add(mMockAccessPoint);
+        when(mMockWifiTracker.getAccessPoints()).thenReturn(list);
+        when(mMockAccessPoint.getSsidStr()).thenReturn(FAKE_NEW_OPEN_SSID);
+        when(mMockAccessPoint.matches(any(WifiConfiguration.class))).thenReturn(true);
+        when(mMockAccessPoint.getLevel()).thenReturn(SCANED_LEVEL);
+    }
+
     private void addOneSavedNetworkConfiguration(@NonNull WifiConfiguration wifiConfiguration) {
         if (mFakeSavedNetworksList == null) {
             mFakeSavedNetworksList = new ArrayList<>();