Merge changes from topic "start-wifi-after-boot"

* changes:
  Make Wifi more resilient to services starting late
  Revert "Revert "Start Wifi only after boot completes""

7 files changed, 182 insertions, 66 deletions

diff --git a/service/AndroidManifest.xml b/service/AndroidManifest.xml
index ee05237ed..878b7d51b 100644
--- a/service/AndroidManifest.xml
+++ b/service/AndroidManifest.xml
@@ -69,7 +69,8 @@
     <!-- TODO(b/135691051): Need to move to network stack process.
          "android:process="com.google.android.networkstack"
          This is not possible currently because hidden API access is denied when run on network
-         stack process -->
+         stack process.
+         <receiver> also needs to run on the networkstack process. -->
     <application
         android:persistent="true"
         android:directBootAware="true"
@@ -81,5 +82,10 @@
                 <action android:name="android.net.wifi.IWifiStackConnector"/>
             </intent-filter>
         </service>
+        <receiver android:name="com.android.server.wifi.BootCompleteReceiver">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
     </application>
 </manifest>
diff --git a/service/AndroidManifest_InProcess.xml b/service/AndroidManifest_InProcess.xml
index 866f129fb..c480a464a 100644
--- a/service/AndroidManifest_InProcess.xml
+++ b/service/AndroidManifest_InProcess.xml
@@ -37,5 +37,11 @@
                 <action android:name="android.net.wifi.IWifiStackConnector.InProcess"/>
             </intent-filter>
         </service>
+        <receiver android:name="com.android.server.wifi.BootCompleteReceiver"
+                  android:process="system">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
     </application>
 </manifest>
