am 03ba4a5..ed3f1dd from mirror-m-wireless-internal-release

ed3f1dd Fix permissions check on WifiScanner APIs
f4b30aa Don't pause/restart scans across network connections
ad99846 Remove old (KK based) batched scan API support
fc42a2c Introduce battery blaming for WifiScanner
87df79e make autojoin more deterministic
d79bb0e Merge "enable background scan as soon as screen is off Bug:20909311" into m-wireless-dev
9ac124e enable background scan as soon as screen is off Bug:20909311
6d0cd10 change wifi Logging header
d4c25fd 5GHz roam configuration

Change-Id: Ib7621b11ca851236f9003947c24c5d84670fac94

11 files changed, 1088 insertions, 904 deletions

diff --git a/service/java/com/android/server/wifi/WifiAutoJoinController.java b/service/java/com/android/server/wifi/WifiAutoJoinController.java
index 42656dcc7..a04364f6a 100644
--- a/service/java/com/android/server/wifi/WifiAutoJoinController.java
+++ b/service/java/com/android/server/wifi/WifiAutoJoinController.java
@@ -109,6 +109,8 @@ public class WifiAutoJoinController {
 
     public static final int HIGH_THRESHOLD_MODIFIER = 5;
 
+    public static final int MAX_RSSI_DELTA = 50;
+
     // Below are AutoJoin wide parameters indicating if we should be aggressive before joining
     // weak network. Note that we cannot join weak network that are going to be marked as unanted by
     // ConnectivityService because this will trigger link flapping.
@@ -510,30 +512,17 @@ public class WifiAutoJoinController {
                         continue;
                     }
 
-                    // Compare RSSI values so as to evaluate the strength of the user preference
-                    int order = compareWifiConfigurationsRSSI(config, selected, null);
-
-                    if (order < -30) {
-                        // Selected configuration is worse than the visible configuration
-                        // hence register a strong choice so as autojoin cannot override this
-                        // for instance, the user has select a network
-                        // with 1 bar over a network with 3 bars...
-                        choice = 60;
-                    } else if (order < -20) {
-                        choice = 50;
-                    } else if (order < -10) {
-                        choice = 40;
-                    } else if (order < 20) {
-                        // Selected configuration is about same or has a slightly better RSSI
-                        // hence register a weaker choice, here a difference of at least +/-30 in
-                        // RSSI comparison triggered by autoJoin will override the choice
-                        choice = 30;
-                    } else {
-                        // Selected configuration is better than the visible configuration
-                        // hence we do not know if the user prefers this configuration strongly
-                        choice = 20;
+                    // If the selection was made while config was visible with reasonably good RSSI
+                    // then register the user preference, else ignore
+                    if (config.visibility == null ||
+                            (config.visibility.rssi24 < mWifiConfigStore.thresholdBadRssi24.get()
+                            && config.visibility.rssi5 < mWifiConfigStore.thresholdBadRssi5.get())
+                    ) {
+                        continue;
                     }
 
+                    choice = MAX_RSSI_DELTA + 10; // Make sure the choice overrides the RSSI diff
+
                     // The selected configuration was preferred over a recently seen config
                     // hence remember the user's choice:
                     // add the recently seen config to the selected's connectChoices array
@@ -546,11 +535,6 @@ public class WifiAutoJoinController {
                             + " over " + config.configKey(true)
                             + " choice " + Integer.toString(choice));
 
-                    Integer currentChoice = selected.connectChoices.get(config.configKey(true));
-                    if (currentChoice != null) {
-                        // User has made this choice multiple time in a row, so bump up a lot
-                        choice += currentChoice;
-                    }
                     // Add the visible config to the selected's connect choice list
                     selected.connectChoices.put(config.configKey(true), choice);
 
@@ -762,9 +746,9 @@ public class WifiAutoJoinController {
                 a.visibility, aRssiBoost, a.configKey(),
                 b.visibility, bRssiBoost, b.configKey());
 
-        // Normalize the order to [-50, +50]
-        if (order > 50) order = 50;
-        else if (order < -50) order = -50;
+        // Normalize the order to [-50, +50] = [ -MAX_RSSI_DELTA, MAX_RSSI_DELTA]
+        if (order > MAX_RSSI_DELTA) order = MAX_RSSI_DELTA;
+        else if (order < -MAX_RSSI_DELTA) order = -MAX_RSSI_DELTA;
 
         if (VDBG) {
             String prefer = " = ";
@@ -1912,34 +1896,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/WifiConfigStore.java b/service/java/com/android/server/wifi/WifiConfigStore.java
index bf7867ae7..0f5b78f77 100644
--- a/service/java/com/android/server/wifi/WifiConfigStore.java
+++ b/service/java/com/android/server/wifi/WifiConfigStore.java
@@ -2589,9 +2589,8 @@ public class WifiConfigStore extends IpConfigStore {
     }
 
     private boolean matchHomeSP(String fqdn) {
-        if (fqdn == null) {
+        if (fqdn == null)
             return false;
-        }
         List<String> labels = Utils.splitDomain(fqdn);
         for (HomeSP homeSP : mConfiguredHomeSPs.values()) {
             if (Utils.splitDomain(homeSP.getFQDN()).equals(labels)) {
diff --git a/service/java/com/android/server/wifi/WifiLogger.java b/service/java/com/android/server/wifi/WifiLogger.java
index 94a468e48..7b49252be 100644
--- a/service/java/com/android/server/wifi/WifiLogger.java
+++ b/service/java/com/android/server/wifi/WifiLogger.java
@@ -45,24 +45,37 @@ import java.io.PrintWriter;
  * - detect a failed WPA handshake that loops indefinitely
  * - authentication failure handling
  */
-class WifiLogger extends StateMachine {
+class WifiLogger  {
 
     private static final String TAG = "WifiLogger";
     private static boolean DBG = true;
-
-    private final WifiStateMachine mWifiStateMachine;
-
-    private final Context mContext;
-
-    private final State mEnabledState = new EnabledState();
-    private final State mDefaultState = new DefaultState();
-
+    private int mSupportedLoggerFeatures;
+    private RingBufferStatus[] mRingBufferStatuses;
 
     /* The base for wifi message types */
     static final int BASE = Protocol.BASE_WIFI_LOGGER;
     /* receive log data */
     static final int LOG_DATA                 = BASE + 1;
 
+    public static class RingBufferStatus{
+        String name;
+        int flag;
+        int ringBufferId;
+        int ringBufferByteSize;
+        int verboseLevel;
+        int writtenBytes;
+        int readBytes;
+        int writtenRecords;
+
+        @Override
+        public String toString() {
+            return "name: " + name + " flag: " + flag + " ringBufferId: " + ringBufferId +
+                    " ringBufferByteSize: " +ringBufferByteSize + " verboseLevel: " +verboseLevel +
+                    " writtenBytes: " + writtenBytes + " readBytes: " + readBytes +
+                    " writtenRecords: " + writtenRecords;
+        }
+    }
+
     void enableVerboseLogging(int verbose) {
         if (verbose > 0) {
             DBG = true;
@@ -71,64 +84,119 @@ class WifiLogger extends StateMachine {
         }
     }
 
-    private WifiNative.WifiLoggerEventHandler mEventHandler
-            = new WifiNative.WifiLoggerEventHandler() {
-        @Override
-        public void onDataAvailable(char data[], int len) {
-            sendMessage(LOG_DATA, data);
+
+
+    public  WifiLogger() {}
+
+    public int getSupportedFeatureSet() {
+        if(mSupportedLoggerFeatures == 0) {
+            mSupportedLoggerFeatures = WifiNative.getSupportedLoggerFeatureSet();
         }
-    };
 
-    public WifiLogger(Context c, WifiStateMachine wsm) {
-        super(TAG);
+        if(DBG) Log.d(TAG, "Supported Logger features is: " + mSupportedLoggerFeatures);
+        return mSupportedLoggerFeatures;
+    }
 
-        mContext = c;
-        mWifiStateMachine = wsm;
-        addState(mDefaultState);
-            addState(mEnabledState, mDefaultState);
+    public String getDriverVersion() {
+        String driverVersion = WifiNative.getDriverVersion();
+        if(DBG) Log.d(TAG, "Driver Version is: " + driverVersion);
+        return driverVersion;
+    }
 
-        setInitialState(mEnabledState);
-        setLogRecSize(50);
-        setLogOnlyTransitions(true);
-        //start the state machine
-        start();
+    public String getFirmwareVersion() {
+        String firmwareVersion = WifiNative.getFirmwareVersion();
+        if(DBG) Log.d(TAG, "Firmware Version is: " + firmwareVersion);
+        return firmwareVersion;
     }
 
-    /********************************************************
-     * HSM states
-     *******************************************************/
+    public RingBufferStatus[] getRingBufferStatus() {
 
-    class DefaultState extends State {
-        @Override
-         public void enter() {
-             if (DBG) Log.d(TAG, getName() + "\n");
-         }
-        @Override
-        public boolean processMessage(Message message) {
-            if (DBG) Log.d(TAG, getName() + message.toString() + "\n");
-            switch (message.what) {
-                case LOG_DATA:
-                    break;
-
-                default:
-                    Log.e(TAG, "Ignoring " + message);
-                    break;
+        mRingBufferStatuses = WifiNative.getRingBufferStatus();
+        if (mRingBufferStatuses != null) {
+            if(DBG) {
+                for (RingBufferStatus element : mRingBufferStatuses) {
+                    Log.d(TAG, "RingBufferStatus is: \n" + element);
+                }
             }
-            return HANDLED;
+        } else {
+            Log.e(TAG, "get empty RingBufferStatus");
         }
+
+        return mRingBufferStatuses;
     }
 
-    class EnabledState extends State {
-        @Override
-         public void enter() {
-             if (DBG) Log.d(TAG, getName() + "\n");
-         }
+    public static final int VERBOSE_NO_LOG = 0;
+    public static final int VERBOSE_NORMAL_LOG = 1;
+    /** Be careful since this one can affect performance and power */
+    public static final int VERBOSE_DETAILED_LOG  = 2;
+
+    /**
+     * start both logging and alert collection
+     * @param verboseLevel please check the definition above
+     * @param flags   TBD not used now
+     * @param maxInterval maximum interval in seconds for driver to report, ignore if zero
+     * @param minDataSize minimum data size in buffer for driver to report, ignore if zer0
+     * @param ringName  The name of the ring you'd like to report
+     * @return true -- successful false --failed
+     */
+    public boolean startLoggingRingBuffer(int verboseLevel, int flags, int maxInterval,
+            int minDataSize, String ringName) {
+        boolean result = WifiNative.startLoggingRingBuffer(verboseLevel,flags, maxInterval,
+                minDataSize, ringName);
+        if (DBG) Log.d("TAG", "RingBuffer- " + ringName + "'s verbose level is:" +
+                verboseLevel + (result ? "Successful" : "failed"));
+        return result;
+    }
+
+    public boolean startLoggingAllBuffer(int verboseLevel, int flags, int maxInterval,
+                                         int minDataSize){
+        Log.e(TAG, "startLoggingAllBuffer");
+        if (mRingBufferStatuses == null) {
+            getRingBufferStatus();
+            if(mRingBufferStatuses == null) {
+                Log.e(TAG, "Can not get Ring Buffer Status. Can not start Logging!");
+                return false;
+            }
+        }
+
+        for (RingBufferStatus element : mRingBufferStatuses){
+            boolean result = startLoggingRingBuffer(verboseLevel, flags, maxInterval, minDataSize,
+                    element.name);
+            if(!result) {
+                return false;
+            }
+        }
+
+        getRingBufferStatus();
+        return true;
     }
 
-    @Override
-    public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
-        super.dump(fd, pw, args);
+    public boolean getRingBufferData(String ringName) {
+        return WifiNative.getRingBufferData(ringName);
+    }
 
-        pw.println();
+    public boolean getAllRingBufferData() {
+        if (mRingBufferStatuses == null) {
+            getRingBufferStatus();
+            if(mRingBufferStatuses == null) {
+                Log.e(TAG, "Can not get Ring Buffer Status. Can not collect data!");
+                return false;
+            }
+        }
+
+        for (RingBufferStatus element : mRingBufferStatuses){
+            boolean result = getRingBufferData(element.name);
+            if(!result) {
+                Log.e(TAG, "Fail to get ring buffer data of: " + element.name);
+                return false;
+            }
+        }
+        Log.d(TAG, "getAllRingBufferData Successfully!");
+        return true;
+    }
+
+    public String getFwMemoryDump() {
+        return WifiNative.getFwMemoryDump();
     }
+
 }
diff --git a/service/java/com/android/server/wifi/WifiNative.java b/service/java/com/android/server/wifi/WifiNative.java
index 7440cf385..0cd1a0a07 100644
--- a/service/java/com/android/server/wifi/WifiNative.java
+++ b/service/java/com/android/server/wifi/WifiNative.java
@@ -31,6 +31,7 @@ import android.net.wifi.p2p.WifiP2pGroup;
 import android.net.wifi.p2p.nsd.WifiP2pServiceInfo;
 import android.os.SystemClock;
 import android.text.TextUtils;
+import android.util.Base64;
 import android.util.LocalLog;
 import android.util.Log;
 
@@ -1883,7 +1884,7 @@ public class WifiNative {
 
     /* Wifi Logger commands/events */
 
-    private static native boolean startLogging(int iface);
+    public static native boolean startLogging(int iface);
 
     public static interface WifiLoggerEventHandler {
         void onDataAvailable(char data[], int len);
@@ -1891,9 +1892,135 @@ public class WifiNative {
 
     private static WifiLoggerEventHandler sWifiLoggerEventHandler = null;
 
-    synchronized private static void onDataAvailable(char data[], int len) {
-        if (sWifiLoggerEventHandler != null) {
-            sWifiLoggerEventHandler.onDataAvailable(data, len);
+    public static class WifiLoggerEvent {
+        WifiLogger.RingBufferStatus status;
+        int entrySize;
+        int flags;
+        int type;
+        long timestamp;
+        byte[] entry;
+
+        public String toString() {
+            StringBuilder str =  new StringBuilder();
+            str.append(status + "\n entry size: " + entrySize + " flags: " + flags);
+            str.append(" type: " + type + " timestamp: " + timestamp +"\n");
+            if (entry != null) {
+                str.append(android.util.Base64.encodeToString(entry, Base64.DEFAULT));
+            } else {
+                str.append(" empty bytes[]");
+            }
+            str.append("\n\n");
+            return str.toString();
+        }
+    }
+
+    private static void onWifiLoggerEvent(WifiLoggerEvent event) {
+        if (event != null) {
+            Log.d(TAG, "Logger Event:" + event);
+        }
+    }
+
+    private static void onWifiAlert(byte[] buffer, int errorCode) {
+        Log.d(TAG, "Logger Alert error code:" + errorCode);
+        if (buffer != null) {
+            StringBuilder str =  new StringBuilder();
+            str.append(android.util.Base64.encodeToString(buffer, android.util.Base64.NO_WRAP));
+            Log.e(TAG,"Logger Alert event:");
+            Log.e(TAG, str.toString());
+        } else {
+            Log.e(TAG," empty Alert");
+        }
+    }
+
+    private static native boolean startLoggingRingBufferNative(int iface, int verboseLevel,
+            int flags, int maxInterval,int minDataSize, String ringName);
+    synchronized public static boolean startLoggingRingBuffer(int verboseLevel, int flags, int maxInterval,
+            int minDataSize, String ringName){
+        synchronized (mLock) {
+            if (startHal()) {
+                return startLoggingRingBufferNative(sWlan0Index, verboseLevel, flags, maxInterval,
+                        minDataSize, ringName);
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private static native int getSupportedLoggerFeatureSetNative(int iface);
+    synchronized public static int getSupportedLoggerFeatureSet() {
+        synchronized (mLock) {
+            if (startHal()) {
+                return getSupportedLoggerFeatureSetNative(sWlan0Index);
+            } else {
+                return -1;
+            }
+        }
+    }
+
+    private static native String getDriverVersionNative(int iface);
+    synchronized public static String getDriverVersion() {
+        synchronized (mLock) {
+            if (startHal()) {
+                return getDriverVersionNative(sWlan0Index);
+            } else {
+                return null;
+            }
+        }
+    }
+
+
+    private static native String getFirmwareVersionNative(int iface);
+    synchronized public static String getFirmwareVersion() {
+        synchronized (mLock) {
+            if (startHal()) {
+                return getFirmwareVersionNative(sWlan0Index);
+            } else {
+                return null;
+            }
+        }
+    }
+
+    private static native WifiLogger.RingBufferStatus[] getRingBufferStatusNative(int iface);
+    synchronized public static WifiLogger.RingBufferStatus[] getRingBufferStatus() {
+        synchronized (mLock) {
+            if (startHal()) {
+                return getRingBufferStatusNative(sWlan0Index);
+            } else {
+                return null;
+            }
+        }
+    }
+
+    private static native boolean getRingBufferDataNative(int iface, String ringName);
+    synchronized public static boolean getRingBufferData(String ringName) {
+        synchronized (mLock) {
+            if (startHal()) {
+                return getRingBufferDataNative(sWlan0Index, ringName);
+            } else {
+                return false;
+            }
+        }
+    }
+
+    public static String mFwMemoryDump;
+    private static void onWifiFwMemoryAvailable(byte[] buffer) {
+        Log.d(TAG, "onWifiFwMemoryAvailable is called");
+        mFwMemoryDump =  android.util.Base64.encodeToString(buffer, Base64.DEFAULT);
+    }
+    private static native boolean getFwMemoryDumpNative(int iface);
+    synchronized public static String getFwMemoryDump() {
+        synchronized (mLock) {
+            if (startHal()) {
+                if(getFwMemoryDumpNative(sWlan0Index)) {
+                    String tmp = mFwMemoryDump;
+                    mFwMemoryDump = null;
+                    return tmp;
+                } else {
+                    return null;
+                }
+            } else {
+                return null;
+            }
         }
     }
 
@@ -1995,6 +2122,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/WifiScanningServiceImpl.java b/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
index 93e7e46fd..cb63233c7 100644
--- a/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
+++ b/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
@@ -16,6 +16,7 @@
 
 package com.android.server.wifi;
 
+import android.Manifest;
 import android.app.AlarmManager;
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
@@ -39,13 +40,17 @@ import android.os.Message;
 import android.os.Messenger;
 import android.os.RemoteException;
 import android.os.SystemClock;
+import android.os.WorkSource;
 import android.util.Log;
 import android.util.Slog;
 
+import com.android.internal.app.IBatteryStats;
 import com.android.internal.util.AsyncChannel;
 import com.android.internal.util.Protocol;
 import com.android.internal.util.StateMachine;
 import com.android.internal.util.State;
+import com.android.server.am.BatteryStatsService;
+
 
 import java.io.FileDescriptor;
 import java.io.PrintWriter;
@@ -64,6 +69,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
     
     private static final int INVALID_KEY = 0;                               // same as WifiScanner
     private static final int MIN_PERIOD_PER_CHANNEL_MS = 200;               // DFS needs 120 ms
+    private static final int UNKNOWN_PID = -1;
 
     @Override
     public Messenger getMessenger() {
@@ -87,10 +93,11 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
         return b;
     }
 
-    private void enforceConnectivityInternalPermission() {
-        mContext.enforceCallingOrSelfPermission(
-                android.Manifest.permission.CONNECTIVITY_INTERNAL,
-                "WifiScanningServiceImpl");
+    private void enforceLocationHardwarePermission(int uid) {
+        mContext.enforcePermission(
+                Manifest.permission.LOCATION_HARDWARE,
+                UNKNOWN_PID, uid,
+                "LocationHardware");
     }
 
     private class ClientHandler extends Handler {
@@ -107,16 +114,17 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
             switch (msg.what) {
 
                 case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED:
-                    if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
-                        AsyncChannel c = (AsyncChannel) msg.obj;
-                        if (DBG) Slog.d(TAG, "New client listening to asynchronous messages: " +
-                                msg.replyTo);
-                        ClientInfo cInfo = new ClientInfo(c, msg.replyTo);
-                        mClients.put(msg.replyTo, cInfo);
-                    } else {
+                    if (msg.arg1 != AsyncChannel.STATUS_SUCCESSFUL) {
                         Slog.e(TAG, "Client connection failure, error=" + msg.arg1);
                     }
                     return;
+                case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION:
+                    AsyncChannel ac = new AsyncChannel();
+                    ac.connect(mContext, this, msg.replyTo);
+                    if (DBG) Slog.d(TAG, "New client connected : " + msg.sendingUid + msg.replyTo);
+                    ClientInfo cInfo = new ClientInfo(msg.sendingUid, ac, msg.replyTo);
+                    mClients.put(msg.replyTo, cInfo);
+                    return;
                 case AsyncChannel.CMD_CHANNEL_DISCONNECTED:
                     if (msg.arg1 == AsyncChannel.STATUS_SEND_UNSUCCESSFUL) {
                         Slog.e(TAG, "Send failed, client connection lost");
@@ -126,18 +134,16 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                     if (DBG) Slog.d(TAG, "closing client " + msg.replyTo);
                     ClientInfo ci = mClients.remove(msg.replyTo);
                     if (ci != null) {                       /* can be null if send failed above */
+                        if (DBG) Slog.d(TAG, "closing client " + ci.mUid);
                         ci.cleanup();
                     }
                     return;
-                case AsyncChannel.CMD_CHANNEL_FULL_CONNECTION:
-                    AsyncChannel ac = new AsyncChannel();
-                    ac.connect(mContext, this, msg.replyTo);
-                    return;
             }
 
             try {
-                enforceConnectivityInternalPermission();
+                enforceLocationHardwarePermission(msg.sendingUid);
             } catch (SecurityException e) {
+                Log.d(TAG, "failed to authorize app: " + e);
                 replyFailed(msg, WifiScanner.REASON_NOT_AUTHORIZED, "Not authorized");
                 return;
             }
@@ -193,6 +199,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
     private Context mContext;
     private WifiScanningStateMachine mStateMachine;
     private ClientHandler mClientHandler;
+    private IBatteryStats mBatteryStats;
 
     WifiScanningServiceImpl() { }
 
@@ -209,6 +216,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
         mClientHandler = new ClientHandler(thread.getLooper());
         mStateMachine = new WifiScanningStateMachine(thread.getLooper());
         mWifiChangeStateMachine = new WifiChangeStateMachine(thread.getLooper());
+        mBatteryStats = BatteryStatsService.getService();
 
         mContext.registerReceiver(
                 new BroadcastReceiver() {
@@ -524,13 +532,70 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
         private static final int MAX_LIMIT = 16;
         private final AsyncChannel mChannel;
         private final Messenger mMessenger;
+        private final int mUid;
+        private final WorkSource mWorkSource;
+        private boolean mScanWorkReported = false;
 
-        ClientInfo(AsyncChannel c, Messenger m) {
+        ClientInfo(int uid, AsyncChannel c, Messenger m) {
             mChannel = c;
             mMessenger = m;
+            mUid = uid;
+            mWorkSource = new WorkSource(uid, TAG);
             if (DBG) Slog.d(TAG, "New client, channel: " + c + " messenger: " + m);
         }
 
+        void reportBatchedScanStart() {
+            if (mUid == 0)
+                return;
+
+            int csph = getCsph();
+
+            try {
+                mBatteryStats.noteWifiBatchedScanStartedFromSource(mWorkSource, csph);
+                Log.d(TAG, "started scanning for UID " + mUid + ", csph = " + csph);
+            } catch (RemoteException e) {
+                Log.w(TAG, "failed to report scan work: " + e.toString());
+            }
+        }
+
+        void reportBatchedScanStop() {
+            if (mUid == 0)
+                return;
+
+            try {
+                mBatteryStats.noteWifiBatchedScanStoppedFromSource(mWorkSource);
+                Log.d(TAG, "stopped scanning for UID " + mUid);
+            } catch (RemoteException e) {
+                Log.w(TAG, "failed to cleanup scan work: " + e.toString());
+            }
+        }
+
+        int getCsph() {
+            int csph = 0;
+            for (ScanSettings settings : getScanSettings()) {
+                int num_channels = settings.channels == null ? 0 : settings.channels.length;
+                if (num_channels == 0 && settings.band != 0) {
+                    num_channels = getChannelsForBand(settings.band).length;
+                }
+
+                int scans_per_Hour = settings.periodInMs == 0 ? 1 : (3600 * 1000) / settings.periodInMs;
+                csph += num_channels * scans_per_Hour;
+            }
+
+            return csph;
+        }
+
+        void reportScanWorkUpdate() {
+            if (mScanWorkReported) {
+                reportBatchedScanStop();
+                mScanWorkReported = false;
+            }
+            if (mScanSettings.isEmpty() == false) {
+                reportBatchedScanStart();
+                mScanWorkReported = true;
+            }
+        }
+
         @Override
         public String toString() {
             StringBuffer sb = new StringBuffer();
@@ -569,6 +634,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
 
         void addScanRequest(ScanSettings settings, int id) {
             mScanSettings.put(id, settings);
+            reportScanWorkUpdate();
         }
 
         void removeScanRequest(int id) {
@@ -577,6 +643,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                 /* this was a single shot scan */
                 mChannel.sendMessage(WifiScanner.CMD_SINGLE_SCAN_COMPLETED, 0, id);
             }
+            reportScanWorkUpdate();
         }
 
         Iterator<Map.Entry<Integer, ScanSettings>> getScans() {
@@ -1642,7 +1709,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
 
         class ClientInfoLocal extends ClientInfo {
             ClientInfoLocal() {
-                super(null, null);
+                super(0, null, null);
             }
             @Override
             void deliverScanResults(int handler, ScanData results[]) {
diff --git a/service/java/com/android/server/wifi/WifiServiceImpl.java b/service/java/com/android/server/wifi/WifiServiceImpl.java
index 3b695ef65..49b1ab815 100644
--- a/service/java/com/android/server/wifi/WifiServiceImpl.java
+++ b/service/java/com/android/server/wifi/WifiServiceImpl.java
@@ -134,8 +134,6 @@ public final class WifiServiceImpl extends IWifiManager.Stub {
     /* Tracks the persisted states for wi-fi & airplane mode */
     final WifiSettingsStore mSettingsStore;
 
-    final boolean mBatchedScanSupported;
-
     /**
      * Asynchronous channel to WifiStateMachine
      */
@@ -318,9 +316,6 @@ public final class WifiServiceImpl extends IWifiManager.Stub {
         mClientHandler = new ClientHandler(wifiThread.getLooper());
         mWifiStateMachineHandler = new WifiStateMachineHandler(wifiThread.getLooper());
         mWifiController = new WifiController(mContext, this, wifiThread.getLooper());
-
-        mBatchedScanSupported = mContext.getResources().getBoolean(
-                R.bool.config_wifi_batched_scan_supported);
     }
 
 
@@ -454,44 +449,11 @@ public final class WifiServiceImpl extends IWifiManager.Stub {
                 settings, workSource);
     }
 
-    private class BatchedScanRequest extends DeathRecipient {
-        final BatchedScanSettings settings;
-        final int uid;
-        final int pid;
-        final WorkSource workSource;
-
-        BatchedScanRequest(BatchedScanSettings settings, IBinder binder, WorkSource ws) {
-            super(0, null, binder, null);
-            this.settings = settings;
-            this.uid = getCallingUid();
-            this.pid = getCallingPid();
-            workSource = ws;
-        }
-        public void binderDied() {
-            stopBatchedScan(settings, uid, pid);
-        }
-        public String toString() {
-            return "BatchedScanRequest{settings=" + settings + ", binder=" + mBinder + "}";
-        }
-
-        public boolean isSameApp(int uid, int pid) {
-            return (this.uid == uid && this.pid == pid);
-        }
-    }
-
-    private final List<BatchedScanRequest> mBatchedScanners = new ArrayList<BatchedScanRequest>();
-    boolean mInIdleMode;
-    boolean mScanPending;
-
     public boolean isBatchedScanSupported() {
-        return mBatchedScanSupported;
+        return false;
     }
 
-    public void pollBatchedScan() {
-        enforceChangePermission();
-        if (mBatchedScanSupported == false) return;
-        mWifiStateMachine.requestBatchedScanPoll();
-    }
+    public void pollBatchedScan() { }
 
     public String getWpsNfcConfigurationToken(int netId) {
         enforceConnectivityInternalPermission();
@@ -503,146 +465,14 @@ public final class WifiServiceImpl extends IWifiManager.Stub {
      */
     public boolean requestBatchedScan(BatchedScanSettings requested, IBinder binder,
             WorkSource workSource) {
-        enforceChangePermission();
-        if (workSource != null) {
-            enforceWorkSourcePermission();
-            // WifiManager currently doesn't use names, so need to clear names out of the
-            // supplied WorkSource to allow future WorkSource combining.
-            workSource.clearNames();
-        }
-        if (mBatchedScanSupported == false) return false;
-        requested = new BatchedScanSettings(requested);
-        if (requested.isInvalid()) return false;
-        BatchedScanRequest r = new BatchedScanRequest(requested, binder, workSource);
-        synchronized(mBatchedScanners) {
-            mBatchedScanners.add(r);
-            resolveBatchedScannersLocked();
-        }
-        return true;
+        return false;
     }
 
     public List<BatchedScanResult> getBatchedScanResults(String callingPackage) {
-        enforceAccessPermission();
-        if (mBatchedScanSupported == false) return new ArrayList<BatchedScanResult>();
-        int uid = Binder.getCallingUid();
-        int userId = UserHandle.getCallingUserId();
-        boolean hasInteractUsersFull = checkInteractAcrossUsersFull();
-        long ident = Binder.clearCallingIdentity();
-        try {
-            if (mAppOps.noteOp(AppOpsManager.OP_WIFI_SCAN, uid, callingPackage)
-                    != AppOpsManager.MODE_ALLOWED) {
-                return new ArrayList<BatchedScanResult>();
-            }
-            if (!isCurrentProfile(userId) && !hasInteractUsersFull) {
-                return new ArrayList<BatchedScanResult>();
-            }
-            return mWifiStateMachine.syncGetBatchedScanResultsList();
-        } finally {
-            Binder.restoreCallingIdentity(ident);
-        }
-    }
-
-    public void stopBatchedScan(BatchedScanSettings settings) {
-        enforceChangePermission();
-        if (mBatchedScanSupported == false) return;
-        stopBatchedScan(settings, getCallingUid(), getCallingPid());
-    }
-
-    private void stopBatchedScan(BatchedScanSettings settings, int uid, int pid) {
-        ArrayList<BatchedScanRequest> found = new ArrayList<BatchedScanRequest>();
-        synchronized(mBatchedScanners) {
-            for (BatchedScanRequest r : mBatchedScanners) {
-                if (r.isSameApp(uid, pid) && (settings == null || settings.equals(r.settings))) {
-                    found.add(r);
-                    if (settings != null) break;
-                }
-            }
-            for (BatchedScanRequest r : found) {
-                mBatchedScanners.remove(r);
-            }
-            if (found.size() != 0) {
-                resolveBatchedScannersLocked();
-            }
-        }
+        return null;
     }
 
-    private void resolveBatchedScannersLocked() {
-        BatchedScanSettings setting = new BatchedScanSettings();
-        WorkSource responsibleWorkSource = null;
-        int responsibleUid = 0;
-        double responsibleCsph = 0; // Channel Scans Per Hour
-
-        if (mBatchedScanners.size() == 0 || mInIdleMode) {
-            mWifiStateMachine.setBatchedScanSettings(null, 0, 0, null);
-            return;
-        }
-        for (BatchedScanRequest r : mBatchedScanners) {
-            BatchedScanSettings s = r.settings;
-
-            // evaluate responsibility
-            int currentChannelCount;
-            int currentScanInterval;
-            double currentCsph;
-
-            if (s.channelSet == null || s.channelSet.isEmpty()) {
-                // all channels - 11 B and 9 A channels roughly.
-                currentChannelCount = 9 + 11;
-            } else {
-                currentChannelCount = s.channelSet.size();
-                // these are rough est - no real need to correct for reg-domain;
-                if (s.channelSet.contains("A")) currentChannelCount += (9 - 1);
-                if (s.channelSet.contains("B")) currentChannelCount += (11 - 1);
-
-            }
-            if (s.scanIntervalSec == BatchedScanSettings.UNSPECIFIED) {
-                currentScanInterval = BatchedScanSettings.DEFAULT_INTERVAL_SEC;
-            } else {
-                currentScanInterval = s.scanIntervalSec;
-            }
-            currentCsph = 60 * 60 * currentChannelCount / currentScanInterval;
-
-            if (currentCsph > responsibleCsph) {
-                responsibleUid = r.uid;
-                responsibleWorkSource = r.workSource;
-                responsibleCsph = currentCsph;
-            }
-
-            if (s.maxScansPerBatch != BatchedScanSettings.UNSPECIFIED &&
-                    s.maxScansPerBatch < setting.maxScansPerBatch) {
-                setting.maxScansPerBatch = s.maxScansPerBatch;
-            }
-            if (s.maxApPerScan != BatchedScanSettings.UNSPECIFIED &&
-                    (setting.maxApPerScan == BatchedScanSettings.UNSPECIFIED ||
-                    s.maxApPerScan > setting.maxApPerScan)) {
-                setting.maxApPerScan = s.maxApPerScan;
-            }
-            if (s.scanIntervalSec != BatchedScanSettings.UNSPECIFIED &&
-                    s.scanIntervalSec < setting.scanIntervalSec) {
-                setting.scanIntervalSec = s.scanIntervalSec;
-            }
-            if (s.maxApForDistance != BatchedScanSettings.UNSPECIFIED &&
-                    (setting.maxApForDistance == BatchedScanSettings.UNSPECIFIED ||
-                    s.maxApForDistance > setting.maxApForDistance)) {
-                setting.maxApForDistance = s.maxApForDistance;
-            }
-            if (s.channelSet != null && s.channelSet.size() != 0) {
-                if (setting.channelSet == null || setting.channelSet.size() != 0) {
-                    if (setting.channelSet == null) setting.channelSet = new ArrayList<String>();
-                    for (String i : s.channelSet) {
-                        if (setting.channelSet.contains(i) == false) setting.channelSet.add(i);
-                    }
-                } // else, ignore the constraint - we already use all channels
-            } else {
-                if (setting.channelSet == null || setting.channelSet.size() != 0) {
-                    setting.channelSet = new ArrayList<String>();
-                }
-            }
-        }
-
-        setting.constrain();
-        mWifiStateMachine.setBatchedScanSettings(setting, responsibleUid, (int)responsibleCsph,
-                responsibleWorkSource);
-    }
+    public void stopBatchedScan(BatchedScanSettings settings) { }
 
     void handleIdleModeChanged() {
         boolean doScan = false;
diff --git a/service/java/com/android/server/wifi/WifiStateMachine.java b/service/java/com/android/server/wifi/WifiStateMachine.java
index ebb3e12ac..6bf3994a9 100644
--- a/service/java/com/android/server/wifi/WifiStateMachine.java
+++ b/service/java/com/android/server/wifi/WifiStateMachine.java
@@ -66,8 +66,6 @@ import android.net.NetworkUtils;
 import android.net.RouteInfo;
 import android.net.StaticIpConfiguration;
 import android.net.TrafficStats;
-import android.net.wifi.BatchedScanResult;
-import android.net.wifi.BatchedScanSettings;
 import android.net.wifi.RssiPacketCountInfo;
 import android.net.wifi.ScanResult;
 import android.net.wifi.ScanSettings;
@@ -214,13 +212,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
     private int mNumScanResultsKnown;
     private int mNumScanResultsReturned;
 
-    /* Batch scan results */
-    private final List<BatchedScanResult> mBatchedScanResults =
-            new ArrayList<BatchedScanResult>();
-    private int mBatchedScanOwnerUid = UNKNOWN_SCAN_SOURCE;
-    private int mExpectedBatchedScans = 0;
-    private long mBatchedScanMinPollTime = 0;
-
     private boolean mScreenOn = false;
 
     /* Chipset supports background scan */
@@ -303,9 +294,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
     private static final String CUSTOMIZED_SCAN_WORKSOURCE = "customized_scan_worksource";
     private static final String SCAN_REQUEST_TIME = "scan_request_time";
 
-    private static final String BATCHED_SETTING = "batched_settings";
-    private static final String BATCHED_WORKSOURCE = "batched_worksource";
-
     /* Tracks if state machine has received any screen state change broadcast yet.
      * We can miss one of these at boot.
      */
@@ -506,7 +494,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
     private AlarmManager mAlarmManager;
     private PendingIntent mScanIntent;
     private PendingIntent mDriverStopIntent;
-    private PendingIntent mBatchedScanIntervalIntent;
 
     /* Tracks current frequency mode */
     private AtomicInteger mFrequencyBand = new AtomicInteger(WifiManager.WIFI_FREQUENCY_BAND_AUTO);
@@ -719,15 +706,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
 
     public static final int CMD_BOOT_COMPLETED = BASE + 134;
 
-    /* change the batch scan settings.
-     * arg1 = responsible UID
-     * arg2 = csph (channel scans per hour)
-     * obj = bundle with the new settings and the optional worksource
-     */
-    public static final int CMD_SET_BATCHED_SCAN = BASE + 135;
-    public static final int CMD_START_NEXT_BATCHED_SCAN = BASE + 136;
-    public static final int CMD_POLL_BATCHED_SCAN = BASE + 137;
-
     /* We now have a valid IP configuration. */
     static final int CMD_IP_CONFIGURATION_SUCCESSFUL = BASE + 138;
     /* We no longer have a valid IP configuration. */
@@ -987,8 +965,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
     private static final String ACTION_DELAYED_DRIVER_STOP =
             "com.android.server.WifiManager.action.DELAYED_DRIVER_STOP";
 
-    private static final String ACTION_REFRESH_BATCHED_SCAN =
-            "com.android.server.WifiManager.action.REFRESH_BATCHED_SCAN";
     /**
      * Keep track of whether WIFI is running.
      */
@@ -1011,18 +987,7 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
 
     private final IBatteryStats mBatteryStats;
 
-    private BatchedScanSettings mBatchedScanSettings = null;
-
-    /**
-     * Track the worksource/cost of the current settings and track what's been noted
-     * to the battery stats, so we can mark the end of the previous when changing.
-     */
-    private WorkSource mBatchedScanWorkSource = null;
-    private int mBatchedScanCsph = 0;
-    private WorkSource mNotedBatchedScanWorkSource = null;
-    private int mNotedBatchedScanCsph = 0;
-
-    private final String mTcpBufferSizes;
+    private String mTcpBufferSizes = null;
 
     // Used for debug and stats gathering
     private static int sScanAlarmIntentCount = 0;
@@ -1050,8 +1015,9 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
         mWifiConfigStore = new WifiConfigStore(context, mWifiNative);
         mWifiAutoJoinController = new WifiAutoJoinController(context, this,
                 mWifiConfigStore, mWifiConnectionStatistics, mWifiNative);
-        mWifiLogger = new WifiLogger(mContext, this);
         mWifiMonitor = new WifiMonitor(this, mWifiNative);
+        mWifiLogger = new WifiLogger();
+
         mWifiInfo = new WifiInfo();
         mSupplicantStateTracker = new SupplicantStateTracker(context, this, mWifiConfigStore,
                 getHandler());
@@ -1093,7 +1059,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
 
         mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
         mScanIntent = getPrivateBroadcast(ACTION_START_SCAN, SCAN_REQUEST);
-        mBatchedScanIntervalIntent = getPrivateBroadcast(ACTION_REFRESH_BATCHED_SCAN, 0);
 
         // Make sure the interval is not configured less than 10 seconds
         int period = mContext.getResources().getInteger(
@@ -1149,7 +1114,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
         IntentFilter filter = new IntentFilter();
         filter.addAction(Intent.ACTION_SCREEN_ON);
         filter.addAction(Intent.ACTION_SCREEN_OFF);
-        filter.addAction(ACTION_REFRESH_BATCHED_SCAN);
         mContext.registerReceiver(
                 new BroadcastReceiver() {
                     @Override
@@ -1160,8 +1124,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
                             sendMessage(CMD_SCREEN_STATE_CHANGED, 1);
                         } else if (action.equals(Intent.ACTION_SCREEN_OFF)) {
                             sendMessage(CMD_SCREEN_STATE_CHANGED, 0);
-                        } else if (action.equals(ACTION_REFRESH_BATCHED_SCAN)) {
-                            startNextBatchedScanAsync();
                         }
                     }
                 }, filter);
@@ -1489,145 +1451,7 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
         sendMessage(CMD_START_SCAN, callingUid, scanCounter, bundle);
     }
 
-    /**
-     * start or stop batched scanning using the given settings
-     */
-    public void setBatchedScanSettings(BatchedScanSettings settings, int callingUid, int csph,
-                                       WorkSource workSource) {
-        Bundle bundle = new Bundle();
-        bundle.putParcelable(BATCHED_SETTING, settings);
-        bundle.putParcelable(BATCHED_WORKSOURCE, workSource);
-        sendMessage(CMD_SET_BATCHED_SCAN, callingUid, csph, bundle);
-    }
-
-    public List<BatchedScanResult> syncGetBatchedScanResultsList() {
-        synchronized (mBatchedScanResults) {
-            List<BatchedScanResult> batchedScanList =
-                    new ArrayList<BatchedScanResult>(mBatchedScanResults.size());
-            for (BatchedScanResult result : mBatchedScanResults) {
-                batchedScanList.add(new BatchedScanResult(result));
-            }
-            return batchedScanList;
-        }
-    }
-
-    public void requestBatchedScanPoll() {
-        sendMessage(CMD_POLL_BATCHED_SCAN);
-    }
-
-    private void startBatchedScan() {
-        if (mBatchedScanSettings == null) return;
-
-        if (mDhcpActive) {
-            if (DBG) log("not starting Batched Scans due to DHCP");
-            return;
-        }
-
-        // first grab any existing data
-        retrieveBatchedScanData();
-
-        if (PDBG) loge("try  starting Batched Scans due to DHCP");
-
-
-        mAlarmManager.cancel(mBatchedScanIntervalIntent);
-
-        String scansExpected = mWifiNative.setBatchedScanSettings(mBatchedScanSettings);
-        try {
-            mExpectedBatchedScans = Integer.parseInt(scansExpected);
-            setNextBatchedAlarm(mExpectedBatchedScans);
-            if (mExpectedBatchedScans > 0) noteBatchedScanStart();
-        } catch (NumberFormatException e) {
-            stopBatchedScan();
-            loge("Exception parsing WifiNative.setBatchedScanSettings response " + e);
-        }
-    }
-
     // called from BroadcastListener
-    private void startNextBatchedScanAsync() {
-        sendMessage(CMD_START_NEXT_BATCHED_SCAN);
-    }
-
-    private void startNextBatchedScan() {
-        // first grab any existing data
-        retrieveBatchedScanData();
-
-        setNextBatchedAlarm(mExpectedBatchedScans);
-    }
-
-    private void handleBatchedScanPollRequest() {
-        if (DBG) {
-            log("handleBatchedScanPoll Request - mBatchedScanMinPollTime=" +
-                    mBatchedScanMinPollTime + " , mBatchedScanSettings=" +
-                    mBatchedScanSettings);
-        }
-        // if there is no appropriate PollTime that's because we either aren't
-        // batching or we've already set a time for a poll request
-        if (mBatchedScanMinPollTime == 0) return;
-        if (mBatchedScanSettings == null) return;
-
-        long now = System.currentTimeMillis();
-
-        if (now > mBatchedScanMinPollTime) {
-            // do the poll and reset our timers
-            startNextBatchedScan();
-        } else {
-            mAlarmManager.setExact(AlarmManager.RTC_WAKEUP, mBatchedScanMinPollTime,
-                    mBatchedScanIntervalIntent);
-            mBatchedScanMinPollTime = 0;
-        }
-    }
-
-    // return true if new/different
-    private boolean recordBatchedScanSettings(int responsibleUid, int csph, Bundle bundle) {
-        BatchedScanSettings settings = bundle.getParcelable(BATCHED_SETTING);
-        WorkSource responsibleWorkSource = bundle.getParcelable(BATCHED_WORKSOURCE);
-
-        if (DBG) {
-            log("set batched scan to " + settings + " for uid=" + responsibleUid +
-                    ", worksource=" + responsibleWorkSource);
-        }
-        if (settings != null) {
-            if (settings.equals(mBatchedScanSettings)) return false;
-        } else {
-            if (mBatchedScanSettings == null) return false;
-        }
-        mBatchedScanSettings = settings;
-        if (responsibleWorkSource == null) responsibleWorkSource = new WorkSource(responsibleUid);
-        mBatchedScanWorkSource = responsibleWorkSource;
-        mBatchedScanCsph = csph;
-        return true;
-    }
-
-    private void stopBatchedScan() {
-        mAlarmManager.cancel(mBatchedScanIntervalIntent);
-        retrieveBatchedScanData();
-        mWifiNative.setBatchedScanSettings(null);
-        noteBatchedScanStop();
-    }
-
-    private void setNextBatchedAlarm(int scansExpected) {
-
-        if (mBatchedScanSettings == null || scansExpected < 1) return;
-
-        mBatchedScanMinPollTime = System.currentTimeMillis() +
-                mBatchedScanSettings.scanIntervalSec * 1000;
-
-        if (mBatchedScanSettings.maxScansPerBatch < scansExpected) {
-            scansExpected = mBatchedScanSettings.maxScansPerBatch;
-        }
-
-        int secToFull = mBatchedScanSettings.scanIntervalSec;
-        secToFull *= scansExpected;
-
-        int debugPeriod = SystemProperties.getInt("wifi.batchedScan.pollPeriod", 0);
-        if (debugPeriod > 0) secToFull = debugPeriod;
-
-        // set the alarm to do the next poll.  We set it a little short as we'd rather
-        // wake up wearly than miss a scan due to buffer overflow
-        mAlarmManager.setExact(AlarmManager.RTC_WAKEUP, System.currentTimeMillis()
-                        + ((secToFull - (mBatchedScanSettings.scanIntervalSec / 2)) * 1000),
-                mBatchedScanIntervalIntent);
-    }
 
     /**
      * Start reading new scan data
@@ -1658,156 +1482,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
      */
     private final static boolean DEBUG_PARSE = false;
 
-    private void retrieveBatchedScanData() {
-        String rawData = mWifiNative.getBatchedScanResults();
-        if (DEBUG_PARSE) log("rawData = " + rawData);
-        mBatchedScanMinPollTime = 0;
-        if (rawData == null || rawData.equalsIgnoreCase("OK")) {
-            loge("Unexpected BatchedScanResults :" + rawData);
-            return;
-        }
-
-        int scanCount = 0;
-        final String END_OF_BATCHES = "----";
-        final String SCANCOUNT = "scancount=";
-        final String TRUNCATED = "trunc";
-        final String AGE = "age=";
-        final String DIST = "dist=";
-        final String DISTSD = "distSd=";
-
-        String splitData[] = rawData.split("\n");
-        int n = 0;
-        if (splitData[n].startsWith(SCANCOUNT)) {
-            try {
-                scanCount = Integer.parseInt(splitData[n++].substring(SCANCOUNT.length()));
-            } catch (NumberFormatException e) {
-                loge("scancount parseInt Exception from " + splitData[n]);
-            }
-        } else log("scancount not found");
-        if (scanCount == 0) {
-            loge("scanCount==0 - aborting");
-            return;
-        }
-
-        final Intent intent = new Intent(WifiManager.BATCHED_SCAN_RESULTS_AVAILABLE_ACTION);
-        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
-
-        synchronized (mBatchedScanResults) {
-            mBatchedScanResults.clear();
-            BatchedScanResult batchedScanResult = new BatchedScanResult();
-
-            String bssid = null;
-            WifiSsid wifiSsid = null;
-            int level = 0;
-            int freq = 0;
-            int dist, distSd;
-            long tsf = 0;
-            dist = distSd = ScanResult.UNSPECIFIED;
-            final long now = SystemClock.elapsedRealtime();
-            final int bssidStrLen = BSSID_STR.length();
-
-            while (true) {
-                while (n < splitData.length) {
-                    if (DEBUG_PARSE) logd("parsing " + splitData[n]);
-                    if (splitData[n].equals(END_OF_BATCHES)) {
-                        if (n + 1 != splitData.length) {
-                            loge("didn't consume " + (splitData.length - n));
-                        }
-                        if (mBatchedScanResults.size() > 0) {
-                            mContext.sendBroadcastAsUser(intent, UserHandle.ALL);
-                        }
-                        logd("retrieveBatchedScanResults X");
-                        return;
-                    }
-                    if ((splitData[n].equals(END_STR)) || splitData[n].equals(DELIMITER_STR)) {
-                        if (bssid != null) {
-                            batchedScanResult.scanResults.add(new ScanResult(
-                                    wifiSsid, bssid, null,
-                                    level, freq, tsf, dist, distSd));
-                            wifiSsid = null;
-                            bssid = null;
-                            level = 0;
-                            freq = 0;
-                            tsf = 0;
-                            dist = distSd = ScanResult.UNSPECIFIED;
-                        }
-                        if (splitData[n].equals(END_STR)) {
-                            if (batchedScanResult.scanResults.size() != 0) {
-                                mBatchedScanResults.add(batchedScanResult);
-                                batchedScanResult = new BatchedScanResult();
-                            } else {
-                                logd("Found empty batch");
-                            }
-                        }
-                    } else if (splitData[n].equals(TRUNCATED)) {
-                        batchedScanResult.truncated = true;
-                    } else if (splitData[n].startsWith(BSSID_STR)) {
-                        bssid = new String(splitData[n].getBytes(), bssidStrLen,
-                                splitData[n].length() - bssidStrLen);
-                    } else if (splitData[n].startsWith(FREQ_STR)) {
-                        try {
-                            freq = Integer.parseInt(splitData[n].substring(FREQ_STR.length()));
-                        } catch (NumberFormatException e) {
-                            loge("Invalid freqency: " + splitData[n]);
-                            freq = 0;
-                        }
-                    } else if (splitData[n].startsWith(AGE)) {
-                        try {
-                            tsf = now - Long.parseLong(splitData[n].substring(AGE.length()));
-                            tsf *= 1000; // convert mS -> uS
-                        } catch (NumberFormatException e) {
-                            loge("Invalid timestamp: " + splitData[n]);
-                            tsf = 0;
-                        }
-                    } else if (splitData[n].startsWith(SSID_STR)) {
-                        wifiSsid = WifiSsid.createFromAsciiEncoded(
-                                splitData[n].substring(SSID_STR.length()));
-                    } else if (splitData[n].startsWith(LEVEL_STR)) {
-                        try {
-                            level = Integer.parseInt(splitData[n].substring(LEVEL_STR.length()));
-                            if (level > 0) level -= 256;
-                        } catch (NumberFormatException e) {
-                            loge("Invalid level: " + splitData[n]);
-                            level = 0;
-                        }
-                    } else if (splitData[n].startsWith(DIST)) {
-                        try {
-                            dist = Integer.parseInt(splitData[n].substring(DIST.length()));
-                        } catch (NumberFormatException e) {
-                            loge("Invalid distance: " + splitData[n]);
-                            dist = ScanResult.UNSPECIFIED;
-                        }
-                    } else if (splitData[n].startsWith(DISTSD)) {
-                        try {
-                            distSd = Integer.parseInt(splitData[n].substring(DISTSD.length()));
-                        } catch (NumberFormatException e) {
-                            loge("Invalid distanceSd: " + splitData[n]);
-                            distSd = ScanResult.UNSPECIFIED;
-                        }
-                    } else {
-                        loge("Unable to parse batched scan result line: " + splitData[n]);
-                    }
-                    n++;
-                }
-                rawData = mWifiNative.getBatchedScanResults();
-                if (DEBUG_PARSE) log("reading more data:\n" + rawData);
-                if (rawData == null) {
-                    loge("Unexpected null BatchedScanResults");
-                    return;
-                }
-                splitData = rawData.split("\n");
-                if (splitData.length == 0 || splitData[0].equals("ok")) {
-                    loge("batch scan results just ended!");
-                    if (mBatchedScanResults.size() > 0) {
-                        mContext.sendStickyBroadcastAsUser(intent, UserHandle.ALL);
-                    }
-                    return;
-                }
-                n = 0;
-            }
-        }
-    }
-
     private long mDisconnectedTimeStamp = 0;
 
     public long getDisconnectedTimeMilli() {
@@ -2003,47 +1677,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
         }
     }
 
-    private void noteBatchedScanStart() {
-        if (PDBG) loge("noteBatchedScanstart()");
-        // note the end of a previous scan set
-        if (mNotedBatchedScanWorkSource != null &&
-                (mNotedBatchedScanWorkSource.equals(mBatchedScanWorkSource) == false ||
-                        mNotedBatchedScanCsph != mBatchedScanCsph)) {
-            try {
-                mBatteryStats.noteWifiBatchedScanStoppedFromSource(mNotedBatchedScanWorkSource);
-            } catch (RemoteException e) {
-                log(e.toString());
-            } finally {
-                mNotedBatchedScanWorkSource = null;
-                mNotedBatchedScanCsph = 0;
-            }
-        }
-        // note the start of the new
-        try {
-            mBatteryStats.noteWifiBatchedScanStartedFromSource(mBatchedScanWorkSource,
-                    mBatchedScanCsph);
-            mNotedBatchedScanWorkSource = mBatchedScanWorkSource;
-            mNotedBatchedScanCsph = mBatchedScanCsph;
-        } catch (RemoteException e) {
-            log(e.toString());
-        }
-    }
-
-    private void noteBatchedScanStop() {
-        if (PDBG) loge("noteBatchedScanstop()");
-
-        if (mNotedBatchedScanWorkSource != null) {
-            try {
-                mBatteryStats.noteWifiBatchedScanStoppedFromSource(mNotedBatchedScanWorkSource);
-            } catch (RemoteException e) {
-                log(e.toString());
-            } finally {
-                mNotedBatchedScanWorkSource = null;
-                mNotedBatchedScanCsph = 0;
-            }
-        }
-    }
-
     private void handleScanRequest(int type, Message message) {
         ScanSettings settings = null;
         WorkSource workSource = null;
@@ -2700,6 +2333,21 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
         mUntrustedNetworkFactory.dump(fd, pw, args);
         pw.println();
         mWifiConfigStore.dump(fd, pw, args);
+        pw.println("FW Version is: " + mWifiLogger.getFirmwareVersion());
+        pw.println("Driver Version is: " + mWifiLogger.getDriverVersion());
+        WifiLogger.RingBufferStatus[] status = mWifiLogger.getRingBufferStatus();
+        for (WifiLogger.RingBufferStatus element : status) {
+            pw.println("Ring buffer status: " + element);
+        }
+        mWifiLogger.getAllRingBufferData();
+        pw.println("Start fw memory dump:-----------------------------------------------");
+        String fwDump = mWifiLogger.getFwMemoryDump();
+        if(fwDump != null) {
+            pw.println(fwDump);
+        } else {
+            pw.println("Fail to get FW memory dump");
+        }
+        pw.println("End fw memory dump:--------------------------------------------------");
     }
 
     /**
@@ -3304,6 +2952,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;
 
@@ -3319,46 +3046,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) {
@@ -3385,7 +3112,7 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
         getWifiLinkLayerStats(false);
         mOnTimeScreenStateChange = mOnTime;
         lastScreenStateChangeTimeStamp = lastLinkLayerStatsUpdate;
-        mEnableBackgroundScan = false;
+        mEnableBackgroundScan = mScreenOn == false;
         cancelDelayedScan();
 
         if (screenOn) {
@@ -4770,9 +4497,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
         setSuspendOptimizationsNative(SUSPEND_DUE_TO_DHCP, false);
         mWifiNative.setPowerSave(false);
 
-        // stopBatchedScan();
-        WifiNative.pauseScan();
-
         // Update link layer stats
         getWifiLinkLayerStats(false);
 
@@ -4836,9 +4560,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
                 mWifiNative.BLUETOOTH_COEXISTENCE_MODE_SENSE);
 
         mDhcpActive = false;
-
-        // startBatchedScan();
-        WifiNative.restartScan();
     }
 
     void connectScanningService() {
@@ -5244,15 +4965,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
                 case CMD_BOOT_COMPLETED:
                     maybeRegisterNetworkFactory();
                     break;
-                case CMD_SET_BATCHED_SCAN:
-                    recordBatchedScanSettings(message.arg1, message.arg2, (Bundle)message.obj);
-                    break;
-                case CMD_POLL_BATCHED_SCAN:
-                    handleBatchedScanPollRequest();
-                    break;
-                case CMD_START_NEXT_BATCHED_SCAN:
-                    startNextBatchedScan();
-                    break;
                 case CMD_SCREEN_STATE_CHANGED:
                     handleScreenStateChanged(message.arg1 != 0,
                             /* startBackgroundScanIfNeeded = */ false);
@@ -5417,7 +5129,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
         @Override
         public void enter() {
             mWifiNative.unloadDriver();
-
             if (mWifiP2pChannel == null) {
                 mWifiP2pChannel = new AsyncChannel();
                 mWifiP2pChannel.connect(mContext, getHandler(),
@@ -5876,6 +5587,10 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
             if (PDBG) {
                 loge("DriverStartedState enter");
             }
+            if (VDBG) {
+                mWifiLogger.startLoggingAllBuffer(3, 0, 60, 0);
+                mWifiLogger.getAllRingBufferData();
+            }
             mIsRunning = true;
             mInDelayedStop = false;
             mDelayedStopCounter++;
@@ -5903,8 +5618,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
 
             mDhcpActive = false;
 
-            startBatchedScan();
-
             if (mOperationalMode != CONNECT_MODE) {
                 mWifiNative.disconnect();
                 mWifiConfigStore.disableAllNetworks();
@@ -5974,16 +5687,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
                 case CMD_START_SCAN:
                     handleScanRequest(WifiNative.SCAN_WITHOUT_CONNECTION_SETUP, message);
                     break;
-                case CMD_SET_BATCHED_SCAN:
-                    if (recordBatchedScanSettings(message.arg1, message.arg2,
-                            (Bundle) message.obj)) {
-                        if (mBatchedScanSettings != null) {
-                            startBatchedScan();
-                        } else {
-                            stopBatchedScan();
-                        }
-                    }
-                    break;
                 case CMD_SET_FREQUENCY_BAND:
                     int band =  message.arg1;
                     if (DBG) log("set frequency band " + band);
@@ -6117,8 +5820,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
             updateBatteryWorkSource(null);
             mScanResults = new ArrayList<>();
 
-            stopBatchedScan();
-
             final Intent intent = new Intent(WifiManager.WIFI_SCAN_AVAILABLE);
             intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
             intent.putExtra(WifiManager.EXTRA_SCAN_AVAILABLE, WIFI_STATE_DISABLED);
@@ -6476,15 +6177,6 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
             case CMD_NO_NETWORKS_PERIODIC_SCAN:
                 s = "CMD_NO_NETWORKS_PERIODIC_SCAN";
                 break;
-            case CMD_SET_BATCHED_SCAN:
-                s = "CMD_SET_BATCHED_SCAN";
-                break;
-            case CMD_START_NEXT_BATCHED_SCAN:
-                s = "CMD_START_NEXT_BATCHED_SCAN";
-                break;
-            case CMD_POLL_BATCHED_SCAN:
-                s = "CMD_POLL_BATCHED_SCAN";
-                break;
             case CMD_UPDATE_LINKPROPERTIES:
                 s = "CMD_UPDATE_LINKPROPERTIES";
                 break;
@@ -8337,11 +8029,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) {
@@ -8373,6 +8067,8 @@ public class WifiStateMachine extends StateMachine implements WifiNative.WifiPno
             mWifiConfigStore.enableAllNetworks();
 
             mLastDriverRoamAttempt = 0;
+
+            //startLazyRoam();
         }
         @Override
         public boolean processMessage(Message message) {
@@ -8569,6 +8265,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 246669cb7..92c144c18 100644
--- a/service/jni/com_android_server_wifi_WifiNative.cpp
+++ b/service/jni/com_android_server_wifi_WifiNative.cpp
@@ -25,7 +25,6 @@
 #include <ctype.h>
 #include <sys/socket.h>
 #include <linux/if.h>
-
 #include "wifi.h"
 #include "wifi_hal.h"
 #include "jni_helper.h"
@@ -79,6 +78,19 @@ int init_wifi_hal_func_table(wifi_hal_fn *hal_fn) {
     hal_fn->wifi_get_tdls_status = wifi_get_tdls_status_stub;
     hal_fn->wifi_get_tdls_capabilities = wifi_get_tdls_capabilities_stub;
     hal_fn->wifi_set_nodfs_flag = wifi_set_nodfs_flag_stub;
+    hal_fn->wifi_get_firmware_memory_dump = wifi_get_firmware_memory_dump_stub;
+    hal_fn->wifi_set_log_handler = wifi_set_log_handler_stub;
+    hal_fn->wifi_set_alert_handler = wifi_set_alert_handler_stub;
+    hal_fn->wifi_get_firmware_version = wifi_get_firmware_version_stub;
+    hal_fn->wifi_get_ring_buffers_status = wifi_get_ring_buffers_status_stub;
+    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_enable_lazy_roam = wifi_enable_lazy_roam_stub;
+    hal_fn->wifi_set_bssid_blacklist = wifi_set_bssid_blacklist_stub;
     return 0;
 }
 
@@ -1486,20 +1498,312 @@ int buffer_size, wifi_ring_buffer_status *status) {
         0, 0);
 }
 
-static jboolean android_net_wifi_start_logging(JNIEnv *env, jclass cls, jint iface) {
+static jint android_net_wifi_get_supported_logger_feature(JNIEnv *env, jclass cls, jint iface){
+    //Not implemented yet
+    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
+    return -1;
+}
+
+static jobject android_net_wifi_get_driver_version(JNIEnv *env, jclass cls, jint iface) {
+     //Need to be fixed. The memory should be allocated from lower layer
+    //char *buffer = NULL;
+    int buffer_length =  256;
+    char *buffer = (char *)malloc(buffer_length);
+    if (!buffer) return NULL;
+    memset(buffer, 0, buffer_length);
+    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
+
+    ALOGD("android_net_wifi_get_driver_version = %p", handle);
+
+    if (handle == 0) {
+        return NULL;
+    }
+
+    wifi_error result = hal_fn.wifi_get_driver_version(handle, buffer, buffer_length);
+
+    if (result == WIFI_SUCCESS) {
+        ALOGD("buffer is %p, length is %d", buffer, buffer_length);
+        jstring driver_version = env->NewStringUTF(buffer);
+        free(buffer);
+        return driver_version;
+    } else {
+        ALOGD("Fail to get driver version");
+        return NULL;
+    }
+}
+
+static jobject android_net_wifi_get_firmware_version(JNIEnv *env, jclass cls, jint iface) {
+
+    //char *buffer = NULL;
+    int buffer_length = 256;
+    char *buffer = (char *)malloc(buffer_length);
+    if (!buffer) return NULL;
+    memset(buffer, 0, buffer_length);
+    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
+
+    ALOGD("android_net_wifi_get_firmware_version = %p", handle);
+
+    if (handle == 0) {
+        return NULL;
+    }
+
+    wifi_error result = hal_fn.wifi_get_firmware_version(handle, buffer, buffer_length);
+
+    if (result == WIFI_SUCCESS) {
+        ALOGD("buffer is %p, length is %d", buffer, buffer_length);
+        jstring firmware_version = env->NewStringUTF(buffer);
+        free(buffer);
+        return firmware_version;
+    } else {
+        ALOGD("Fail to get Firmware version");
+        return NULL;
+    }
+}
+
+static jobject android_net_wifi_get_ring_buffer_status (JNIEnv *env, jclass cls, jint iface) {
+
+    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
+
+    ALOGD(" android_net_wifi_get_ring_buffer_status = %p", handle);
+
+    if (handle == 0) {
+        return NULL;
+    }
+
+    //wifi_ring_buffer_status *status = NULL;
+    u32 num_rings = 10;
+    wifi_ring_buffer_status *status =
+        (wifi_ring_buffer_status *)malloc(sizeof(wifi_ring_buffer_status) * num_rings);
+    if (!status) return NULL;
+    memset(status, 0, sizeof(wifi_ring_buffer_status) * num_rings);
+    wifi_error result = hal_fn.wifi_get_ring_buffers_status(handle, &num_rings, status);
+    if (result == WIFI_SUCCESS) {
+        ALOGD("status is %p, number is %d", status, num_rings);
+        jclass clsRingBufferStatus =
+               (env)->FindClass("com/android/server/wifi/WifiLogger$RingBufferStatus");
+        if (clsRingBufferStatus == NULL) {
+            ALOGE("Error in accessing class");
+            free(status);
+            return NULL;
+        }
+        jobjectArray ringBuffersStatus = env->NewObjectArray(num_rings,clsRingBufferStatus, NULL);
+        wifi_ring_buffer_status *tmp = status;
+
+        for(u32 i = 0; i < num_rings; i++, tmp++) {
+            jobject ringStatus = createObject(env,
+                    "com/android/server/wifi/WifiLogger$RingBufferStatus");
+            if (ringStatus == NULL) {
+                ALOGE("Error in creating ringBufferStatus");
+                free(status);
+                return NULL;
+            }
+            char name[32];
+            for(int j = 0; j < 32; j++) {
+                name[j] = tmp->name[j];
+            }
+            setStringField(env, ringStatus, "name", name);
+            setIntField(env, ringStatus, "flag", tmp->flags);
+            setIntField(env, ringStatus, "ringBufferId", tmp->ring_id);
+            setIntField(env, ringStatus, "ringBufferByteSize", tmp->ring_buffer_byte_size);
+            setIntField(env, ringStatus, "verboseLevel", tmp->verbose_level);
+            setIntField(env, ringStatus, "writtenBytes", tmp->written_bytes);
+            setIntField(env, ringStatus, "readBytes", tmp->read_bytes);
+            setIntField(env, ringStatus, "writtenRecords", tmp->written_records);
+            env->SetObjectArrayElement(ringBuffersStatus, i, ringStatus);
+        }
+        free(status);
+        return ringBuffersStatus;
+    } else {
+        free(status);
+        return NULL;
+    }
+}
+
+static void on_ring_buffer_data(char *ring_name, char *buffer, int buffer_size,
+        wifi_ring_buffer_status *status) {
+    if (!ring_name || !buffer || !status || buffer_size <= sizeof(wifi_ring_buffer_entry)) {
+        ALOGE("Error input for on_ring_buffer_data!");
+    }
+    JNIEnv *env = NULL;
+    mVM->AttachCurrentThread(&env, NULL);
+    ALOGD("on_ring_buffer_data called, vm = %p, obj = %p, env = %p buffer size = %d", mVM,
+            mCls, env, buffer_size);
+
+    jobject wifiLoggerEvent = createObject(env,
+            "com/android/server/wifi/WifiNative$WifiLoggerEvent");
+
+    //jstring reportBuffer = env->NewStringUTF(buffer);
+    //setStringField(env, wifiLoggerEvent, "buffer", buffer);
+
+    jobject ringStatus = createObject(env,
+                    "com/android/server/wifi/WifiLogger$RingBufferStatus");
+    if (status == NULL) {
+        ALOGE("Error in creating ringBufferStatus");
+        return;
+    }
+
+    char name[32];
+    for(int j = 0; j < 32; j++) {
+        name[j] = status->name[j];
+    }
+    setStringField(env, ringStatus, "name", name);
+    setIntField(env, ringStatus, "flag", status->flags);
+    setIntField(env, ringStatus, "ringBufferId", status->ring_id);
+    setIntField(env, ringStatus, "ringBufferByteSize", status->ring_buffer_byte_size);
+    setIntField(env, ringStatus, "verboseLevel", status->verbose_level);
+    setIntField(env, ringStatus, "writtenBytes", status->written_bytes);
+    setIntField(env, ringStatus, "readBytes", status->read_bytes);
+    setIntField(env, ringStatus, "writtenRecords", status->written_records);
+    setObjectField(env, wifiLoggerEvent, "status",
+            "Lcom/android/server/wifi/WifiLogger$RingBufferStatus;", ringStatus);
+    //set entry
+    wifi_ring_buffer_entry *buffer_entry = (wifi_ring_buffer_entry *) buffer;
+    setIntField(env,wifiLoggerEvent, "entrySize", buffer_entry->entry_size);
+    setIntField(env,wifiLoggerEvent, "flags", buffer_entry->flags);
+    setIntField(env,wifiLoggerEvent, "type", buffer_entry->type);
+    setLongField(env,wifiLoggerEvent, "timestamp", buffer_entry->timestamp);
+    //set records
+    int record_size = buffer_size - sizeof(wifi_ring_buffer_entry);
+    if (buffer_entry->entry_size > 0) {
+        jbyteArray records = env->NewByteArray(buffer_entry->entry_size);
+        jbyte *bytes = (jbyte *) (buffer_entry + 1);
+        env->SetByteArrayRegion(records, 0, buffer_entry->entry_size, bytes);
+        setObjectField(env,wifiLoggerEvent, "entry", "[B", records);
+        env->DeleteLocalRef(records);
+    }
+
+    reportEvent(env, mCls,"onWifiLoggerEvent",
+            "(Lcom/android/server/wifi/WifiNative$WifiLoggerEvent;)V", wifiLoggerEvent);
+
+    env->DeleteLocalRef(ringStatus);
+    env->DeleteLocalRef(wifiLoggerEvent);
+}
+
+static void on_alert_data(wifi_request_id id, char *buffer, int buffer_size, int err_code){
+    JNIEnv *env = NULL;
+    mVM->AttachCurrentThread(&env, NULL);
+    ALOGD(" on_alert_data called, vm = %p, obj = %p, env = %p buffer_size = %d, error code = %d"
+            , mVM, mCls, env, buffer_size, err_code);
+
+    if (buffer_size > 0) {
+        jbyteArray records = env->NewByteArray(buffer_size);
+        jbyte *bytes = (jbyte *) buffer;
+        env->SetByteArrayRegion(records, 0,buffer_size, bytes);
+        reportEvent(env, mCls,"onWifiAlert","([B;I)V", records, err_code);
+        env->DeleteLocalRef(records);
+    } else {
+        reportEvent(env, mCls,"onWifiAlert","([B;I)V", NULL, err_code);
+    }
+}
+
+static jboolean android_net_wifi_start_logging_ring_buffer(JNIEnv *env, jclass cls, jint iface,
+        jint verbose_level,jint flags, jint max_interval,jint min_data_size, jstring ring_name) {
 
     wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
-    ALOGD("android_net_wifi_start_logging = %p", handle);
+
+    ALOGD("android_net_wifi_start_logging_ring_buffer = %p", handle);
 
     if (handle == 0) {
-        return WIFI_ERROR_UNINITIALIZED;
+        return false;
     }
+
+    //set logging handler
+
+    //initialize the handler on first time
     wifi_ring_buffer_data_handler handler;
-    handler.on_ring_buffer_data = &onRingBufferData;
+    handler.on_ring_buffer_data = &on_ring_buffer_data;
+    int result = hal_fn.wifi_set_log_handler(0, handle, handler);
+    if (result != WIFI_SUCCESS) {
+        ALOGE("Fail to set logging handler");
+        return false;
+    } else {
+        ALOGE(" Successfully set on_ring_buffer_data");
+    }
+    //set alter handler
+    wifi_alert_handler alert_handler;
+    alert_handler.on_alert = &on_alert_data;
+    result = hal_fn.wifi_set_alert_handler(0, handle, alert_handler);
+    if (result != WIFI_SUCCESS) {
+        ALOGE(" Fail to set logging handler");
+        return false;
+    } else {
+        ALOGE(" Successfully set on_alert");
+    }
+
 
-    wifi_error result = WIFI_SUCCESS; //ifi_start_logging(handle, 1, 0, 5, 4*1024,(u8*)"wifi_connectivity_events", handler);
+    const char* ring_name_const_char = env->GetStringUTFChars(ring_name, JNI_FALSE);
+    int len;
+    for(len = 0; ring_name_const_char[len] != 0; len++);
+
+    char* ring_name_char = (char*) malloc(len+1);
+    memcpy(ring_name_char, ring_name_const_char, len+1);
+
+    int ret = hal_fn.wifi_start_logging(handle, verbose_level, flags, max_interval, min_data_size,
+            ring_name_char);
+
+    if (ret != WIFI_SUCCESS) {
+        ALOGE("Fail to start logging for ring %s", ring_name);
+    } else {
+        ALOGD("start logging for ring %s", ring_name);
+    }
+    env->ReleaseStringUTFChars(ring_name, ring_name_char);
+    return ret == WIFI_SUCCESS;
+}
+
+static jboolean android_net_wifi_get_ring_buffer_data(JNIEnv *env, jclass cls, jint iface,
+        jstring ring_name) {
+    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
+    ALOGD("android_net_wifi_get_ring_buffer_data = %p", handle);
+
+
+    const char* ring_name_const_char = env->GetStringUTFChars(ring_name, JNI_FALSE);
+    int len;
+    for(len = 0; ring_name_const_char[len] != 0; len++);
+    char* ring_name_char = (char*) malloc(len+1);
+    memcpy(ring_name_char, ring_name_const_char, len+1);
+
+    int result = hal_fn.wifi_get_ring_data(handle, ring_name_char);
+
+    if (result == WIFI_SUCCESS)
+        ALOGD("Get Ring data command success\n");
+    else
+        ALOGE("Failed to execute get ring data command\n");
+
+    env->ReleaseStringUTFChars(ring_name, ring_name_char);
+    return result == WIFI_SUCCESS;
+}
+
+
+void on_firmware_memory_dump(char *buffer, int buffer_size) {
+    JNIEnv *env = NULL;
+    mVM->AttachCurrentThread(&env, NULL);
+    ALOGD("on_firmware_memory_dump called, vm = %p, obj = %p, env = %p buffer_size = %d"
+            , mVM, mCls, env, buffer_size);
+
+    if (buffer_size > 0) {
+        jbyteArray dump = env->NewByteArray(buffer_size);
+        jbyte *bytes = (jbyte *) (buffer);
+        env->SetByteArrayRegion(dump, 0, buffer_size, bytes);
+        reportEvent(env, mCls,"onWifiFwMemoryAvailable","([B)V", dump);
+        env->DeleteLocalRef(dump);
+    }
+
+}
+
+static jboolean android_net_wifi_get_fw_memory_dump(JNIEnv *env, jclass cls, jint iface){
+    wifi_interface_handle handle = getIfaceHandle(env, cls, iface);
+    ALOGD("android_net_wifi_get_fw_memory_dump = %p", handle);
+
+    if (handle == NULL) {
+        ALOGE("Can not get wifi_interface_handle");
+        return false;
+    }
+
+    wifi_firmware_memory_dump_handler fw_dump_handle;
+    fw_dump_handle.on_firmware_memory_dump = on_firmware_memory_dump;
+    int result = hal_fn.wifi_get_firmware_memory_dump(handle, fw_dump_handle);
+    return result == WIFI_SUCCESS;
 
-    return result;
 }
 
 // ----------------------------------------------------------------------------
@@ -1540,9 +1844,10 @@ 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,
-            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]);
+        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]);
 
         /*elements = env->NewByteArray(results->ie_length);
         if (elements == NULL) {
@@ -1636,7 +1941,9 @@ static jboolean android_net_wifi_setPnoListNative(
         net_list[i].auth_bit_field = a;
         int f = getIntField(env, pno_net, "flags");
         net_list[i].flags = f;
-        ALOGE(" setPnoListNative: idx %u rssi %d/%d auth %x/%x flags %x/%x [%s]", i, (signed)net_list[i].rssi_threshold, net_list[i].rssi_threshold, net_list[i].auth_bit_field, a, net_list[i].flags, f, net_list[i].ssid);
+        ALOGE(" setPnoListNative: idx %u rssi %d/%d auth %x/%x flags %x/%x [%s]", i,
+                (signed)net_list[i].rssi_threshold, net_list[i].rssi_threshold,
+                net_list[i].auth_bit_field, a, net_list[i].flags, f, net_list[i].ssid);
     }
 
     int result = hal_fn.wifi_set_epno_list(id, handle, len, net_list, handler);
@@ -1645,6 +1952,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;
+}
+
 // ----------------------------------------------------------------------------
 
 /*
@@ -1699,7 +2034,6 @@ static JNINativeMethod gWifiMethods[] = {
     { "toggleInterfaceNative",    "(I)Z",  (void*) android_net_wifi_toggle_interface},
     { "getRttCapabilitiesNative", "(I)Landroid/net/wifi/RttManager$RttCapabilities;",
             (void*) android_net_wifi_get_rtt_capabilities},
-    { "startLogging", "(I)Z", (void*) android_net_wifi_start_logging},
     {"setCountryCodeHalNative", "(ILjava/lang/String;)Z",
             (void*) android_net_wifi_set_Country_Code_Hal},
     { "setPnoListNative", "(II[Lcom/android/server/wifi/WifiNative$WifiPnoNetwork;)Z",
@@ -1709,7 +2043,22 @@ static JNINativeMethod gWifiMethods[] = {
     {"getTdlsStatusNative", "(ILjava/lang/String;)Lcom/android/server/wifi/WifiNative$TdlsStatus;",
             (void*) android_net_wifi_get_tdls_status},
     {"getTdlsCapabilitiesNative", "(I)Lcom/android/server/wifi/WifiNative$TdlsCapabilities;",
-            (void*) android_net_wifi_get_tdls_capabilities}
+            (void*) android_net_wifi_get_tdls_capabilities},
+    {"getSupportedLoggerFeatureSetNative","(I)I",
+            (void*) android_net_wifi_get_supported_logger_feature},
+    {"getDriverVersionNative", "(I)Ljava/lang/String;",
+            (void*) android_net_wifi_get_driver_version},
+    {"getFirmwareVersionNative", "(I)Ljava/lang/String;",
+            (void*) android_net_wifi_get_firmware_version},
+    {"getRingBufferStatusNative", "(I)[Lcom/android/server/wifi/WifiLogger$RingBufferStatus;",
+            (void*) android_net_wifi_get_ring_buffer_status},
+    {"startLoggingRingBufferNative", "(IIIIILjava/lang/String;)Z",
+            (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},
+    { "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 351cdc478..f02e6322f 100644
--- a/service/jni/wifi_hal_stub.h
+++ b/service/jni/wifi_hal_stub.h
@@ -78,15 +78,13 @@ wifi_error wifi_set_log_handler_stub(wifi_request_id id, wifi_interface_handle i
         wifi_ring_buffer_data_handler handler);
 wifi_error wifi_set_alert_handler_stub(wifi_request_id id, wifi_interface_handle iface,
         wifi_alert_handler handler);
-wifi_error wifi_get_firmware_version_stub( wifi_interface_handle iface, char **buffer,
-        int *buffer_size);
+wifi_error wifi_get_firmware_version_stub(wifi_interface_handle iface, char *buffer,
+        int buffer_size);
 wifi_error wifi_get_ring_buffers_status_stub(wifi_interface_handle iface,
-        u32 *num_rings, wifi_ring_buffer_status **status);
+        u32 *num_rings, wifi_ring_buffer_status *status);
 wifi_error wifi_get_logger_supported_feature_set_stub(wifi_interface_handle iface,
         unsigned int *support);
 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_epno_list_stub(int id, wifi_interface_info *iface, int num_networks,
         wifi_epno_network *networks, wifi_epno_handler handler);
 wifi_error wifi_enable_tdls_stub(wifi_interface_handle iface, mac_addr addr,
@@ -96,6 +94,18 @@ wifi_error wifi_get_tdls_status_stub(wifi_interface_handle iface, mac_addr addr,
         wifi_tdls_status *status);
 wifi_error wifi_get_tdls_capabilities_stub(wifi_interface_handle iface,
         wifi_tdls_capabilities *capabilities);
+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 1d8f3e4f3..fb86ff9e0 100644
--- a/service/lib/wifi_hal_stub.cpp
+++ b/service/lib/wifi_hal_stub.cpp
@@ -166,13 +166,13 @@ wifi_error wifi_set_alert_handler_stub(wifi_request_id id, wifi_interface_handle
     return WIFI_ERROR_NOT_SUPPORTED;
 }
 
-wifi_error wifi_get_firmware_version_stub( wifi_interface_handle iface, char **buffer,
-        int *buffer_size) {
+wifi_error wifi_get_firmware_version_stub( wifi_interface_handle iface, char *buffer,
+        int buffer_size) {
     return WIFI_ERROR_NOT_SUPPORTED;
 }
 
 wifi_error wifi_get_ring_buffers_status_stub(wifi_interface_handle iface,
-        u32 *num_rings, wifi_ring_buffer_status **status) {
+        u32 *num_rings, wifi_ring_buffer_status *status) {
     return WIFI_ERROR_NOT_SUPPORTED;
 }
 
@@ -185,7 +185,8 @@ wifi_error wifi_get_ring_data_stub(wifi_interface_handle iface, char *ring_name)
     return WIFI_ERROR_NOT_SUPPORTED;
 }
 
-wifi_error wifi_get_driver_version_stub(wifi_interface_handle iface, char **buffer, int *buffer_size) {
+wifi_error wifi_get_driver_version_stub(wifi_interface_handle iface, char *buffer,
+        int buffer_size) {
     return WIFI_ERROR_NOT_SUPPORTED;
 }
 
@@ -207,3 +208,28 @@ wifi_error wifi_get_tdls_capabilities_stub(wifi_interface_handle iface,
         wifi_tdls_capabilities *capabilities) {
     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 39ca8270e..00ed1b8e6 100644
--- a/service/tools/halutil/halutil.cpp
+++ b/service/tools/halutil/halutil.cpp
@@ -62,6 +62,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;
 }
 
@@ -1744,125 +1749,138 @@ static void onRingBufferData(char *ring_name, char *buffer, int buffer_size,
     }
 
     /*
-     * Parsing TLV data
+     * Parsing Wake Lock event
      */
-    if (buffer_entry->type != ENTRY_TYPE_CONNECT_EVENT)
+    if (buffer_entry->type == ENTRY_TYPE_WAKE_LOCK) {
+        const char *strStatus[] = {"Taken", "Released", "Timeout"};
+        wake_lock_event *wlock_event = (wake_lock_event *) pBuff;
+
+        printMsg("Wakelock Event: Status=%s (%02x), Name=%s, Reason=%s (%02x)\n",
+            strStatus[wlock_event->status], wlock_event->status,
+            wlock_event->name, "\"TO BE\"", wlock_event->reason);
         return;
-    wifi_ring_buffer_driver_connectivity_event *connect_event =
-        (wifi_ring_buffer_driver_connectivity_event *) (pBuff);
-
-    tlv_log *tlv_data = (tlv_log *) (connect_event + 1);
-    printMsg("Event type: %s (%u)\n", RBconnectEventToString(connect_event->event),
-            connect_event->event);
-
-    char *pos = (char *)tlv_data;
-    char *end = (char *)connect_event + buffer_entry->entry_size;
-    while (pos < end) {
-        printMsg("TLV.type: %s (%02x), TLV.len=%d(%02x)\n",
-                RBTlvTagToString(tlv_data->tag),
-                tlv_data->tag, tlv_data->length, tlv_data->length);
-
-        switch (tlv_data->tag) {
-            case WIFI_TAG_VENDOR_SPECIFIC:
-                break;
+    }
 
-            case WIFI_TAG_BSSID:
-            case WIFI_TAG_ADDR:
-            case WIFI_TAG_ADDR1:
-            case WIFI_TAG_ADDR2:
-            case WIFI_TAG_ADDR3:
-            case WIFI_TAG_ADDR4:
-            {
-                if (tlv_data->length == sizeof(mac_addr)) {
-                    mac_addr addr;
-                    memcpy(&addr, tlv_data->value, sizeof(mac_addr));
-                    printMsg("Address: %02x:%02x:%02x:%02x:%02x:%02x\n",
-                        addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
-                } else
-                    printMsg("wrong lenght of address\n");
-                break;
-            }
+    /*
+     * Parsing TLV data
+     */
+    if (buffer_entry->type == ENTRY_TYPE_CONNECT_EVENT) {
+        wifi_ring_buffer_driver_connectivity_event *connect_event =
+            (wifi_ring_buffer_driver_connectivity_event *) (pBuff);
+
+        tlv_log *tlv_data = (tlv_log *) (connect_event + 1);
+        printMsg("Event type: %s (%u)\n", RBconnectEventToString(connect_event->event),
+                connect_event->event);
+
+        char *pos = (char *)tlv_data;
+        char *end = (char *)connect_event + buffer_entry->entry_size;
+        while (pos < end) {
+            printMsg("TLV.type: %s (%d), TLV.len=%d (%02x)\n",
+                    RBTlvTagToString(tlv_data->tag),
+                    tlv_data->tag, tlv_data->length, tlv_data->length);
+
+            switch (tlv_data->tag) {
+                case WIFI_TAG_VENDOR_SPECIFIC:
+                    break;
 
-            case WIFI_TAG_SSID:
-            {
-                char ssid[MAX_SSID_LEN];
-                memset(ssid, 0, sizeof(ssid));
-                if (tlv_data->length > MAX_SSID_LEN)
-                    tlv_data->length = MAX_SSID_LEN;
-                memcpy(ssid, tlv_data->value, tlv_data->length);
-                printMsg("SSID = %s\n", ssid);
-                break;
-            }
+                case WIFI_TAG_BSSID:
+                case WIFI_TAG_ADDR:
+                case WIFI_TAG_ADDR1:
+                case WIFI_TAG_ADDR2:
+                case WIFI_TAG_ADDR3:
+                case WIFI_TAG_ADDR4:
+                {
+                    if (tlv_data->length == sizeof(mac_addr)) {
+                        mac_addr addr;
+                        memcpy(&addr, tlv_data->value, sizeof(mac_addr));
+                        printMsg("Address: %02x:%02x:%02x:%02x:%02x:%02x\n",
+                            addr[0], addr[1], addr[2], addr[3], addr[4], addr[5]);
+                    } else
+                        printMsg("wrong lenght of address\n");
+                    break;
+                }
 
-            case WIFI_TAG_STATUS:
-            {
-                unsigned int status = 0;
-                memcpy(&status, tlv_data->value, tlv_data->length);
-                printMsg("Status = %u\n", status);
-                break;
-            }
+                case WIFI_TAG_SSID:
+                {
+                    char ssid[MAX_SSID_LEN];
+                    memset(ssid, 0, sizeof(ssid));
+                    if (tlv_data->length > MAX_SSID_LEN)
+                        tlv_data->length = MAX_SSID_LEN;
+                    memcpy(ssid, tlv_data->value, tlv_data->length);
+                    printMsg("SSID = %s\n", ssid);
+                    break;
+                }
 
-            case WIFI_TAG_CHANNEL_SPEC:
-            {
-                wifi_channel_info *ch_spec = (wifi_channel_info *) tlv_data->value;
-                printMsg("Channel Info: center_freq=%d, freq0=%d, freq1=%d, width=%s (%d)\n",
-                    RBchanWidthToString(ch_spec->width), ch_spec->center_freq,
-                    ch_spec->center_freq0, ch_spec->center_freq1);
-                break;
-            }
+                case WIFI_TAG_STATUS:
+                {
+                    unsigned int status = 0;
+                    memcpy(&status, tlv_data->value, tlv_data->length);
+                    printMsg("Status = %u\n", status);
+                    break;
+                }
 
-            case WIFI_TAG_WAKE_LOCK_EVENT:
-            {
-                printMsg("Wake lock event = \"TO BE DONE LATER\"\n", tlv_data->value);
-                break;
-            }
+                case WIFI_TAG_CHANNEL_SPEC:
+                {
+                    wifi_channel_info *ch_spec = (wifi_channel_info *) tlv_data->value;
+                    printMsg("Channel Info: center_freq=%d, freq0=%d, freq1=%d, width=%s (%d)\n",
+                        RBchanWidthToString(ch_spec->width), ch_spec->center_freq,
+                        ch_spec->center_freq0, ch_spec->center_freq1);
+                    break;
+                }
 
-            case WIFI_TAG_TSF:
-            {
-                u64 tsf = 0;
-                memcpy(&tsf, tlv_data->value, tlv_data->length);
-                printMsg("TSF value = %d\n", tsf);
-                break;
-            }
+                case WIFI_TAG_WAKE_LOCK_EVENT:
+                {
+                    printMsg("Wake lock event = \"TO BE DONE LATER\"\n", tlv_data->value);
+                    break;
+                }
 
-            case WIFI_TAG_IE:
-            {
-                printMsg("Information Element = \"TO BE\"\n");
-                break;
-            }
+                case WIFI_TAG_TSF:
+                {
+                    u64 tsf = 0;
+                    memcpy(&tsf, tlv_data->value, tlv_data->length);
+                    printMsg("TSF value = %d\n", tsf);
+                    break;
+                }
 
-            case WIFI_TAG_INTERFACE:
-            {
-                const int len = 32;
-                char inf_name[len];
+                case WIFI_TAG_IE:
+                {
+                    printMsg("Information Element = \"TO BE\"\n");
+                    break;
+                }
 
-                if (tlv_data->length > len)
-                    tlv_data->length = len;
-                memset(inf_name, 0, 32);
-                memcpy(inf_name, tlv_data->value, tlv_data->length);
-                printMsg("Interface = %s\n", inf_name);
-                break;
-            }
+                case WIFI_TAG_INTERFACE:
+                {
+                    const int len = 32;
+                    char inf_name[len];
 
-            case WIFI_TAG_REASON_CODE:
-            {
-                u16 reason = 0;
-                memcpy(&reason, tlv_data->value, 2);
-                printMsg("Reason code = %d\n", reason);
-                break;
-            }
+                    if (tlv_data->length > len)
+                        tlv_data->length = len;
+                    memset(inf_name, 0, 32);
+                    memcpy(inf_name, tlv_data->value, tlv_data->length);
+                    printMsg("Interface = %s\n", inf_name);
+                    break;
+                }
 
-            case WIFI_TAG_RATE_MBPS:
-            {
-                u32 rate = 0;
-                memcpy(&rate, tlv_data->value, tlv_data->length);
-                printMsg("Rate = %d Kbps\n", rate);
-                break;
+                case WIFI_TAG_REASON_CODE:
+                {
+                    u16 reason = 0;
+                    memcpy(&reason, tlv_data->value, 2);
+                    printMsg("Reason code = %d\n", reason);
+                    break;
+                }
+
+                case WIFI_TAG_RATE_MBPS:
+                {
+                    u32 rate = 0;
+                    memcpy(&rate, tlv_data->value, tlv_data->length);
+                    printMsg("Rate = %.1f Mbps\n", rate * 0.5);    // rate unit is 500 Kbps.
+                    break;
+                }
             }
+            pos = (char *)(tlv_data + 1);
+            pos += tlv_data->length;
+            tlv_data = (tlv_log *) pos;
         }
-        pos = (char *)(tlv_data + 1);
-        pos += tlv_data->length;
-        tlv_data = (tlv_log *) pos;
     }
 }
 
@@ -1927,7 +1945,7 @@ static void onFirmwareMemoryDump(char *buffer, int buffer_size)
     printMsg("Write to \"%s\"\n", mem_dump_file);
     fwrite(buffer, 1, buffer_size, w_fp);
     fclose(w_fp);
-	w_fp = NULL;
+    w_fp = NULL;
 
     putEventInCache(EVENT_TYPE_LOGGER_MEMDUMP_DATA, "Memdump data");
 }
@@ -1992,64 +2010,55 @@ static wifi_error LoggerGetRingData()
 static wifi_error LoggerGetFW()
 {
     int ret;
-    int buffer_size = 256;
+    const int BSIZE = 256;
+    int buffer_size = BSIZE;
 
-    char *buffer = (char *)malloc(buffer_size);
-    if (buffer == NULL)
-        return WIFI_ERROR_OUT_OF_MEMORY;
-    memset(buffer, 0, buffer_size);
+    char buffer[BSIZE];
+    memset(buffer, 0, BSIZE);
 
-    ret = hal_fn.wifi_get_firmware_version(wlan0Handle, &buffer, &buffer_size);
+    ret = hal_fn.wifi_get_firmware_version(wlan0Handle, buffer, buffer_size);
 
     if (ret == WIFI_SUCCESS)
-        printMsg("FW version (len=%d):\n%s\n", buffer_size, buffer);
+        printMsg("FW version (len=%d):\n%s\n", strlen(buffer), buffer);
     else
         printMsg("Failed to get FW version\n");
 
-    free(buffer);
-    buffer = NULL;
-
     return WIFI_SUCCESS;
 }
 
 static wifi_error LoggerGetDriver()
 {
-    // halutil -logger -get driver
-
     int ret;
-    int buffer_size = 256;
+    const int BSIZE = 256;
+    int buffer_size = BSIZE;
 
-    char *buffer = (char *)malloc(buffer_size);
-    if (buffer == NULL)
-        return WIFI_ERROR_OUT_OF_MEMORY;
-    memset(buffer, 0, buffer_size);
+    char buffer[BSIZE];
+    memset(buffer, 0, BSIZE);
 
-    ret = hal_fn.wifi_get_driver_version(wlan0Handle, &buffer, &buffer_size);
+    ret = hal_fn.wifi_get_driver_version(wlan0Handle, buffer, buffer_size);
 
     if (ret == WIFI_SUCCESS)
-        printMsg("Driver version (len=%d):\n%s\n", buffer_size, buffer);
+        printMsg("Driver version (len=%d):\n%s\n", strlen(buffer), buffer);
     else
         printMsg("Failed to get driver version\n");
 
-    free(buffer);
-    buffer = NULL;
-
     return WIFI_SUCCESS;
 }
 
 static wifi_error LoggerGetRingbufferStatus()
 {
     int ret;
-    u32 num_rings = 10;
+    const int NRING = 10;
+    u32 num_rings = NRING;
 
     wifi_ring_buffer_status *status =
         (wifi_ring_buffer_status *)malloc(sizeof(wifi_ring_buffer_status) * num_rings);
 
     if (status == NULL)
         return WIFI_ERROR_OUT_OF_MEMORY;
-    memset(status, 0, sizeof(wifi_ring_buffer_status));
+    memset(status, 0, sizeof(wifi_ring_buffer_status) * num_rings);
 
-    ret = hal_fn.wifi_get_ring_buffers_status(wlan0Handle, &num_rings, &status);
+    ret = hal_fn.wifi_get_ring_buffers_status(wlan0Handle, &num_rings, status);
 
     if (ret == WIFI_SUCCESS) {
         printMsg("RingBuffer status: [%d ring(s)]\n", num_rings);
@@ -2697,7 +2706,7 @@ static wifi_error setWhitelistBSSIDs()
     }
 
     cmdId = getNewCmdId();
-    return WIFI_SUCCESS;//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 +2725,7 @@ static wifi_error setRoamParams()
 
     cmdId = getNewCmdId();
     printMsg("Setting Roam params\n");
-    return WIFI_SUCCESS;//wifi_set_gscan_roam_params(cmdId, wlan0Handle, &params);
+    return hal_fn.wifi_set_gscan_roam_params(cmdId, wlan0Handle, &params);
 }
 
 
@@ -2745,7 +2754,7 @@ static wifi_error setBSSIDPreference()
 
     cmdId = getNewCmdId();
     printMsg("Setting BSSID pref\n");
-    return WIFI_SUCCESS;//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 +2762,7 @@ static wifi_error setLazyRoam()
     int cmdId;
     cmdId = getNewCmdId();
     printMsg("Lazy roam\n");
-    return WIFI_SUCCESS; //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 +2780,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_SUCCESS;//wifi_set_bssid_blacklist(cmdId, wlan0Handle, params);
+    return hal_fn.wifi_set_bssid_blacklist(cmdId, wlan0Handle, params);
 }
 
 static void testLazyRoam()
@@ -2786,7 +2795,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);
     }