Merge "Remodel Network Selection" into mm-wireless-dev

2 files changed, 199 insertions, 24 deletions

diff --git a/tests/wifitests/src/com/android/server/wifi/WifiConfigurationUtil.java b/tests/wifitests/src/com/android/server/wifi/WifiConfigurationUtil.java
index c786741cf..1368fc1c2 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiConfigurationUtil.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiConfigurationUtil.java
@@ -23,6 +23,15 @@ import android.net.wifi.WifiEnterpriseConfig;
  * Helper for creating and populating WifiConfigurations in unit tests.
  */
 public class WifiConfigurationUtil {
+    /**
+     * These values are used to describe AP's security setting. One AP can support multiple of them,
+     * only if there is no conflict.
+     */
+    public static final int SECURITY_NONE = 0;
+    public static final int SECURITY_WEP =  1 << 0;
+    public static final int SECURITY_PSK =  1 << 1;
+    public static final int SECURITY_EAP =  1 << 2;
+
     public static WifiConfiguration generateWifiConfig(int networkId, int uid, String ssid,
             boolean shared, boolean enabled, String fqdn, String providerFriendlyName) {
         final WifiConfiguration config = new WifiConfiguration();
@@ -39,4 +48,25 @@ public class WifiConfigurationUtil {
         }
         return config;
     }
+
+    public static WifiConfiguration generateWifiConfig(int networkId, int uid, String ssid,
+            boolean shared, boolean enabled, String fqdn, String providerFriendlyName,
+            int security) {
+        WifiConfiguration config = generateWifiConfig(networkId, uid, ssid, shared, enabled, fqdn,
+                providerFriendlyName);
+
+        if (security == SECURITY_NONE) {
+            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
+        } else {
+            if (((security & SECURITY_WEP) != 0) || ((security & SECURITY_PSK) != 0)) {
+                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
+            }
+
+            if ((security & SECURITY_EAP) != 0) {
+                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_EAP);
+                config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.IEEE8021X);
+            }
+        }
+        return config;
+    }
 }
diff --git a/tests/wifitests/src/com/android/server/wifi/WifiQualifiedNetworkSelectionTest.java b/tests/wifitests/src/com/android/server/wifi/WifiQualifiedNetworkSelectionTest.java
index 49b7f88d5..56f3333dc 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiQualifiedNetworkSelectionTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiQualifiedNetworkSelectionTest.java
@@ -16,8 +16,12 @@
 
 package com.android.server.wifi;
 
+import static com.android.server.wifi.WifiConfigurationUtil.SECURITY_NONE;
+import static com.android.server.wifi.WifiConfigurationUtil.SECURITY_PSK;
+import static com.android.server.wifi.WifiConfigurationUtil.generateWifiConfig;
+
 import static org.junit.Assert.assertEquals;
-import static org.mockito.Mockito.any;
+import static org.mockito.Matchers.anyInt;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.validateMockitoUsage;
 import static org.mockito.Mockito.when;