diff --git a/service/java/com/android/server/wifi/BootCompleteReceiver.java b/service/java/com/android/server/wifi/BootCompleteReceiver.java
new file mode 100644
index 000000000..86f263a2d
--- /dev/null
+++ b/service/java/com/android/server/wifi/BootCompleteReceiver.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2019 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;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.annotation.concurrent.GuardedBy;
+
+/**
+ * Receives boot complete broadcast (registered in AndroidManifest.xml).
+ *
+ * Ensures that if WifiStack is initialized after boot complete, we can check whether boot was
+ * already completed, since if we start listening for the boot complete broadcast now it will be too
+ * late and we will never get the broadcast.
+ *
+ * This BroadcastReceiver can be registered multiple times in different places, and it will ensure
+ * that all registered callbacks are triggered exactly once.
+ */
+public class BootCompleteReceiver extends BroadcastReceiver {
+    private static final String TAG = "WifiBootCompleteReceiver";
+
+    private static final Object sLock = new Object();
+    @GuardedBy("sLock")
+    private static boolean sIsBootCompleted = false;
+    @GuardedBy("sLock")
+    private static final List<Runnable> sCallbacks = new ArrayList<>(1);
+
+    public BootCompleteReceiver() {
+        Log.d(TAG, "Constructed BootCompleteReceiver");
+    }
+
+    /**
+     * Registers a callback that will be triggered when boot is completed. Note that if boot has
+     * already been completed when the callback is registered, the callback will be triggered
+     * immediately.
+     *
+     * No guarantees are made about which thread the callback is triggered on. Please do not
+     * perform expensive operations in the callback, instead post to other threads.
+     */
+    public static void registerCallback(Runnable callback) {
+        boolean runImmediately = false;
+
+        synchronized (sLock) {
+            if (sIsBootCompleted) {
+                runImmediately = true;
+            } else {
+                sCallbacks.add(callback);
+            }
+        }
+
+        // run callback outside of synchronized block
+        if (runImmediately) {
+            Log.d(TAG, "Triggering callback immediately since boot is already complete.");
+            callback.run();
+        } else {
+            Log.d(TAG, "Enqueuing callback since boot is not yet complete.");
+        }
+    }
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        Log.d(TAG, "Received boot complete broadcast");
+
+        List<Runnable> callbacks = new ArrayList<>(1);
+
+        synchronized (sLock) {
+            sIsBootCompleted = true;
+            callbacks.addAll(sCallbacks);
+            sCallbacks.clear();
+        }
+
+        // run callbacks outside of synchronized block
+        for (Runnable r : callbacks) {
+            Log.d(TAG, "Triggered callback");
+            r.run();
+        }
+    }
+}
diff --git a/service/java/com/android/server/wifi/ScanRequestProxy.java b/service/java/com/android/server/wifi/ScanRequestProxy.java
index 1b74191d5..cd5f1280e 100644
--- a/service/java/com/android/server/wifi/ScanRequestProxy.java
+++ b/service/java/com/android/server/wifi/ScanRequestProxy.java
@@ -453,7 +453,7 @@ public class ScanRequestProxy {
      * @return true if the scan request was placed or a scan is already ongoing, false otherwise.
      */
     public boolean startScan(int callingUid, String packageName) {
-        if (!retrieveWifiScannerIfNecessary()) {
+        if (!mScanningEnabled || !retrieveWifiScannerIfNecessary()) {
             Log.e(TAG, "Failed to retrieve wifiscanner");
             sendScanResultFailureBroadcastToPackage(packageName);
             return false;
diff --git a/service/java/com/android/server/wifi/WifiStackService.java b/service/java/com/android/server/wifi/WifiStackService.java
index dbf3882eb..8887005b0 100644
--- a/service/java/com/android/server/wifi/WifiStackService.java
+++ b/service/java/com/android/server/wifi/WifiStackService.java
@@ -31,8 +31,11 @@ import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.net.wifi.IWifiStackConnector;
+import android.net.wifi.WifiApiServiceInfo;
 import android.os.Binder;
+import android.os.Handler;
 import android.os.IBinder;
+import android.os.Looper;
 import android.os.UserHandle;
 import android.os.storage.StorageManager;
 import android.util.Log;
@@ -47,6 +50,7 @@ import com.android.server.wifi.scanner.WifiScanningService;
 import java.util.ArrayList;
 import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * Android service used to start the wifi stack when bound to via an intent.
@@ -67,41 +71,21 @@ public class WifiStackService extends Service {
         }
 
         @Override
-        public IBinder retrieveApiServiceImpl(@NonNull String serviceName) {
+        public List<WifiApiServiceInfo> getWifiApiServiceInfos() {
             // Ensure this is being invoked from system_server only.
             mContext.enforceCallingOrSelfPermission(
                     android.Manifest.permission.NETWORK_STACK, "WifiStackService");
             long ident = Binder.clearCallingIdentity();
             try {
                 synchronized (mApiServices) {
-                    WifiServiceBase serviceBase = mApiServices.get(serviceName);
-                    if (serviceBase == null) return null;
-                    return serviceBase.retrieveImpl();
-                }
-            } finally {
-                Binder.restoreCallingIdentity(ident);
-            }
-        }
-
-        @Override
-        public boolean startApiService(@NonNull String serviceName) {
-            // Ensure this is being invoked from system_server only.
-            mContext.enforceCallingOrSelfPermission(
-                    android.Manifest.permission.NETWORK_STACK, "WifiStackService");
-            long ident = Binder.clearCallingIdentity();
-            try {
-                synchronized (mApiServices) {
-                    WifiServiceBase serviceBase = mApiServices.get(serviceName);
-                    if (serviceBase == null) return false;
-                    serviceBase.onStart();
-                    // The current active user might have switched before the wifi services
-                    // started up. So, send a onSwitchUser callback just after onStart callback is
-                    // invoked.
-                    int currentUser = ActivityManager.getCurrentUser();
-                    if (currentUser != UserHandle.USER_SYSTEM) {
-                        serviceBase.onSwitchUser(currentUser);
-                    }
-                    return true;
+                    return mApiServices.entrySet().stream()
+                            .map(entry -> {
+                                WifiApiServiceInfo service = new WifiApiServiceInfo();
+                                service.name = entry.getKey();
+                                service.binder = entry.getValue().retrieveImpl();
+                                return service;
+                            })
+                            .collect(Collectors.toList());
                 }
             } finally {
                 Binder.restoreCallingIdentity(ident);
@@ -191,6 +175,16 @@ public class WifiStackService extends Service {
             return false;
         }
 
+        // BootCompleteReceiver is registered in AndroidManifest.xml and here. The receiver
+        // registered here is triggered earlier, while the receiver registered in the manifest
+        // is more reliable since it is registered earlier, so we are guaranteed to get the
+        // broadcast (if we register too late the broadcast may have already triggered and we
+        // would have missed it). Register in both places and BootCompleteReceiver will ensure that
+        // callbacks are called exactly once.
+        Log.d(TAG, "Registering BootCompleteReceiver to listen for ACTION_BOOT_COMPLETED");
+        context.registerReceiver(new BootCompleteReceiver(),
+                new IntentFilter(Intent.ACTION_BOOT_COMPLETED));
+
         synchronized (mApiServices) {
             // Top level wifi feature flag.
             if (!context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WIFI)) {
@@ -219,6 +213,22 @@ public class WifiStackService extends Service {
             }
         }
 
+        Handler handler = new Handler(Looper.myLooper());
+        // register callback to start Wifi services after boot completes
+        BootCompleteReceiver.registerCallback(() -> handler.post(() -> {
+            int currentUser = ActivityManager.getCurrentUser();
+            synchronized (mApiServices) {
+                for (WifiServiceBase service : mApiServices.values()) {
+                    service.onStart();
+                    // The current active user might have switched before the wifi services started
+                    // up. So, send a onSwitchUser callback just after onStart callback is invoked.
+                    if (currentUser != UserHandle.USER_SYSTEM) {
+                        service.onSwitchUser(currentUser);
+                    }
+                }
+            }
+        }));
+
         // Register broadcast receiver for system events.
         IntentFilter intentFilter = new IntentFilter();
         intentFilter.addAction(Intent.ACTION_USER_SWITCHED);
diff --git a/service/java/com/android/server/wifi/rtt/RttServiceImpl.java b/service/java/com/android/server/wifi/rtt/RttServiceImpl.java
index d69ce8f00..ce64d2e4a 100644
--- a/service/java/com/android/server/wifi/rtt/RttServiceImpl.java
+++ b/service/java/com/android/server/wifi/rtt/RttServiceImpl.java
@@ -399,7 +399,7 @@ public class RttServiceImpl extends IWifiRttManager.Stub {
     public boolean isAvailable() {
         long ident = Binder.clearCallingIdentity();
         try {
-            return mRttNative.isReady() && !mPowerManager.isDeviceIdleMode()
+            return mRttNative != null && mRttNative.isReady() && !mPowerManager.isDeviceIdleMode()
                     && mWifiPermissionsUtil.isLocationModeEnabled();
         } finally {
             Binder.restoreCallingIdentity(ident);
diff --git a/tests/wifitests/src/com/android/server/wifi/ScanRequestProxyTest.java b/tests/wifitests/src/com/android/server/wifi/ScanRequestProxyTest.java
index 09537769c..471c9ebb5 100644
--- a/tests/wifitests/src/com/android/server/wifi/ScanRequestProxyTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/ScanRequestProxyTest.java
@@ -144,6 +144,16 @@ public class ScanRequestProxyTest extends WifiBaseTest {
         validateMockitoUsage();
     }
 
+    private void enableScanning() {
+        // Enable scanning
+        mScanRequestProxy.enableScanning(true, false);
+        mInOrder.verify(mWifiScanner).registerScanListener(any());
+        mInOrder.verify(mWifiScanner).setScanningEnabled(true);
+        validateScanAvailableBroadcastSent(true);
+
+        when(mClock.getElapsedSinceBootMillis()).thenReturn(782L);
+    }
+
     /**
      * Verify scan enable sequence.
      */
@@ -181,8 +191,8 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testStartScanSuccess() {
+        enableScanning();
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
 
         assertTrue(mWorkSourceArgumentCaptor.getValue().equals(
@@ -197,9 +207,9 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testStartScanSuccessFromAppWithNetworkSettings() {
+        enableScanning();
         when(mWifiPermissionsUtil.checkNetworkSettingsPermission(TEST_UID)).thenReturn(true);
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
 
         assertTrue(mWorkSourceArgumentCaptor.getValue().equals(
@@ -212,9 +222,9 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testStartScanSuccessFromAppWithNetworkSetupWizard() {
+        enableScanning();
         when(mWifiPermissionsUtil.checkNetworkSetupWizardPermission(TEST_UID)).thenReturn(true);
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
 
         assertEquals(mWorkSourceArgumentCaptor.getValue(),
@@ -310,9 +320,9 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testScanSuccessOverwritesPreviousResults() {
+        enableScanning();
         // Make scan request 1.
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         // Verify the scan results processing for request 1.
         mGlobalScanListenerArgumentCaptor.getValue().onResults(mTestScanDatas1);
@@ -341,9 +351,9 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testScanFailureDoesNotOverwritePreviousResults() {
+        enableScanning();
         // Make scan request 1.
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         // Verify the scan results processing for request 1.
         mGlobalScanListenerArgumentCaptor.getValue().onResults(mTestScanDatas1);
@@ -373,9 +383,9 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testNewScanRequestAfterPreviousScanSucceeds() {
+        enableScanning();
         // Make scan request 1.
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         // Now send the scan results for request 1.
         mGlobalScanListenerArgumentCaptor.getValue().onResults(mTestScanDatas1);
@@ -407,9 +417,9 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testNewScanRequestAfterPreviousScanSucceedsWithInvalidScanDatas() {
+        enableScanning();
         // Make scan request 1.
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
 
         // Now send scan success for request 1, but with invalid scan datas.
@@ -441,9 +451,9 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testNewScanRequestAfterPreviousScanFailure() {
+        enableScanning();
         // Make scan request 1.
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
 
         // Now send scan failure for request 1.
@@ -504,11 +514,11 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testSuccessiveScanRequestsDontUseSameListener() {
+        enableScanning();
         WifiScanner.ScanListener listener1;
         WifiScanner.ScanListener listener2;
         // Make scan request 1.
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         listener1 = mScanRequestListenerArgumentCaptor.getValue();
 
@@ -530,14 +540,12 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testSuccessiveScanRequestFromSameFgAppThrottled() {
+        enableScanning();
         long firstRequestMs = 782;
         when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs);
         for (int i = 0; i < SCAN_REQUEST_THROTTLE_MAX_IN_TIME_WINDOW_FG_APPS; i++) {
             when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs + i);
             assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-            if (i == 0) {
-                mInOrder.verify(mWifiScanner).registerScanListener(any());
-            }
             mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         }
         // Make next scan request from the same package name & ensure that it is throttled.
@@ -556,14 +564,12 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testSuccessiveScanRequestFromSameFgAppNotThrottled() {
+        enableScanning();
         long firstRequestMs = 782;
         when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs);
         for (int i = 0; i < SCAN_REQUEST_THROTTLE_MAX_IN_TIME_WINDOW_FG_APPS; i++) {
             when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs + i);
             assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-            if (i == 0) {
-                mInOrder.verify(mWifiScanner).registerScanListener(any());
-            }
             mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         }
         long lastRequestMs = firstRequestMs + SCAN_REQUEST_THROTTLE_TIME_WINDOW_FG_APPS_MS + 1;
@@ -582,6 +588,7 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testSuccessiveScanRequestFromSameAppWithNetworkSettingsPermissionNotThrottled() {
+        enableScanning();
         when(mWifiPermissionsUtil.checkNetworkSettingsPermission(TEST_UID)).thenReturn(true);
 
         long firstRequestMs = 782;
@@ -589,9 +596,6 @@ public class ScanRequestProxyTest extends WifiBaseTest {
         for (int i = 0; i < SCAN_REQUEST_THROTTLE_MAX_IN_TIME_WINDOW_FG_APPS; i++) {
             when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs + i);
             assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-            if (i == 0) {
-                mInOrder.verify(mWifiScanner).registerScanListener(any());
-            }
             mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         }
         // Make next scan request from the same package name & ensure that it is not throttled.
@@ -605,6 +609,7 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testSuccessiveScanRequestFromSameAppWithNetworkSetupWizardPermissionNotThrottled() {
+        enableScanning();
         when(mWifiPermissionsUtil.checkNetworkSetupWizardPermission(TEST_UID)).thenReturn(true);
 
         long firstRequestMs = 782;
@@ -612,9 +617,6 @@ public class ScanRequestProxyTest extends WifiBaseTest {
         for (int i = 0; i < SCAN_REQUEST_THROTTLE_MAX_IN_TIME_WINDOW_FG_APPS; i++) {
             when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs + i);
             assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-            if (i == 0) {
-                mInOrder.verify(mWifiScanner).registerScanListener(any());
-            }
             mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         }
         // Make next scan request from the same package name & ensure that it is not throttled.
@@ -657,14 +659,12 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testSuccessiveScanRequestFromDifferentFgAppsNotThrottled() {
+        enableScanning();
         long firstRequestMs = 782;
         when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs);
         for (int i = 0; i < SCAN_REQUEST_THROTTLE_MAX_IN_TIME_WINDOW_FG_APPS / 2; i++) {
             when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs + i);
             assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-            if (i == 0) {
-                mInOrder.verify(mWifiScanner).registerScanListener(any());
-            }
             mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         }
         for (int i = 0; i < SCAN_REQUEST_THROTTLE_MAX_IN_TIME_WINDOW_FG_APPS / 2; i++) {
@@ -689,14 +689,12 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testSuccessiveScanRequestFromSameAppAfterRemovalAndReinstallNotThrottled() {
+        enableScanning();
         long firstRequestMs = 782;
         when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs);
         for (int i = 0; i < SCAN_REQUEST_THROTTLE_MAX_IN_TIME_WINDOW_FG_APPS; i++) {
             when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs + i);
             assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-            if (i == 0) {
-                mInOrder.verify(mWifiScanner).registerScanListener(any());
-            }
             mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         }
         // Now simulate removing the app.
@@ -718,14 +716,12 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testSuccessiveScanRequestFromSameAppAfterRemovalOnAnotherUserThrottled() {
+        enableScanning();
         long firstRequestMs = 782;
         when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs);
         for (int i = 0; i < SCAN_REQUEST_THROTTLE_MAX_IN_TIME_WINDOW_FG_APPS; i++) {
             when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs + i);
             assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-            if (i == 0) {
-                mInOrder.verify(mWifiScanner).registerScanListener(any());
-            }
             mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         }
         // Now simulate removing the app for another user (User 1).
@@ -748,6 +744,7 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testSuccessiveScanRequestFromBgAppsThrottled() {
+        enableScanning();
         when(mActivityManager.getPackageImportance(TEST_PACKAGE_NAME_1))
                 .thenReturn(IMPORTANCE_FOREGROUND_SERVICE + 1);
         when(mActivityManager.getPackageImportance(TEST_PACKAGE_NAME_2))
@@ -757,7 +754,6 @@ public class ScanRequestProxyTest extends WifiBaseTest {
         when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs);
         // Make scan request 1.
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
 
         // Make scan request 2 from the different package name & ensure that it is throttled.
@@ -774,6 +770,7 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testSuccessiveScanRequestFromBgAppsNotThrottled() {
+        enableScanning();
         when(mActivityManager.getPackageImportance(TEST_PACKAGE_NAME_1))
                 .thenReturn(ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND + 1);
         when(mActivityManager.getPackageImportance(TEST_PACKAGE_NAME_2))
@@ -783,7 +780,6 @@ public class ScanRequestProxyTest extends WifiBaseTest {
         when(mClock.getElapsedSinceBootMillis()).thenReturn(firstRequestMs);
         // Make scan request 1.
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
 
         long secondRequestMs =
@@ -802,9 +798,9 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testFullInternalScanResultsOverwritesPreviousResults() {
+        enableScanning();
         // Make scan request 1.
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         // Verify the scan results processing for request 1.
         mGlobalScanListenerArgumentCaptor.getValue().onResults(mTestScanDatas1);
@@ -832,9 +828,9 @@ public class ScanRequestProxyTest extends WifiBaseTest {
      */
     @Test
     public void testPartialInternalScanResultsDoesNotOverwritePreviousResults() {
+        enableScanning();
         // Make scan request 1.
         assertTrue(mScanRequestProxy.startScan(TEST_UID, TEST_PACKAGE_NAME_1));
-        mInOrder.verify(mWifiScanner).registerScanListener(any());
         mInOrder.verify(mWifiScanner).startScan(any(), any(), any());
         // Verify the scan results processing for request 1.
         mGlobalScanListenerArgumentCaptor.getValue().onResults(mTestScanDatas1);