Merge "WifiScannerImpl: PNO implementation (Part 1)" into mm-wireless-dev

am: d17c24a96d

* commit 'd17c24a96de6fdeec1d6d41ad5c986712d9acf18':
  WifiScannerImpl: PNO implementation (Part 1)

5 files changed, 216 insertions, 7 deletions

diff --git a/service/java/com/android/server/wifi/HalWifiScannerImpl.java b/service/java/com/android/server/wifi/HalWifiScannerImpl.java
index c7fbbd6c5..3da4010ea 100644
--- a/service/java/com/android/server/wifi/HalWifiScannerImpl.java
+++ b/service/java/com/android/server/wifi/HalWifiScannerImpl.java
@@ -196,6 +196,22 @@ public class HalWifiScannerImpl extends WifiScannerImpl implements Handler.Callb
     }
 
     @Override
+    public boolean setPnoList(WifiNative.PnoSettings settings,
+            WifiNative.PnoEventHandler eventHandler) {
+        return mWifiNative.setPnoList(settings, eventHandler);
+    }
+
+    @Override
+    public boolean resetPnoList(WifiNative.PnoSettings settings) {
+        return mWifiNative.resetPnoList();
+    }
+
+    @Override
+    public boolean shouldScheduleBackgroundScanForPno() {
+        return true;
+    }
+
+    @Override
     public WifiScanner.ScanData[] getLatestBatchedScanResults(boolean flush) {
         return mWifiNative.getScanResults(flush);
     }
diff --git a/service/java/com/android/server/wifi/SupplicantWifiScannerImpl.java b/service/java/com/android/server/wifi/SupplicantWifiScannerImpl.java
index 35209f578..168302170 100644
--- a/service/java/com/android/server/wifi/SupplicantWifiScannerImpl.java
+++ b/service/java/com/android/server/wifi/SupplicantWifiScannerImpl.java
@@ -19,6 +19,7 @@ package com.android.server.wifi;
 import android.app.AlarmManager;
 import android.content.Context;
 import android.net.wifi.ScanResult;
+import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiScanner;
 import android.os.Handler;
 import android.os.Looper;
@@ -85,6 +86,10 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
     private WifiNative.HotlistEventHandler mHotlistHandler = null;
     private ChangeBuffer mHotlistChangeBuffer = new ChangeBuffer();
 
