Merge "Handle multiple network request configs in WifiPickerTracker" into sc-dev

2 files changed, 92 insertions, 17 deletions

diff --git a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiPickerTracker.java b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiPickerTracker.java
index cc6fe039d..aa65ca4ad 100644
--- a/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiPickerTracker.java
+++ b/libs/WifiTrackerLib/src/com/android/wifitrackerlib/WifiPickerTracker.java
@@ -103,6 +103,9 @@ public class WifiPickerTracker extends BaseWifiTracker {
     // Cache containing suggested WifiConfigurations mapped by StandardWifiEntry key
     private final Map<StandardWifiEntryKey, List<WifiConfiguration>> mSuggestedConfigCache =
             new ArrayMap<>();
+    // Cache containing network request WifiConfigurations mapped by StandardWifiEntry key.
+    private final ArrayMap<StandardWifiEntryKey, List<WifiConfiguration>>
+            mNetworkRequestConfigCache = new ArrayMap<>();
     // Cache containing visible StandardWifiEntries. Must be accessed only by the worker thread.
     private final List<StandardWifiEntry> mStandardWifiEntryCache = new ArrayList<>();
     // Cache containing available suggested StandardWifiEntries. These entries may be already
@@ -678,6 +681,7 @@ public class WifiPickerTracker extends BaseWifiTracker {
         checkNotNull(configs, "Config list should not be null!");
         mStandardWifiConfigCache.clear();
         mSuggestedConfigCache.clear();
+        mNetworkRequestConfigCache.clear();
         final List<WifiConfiguration> networkRequestConfigs = new ArrayList<>();
         for (WifiConfiguration config : configs) {
             if (config.carrierMerged) {
@@ -693,7 +697,10 @@ public class WifiPickerTracker extends BaseWifiTracker {
                 }
                 mSuggestedConfigCache.get(standardWifiEntryKey).add(config);
             } else if (config.fromWifiNetworkSpecifier) {
-                networkRequestConfigs.add(config);
+                if (!mNetworkRequestConfigCache.containsKey(standardWifiEntryKey)) {
+                    mNetworkRequestConfigCache.put(standardWifiEntryKey, new ArrayList<>());
+                }
+                mNetworkRequestConfigCache.get(standardWifiEntryKey).add(config);
             } else {
                 if (!mStandardWifiConfigCache.containsKey(standardWifiEntryKey)) {
                     mStandardWifiConfigCache.put(standardWifiEntryKey, new ArrayList<>());
@@ -701,7 +708,6 @@ public class WifiPickerTracker extends BaseWifiTracker {
                 mStandardWifiConfigCache.get(standardWifiEntryKey).add(config);
             }
         }
-        updateNetworkRequestConfig(networkRequestConfigs);
         mNumSavedNetworks = (int) mStandardWifiConfigCache.values().stream()
                 .flatMap(List::stream)
                 .filter(config -> !config.isEphemeral())
@@ -719,23 +725,11 @@ public class WifiPickerTracker extends BaseWifiTracker {
             // Remove if the suggestion does not have a config anymore.
             return !entry.isSuggestion();
         });
-    }
-
-    @WorkerThread
-    private void updateNetworkRequestConfig(@Nullable List<WifiConfiguration> configs) {
-        if (configs == null || configs.isEmpty()) {
-            mNetworkRequestEntry = null;
-            return;
-        }
 
-        StandardWifiEntryKey configKey =
-                new StandardWifiEntryKey(configs.get(0), true /* isTargetingNewNetworks */);
-        if (mNetworkRequestEntry == null
-                || !mNetworkRequestEntry.getStandardWifiEntryKey().equals(configKey)) {
-            mNetworkRequestEntry = new NetworkRequestEntry(mContext, mMainHandler, configKey,
-                    mWifiManager, mWifiNetworkScoreCache, false /* forSavedNetworksPPage */);
+        if (mNetworkRequestEntry != null) {
+            mNetworkRequestEntry.updateConfig(
+                    mNetworkRequestConfigCache.get(mNetworkRequestEntry.getStandardWifiEntryKey()));
         }
-        mNetworkRequestEntry.updateConfig(configs);
     }
 
     @WorkerThread
@@ -779,6 +773,7 @@ public class WifiPickerTracker extends BaseWifiTracker {
         if (mNetworkRequestEntry != null) {
             mNetworkRequestEntry.updateConnectionInfo(wifiInfo, networkInfo);
         }
+        updateNetworkRequestEntryConnectionInfo(wifiInfo, networkInfo);
         if (mMergedCarrierEntry != null) {
             mMergedCarrierEntry.updateConnectionInfo(wifiInfo, networkInfo);
         }
@@ -789,6 +784,40 @@ public class WifiPickerTracker extends BaseWifiTracker {
     }
 
     /**
+     * Updates the connection info of the current NetworkRequestEntry. A new NetworkRequestEntry is
+     * created if there is no existing entry, or the existing entry doesn't match WifiInfo.
+     */
+    @WorkerThread
+    private void updateNetworkRequestEntryConnectionInfo(
+            @Nullable WifiInfo wifiInfo, @Nullable NetworkInfo networkInfo) {
+        final List<WifiConfiguration> matchingConfigs = new ArrayList<>();
+
+        for (int i = 0; i < mNetworkRequestConfigCache.size(); i++) {
+            final List<WifiConfiguration> configs = mNetworkRequestConfigCache.valueAt(i);
+            if (!configs.isEmpty() && configs.get(0).networkId == wifiInfo.getNetworkId()) {
+                matchingConfigs.addAll(configs);
+                break;
+            }
+        }
+
+        // WifiInfo isn't for any request configs, remove the NetworkRequestEntry
+        if (matchingConfigs.isEmpty()) {
+            mNetworkRequestEntry = null;
+            return;
+        }
+
+        // WifiInfo matches a request config, create a NetworkRequestEntry or update the existing.
+        final StandardWifiEntryKey entryKey = new StandardWifiEntryKey(matchingConfigs.get(0));
+        if (mNetworkRequestEntry == null
+                || !mNetworkRequestEntry.getStandardWifiEntryKey().equals(entryKey)) {
+            mNetworkRequestEntry = new NetworkRequestEntry(mContext, mMainHandler, entryKey,
+                    mWifiManager, mWifiNetworkScoreCache, false /* forSavedNetworksPage */);
+            mNetworkRequestEntry.updateConfig(matchingConfigs);
+        }
+        mNetworkRequestEntry.updateConnectionInfo(wifiInfo, networkInfo);
+    }
+
+    /**
      * Creates and caches a StandardWifiEntry representing the current connection using the current
      * WifiInfo and NetworkInfo if there are no scans results available for the network yet.
      * @param wifiInfo WifiInfo of the current connection
diff --git a/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiPickerTrackerTest.java b/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiPickerTrackerTest.java
index 5b05e3c08..76408a8f4 100644
--- a/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiPickerTrackerTest.java
+++ b/libs/WifiTrackerLib/tests/src/com/android/wifitrackerlib/WifiPickerTrackerTest.java
@@ -908,6 +908,52 @@ public class WifiPickerTrackerTest {
     }
 
     /**
+     * Tests that getConnectedEntry will return the correct network request if there are multiple
+     * active requests
+     */
+    @Test
+    public void testGetConnectedEntry_multipleNetworkRequests_returnsConnectedRequest() {
+        final WifiConfiguration requestConfig1 = new WifiConfiguration();
+        requestConfig1.SSID = "\"ssid1\"";
+        requestConfig1.networkId = 1;
+        requestConfig1.fromWifiNetworkSpecifier = true;
+        final WifiConfiguration requestConfig2 = new WifiConfiguration();
+        requestConfig2.SSID = "\"ssid2\"";
+        requestConfig2.networkId = 2;
+        requestConfig2.fromWifiNetworkSpecifier = true;
+        when(mMockWifiManager.getPrivilegedConfiguredNetworks()).thenReturn(
+                Arrays.asList(requestConfig1, requestConfig2));
+        when(mMockWifiInfo.getNetworkId()).thenReturn(1);
+        when(mMockWifiInfo.getRssi()).thenReturn(-50);
+        when(mMockNetworkInfo.getDetailedState()).thenReturn(NetworkInfo.DetailedState.CONNECTED);
+
+        final WifiPickerTracker wifiPickerTracker = createTestWifiPickerTracker();
+        wifiPickerTracker.onStart();
+        verify(mMockContext).registerReceiver(mBroadcastReceiverCaptor.capture(),
+                any(), any(), any());
+        mTestLooper.dispatchAll();
+
+        // WifiInfo has network id 1, so the connected entry should correspond to request 1
+        assertThat(wifiPickerTracker.getConnectedWifiEntry().getSsid()).isEqualTo("ssid1");
+
+        when(mMockWifiInfo.getNetworkId()).thenReturn(2);
+        mBroadcastReceiverCaptor.getValue().onReceive(mMockContext,
+                new Intent(WifiManager.NETWORK_STATE_CHANGED_ACTION)
+                        .putExtra(WifiManager.EXTRA_NETWORK_INFO, mMockNetworkInfo));
+
+        // WifiInfo has network id 2, so the connected entry should correspond to request 2
+        assertThat(wifiPickerTracker.getConnectedWifiEntry().getSsid()).isEqualTo("ssid2");
+
+        when(mMockWifiInfo.getNetworkId()).thenReturn(-1);
+        mBroadcastReceiverCaptor.getValue().onReceive(mMockContext,
+                new Intent(WifiManager.NETWORK_STATE_CHANGED_ACTION)
+                        .putExtra(WifiManager.EXTRA_NETWORK_INFO, mMockNetworkInfo));
+
+        // WifiInfo matches no request configs, so the connected entry should be null
+        assertThat(wifiPickerTracker.getConnectedWifiEntry()).isNull();
+    }
+
+    /**
      * Tests that SCAN_RESULTS_AVAILABLE_ACTION calls WifiManager#getMatchingOsuProviders()
      */
     @Test