5GHz roam configuration

Change-Id: I34a59b6de90bda5198e42c3ecf24e978efc73c93

7 files changed, 240 insertions, 61 deletions

diff --git a/service/java/com/android/server/wifi/WifiAutoJoinController.java b/service/java/com/android/server/wifi/WifiAutoJoinController.java
index c9870ed..a99a17b 100644
--- a/service/java/com/android/server/wifi/WifiAutoJoinController.java
+++ b/service/java/com/android/server/wifi/WifiAutoJoinController.java
@@ -1903,34 +1903,11 @@ public class WifiAutoJoinController {
             }
         }
 
-        if (networkSwitchType == AUTO_JOIN_IDLE) {
+        if (networkSwitchType == AUTO_JOIN_IDLE && !mWifiConfigStore.enableHalBasedPno.get()) {
             String currentBSSID = mWifiStateMachine.getCurrentBSSID();
             // Attempt same WifiConfiguration roaming
             ScanResult roamCandidate =
                     attemptRoam(null, currentConfiguration, mScanResultAutoJoinAge, currentBSSID);
-            /**
-             *  TODO: (post L initial release)
-             *  consider handling linked configurations roaming (i.e. extended Roaming)
-             *  thru the attemptRoam function which makes use of the RSSI roaming threshold.
-             *  At the moment, extended roaming is only handled thru the attemptAutoJoin()
-             *  function which compare configurations.
-             *
-             *  The advantage of making use of attemptRoam function is that this function
-             *  will looks at all the BSSID of each configurations, instead of only looking
-             *  at WifiConfiguration.visibility which keeps trackonly of the RSSI/band of the
-             *  two highest BSSIDs.
-             */
-            // Attempt linked WifiConfiguration roaming
-            /* if (currentConfiguration != null
-                    && currentConfiguration.linkedConfigurations != null) {
-                for (String key : currentConfiguration.linkedConfigurations.keySet()) {
-                    WifiConfiguration link = mWifiConfigStore.getWifiConfiguration(key);
-                    if (link != null) {
-                        roamCandidate = attemptRoam(roamCandidate, link, mScanResultAutoJoinAge,
-                                currentBSSID);
-                    }
-                }
-            }*/
             if (roamCandidate != null && currentBSSID != null
                     && currentBSSID.equals(roamCandidate.BSSID)) {
                 roamCandidate = null;
diff --git a/service/java/com/android/server/wifi/WifiNative.java b/service/java/com/android/server/wifi/WifiNative.java
index e921625..7eb35eb 100644
--- a/service/java/com/android/server/wifi/WifiNative.java
+++ b/service/java/com/android/server/wifi/WifiNative.java
@@ -2120,6 +2120,46 @@ public class WifiNative {
                 Log.d(TAG, "Ignoring Pno Network found event");
             }
         }
-}
+    }
+
+    public class WifiLazyRoamParams {
+        int A_band_boost_threshold;
+        int A_band_penalty_threshold;
+        int A_band_boost_factor;
+        int A_band_penalty_factor;
+        int A_band_max_boost;
+        int lazy_roam_hysteresis;
+        int alert_roam_rssi_trigger;
 
+        WifiLazyRoamParams() {
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder sbuf = new StringBuilder();
+            sbuf.append(" A_band_boost_threshold=").append(this.A_band_boost_threshold);
+            sbuf.append(" A_band_penalty_threshold=").append(this.A_band_penalty_threshold);
+            sbuf.append(" A_band_boost_factor=").append(this.A_band_boost_factor);
+            sbuf.append(" A_band_penalty_factor=").append(this.A_band_penalty_factor);
+            sbuf.append(" A_band_max_boost=").append(this.A_band_max_boost);
+            sbuf.append(" lazy_roam_hysteresis=").append(this.lazy_roam_hysteresis);
+            sbuf.append(" alert_roam_rssi_trigger=").append(this.alert_roam_rssi_trigger);
+            return sbuf.toString();
+        }
+    }
+
+    private native static boolean setLazyRoam(int iface, int id,
+                                              boolean enabled, WifiLazyRoamParams param);
+
+    synchronized public static boolean setLazyRoam(boolean enabled, WifiLazyRoamParams params) {
+        synchronized (mLock) {
+            if (startHal()) {
+                sPnoCmdId = getNewCmdIdLocked();
+
+                return setLazyRoam(sWlan0Index, sPnoCmdId, enabled, params);
+            } else {
+                return false;
+            }
+        }
+    }
 }
