hotspot2: add ANQPRequestManager for managing ANQP requests

The main objective is to hold off ANQP requests to an AP
after the previous request is unanwered or failed.

This can eaisly be expanded in the future to throttle ANQP requests
further by taking into consideration of the current connection
status and other criteria, to reduce the impact of ANQP
requests on the network performance and the power consumption.

Bug: 33746564
Test: frameworks/opt/net/wifi/tests/wifitests/runtests.sh
Change-Id: I906508f72832a9e461be6b2db2ceacb997765bb8

2 files changed, 373 insertions, 0 deletions

diff --git a/tests/wifitests/src/com/android/server/wifi/hotspot2/ANQPRequestManagerTest.java b/tests/wifitests/src/com/android/server/wifi/hotspot2/ANQPRequestManagerTest.java
new file mode 100644
index 000000000..08b37deb9
--- /dev/null
+++ b/tests/wifitests/src/com/android/server/wifi/hotspot2/ANQPRequestManagerTest.java
@@ -0,0 +1,304 @@
+/*
+ * Copyright (C) 2016 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.server.wifi.hotspot2;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.anyLong;
+import static org.mockito.Mockito.anyObject;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.reset;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+import static org.mockito.MockitoAnnotations.initMocks;
+
+import android.test.suitebuilder.annotation.SmallTest;
+
+import com.android.server.wifi.Clock;
+import com.android.server.wifi.ScanDetail;
+import com.android.server.wifi.hotspot2.anqp.Constants;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mock;
+
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * Unit tests for {@link com.android.server.wifi.hotspot2.ANQPRequestManager}.
+ */
+@SmallTest
+public class ANQPRequestManagerTest {
+    private static final long TEST_BSSID = 0x123456L;
+    private static final ScanDetail TEST_SCAN_DETAIL = mock(ScanDetail.class);
+
+    private static final List<Constants.ANQPElementType> R1_ANQP_WITHOUT_RC = Arrays.asList(
+            Constants.ANQPElementType.ANQPVenueName,
+            Constants.ANQPElementType.ANQPIPAddrAvailability,
+            Constants.ANQPElementType.ANQPNAIRealm,
+            Constants.ANQPElementType.ANQP3GPPNetwork,
+            Constants.ANQPElementType.ANQPDomName);
+
+    private static final List<Constants.ANQPElementType> R1_ANQP_WITH_RC = Arrays.asList(
+            Constants.ANQPElementType.ANQPVenueName,
+            Constants.ANQPElementType.ANQPIPAddrAvailability,
+            Constants.ANQPElementType.ANQPNAIRealm,
+            Constants.ANQPElementType.ANQP3GPPNetwork,
+            Constants.ANQPElementType.ANQPDomName,
+            Constants.ANQPElementType.ANQPRoamingConsortium);
+
+    private static final List<Constants.ANQPElementType> R1R2_ANQP_WITHOUT_RC = Arrays.asList(
+            Constants.ANQPElementType.ANQPVenueName,
+            Constants.ANQPElementType.ANQPIPAddrAvailability,
+            Constants.ANQPElementType.ANQPNAIRealm,
+            Constants.ANQPElementType.ANQP3GPPNetwork,
+            Constants.ANQPElementType.ANQPDomName,
+            Constants.ANQPElementType.HSFriendlyName,
+            Constants.ANQPElementType.HSWANMetrics,
+            Constants.ANQPElementType.HSConnCapability);
+
+    private static final List<Constants.ANQPElementType> R1R2_ANQP_WITH_RC = Arrays.asList(
+            Constants.ANQPElementType.ANQPVenueName,
+            Constants.ANQPElementType.ANQPIPAddrAvailability,
+            Constants.ANQPElementType.ANQPNAIRealm,
+            Constants.ANQPElementType.ANQP3GPPNetwork,
+            Constants.ANQPElementType.ANQPDomName,
+            Constants.ANQPElementType.ANQPRoamingConsortium,
+            Constants.ANQPElementType.HSFriendlyName,
+            Constants.ANQPElementType.HSWANMetrics,
+            Constants.ANQPElementType.HSConnCapability);
+
+    @Mock PasspointEventHandler mHandler;
+    @Mock Clock mClock;
+    ANQPRequestManager mManager;
+
+    /**
+     * Test setup.
+     */
+    @Before
+    public void setUp() throws Exception {
+        initMocks(this);
+        mManager = new ANQPRequestManager(mHandler, mClock);
+    }
+
+    /**
+     * Verify that the expected set of ANQP elements are being requested when the targeted AP
+     * doesn't provide roaming consortium OIs and doesn't support Hotspot 2.0 Release 2 ANQP
+     * elements, based on the IEs in the scan result .
+     *
+     * @throws Exception
+     */
+    @Test
+    public void requestR1ANQPElementsWithoutRC() throws Exception {
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+    }
+
+    /**
+     * Verify that the expected set of ANQP elements are being requested when the targeted AP
+     * does provide roaming consortium OIs and doesn't support Hotspot 2.0 Release ANQP elements,
+     * based on the IEs in the scan result.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void requestR1ANQPElementsWithRC() throws Exception {
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITH_RC)).thenReturn(true);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, true, false));
+    }
+
+    /**
+     * Verify that the expected set of ANQP elements are being requested when the targeted AP
+     * doesn't provide roaming consortium OIs and does support Hotspot 2.0 Release ANQP elements,
+     * based on the IEs in the scan result.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void requestR1R2ANQPElementsWithoutRC() throws Exception {
+        when(mHandler.requestANQP(TEST_BSSID, R1R2_ANQP_WITHOUT_RC)).thenReturn(true);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, true));
+    }
+
+    /**
+     * Verify that the expected set of ANQP elements are being requested when the targeted AP
+     * does provide roaming consortium OIs and support Hotspot 2.0 Release ANQP elements,
+     * based on the IEs in the scan result.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void requestR1R2ANQPElementsWithRC() throws Exception {
+        when(mHandler.requestANQP(TEST_BSSID, R1R2_ANQP_WITH_RC)).thenReturn(true);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, true, true));
+    }
+
+    /**
+     * Verify that attempt to request ANQP elements from an AP will fail when there is a request
+     * already pending.  The request will succeed when the hold off time is up.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void requestANQPElementsWithPendingRequest() throws Exception {
+        // Send the initial request.
+        long startTime = 0;
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(startTime);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+        reset(mHandler);
+
+        // Attempt another request will fail while one is still pending and hold off time is not up
+        // yet.
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(startTime + 1);
+        assertFalse(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+        verify(mHandler, never()).requestANQP(anyLong(), anyObject());
+        reset(mHandler);
+
+        // Attempt other request will succeed after the hold off time is up.
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+        when(mClock.getElapsedSinceBootMillis())
+                .thenReturn(startTime + ANQPRequestManager.BASE_HOLDOFF_TIME_MILLISECONDS);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+    }
+
+    /**
+     * Verify that an immediate attempt to request ANQP elements from an AP will succeed when
+     * the previous request is failed on sending.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void requestANQPElementsAfterRequestSendFailure() throws Exception {
+        // Initial request failed to send.
+        long startTime = 0;
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(false);
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(startTime);
+        assertFalse(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+        reset(mHandler);
+
+        // Verify that new request is not being held off after previous send failure.
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(startTime);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+    }
+
+    /**
+     * Verify that an immediate attempt to request ANQP elements from an AP will succeed when
+     * the previous request is completed with success.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void requestANQPElementsAfterRequestSucceeded() throws Exception {
+        // Send the initial request.
+        long startTime = 0;
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(startTime);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+        reset(mHandler);
+
+        // Request completed with success.
+        mManager.onRequestCompleted(TEST_BSSID, true);
+
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(startTime + 1);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+    }
+
+    /**
+     * Verify that an immediate attempt to request ANQP elements from an AP will fail when
+     * the previous request is completed with failure.  The request will succeed after the
+     * hold off time is up.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void requestANQPElementsAfterRequestFailed() throws Exception {
+        // Send the initial request.
+        long startTime = 0;
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(startTime);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+        reset(mHandler);
+
+        // Request completed with failure.
+        mManager.onRequestCompleted(TEST_BSSID, false);
+
+        // Attempt another request will fail since the hold off time is not up yet.
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(startTime + 1);
+        assertFalse(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+        verify(mHandler, never()).requestANQP(anyLong(), anyObject());
+
+        // Attempt another request will succeed after the hold off time is up.
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+        when(mClock.getElapsedSinceBootMillis())
+                .thenReturn(startTime + ANQPRequestManager.BASE_HOLDOFF_TIME_MILLISECONDS);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+    }
+
+    /**
+     * Verify the hold off time for each unanswered query, and that it will stay the same after
+     * reaching the max hold off count {@link ANQPRequestManager#MAX_HOLDOFF_COUNT}.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void requestANQPElementsWithMaxRetries() throws Exception {
+        long currentTime = 0;
+
+        // Initial request.
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTime);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+        reset(mHandler);
+
+        // Sending the request with the hold off time based on the current hold off count.
+        for (int i = 0; i <= ANQPRequestManager.MAX_HOLDOFF_COUNT; i++) {
+            long currentHoldOffTime = ANQPRequestManager.BASE_HOLDOFF_TIME_MILLISECONDS * (1 << i);
+            currentTime += (currentHoldOffTime - 1);
+
+            // Request will fail before the hold off time is up.
+            when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTime);
+            assertFalse(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+            verify(mHandler, never()).requestANQP(anyLong(), anyObject());
+
+            // Request will succeed when the hold off time is up.
+            currentTime += 1;
+            when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+            when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTime);
+            assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+            reset(mHandler);
+        }
+
+        // Verify that the hold off time is max out at the maximum hold off count.
+        currentTime += (ANQPRequestManager.BASE_HOLDOFF_TIME_MILLISECONDS
+                * (1 << ANQPRequestManager.MAX_HOLDOFF_COUNT) - 1);
+
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTime);
+        assertFalse(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+        verify(mHandler, never()).requestANQP(anyLong(), anyObject());
+
+        currentTime += 1;
+        when(mHandler.requestANQP(TEST_BSSID, R1_ANQP_WITHOUT_RC)).thenReturn(true);
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(currentTime);
+        assertTrue(mManager.requestANQPElements(TEST_BSSID, TEST_SCAN_DETAIL, false, false));
+        reset(mHandler);
+    }
+}
diff --git a/tests/wifitests/src/com/android/server/wifi/hotspot2/PasspointManagerTest.java b/tests/wifitests/src/com/android/server/wifi/hotspot2/PasspointManagerTest.java
index 59dfa3b58..74bb10e84 100644
--- a/tests/wifitests/src/com/android/server/wifi/hotspot2/PasspointManagerTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/hotspot2/PasspointManagerTest.java
@@ -25,10 +25,12 @@ import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.anyBoolean;
 import static org.mockito.Mockito.anyLong;
 import static org.mockito.Mockito.anyMap;
 import static org.mockito.Mockito.eq;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 import static org.mockito.MockitoAnnotations.initMocks;
@@ -50,6 +52,9 @@ import com.android.server.wifi.SIMAccessor;
 import com.android.server.wifi.ScanDetail;
 import com.android.server.wifi.WifiKeyStore;
 import com.android.server.wifi.WifiNative;
+import com.android.server.wifi.hotspot2.anqp.ANQPElement;
+import com.android.server.wifi.hotspot2.anqp.Constants.ANQPElementType;
+import com.android.server.wifi.hotspot2.anqp.DomainNameElement;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -57,7 +62,10 @@ import org.mockito.ArgumentCaptor;
 import org.mockito.Mock;
 
 import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 /**
  * Unit tests for {@link com.android.server.wifi.hotspot2.PasspointManager}.
@@ -85,6 +93,7 @@ public class PasspointManagerTest {
     @Mock PasspointObjectFactory mObjectFactory;
     @Mock PasspointEventHandler.Callbacks mCallbacks;
     @Mock AnqpCache mAnqpCache;
+    @Mock ANQPRequestManager mAnqpRequestManager;
     PasspointManager mManager;
 
     /** Sets up test. */
@@ -92,6 +101,8 @@ public class PasspointManagerTest {
     public void setUp() throws Exception {
         initMocks(this);
         when(mObjectFactory.makeAnqpCache(mClock)).thenReturn(mAnqpCache);
+        when(mObjectFactory.makeANQPRequestManager(any(PasspointEventHandler.class), eq(mClock)))
+                .thenReturn(mAnqpRequestManager);
         mManager = new PasspointManager(mContext, mWifiNative, mWifiKeyStore, mClock,
                 mSimAccessor, mObjectFactory);
         ArgumentCaptor<PasspointEventHandler.Callbacks> callbacks =
@@ -192,6 +203,61 @@ public class PasspointManagerTest {
     }
 
     /**
+     * Verify that the ANQP elements will be added to the ANQP cache on receiving a successful
+     * response.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void anqpResponseSuccess() throws Exception {
+        Map<ANQPElementType, ANQPElement> anqpElementMap = new HashMap<>();
+        anqpElementMap.put(ANQPElementType.ANQPDomName,
+                new DomainNameElement(Arrays.asList(new String[] {"test.com"})));
+
+        ScanDetail scanDetail = createMockScanDetail();
+        ANQPNetworkKey anqpKey = ANQPNetworkKey.buildKey(TEST_SSID, TEST_BSSID, TEST_HESSID,
+                TEST_ANQP_DOMAIN_ID);
+        when(mAnqpRequestManager.onRequestCompleted(TEST_BSSID, true)).thenReturn(scanDetail);
+        mCallbacks.onANQPResponse(TEST_BSSID, anqpElementMap);
+        verify(mAnqpCache).addEntry(anqpKey, anqpElementMap);
+        verify(scanDetail).propagateANQPInfo(anqpElementMap);
+    }
+
+    /**
+     * Verify that no ANQP elements will be added to the ANQP cache on receiving a successful
+     * response for a request that's not sent by us.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void anqpResponseSuccessWithUnknownRequest() throws Exception {
+        Map<ANQPElementType, ANQPElement> anqpElementMap = new HashMap<>();
+        anqpElementMap.put(ANQPElementType.ANQPDomName,
+                new DomainNameElement(Arrays.asList(new String[] {"test.com"})));
+
+        when(mAnqpRequestManager.onRequestCompleted(TEST_BSSID, true)).thenReturn(null);
+        mCallbacks.onANQPResponse(TEST_BSSID, anqpElementMap);
+        verify(mAnqpCache, never()).addEntry(any(ANQPNetworkKey.class), anyMap());
+    }
+
+    /**
+     * Verify that no ANQP elements will be added to the ANQP cache on receiving a failure response.
+     *
+     * @throws Exception
+     */
+    @Test
+    public void anqpResponseFailure() throws Exception {
+        ANQPNetworkKey anqpKey = ANQPNetworkKey.buildKey(TEST_SSID, TEST_BSSID, TEST_HESSID,
+                TEST_ANQP_DOMAIN_ID);
+
+        ScanDetail scanDetail = createMockScanDetail();
+        when(mAnqpRequestManager.onRequestCompleted(TEST_BSSID, false)).thenReturn(scanDetail);
+        mCallbacks.onANQPResponse(TEST_BSSID, null);
+        verify(mAnqpCache, never()).addEntry(any(ANQPNetworkKey.class), anyMap());
+
+    }
+
+    /**
      * Validate the broadcast intent when icon file retrieval succeeded.
      *
      * @throws Exception
@@ -449,6 +515,9 @@ public class PasspointManagerTest {
         when(mAnqpCache.getEntry(anqpKey)).thenReturn(null);
         List<Pair<PasspointProvider, PasspointMatch>> result =
                 mManager.matchProvider(createMockScanDetail());
+        // Verify that a request for ANQP elements is initiated.
+        verify(mAnqpRequestManager).requestANQPElements(eq(TEST_BSSID), any(ScanDetail.class),
+                anyBoolean(), anyBoolean());
         assertTrue(result.isEmpty());
     }