+    // Pno related info.
+    private boolean mPnoRunning = false;
+    private WifiNative.PnoEventHandler mPnoEventHandler;
+
     AlarmManager.OnAlarmListener mScanPeriodListener = new AlarmManager.OnAlarmListener() {
             public void onAlarm() {
                 synchronized (mSettingsLock) {
@@ -248,6 +253,66 @@ public class SupplicantWifiScannerImpl extends WifiScannerImpl implements Handle
         }
     }
 
+    private boolean setNetworkPriorities(WifiNative.PnoNetwork[] networkList) {
+        if (networkList != null) {
+            if (DBG) Log.i(TAG, "Set priorities for PNO.");
+            for (WifiNative.PnoNetwork network : networkList) {
+                // What if this fails? Should we bail out?
+                boolean isSuccess = mWifiNative.setNetworkVariable(network.networkId,
+                        WifiConfiguration.priorityVarName,
+                        Integer.toString(network.priority));
+                if (!isSuccess) {
+                    Log.e(TAG, "Update priority failed for :" + network.networkId);
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
+    private boolean startPnoScan() {
+        if (!mWifiNative.setPnoScan(true)) {
+            mPnoRunning = true;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean setPnoList(WifiNative.PnoSettings settings,
+            WifiNative.PnoEventHandler eventHandler) {
+        if (mPnoRunning) return true;
+        mPnoEventHandler = eventHandler;
+        boolean isSuccess = setNetworkPriorities(settings.networkList);
+        if (!isSuccess) return false;
+        // For supplicant based PNO, we start the scan immediately when we set pno list.
+        return startPnoScan();
+    }
+
+    private boolean stopPnoScan() {
+        if (!mWifiNative.setPnoScan(false)) {
+            mPnoRunning = false;
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public boolean resetPnoList(WifiNative.PnoSettings settings) {
+        if (!mPnoRunning) return true;
+        mPnoEventHandler = null;
+        setNetworkPriorities(settings.networkList);
+        // For supplicant based PNO, we stop the scan immediately when we reset pno list.
+        return stopPnoScan();
+    }
+
+    @Override
+    public boolean shouldScheduleBackgroundScanForPno() {
+        return false;
+    }
+
     private void unscheduleScansLocked() {
         mAlarmManager.cancel(mScanPeriodListener);
         mLastScanSettings = null; // make sure that a running scan is marked as ended
diff --git a/service/java/com/android/server/wifi/WifiNative.java b/service/java/com/android/server/wifi/WifiNative.java
index 4aeb02d49..12d7b81c7 100644
--- a/service/java/com/android/server/wifi/WifiNative.java
+++ b/service/java/com/android/server/wifi/WifiNative.java
@@ -909,7 +909,16 @@ public class WifiNative {
             return doBooleanCommand("DRIVER COUNTRY");
     }
 
+    /**
+     * Start/Stop PNO scan.
+     * @param enable boolean indicating whether PNO is being enabled or disabled.
+     */
+    public boolean setPnoScan(boolean enable) {
+        String cmd = enable ? "SET pno 1" : "SET pno 0";
+        return doBooleanCommand(cmd);
+    }
 
+    // TODO(rpius): Move PnoMonitor to SupplicantWifiScannerImpl.
     //PNO Monitor
     private class PnoMonitor {
         private static final int MINIMUM_PNO_GAP = 5 * 1000;
@@ -955,8 +964,8 @@ public class WifiNative {
                 new IntentFilter(ACTION_TOGGLE_PNO));
         }
 
-        /*  Enable/Disable PNO with updated network priorities.
-         *
+        /**
+         * Enable/Disable PNO with updated network priorities.
          * @param enable boolean indicating whether PNO is being enabled or disabled.
          * @param pnoNetworkList list of networks with priorities to be set before PNO setting.
          */
@@ -976,8 +985,7 @@ public class WifiNative {
                     }
                 }
             }
-            String cmd = enable ? "SET pno 1" : "SET pno 0";
-            boolean ret = doBooleanCommand(cmd);
+            boolean ret = WifiNative.this.setPnoScan(enable);
             mLastPnoChangeTimeStamp = System.currentTimeMillis();
             if (ret) {
                 mCurrentPnoState = enable;
@@ -1799,8 +1807,15 @@ public class WifiNative {
         public String configKey; // kept for reference
 
         /**
+         * Default constructor needed in WifiScanningServiceImpl.
+         * TODO(rpius): Remove both the constructors.
+         */
+        PnoNetwork() {
+        }
+
+        /**
          * Constructor for the PnoNetwork object used by WifiStateMachine.
-         * TODO(rpius): Remove this interface when we remove the PNO usage out of StateMachine.
+         * TODO(rpius): Remove this constructor when we remove the PNO usage out of StateMachine.
          * @param config Corresponding configuration for the network
          * @param newPriority Priority to be set.
          */
diff --git a/service/java/com/android/server/wifi/WifiScannerImpl.java b/service/java/com/android/server/wifi/WifiScannerImpl.java
index d425f623f..41c356c29 100644
--- a/service/java/com/android/server/wifi/WifiScannerImpl.java
+++ b/service/java/com/android/server/wifi/WifiScannerImpl.java
@@ -108,6 +108,28 @@ public abstract class WifiScannerImpl {
     public abstract void restartBatchedScan();
 
     /**
+     * Set PNO list to start PNO background scan.
+     * @param settings PNO settings for this scan.
+     * @param eventHandler Event handler for notifying the scan results.
+     * @return true if success, false otherwise
+     */
+    public abstract boolean setPnoList(WifiNative.PnoSettings settings,
+            WifiNative.PnoEventHandler eventHandler);
+
+    /**
+     * Reset PNO list to terminate PNO background scan.
+     * @param settings PNO settings for this scan.
+     * @return true if success, false otherwise
+     */
+    public abstract boolean resetPnoList(WifiNative.PnoSettings settings);
+
+    /**
+     * This returns whether a background scan should be running for PNO scan or not.
+     * @return true if background scan needs to be started, false otherwise.
+     */
+    public abstract boolean shouldScheduleBackgroundScanForPno();
+
+    /**
      * Get the latest cached scan results from the last scan event. This should be called
      * immediately when the scan success callback is receieved.
      */
diff --git a/service/java/com/android/server/wifi/WifiScanningServiceImpl.java b/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
index 75f2cc229..6b1c92633 100644
--- a/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
+++ b/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
@@ -30,6 +30,7 @@ import android.net.wifi.WifiManager;
 import android.net.wifi.WifiScanner;
 import android.net.wifi.WifiScanner.BssidInfo;
 import android.net.wifi.WifiScanner.ChannelSpec;
+import android.net.wifi.WifiScanner.PnoSettings;
 import android.net.wifi.WifiScanner.ScanData;
 import android.net.wifi.WifiScanner.ScanSettings;
 import android.os.Binder;
@@ -187,6 +188,8 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
             switch (msg.what) {
                 case WifiScanner.CMD_START_BACKGROUND_SCAN:
                 case WifiScanner.CMD_STOP_BACKGROUND_SCAN:
+                case WifiScanner.CMD_START_PNO_SCAN:
+                case WifiScanner.CMD_STOP_PNO_SCAN:
                 case WifiScanner.CMD_SET_HOTLIST:
                 case WifiScanner.CMD_RESET_HOTLIST:
                 case WifiScanner.CMD_CONFIGURE_WIFI_CHANGE:
@@ -216,7 +219,8 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
     private static final int CMD_SCAN_PAUSED                         = BASE + 8;
     private static final int CMD_SCAN_RESTARTED                      = BASE + 9;
     private static final int CMD_STOP_SCAN_INTERNAL                  = BASE + 10;
-    private static final int CMD_SCAN_FAILED                       = BASE + 11;
+    private static final int CMD_SCAN_FAILED                         = BASE + 11;
+    private static final int CMD_PNO_NETWORK_FOUND                   = BASE + 12;
 
     private final Context mContext;
     private final Looper mLooper;
@@ -267,7 +271,8 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
     }
 
     class WifiScanningStateMachine extends StateMachine implements WifiNative.ScanEventHandler,
-            WifiNative.HotlistEventHandler, WifiNative.SignificantWifiChangeEventHandler {
+            WifiNative.PnoEventHandler, WifiNative.HotlistEventHandler,
+            WifiNative.SignificantWifiChangeEventHandler {
 
         private final DefaultState mDefaultState = new DefaultState();
         private final StartedState mStartedState = new StartedState();
@@ -340,6 +345,12 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
             sendMessage(CMD_WIFI_CHANGE_DETECTED, 0, 0, results);
         }
 
+        @Override
+        public void onPnoNetworkFound(ScanResult[] results) {
+            if (DBG) localLog("onWifiPnoNetworkFound event received");
+            sendMessage(CMD_PNO_NETWORK_FOUND, 0, 0, results);
+        }
+
         class DefaultState extends State {
             @Override
             public void enter() {
@@ -375,6 +386,8 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                         break;
                     case WifiScanner.CMD_START_BACKGROUND_SCAN:
                     case WifiScanner.CMD_STOP_BACKGROUND_SCAN:
+                    case WifiScanner.CMD_START_PNO_SCAN:
+                    case WifiScanner.CMD_STOP_PNO_SCAN:
                     case WifiScanner.CMD_START_SINGLE_SCAN:
                     case WifiScanner.CMD_STOP_SINGLE_SCAN:
                     case WifiScanner.CMD_SET_HOTLIST:
@@ -428,6 +441,21 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                     case WifiScanner.CMD_STOP_BACKGROUND_SCAN:
                         removeScanRequest(ci, msg.arg2);
                         break;
+                    case WifiScanner.CMD_START_PNO_SCAN:
+                        Bundle pnoParams = (Bundle) msg.obj;
+                        PnoSettings pnoSettings =
+                                pnoParams.getParcelable(WifiScanner.PNO_PARAMS_PNO_SETTINGS_KEY);
+                        ScanSettings scanSettings =
+                                pnoParams.getParcelable(WifiScanner.PNO_PARAMS_SCAN_SETTINGS_KEY);
+                        if (addScanRequestForPno(ci, msg.arg2, scanSettings, pnoSettings)) {
+                            replySucceeded(msg);
+                        } else {
+                            replyFailed(msg, WifiScanner.REASON_INVALID_REQUEST, "bad request");
+                        }
+                        break;
+                    case WifiScanner.CMD_STOP_PNO_SCAN:
+                        removeScanRequestForPno(ci, msg.arg2, (PnoSettings) msg.obj);
+                        break;
                     case WifiScanner.CMD_GET_SCAN_RESULTS:
                         reportScanResults(mScannerImpl.getLatestBatchedScanResults(true));
                         replySucceeded(msg);
@@ -507,6 +535,11 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                         // report this)
                         Log.e(TAG, "WifiScanner background scan gave CMD_SCAN_TERMINATED");
                         break;
+                    case CMD_PNO_NETWORK_FOUND: {
+                        ScanResult[] results = (ScanResult[]) msg.obj;
+                        reportPnoNetworkFound(results);
+                    }
+                    break;
                     default:
                         return NOT_HANDLED;
                 }
@@ -796,6 +829,17 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
             }
         }
 
+        void reportPnoNetworkFound(ScanResult[] results) {
+            WifiScanner.ParcelableScanResults parcelableScanResults =
+                    new WifiScanner.ParcelableScanResults(results);
+            Iterator<Integer> it = mSignificantWifiHandlers.iterator();
+            while (it.hasNext()) {
+                int handler = it.next();
+                mChannel.sendMessage(WifiScanner.CMD_PNO_NETWORK_FOUND, 0, handler,
+                        parcelableScanResults);
+            }
+        }
+
         void cleanup() {
             mScanSettings.clear();
             updateSchedule();
@@ -974,6 +1018,46 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
         }
     }
 
+    private WifiNative.PnoSettings convertPnoSettingsToNative(PnoSettings pnoSettings) {
+        WifiNative.PnoSettings nativePnoSetting = new WifiNative.PnoSettings();
+        nativePnoSetting.min5GHzRssi = pnoSettings.min5GHzRssi;
+        nativePnoSetting.min24GHzRssi = pnoSettings.min24GHzRssi;
+        nativePnoSetting.initialScoreMax = pnoSettings.initialScoreMax;
+        nativePnoSetting.currentConnectionBonus = pnoSettings.currentConnectionBonus;
+        nativePnoSetting.sameNetworkBonus = pnoSettings.sameNetworkBonus;
+        nativePnoSetting.secureBonus = pnoSettings.secureBonus;
+        nativePnoSetting.band5GHzBonus = pnoSettings.band5GHzBonus;
+        nativePnoSetting.networkList = new WifiNative.PnoNetwork[pnoSettings.networkList.length];
+        for (int i = 0; i < pnoSettings.networkList.length; i++) {
+            nativePnoSetting.networkList[i] = new WifiNative.PnoNetwork();
+            nativePnoSetting.networkList[i].ssid = pnoSettings.networkList[i].ssid;
+            nativePnoSetting.networkList[i].networkId = pnoSettings.networkList[i].networkId;
+            nativePnoSetting.networkList[i].priority = pnoSettings.networkList[i].priority;
+            nativePnoSetting.networkList[i].flags = pnoSettings.networkList[i].flags;
+            nativePnoSetting.networkList[i].auth = pnoSettings.networkList[i].authBitField;
+        }
+        return nativePnoSetting;
+    }
+
+    boolean addScanRequestForPno(ClientInfo ci, int handler, ScanSettings settings,
+            PnoSettings pnoSettings) {
+        if (!mScannerImpl.setPnoList(convertPnoSettingsToNative(pnoSettings), mStateMachine)) {
+            return false;
+        }
+        if (!mScannerImpl.shouldScheduleBackgroundScanForPno()) {
+            return true;
+        }
+        return addScanRequest(ci, handler, settings);
+    }
+
+    void removeScanRequestForPno(ClientInfo ci, int handler, PnoSettings pnoSettings) {
+        mScannerImpl.resetPnoList(convertPnoSettingsToNative(pnoSettings));
+        if (!mScannerImpl.shouldScheduleBackgroundScanForPno()) {
+            return;
+        }
+        removeScanRequest(ci, handler);
+    }
+
     boolean addSingleScanRequest(ClientInfo ci, int handler, ScanSettings settings) {
         if (ci == null) {
             Log.d(TAG, "Failing single scan request ClientInfo not found " + handler);
@@ -1114,6 +1198,13 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
         }
     }
 
+    void reportPnoNetworkFound(ScanResult[] results) {
+        Collection<ClientInfo> clients = mClients.values();
+        for (ClientInfo ci : clients) {
+            ci.reportPnoNetworkFound(results);
+        }
+    }
+
     class WifiChangeStateMachine extends StateMachine
             implements WifiNative.SignificantWifiChangeEventHandler {