diff --git a/service/java/com/android/server/wifi/WifiStateMachine.java b/service/java/com/android/server/wifi/WifiStateMachine.java
index 01ca361..32539d8 100644
--- a/service/java/com/android/server/wifi/WifiStateMachine.java
+++ b/service/java/com/android/server/wifi/WifiStateMachine.java
@@ -3200,6 +3200,85 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
 
     }
 
+    // In associated more, lazy roam will be looking for 5GHz roam candidate
+    private boolean configureLazyRoam() {
+        boolean status;
+        if (!mAlwaysOnPnoSupported || (!mWifiConfigStore.enableHalBasedPno.get())) return false;
+
+        WifiNative.WifiLazyRoamParams params = mWifiNative.new WifiLazyRoamParams();
+        params.A_band_boost_threshold = mWifiConfigStore.bandPreferenceBoostThreshold5.get();
+        params.A_band_penalty_threshold = mWifiConfigStore.bandPreferencePenaltyThreshold5.get();
+        params.A_band_boost_factor = mWifiConfigStore.bandPreferenceBoostFactor5;
+        params.A_band_penalty_factor = mWifiConfigStore.bandPreferencePenaltyFactor5;
+        params.A_band_max_boost = 50;
+        params.lazy_roam_hysteresis = 25;
+        params.alert_roam_rssi_trigger = -75;
+
+        loge("startLazyRoam " + params.toString());
+
+        if (!WifiNative.setLazyRoam(true, params)) {
+
+            loge("startLazyRoam couldnt program params");
+
+            return false;
+        }
+        return true;
+    }
+
+    // This function sends a background scan request for the current configuration
+    private boolean setScanSettingsForLazyRoam() {
+
+        WifiConfiguration config = getCurrentWifiConfiguration();
+        HashSet<Integer> channels = mWifiConfigStore.makeChannelList(config,
+                ONE_HOUR_MILLI, false);
+        if (channels != null && channels.size() != 0) {
+
+            // then send a scan background request so as firmware
+            // starts looking for our networks
+            WifiScanner.ScanSettings settings = new WifiScanner.ScanSettings();
+            settings.band = WifiScanner.WIFI_BAND_UNSPECIFIED;
+            settings.channels = new WifiScanner.ChannelSpec[channels.size()];
+            int i = 0;
+
+            StringBuilder sb = new StringBuilder();
+            for (Integer channel : channels) {
+                settings.channels[i++] = new WifiScanner.ChannelSpec(channel);
+                sb.append(" " + channel);
+            }
+
+            // TODO, fix the scan interval logic
+            if (mScreenOn)
+                settings.periodInMs = mWifiConfigStore.wifiDisconnectedScanIntervalMs.get();
+            else
+                settings.periodInMs = mWifiConfigStore.wifiDisconnectedScanIntervalMs.get();
+
+            settings.reportEvents = WifiScanner.REPORT_EVENT_AFTER_BUFFER_FULL;
+            log("startLazyRoam: scan interval " + settings.periodInMs
+                    + " screen " + mScreenOn
+                    + " channels " + channels.size() + " : " + sb.toString());
+
+            mWifiScanner.startBackgroundScan(settings, mWifiScanListener);
+
+
+        } else {
+            if (DBG) loge("WifiStateMachine no channels for " + config.configKey());
+            return false;
+        }
+
+
+
+
+        return true;
+    }
+
+    // In associated more, lazy roam will be looking for 5GHz roam candidate
+    private boolean stopLazyRoam() {
+        boolean status;
+        if (!mAlwaysOnPnoSupported || (!mWifiConfigStore.enableHalBasedPno.get())) return false;
+
+        return WifiNative.setLazyRoam(false, null);
+    }
+
     private boolean startPno() {
         if (!mAlwaysOnPnoSupported || (!mWifiConfigStore.enableHalBasedPno.get())) return false;
 
@@ -3215,46 +3294,46 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
 
         List<WifiNative.WifiPnoNetwork> llist
                 = mWifiAutoJoinController.getPnoList(getCurrentWifiConfiguration());
-        if (llist != null) {
-            log("startPno: got llist size " + llist.size());
+        if (llist == null) {
+            log("startPno: couldnt get PNO list ");
+            return false;
+        }
+        log("startPno: got llist size " + llist.size());
 
-            // first program the network we want to look for thru the pno API
-            WifiNative.WifiPnoNetwork list[]
+        // first program the network we want to look for thru the pno API
+        WifiNative.WifiPnoNetwork list[]
                     = (WifiNative.WifiPnoNetwork[]) llist.toArray(new WifiNative.WifiPnoNetwork[0]);
 
-            if (!WifiNative.setPnoList(list, WifiStateMachine.this)) {
-                Log.e(TAG, "Failed to set pno, length = " + list.length);
-            }
+        if (!WifiNative.setPnoList(list, WifiStateMachine.this)) {
+            Log.e(TAG, "Failed to set pno, length = " + list.length);
+        }
 
-            // then send a scan background request so as firmware
-            // starts looking for our networks
-            WifiScanner.ScanSettings settings = new WifiScanner.ScanSettings();
-            settings.band = WifiScanner.WIFI_BAND_BOTH;
+        // then send a scan background request so as firmware
+        // starts looking for our networks
+        WifiScanner.ScanSettings settings = new WifiScanner.ScanSettings();
+        settings.band = WifiScanner.WIFI_BAND_BOTH;
 
-            // TODO, fix the scan interval logic
-            if (mScreenOn)
+        // TODO, fix the scan interval logic
+        if (mScreenOn)
                 settings.periodInMs = mDefaultFrameworkScanIntervalMs;
-            else
+        else
                 settings.periodInMs = mWifiConfigStore.wifiDisconnectedScanIntervalMs.get();
 
-            settings.reportEvents = WifiScanner.REPORT_EVENT_AFTER_BUFFER_FULL;
-            log("startPno: settings BOTH_BANDS, length = " + list.length);
+        settings.reportEvents = WifiScanner.REPORT_EVENT_AFTER_BUFFER_FULL;
+        log("startPno: settings BOTH_BANDS, length = " + list.length);
 
-            mWifiScanner.startBackgroundScan(settings, mWifiScanListener);
+        mWifiScanner.startBackgroundScan(settings, mWifiScanListener);
 //            mWifiScannerChannel.sendMessage
 //                  (WifiScanner.CMD_START_BACKGROUND_SCAN, settings);
-            if (DBG) {
-                StringBuilder sb = new StringBuilder();
-                sb.append(" list: ");
-                for (WifiNative.WifiPnoNetwork net : llist) {
-                    sb.append(" ").append(net.SSID).append(" auth ").append(net.auth);
-                }
-                sendMessage(CMD_STARTED_PNO_DBG, 1, 0, sb.toString());
+        if (DBG) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(" list: ");
+            for (WifiNative.WifiPnoNetwork net : llist) {
+                sb.append(" ").append(net.SSID).append(" auth ").append(net.auth);
             }
-            return true;
+            sendMessage(CMD_STARTED_PNO_DBG, 1, 0, sb.toString());
         }
-        log("startPno: couldnt get PNO list ");
-        return false;
+        return true;
     }
 
     private void handleScreenStateChanged(boolean screenOn, boolean startBackgroundScanIfNeeded) {
@@ -8080,11 +8159,13 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
             String address;
             updateDefaultRouteMacAddress(1000);
             if (DBG) {
-                log("ConnectedState Enter "
+                log("ConnectedState EEnter "
                         + " mScreenOn=" + mScreenOn
                         + " scanperiod="
                         + Integer.toString(mWifiConfigStore.associatedPartialScanPeriodMilli.get()) );
             }
+
+            configureLazyRoam();
             if (mScreenOn
                     && mWifiConfigStore.enableAutoJoinScanWhenAssociated.get()) {
                 if (mAlwaysOnPnoSupported) {
@@ -8116,6 +8197,8 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
             mWifiConfigStore.enableAllNetworks();
 
             mLastDriverRoamAttempt = 0;
+
+            //startLazyRoam();
         }
         @Override
         public boolean processMessage(Message message) {
@@ -8296,6 +8379,8 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
             loge("WifiStateMachine: Leaving Connected state");
             setScanAlarm(false);
             mLastDriverRoamAttempt = 0;
+
+            stopLazyRoam();
         }
     }
 
diff --git a/service/jni/com_android_server_wifi_WifiNative.cpp b/service/jni/com_android_server_wifi_WifiNative.cpp
index 5636653..bc775ac 100644
--- a/service/jni/com_android_server_wifi_WifiNative.cpp
+++ b/service/jni/com_android_server_wifi_WifiNative.cpp
@@ -87,6 +87,12 @@ int init_wifi_hal_func_table(wifi_hal_fn *hal_fn) {
     hal_fn->wifi_get_logger_supported_feature_set = wifi_get_logger_supported_feature_set_stub;
     hal_fn->wifi_get_ring_data = wifi_get_ring_data_stub;
     hal_fn->wifi_get_driver_version = wifi_get_driver_version_stub;
+    hal_fn->wifi_set_country_code = wifi_set_country_code;
+    hal_fn->wifi_set_ssid_white_list = wifi_set_ssid_white_list;
+    hal_fn->wifi_set_gscan_roam_params = wifi_set_gscan_roam_params;
+    hal_fn->wifi_set_bssid_preference = wifi_set_bssid_preference;
+    hal_fn->wifi_enable_lazy_roam = wifi_enable_lazy_roam;
+    hal_fn->wifi_set_bssid_blacklist = wifi_set_bssid_blacklist;
     return 0;
 }
 
@@ -1834,7 +1840,8 @@ static void onPnoNetworkFound(wifi_request_id id,
             env->SetObjectArrayElement(scanResults, i, scanResult);
         }
 
-        ALOGD("Scan result with ie length %d, i %u, <%s> rssi=%d %02x:%02x:%02x:%02x:%02x:%02x", results->ie_length, i,
+        ALOGD("Scan result with ie length %d, i %u, <%s> rssi=%d %02x:%02x:%02x:%02x:%02x:%02x",
+        results->ie_length, i,
             results[i].ssid, results[i].rssi, results[i].bssid[0], results[i].bssid[1],
             results[i].bssid[2], results[i].bssid[3], results[i].bssid[4], results[i].bssid[5]);
 
@@ -1941,6 +1948,34 @@ static jboolean android_net_wifi_setPnoListNative(
     return result >= 0;
 }
 
+static jboolean android_net_wifi_setLazyRoam(
+        JNIEnv *env, jclass cls, jint iface, jint id, jboolean enabled, jobject roam_param)  {
+
+    jboolean status = true;
+    wifi_roam_params params;
+    memset(&params, 0, sizeof(params));
+
+    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
+    ALOGD("configure lazy roam request [%d] = %p", id, handle);
+
+    if (roam_param != NULL) {
+        params.A_band_boost_threshold  = getIntField(env, roam_param, "A_band_boost_threshold");
+        params.A_band_penalty_threshold  = getIntField(env, roam_param, "A_band_penalty_threshold");
+        params.A_band_boost_factor = getIntField(env, roam_param, "A_band_boost_factor");
+        params.A_band_penalty_factor  = getIntField(env, roam_param, "A_band_penalty_factor");
+        params.A_band_max_boost  = getIntField(env, roam_param, "A_band_max_boost");
+        params.lazy_roam_hysteresis = getIntField(env, roam_param, "lazy_roam_hysteresis");
+        params.alert_roam_rssi_trigger = getIntField(env, roam_param, "alert_roam_rssi_trigger");
+        status = hal_fn.wifi_set_gscan_roam_params(id, handle, &params);
+    }
+    if (status) {
+        int doEnable = enabled ? 1 : 0;
+        status = hal_fn.wifi_enable_lazy_roam(id, handle, doEnable);
+    }
+    ALOGE("android_net_wifi_setLazyRoam\n");
+    return status;
+}
+
 // ----------------------------------------------------------------------------
 
 /*
@@ -2017,7 +2052,9 @@ static JNINativeMethod gWifiMethods[] = {
             (void*) android_net_wifi_start_logging_ring_buffer},
     {"getRingBufferDataNative", "(ILjava/lang/String;)Z",
             (void*) android_net_wifi_get_ring_buffer_data},
-    {"getFwMemoryDumpNative","(I)Z", (void*) android_net_wifi_get_fw_memory_dump}
+    {"getFwMemoryDumpNative","(I)Z", (void*) android_net_wifi_get_fw_memory_dump},
+    { "setLazyRoam", "(IIZLcom/android/server/wifi/WifiNative$WifiLazyRoamParams;)Z",
+            (void*) android_net_wifi_setLazyRoam}
 };
 
 int register_android_net_wifi_WifiNative(JNIEnv* env) {
diff --git a/service/jni/wifi_hal_stub.h b/service/jni/wifi_hal_stub.h
index d5f20d0..67cbc27 100644
--- a/service/jni/wifi_hal_stub.h
+++ b/service/jni/wifi_hal_stub.h
@@ -96,6 +96,16 @@ wifi_error wifi_get_logger_supported_feature_set_stub(wifi_interface_handle ifac
 wifi_error wifi_get_ring_data_stub(wifi_interface_handle iface, char *ring_name);
 wifi_error wifi_get_driver_version_stub(wifi_interface_handle iface, char **buffer,
         int *buffer_size);
+ wifi_error wifi_set_country_code_stub(wifi_interface_handle iface, const char *code);
+wifi_error wifi_set_bssid_blacklist_stub(wifi_request_id id, wifi_interface_handle iface,
+        wifi_bssid_params params);
+wifi_error wifi_enable_lazy_roam_stub(wifi_request_id id, wifi_interface_handle iface, int enable);
+wifi_error wifi_set_bssid_preference_stub(wifi_request_id id, wifi_interface_handle iface,
+                                    int num_bssid, wifi_bssid_preference *prefs);
+wifi_error wifi_set_gscan_roam_params_stub(wifi_request_id id, wifi_interface_handle iface,
+                                        wifi_roam_params * params);
+wifi_error wifi_set_ssid_white_list_stub(wifi_request_id id, wifi_interface_handle iface,
+                       int num_networks, wifi_ssid *ssids);
 #ifdef __cplusplus
 }
 #endif
diff --git a/service/lib/wifi_hal_stub.cpp b/service/lib/wifi_hal_stub.cpp
index ec337a0..c9f87f9 100644
--- a/service/lib/wifi_hal_stub.cpp
+++ b/service/lib/wifi_hal_stub.cpp
@@ -224,3 +224,28 @@ wifi_error wifi_get_driver_version_stub(wifi_interface_handle iface, char **buff
         int *buffer_size) {
     return WIFI_ERROR_NOT_SUPPORTED;
 }
+
+wifi_error wifi_set_bssid_blacklist_stub(wifi_request_id id, wifi_interface_handle iface,
+        wifi_bssid_params params) {
+      return WIFI_ERROR_NOT_SUPPORTED;
+}
+
+wifi_error wifi_enable_lazy_roam_stub(wifi_request_id id, wifi_interface_handle iface, int enable)
+{
+      return WIFI_ERROR_NOT_SUPPORTED;
+}
+
+wifi_error wifi_set_bssid_preference_stub(wifi_request_id id, wifi_interface_handle iface,
+                                    int num_bssid, wifi_bssid_preference *prefs) {
+      return WIFI_ERROR_NOT_SUPPORTED;
+}
+
+wifi_error wifi_set_gscan_roam_params_stub(wifi_request_id id, wifi_interface_handle iface,
+                                        wifi_roam_params * params) {
+      return WIFI_ERROR_NOT_SUPPORTED;
+}
+
+wifi_error wifi_set_ssid_white_list_stub(wifi_request_id id, wifi_interface_handle iface,
+                       int num_networks, wifi_ssid *ssids) {
+      return WIFI_ERROR_NOT_SUPPORTED;
+}
diff --git a/service/tools/halutil/halutil.cpp b/service/tools/halutil/halutil.cpp
index 6dc3ed6..e77570f 100644
--- a/service/tools/halutil/halutil.cpp
+++ b/service/tools/halutil/halutil.cpp
@@ -64,6 +64,11 @@ int init_wifi_hal_func_table(wifi_hal_fn *hal_fn) {
     hal_fn->wifi_get_logger_supported_feature_set = wifi_get_logger_supported_feature_set_stub;
     hal_fn->wifi_get_ring_data = wifi_get_ring_data_stub;
     hal_fn->wifi_get_driver_version = wifi_get_driver_version_stub;
+    hal_fn->wifi_set_ssid_white_list = wifi_set_ssid_white_list_stub;
+    hal_fn->wifi_set_gscan_roam_params = wifi_set_gscan_roam_params_stub;
+    hal_fn->wifi_set_bssid_preference = wifi_set_bssid_preference_stub;
+    hal_fn->wifi_set_bssid_blacklist = wifi_set_bssid_blacklist_stub;
+    hal_fn->wifi_enable_lazy_roam = wifi_enable_lazy_roam_stub;
     return 0;
 }
 
@@ -2697,7 +2702,7 @@ static wifi_error setWhitelistBSSIDs()
     }
 
     cmdId = getNewCmdId();
-    return wifi_set_ssid_white_list(cmdId, wlan0Handle, num_whitelist_ssids, params);
+    return hal_fn.wifi_set_ssid_white_list(cmdId, wlan0Handle, num_whitelist_ssids, params);
 }
 
 static wifi_error setRoamParams()
@@ -2716,7 +2721,7 @@ static wifi_error setRoamParams()
 
     cmdId = getNewCmdId();
     printMsg("Setting Roam params\n");
-    return wifi_set_gscan_roam_params(cmdId, wlan0Handle, &params);
+    return hal_fn.wifi_set_gscan_roam_params(cmdId, wlan0Handle, &params);
 }
 
 
@@ -2745,7 +2750,7 @@ static wifi_error setBSSIDPreference()
 
     cmdId = getNewCmdId();
     printMsg("Setting BSSID pref\n");
-    return wifi_set_bssid_preference(cmdId, wlan0Handle, num_pref_bssids, prefs);
+    return hal_fn.wifi_set_bssid_preference(cmdId, wlan0Handle, num_pref_bssids, prefs);
 }
 
 static wifi_error setLazyRoam()
@@ -2753,7 +2758,7 @@ static wifi_error setLazyRoam()
     int cmdId;
     cmdId = getNewCmdId();
     printMsg("Lazy roam\n");
-    return wifi_enable_lazy_roam(cmdId, wlan0Handle, lazy_roam);
+    return hal_fn.wifi_enable_lazy_roam(cmdId, wlan0Handle, lazy_roam);
 }
 
 static wifi_error setBlacklist()
@@ -2771,7 +2776,7 @@ static wifi_error setBlacklist()
         printMsg("%02x:%02x:%02x:%02x:%02x:%02x\n", addr[0],
                 addr[1], addr[2], addr[3], addr[4], addr[5]);
     }
-    return wifi_set_bssid_blacklist(cmdId, wlan0Handle, params);
+    return hal_fn.wifi_set_bssid_blacklist(cmdId, wlan0Handle, params);
 }
 
 static void testLazyRoam()
@@ -2786,7 +2791,7 @@ static void testLazyRoam()
     }
     result = setBlacklist();
     if (result == WIFI_SUCCESS) {
-        printMsg("Set Roaming Parameters\n");
+        printMsg("Set Blacklist Parameters\n");
     } else {
         printMsg("Could not set Roaming Parameters : %d\n", result);
     }