@@ -32,12 +36,14 @@ import android.net.wifi.WifiSsid;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import com.android.internal.R;
+import com.android.server.wifi.MockAnswerUtil.AnswerWithArguments;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -46,6 +52,8 @@ import java.util.concurrent.atomic.AtomicInteger;
  */
 @SmallTest
 public class WifiQualifiedNetworkSelectionTest {
+
+
     @Before
     public void setUp() throws Exception {
         mWifiStateMachine = getWifiStateMachine();
@@ -159,44 +167,68 @@ public class WifiQualifiedNetworkSelectionTest {
         return wifiConfigStore;
     }
 
-    @Test
     /**
+     * This API is used to generate multiple simulated saved configurations used for test
+     * @param ssid array of SSID of saved configuration
+     * @param security array  of securities of  saved configuration
+     * @return generated new array of configurations based on input
+     */
+    private WifiConfiguration[] generateWifiConfigurations(String[] ssid, int[] security) {
+        if (ssid == null || security == null || ssid.length != security.length
+                || ssid.length == 0) {
+            return null;
+        }
+
+        WifiConfiguration[] configs = new WifiConfiguration[ssid.length];
+        for (int index = 0; index < ssid.length; index++) {
+            configs[index] = generateWifiConfig(index, 0, ssid[index], false, true, null , null,
+                    security[index]);
+        }
+
+        return configs;
+    }
+
+    /**
+     * Case #1
      * In this test. we simulate following scenario
      * WifiStateMachine is under disconnected state
      * Two networks test1, test2 are secured network
      * Both network are enabled
-     * test1 is @ 2GHz with RSSI
+     * test1 is @ 2GHz with RSSI -50
+     * test2 is @ 5Ghz with RSSI -65
+     * Expected behavior: test2 is chosen
      */
-    public void chooseNetworkDisconnect5GOver2G() {
+    @Test
+    public void chooseNetworkDisconnect5GOver2GTest() {
         String[] ssids = {"\"test1\"", "\"test2\""};
         String[] bssids = {"6c:f3:7f:ae:8c:f3", "6c:f3:7f:ae:8c:f4"};
         int[] frequencies = {2437, 5180};
         String[] caps = {"[WPA2-EAP-CCMP][ESS]", "[WPA2-EAP-CCMP][ESS][ESS]"};
         int[] levels = {-50, -65};
+        int[] security = {SECURITY_PSK, SECURITY_PSK};
 
         List<ScanDetail> scanDetails = getScanDetails(ssids, bssids, frequencies, caps, levels);
         when(mWifiStateMachine.getScanResultsListNoCopyUnsync()).thenReturn(scanDetails);
-        when(mWifiStateMachine.isConnected()).thenReturn(false);
         when(mWifiStateMachine.isDisconnected()).thenReturn(true);
 
-        WifiConfiguration configuration1 = new WifiConfiguration();
-        configuration1.networkId = 0;
-        configuration1.SSID = "\"test1\"";
-        WifiConfiguration configuration2 = new WifiConfiguration();
-        configuration2.networkId = 1;
-        configuration2.SSID = "\"test2\"";
-
-        List<WifiConfiguration> savedNetwork =  new ArrayList<WifiConfiguration>();
-        savedNetwork.add(configuration1);
-        savedNetwork.add(configuration2);
-
-        when(mWifiConfigStore.isOpenNetwork(any(WifiConfiguration.class))).thenReturn(false);
-        when(mWifiConfigStore.isOpenNetwork(any(ScanResult.class))).thenReturn(false);
-        when(mWifiConfigStore.getWifiConfiguration(0)).thenReturn(configuration1);
-        when(mWifiConfigStore.getWifiConfiguration(1)).thenReturn(configuration2);
+        final List<WifiConfiguration> savedNetwork =
+                Arrays.asList(generateWifiConfigurations(ssids, security));
+
+        WifiConfiguration configuration1 = savedNetwork.get(0);
+        WifiConfiguration configuration2 = savedNetwork.get(1);
+
+        when(mWifiConfigStore.getWifiConfiguration(anyInt()))
+                .then(new AnswerWithArguments<Boolean>() {
+                        public WifiConfiguration answer(int netId) {
+                            if (netId >= 0 && netId < savedNetwork.size()) {
+                                return savedNetwork.get(netId);
+                            } else {
+                                return null;
+                            }
+                        }
+                });
+
         when(mWifiConfigStore.getConfiguredNetworks()).thenReturn(savedNetwork);
-        when(mWifiConfigStore.getLastSelectedConfiguration()).thenReturn(null);
-        when(mWifiConfigStore.isBssidBlacklisted(any(String.class))).thenReturn(false);
 
         List<WifiConfiguration> associateWithScanResult1 = new ArrayList<WifiConfiguration>();
         associateWithScanResult1.add(configuration1);
@@ -208,10 +240,123 @@ public class WifiQualifiedNetworkSelectionTest {
                 associateWithScanResult1);
         when(mWifiConfigStore.updateSavedNetworkWithNewScanDetail(scanDetails.get(1))).thenReturn(
                 associateWithScanResult2);
-        ScanResult scanResult = scanDetails.get(1).getScanResult();
+        ScanResult chosenScanResult = scanDetails.get(scanDetails.size() - 1).getScanResult();
+
+        mWifiQualifiedNetworkSelector.selectQualifiedNetwork(false);
+        assertEquals("choose the wrong SSID", chosenScanResult.SSID,
+                mWifiQualifiedNetworkSelector.getConnetionTargetNetwork().SSID);
+    }
+
 
+    /**
+     * Case #2
+     * In this test. we simulate following scenario
+     * There are three saved networks: test1, test2 and test3. Now user select the network test3
+     */
+    @Test
+    public void userSelectsNetworkForFirstTime() {
+        String[] ssids = {"\"test1\"", "\"test2\"", "\"test3\""};
+        int[] security = {SECURITY_PSK, SECURITY_PSK, SECURITY_NONE};
+
+        final WifiConfiguration[] configs = generateWifiConfigurations(ssids, security);
+
+        when(mWifiConfigStore.getWifiConfiguration(anyInt()))
+                .then(new AnswerWithArguments<Boolean>() {
+                    public WifiConfiguration answer(int netId) {
+                        if (netId >= 0 && netId < configs.length) {
+                            return configs[netId];
+                        } else {
+                            return null;
+                        }
+                    }
+                });
+
+        when(mWifiConfigStore.getConfiguredNetworks()).thenReturn(Arrays.asList(configs));
+        for (WifiConfiguration network : configs) {
+            WifiConfiguration.NetworkSelectionStatus status = network.getNetworkSelectionStatus();
+            status.setSeenInLastQualifiedNetworkSelection(true);
+        }
+
+        mWifiQualifiedNetworkSelector.userSelectNetwork(configs.length - 1, true);
+        String key = configs[configs.length - 1].configKey();
+        for (int index = 0; index < configs.length; index++) {
+            WifiConfiguration config = configs[index];
+            WifiConfiguration.NetworkSelectionStatus status = config.getNetworkSelectionStatus();
+            if (index == configs.length - 1) {
+                assertEquals("User selected network should not have prefernce over it", null,
+                        status.getConnectChoice());
+            } else {
+                assertEquals("Wrong user preference", key, status.getConnectChoice());
+            }
+        }
+    }
+
+    /**
+     * case #3
+     * In this test, we simulate following scenario:
+     * There are three networks: test1, test2, test3 and test3 is the user preference
+     * All three networks are enabled
+     * test1 is @ 2.4GHz with RSSI -50 PSK
+     * test2 is @ 5Ghz with RSSI -65 PSK
+     * test3 is @ 2.4GHz with RSSI -55
+     * Expected behavior: test3 is chosen
+     */
+    @Test
+    public void chooseUserPreferredNetwork() {
+        //Generate mocked saved configurations
+        String[] ssids = {"\"test1\"", "\"test2\"", "\"test3\""};
+        int[] security = {SECURITY_PSK, SECURITY_PSK, SECURITY_NONE};
+        final WifiConfiguration[] configs = generateWifiConfigurations(ssids, security);
+        for (WifiConfiguration network : configs) {
+            WifiConfiguration.NetworkSelectionStatus status = network.getNetworkSelectionStatus();
+            status.setSeenInLastQualifiedNetworkSelection(true);
+        }
+
+        when(mWifiConfigStore.getConfiguredNetworks()).thenReturn(Arrays.asList(configs));
+
+        when(mWifiConfigStore.getWifiConfiguration(anyInt()))
+                .then(new AnswerWithArguments<Boolean>() {
+                        public WifiConfiguration answer(int netId) {
+                            if (netId >= 0 && netId < configs.length) {
+                                return configs[netId];
+                            } else {
+                                return null;
+                            }
+                        }
+                });
+
+        //set user preference
+        mWifiQualifiedNetworkSelector.userSelectNetwork(ssids.length - 1, true);
+        //Generate mocked recent scan results
+        String[] bssids = {"6c:f3:7f:ae:8c:f3", "6c:f3:7f:ae:8c:f4", "6c:f3:7f:ae:8c:f5"};
+        int[] frequencies = {2437, 5180, 2437};
+        String[] caps = {"[WPA2-EAP-CCMP][ESS]", "[WPA2-EAP-CCMP][ESS][ESS]", "NONE"};
+        int[] levels = {-50, -65, -55};
+
+        List<ScanDetail> scanDetails = getScanDetails(ssids, bssids, frequencies, caps, levels);
+        when(mWifiStateMachine.getScanResultsListNoCopyUnsync()).thenReturn(scanDetails);
+        when(mWifiStateMachine.isDisconnected()).thenReturn(true);
+
+        List<WifiConfiguration> associateWithScanResult1 = new ArrayList<WifiConfiguration>();
+        associateWithScanResult1.add(configs[0]);
+
+        List<WifiConfiguration> associateWithScanResult2 = new ArrayList<WifiConfiguration>();
+        associateWithScanResult2.add(configs[1]);
+
+        List<WifiConfiguration> associateWithScanResult3 = new ArrayList<WifiConfiguration>();
+        associateWithScanResult3.add(configs[2]);
+
+        when(mWifiConfigStore.updateSavedNetworkWithNewScanDetail(scanDetails.get(0))).thenReturn(
+                associateWithScanResult1);
+        when(mWifiConfigStore.updateSavedNetworkWithNewScanDetail(scanDetails.get(1))).thenReturn(
+                associateWithScanResult2);
+        when(mWifiConfigStore.updateSavedNetworkWithNewScanDetail(scanDetails.get(2))).thenReturn(
+                associateWithScanResult3);
+        ScanResult chosenScanResult = scanDetails.get(scanDetails.size() - 1).getScanResult();
+        when(mWifiConfigStore.getWifiConfiguration(configs[2].configKey()))
+                .thenReturn(configs[2]);
         mWifiQualifiedNetworkSelector.selectQualifiedNetwork(false);
-        assertEquals("choose the wrong SSID", scanResult.SSID,
+        assertEquals("choose the wrong SSID", chosenScanResult.SSID,
                 mWifiQualifiedNetworkSelector.getConnetionTargetNetwork().SSID);
     }
 }