resolve merge conflicts of 849c5c7 to mnc-dev

This resovles the merge conflict for ag/1514448/
After Android M, this function uses num_bssid instead of num_ap.
Both are prone to stack overflow attacks.

Bug: 31856351
Test: compile, unit tests, manual test

Change-Id: I194850a4c79ddf478d98e750f65b24e82d99ebc0
diff --git a/service/Android.mk b/service/Android.mk
old mode 100755
new mode 100644
index fd7b41c..f325782
--- a/service/Android.mk
+++ b/service/Android.mk
@@ -16,16 +16,14 @@
 
 ifneq ($(TARGET_BUILD_PDK), true)
 
-# Make HAL stub library
+# Make HAL stub library 1
 # ============================================================
 
 include $(CLEAR_VARS)
 
 LOCAL_REQUIRED_MODULES :=
 
-LOCAL_CFLAGS += -Wno-unused-parameter -Wno-int-to-pointer-cast
-LOCAL_CFLAGS += -Wno-maybe-uninitialized -Wno-parentheses
-LOCAL_CPPFLAGS += -Wno-conversion-null
+LOCAL_CFLAGS += -Wno-unused-parameter
 
 LOCAL_C_INCLUDES += \
 	external/libnl-headers \
@@ -38,6 +36,27 @@
 
 include $(BUILD_STATIC_LIBRARY)
 
+# Make HAL stub library 2
+# ============================================================
+
+include $(CLEAR_VARS)
+
+LOCAL_REQUIRED_MODULES :=
+
+LOCAL_CFLAGS += -Wno-unused-parameter
+
+LOCAL_C_INCLUDES += \
+	$(LOCAL_PATH)/jni \
+	external/libnl-headers \
+	$(call include-path-for, libhardware_legacy)/hardware_legacy
+
+LOCAL_SRC_FILES := \
+	lib/wifi_hal_stub.cpp
+
+LOCAL_MODULE := libwifi-hal-stub
+
+include $(BUILD_STATIC_LIBRARY)
+
 # set correct hal library path
 # ============================================================
 LIB_WIFI_HAL := libwifi-hal
@@ -45,9 +64,7 @@
 ifeq ($(BOARD_WLAN_DEVICE), bcmdhd)
   LIB_WIFI_HAL := libwifi-hal-bcm
 else ifeq ($(BOARD_WLAN_DEVICE), qcwcn)
-  # this is commented because none of the nexus devices
-  # that sport Qualcomm's wifi have support for HAL
-  # LIB_WIFI_HAL := libwifi-hal-qcom
+  LIB_WIFI_HAL := libwifi-hal-qcom
 else ifeq ($(BOARD_WLAN_DEVICE), mrvl)
   # this is commented because none of the nexus devices
   # that sport Marvell's wifi have support for HAL
@@ -57,46 +74,13 @@
   LIB_WIFI_HAL := libwifi-hal-mt66xx
 endif
 
-# Build the HalUtil
-# ============================================================
-
-include $(CLEAR_VARS)
-
-LOCAL_REQUIRED_MODULES := libandroid_runtime libhardware_legacy
-
-LOCAL_CFLAGS += -Wno-unused-parameter -Wno-int-to-pointer-cast
-LOCAL_CFLAGS += -Wno-maybe-uninitialized -Wno-parentheses
-LOCAL_CPPFLAGS += -Wno-conversion-null
-
-LOCAL_C_INCLUDES += \
-	$(call include-path-for, libhardware)/hardware \
-	$(call include-path-for, libhardware_legacy)/hardware_legacy \
-	libcore/include
-
-LOCAL_SHARED_LIBRARIES += \
-	libcutils \
-	libnl \
-	libandroid_runtime \
-	libutils
-
-LOCAL_STATIC_LIBRARIES += $(LIB_WIFI_HAL)
-
-LOCAL_SRC_FILES := \
-	tools/halutil/halutil.cpp
-
-LOCAL_MODULE := halutil
-
-include $(BUILD_EXECUTABLE)
-
 # Make the JNI part
 # ============================================================
 include $(CLEAR_VARS)
 
 LOCAL_REQUIRED_MODULES := libandroid_runtime libhardware_legacy
 
-LOCAL_CFLAGS += -Wno-unused-parameter -Wno-int-to-pointer-cast
-LOCAL_CFLAGS += -Wno-maybe-uninitialized -Wno-parentheses
-LOCAL_CPPFLAGS += -Wno-conversion-null
+LOCAL_CFLAGS += -Wno-unused-parameter
 
 LOCAL_C_INCLUDES += \
 	$(JNI_H_INCLUDE) \
@@ -111,8 +95,10 @@
 	libhardware \
 	libhardware_legacy \
 	libandroid_runtime \
-    libnl
+	libnl \
+    libdl
 
+LOCAL_STATIC_LIBRARIES += libwifi-hal-stub
 LOCAL_STATIC_LIBRARIES += $(LIB_WIFI_HAL)
 
 LOCAL_SRC_FILES := \
@@ -135,7 +121,7 @@
 
 LOCAL_JNI_SHARED_LIBRARIES := libandroid_runtime
 LOCAL_JAVA_LIBRARIES := bouncycastle conscrypt services
-LOCAL_STATIC_JAVA_LIBRARIES := ksoap2
+LOCAL_STATIC_JAVA_LIBRARIES := ksoap2 android-support-v4
 LOCAL_REQUIRED_MODULES := services
 LOCAL_MODULE_TAGS :=
 LOCAL_MODULE := wifi-service
diff --git a/service/java/com/android/server/wifi/ConfigurationMap.java b/service/java/com/android/server/wifi/ConfigurationMap.java
new file mode 100644
index 0000000..0fb56ea
--- /dev/null
+++ b/service/java/com/android/server/wifi/ConfigurationMap.java
@@ -0,0 +1,146 @@
+package com.android.server.wifi;
+
+import android.net.wifi.WifiConfiguration;
+import android.util.Log;
+
+import com.android.server.wifi.hotspot2.Utils;
+import com.android.server.wifi.hotspot2.pps.HomeSP;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+public class ConfigurationMap {
+    private final Map<Integer, WifiConfiguration> mPerID = new HashMap<>();
+    private final Map<Integer, WifiConfiguration> mPerConfigKey = new HashMap<>();
+    private final Map<String, Integer> mPerFQDN = new HashMap<>();
+
+    // RW methods:
+    public WifiConfiguration put(int netid, WifiConfiguration config) {
+        WifiConfiguration current = mPerID.put(netid, config);
+        mPerConfigKey.put(config.configKey().hashCode(), config);   // This is ridiculous...
+        if (config.FQDN != null && config.FQDN.length() > 0) {
+            mPerFQDN.put(config.FQDN, netid);
+        }
+        return current;
+    }
+
+    public void populatePasspointData(Collection<HomeSP> homeSPs, WifiNative wifiNative) {
+        mPerFQDN.clear();
+
+        for (HomeSP homeSp : homeSPs) {
+            String fqdn = homeSp.getFQDN();
+            Log.d(WifiConfigStore.TAG, "Looking for " + fqdn);
+            for (WifiConfiguration config : mPerID.values()) {
+                Log.d(WifiConfigStore.TAG, "Testing " + config.SSID);
+
+                String id_str = Utils.unquote(wifiNative.getNetworkVariable(
+                        config.networkId, WifiConfigStore.idStringVarName));
+                if (id_str != null && id_str.equals(fqdn) && config.enterpriseConfig != null) {
+                    Log.d(WifiConfigStore.TAG, "Matched " + id_str + " with " + config.networkId);
+                    config.FQDN = fqdn;
+                    config.providerFriendlyName = homeSp.getFriendlyName();
+
+                    HashSet<Long> roamingConsortiumIds = homeSp.getRoamingConsortiums();
+                    config.roamingConsortiumIds = new long[roamingConsortiumIds.size()];
+                    int i = 0;
+                    for (long id : roamingConsortiumIds) {
+                        config.roamingConsortiumIds[i] = id;
+                        i++;
+                    }
+                    IMSIParameter imsiParameter = homeSp.getCredential().getImsi();
+                    config.enterpriseConfig.setPlmn(
+                            imsiParameter != null ? imsiParameter.toString() : null);
+                    config.enterpriseConfig.setRealm(homeSp.getCredential().getRealm());
+                    mPerFQDN.put(fqdn, config.networkId);
+                }
+            }
+        }
+
+        Log.d(WifiConfigStore.TAG, "loaded " + mPerFQDN.size() + " passpoint configs");
+    }
+
+    public WifiConfiguration remove(int netID) {
+        WifiConfiguration config = mPerID.remove(netID);
+        if (config == null) {
+            return null;
+        }
+        mPerConfigKey.remove(config.configKey().hashCode());
+
+        Iterator<Map.Entry<String, Integer>> entries = mPerFQDN.entrySet().iterator();
+        while (entries.hasNext()) {
+            if (entries.next().getValue() == netID) {
+                entries.remove();
+                break;
+            }
+        }
+        return config;
+    }
+
+    public void clear() {
+        mPerID.clear();
+        mPerConfigKey.clear();
+        mPerFQDN.clear();
+    }
+
+    // RO methods:
+    public WifiConfiguration get(int netid) {
+        return mPerID.get(netid);
+    }
+
+    public int size() {
+        return mPerID.size();
+    }
+
+    public boolean isEmpty() {
+        return mPerID.size() == 0;
+    }
+
+    public WifiConfiguration getByFQDN(String fqdn) {
+        Integer id = mPerFQDN.get(fqdn);
+        return id != null ? mPerID.get(id) : null;
+    }
+
+    public WifiConfiguration getByConfigKey(String key) {
+        if (key == null) {
+            return null;
+        }
+        for (WifiConfiguration config : mPerID.values()) {
+            if (config.configKey().equals(key)) {
+                return config;
+            }
+        }
+        return null;
+    }
+
+    public WifiConfiguration getByConfigKeyID(int id) {
+        return mPerConfigKey.get(id);
+    }
+
+    public Collection<WifiConfiguration> getEnabledNetworks() {
+        List<WifiConfiguration> list = new ArrayList<>();
+        for (WifiConfiguration config : mPerID.values()) {
+            if (config.status != WifiConfiguration.Status.DISABLED) {
+                list.add(config);
+            }
+        }
+        return list;
+    }
+
+    public WifiConfiguration getEphemeral(String ssid) {
+        for (WifiConfiguration config : mPerID.values()) {
+            if (ssid.equals(config.SSID) && config.ephemeral) {
+                return config;
+            }
+        }
+        return null;
+    }
+
+    public Collection<WifiConfiguration> values() {
+        return mPerID.values();
+    }
+}
diff --git a/service/java/com/android/server/wifi/IMSIParameter.java b/service/java/com/android/server/wifi/IMSIParameter.java
new file mode 100644
index 0000000..deea870
--- /dev/null
+++ b/service/java/com/android/server/wifi/IMSIParameter.java
@@ -0,0 +1,102 @@
+package com.android.server.wifi;
+
+import java.io.IOException;
+
+public class IMSIParameter {
+    private final String mImsi;
+    private final boolean mPrefix;
+
+    public IMSIParameter(String imsi, boolean prefix) {
+        mImsi = imsi;
+        mPrefix = prefix;
+    }
+
+    public IMSIParameter(String imsi) throws IOException {
+        if (imsi == null || imsi.length() == 0) {
+            throw new IOException("Bad IMSI: '" + imsi + "'");
+        }
+
+        int nonDigit;
+        char stopChar = '\0';
+        for (nonDigit = 0; nonDigit < imsi.length(); nonDigit++) {
+            stopChar = imsi.charAt(nonDigit);
+            if (stopChar < '0' || stopChar > '9') {
+                break;
+            }
+        }
+
+        if (nonDigit == imsi.length()) {
+            mImsi = imsi;
+            mPrefix = false;
+        }
+        else if (nonDigit == imsi.length()-1 && stopChar == '*') {
+            mImsi = imsi.substring(0, nonDigit);
+            mPrefix = true;
+        }
+        else {
+            throw new IOException("Bad IMSI: '" + imsi + "'");
+        }
+    }
+
+    public boolean matches(String fullIMSI) {
+        if (mPrefix) {
+            return mImsi.regionMatches(false, 0, fullIMSI, 0, mImsi.length());
+        }
+        else {
+            return mImsi.equals(fullIMSI);
+        }
+    }
+
+    public boolean matchesMccMnc(String mccMnc) {
+        if (mPrefix) {
+            // For a prefix match, the entire prefix must match the mcc+mnc
+            return mImsi.regionMatches(false, 0, mccMnc, 0, mImsi.length());
+        }
+        else {
+            // For regular match, the entire length of mcc+mnc must match this IMSI
+            return mImsi.regionMatches(false, 0, mccMnc, 0, mccMnc.length());
+        }
+    }
+
+    public boolean isPrefix() {
+        return mPrefix;
+    }
+
+    public String getImsi() {
+        return mImsi;
+    }
+
+    public int prefixLength() {
+        return mImsi.length();
+    }
+
+    @Override
+    public boolean equals(Object thatObject) {
+        if (this == thatObject) {
+            return true;
+        }
+        else if (thatObject == null || getClass() != thatObject.getClass()) {
+            return false;
+        }
+
+        IMSIParameter that = (IMSIParameter) thatObject;
+        return mPrefix == that.mPrefix && mImsi.equals(that.mImsi);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = mImsi != null ? mImsi.hashCode() : 0;
+        result = 31 * result + (mPrefix ? 1 : 0);
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        if (mPrefix) {
+            return mImsi + '*';
+        }
+        else {
+            return mImsi;
+        }
+    }
+}
diff --git a/service/java/com/android/server/wifi/RttService.java b/service/java/com/android/server/wifi/RttService.java
index c447e28..cc7f549 100644
--- a/service/java/com/android/server/wifi/RttService.java
+++ b/service/java/com/android/server/wifi/RttService.java
@@ -28,8 +28,9 @@
 import java.util.Iterator;
 import java.util.LinkedList;
 import java.util.Queue;
+import android.Manifest;
 
-class RttService extends SystemService {
+public final class RttService extends SystemService {
 
     public static final boolean DBG = true;
 
@@ -144,6 +145,16 @@
             Integer key;
             ClientInfo ci;
             RttManager.RttParams[] params;
+
+            @Override
+            public String toString() {
+                String str = getClass().getName() + "@" + Integer.toHexString(hashCode());
+                if(this.key != null) {
+                    return str + " key: " + this.key;
+                } else {
+                    return str + " key: " + " , null";
+                }
+            }
         }
 
         private class ClientInfo {
@@ -198,12 +209,14 @@
             }
 
             void reportAborted(int key) {
-                mChannel.sendMessage(RttManager.CMD_OP_ABORTED, key);
-                mRequests.remove(key);
+                mChannel.sendMessage(RttManager.CMD_OP_ABORTED, 0, key);
+                //All Queued RTT request will be cleaned
+                cleanup();
             }
 
             void cleanup() {
                 mRequests.clear();
+                mRequestQueue.clear();
             }
         }
 
@@ -271,20 +284,32 @@
                             transitionTo(mRequestPendingState);
                             break;
                         case RttManager.CMD_OP_START_RANGING: {
-                                RttManager.ParcelableRttParams params =
-                                        (RttManager.ParcelableRttParams)msg.obj;
-                                if (params == null) {
-                                    replyFailed(msg,
-                                            RttManager.REASON_INVALID_REQUEST, "No params");
-                                } else if (ci.addRttRequest(msg.arg2, params) == false) {
-                                    replyFailed(msg,
-                                            RttManager.REASON_INVALID_REQUEST, "Unspecified");
-                                } else {
-                                    sendMessage(CMD_ISSUE_NEXT_REQUEST);
-                                }
+                            //check permission
+                            if(DBG) Log.d(TAG, "UID is: " + msg.sendingUid);
+                            if (!enforcePermissionCheck(msg)) {
+                                Log.e(TAG, "UID: " + msg.sendingUid + " has no" +
+                                        " LOCATION_HARDWARE Permission");
+                                break;
                             }
+
+                            RttManager.ParcelableRttParams params =
+                                    (RttManager.ParcelableRttParams)msg.obj;
+                            if (params == null) {
+                                replyFailed(msg,
+                                        RttManager.REASON_INVALID_REQUEST, "No params");
+                            } else if (ci.addRttRequest(msg.arg2, params) == false) {
+                                replyFailed(msg,
+                                        RttManager.REASON_INVALID_REQUEST, "Unspecified");
+                            } else {
+                                sendMessage(CMD_ISSUE_NEXT_REQUEST);
+                            }
+                        }
                             break;
                         case RttManager.CMD_OP_STOP_RANGING:
+                            if(!enforcePermissionCheck(msg)) {
+                                break;
+                            }
+
                             for (Iterator<RttRequest> it = mRequestQueue.iterator();
                                     it.hasNext(); ) {
                                 RttRequest request = it.next();
@@ -312,6 +337,7 @@
                         case CMD_DRIVER_UNLOADED:
                             if (mOutstandingRequest != null) {
                                 WifiNative.cancelRtt(mOutstandingRequest.params);
+                                if (DBG) Log.d(TAG, "abort key: " + mOutstandingRequest.key);
                                 mOutstandingRequest.ci.reportAborted(mOutstandingRequest.key);
                                 mOutstandingRequest = null;
                             }
@@ -323,23 +349,38 @@
                                 if (mOutstandingRequest == null) {
                                     transitionTo(mEnabledState);
                                 }
+                                if(mOutstandingRequest != null) {
+                                    if (DBG) Log.d(TAG, "new mOutstandingRequest.key is: " +
+                                            mOutstandingRequest.key);
+                                } else {
+                                    if (DBG) Log.d(TAG,
+                                            "CMD_ISSUE_NEXT_REQUEST: mOutstandingRequest =null ");
+                                }
                             } else {
                                 /* just wait; we'll issue next request after
                                  * current one is finished */
-                                if (DBG) Log.d(TAG, "Ignoring CMD_ISSUE_NEXT_REQUEST");
+                                 if (DBG) Log.d(TAG, "Current mOutstandingRequest.key is: " +
+                                         mOutstandingRequest.key);
+                                 if (DBG) Log.d(TAG, "Ignoring CMD_ISSUE_NEXT_REQUEST");
                             }
                             break;
                         case CMD_RTT_RESPONSE:
-                            if (DBG) Log.d(TAG, "Received an RTT response");
+                            if (DBG) Log.d(TAG, "Received an RTT response from: " + msg.arg2);
                             mOutstandingRequest.ci.reportResult(
                                     mOutstandingRequest, (RttManager.RttResult[])msg.obj);
                             mOutstandingRequest = null;
                             sendMessage(CMD_ISSUE_NEXT_REQUEST);
                             break;
                         case RttManager.CMD_OP_STOP_RANGING:
+                            if(!enforcePermissionCheck(msg)) {
+                                Log.e(TAG, "UID: " + msg.sendingUid + " has no " +
+                                        "LOCATION_HARDWARE Permission");
+                                break;
+                            }
+
                             if (mOutstandingRequest != null
                                     && msg.arg2 == mOutstandingRequest.key) {
-                                if (DBG) Log.d(TAG, "Cancelling ongoing RTT");
+                                if (DBG) Log.d(TAG, "Cancelling ongoing RTT of: " + msg.arg2);
                                 WifiNative.cancelRtt(mOutstandingRequest.params);
                                 mOutstandingRequest.ci.reportAborted(mOutstandingRequest.key);
                                 mOutstandingRequest = null;
@@ -390,6 +431,17 @@
             }
         }
 
+        boolean enforcePermissionCheck(Message msg) {
+            try {
+                mContext.enforcePermission(Manifest.permission.LOCATION_HARDWARE,
+                         -1, msg.sendingUid, "LocationRTT");
+            } catch (SecurityException e) {
+                replyFailed(msg,RttManager.REASON_PERMISSION_DENIED, "No params");
+                return false;
+            }
+            return true;
+        }
+
         private WifiNative.RttEventHandler mEventHandler = new WifiNative.RttEventHandler() {
             @Override
             public void onRttResults(RttManager.RttResult[] result) {
@@ -401,12 +453,15 @@
             RttRequest request = null;
             while (mRequestQueue.isEmpty() == false) {
                 request = mRequestQueue.remove();
-                if (WifiNative.requestRtt(request.params, mEventHandler)) {
-                    if (DBG) Log.d(TAG, "Issued next RTT request");
-                    return request;
-                } else {
-                    request.ci.reportFailed(request,
-                            RttManager.REASON_UNSPECIFIED, "Failed to start");
+                if(request !=  null) {
+                    if (WifiNative.requestRtt(request.params, mEventHandler)) {
+                        if (DBG) Log.d(TAG, "Issued next RTT request with key: " + request.key);
+                        return request;
+                    } else {
+                        Log.e(TAG, "Fail to issue key at native layer");
+                        request.ci.reportFailed(request,
+                                RttManager.REASON_UNSPECIFIED, "Failed to start");
+                    }
                 }
             }
 
@@ -414,6 +469,10 @@
             if (DBG) Log.d(TAG, "No more requests left");
             return null;
         }
+        @Override
+        public RttManager.RttCapabilities getRttCapabilities() {
+            return WifiNative.getRttCapabilities();
+        }
     }
 
     private static final String TAG = "RttService";
@@ -442,4 +501,6 @@
             mImpl.startService(getContext());
         }
     }
+
+
 }
diff --git a/service/java/com/android/server/wifi/SIMAccessor.java b/service/java/com/android/server/wifi/SIMAccessor.java
new file mode 100644
index 0000000..e446436
--- /dev/null
+++ b/service/java/com/android/server/wifi/SIMAccessor.java
@@ -0,0 +1,32 @@
+package com.android.server.wifi;
+
+import android.content.Context;
+import android.telephony.SubscriptionManager;
+import android.telephony.TelephonyManager;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SIMAccessor {
+    private final TelephonyManager mTelephonyManager;
+    private final SubscriptionManager mSubscriptionManager;
+
+    public SIMAccessor(Context context) {
+        mTelephonyManager = TelephonyManager.from(context);
+        mSubscriptionManager = SubscriptionManager.from(context);
+    }
+
+    public List<String> getMatchingImsis(IMSIParameter mccMnc) {
+        if (mccMnc == null) {
+            return null;
+        }
+        List<String> imsis = new ArrayList<>();
+        for (int subId : mSubscriptionManager.getActiveSubscriptionIdList()) {
+            String imsi = mTelephonyManager.getSubscriberId(subId);
+            if (mccMnc.matches(imsi)) {
+                imsis.add(imsi);
+            }
+        }
+        return imsis.isEmpty() ? null : imsis;
+    }
+}
diff --git a/service/java/com/android/server/wifi/ScanDetail.java b/service/java/com/android/server/wifi/ScanDetail.java
new file mode 100644
index 0000000..868a192
--- /dev/null
+++ b/service/java/com/android/server/wifi/ScanDetail.java
@@ -0,0 +1,157 @@
+package com.android.server.wifi;
+
+import android.net.wifi.ScanResult;
+import android.net.wifi.WifiSsid;
+
+import com.android.server.wifi.anqp.ANQPElement;
+import com.android.server.wifi.anqp.Constants;
+import com.android.server.wifi.anqp.HSFriendlyNameElement;
+import com.android.server.wifi.anqp.VenueNameElement;
+import com.android.server.wifi.hotspot2.NetworkDetail;
+import com.android.server.wifi.hotspot2.PasspointMatch;
+import com.android.server.wifi.hotspot2.PasspointMatchInfo;
+import com.android.server.wifi.hotspot2.Utils;
+import com.android.server.wifi.hotspot2.pps.HomeSP;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+public class ScanDetail {
+    private final ScanResult mScanResult;
+    private volatile NetworkDetail mNetworkDetail;
+    private final Map<HomeSP, PasspointMatch> mMatches;
+    private long mSeen = 0;
+
+    public ScanDetail(NetworkDetail networkDetail, WifiSsid wifiSsid, String BSSID,
+                      String caps, int level, int frequency, long tsf) {
+        mNetworkDetail = networkDetail;
+        mScanResult = new ScanResult(wifiSsid, BSSID, caps, level, frequency, tsf );
+        mSeen = System.currentTimeMillis();
+        //mScanResult.seen = mSeen;
+        mScanResult.channelWidth = networkDetail.getChannelWidth();
+        mScanResult.centerFreq0 = networkDetail.getCenterfreq0();
+        mScanResult.centerFreq1 = networkDetail.getCenterfreq1();
+        if (networkDetail.is80211McResponderSupport())
+            mScanResult.setFlag(ScanResult.FLAG_80211mc_RESPONDER);
+        mMatches = null;
+    }
+
+    public ScanDetail(WifiSsid wifiSsid, String BSSID, String caps, int level, int frequency,
+                      long tsf, long seen) {
+        mNetworkDetail = null;
+        mScanResult = new ScanResult(wifiSsid, BSSID, caps, level, frequency, tsf );
+        mSeen = seen;
+        //mScanResult.seen = mSeen;
+        mScanResult.channelWidth = 0;
+        mScanResult.centerFreq0 = 0;
+        mScanResult.centerFreq1 = 0;
+        mScanResult.flags = 0;
+        mMatches = null;
+    }
+
+    private ScanDetail(ScanResult scanResult, NetworkDetail networkDetail,
+                       Map<HomeSP, PasspointMatch> matches) {
+        mScanResult = scanResult;
+        mNetworkDetail = networkDetail;
+        mMatches = matches;
+    }
+
+    public void updateResults(NetworkDetail networkDetail, int level, WifiSsid wssid, String ssid,
+                              String flags, int freq, long tsf) {
+        mScanResult.level = level;
+        mScanResult.wifiSsid = wssid;
+        // Keep existing API
+        mScanResult.SSID = ssid;
+        mScanResult.capabilities = flags;
+        mScanResult.frequency = freq;
+        mScanResult.timestamp = tsf;
+        mSeen = System.currentTimeMillis();
+        //mScanResult.seen = mSeen;
+        mScanResult.channelWidth = networkDetail.getChannelWidth();
+        mScanResult.centerFreq0 = networkDetail.getCenterfreq0();
+        mScanResult.centerFreq1 = networkDetail.getCenterfreq1();
+        if (networkDetail.is80211McResponderSupport())
+            mScanResult.setFlag(ScanResult.FLAG_80211mc_RESPONDER);
+        if (networkDetail.isInterworking())
+            mScanResult.setFlag(ScanResult.FLAG_PASSPOINT_NETWORK);
+    }
+
+    public void propagateANQPInfo(Map<Constants.ANQPElementType, ANQPElement> anqpElements) {
+        if (anqpElements.isEmpty()) {
+            return;
+        }
+        mNetworkDetail = mNetworkDetail.complete(anqpElements);
+        HSFriendlyNameElement fne = (HSFriendlyNameElement)anqpElements.get(
+                Constants.ANQPElementType.HSFriendlyName);
+        // !!! Match with language
+        if (fne != null && !fne.getNames().isEmpty()) {
+            mScanResult.venueName = fne.getNames().get(0).getText();
+        } else {
+            VenueNameElement vne =
+                    (((VenueNameElement)anqpElements.get(Constants.ANQPElementType.ANQPVenueName)));
+            if (vne != null && !vne.getNames().isEmpty()) {
+                mScanResult.venueName = vne.getNames().get(0).getText();
+            }
+        }
+    }
+
+    public ScanResult getScanResult() {
+        return mScanResult;
+    }
+
+    public NetworkDetail getNetworkDetail() {
+        return mNetworkDetail;
+    }
+
+    public String getSSID() {
+        return mNetworkDetail == null ? mScanResult.SSID : mNetworkDetail.getSSID();
+    }
+
+    public String getBSSIDString() {
+        return  mNetworkDetail == null ? mScanResult.BSSID : mNetworkDetail.getBSSIDString();
+    }
+
+    public String toKeyString() {
+        NetworkDetail networkDetail = mNetworkDetail;
+        if (networkDetail != null) {
+            return networkDetail.toKeyString();
+        }
+        else {
+            return String.format("'%s':%012x", mScanResult.BSSID, Utils.parseMac(mScanResult.BSSID));
+        }
+    }
+
+    public long getSeen() {
+        return mSeen;
+    }
+
+    public long setSeen() {
+        mSeen = System.currentTimeMillis();
+        mScanResult.seen = mSeen;
+        return mSeen;
+    }
+
+    public List<PasspointMatchInfo> getMatchList() {
+        if (mMatches == null || mMatches.isEmpty()) {
+            return null;
+        }
+
+        List<PasspointMatchInfo> list = new ArrayList<>();
+        for (Map.Entry<HomeSP, PasspointMatch> entry : mMatches.entrySet()) {
+            new PasspointMatchInfo(entry.getValue(), this, entry.getKey());
+        }
+        return list;
+    }
+
+    @Override
+    public String toString() {
+        try {
+            return String.format("'%s'/%012x",
+                    mScanResult.SSID, Utils.parseMac(mScanResult.BSSID));
+        }
+        catch (IllegalArgumentException iae) {
+            return String.format("'%s'/----", mScanResult.BSSID);
+        }
+    }
+}
diff --git a/service/java/com/android/server/wifi/ScanDetailCache.java b/service/java/com/android/server/wifi/ScanDetailCache.java
new file mode 100644
index 0000000..d246c55
--- /dev/null
+++ b/service/java/com/android/server/wifi/ScanDetailCache.java
@@ -0,0 +1,300 @@
+
+package com.android.server.wifi;
+
+import android.net.wifi.ScanResult;
+import android.net.wifi.WifiConfiguration;
+import android.util.Log;
+import android.os.SystemClock;
+
+import com.android.server.wifi.ScanDetail;
+import com.android.server.wifi.hotspot2.PasspointMatch;
+import com.android.server.wifi.hotspot2.PasspointMatchInfo;
+import com.android.server.wifi.hotspot2.pps.HomeSP;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+
+class ScanDetailCache {
+
+    private static final String TAG = "ScanDetailCache";
+
+    private WifiConfiguration mConfig;
+    private HashMap<String, ScanDetail> mMap;
+    private HashMap<String, PasspointMatchInfo> mPasspointMatches;
+    private static boolean DBG=false;
+    ScanDetailCache(WifiConfiguration config) {
+        mConfig = config;
+        mMap = new HashMap();
+        mPasspointMatches = new HashMap();
+    }
+
+    void put(ScanDetail scanDetail) {
+        put(scanDetail, null, null);
+    }
+
+    void put(ScanDetail scanDetail, PasspointMatch match, HomeSP homeSp) {
+
+        mMap.put(scanDetail.getBSSIDString(), scanDetail);
+
+        if (match != null && homeSp != null) {
+            mPasspointMatches.put(scanDetail.getBSSIDString(),
+                    new PasspointMatchInfo(match, scanDetail, homeSp));
+        }
+    }
+
+    ScanResult get(String bssid) {
+        ScanDetail scanDetail = getScanDetail(bssid);
+        return scanDetail == null ? null : scanDetail.getScanResult();
+    }
+
+    ScanDetail getScanDetail(String bssid) {
+        return mMap.get(bssid);
+    }
+
+    void remove(String bssid) {
+        mMap.remove(bssid);
+    }
+
+    int size() {
+        return mMap.size();
+    }
+
+    boolean isEmpty() {
+        return size() == 0;
+    }
+
+    ScanDetail getFirst() {
+        Iterator<ScanDetail> it = mMap.values().iterator();
+        return it.hasNext() ? it.next() : null;
+    }
+
+    Collection<String> keySet() {
+        return mMap.keySet();
+    }
+
+    Collection<ScanDetail> values() {
+        return mMap.values();
+    }
+
+    public void trim(int num) {
+        int currentSize = mMap.size();
+        if (currentSize <= num) {
+            return; // Nothing to trim
+        }
+        ArrayList<ScanDetail> list = new ArrayList<ScanDetail>(mMap.values());
+        if (list.size() != 0) {
+            // Sort by descending timestamp
+            Collections.sort(list, new Comparator() {
+                public int compare(Object o1, Object o2) {
+                    ScanDetail a = (ScanDetail) o1;
+                    ScanDetail b = (ScanDetail) o2;
+                    if (a.getSeen() > b.getSeen()) {
+                        return 1;
+                    }
+                    if (a.getSeen() < b.getSeen()) {
+                        return -1;
+                    }
+                    return a.getBSSIDString().compareTo(b.getBSSIDString());
+                }
+            });
+        }
+        for (int i = 0; i < currentSize - num ; i++) {
+            // Remove oldest results from scan cache
+            ScanDetail result = list.get(i);
+            mMap.remove(result.getBSSIDString());
+            mPasspointMatches.remove(result.getBSSIDString());
+        }
+    }
+
+    /* @hide */
+    private ArrayList<ScanDetail> sort() {
+        ArrayList<ScanDetail> list = new ArrayList<ScanDetail>(mMap.values());
+        if (list.size() != 0) {
+            Collections.sort(list, new Comparator() {
+                public int compare(Object o1, Object o2) {
+                    ScanResult a = ((ScanDetail)o1).getScanResult();
+                    ScanResult b = ((ScanDetail)o2).getScanResult();
+                    if (a.numIpConfigFailures > b.numIpConfigFailures) {
+                        return 1;
+                    }
+                    if (a.numIpConfigFailures < b.numIpConfigFailures) {
+                        return -1;
+                    }
+                    if (a.seen > b.seen) {
+                        return -1;
+                    }
+                    if (a.seen < b.seen) {
+                        return 1;
+                    }
+                    if (a.level > b.level) {
+                        return -1;
+                    }
+                    if (a.level < b.level) {
+                        return 1;
+                    }
+                    return a.BSSID.compareTo(b.BSSID);
+                }
+            });
+        }
+        return list;
+    }
+
+    public WifiConfiguration.Visibility getVisibilityByRssi(long age) {
+        WifiConfiguration.Visibility status = new WifiConfiguration.Visibility();
+
+        long now_ms = System.currentTimeMillis();
+        long now_elapsed_ms = SystemClock.elapsedRealtime();
+        for(ScanDetail scanDetail : values()) {
+            ScanResult result = scanDetail.getScanResult();
+            if (scanDetail.getSeen() == 0)
+                continue;
+
+            if (result.is5GHz()) {
+                //strictly speaking: [4915, 5825]
+                //number of known BSSID on 5GHz band
+                status.num5 = status.num5 + 1;
+            } else if (result.is24GHz()) {
+                //strictly speaking: [2412, 2482]
+                //number of known BSSID on 2.4Ghz band
+                status.num24 = status.num24 + 1;
+            }
+
+            if (result.timestamp != 0) {
+                if (DBG) {
+                    Log.e("getVisibilityByRssi", " considering " + result.SSID + " " + result.BSSID
+                        + " elapsed=" + now_elapsed_ms + " timestamp=" + result.timestamp
+                        + " age = " + age);
+                }
+                if ((now_elapsed_ms - (result.timestamp/1000)) > age) continue;
+            } else {
+                // This check the time at which we have received the scan result from supplicant
+                if ((now_ms - result.seen) > age) continue;
+            }
+
+            if (result.is5GHz()) {
+                if (result.level > status.rssi5) {
+                    status.rssi5 = result.level;
+                    status.age5 = result.seen;
+                    status.BSSID5 = result.BSSID;
+                }
+            } else if (result.is24GHz()) {
+                if (result.level > status.rssi24) {
+                    status.rssi24 = result.level;
+                    status.age24 = result.seen;
+                    status.BSSID24 = result.BSSID;
+                }
+            }
+        }
+
+        return status;
+    }
+
+    public WifiConfiguration.Visibility getVisibilityByPasspointMatch(long age) {
+
+        long now_ms = System.currentTimeMillis();
+        PasspointMatchInfo pmiBest24 = null, pmiBest5 = null;
+
+        for(PasspointMatchInfo pmi : mPasspointMatches.values()) {
+            ScanDetail scanDetail = pmi.getScanDetail();
+            if (scanDetail == null) continue;
+            ScanResult result = scanDetail.getScanResult();
+            if (result == null) continue;
+
+            if (scanDetail.getSeen() == 0)
+                continue;
+
+            if ((now_ms - result.seen) > age) continue;
+
+            if (result.is5GHz()) {
+                if (pmiBest5 == null || pmiBest5.compareTo(pmi) < 0) {
+                    pmiBest5 = pmi;
+                }
+            } else if (result.is24GHz()) {
+                if (pmiBest24 == null || pmiBest24.compareTo(pmi) < 0) {
+                    pmiBest24 = pmi;
+                }
+            }
+        }
+
+        WifiConfiguration.Visibility status = new WifiConfiguration.Visibility();
+        String logMsg = "Visiblity by passpoint match returned ";
+        if (pmiBest5 != null) {
+            ScanResult result = pmiBest5.getScanDetail().getScanResult();
+            status.rssi5 = result.level;
+            status.age5 = result.seen;
+            status.BSSID5 = result.BSSID;
+            logMsg += "5 GHz BSSID of " + result.BSSID;
+        }
+        if (pmiBest24 != null) {
+            ScanResult result = pmiBest24.getScanDetail().getScanResult();
+            status.rssi24 = result.level;
+            status.age24 = result.seen;
+            status.BSSID24 = result.BSSID;
+            logMsg += "2.4 GHz BSSID of " + result.BSSID;
+        }
+
+        Log.d(TAG, logMsg);
+
+        return status;
+    }
+
+    public WifiConfiguration.Visibility getVisibility(long age) {
+        if (mConfig.isPasspoint()) {
+            return getVisibilityByPasspointMatch(age);
+        } else {
+            return getVisibilityByRssi(age);
+        }
+    }
+
+
+
+    @Override
+    public String toString() {
+        StringBuilder sbuf = new StringBuilder();
+        sbuf.append("Scan Cache:  ").append('\n');
+
+        ArrayList<ScanDetail> list = sort();
+        long now_ms = System.currentTimeMillis();
+        if (list.size() > 0) {
+            for (ScanDetail scanDetail : list) {
+                ScanResult result = scanDetail.getScanResult();
+                long milli = now_ms - scanDetail.getSeen();
+                long ageSec = 0;
+                long ageMin = 0;
+                long ageHour = 0;
+                long ageMilli = 0;
+                long ageDay = 0;
+                if (now_ms > scanDetail.getSeen() && scanDetail.getSeen() > 0) {
+                    ageMilli = milli % 1000;
+                    ageSec   = (milli / 1000) % 60;
+                    ageMin   = (milli / (60*1000)) % 60;
+                    ageHour  = (milli / (60*60*1000)) % 24;
+                    ageDay   = (milli / (24*60*60*1000));
+                }
+                sbuf.append("{").append(result.BSSID).append(",").append(result.frequency);
+                sbuf.append(",").append(String.format("%3d", result.level));
+                if (result.autoJoinStatus > 0) {
+                    sbuf.append(",st=").append(result.autoJoinStatus);
+                }
+                if (ageSec > 0 || ageMilli > 0) {
+                    sbuf.append(String.format(",%4d.%02d.%02d.%02d.%03dms", ageDay,
+                            ageHour, ageMin, ageSec, ageMilli));
+                }
+                if (result.numIpConfigFailures > 0) {
+                    sbuf.append(",ipfail=");
+                    sbuf.append(result.numIpConfigFailures);
+                }
+                sbuf.append("} ");
+            }
+            sbuf.append('\n');
+        }
+
+        return sbuf.toString();
+    }
+
+}
diff --git a/service/java/com/android/server/wifi/WifiApConfigStore.java b/service/java/com/android/server/wifi/WifiApConfigStore.java
index eb35db8..ed5ddf7 100644
--- a/service/java/com/android/server/wifi/WifiApConfigStore.java
+++ b/service/java/com/android/server/wifi/WifiApConfigStore.java
@@ -37,6 +37,7 @@
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.UUID;
 
 /**
@@ -51,7 +52,7 @@
     private static final String AP_CONFIG_FILE = Environment.getDataDirectory() +
         "/misc/wifi/softap.conf";
 
-    private static final int AP_CONFIG_FILE_VERSION = 1;
+    private static final int AP_CONFIG_FILE_VERSION = 2;
 
     private State mDefaultState = new DefaultState();
     private State mInactiveState = new InactiveState();
@@ -59,6 +60,7 @@
 
     private WifiConfiguration mWifiApConfig = null;
     private AsyncChannel mReplyChannel = new AsyncChannel();
+    public ArrayList <Integer> allowed2GChannel = null;
 
     WifiApConfigStore(Context context, Handler target) {
         super(TAG, target.getLooper());
@@ -69,6 +71,17 @@
             addState(mActiveState, mDefaultState);
 
         setInitialState(mInactiveState);
+        String ap2GChannelListStr = (mContext.getResources().getString(
+                R.string.config_wifi_framework_sap_2G_channel_list));
+        Log.d(TAG, "2G band allowed channels are:" + ap2GChannelListStr);
+
+        if (ap2GChannelListStr != null) {
+            allowed2GChannel = new ArrayList<Integer>();
+            String channelList[] = ap2GChannelListStr.split(",");
+            for (String tmp : channelList) {
+                allowed2GChannel.add(Integer.parseInt(tmp));
+            }
+        }
     }
 
     public static WifiApConfigStore makeWifiApConfigStore(Context context, Handler target) {
@@ -100,9 +113,9 @@
         public boolean processMessage(Message message) {
             switch (message.what) {
                 case WifiStateMachine.CMD_SET_AP_CONFIG:
-                    WifiConfiguration config = (WifiConfiguration) message.obj;
+                     WifiConfiguration config = (WifiConfiguration)message.obj;
                     if (config.SSID != null) {
-                        mWifiApConfig = (WifiConfiguration) message.obj;
+                        mWifiApConfig = config;
                         transitionTo(mActiveState);
                     } else {
                         Log.e(TAG, "Try to setup AP config without SSID: " + message);
@@ -150,17 +163,24 @@
                             AP_CONFIG_FILE)));
 
             int version = in.readInt();
-            if (version != 1) {
+            if ((version != 1) && (version != 2)) {
                 Log.e(TAG, "Bad version on hotspot configuration file, set defaults");
                 setDefaultApConfiguration();
                 return;
             }
             config.SSID = in.readUTF();
+
+            if (version >= 2) {
+                config.apBand = in.readInt();
+                config.apChannel = in.readInt();
+            }
+
             int authType = in.readInt();
             config.allowedKeyManagement.set(authType);
             if (authType != KeyMgmt.NONE) {
                 config.preSharedKey = in.readUTF();
             }
+
             mWifiApConfig = config;
         } catch (IOException ignore) {
             setDefaultApConfiguration();
@@ -185,6 +205,8 @@
 
             out.writeInt(AP_CONFIG_FILE_VERSION);
             out.writeUTF(config.SSID);
+            out.writeInt(config.apBand);
+            out.writeInt(config.apChannel);
             int authType = config.getAuthType();
             out.writeInt(authType);
             if(authType != KeyMgmt.NONE) {
diff --git a/service/java/com/android/server/wifi/WifiAutoJoinController.java b/service/java/com/android/server/wifi/WifiAutoJoinController.java
index c7da179..a1a9a82 100644
--- a/service/java/com/android/server/wifi/WifiAutoJoinController.java
+++ b/service/java/com/android/server/wifi/WifiAutoJoinController.java
@@ -20,17 +20,23 @@
 import android.net.NetworkKey;
 import android.net.NetworkScoreManager;
 import android.net.WifiKey;
-import android.net.wifi.*;
+import android.net.wifi.ScanResult;
+import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiConfiguration.KeyMgmt;
-import android.os.SystemClock;
-import android.provider.Settings;
+import android.net.wifi.WifiConnectionStatistics;
 import android.os.Process;
+import android.provider.Settings;
 import android.text.TextUtils;
 import android.util.Log;
+import android.os.SystemClock;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.StringReader;
 import java.util.ArrayList;
-import java.util.Iterator;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 
 /**
@@ -59,12 +65,13 @@
 
     private String mCurrentConfigurationKey = null; //used by autojoin
 
-    private HashMap<String, ScanResult> scanResultCache =
-            new HashMap<String, ScanResult>();
+    private final HashMap<String, ScanDetail> scanResultCache = new HashMap<>();
 
     private WifiConnectionStatistics mWifiConnectionStatistics;
 
-    /** Whether to allow connections to untrusted networks. */
+    /**
+     * Whether to allow connections to untrusted networks.
+     */
     private boolean mAllowUntrustedConnections = false;
 
     /* For debug purpose only: if the scored override a score */
@@ -75,7 +82,9 @@
     // Lose some temporary blacklisting after 30 minutes
     private final static long loseBlackListSoftMilli = 1000 * 60 * 30;
 
-    /** @see android.provider.Settings.Global#WIFI_EPHEMERAL_OUT_OF_RANGE_TIMEOUT_MS */
+    /**
+     * @see android.provider.Settings.Global#WIFI_EPHEMERAL_OUT_OF_RANGE_TIMEOUT_MS
+     */
     private static final long DEFAULT_EPHEMERAL_OUT_OF_RANGE_TIMEOUT_MS = 1000 * 60; // 1 minute
 
     public static final int AUTO_JOIN_IDLE = 0;
@@ -85,6 +94,8 @@
 
     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.
@@ -123,7 +134,7 @@
     }
 
     void enableVerboseLogging(int verbose) {
-        if (verbose > 0 ) {
+        if (verbose > 0) {
             DBG = true;
             VDBG = true;
         } else {
@@ -134,7 +145,6 @@
 
     /**
      * Flush out scan results older than mScanResultMaximumAge
-     *
      */
     private void ageScanResultsOut(int delay) {
         if (delay <= 0) {
@@ -146,18 +156,67 @@
                     + Integer.valueOf(scanResultCache.size()) + " now " + Long.valueOf(milli));
         }
 
-        Iterator<HashMap.Entry<String,ScanResult>> iter = scanResultCache.entrySet().iterator();
+        Iterator<HashMap.Entry<String, ScanDetail>> iter = scanResultCache.entrySet().iterator();
         while (iter.hasNext()) {
-            HashMap.Entry<String,ScanResult> entry = iter.next();
-            ScanResult result = entry.getValue();
-
-            if ((result.seen + delay) < milli) {
+            HashMap.Entry<String, ScanDetail> entry = iter.next();
+            ScanDetail scanDetail = entry.getValue();
+            if ((scanDetail.getSeen() + delay) < milli) {
                 iter.remove();
             }
         }
     }
 
-    int addToScanCache(List<ScanResult> scanList) {
+
+    void averageRssiAndRemoveFromCache(ScanResult result) {
+        // Fetch the previous instance for this result
+        ScanDetail sd = scanResultCache.get(result.BSSID);
+        if (sd != null) {
+            ScanResult sr = sd.getScanResult();
+            if (mWifiConfigStore.scanResultRssiLevelPatchUp != 0
+                    && result.level == 0
+                    && sr.level < -20) {
+                // A 'zero' RSSI reading is most likely a chip problem which returns
+                // an unknown RSSI, hence ignore it
+                result.level = sr.level;
+            }
+
+            // If there was a previous cache result for this BSSID, average the RSSI values
+            result.averageRssi(sr.level, sr.seen, mScanResultMaximumAge);
+
+            // Remove the previous Scan Result - this is not necessary
+            scanResultCache.remove(result.BSSID);
+        } else if (mWifiConfigStore.scanResultRssiLevelPatchUp != 0 && result.level == 0) {
+            // A 'zero' RSSI reading is most likely a chip problem which returns
+            // an unknown RSSI, hence initialize it to a sane value
+            result.level = mWifiConfigStore.scanResultRssiLevelPatchUp;
+        }
+    }
+
+    void addToUnscoredNetworks(ScanResult result, List<NetworkKey> unknownScanResults) {
+        WifiKey wkey;
+        // Quoted SSIDs are the only one valid at this stage
+        try {
+            wkey = new WifiKey("\"" + result.SSID + "\"", result.BSSID);
+        } catch (IllegalArgumentException e) {
+            logDbg("AutoJoinController: received badly encoded SSID=[" + result.SSID +
+                    "] ->skipping this network");
+            wkey = null;
+        }
+        if (wkey != null) {
+            NetworkKey nkey = new NetworkKey(wkey);
+            //if we don't know this scan result then request a score from the scorer
+            unknownScanResults.add(nkey);
+        }
+        if (VDBG) {
+            String cap = "";
+            if (result.capabilities != null)
+                cap = result.capabilities;
+            logDbg(result.SSID + " " + result.BSSID + " rssi="
+                    + result.level + " cap " + cap + " tsf " + result.timestamp + " is not scored");
+        }
+    }
+
+    int addToScanCache(List<ScanDetail> scanList) {
         int numScanResultsKnown = 0; // Record number of scan results we knew about
         WifiConfiguration associatedConfig = null;
         boolean didAssociate = false;
@@ -165,56 +224,24 @@
 
         ArrayList<NetworkKey> unknownScanResults = new ArrayList<NetworkKey>();
 
-        for(ScanResult result: scanList) {
+        for (ScanDetail scanDetail : scanList) {
+            ScanResult result = scanDetail.getScanResult();
             if (result.SSID == null) continue;
 
-            // Make sure we record the last time we saw this result
-            result.seen = System.currentTimeMillis();
-
-            // Fetch the previous instance for this result
-            ScanResult sr = scanResultCache.get(result.BSSID);
-            if (sr != null) {
-                if (mWifiConfigStore.scanResultRssiLevelPatchUp != 0
-                        && result.level == 0
-                        && sr.level < -20) {
-                    // A 'zero' RSSI reading is most likely a chip problem which returns
-                    // an unknown RSSI, hence ignore it
-                    result.level = sr.level;
-                }
-
-                // If there was a previous cache result for this BSSID, average the RSSI values
-                result.averageRssi(sr.level, sr.seen, mScanResultMaximumAge);
-
-                // Remove the previous Scan Result - this is not necessary
-                scanResultCache.remove(result.BSSID);
-            } else if (mWifiConfigStore.scanResultRssiLevelPatchUp != 0 && result.level == 0) {
-                // A 'zero' RSSI reading is most likely a chip problem which returns
-                // an unknown RSSI, hence initialize it to a sane value
-                result.level = mWifiConfigStore.scanResultRssiLevelPatchUp;
+            if (VDBG) {
+                logDbg(" addToScanCache " + result.SSID + " " + result.BSSID
+                        + " tsf=" + result.timestamp
+                        + " now= " + now + " uptime=" + SystemClock.uptimeMillis()
+                        + " elapsed=" + SystemClock.elapsedRealtime());
             }
 
+            // Make sure we record the last time we saw this result
+            scanDetail.setSeen();
+
+            averageRssiAndRemoveFromCache(result);
+
             if (!mNetworkScoreCache.isScoredNetwork(result)) {
-                WifiKey wkey;
-                // Quoted SSIDs are the only one valid at this stage
-                try {
-                    wkey = new WifiKey("\"" + result.SSID + "\"", result.BSSID);
-                } catch (IllegalArgumentException e) {
-                    logDbg("AutoJoinController: received badly encoded SSID=[" + result.SSID +
-                            "] ->skipping this network");
-                    wkey = null;
-                }
-                if (wkey != null) {
-                    NetworkKey nkey = new NetworkKey(wkey);
-                    //if we don't know this scan result then request a score from the scorer
-                    unknownScanResults.add(nkey);
-                }
-                if (VDBG) {
-                    String cap = "";
-                    if (result.capabilities != null)
-                        cap = result.capabilities;
-                    logDbg(result.SSID + " " + result.BSSID + " rssi="
-                            + result.level + " cap " + cap + " is not scored");
-                }
+                addToUnscoredNetworks(result, unknownScanResults);
             } else {
                 if (VDBG) {
                     String cap = "";
@@ -227,29 +254,15 @@
             }
 
             // scanResultCache.put(result.BSSID, new ScanResult(result));
-            scanResultCache.put(result.BSSID, result);
+            scanResultCache.put(result.BSSID, scanDetail);
             // Add this BSSID to the scanResultCache of a Saved WifiConfiguration
-            didAssociate = mWifiConfigStore.updateSavedNetworkHistory(result);
+            didAssociate = mWifiConfigStore.updateSavedNetworkHistory(scanDetail);
 
             // If not successful, try to associate this BSSID to an existing Saved WifiConfiguration
             if (!didAssociate) {
                 // We couldn't associate the scan result to a Saved WifiConfiguration
                 // Hence it is untrusted
                 result.untrusted = true;
-                associatedConfig = mWifiConfigStore.associateWithConfiguration(result);
-                if (associatedConfig != null && associatedConfig.SSID != null) {
-                    if (VDBG) {
-                        logDbg("addToScanCache save associated config "
-                                + associatedConfig.SSID + " with " + result.SSID
-                                + " status " + associatedConfig.autoJoinStatus
-                                + " reason " + associatedConfig.disableReason
-                                + " tsp " + associatedConfig.blackListTimestamp
-                                + " was " + (now - associatedConfig.blackListTimestamp));
-                    }
-                    mWifiStateMachine.sendMessage(
-                            WifiStateMachine.CMD_AUTO_SAVE_NETWORK, associatedConfig);
-                    didAssociate = true;
-                }
             } else {
                 // If the scan result has been blacklisted fir 18 hours -> unblacklist
                 if ((now - result.blackListTimestamp) > loseBlackListHardMilli) {
@@ -258,7 +271,7 @@
             }
             if (didAssociate) {
                 numScanResultsKnown++;
-                result.isAutoJoinCandidate ++;
+                result.isAutoJoinCandidate++;
             } else {
                 result.isAutoJoinCandidate = 0;
             }
@@ -279,26 +292,26 @@
 
     void logDbg(String message, boolean stackTrace) {
         if (stackTrace) {
-            Log.e(TAG, message + " stack:"
+            Log.d(TAG, message + " stack:"
                     + Thread.currentThread().getStackTrace()[2].getMethodName() + " - "
                     + Thread.currentThread().getStackTrace()[3].getMethodName() + " - "
                     + Thread.currentThread().getStackTrace()[4].getMethodName() + " - "
                     + Thread.currentThread().getStackTrace()[5].getMethodName());
         } else {
-            Log.e(TAG, message);
+            Log.d(TAG, message);
         }
     }
 
     // Called directly from WifiStateMachine
     int newSupplicantResults(boolean doAutoJoin) {
         int numScanResultsKnown;
-        List<ScanResult> scanList = mWifiStateMachine.getScanResultsListNoCopyUnsync();
+        List<ScanDetail> scanList = mWifiStateMachine.getScanResultsListNoCopyUnsync();
         numScanResultsKnown = addToScanCache(scanList);
         ageScanResultsOut(mScanResultMaximumAge);
         if (DBG) {
             logDbg("newSupplicantResults size=" + Integer.valueOf(scanResultCache.size())
-                        + " known=" + numScanResultsKnown + " "
-                        + doAutoJoin);
+                    + " known=" + numScanResultsKnown + " "
+                    + doAutoJoin);
         }
         if (doAutoJoin) {
             attemptAutoJoin();
@@ -316,7 +329,7 @@
      * results as normal.
      */
     void newHalScanResults() {
-        List<ScanResult> scanList = null;//mWifiScanner.syncGetScanResultsList();
+        List<ScanDetail> scanList = null;//mWifiScanner.syncGetScanResultsList();
         String akm = WifiParser.parse_akm(null, null);
         logDbg(akm);
         addToScanCache(scanList);
@@ -326,7 +339,7 @@
     }
 
     /**
-     *  network link quality changed, called directly from WifiTrafficPoller,
+     * network link quality changed, called directly from WifiTrafficPoller,
      * or by listening to Link Quality intent
      */
     void linkQualitySignificantChange() {
@@ -350,7 +363,7 @@
         if (currentNetwork == null) {
             // Return any absurdly high score, if we are not connected there is no current
             // network to...
-           return 1000;
+            return 1000;
         }
 
         if (candidate.configKey(true).equals(currentNetwork.configKey(true))) {
@@ -375,7 +388,7 @@
             // above RSSI/scorer based selection of linked configuration (+/- 50)
             // by reducing order by -100
             order = order - 100;
-            if (VDBG)   {
+            if (VDBG) {
                 logDbg("     ...and prefers -100 " + currentNetwork.configKey()
                         + " over " + candidate.configKey()
                         + " because it is the last selected -> "
@@ -388,7 +401,7 @@
             // above RSSI/scorer based selection of linked configuration (+/- 50)
             // by increasing order by +100
             order = order + 100;
-            if (VDBG)   {
+            if (VDBG) {
                 logDbg("     ...and prefers +100 " + candidate.configKey()
                         + " over " + currentNetwork.configKey()
                         + " because it is the last selected -> "
@@ -408,7 +421,7 @@
      *
      * @param netId
      * @param userTriggered : if the update come from WiFiManager
-     * @param connect : if the update includes a connect
+     * @param connect       : if the update includes a connect
      */
     public void updateConfigurationHistory(int netId, boolean userTriggered, boolean connect) {
         WifiConfiguration selected = mWifiConfigStore.getWifiConfiguration(netId);
@@ -472,30 +485,17 @@
                         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
@@ -508,11 +508,6 @@
                             + " 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.intValue();
-                    }
                     // Add the visible config to the selected's connect choice list
                     selected.connectChoices.put(config.configKey(true), choice);
 
@@ -525,21 +520,21 @@
                         config.connectChoices.remove(selected.configKey(true));
 
                         if (selected.linkedConfigurations != null) {
-                           // Remove the selected's linked configuration from the
-                           // recently seen config's connectChoice list
-                           for (String key : selected.linkedConfigurations.keySet()) {
-                               config.connectChoices.remove(key);
-                           }
+                            // Remove the selected's linked configuration from the
+                            // recently seen config's connectChoice list
+                            for (String key : selected.linkedConfigurations.keySet()) {
+                                config.connectChoices.remove(key);
+                            }
                         }
                     }
                 }
                 if (found == false) {
-                     // We haven't found the configuration that the user just selected in our
-                     // scan cache.
-                     // In that case we will need a new scan before attempting to connect to this
-                     // configuration anyhow and thus we can process the scan results then.
-                     logDbg("updateConfigurationHistory try to connect to an old network!! : "
-                             + selected.configKey());
+                    // We haven't found the configuration that the user just selected in our
+                    // scan cache.
+                    // In that case we will need a new scan before attempting to connect to this
+                    // configuration anyhow and thus we can process the scan results then.
+                    logDbg("updateConfigurationHistory try to connect to an old network!! : "
+                            + selected.configKey());
                 }
 
                 if (selected.connectChoices != null) {
@@ -556,39 +551,44 @@
         }
     }
 
-    int getConnectChoice(WifiConfiguration source, WifiConfiguration target) {
-        Integer choice = null;
+    int getConnectChoice(WifiConfiguration source, WifiConfiguration target, boolean strict) {
+        int choice = 0;
         if (source == null || target == null) {
             return 0;
         }
 
         if (source.connectChoices != null
                 && source.connectChoices.containsKey(target.configKey(true))) {
-            choice = source.connectChoices.get(target.configKey(true));
+            Integer val = source.connectChoices.get(target.configKey(true));
+            if (val != null) {
+                choice = val;
+            }
         } else if (source.linkedConfigurations != null) {
             for (String key : source.linkedConfigurations.keySet()) {
                 WifiConfiguration config = mWifiConfigStore.getWifiConfiguration(key);
                 if (config != null) {
                     if (config.connectChoices != null) {
-                        choice = config.connectChoices.get(target.configKey(true));
+                        Integer val = config.connectChoices.get(target.configKey(true));
+                        if (val != null) {
+                            choice = val;
+                        }
                     }
                 }
             }
         }
 
-        if (choice == null) {
-            //We didn't find the connect choice
-            return 0;
-        } else {
-            if (choice.intValue() < 0) {
-                choice = 20; // Compatibility with older files
-            }
-            return choice.intValue();
+        if (!strict && choice == 0) {
+            // We didn't find the connect choice; fallback to some default choices
+            int sourceScore = getSecurityScore(source);
+            int targetScore = getSecurityScore(target);
+            choice = sourceScore - targetScore;
         }
+
+        return choice;
     }
 
-    int compareWifiConfigurationsFromVisibility(WifiConfiguration a, int aRssiBoost,
-             WifiConfiguration b, int bRssiBoost) {
+    int compareWifiConfigurationsFromVisibility(WifiConfiguration.Visibility a, int aRssiBoost,
+                                                String dbgA, WifiConfiguration.Visibility b, int bRssiBoost, String dbgB) {
 
         int aRssiBoost5 = 0; // 5GHz RSSI boost to apply for purpose band selection (5GHz pref)
         int bRssiBoost5 = 0; // 5GHz RSSI boost to apply for purpose band selection (5GHz pref)
@@ -606,17 +606,17 @@
          * This implements band preference where we prefer 5GHz if RSSI5 is good enough, whereas
          * we prefer 2.4GHz otherwise.
          */
-        aRssiBoost5 = rssiBoostFrom5GHzRssi(a.visibility.rssi5, a.configKey() + "->");
-        bRssiBoost5 = rssiBoostFrom5GHzRssi(b.visibility.rssi5, b.configKey() + "->");
+        aRssiBoost5 = rssiBoostFrom5GHzRssi(a.rssi5, dbgA + "->");
+        bRssiBoost5 = rssiBoostFrom5GHzRssi(b.rssi5, dbgB + "->");
 
         // Select which band to use for a
-        if (a.visibility.rssi5 + aRssiBoost5 > a.visibility.rssi24) {
+        if (a.rssi5 + aRssiBoost5 > a.rssi24) {
             // Prefer a's 5GHz
             aPrefers5GHz = true;
         }
 
         // Select which band to use for b
-        if (b.visibility.rssi5 + bRssiBoost5 > b.visibility.rssi24) {
+        if (b.rssi5 + bRssiBoost5 > b.rssi24) {
             // Prefer b's 5GHz
             bPrefers5GHz = true;
         }
@@ -626,13 +626,13 @@
                 // If both a and b are on 5GHz then we don't apply the 5GHz RSSI boost to either
                 // one, but directly compare the RSSI values, this improves stability,
                 // since the 5GHz RSSI boost can introduce large fluctuations
-                aScore = a.visibility.rssi5 + aRssiBoost;
+                aScore = a.rssi5 + aRssiBoost;
             } else {
                 // If only a is on 5GHz, then apply the 5GHz preference boost to a
-                aScore = a.visibility.rssi5 + aRssiBoost + aRssiBoost5;
+                aScore = a.rssi5 + aRssiBoost + aRssiBoost5;
             }
         } else {
-            aScore = a.visibility.rssi24 + aRssiBoost;
+            aScore = a.rssi24 + aRssiBoost;
         }
 
         if (bPrefers5GHz) {
@@ -640,29 +640,30 @@
                 // If both a and b are on 5GHz then we don't apply the 5GHz RSSI boost to either
                 // one, but directly compare the RSSI values, this improves stability,
                 // since the 5GHz RSSI boost can introduce large fluctuations
-                bScore = b.visibility.rssi5 + bRssiBoost;
+                bScore = b.rssi5 + bRssiBoost;
             } else {
                 // If only b is on 5GHz, then apply the 5GHz preference boost to b
-                bScore = b.visibility.rssi5 + bRssiBoost + bRssiBoost5;
+                bScore = b.rssi5 + bRssiBoost + bRssiBoost5;
             }
         } else {
-            bScore = b.visibility.rssi24 + bRssiBoost;
+            bScore = b.rssi24 + bRssiBoost;
         }
+
         if (VDBG) {
-            logDbg("        " + a.configKey() + " is5=" + aPrefers5GHz + " score=" + aScore
-                    + " " + b.configKey() + " is5=" + bPrefers5GHz + " score=" + bScore);
+            logDbg("        " + dbgA + " is5=" + aPrefers5GHz + " score=" + aScore
+                    + " " + dbgB + " is5=" + bPrefers5GHz + " score=" + bScore);
         }
 
         // Debug only, record RSSI comparison parameters
-        if (a.visibility != null) {
-            a.visibility.score = aScore;
-            a.visibility.currentNetworkBoost = aRssiBoost;
-            a.visibility.bandPreferenceBoost = aRssiBoost5;
+        if (a != null) {
+            a.score = aScore;
+            a.currentNetworkBoost = aRssiBoost;
+            a.bandPreferenceBoost = aRssiBoost5;
         }
-        if (b.visibility != null) {
-            b.visibility.score = bScore;
-            b.visibility.currentNetworkBoost = bRssiBoost;
-            b.visibility.bandPreferenceBoost = bRssiBoost5;
+        if (b != null) {
+            b.score = bScore;
+            b.currentNetworkBoost = bRssiBoost;
+            b.bandPreferenceBoost = bRssiBoost5;
         }
 
         // Compare a and b
@@ -686,9 +687,6 @@
         int aRssiBoost = 0;
         int bRssiBoost = 0;
 
-        int scoreA;
-        int scoreB;
-
         // Retrieve the visibility
         WifiConfiguration.Visibility astatus = a.visibility;
         WifiConfiguration.Visibility bstatus = b.visibility;
@@ -707,23 +705,25 @@
             }
         }
 
-        if (VDBG)  {
+        if (VDBG) {
             logDbg("    compareWifiConfigurationsRSSI: " + a.configKey()
-                    + " rssi=" + Integer.toString(astatus.rssi24)
-                    + "," + Integer.toString(astatus.rssi5)
-                    + " boost=" + Integer.toString(aRssiBoost)
-                    + " " + b.configKey() + " rssi="
-                    + Integer.toString(bstatus.rssi24) + ","
-                    + Integer.toString(bstatus.rssi5)
-                    + " boost=" + Integer.toString(bRssiBoost)
+                            + " rssi=" + Integer.toString(astatus.rssi24)
+                            + "," + Integer.toString(astatus.rssi5)
+                            + " boost=" + Integer.toString(aRssiBoost)
+                            + " " + b.configKey() + " rssi="
+                            + Integer.toString(bstatus.rssi24) + ","
+                            + Integer.toString(bstatus.rssi5)
+                            + " boost=" + Integer.toString(bRssiBoost)
             );
         }
 
-        order = compareWifiConfigurationsFromVisibility(a, aRssiBoost, b, bRssiBoost);
+        order = compareWifiConfigurationsFromVisibility(
+                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 = " = ";
@@ -750,64 +750,85 @@
 
     /**
      * b/18490330 only use scorer for untrusted networks
-     *
-    int compareWifiConfigurationsWithScorer(WifiConfiguration a, WifiConfiguration b) {
-
-        boolean aIsActive = false;
-        boolean bIsActive = false;
-
-        // Apply Hysteresis : boost RSSI of current configuration before
-        // looking up the score
-        if (null != mCurrentConfigurationKey) {
-            if (a.configKey().equals(mCurrentConfigurationKey)) {
-                aIsActive = true;
-            } else if (b.configKey().equals(mCurrentConfigurationKey)) {
-                bIsActive = true;
-            }
-        }
-        int scoreA = getConfigNetworkScore(a, mScanResultAutoJoinAge, aIsActive);
-        int scoreB = getConfigNetworkScore(b, mScanResultAutoJoinAge, bIsActive);
-
-        // Both configurations need to have a score for the scorer to be used
-        // ...and the scores need to be different:-)
-        if (scoreA == WifiNetworkScoreCache.INVALID_NETWORK_SCORE
-                || scoreB == WifiNetworkScoreCache.INVALID_NETWORK_SCORE) {
-            if (VDBG)  {
-                logDbg("    compareWifiConfigurationsWithScorer no-scores: "
-                        + a.configKey()
-                        + " "
-                        + b.configKey());
-            }
-            return 0;
-        }
-
-        if (VDBG) {
-            String prefer = " = ";
-            if (scoreA < scoreB) {
-                prefer = " < ";
-            } if (scoreA > scoreB) {
-                prefer = " > ";
-            }
-            logDbg("    compareWifiConfigurationsWithScorer " + a.configKey()
-                    + " rssi=(" + a.visibility.rssi24
-                    + "," + a.visibility.rssi5
-                    + ") num=(" + a.visibility.num24
-                    + "," + a.visibility.num5 + ")"
-                    + " sc=" + scoreA
-                    + prefer + b.configKey()
-                    + " rssi=(" + b.visibility.rssi24
-                    + "," + b.visibility.rssi5
-                    + ") num=(" + b.visibility.num24
-                    + "," + b.visibility.num5 + ")"
-                    + " sc=" + scoreB
-                    + " -> " + Integer.toString(scoreB - scoreA));
-        }
-
-        // If scoreA > scoreB, the comparison is descending hence the return value is negative
-        return scoreB - scoreA;
-    }
+     * <p/>
+     * int compareWifiConfigurationsWithScorer(WifiConfiguration a, WifiConfiguration b) {
+     * <p/>
+     * boolean aIsActive = false;
+     * boolean bIsActive = false;
+     * <p/>
+     * // Apply Hysteresis : boost RSSI of current configuration before
+     * // looking up the score
+     * if (null != mCurrentConfigurationKey) {
+     * if (a.configKey().equals(mCurrentConfigurationKey)) {
+     * aIsActive = true;
+     * } else if (b.configKey().equals(mCurrentConfigurationKey)) {
+     * bIsActive = true;
+     * }
+     * }
+     * int scoreA = getConfigNetworkScore(a, mScanResultAutoJoinAge, aIsActive);
+     * int scoreB = getConfigNetworkScore(b, mScanResultAutoJoinAge, bIsActive);
+     * <p/>
+     * // Both configurations need to have a score for the scorer to be used
+     * // ...and the scores need to be different:-)
+     * if (scoreA == WifiNetworkScoreCache.INVALID_NETWORK_SCORE
+     * || scoreB == WifiNetworkScoreCache.INVALID_NETWORK_SCORE) {
+     * if (VDBG)  {
+     * logDbg("    compareWifiConfigurationsWithScorer no-scores: "
+     * + a.configKey()
+     * + " "
+     * + b.configKey());
+     * }
+     * return 0;
+     * }
+     * <p/>
+     * if (VDBG) {
+     * String prefer = " = ";
+     * if (scoreA < scoreB) {
+     * prefer = " < ";
+     * } if (scoreA > scoreB) {
+     * prefer = " > ";
+     * }
+     * logDbg("    compareWifiConfigurationsWithScorer " + a.configKey()
+     * + " rssi=(" + a.visibility.rssi24
+     * + "," + a.visibility.rssi5
+     * + ") num=(" + a.visibility.num24
+     * + "," + a.visibility.num5 + ")"
+     * + " sc=" + scoreA
+     * + prefer + b.configKey()
+     * + " rssi=(" + b.visibility.rssi24
+     * + "," + b.visibility.rssi5
+     * + ") num=(" + b.visibility.num24
+     * + "," + b.visibility.num5 + ")"
+     * + " sc=" + scoreB
+     * + " -> " + Integer.toString(scoreB - scoreA));
+     * }
+     * <p/>
+     * // If scoreA > scoreB, the comparison is descending hence the return value is negative
+     * return scoreB - scoreA;
+     * }
      */
 
+    int getSecurityScore(WifiConfiguration config) {
+
+        if (TextUtils.isEmpty(config.SSID) == false) {
+            if (config.allowedKeyManagement.get(KeyMgmt.WPA_EAP)
+                    || config.allowedKeyManagement.get(KeyMgmt.WPA_PSK)
+                    || config.allowedKeyManagement.get(KeyMgmt.WPA2_PSK)) {
+                /* enterprise or PSK networks get highest score */
+                return 100;
+            } else if (config.allowedKeyManagement.get(KeyMgmt.NONE)) {
+                /* open networks have lowest score */
+                return 33;
+            }
+        } else if (TextUtils.isEmpty(config.FQDN) == false) {
+            /* passpoint networks have medium preference */
+            return 66;
+        }
+
+        /* bad network */
+        return 0;
+    }
+
     int compareWifiConfigurations(WifiConfiguration a, WifiConfiguration b) {
         int order = 0;
         boolean linked = false;
@@ -845,7 +866,7 @@
         if (!linked) {
             int choice;
 
-            choice = getConnectChoice(a, b);
+            choice = getConnectChoice(a, b, false);
             if (choice > 0) {
                 // a is of higher priority - descending
                 order = order - choice;
@@ -861,7 +882,7 @@
                 }
             }
 
-            choice = getConnectChoice(b, a);
+            choice = getConnectChoice(b, a, false);
             if (choice > 0) {
                 // a is of lower priority - ascending
                 order = order + choice;
@@ -948,13 +969,13 @@
             return 0;
         }
         if (rssi
-                > mWifiConfigStore.bandPreferenceBoostThreshold5) {
+                > mWifiConfigStore.bandPreferenceBoostThreshold5.get()) {
             // Boost by 2 dB for each point
             //    Start boosting at -65
             //    Boost by 20 if above -55
             //    Boost by 40 if abore -45
             int boost = mWifiConfigStore.bandPreferenceBoostFactor5
-                    *(rssi - mWifiConfigStore.bandPreferenceBoostThreshold5);
+                    * (rssi - mWifiConfigStore.bandPreferenceBoostThreshold5.get());
             if (boost > 50) {
                 // 50 dB boost allows jumping from 2.4 to 5GHz
                 // consistently
@@ -967,38 +988,43 @@
         }
 
         if (rssi
-                < mWifiConfigStore.bandPreferencePenaltyThreshold5) {
+                < mWifiConfigStore.bandPreferencePenaltyThreshold5.get()) {
             // penalize if < -75
             int boost = mWifiConfigStore.bandPreferencePenaltyFactor5
-                    *(rssi - mWifiConfigStore.bandPreferencePenaltyThreshold5);
+                    * (rssi - mWifiConfigStore.bandPreferencePenaltyThreshold5.get());
             return boost;
         }
         return 0;
     }
-        /**
-         * attemptRoam() function implements the core of the same SSID switching algorithm
-         *
-         * Run thru all recent scan result of a WifiConfiguration and select the
-         * best one.
-         */
+
+    /**
+     * attemptRoam() function implements the core of the same SSID switching algorithm
+     * <p/>
+     * Run thru all recent scan result of a WifiConfiguration and select the
+     * best one.
+     */
     public ScanResult attemptRoam(ScanResult a,
                                   WifiConfiguration current, int age, String currentBSSID) {
         if (current == null) {
-            if (VDBG)   {
+            if (VDBG) {
                 logDbg("attemptRoam not associated");
             }
             return a;
         }
-        if (current.scanResultCache == null) {
-            if (VDBG)   {
+
+        ScanDetailCache scanDetailCache =
+                mWifiConfigStore.getScanDetailCache(current);
+
+        if (scanDetailCache == null) {
+            if (VDBG) {
                 logDbg("attemptRoam no scan cache");
             }
             return a;
         }
-        if (current.scanResultCache.size() > 6) {
-            if (VDBG)   {
+        if (scanDetailCache.size() > 6) {
+            if (VDBG) {
                 logDbg("attemptRoam scan cache size "
-                        + current.scanResultCache.size() + " --> bail");
+                        + scanDetailCache.size() + " --> bail");
             }
             // Implement same SSID roaming only for configurations
             // that have less than 4 BSSIDs
@@ -1006,7 +1032,7 @@
         }
 
         if (current.BSSID != null && !current.BSSID.equals("any")) {
-            if (DBG)   {
+            if (DBG) {
                 logDbg("attemptRoam() BSSID is set "
                         + current.BSSID + " -> bail");
             }
@@ -1017,13 +1043,14 @@
         // relative strength of 5 and 2.4 GHz BSSIDs
         long nowMs = System.currentTimeMillis();
 
-        for (ScanResult b : current.scanResultCache.values()) {
+        for (ScanDetail sd : scanDetailCache.values()) {
+            ScanResult b = sd.getScanResult();
             int bRssiBoost5 = 0;
             int aRssiBoost5 = 0;
             int bRssiBoost = 0;
             int aRssiBoost = 0;
-            if ((b.seen == 0) || (b.BSSID == null)
-                    || ((nowMs - b.seen) > age)
+            if ((sd.getSeen() == 0) || (b.BSSID == null)
+                    || ((nowMs - sd.getSeen()) > age)
                     || b.autoJoinStatus != ScanResult.ENABLED
                     || b.numIpConfigFailures > 8) {
                 continue;
@@ -1038,10 +1065,10 @@
             if (b.numIpConfigFailures < (a.numIpConfigFailures - 1)) {
                 // Prefer a BSSID that doesn't have less number of Ip config failures
                 logDbg("attemptRoam: "
-                        + b.BSSID + " rssi=" + b.level + " ipfail=" +b.numIpConfigFailures
+                        + b.BSSID + " rssi=" + b.level + " ipfail=" + b.numIpConfigFailures
                         + " freq=" + b.frequency
                         + " > "
-                        + a.BSSID + " rssi=" + a.level + " ipfail=" +a.numIpConfigFailures
+                        + a.BSSID + " rssi=" + a.level + " ipfail=" + a.numIpConfigFailures
                         + " freq=" + a.frequency);
                 a = b;
                 continue;
@@ -1050,14 +1077,14 @@
             // Apply hysteresis: we favor the currentBSSID by giving it a boost
             if (currentBSSID != null && currentBSSID.equals(b.BSSID)) {
                 // Reduce the benefit of hysteresis if RSSI <= -75
-                if (b.level <= mWifiConfigStore.bandPreferencePenaltyThreshold5) {
+                if (b.level <= mWifiConfigStore.bandPreferencePenaltyThreshold5.get()) {
                     bRssiBoost = mWifiConfigStore.associatedHysteresisLow;
                 } else {
                     bRssiBoost = mWifiConfigStore.associatedHysteresisHigh;
                 }
             }
             if (currentBSSID != null && currentBSSID.equals(a.BSSID)) {
-                if (a.level <= mWifiConfigStore.bandPreferencePenaltyThreshold5) {
+                if (a.level <= mWifiConfigStore.bandPreferencePenaltyThreshold5.get()) {
                     // Reduce the benefit of hysteresis if RSSI <= -75
                     aRssiBoost = mWifiConfigStore.associatedHysteresisLow;
                 } else {
@@ -1082,9 +1109,9 @@
                 aRssiBoost5 = rssiBoostFrom5GHzRssi(a.level + aRssiBoost, a.BSSID);
             }
 
-            if (VDBG)  {
+            if (VDBG) {
                 String comp = " < ";
-                if (b.level + bRssiBoost + bRssiBoost5 > a.level +aRssiBoost + aRssiBoost5) {
+                if (b.level + bRssiBoost + bRssiBoost5 > a.level + aRssiBoost + aRssiBoost5) {
                     comp = " > ";
                 }
                 logDbg("attemptRoam: "
@@ -1097,13 +1124,13 @@
 
             // Compare the RSSIs after applying the hysteresis boost and the 5GHz
             // boost if applicable
-            if (b.level + bRssiBoost + bRssiBoost5 > a.level +aRssiBoost + aRssiBoost5) {
+            if (b.level + bRssiBoost + bRssiBoost5 > a.level + aRssiBoost + aRssiBoost5) {
                 // b is the better BSSID
                 a = b;
             }
         }
         if (a != null) {
-            if (VDBG)  {
+            if (VDBG) {
                 StringBuilder sb = new StringBuilder();
                 sb.append("attemptRoam: " + current.configKey() +
                         " Found " + a.BSSID + " rssi=" + a.level + " freq=" + a.frequency);
@@ -1119,9 +1146,9 @@
 
     /**
      * getNetworkScore()
-     *
+     * <p/>
      * if scorer is present, get the network score of a WifiConfiguration
-     *
+     * <p/>
      * Note: this should be merge with setVisibility
      *
      * @param config
@@ -1136,7 +1163,8 @@
             }
             return WifiNetworkScoreCache.INVALID_NETWORK_SCORE;
         }
-        if (config.scanResultCache == null) {
+
+        if (mWifiConfigStore.getScanDetailCache(config) == null) {
             if (VDBG) {
                 logDbg("       getConfigNetworkScore for " + config.configKey()
                         + " -> no scan cache");
@@ -1150,8 +1178,9 @@
         int startScore = -10000;
 
         // Run thru all cached scan results
-        for (ScanResult result : config.scanResultCache.values()) {
-            if ((nowMs - result.seen) < age) {
+        for (ScanDetail sd : mWifiConfigStore.getScanDetailCache(config).values()) {
+            ScanResult result = sd.getScanResult();
+            if ((nowMs - sd.getSeen()) < age) {
                 int sc = mNetworkScoreCache.getNetworkScore(result, isActive);
                 if (sc > startScore) {
                     startScore = sc;
@@ -1204,8 +1233,9 @@
         // Otherwise, we stop here if the currently selected network has a score. If it doesn't, we
         // keep going - it could be that another BSSID is in range (has been seen recently) which
         // has a score, even if the one we're immediately connected to doesn't.
-        ScanResult currentScanResult =  mWifiStateMachine.getCurrentScanResult();
-        boolean currentNetworkHasScoreCurve = mNetworkScoreCache.hasScoreCurve(currentScanResult);
+        ScanResult currentScanResult = mWifiStateMachine.getCurrentScanResult();
+        boolean currentNetworkHasScoreCurve = currentScanResult != null
+                && mNetworkScoreCache.hasScoreCurve(currentScanResult);
         if (ephemeralOutOfRangeTimeoutMs <= 0 || currentNetworkHasScoreCurve) {
             if (DBG) {
                 if (currentNetworkHasScoreCurve) {
@@ -1218,14 +1248,16 @@
             return currentNetworkHasScoreCurve;
         }
 
-        if (config.scanResultCache == null || config.scanResultCache.isEmpty()) {
+        if (mWifiConfigStore.getScanDetailCache(config) == null
+                || mWifiConfigStore.getScanDetailCache(config).isEmpty()) {
             return false;
         }
 
         long currentTimeMs = System.currentTimeMillis();
-        for (ScanResult result : config.scanResultCache.values()) {
-            if (currentTimeMs > result.seen
-                    && currentTimeMs - result.seen < ephemeralOutOfRangeTimeoutMs
+        for (ScanDetail sd : mWifiConfigStore.getScanDetailCache(config).values()) {
+            ScanResult result = sd.getScanResult();
+            if (currentTimeMs > sd.getSeen()
+                    && currentTimeMs - sd.getSeen() < ephemeralOutOfRangeTimeoutMs
                     && mNetworkScoreCache.hasScoreCurve(result)) {
                 if (DBG) {
                     logDbg("Found scored BSSID, keeping network: " + result.BSSID);
@@ -1240,6 +1272,163 @@
         return false;
     }
 
+    // After WifiStateMachine ask the supplicant to associate or reconnect
+    // we might still obtain scan results from supplicant
+    // however the supplicant state in the mWifiInfo and supplicant state tracker
+    // are updated when we get the supplicant state change message which can be
+    // processed after the SCAN_RESULT message, so at this point the framework doesn't
+    // know that supplicant is ASSOCIATING.
+    // A good fix for this race condition would be for the WifiStateMachine to add
+    // a new transient state where it expects to get the supplicant message indicating
+    // that it started the association process and within which critical operations
+    // like autojoin should be deleted.
+
+    // This transient state would remove the need for the roam Wathchdog which
+    // basically does that.
+
+    // At the moment, we just query the supplicant state synchronously with the
+    // mWifiNative.status() command, which allow us to know that
+    // supplicant has started association process, even though we didnt yet get the
+    // SUPPLICANT_STATE_CHANGE message.
+
+    private static final List<String> ASSOC_STATES = Arrays.asList(
+            "ASSOCIATING",
+            "ASSOCIATED",
+            "FOUR_WAY_HANDSHAKE",
+            "GROUP_KEY_HANDSHAKE");
+
+    private int getNetID(String wpaStatus) {
+        if (VDBG) {
+            logDbg("attemptAutoJoin() status=" + wpaStatus);
+        }
+
+        try {
+            int id = WifiConfiguration.INVALID_NETWORK_ID;
+            String state = null;
+            BufferedReader br = new BufferedReader(new StringReader(wpaStatus));
+            String line;
+            while ((line = br.readLine()) != null) {
+                int split = line.indexOf('=');
+                if (split < 0) {
+                    continue;
+                }
+
+                String name = line.substring(0, split);
+                if (name.equals("id")) {
+                    try {
+                        id = Integer.parseInt(line.substring(split + 1));
+                        if (state != null) {
+                            break;
+                        }
+                    } catch (NumberFormatException nfe) {
+                        return WifiConfiguration.INVALID_NETWORK_ID;
+                    }
+                } else if (name.equals("wpa_state")) {
+                    state = line.substring(split + 1);
+                    if (ASSOC_STATES.contains(state)) {
+                        return WifiConfiguration.INVALID_NETWORK_ID;
+                    } else if (id >= 0) {
+                        break;
+                    }
+                }
+            }
+            return id;
+        } catch (IOException ioe) {
+            return WifiConfiguration.INVALID_NETWORK_ID;    // Won't happen
+        }
+    }
+
+    private boolean setCurrentConfigurationKey(WifiConfiguration currentConfig,
+                                               int supplicantNetId) {
+        if (currentConfig != null) {
+            if (supplicantNetId != currentConfig.networkId
+                    // https://b.corp.google.com/issue?id=16484607
+                    // mark this condition as an error only if the mismatched networkId are valid
+                    && supplicantNetId != WifiConfiguration.INVALID_NETWORK_ID
+                    && currentConfig.networkId != WifiConfiguration.INVALID_NETWORK_ID) {
+                logDbg("attemptAutoJoin() ERROR wpa_supplicant out of sync nid="
+                        + Integer.toString(supplicantNetId) + " WifiStateMachine="
+                        + Integer.toString(currentConfig.networkId));
+                mWifiStateMachine.disconnectCommand();
+                return false;
+            } else if (currentConfig.ephemeral && (!mAllowUntrustedConnections ||
+                    !haveRecentlySeenScoredBssid(currentConfig))) {
+                // The current connection is untrusted (the framework added it), but we're either
+                // no longer allowed to connect to such networks, the score has been nullified
+                // since we connected, or the scored BSSID has gone out of range.
+                // Drop the current connection and perform the rest of autojoin.
+                logDbg("attemptAutoJoin() disconnecting from unwanted ephemeral network");
+                mWifiStateMachine.disconnectCommand(Process.WIFI_UID,
+                        mAllowUntrustedConnections ? 1 : 0);
+                return false;
+            } else {
+                mCurrentConfigurationKey = currentConfig.configKey();
+                return true;
+            }
+        } else {
+            // If not invalid, then maybe in the process of associating, skip this attempt
+            return supplicantNetId == WifiConfiguration.INVALID_NETWORK_ID;
+        }
+    }
+
+    private void updateBlackListStatus(WifiConfiguration config, long now) {
+        // Wait for 5 minutes before reenabling config that have known,
+        // repeated connection or DHCP failures
+        if (config.disableReason == WifiConfiguration.DISABLED_DHCP_FAILURE
+                || config.disableReason
+                == WifiConfiguration.DISABLED_ASSOCIATION_REJECT
+                || config.disableReason
+                == WifiConfiguration.DISABLED_AUTH_FAILURE) {
+            if (config.blackListTimestamp == 0
+                    || (config.blackListTimestamp > now)) {
+                // Sanitize the timestamp
+                config.blackListTimestamp = now;
+            }
+            if ((now - config.blackListTimestamp) >
+                    mWifiConfigStore.wifiConfigBlacklistMinTimeMilli) {
+                // Re-enable the WifiConfiguration
+                config.status = WifiConfiguration.Status.ENABLED;
+
+                // Reset the blacklist condition
+                config.numConnectionFailures = 0;
+                config.numIpConfigFailures = 0;
+                config.numAuthFailures = 0;
+                config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED);
+
+                config.dirty = true;
+            } else {
+                if (VDBG) {
+                    long delay = mWifiConfigStore.wifiConfigBlacklistMinTimeMilli
+                            - (now - config.blackListTimestamp);
+                    logDbg("attemptautoJoin " + config.configKey()
+                            + " dont unblacklist yet, waiting for "
+                            + delay + " ms");
+                }
+            }
+        }
+        // Avoid networks disabled because of AUTH failure altogether
+        if (DBG) {
+            logDbg("attemptAutoJoin skip candidate due to auto join status "
+                    + Integer.toString(config.autoJoinStatus) + " key "
+                    + config.configKey(true)
+                    + " reason " + config.disableReason);
+        }
+    }
+
+    boolean underSoftThreshold(WifiConfiguration config) {
+        return config.visibility.rssi24 < mWifiConfigStore.thresholdUnblacklistThreshold24Soft.get()
+                && config.visibility.rssi5 < mWifiConfigStore.thresholdUnblacklistThreshold5Soft.get();
+    }
+
+    boolean underHardThreshold(WifiConfiguration config) {
+        return config.visibility.rssi24 < mWifiConfigStore.thresholdUnblacklistThreshold24Hard.get()
+                && config.visibility.rssi5 < mWifiConfigStore.thresholdUnblacklistThreshold5Hard.get();
+    }
+
+    boolean underThreshold(WifiConfiguration config, int rssi24, int rssi5) {
+        return config.visibility.rssi24 < rssi24 && config.visibility.rssi5 < rssi5;
+    }
+
     /**
      * attemptAutoJoin() function implements the core of the a network switching algorithm
      * Return false if no acceptable networks were found.
@@ -1249,79 +1438,32 @@
         didOverride = false;
         didBailDueToWeakRssi = false;
         int networkSwitchType = AUTO_JOIN_IDLE;
+        int age = mScanResultAutoJoinAge;
 
         long now = System.currentTimeMillis();
 
         String lastSelectedConfiguration = mWifiConfigStore.getLastSelectedConfiguration();
-
+        if (lastSelectedConfiguration != null) {
+            age = 14000;
+        }
         // Reset the currentConfiguration Key, and set it only if WifiStateMachine and
         // supplicant agree
         mCurrentConfigurationKey = null;
         WifiConfiguration currentConfiguration = mWifiStateMachine.getCurrentWifiConfiguration();
 
         WifiConfiguration candidate = null;
-
         // Obtain the subset of recently seen networks
         List<WifiConfiguration> list =
-                mWifiConfigStore.getRecentConfiguredNetworks(mScanResultAutoJoinAge, false);
+                mWifiConfigStore.getRecentConfiguredNetworks(age, false);
         if (list == null) {
-            if (VDBG)  logDbg("attemptAutoJoin nothing known=" +
-                    mWifiConfigStore.getconfiguredNetworkSize());
+            if (VDBG) logDbg("attemptAutoJoin nothing known=" +
+                    mWifiConfigStore.getConfiguredNetworksSize());
             return false;
         }
 
         // Find the currently connected network: ask the supplicant directly
-        String val = mWifiNative.status(true);
-        String status[] = val.split("\\r?\\n");
-        if (VDBG) {
-            logDbg("attemptAutoJoin() status=" + val + " split="
-                    + Integer.toString(status.length));
-        }
+        int supplicantNetId = getNetID(mWifiNative.status(true));
 
-        int supplicantNetId = -1;
-        for (String key : status) {
-            if (key.regionMatches(0, "id=", 0, 3)) {
-                int idx = 3;
-                supplicantNetId = 0;
-                while (idx < key.length()) {
-                    char c = key.charAt(idx);
-
-                    if ((c >= 0x30) && (c <= 0x39)) {
-                        supplicantNetId *= 10;
-                        supplicantNetId += c - 0x30;
-                        idx++;
-                    } else {
-                        break;
-                    }
-                }
-            } else if (key.contains("wpa_state=ASSOCIATING")
-                    || key.contains("wpa_state=ASSOCIATED")
-                    || key.contains("wpa_state=FOUR_WAY_HANDSHAKE")
-                    || key.contains("wpa_state=GROUP_KEY_HANDSHAKE")) {
-                if (DBG) {
-                    logDbg("attemptAutoJoin: bail out due to sup state " + key);
-                }
-                // After WifiStateMachine ask the supplicant to associate or reconnect
-                // we might still obtain scan results from supplicant
-                // however the supplicant state in the mWifiInfo and supplicant state tracker
-                // are updated when we get the supplicant state change message which can be
-                // processed after the SCAN_RESULT message, so at this point the framework doesn't
-                // know that supplicant is ASSOCIATING.
-                // A good fix for this race condition would be for the WifiStateMachine to add
-                // a new transient state where it expects to get the supplicant message indicating
-                // that it started the association process and within which critical operations
-                // like autojoin should be deleted.
-
-                // This transient state would remove the need for the roam Wathchdog which
-                // basically does that.
-
-                // At the moment, we just query the supplicant state synchronously with the
-                // mWifiNative.status() command, which allow us to know that
-                // supplicant has started association process, even though we didnt yet get the
-                // SUPPLICANT_STATE_CHANGE message.
-                return false;
-            }
-        }
         if (DBG) {
             String conf = "";
             String last = "";
@@ -1336,35 +1478,8 @@
                     + " ---> suppNetId=" + Integer.toString(supplicantNetId));
         }
 
-        if (currentConfiguration != null) {
-            if (supplicantNetId != currentConfiguration.networkId
-                    // https://b.corp.google.com/issue?id=16484607
-                    // mark this condition as an error only if the mismatched networkId are valid
-                    && supplicantNetId != WifiConfiguration.INVALID_NETWORK_ID
-                    && currentConfiguration.networkId != WifiConfiguration.INVALID_NETWORK_ID) {
-                logDbg("attemptAutoJoin() ERROR wpa_supplicant out of sync nid="
-                        + Integer.toString(supplicantNetId) + " WifiStateMachine="
-                        + Integer.toString(currentConfiguration.networkId));
-                mWifiStateMachine.disconnectCommand();
-                return false;
-            } else if (currentConfiguration.ephemeral && (!mAllowUntrustedConnections ||
-                    !haveRecentlySeenScoredBssid(currentConfiguration))) {
-                // The current connection is untrusted (the framework added it), but we're either
-                // no longer allowed to connect to such networks, the score has been nullified
-                // since we connected, or the scored BSSID has gone out of range.
-                // Drop the current connection and perform the rest of autojoin.
-                logDbg("attemptAutoJoin() disconnecting from unwanted ephemeral network");
-                mWifiStateMachine.disconnectCommand(Process.WIFI_UID,
-                        mAllowUntrustedConnections ? 1 : 0);
-                return false;
-            } else {
-                mCurrentConfigurationKey = currentConfiguration.configKey();
-            }
-        } else {
-            if (supplicantNetId != WifiConfiguration.INVALID_NETWORK_ID) {
-                // Maybe in the process of associating, skip this attempt
-                return false;
-            }
+        if (!setCurrentConfigurationKey(currentConfiguration, supplicantNetId)) {
+            return false;
         }
 
         int currentNetId = -1;
@@ -1384,48 +1499,17 @@
                 continue;
             }
 
-            if (config.autoJoinStatus >=
-                    WifiConfiguration.AUTO_JOIN_DISABLED_ON_AUTH_FAILURE) {
-                // Wait for 5 minutes before reenabling config that have known,
-                // repeated connection or DHCP failures
-                if (config.disableReason == WifiConfiguration.DISABLED_DHCP_FAILURE
-                        || config.disableReason
-                        == WifiConfiguration.DISABLED_ASSOCIATION_REJECT
-                        || config.disableReason
-                        == WifiConfiguration.DISABLED_AUTH_FAILURE) {
-                    if (config.blackListTimestamp == 0
-                            || (config.blackListTimestamp > now)) {
-                        // Sanitize the timestamp
-                        config.blackListTimestamp = now;
-                    }
-                    if ((now - config.blackListTimestamp) >
-                            mWifiConfigStore.wifiConfigBlacklistMinTimeMilli) {
-                        // Re-enable the WifiConfiguration
-                        config.status = WifiConfiguration.Status.ENABLED;
+            if (config.autoJoinStatus >= WifiConfiguration.AUTO_JOIN_DISABLED_ON_AUTH_FAILURE) {
+                updateBlackListStatus(config, now);
+                continue;
+            }
 
-                        // Reset the blacklist condition
-                        config.numConnectionFailures = 0;
-                        config.numIpConfigFailures = 0;
-                        config.numAuthFailures = 0;
-                        config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED);
-
-                        config.dirty = true;
-                    } else {
-                        if (VDBG) {
-                            long delay = mWifiConfigStore.wifiConfigBlacklistMinTimeMilli
-                                    - (now - config.blackListTimestamp);
-                            logDbg("attemptautoJoin " + config.configKey()
-                                    + " dont unblacklist yet, waiting for "
-                                    + delay + " ms");
-                        }
-                    }
-                }
-                // Avoid networks disabled because of AUTH failure altogether
+            if (config.userApproved == WifiConfiguration.USER_PENDING ||
+                    config.userApproved == WifiConfiguration.USER_BANNED) {
                 if (DBG) {
-                    logDbg("attemptAutoJoin skip candidate due to auto join status "
-                            + Integer.toString(config.autoJoinStatus) + " key "
-                            + config.configKey(true)
-                            + " reason " + config.disableReason);
+                    logDbg("attemptAutoJoin skip candidate due to user approval status "
+                            + WifiConfiguration.userApprovedAsString(config.userApproved) + " key "
+                            + config.configKey(true));
                 }
                 continue;
             }
@@ -1450,42 +1534,29 @@
                 }
             }
 
+            if (config.visibility == null) {
+                continue;
+            }
+
             // Try to unblacklist based on good visibility
-            if (config.visibility.rssi5 < mWifiConfigStore.thresholdUnblacklistThreshold5Soft
-                    && config.visibility.rssi24
-                    < mWifiConfigStore.thresholdUnblacklistThreshold24Soft) {
+            if (underSoftThreshold(config)) {
                 if (DBG) {
-                    logDbg("attemptAutoJoin do not unblacklist due to low visibility "
-                            + config.autoJoinStatus
-                            + " key " + config.configKey(true)
-                            + " rssi=(" + config.visibility.rssi24
-                            + "," + config.visibility.rssi5
-                            + ") num=(" + config.visibility.num24
-                            + "," + config.visibility.num5 + ")");
+                    logDbg("attemptAutoJoin do not unblacklist due to low visibility " +
+                            config.configKey() + " status=" + config.autoJoinStatus);
                 }
-            } else if (config.visibility.rssi5 < mWifiConfigStore.thresholdUnblacklistThreshold5Hard
-                    && config.visibility.rssi24
-                    < mWifiConfigStore.thresholdUnblacklistThreshold24Hard) {
+            } else if (underHardThreshold(config)) {
                 // If the network is simply temporary disabled, don't allow reconnect until
                 // RSSI becomes good enough
                 config.setAutoJoinStatus(config.autoJoinStatus - 1);
                 if (DBG) {
-                    logDbg("attemptAutoJoin good candidate seen, bumped soft -> status="
-                            + config.autoJoinStatus
-                            + " " + config.configKey(true) + " rssi=("
-                            + config.visibility.rssi24 + "," + config.visibility.rssi5
-                            + ") num=(" + config.visibility.num24
-                            + "," + config.visibility.num5 + ")");
+                    logDbg("attemptAutoJoin good candidate seen, bumped soft -> status=" +
+                            config.configKey() + " status=" + config.autoJoinStatus);
                 }
             } else {
                 config.setAutoJoinStatus(config.autoJoinStatus - 3);
                 if (DBG) {
-                    logDbg("attemptAutoJoin good candidate seen, bumped hard -> status="
-                            + config.autoJoinStatus
-                            + " " + config.configKey(true) + " rssi=("
-                            + config.visibility.rssi24 + "," + config.visibility.rssi5
-                            + ") num=(" + config.visibility.num24
-                            + "," + config.visibility.num5 + ")");
+                    logDbg("attemptAutoJoin good candidate seen, bumped hard -> status=" +
+                            config.configKey() + " status=" + config.autoJoinStatus);
                 }
             }
 
@@ -1493,12 +1564,8 @@
                     WifiConfiguration.AUTO_JOIN_TEMPORARY_DISABLED) {
                 // Network is blacklisted, skip
                 if (DBG) {
-                    logDbg("attemptAutoJoin skip blacklisted -> status="
-                            + config.autoJoinStatus
-                            + " " + config.configKey(true) + " rssi=("
-                            + config.visibility.rssi24 + "," + config.visibility.rssi5
-                            + ") num=(" + config.visibility.num24
-                            + "," + config.visibility.num5 + ")");
+                    logDbg("attemptAutoJoin skip blacklisted -> status=" +
+                            config.configKey() + " status=" + config.autoJoinStatus);
                 }
                 continue;
             }
@@ -1517,10 +1584,6 @@
                 isLastSelected = true;
             }
 
-            if (config.visibility == null) {
-                continue;
-            }
-
             if (config.lastRoamingFailure != 0
                     && currentConfiguration != null
                     && (lastSelectedConfiguration == null
@@ -1544,17 +1607,12 @@
             }
 
             int boost = config.autoJoinUseAggressiveJoinAttemptThreshold + weakRssiBailCount;
-            if ((config.visibility.rssi5 + boost)
-                        < mWifiConfigStore.thresholdInitialAutoJoinAttemptMin5RSSI
-                        && (config.visibility.rssi24 + boost)
-                        < mWifiConfigStore.thresholdInitialAutoJoinAttemptMin24RSSI) {
+            if (underThreshold(config,
+                    mWifiConfigStore.thresholdInitialAutoJoinAttemptMin24RSSI.get() - boost,
+                    mWifiConfigStore.thresholdInitialAutoJoinAttemptMin5RSSI.get() - boost)) {
+
                 if (DBG) {
-                    logDbg("attemptAutoJoin skip due to low visibility -> status="
-                            + config.autoJoinStatus
-                            + " key " + config.configKey(true) + " rssi="
-                            + config.visibility.rssi24 + ", " + config.visibility.rssi5
-                            + " num=" + config.visibility.num24
-                            + ", " + config.visibility.num5);
+                    logDbg("attemptAutoJoin skip due to low visibility " + config.configKey());
                 }
 
                 // Don't try to autojoin a network that is too far but
@@ -1572,6 +1630,7 @@
                     }
                 }
             }
+            // NOTE: If this condition is updated, update NETWORK_STATUS_UNWANTED_DISABLE_AUTOJOIN.
             if (config.numNoInternetAccessReports > 0
                     && !isLastSelected
                     && !config.validatedInternetAccess) {
@@ -1601,11 +1660,15 @@
             if (candidate == null) {
                 candidate = config;
             } else {
-                if (VDBG)  {
+                if (VDBG) {
                     logDbg("attemptAutoJoin will compare candidate  " + candidate.configKey()
                             + " with " + config.configKey());
                 }
+
                 int order = compareWifiConfigurations(candidate, config);
+                if (VDBG) {
+                    logDbg("attemptAutoJoin compareWifiConfigurations returned " + order);
+                }
 
                 // The lastSelectedConfiguration is the configuration the user has manually selected
                 // thru WifiPicker, or that a 3rd party app asked us to connect to via the
@@ -1619,7 +1682,7 @@
                     // above RSSI/scorer based selection of linked configuration (+/- 50)
                     // by reducing order by -100
                     order = order - 100;
-                    if (VDBG)   {
+                    if (VDBG) {
                         logDbg("     ...and prefers -100 " + candidate.configKey()
                                 + " over " + config.configKey()
                                 + " because it is the last selected -> "
@@ -1632,7 +1695,7 @@
                     // above RSSI/scorer based selection of linked configuration (+/- 50)
                     // by increasing order by +100
                     order = order + 100;
-                    if (VDBG)   {
+                    if (VDBG) {
                         logDbg("     ...and prefers +100 " + config.configKey()
                                 + " over " + candidate.configKey()
                                 + " because it is the last selected -> "
@@ -1660,10 +1723,11 @@
             long nowMs = System.currentTimeMillis();
             int currentScore = -10000;
             // The untrusted network with highest score
-            ScanResult untrustedCandidate = null;
+            ScanDetail untrustedCandidate = null;
             // Look for untrusted scored network only if the current candidate is bad
             if (isBadCandidate(rssi24, rssi5)) {
-                for (ScanResult result : scanResultCache.values()) {
+                for (ScanDetail scanDetail : scanResultCache.values()) {
+                    ScanResult result = scanDetail.getScanResult();
                     // We look only at untrusted networks with a valid SSID
                     // A trusted result would have been looked at thru it's Wificonfiguration
                     if (TextUtils.isEmpty(result.SSID) || !result.untrusted ||
@@ -1686,13 +1750,13 @@
                                 && score > currentScore) {
                             // Highest score: Select this candidate
                             currentScore = score;
-                            untrustedCandidate = result;
+                            untrustedCandidate = scanDetail;
                             if (VDBG) {
                                 logDbg("AutoJoinController: found untrusted candidate "
                                         + result.SSID
-                                + " RSSI=" + result.level
-                                + " freq=" + result.frequency
-                                + " score=" + score);
+                                        + " RSSI=" + result.level
+                                        + " freq=" + result.frequency
+                                        + " score=" + score);
                             }
                         }
                     }
@@ -1705,6 +1769,7 @@
                         mWifiConfigStore.wifiConfigurationFromScanResult(untrustedCandidate);
                 candidate.allowedKeyManagement.set(KeyMgmt.NONE);
                 candidate.ephemeral = true;
+                candidate.dirty = true;
             }
         }
 
@@ -1716,7 +1781,7 @@
                 && currentConfiguration == null
                 && didBailDueToWeakRssi
                 && (mWifiConfigStore.lastUnwantedNetworkDisconnectTimestamp == 0
-                    || lastUnwanted > (1000 * 60 * 60 * 24 * 7))
+                || lastUnwanted > (1000 * 60 * 60 * 24 * 7))
                 ) {
             // We are bailing out of autojoin although we are seeing a weak configuration, and
             // - we didn't find another valid candidate
@@ -1751,7 +1816,7 @@
                     + candidate.configKey()
                     + current
                     + " linked=" + (currentConfiguration != null
-                            && currentConfiguration.isLinked(candidate))
+                    && currentConfiguration.isLinked(candidate))
                     + " : delta="
                     + Integer.toString(networkDelta) + " "
                     + doSwitch);
@@ -1762,7 +1827,7 @@
          * if user is currently streaming voice traffic,
          * then we should not be allowed to switch regardless of the delta
          */
-        if (mWifiStateMachine.shouldSwitchNetwork(networkDelta)) {
+        if (mWifiStateMachine.shouldSwitchNetwork(networkDelta)) {      // !!! JNo: Here!
             if (mStaStaSupported) {
                 logDbg("mStaStaSupported --> error do nothing now ");
             } else {
@@ -1818,39 +1883,16 @@
                     }
                 }
                 mWifiStateMachine.sendMessage(WifiStateMachine.CMD_AUTO_CONNECT,
-                            candidate.networkId, networkSwitchType, candidate);
+                        candidate.networkId, networkSwitchType, candidate);
                 found = true;
             }
         }
 
-        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;
@@ -1867,12 +1909,87 @@
                 mWifiConnectionStatistics.numAutoRoamAttempt++;
 
                 mWifiStateMachine.sendMessage(WifiStateMachine.CMD_AUTO_ROAM,
-                            currentConfiguration.networkId, 1, roamCandidate);
+                        currentConfiguration.networkId, 1, roamCandidate);
                 found = true;
             }
         }
         if (VDBG) logDbg("Done attemptAutoJoin status=" + Integer.toString(networkSwitchType));
         return found;
     }
+
+    private void logDenial(String reason, WifiConfiguration config) {
+        if (!DBG) {
+            return;
+        }
+        logDbg(reason + config.toString());
+    }
+
+    WifiConfiguration getWifiConfiguration(WifiNative.WifiPnoNetwork network) {
+        if (network.configKey != null) {
+            return mWifiConfigStore.getWifiConfiguration(network.configKey);
+        }
+        return null;
+    }
+
+    ArrayList<WifiNative.WifiPnoNetwork> getPnoList(WifiConfiguration current) {
+        int size = -1;
+        ArrayList<WifiNative.WifiPnoNetwork> list = new ArrayList<WifiNative.WifiPnoNetwork>();
+
+        if (mWifiConfigStore.mCachedPnoList != null) {
+            size = mWifiConfigStore.mCachedPnoList.size();
+        }
+
+        if (DBG) {
+            String s = "";
+            if (current != null) {
+                s = " for: " + current.configKey();
+            }
+            Log.e(TAG, " get Pno List total size:" + size + s);
+        }
+        if (current != null) {
+            String configKey = current.configKey();
+            /**
+             * If we are currently associated to a WifiConfiguration then include
+             * only those networks that have a higher priority
+             */
+            for (WifiNative.WifiPnoNetwork network : mWifiConfigStore.mCachedPnoList) {
+                WifiConfiguration config = getWifiConfiguration(network);
+                if (config == null) {
+                    continue;
+                }
+                if (config.autoJoinStatus
+                        >= WifiConfiguration.AUTO_JOIN_DISABLED_NO_CREDENTIALS) {
+                     continue;
+                }
+
+                if (!configKey.equals(network.configKey)) {
+                    int choice = getConnectChoice(config, current, true);
+                    if (choice > 0) {
+                        // config is of higher priority
+                        if (DBG) {
+                            Log.e(TAG, " Pno List adding:" + network.configKey
+                                    + " choice " + choice);
+                        }
+                        list.add(network);
+                        network.rssi_threshold = mWifiConfigStore.thresholdGoodRssi24.get();
+                    }
+                }
+            }
+        } else {
+            for (WifiNative.WifiPnoNetwork network : mWifiConfigStore.mCachedPnoList) {
+                WifiConfiguration config = getWifiConfiguration(network);
+                if (config == null) {
+                    continue;
+                }
+                if (config.autoJoinStatus
+                        >= WifiConfiguration.AUTO_JOIN_DISABLED_NO_CREDENTIALS) {
+                    continue;
+                }
+                list.add(network);
+                network.rssi_threshold = mWifiConfigStore.thresholdGoodRssi24.get();
+            }
+        }
+        return list;
+    }
 }
 
diff --git a/service/java/com/android/server/wifi/WifiConfigStore.java b/service/java/com/android/server/wifi/WifiConfigStore.java
index 94752d3..dd47b08 100644
--- a/service/java/com/android/server/wifi/WifiConfigStore.java
+++ b/service/java/com/android/server/wifi/WifiConfigStore.java
@@ -16,32 +16,34 @@
 
 package com.android.server.wifi;
 
+import android.app.AppGlobals;
+import android.app.admin.DeviceAdminInfo;
+import android.app.admin.DevicePolicyManagerInternal;
+import android.content.ContentResolver;
 import android.content.Context;
 import android.content.Intent;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
 import android.net.IpConfiguration;
 import android.net.IpConfiguration.IpAssignment;
 import android.net.IpConfiguration.ProxySettings;
-import android.net.LinkAddress;
 import android.net.NetworkInfo.DetailedState;
 import android.net.ProxyInfo;
-import android.net.RouteInfo;
 import android.net.StaticIpConfiguration;
+import android.net.wifi.ScanResult;
 import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiConfiguration.KeyMgmt;
 import android.net.wifi.WifiConfiguration.Status;
-import static android.net.wifi.WifiConfiguration.INVALID_NETWORK_ID;
-
 import android.net.wifi.WifiEnterpriseConfig;
+import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiManager;
 import android.net.wifi.WifiSsid;
 import android.net.wifi.WpsInfo;
 import android.net.wifi.WpsResult;
-import android.net.wifi.ScanResult;
-import android.net.wifi.WifiInfo;
-
 import android.os.Environment;
 import android.os.FileObserver;
 import android.os.Process;
+import android.os.RemoteException;
 import android.os.SystemClock;
 import android.os.UserHandle;
 import android.provider.Settings;
@@ -53,12 +55,24 @@
 import android.util.Log;
 import android.util.SparseArray;
 
+import com.android.server.LocalServices;
+import com.android.internal.R;
 import com.android.server.net.DelayedDiskWrite;
 import com.android.server.net.IpConfigStore;
-import com.android.internal.R;
+import com.android.server.wifi.anqp.ANQPElement;
+import com.android.server.wifi.anqp.Constants;
+import com.android.server.wifi.hotspot2.ANQPData;
+import com.android.server.wifi.hotspot2.AnqpCache;
+import com.android.server.wifi.hotspot2.NetworkDetail;
+import com.android.server.wifi.hotspot2.PasspointMatch;
+import com.android.server.wifi.hotspot2.SupplicantBridge;
+import com.android.server.wifi.hotspot2.Utils;
+import com.android.server.wifi.hotspot2.omadm.MOManager;
+import com.android.server.wifi.hotspot2.pps.Credential;
+import com.android.server.wifi.hotspot2.pps.HomeSP;
 
-import java.io.BufferedReader;
 import java.io.BufferedInputStream;
+import java.io.BufferedReader;
 import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.io.EOFException;
@@ -69,19 +83,31 @@
 import java.io.FileReader;
 import java.io.IOException;
 import java.io.PrintWriter;
-import java.math.BigInteger;
-import java.net.InetAddress;
-import java.nio.charset.Charset;
+import java.nio.charset.StandardCharsets;
 import java.security.PrivateKey;
 import java.security.cert.Certificate;
 import java.security.cert.CertificateException;
-import java.text.SimpleDateFormat;
-import java.text.DateFormat;
+import java.util.ArrayList;
+import java.util.BitSet;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import java.util.*;
-import java.util.zip.Checksum;
 import java.util.zip.CRC32;
+import java.util.zip.Checksum;
+
+import static android.net.wifi.WifiConfiguration.INVALID_NETWORK_ID;
+
 
 /**
  * This class provides the API to manage configured
@@ -131,16 +157,17 @@
 public class WifiConfigStore extends IpConfigStore {
 
     private Context mContext;
-    private static final String TAG = "WifiConfigStore";
+    public static final String TAG = "WifiConfigStore";
     private static final boolean DBG = true;
     private static boolean VDBG = false;
     private static boolean VVDBG = false;
 
     private static final String SUPPLICANT_CONFIG_FILE = "/data/misc/wifi/wpa_supplicant.conf";
+    private static final String SUPPLICANT_CONFIG_FILE_BACKUP = SUPPLICANT_CONFIG_FILE + ".tmp";
+    private static final String PPS_FILE = "/data/misc/wifi/PerProviderSubscription.conf";
 
     /* configured networks with network id as the key */
-    private HashMap<Integer, WifiConfiguration> mConfiguredNetworks =
-            new HashMap<Integer, WifiConfiguration>();
+    private final ConfigurationMap mConfiguredNetworks = new ConfigurationMap();
 
     /* A network id is a unique identifier for a network configured in the
      * supplicant. Network ids are generated when the supplicant reads
@@ -149,8 +176,9 @@
      * that is generated from SSID and security type of the network. A mapping
      * from the generated unique id to network id of the network is needed to
      * map supplicant config to IP configuration. */
-    private HashMap<Integer, Integer> mNetworkIds =
-            new HashMap<Integer, Integer>();
+
+    /* Stores a map of NetworkId to ScanCache */
+    private HashMap<Integer, ScanDetailCache> mScanDetailCaches;
 
     /**
      * Framework keeps a list of (the CRC32 hashes of) all SSIDs that where deleted by user,
@@ -180,176 +208,159 @@
             "/misc/wifi/autojoinconfig.txt";
 
     /* Network History Keys */
-    private static final String SSID_KEY = "SSID:  ";
-    private static final String CONFIG_KEY = "CONFIG:  ";
-    private static final String CHOICE_KEY = "CHOICE:  ";
-    private static final String LINK_KEY = "LINK:  ";
-    private static final String BSSID_KEY = "BSSID:  ";
-    private static final String BSSID_KEY_END = "/BSSID:  ";
-    private static final String RSSI_KEY = "RSSI:  ";
-    private static final String FREQ_KEY = "FREQ:  ";
-    private static final String DATE_KEY = "DATE:  ";
-    private static final String MILLI_KEY = "MILLI:  ";
-    private static final String BLACKLIST_MILLI_KEY = "BLACKLIST_MILLI:  ";
-    private static final String NETWORK_ID_KEY = "ID:  ";
-    private static final String PRIORITY_KEY = "PRIORITY:  ";
-    private static final String DEFAULT_GW_KEY = "DEFAULT_GW:  ";
-    private static final String AUTH_KEY = "AUTH:  ";
-    private static final String SEPARATOR_KEY = "\n";
-    private static final String STATUS_KEY = "AUTO_JOIN_STATUS:  ";
-    private static final String BSSID_STATUS_KEY = "BSSID_STATUS:  ";
-    private static final String SELF_ADDED_KEY = "SELF_ADDED:  ";
-    private static final String FAILURE_KEY = "FAILURE:  ";
-    private static final String DID_SELF_ADD_KEY = "DID_SELF_ADD:  ";
-    private static final String PEER_CONFIGURATION_KEY = "PEER_CONFIGURATION:  ";
-    private static final String CREATOR_UID_KEY = "CREATOR_UID_KEY:  ";
-    private static final String CONNECT_UID_KEY = "CONNECT_UID_KEY:  ";
-    private static final String UPDATE_UID_KEY = "UPDATE_UID:  ";
-    private static final String SUPPLICANT_STATUS_KEY = "SUP_STATUS:  ";
-    private static final String SUPPLICANT_DISABLE_REASON_KEY = "SUP_DIS_REASON:  ";
-    private static final String FQDN_KEY = "FQDN:  ";
-    private static final String NUM_CONNECTION_FAILURES_KEY = "CONNECT_FAILURES:  ";
-    private static final String NUM_IP_CONFIG_FAILURES_KEY = "IP_CONFIG_FAILURES:  ";
-    private static final String NUM_AUTH_FAILURES_KEY = "AUTH_FAILURES:  ";
-    private static final String SCORER_OVERRIDE_KEY = "SCORER_OVERRIDE:  ";
-    private static final String SCORER_OVERRIDE_AND_SWITCH_KEY = "SCORER_OVERRIDE_AND_SWITCH:  ";
-    private static final String VALIDATED_INTERNET_ACCESS_KEY = "VALIDATED_INTERNET_ACCESS:  ";
-    private static final String NO_INTERNET_ACCESS_REPORTS_KEY = "NO_INTERNET_ACCESS_REPORTS :   ";
-    private static final String EPHEMERAL_KEY = "EPHEMERAL:   ";
-    private static final String NUM_ASSOCIATION_KEY = "NUM_ASSOCIATION:  ";
-    private static final String DELETED_CRC32_KEY = "DELETED_CRC32:  ";
-    private static final String DELETED_EPHEMERAL_KEY = "DELETED_EPHEMERAL:  ";
+    private static final String SSID_KEY = "SSID";
+    private static final String CONFIG_KEY = "CONFIG";
+    private static final String CHOICE_KEY = "CHOICE";
+    private static final String LINK_KEY = "LINK";
+    private static final String BSSID_KEY = "BSSID";
+    private static final String BSSID_KEY_END = "/BSSID";
+    private static final String RSSI_KEY = "RSSI";
+    private static final String FREQ_KEY = "FREQ";
+    private static final String DATE_KEY = "DATE";
+    private static final String MILLI_KEY = "MILLI";
+    private static final String BLACKLIST_MILLI_KEY = "BLACKLIST_MILLI";
+    private static final String NETWORK_ID_KEY = "ID";
+    private static final String PRIORITY_KEY = "PRIORITY";
+    private static final String DEFAULT_GW_KEY = "DEFAULT_GW";
+    private static final String AUTH_KEY = "AUTH";
+    private static final String STATUS_KEY = "AUTO_JOIN_STATUS";
+    private static final String BSSID_STATUS_KEY = "BSSID_STATUS";
+    private static final String SELF_ADDED_KEY = "SELF_ADDED";
+    private static final String FAILURE_KEY = "FAILURE";
+    private static final String DID_SELF_ADD_KEY = "DID_SELF_ADD";
+    private static final String PEER_CONFIGURATION_KEY = "PEER_CONFIGURATION";
+    private static final String CREATOR_UID_KEY = "CREATOR_UID_KEY";
+    private static final String CONNECT_UID_KEY = "CONNECT_UID_KEY";
+    private static final String UPDATE_UID_KEY = "UPDATE_UID";
+    private static final String SUPPLICANT_STATUS_KEY = "SUP_STATUS";
+    private static final String SUPPLICANT_DISABLE_REASON_KEY = "SUP_DIS_REASON";
+    private static final String FQDN_KEY = "FQDN";
+    private static final String NUM_CONNECTION_FAILURES_KEY = "CONNECT_FAILURES";
+    private static final String NUM_IP_CONFIG_FAILURES_KEY = "IP_CONFIG_FAILURES";
+    private static final String NUM_AUTH_FAILURES_KEY = "AUTH_FAILURES";
+    private static final String SCORER_OVERRIDE_KEY = "SCORER_OVERRIDE";
+    private static final String SCORER_OVERRIDE_AND_SWITCH_KEY = "SCORER_OVERRIDE_AND_SWITCH";
+    private static final String VALIDATED_INTERNET_ACCESS_KEY = "VALIDATED_INTERNET_ACCESS";
+    private static final String NO_INTERNET_ACCESS_REPORTS_KEY = "NO_INTERNET_ACCESS_REPORTS";
+    private static final String EPHEMERAL_KEY = "EPHEMERAL";
+    private static final String NUM_ASSOCIATION_KEY = "NUM_ASSOCIATION";
+    private static final String DELETED_CRC32_KEY = "DELETED_CRC32";
+    private static final String DELETED_EPHEMERAL_KEY = "DELETED_EPHEMERAL";
+    private static final String JOIN_ATTEMPT_BOOST_KEY = "JOIN_ATTEMPT_BOOST";
+    private static final String CREATOR_NAME_KEY = "CREATOR_NAME";
+    private static final String UPDATE_NAME_KEY = "UPDATE_NAME";
+    private static final String USER_APPROVED_KEY = "USER_APPROVED";
+    private static final String CREATION_TIME_KEY = "CREATION_TIME";
+    private static final String UPDATE_TIME_KEY = "UPDATE_TIME";
 
-    private static final String JOIN_ATTEMPT_BOOST_KEY = "JOIN_ATTEMPT_BOOST:  ";
+    private static final String SEPARATOR = ":  ";
+    private static final String NL = "\n";
+
     private static final String THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_5G_KEY
-            = "THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_5G:  ";
+            = "THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_5G";
     private static final String THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_24G_KEY
-            = "THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_24G:  ";
+            = "THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_24G";
     private static final String THRESHOLD_UNBLACKLIST_HARD_5G_KEY
-            = "THRESHOLD_UNBLACKLIST_HARD_5G:  ";
+            = "THRESHOLD_UNBLACKLIST_HARD_5G";
     private static final String THRESHOLD_UNBLACKLIST_SOFT_5G_KEY
-            = "THRESHOLD_UNBLACKLIST_SOFT_5G:  ";
+            = "THRESHOLD_UNBLACKLIST_SOFT_5G";
     private static final String THRESHOLD_UNBLACKLIST_HARD_24G_KEY
-            = "THRESHOLD_UNBLACKLIST_HARD_24G:  ";
+            = "THRESHOLD_UNBLACKLIST_HARD_24G";
     private static final String THRESHOLD_UNBLACKLIST_SOFT_24G_KEY
-            = "THRESHOLD_UNBLACKLIST_SOFT_24G:  ";
+            = "THRESHOLD_UNBLACKLIST_SOFT_24G";
     private static final String THRESHOLD_GOOD_RSSI_5_KEY
-            = "THRESHOLD_GOOD_RSSI_5:  ";
+            = "THRESHOLD_GOOD_RSSI_5";
     private static final String THRESHOLD_LOW_RSSI_5_KEY
-            = "THRESHOLD_LOW_RSSI_5:  ";
+            = "THRESHOLD_LOW_RSSI_5";
     private static final String THRESHOLD_BAD_RSSI_5_KEY
-            = "THRESHOLD_BAD_RSSI_5:  ";
+            = "THRESHOLD_BAD_RSSI_5";
     private static final String THRESHOLD_GOOD_RSSI_24_KEY
-            = "THRESHOLD_GOOD_RSSI_24:  ";
+            = "THRESHOLD_GOOD_RSSI_24";
     private static final String THRESHOLD_LOW_RSSI_24_KEY
-            = "THRESHOLD_LOW_RSSI_24:  ";
+            = "THRESHOLD_LOW_RSSI_24";
     private static final String THRESHOLD_BAD_RSSI_24_KEY
-            = "THRESHOLD_BAD_RSSI_24:  ";
+            = "THRESHOLD_BAD_RSSI_24";
 
     private static final String THRESHOLD_MAX_TX_PACKETS_FOR_NETWORK_SWITCHING_KEY
-            = "THRESHOLD_MAX_TX_PACKETS_FOR_NETWORK_SWITCHING:   ";
+            = "THRESHOLD_MAX_TX_PACKETS_FOR_NETWORK_SWITCHING";
     private static final String THRESHOLD_MAX_RX_PACKETS_FOR_NETWORK_SWITCHING_KEY
-            = "THRESHOLD_MAX_RX_PACKETS_FOR_NETWORK_SWITCHING:   ";
+            = "THRESHOLD_MAX_RX_PACKETS_FOR_NETWORK_SWITCHING";
 
     private static final String THRESHOLD_MAX_TX_PACKETS_FOR_FULL_SCANS_KEY
-            = "THRESHOLD_MAX_TX_PACKETS_FOR_FULL_SCANS:   ";
+            = "THRESHOLD_MAX_TX_PACKETS_FOR_FULL_SCANS";
     private static final String THRESHOLD_MAX_RX_PACKETS_FOR_FULL_SCANS_KEY
-            = "THRESHOLD_MAX_RX_PACKETS_FOR_FULL_SCANS:   ";
+            = "THRESHOLD_MAX_RX_PACKETS_FOR_FULL_SCANS";
 
     private static final String THRESHOLD_MAX_TX_PACKETS_FOR_PARTIAL_SCANS_KEY
-            = "THRESHOLD_MAX_TX_PACKETS_FOR_PARTIAL_SCANS:   ";
+            = "THRESHOLD_MAX_TX_PACKETS_FOR_PARTIAL_SCANS";
     private static final String THRESHOLD_MAX_RX_PACKETS_FOR_PARTIAL_SCANS_KEY
-            = "THRESHOLD_MAX_RX_PACKETS_FOR_PARTIAL_SCANS:   ";
+            = "THRESHOLD_MAX_RX_PACKETS_FOR_PARTIAL_SCANS";
 
     private static final String MAX_NUM_ACTIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY
-            = "MAX_NUM_ACTIVE_CHANNELS_FOR_PARTIAL_SCANS:   ";
+            = "MAX_NUM_ACTIVE_CHANNELS_FOR_PARTIAL_SCANS";
     private static final String MAX_NUM_PASSIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY
-            = "MAX_NUM_PASSIVE_CHANNELS_FOR_PARTIAL_SCANS:   ";
+            = "MAX_NUM_PASSIVE_CHANNELS_FOR_PARTIAL_SCANS";
 
     private static final String A_BAND_PREFERENCE_RSSI_THRESHOLD_LOW_KEY =
-            "A_BAND_PREFERENCE_RSSI_THRESHOLD_LOW:   ";
+            "A_BAND_PREFERENCE_RSSI_THRESHOLD_LOW";
     private static final String A_BAND_PREFERENCE_RSSI_THRESHOLD_KEY =
-            "A_BAND_PREFERENCE_RSSI_THRESHOLD:   ";
+            "A_BAND_PREFERENCE_RSSI_THRESHOLD";
     private static final String G_BAND_PREFERENCE_RSSI_THRESHOLD_KEY =
-            "G_BAND_PREFERENCE_RSSI_THRESHOLD:   ";
+            "G_BAND_PREFERENCE_RSSI_THRESHOLD";
 
     private static final String ENABLE_AUTOJOIN_WHILE_ASSOCIATED_KEY
             = "ENABLE_AUTOJOIN_WHILE_ASSOCIATED:   ";
 
     private static final String ASSOCIATED_PARTIAL_SCAN_PERIOD_KEY
-            = "ASSOCIATED_PARTIAL_SCAN_PERIOD:   ";
+            = "ASSOCIATED_PARTIAL_SCAN_PERIOD";
     private static final String ASSOCIATED_FULL_SCAN_BACKOFF_KEY
-            = "ASSOCIATED_FULL_SCAN_BACKOFF_PERIOD:   ";
+            = "ASSOCIATED_FULL_SCAN_BACKOFF_PERIOD";
     private static final String ALWAYS_ENABLE_SCAN_WHILE_ASSOCIATED_KEY
-            = "ALWAYS_ENABLE_SCAN_WHILE_ASSOCIATED:   ";
+            = "ALWAYS_ENABLE_SCAN_WHILE_ASSOCIATED";
     private static final String ONLY_LINK_SAME_CREDENTIAL_CONFIGURATIONS_KEY
-            = "ONLY_LINK_SAME_CREDENTIAL_CONFIGURATIONS:   ";
+            = "ONLY_LINK_SAME_CREDENTIAL_CONFIGURATIONS";
 
     private static final String ENABLE_FULL_BAND_SCAN_WHEN_ASSOCIATED_KEY
-            = "ENABLE_FULL_BAND_SCAN_WHEN_ASSOCIATED:   ";
+            = "ENABLE_FULL_BAND_SCAN_WHEN_ASSOCIATED";
+
+    private static final String ENABLE_HAL_BASED_PNO
+            = "ENABLE_HAL_BASED_PNO";
 
     // The three below configurations are mainly for power stats and CPU usage tracking
     // allowing to incrementally disable framework features
-    private static final String ENABLE_AUTO_JOIN_SCAN_WHILE_ASSOCIATED_KEY
-            = "ENABLE_AUTO_JOIN_SCAN_WHILE_ASSOCIATED:   ";
     private static final String ENABLE_AUTO_JOIN_WHILE_ASSOCIATED_KEY
-            = "ENABLE_AUTO_JOIN_WHILE_ASSOCIATED:   ";
+            = "ENABLE_AUTO_JOIN_WHILE_ASSOCIATED";
     private static final String ENABLE_CHIP_WAKE_UP_WHILE_ASSOCIATED_KEY
-            = "ENABLE_CHIP_WAKE_UP_WHILE_ASSOCIATED:   ";
+            = "ENABLE_CHIP_WAKE_UP_WHILE_ASSOCIATED";
     private static final String ENABLE_RSSI_POLL_WHILE_ASSOCIATED_KEY
-            = "ENABLE_RSSI_POLL_WHILE_ASSOCIATED_KEY:   ";
+            = "ENABLE_RSSI_POLL_WHILE_ASSOCIATED_KEY";
+
+    public static final String idStringVarName = "id_str";
 
     // The Wifi verbose log is provided as a way to persist the verbose logging settings
     // for testing purpose.
     // It is not intended for normal use.
     private static final String WIFI_VERBOSE_LOGS_KEY
-            = "WIFI_VERBOSE_LOGS:   ";
+            = "WIFI_VERBOSE_LOGS";
 
     // As we keep deleted PSK WifiConfiguration for a while, the PSK of
     // those deleted WifiConfiguration is set to this random unused PSK
     private static final String DELETED_CONFIG_PSK = "Mjkd86jEMGn79KhKll298Uu7-deleted";
 
-    public boolean enableAutoJoinScanWhenAssociated = true;
-    public boolean enableAutoJoinWhenAssociated = true;
-    public boolean enableChipWakeUpWhenAssociated = true;
-    public boolean enableRssiPollWhenAssociated = true;
-
-    public int maxTxPacketForNetworkSwitching = 40;
-    public int maxRxPacketForNetworkSwitching = 80;
-
     public int maxTxPacketForFullScans = 8;
     public int maxRxPacketForFullScans = 16;
 
     public int maxTxPacketForPartialScans = 40;
     public int maxRxPacketForPartialScans = 80;
 
-    public boolean enableFullBandScanWhenAssociated = true;
-
-    public int thresholdInitialAutoJoinAttemptMin5RSSI
-            = WifiConfiguration.INITIAL_AUTO_JOIN_ATTEMPT_MIN_5;
-    public int thresholdInitialAutoJoinAttemptMin24RSSI
-            = WifiConfiguration.INITIAL_AUTO_JOIN_ATTEMPT_MIN_24;
-
-    public int thresholdBadRssi5 = WifiConfiguration.BAD_RSSI_5;
-    public int thresholdLowRssi5 = WifiConfiguration.LOW_RSSI_5;
-    public int thresholdGoodRssi5 = WifiConfiguration.GOOD_RSSI_5;
-    public int thresholdBadRssi24 = WifiConfiguration.BAD_RSSI_24;
-    public int thresholdLowRssi24 = WifiConfiguration.LOW_RSSI_24;
-    public int thresholdGoodRssi24 = WifiConfiguration.GOOD_RSSI_24;
-
-    public int associatedFullScanBackoff = 12; // Will be divided by 8 by WifiStateMachine
     public int associatedFullScanMaxIntervalMilli = 300000;
 
-    public int associatedPartialScanPeriodMilli;
-
     // Sane value for roam blacklisting (not switching to a network if already associated)
     // 2 days
     public int networkSwitchingBlackListPeriodMilli = 2 * 24 * 60 * 60 * 1000;
 
     public int bandPreferenceBoostFactor5 = 5; // Boost by 5 dB per dB above threshold
     public int bandPreferencePenaltyFactor5 = 2; // Penalize by 2 dB per dB below threshold
-    public int bandPreferencePenaltyThreshold5 = WifiConfiguration.G_BAND_PREFERENCE_RSSI_THRESHOLD;
-    public int bandPreferenceBoostThreshold5 = WifiConfiguration.A_BAND_PREFERENCE_RSSI_THRESHOLD;
 
     public int badLinkSpeed24 = 6;
     public int badLinkSpeed5 = 12;
@@ -367,22 +378,8 @@
     public int associatedHysteresisHigh = +14;
     public int associatedHysteresisLow = +8;
 
-    public int thresholdUnblacklistThreshold5Hard
-            = WifiConfiguration.UNBLACKLIST_THRESHOLD_5_HARD;
-    public int thresholdUnblacklistThreshold5Soft
-            = WifiConfiguration.UNBLACKLIST_THRESHOLD_5_SOFT;
-    public int thresholdUnblacklistThreshold24Hard
-            = WifiConfiguration.UNBLACKLIST_THRESHOLD_24_HARD;
-    public int thresholdUnblacklistThreshold24Soft
-            = WifiConfiguration.UNBLACKLIST_THRESHOLD_24_SOFT;
-    public int enableVerboseLogging = 0;
     boolean showNetworks = true; // TODO set this back to false, used for debugging 17516271
 
-    public int alwaysEnableScansWhileAssociated = 0;
-
-    public int maxNumActiveChannelsForPartialScans = 6;
-    public int maxNumPassiveChannelsForPartialScans = 2;
-
     public boolean roamOnAny = false;
     public boolean onlyLinkSameCredentialConfigurations = true;
 
@@ -395,6 +392,51 @@
 
     public static final int maxNumScanCacheEntries = 128;
 
+    public final AtomicBoolean enableHalBasedPno = new AtomicBoolean(false);
+    public final AtomicBoolean enableSsidWhitelist = new AtomicBoolean(false);
+    public final AtomicBoolean enableAutoJoinWhenAssociated = new AtomicBoolean(true);
+    public final AtomicBoolean enableFullBandScanWhenAssociated = new AtomicBoolean(true);
+    public final AtomicBoolean enableChipWakeUpWhenAssociated = new AtomicBoolean(true);
+    public final AtomicBoolean enableRssiPollWhenAssociated = new AtomicBoolean(true);
+    public final AtomicInteger thresholdInitialAutoJoinAttemptMin5RSSI =
+            new AtomicInteger(WifiConfiguration.INITIAL_AUTO_JOIN_ATTEMPT_MIN_5);
+    public final AtomicInteger thresholdInitialAutoJoinAttemptMin24RSSI =
+            new AtomicInteger(WifiConfiguration.INITIAL_AUTO_JOIN_ATTEMPT_MIN_24);
+    public final AtomicInteger thresholdUnblacklistThreshold5Hard
+            = new AtomicInteger(WifiConfiguration.UNBLACKLIST_THRESHOLD_5_HARD);
+    public final AtomicInteger thresholdUnblacklistThreshold5Soft
+            = new AtomicInteger(WifiConfiguration.UNBLACKLIST_THRESHOLD_5_SOFT);
+    public final AtomicInteger thresholdUnblacklistThreshold24Hard
+            = new AtomicInteger(WifiConfiguration.UNBLACKLIST_THRESHOLD_24_HARD);
+    public final AtomicInteger thresholdUnblacklistThreshold24Soft
+            = new AtomicInteger(WifiConfiguration.UNBLACKLIST_THRESHOLD_24_SOFT);
+    public final AtomicInteger thresholdGoodRssi5 =
+            new AtomicInteger(WifiConfiguration.GOOD_RSSI_5);
+    public final AtomicInteger thresholdLowRssi5 = new AtomicInteger(WifiConfiguration.LOW_RSSI_5);
+    public final AtomicInteger thresholdBadRssi5 = new AtomicInteger(WifiConfiguration.BAD_RSSI_5);
+    public final AtomicInteger thresholdGoodRssi24 =
+            new AtomicInteger(WifiConfiguration.GOOD_RSSI_24);
+    public final AtomicInteger thresholdLowRssi24 = new AtomicInteger(WifiConfiguration.LOW_RSSI_24);
+    public final AtomicInteger thresholdBadRssi24 = new AtomicInteger(WifiConfiguration.BAD_RSSI_24);
+    public final AtomicInteger maxTxPacketForNetworkSwitching = new AtomicInteger(40);
+    public final AtomicInteger maxRxPacketForNetworkSwitching = new AtomicInteger(80);
+    public final AtomicInteger enableVerboseLogging = new AtomicInteger(0);
+    public final AtomicInteger bandPreferenceBoostThreshold5 =
+            new AtomicInteger(WifiConfiguration.A_BAND_PREFERENCE_RSSI_THRESHOLD);
+    public final AtomicInteger associatedFullScanBackoff =
+            new AtomicInteger(12); // Will be divided by 8 by WifiStateMachine
+    public final AtomicInteger bandPreferencePenaltyThreshold5 =
+            new AtomicInteger(WifiConfiguration.G_BAND_PREFERENCE_RSSI_THRESHOLD);
+    public final AtomicInteger alwaysEnableScansWhileAssociated = new AtomicInteger(0);
+    public final AtomicInteger maxNumPassiveChannelsForPartialScans = new AtomicInteger(2);
+    public final AtomicInteger maxNumActiveChannelsForPartialScans = new AtomicInteger(6);
+    public final AtomicInteger wifiDisconnectedShortScanIntervalMilli = new AtomicInteger(15000);
+    public final AtomicInteger wifiDisconnectedLongScanIntervalMilli = new AtomicInteger(120000);
+    public final AtomicInteger wifiAssociatedShortScanIntervalMilli = new AtomicInteger(20000);
+    public final AtomicInteger wifiAssociatedLongScanIntervalMilli = new AtomicInteger(180000);
+
+    private static final Map<String, Object> sKeyMap = new HashMap<>();
+
     /**
      * Regex pattern for extracting a connect choice.
      * Matches a strings like the following:
@@ -426,7 +468,9 @@
             WifiEnterpriseConfig.PASSWORD_KEY, WifiEnterpriseConfig.CLIENT_CERT_KEY,
             WifiEnterpriseConfig.CA_CERT_KEY, WifiEnterpriseConfig.SUBJECT_MATCH_KEY,
             WifiEnterpriseConfig.ENGINE_KEY, WifiEnterpriseConfig.ENGINE_ID_KEY,
-            WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY };
+            WifiEnterpriseConfig.PRIVATE_KEY_ID_KEY, WifiEnterpriseConfig.ALTSUBJECT_MATCH_KEY,
+            WifiEnterpriseConfig.DOM_SUFFIX_MATCH_KEY
+    };
 
 
     /**
@@ -460,9 +504,70 @@
      */
     private String lastSelectedConfiguration = null;
 
-    WifiConfigStore(Context c, WifiNative wn) {
+    /**
+     * Cached PNO list, it is updated when WifiConfiguration changes due to user input.
+     */
+    ArrayList<WifiNative.WifiPnoNetwork> mCachedPnoList
+            = new ArrayList<WifiNative.WifiPnoNetwork>();
+
+    /*
+     * BSSID blacklist, i.e. list of BSSID we want to avoid
+     */
+    HashSet<String> mBssidBlacklist = new HashSet<String>();
+
+    /*
+     * Lost config list, whenever we read a config from networkHistory.txt that was not in
+     * wpa_supplicant.conf
+     */
+    HashSet<String> mLostConfigsDbg = new HashSet<String>();
+
+    private final AnqpCache mAnqpCache;
+    private final SupplicantBridge mSupplicantBridge;
+    private final MOManager mMOManager;
+    private final SIMAccessor mSIMAccessor;
+
+    private WifiStateMachine mWifiStateMachine;
+
+    WifiConfigStore(Context c,  WifiStateMachine w, WifiNative wn) {
         mContext = c;
         mWifiNative = wn;
+        mWifiStateMachine = w;
+
+        // A map for value setting in readAutoJoinConfig() - replacing the replicated code.
+        sKeyMap.put(ENABLE_AUTO_JOIN_WHILE_ASSOCIATED_KEY, enableAutoJoinWhenAssociated);
+        sKeyMap.put(ENABLE_FULL_BAND_SCAN_WHEN_ASSOCIATED_KEY, enableFullBandScanWhenAssociated);
+        sKeyMap.put(ENABLE_CHIP_WAKE_UP_WHILE_ASSOCIATED_KEY, enableChipWakeUpWhenAssociated);
+        sKeyMap.put(ENABLE_RSSI_POLL_WHILE_ASSOCIATED_KEY, enableRssiPollWhenAssociated);
+        sKeyMap.put(THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_5G_KEY, thresholdInitialAutoJoinAttemptMin5RSSI);
+        sKeyMap.put(THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_24G_KEY, thresholdInitialAutoJoinAttemptMin24RSSI);
+        sKeyMap.put(THRESHOLD_UNBLACKLIST_HARD_5G_KEY, thresholdUnblacklistThreshold5Hard);
+        sKeyMap.put(THRESHOLD_UNBLACKLIST_SOFT_5G_KEY, thresholdUnblacklistThreshold5Soft);
+        sKeyMap.put(THRESHOLD_UNBLACKLIST_HARD_24G_KEY, thresholdUnblacklistThreshold24Hard);
+        sKeyMap.put(THRESHOLD_UNBLACKLIST_SOFT_24G_KEY, thresholdUnblacklistThreshold24Soft);
+        sKeyMap.put(THRESHOLD_GOOD_RSSI_5_KEY, thresholdGoodRssi5);
+        sKeyMap.put(THRESHOLD_LOW_RSSI_5_KEY, thresholdLowRssi5);
+        sKeyMap.put(THRESHOLD_BAD_RSSI_5_KEY, thresholdBadRssi5);
+        sKeyMap.put(THRESHOLD_GOOD_RSSI_24_KEY, thresholdGoodRssi24);
+        sKeyMap.put(THRESHOLD_LOW_RSSI_24_KEY, thresholdLowRssi24);
+        sKeyMap.put(THRESHOLD_BAD_RSSI_24_KEY, thresholdBadRssi24);
+        sKeyMap.put(THRESHOLD_MAX_TX_PACKETS_FOR_NETWORK_SWITCHING_KEY, maxTxPacketForNetworkSwitching);
+        sKeyMap.put(THRESHOLD_MAX_RX_PACKETS_FOR_NETWORK_SWITCHING_KEY, maxRxPacketForNetworkSwitching);
+        sKeyMap.put(THRESHOLD_MAX_TX_PACKETS_FOR_FULL_SCANS_KEY, maxTxPacketForNetworkSwitching);
+        sKeyMap.put(THRESHOLD_MAX_RX_PACKETS_FOR_FULL_SCANS_KEY, maxRxPacketForNetworkSwitching);
+        sKeyMap.put(THRESHOLD_MAX_TX_PACKETS_FOR_PARTIAL_SCANS_KEY, maxTxPacketForNetworkSwitching);
+        sKeyMap.put(THRESHOLD_MAX_RX_PACKETS_FOR_PARTIAL_SCANS_KEY, maxRxPacketForNetworkSwitching);
+        sKeyMap.put(WIFI_VERBOSE_LOGS_KEY, enableVerboseLogging);
+        sKeyMap.put(A_BAND_PREFERENCE_RSSI_THRESHOLD_KEY, bandPreferenceBoostThreshold5);
+        sKeyMap.put(ASSOCIATED_PARTIAL_SCAN_PERIOD_KEY, wifiAssociatedShortScanIntervalMilli);
+        sKeyMap.put(ASSOCIATED_PARTIAL_SCAN_PERIOD_KEY, wifiAssociatedShortScanIntervalMilli);
+
+        sKeyMap.put(ASSOCIATED_FULL_SCAN_BACKOFF_KEY, associatedFullScanBackoff);
+        sKeyMap.put(G_BAND_PREFERENCE_RSSI_THRESHOLD_KEY, bandPreferencePenaltyThreshold5);
+        sKeyMap.put(ALWAYS_ENABLE_SCAN_WHILE_ASSOCIATED_KEY, alwaysEnableScansWhileAssociated);
+        sKeyMap.put(MAX_NUM_PASSIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY, maxNumPassiveChannelsForPartialScans);
+        sKeyMap.put(MAX_NUM_ACTIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY, maxNumActiveChannelsForPartialScans);
+        sKeyMap.put(ENABLE_HAL_BASED_PNO, enableHalBasedPno);
+        sKeyMap.put(ENABLE_HAL_BASED_PNO, enableSsidWhitelist);
 
         if (showNetworks) {
             mLocalLog = mWifiNative.getLocalLog();
@@ -473,20 +578,25 @@
             mFileObserver = null;
         }
 
-        associatedPartialScanPeriodMilli = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_associated_scan_interval);
-        loge("associatedPartialScanPeriodMilli set to " + associatedPartialScanPeriodMilli);
+        wifiAssociatedShortScanIntervalMilli.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_associated_short_scan_interval));
+        wifiAssociatedLongScanIntervalMilli.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_associated_short_scan_interval));
+        wifiDisconnectedShortScanIntervalMilli.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_disconnected_short_scan_interval));
+        wifiDisconnectedLongScanIntervalMilli.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_disconnected_long_scan_interval));
 
         onlyLinkSameCredentialConfigurations = mContext.getResources().getBoolean(
                 R.bool.config_wifi_only_link_same_credential_configurations);
-        maxNumActiveChannelsForPartialScans = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_associated_partial_scan_max_num_active_channels);
-        maxNumPassiveChannelsForPartialScans = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_associated_partial_scan_max_num_passive_channels);
+        maxNumActiveChannelsForPartialScans.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_associated_partial_scan_max_num_active_channels));
+        maxNumPassiveChannelsForPartialScans.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_associated_partial_scan_max_num_passive_channels));
         associatedFullScanMaxIntervalMilli = mContext.getResources().getInteger(
                 R.integer.config_wifi_framework_associated_full_scan_max_interval);
-        associatedFullScanBackoff = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_associated_full_scan_backoff);
+        associatedFullScanBackoff.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_associated_full_scan_backoff));
         enableLinkDebouncing = mContext.getResources().getBoolean(
                 R.bool.config_wifi_enable_disconnection_debounce);
 
@@ -498,28 +608,28 @@
         bandPreferencePenaltyFactor5 = mContext.getResources().getInteger(
                 R.integer.config_wifi_framework_5GHz_preference_penalty_factor);
 
-        bandPreferencePenaltyThreshold5 = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_5GHz_preference_penalty_threshold);
-        bandPreferenceBoostThreshold5 = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_5GHz_preference_boost_threshold);
+        bandPreferencePenaltyThreshold5.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_5GHz_preference_penalty_threshold));
+        bandPreferenceBoostThreshold5.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_5GHz_preference_boost_threshold));
 
         associatedHysteresisHigh = mContext.getResources().getInteger(
                 R.integer.config_wifi_framework_current_association_hysteresis_high);
         associatedHysteresisLow = mContext.getResources().getInteger(
                 R.integer.config_wifi_framework_current_association_hysteresis_low);
 
-        thresholdBadRssi5 = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_wifi_score_bad_rssi_threshold_5GHz);
-        thresholdLowRssi5 = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_wifi_score_low_rssi_threshold_5GHz);
-        thresholdGoodRssi5 = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_wifi_score_good_rssi_threshold_5GHz);
-        thresholdBadRssi24 = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_wifi_score_bad_rssi_threshold_24GHz);
-        thresholdLowRssi24 = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_wifi_score_low_rssi_threshold_24GHz);
-        thresholdGoodRssi24 = mContext.getResources().getInteger(
-                R.integer.config_wifi_framework_wifi_score_good_rssi_threshold_24GHz);
+        thresholdBadRssi5.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_wifi_score_bad_rssi_threshold_5GHz));
+        thresholdLowRssi5.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_wifi_score_low_rssi_threshold_5GHz));
+        thresholdGoodRssi5.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_wifi_score_good_rssi_threshold_5GHz));
+        thresholdBadRssi24.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_wifi_score_bad_rssi_threshold_24GHz));
+        thresholdLowRssi24.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_wifi_score_low_rssi_threshold_24GHz));
+        thresholdGoodRssi24.set(mContext.getResources().getInteger(
+                R.integer.config_wifi_framework_wifi_score_good_rssi_threshold_24GHz));
 
         enableWifiCellularHandoverUserTriggeredAdjustment = mContext.getResources().getBoolean(
                 R.bool.config_wifi_framework_cellular_handover_enable_user_triggered_adjustment);
@@ -540,12 +650,8 @@
         wifiConfigBlacklistMinTimeMilli = mContext.getResources().getInteger(
                 R.integer.config_wifi_framework_network_black_list_min_time_milli);
 
-
-        enableAutoJoinScanWhenAssociated = mContext.getResources().getBoolean(
-                R.bool.config_wifi_framework_enable_associated_autojoin_scan);
-
-        enableAutoJoinWhenAssociated = mContext.getResources().getBoolean(
-                R.bool.config_wifi_framework_enable_associated_network_selection);
+        enableAutoJoinWhenAssociated.set(mContext.getResources().getBoolean(
+                R.bool.config_wifi_framework_enable_associated_network_selection));
 
         currentNetworkBoost = mContext.getResources().getInteger(
                 R.integer.config_wifi_framework_current_network_boost);
@@ -555,10 +661,33 @@
 
         networkSwitchingBlackListPeriodMilli = mContext.getResources().getInteger(
                 R.integer.config_wifi_network_switching_blacklist_time);
+
+        enableHalBasedPno.set(mContext.getResources().getBoolean(
+                        R.bool.config_wifi_hal_pno_enable));
+
+        enableSsidWhitelist.set(mContext.getResources().getBoolean(
+                R.bool.config_wifi_ssid_white_list_enable));
+        if (!enableHalBasedPno.get() && enableSsidWhitelist.get()) {
+            enableSsidWhitelist.set(false);
+        }
+
+        boolean hs2on = mContext.getResources().getBoolean(R.bool.config_wifi_hotspot2_enabled);
+        Log.d(Utils.hs2LogTag(getClass()), "Passpoint is " + (hs2on ? "enabled" : "disabled"));
+
+        mMOManager = new MOManager(new File(PPS_FILE), hs2on);
+        mAnqpCache = new AnqpCache();
+        mSupplicantBridge = new SupplicantBridge(mWifiNative, this);
+        mScanDetailCaches = new HashMap<>();
+
+        mSIMAccessor = new SIMAccessor(mContext);
+    }
+
+    public void trimANQPCache(boolean all) {
+        mAnqpCache.clear(all, DBG);
     }
 
     void enableVerboseLogging(int verbose) {
-        enableVerboseLogging = verbose;
+        enableVerboseLogging.set(verbose);
         if (verbose > 0) {
             VDBG = true;
             showNetworks = true;
@@ -602,7 +731,8 @@
         return mConfiguredNetworks.size();
     }
 
-    private List<WifiConfiguration> getConfiguredNetworks(Map<String, String> pskMap) {
+    private List<WifiConfiguration>
+    getConfiguredNetworks(Map<String, String> pskMap) {
         List<WifiConfiguration> networks = new ArrayList<>();
         for(WifiConfiguration config : mConfiguredNetworks.values()) {
             WifiConfiguration newConfig = new WifiConfiguration(config);
@@ -627,6 +757,19 @@
     }
 
     /**
+     * This function returns all configuration, and is used for cebug and creating bug reports.
+     */
+    private List<WifiConfiguration>
+    getAllConfiguredNetworks() {
+        List<WifiConfiguration> networks = new ArrayList<>();
+        for(WifiConfiguration config : mConfiguredNetworks.values()) {
+            WifiConfiguration newConfig = new WifiConfiguration(config);
+            networks.add(newConfig);
+        }
+        return networks;
+    }
+
+    /**
      * Fetch the list of currently configured networks
      * @return List of networks
      */
@@ -644,6 +787,27 @@
     }
 
     /**
+     * Find matching network for this scanResult
+     */
+    WifiConfiguration getMatchingConfig(ScanResult scanResult) {
+        if (scanResult == null) {
+            return null;
+        }
+        for (Map.Entry entry : mScanDetailCaches.entrySet()) {
+            Integer netId = (Integer) entry.getKey();
+            ScanDetailCache cache = (ScanDetailCache) entry.getValue();
+            WifiConfiguration config = getWifiConfiguration(netId);
+            if (config == null)
+                continue;
+            if (cache.get(scanResult.BSSID) != null) {
+                return config;
+            }
+        }
+
+        return null;
+    }
+
+    /**
      * Fetch the preSharedKeys for all networks.
      * @return a map from Ssid to preSharedKey.
      */
@@ -651,12 +815,6 @@
         return readNetworkVariablesFromSupplicantFile("psk");
     }
 
-    int getconfiguredNetworkSize() {
-        if (mConfiguredNetworks == null)
-            return 0;
-        return mConfiguredNetworks.size();
-    }
-
     /**
      * Fetch the list of currently configured networks that were recently seen
      *
@@ -674,7 +832,11 @@
             }
 
             // Calculate the RSSI for scan results that are more recent than milli
-            config.setVisibility(milli);
+            ScanDetailCache cache = getScanDetailCache(config);
+            if (cache == null) {
+                continue;
+            }
+            config.setVisibility(cache.getVisibility(milli));
             if (config.visibility == null) {
                 continue;
             }
@@ -696,14 +858,15 @@
      */
     void updateConfiguration(WifiInfo info) {
         WifiConfiguration config = getWifiConfiguration(info.getNetworkId());
-        if (config != null && config.scanResultCache != null) {
-            ScanResult result = config.scanResultCache.get(info.getBSSID());
-            if (result != null) {
+        if (config != null && getScanDetailCache(config) != null) {
+            ScanDetail scanDetail = getScanDetailCache(config).getScanDetail(info.getBSSID());
+            if (scanDetail != null) {
+                ScanResult result = scanDetail.getScanResult();
                 long previousSeen = result.seen;
                 int previousRssi = result.level;
 
                 // Update the scan result
-                result.seen = System.currentTimeMillis();
+                scanDetail.setSeen();
                 result.level = info.getRssi();
 
                 // Average the RSSI value
@@ -725,8 +888,6 @@
      * @return Wificonfiguration
      */
     WifiConfiguration getWifiConfiguration(int netId) {
-        if (mConfiguredNetworks == null)
-            return null;
         return mConfiguredNetworks.get(netId);
     }
 
@@ -735,16 +896,7 @@
      * @return Wificonfiguration
      */
     WifiConfiguration getWifiConfiguration(String key) {
-        if (key == null)
-            return null;
-        int hash = key.hashCode();
-        if (mNetworkIds == null)
-            return null;
-        Integer n = mNetworkIds.get(hash);
-        if (n == null)
-            return null;
-        int netId = n.intValue();
-        return getWifiConfiguration(netId);
+        return mConfiguredNetworks.getByConfigKey(key);
     }
 
     /**
@@ -786,6 +938,7 @@
                     config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED);
                 } else {
                     loge("Enable network failed on " + config.networkId);
+
                 }
             }
         }
@@ -796,6 +949,26 @@
         }
     }
 
+    private boolean setNetworkPriorityNative(int netId, int priority) {
+        return mWifiNative.setNetworkVariable(netId,
+                WifiConfiguration.priorityVarName, Integer.toString(priority));
+    }
+
+    private boolean setSSIDNative(int netId, String ssid) {
+        return mWifiNative.setNetworkVariable(netId, WifiConfiguration.ssidVarName,
+                encodeSSID(ssid));
+    }
+
+    public boolean updateLastConnectUid(WifiConfiguration config, int uid) {
+        if (config != null) {
+            if (config.lastConnectUid != uid) {
+                config.lastConnectUid = uid;
+                config.dirty = true;
+                return true;
+            }
+        }
+        return false;
+    }
 
     /**
      * Selects the specified network for connection. This involves
@@ -806,34 +979,61 @@
      * a call to enableAllNetworks() needs to be issued upon a connection
      * or a failure event from supplicant
      *
-     * @param netId network to select for connection
+     * @param config network to select for connection
+     * @param updatePriorities makes config highest priority network
      * @return false if the network id is invalid
      */
-    boolean selectNetwork(int netId) {
-        if (VDBG) localLog("selectNetwork", netId);
-        if (netId == INVALID_NETWORK_ID) return false;
+    boolean selectNetwork(WifiConfiguration config, boolean updatePriorities, int uid) {
+        if (VDBG) localLog("selectNetwork", config.networkId);
+        if (config.networkId == INVALID_NETWORK_ID) return false;
 
         // Reset the priority of each network at start or if it goes too high.
         if (mLastPriority == -1 || mLastPriority > 1000000) {
-            for(WifiConfiguration config : mConfiguredNetworks.values()) {
-                if (config.networkId != INVALID_NETWORK_ID) {
-                    config.priority = 0;
-                    addOrUpdateNetworkNative(config, -1);
+            for(WifiConfiguration config2 : mConfiguredNetworks.values()) {
+                if (updatePriorities) {
+                    if (config2.networkId != INVALID_NETWORK_ID) {
+                        config2.priority = 0;
+                        setNetworkPriorityNative(config2.networkId, config.priority);
+                    }
                 }
             }
             mLastPriority = 0;
         }
 
         // Set to the highest priority and save the configuration.
-        WifiConfiguration config = new WifiConfiguration();
-        config.networkId = netId;
-        config.priority = ++mLastPriority;
+        if (updatePriorities) {
+            config.priority = ++mLastPriority;
+            setNetworkPriorityNative(config.networkId, config.priority);
+            buildPnoList();
+        }
 
-        addOrUpdateNetworkNative(config, -1);
-        mWifiNative.saveConfig();
+        if (config.isPasspoint()) {
+            /* need to slap on the SSID of selected bssid to work */
+            if (getScanDetailCache(config).size() != 0) {
+                ScanDetail result = getScanDetailCache(config).getFirst();
+                if (result == null) {
+                    loge("Could not find scan result for " + config.BSSID);
+                } else {
+                    log("Setting SSID for " + config.networkId + " to" + result.getSSID());
+                    setSSIDNative(config.networkId, result.getSSID());
+                    config.SSID = result.getSSID();
+                }
+
+            } else {
+                loge("Could not find bssid for " + config);
+            }
+        }
+
+        if (updatePriorities)
+            mWifiNative.saveConfig();
+        else
+            mWifiNative.selectNetwork(config.networkId);
+
+        updateLastConnectUid(config, uid);
+        writeKnownNetworkHistory(false);
 
         /* Enable the given network while disabling all other networks */
-        enableNetworkWithoutBroadcast(netId, true);
+        enableNetworkWithoutBroadcast(config.networkId, true);
 
        /* Avoid saving the config & sending a broadcast to prevent settings
         * from displaying a disabled list of networks */
@@ -922,11 +1122,11 @@
         if (info != null
             && info.getBSSID() != null
             && ScanResult.is5GHz(info.getFrequency())
-            && info.getRssi() > (bandPreferenceBoostThreshold5 + 3)) {
+            && info.getRssi() > (bandPreferenceBoostThreshold5.get() + 3)) {
             WifiConfiguration config = getWifiConfiguration(info.getNetworkId());
             if (config != null) {
-                if (config.scanResultCache != null) {
-                    ScanResult result = config.scanResultCache.get(info.getBSSID());
+                if (getScanDetailCache(config) != null) {
+                    ScanResult result = getScanDetailCache(config).get(info.getBSSID());
                     if (result != null) {
                         result.setAutoJoinStatus(ScanResult.AUTO_ROAM_DISABLED + 1);
                     }
@@ -1017,16 +1217,13 @@
             return null;
         }
 
-        WifiConfiguration foundConfig = null;
+        WifiConfiguration foundConfig = mConfiguredNetworks.getEphemeral(SSID);
 
         mDeletedEphemeralSSIDs.add(SSID);
         loge("Forget ephemeral SSID " + SSID + " num=" + mDeletedEphemeralSSIDs.size());
 
-        for (WifiConfiguration config : mConfiguredNetworks.values()) {
-            if (SSID.equals(config.SSID) && config.ephemeral) {
-                loge("Found ephemeral config in disableEphemeralNetwork: " + config.networkId);
-                foundConfig = config;
-            }
+        if (foundConfig != null) {
+            loge("Found ephemeral config in disableEphemeralNetwork: " + foundConfig.networkId);
         }
 
         // Force a write, because the mDeletedEphemeralSSIDs list has changed even though the
@@ -1045,13 +1242,18 @@
     boolean forgetNetwork(int netId) {
         if (showNetworks) localLog("forgetNetwork", netId);
 
+        WifiConfiguration config = mConfiguredNetworks.get(netId);
         boolean remove = removeConfigAndSendBroadcastIfNeeded(netId);
         if (!remove) {
             //success but we dont want to remove the network from supplicant conf file
             return true;
         }
         if (mWifiNative.removeNetwork(netId)) {
+            if (config != null && config.isPasspoint()) {
+                writePasspointConfigs(config.FQDN, null);
+            }
             mWifiNative.saveConfig();
+            writeKnownNetworkHistory(true);
             return true;
         } else {
             loge("Failed to remove network " + netId);
@@ -1074,6 +1276,14 @@
         Log.e(TAG, " key=" + config.configKey() + " netId=" + Integer.toString(config.networkId)
                 + " uid=" + Integer.toString(config.creatorUid)
                 + "/" + Integer.toString(config.lastUpdateUid));
+
+        if (config.isPasspoint()) {
+            /* create a temporary SSID with providerFriendlyName */
+            Long csum = getChecksum(config.FQDN);
+            config.SSID = csum.toString();
+            config.enterpriseConfig.setDomainSuffixMatch(config.FQDN);
+        }
+
         NetworkUpdateResult result = addOrUpdateNetworkNative(config, uid);
         if (result.getNetworkId() != WifiConfiguration.INVALID_NETWORK_ID) {
             WifiConfiguration conf = mConfiguredNetworks.get(result.getNetworkId());
@@ -1083,9 +1293,103 @@
                             WifiManager.CHANGE_REASON_CONFIG_CHANGE);
             }
         }
+
         return result.getNetworkId();
     }
 
+
+    /**
+     * Get the Wifi PNO list
+     *
+     * @return list of WifiNative.WifiPnoNetwork
+     */
+    private void buildPnoList() {
+        mCachedPnoList = new ArrayList<WifiNative.WifiPnoNetwork>();
+
+        ArrayList<WifiConfiguration> sortedWifiConfigurations
+                = new ArrayList<WifiConfiguration>(getConfiguredNetworks());
+        Log.e(TAG, "buildPnoList sortedWifiConfigurations size " + sortedWifiConfigurations.size());
+        if (sortedWifiConfigurations.size() != 0) {
+            // Sort by descending priority
+            Collections.sort(sortedWifiConfigurations, new Comparator<WifiConfiguration>() {
+                public int compare(WifiConfiguration a, WifiConfiguration b) {
+                    return a.priority >= b.priority ? 1 : -1;
+                }
+            });
+        }
+
+        for (WifiConfiguration config : sortedWifiConfigurations) {
+            // Initialize the RSSI threshold with sane value:
+            // Use the 2.4GHz threshold since most WifiConfigurations are dual bands
+            // There is very little penalty with triggering too soon, i.e. if PNO finds a network
+            // that has an RSSI too low for us to attempt joining it.
+            int threshold = thresholdInitialAutoJoinAttemptMin24RSSI.get();
+            Log.e(TAG, "found sortedWifiConfigurations : " + config.configKey());
+            WifiNative.WifiPnoNetwork network = mWifiNative.new WifiPnoNetwork(config, threshold);
+            mCachedPnoList.add(network);
+        }
+    }
+
+    String[] getWhiteListedSsids(WifiConfiguration config) {
+        int num_ssids = 0;
+        String nonQuoteSSID;
+        int length;
+        if (enableSsidWhitelist.get() == false)
+            return null;
+        List<String> list = new ArrayList<String>();
+        if (config == null)
+            return null;
+        if (config.linkedConfigurations == null) {
+            return null;
+        }
+        if (config.SSID == null || TextUtils.isEmpty(config.SSID)) {
+            return null;
+        }
+        for (String configKey : config.linkedConfigurations.keySet()) {
+
+            // Sanity check that the linked configuration is still valid
+            WifiConfiguration link = getWifiConfiguration(configKey);
+            if (link == null) {
+                continue;
+            }
+
+            if (link.autoJoinStatus != WifiConfiguration.AUTO_JOIN_ENABLED) {
+                continue;
+            }
+
+            if (link.hiddenSSID == true) {
+                continue;
+            }
+
+            if (link.SSID == null || TextUtils.isEmpty(link.SSID)) {
+                continue;
+            }
+
+            length = link.SSID.length();
+            if (length > 2 && (link.SSID.charAt(0) == '"') && link.SSID.charAt(length - 1) == '"') {
+                nonQuoteSSID = link.SSID.substring(1, length - 1);
+            } else {
+                nonQuoteSSID = link.SSID;
+            }
+
+            list.add(nonQuoteSSID);
+        }
+
+        if (list.size() != 0) {
+            length = config.SSID.length();
+            if (length > 2 && (config.SSID.charAt(0) == '"')
+                    && config.SSID.charAt(length - 1) == '"') {
+                nonQuoteSSID = config.SSID.substring(1, length - 1);
+            } else {
+                nonQuoteSSID = config.SSID;
+            }
+
+            list.add(nonQuoteSSID);
+        }
+
+        return (String[])list.toArray(new String[0]);
+    }
+
     /**
      * Remove a network. Note that there is no saveConfig operation.
      * This function is retained for compatibility with the public
@@ -1097,13 +1401,24 @@
      */
     boolean removeNetwork(int netId) {
         if (showNetworks) localLog("removeNetwork", netId);
+        WifiConfiguration config = mConfiguredNetworks.get(netId);
         boolean ret = mWifiNative.removeNetwork(netId);
         if (ret) {
             removeConfigAndSendBroadcastIfNeeded(netId);
+            if (config != null && config.isPasspoint()) {
+                writePasspointConfigs(config.FQDN, null);
+            }
         }
         return ret;
     }
 
+
+    static private Long getChecksum(String source) {
+        Checksum csum = new CRC32();
+        csum.update(source.getBytes(), 0, source.getBytes().length);
+        return csum.getValue();
+    }
+
     private boolean removeConfigAndSendBroadcastIfNeeded(int netId) {
         WifiConfiguration config = mConfiguredNetworks.get(netId);
         if (config != null) {
@@ -1126,20 +1441,23 @@
                     || config.allowedKeyManagement.get(KeyMgmt.WPA_PSK)) {
                 if (!TextUtils.isEmpty(config.SSID)) {
                     /* Remember that we deleted this PSK SSID */
-                    Checksum csum = new CRC32();
                     if (config.SSID != null) {
-                        csum.update(config.SSID.getBytes(), 0, config.SSID.getBytes().length);
-                        mDeletedSSIDs.add(csum.getValue());
+                        Long csum = getChecksum(config.SSID);
+                        mDeletedSSIDs.add(csum);
+                        loge("removeNetwork " + Integer.toString(netId)
+                                + " key=" + config.configKey()
+                                + " config.id=" + Integer.toString(config.networkId)
+                                + "  crc=" + csum);
+                    } else {
+                        loge("removeNetwork " + Integer.toString(netId)
+                                + " key=" + config.configKey()
+                                + " config.id=" + Integer.toString(config.networkId));
                     }
-                    loge("removeNetwork " + Integer.toString(netId)
-                            + " key=" + config.configKey()
-                            + " config.id=" + Integer.toString(config.networkId)
-                            + "  crc=" + csum.getValue());
                 }
             }
 
             mConfiguredNetworks.remove(netId);
-            mNetworkIds.remove(configKey(config));
+            mScanDetailCaches.remove(netId);
 
             writeIpAndProxyConfigurations();
             sendConfiguredNetworksChangedBroadcast(config, WifiManager.CHANGE_REASON_REMOVED);
@@ -1148,6 +1466,57 @@
         return true;
     }
 
+    /*
+     * Remove all networks associated with an application
+     *
+     * @param packageName name of the package of networks to remove
+     * @return {@code true} if all networks removed successfully, {@code false} otherwise
+     */
+    boolean removeNetworksForApp(ApplicationInfo app) {
+        if (app == null || app.packageName == null) {
+            return false;
+        }
+
+        boolean success = true;
+
+        WifiConfiguration [] copiedConfigs =
+                mConfiguredNetworks.values().toArray(new WifiConfiguration[0]);
+        for (WifiConfiguration config : copiedConfigs) {
+            if (app.uid != config.creatorUid || !app.packageName.equals(config.creatorName)) {
+                continue;
+            }
+            if (showNetworks) {
+                localLog("Removing network " + config.SSID
+                         + ", application \"" + app.packageName + "\" uninstalled"
+                         + " from user " + UserHandle.getUserId(app.uid));
+            }
+            success &= removeNetwork(config.networkId);
+        }
+
+        mWifiNative.saveConfig();
+
+        return success;
+    }
+
+    boolean removeNetworksForUser(int userId) {
+        boolean success = true;
+
+        WifiConfiguration[] copiedConfigs =
+                mConfiguredNetworks.values().toArray(new WifiConfiguration[0]);
+        for (WifiConfiguration config : copiedConfigs) {
+            if (userId != UserHandle.getUserId(config.creatorUid)) {
+                continue;
+            }
+            success &= removeNetwork(config.networkId);
+            if (showNetworks) {
+                localLog("Removing network " + config.SSID
+                        + ", user " + userId + " removed");
+            }
+        }
+
+        return success;
+    }
+
     /**
      * Enable a network. Note that there is no saveConfig operation.
      * This function is retained for compatibility with the public
@@ -1157,15 +1526,17 @@
      * @param netId network to be enabled
      * @return {@code true} if it succeeds, {@code false} otherwise
      */
-    boolean enableNetwork(int netId, boolean disableOthers) {
+    boolean enableNetwork(int netId, boolean disableOthers, int uid) {
         boolean ret = enableNetworkWithoutBroadcast(netId, disableOthers);
         if (disableOthers) {
-            if (VDBG) localLog("enableNetwork(disableOthers=true) ", netId);
+            if (VDBG) localLog("enableNetwork(disableOthers=true, uid=" + uid + ") ", netId);
+            updateLastConnectUid(getWifiConfiguration(netId), uid);
+            writeKnownNetworkHistory(false);
             sendConfiguredNetworksChangedBroadcast();
         } else {
             if (VDBG) localLog("enableNetwork(disableOthers=false) ", netId);
-            WifiConfiguration enabledNetwork = null;
-            synchronized(mConfiguredNetworks) {
+            WifiConfiguration enabledNetwork;
+            synchronized(mConfiguredNetworks) {                     // !!! Useless synchronization!
                 enabledNetwork = mConfiguredNetworks.get(netId);
             }
             // check just in case the network was removed by someone else.
@@ -1192,14 +1563,12 @@
     void disableAllNetworks() {
         if (VDBG) localLog("disableAllNetworks");
         boolean networkDisabled = false;
-        for(WifiConfiguration config : mConfiguredNetworks.values()) {
-            if(config != null && config.status != Status.DISABLED) {
-                if(mWifiNative.disableNetwork(config.networkId)) {
-                    networkDisabled = true;
-                    config.status = Status.DISABLED;
-                } else {
-                    loge("Disable network failed on " + config.networkId);
-                }
+        for (WifiConfiguration enabled : mConfiguredNetworks.getEnabledNetworks()) {
+            if(mWifiNative.disableNetwork(enabled.networkId)) {
+                networkDisabled = true;
+                enabled.status = Status.DISABLED;
+            } else {
+                loge("Disable network failed on " + enabled.networkId);
             }
         }
 
@@ -1213,7 +1582,11 @@
      * @return {@code true} if it succeeds, {@code false} otherwise
      */
     boolean disableNetwork(int netId) {
-        return disableNetwork(netId, WifiConfiguration.DISABLED_UNKNOWN_REASON);
+        boolean ret = disableNetwork(netId, WifiConfiguration.DISABLED_UNKNOWN_REASON);
+        if (ret) {
+            mWifiStateMachine.registerNetworkDisabled(netId);
+        }
+        return ret;
     }
 
     /**
@@ -1359,7 +1732,7 @@
 
     /**
      * Fetch the proxy properties for a given network id
-     * @param network id
+     * @param netId id
      * @return ProxyInfo for the network id
      */
     ProxyInfo getProxyProperties(int netId) {
@@ -1372,7 +1745,7 @@
 
     /**
      * Return if the specified network is using static IP
-     * @param network id
+     * @param netId id
      * @return {@code true} if using static ip for netId
      */
     boolean isUsingStaticIp(int netId) {
@@ -1383,6 +1756,11 @@
         return false;
     }
 
+    boolean isEphemeral(int netId) {
+        WifiConfiguration config = mConfiguredNetworks.get(netId);
+        return config != null && config.ephemeral;
+    }
+
     /**
      * Should be called when a single network configuration is made.
      * @param network The network configuration that changed.
@@ -1414,7 +1792,6 @@
         mLastPriority = 0;
 
         mConfiguredNetworks.clear();
-        mNetworkIds.clear();
 
         int last_id = -1;
         boolean done = false;
@@ -1474,12 +1851,11 @@
                 config.setIpAssignment(IpAssignment.DHCP);
                 config.setProxySettings(ProxySettings.NONE);
 
-                if (mNetworkIds.containsKey(configKey(config))) {
+                if (mConfiguredNetworks.getByConfigKey(config.configKey()) != null) {
                     // That SSID is already known, just ignore this duplicate entry
                     if (showNetworks) localLog("discarded duplicate network ", config.networkId);
-                } else if(config.isValid()){
+                } else if(WifiServiceImpl.isValid(config)){
                     mConfiguredNetworks.put(config.networkId, config);
-                    mNetworkIds.put(configKey(config), config.networkId);
                     if (showNetworks) localLog("loaded configured network", config.networkId);
                 } else {
                     if (showNetworks) log("Ignoring loaded configured for network " + config.networkId
@@ -1490,40 +1866,48 @@
             done = (lines.length == 1);
         }
 
+        readPasspointConfig();
         readIpAndProxyConfigurations();
         readNetworkHistory();
         readAutoJoinConfig();
 
+        buildPnoList();
+
         sendConfiguredNetworksChangedBroadcast();
 
-        if (showNetworks) localLog("loadConfiguredNetworks loaded " + mNetworkIds.size() + " networks");
+        if (showNetworks) localLog("loadConfiguredNetworks loaded " + mConfiguredNetworks.size() + " networks");
 
-        if (mNetworkIds.size() == 0) {
-            // no networks? Lets log if the wpa_supplicant.conf file contents
-            BufferedReader reader = null;
+        if (mConfiguredNetworks.isEmpty()) {
+            // no networks? Lets log if the file contents
+            logKernelTime();
+            logContents(SUPPLICANT_CONFIG_FILE);
+            logContents(SUPPLICANT_CONFIG_FILE_BACKUP);
+            logContents(networkHistoryConfigFile);
+        }
+    }
+
+    private void logContents(String file) {
+        localLog("--- Begin " + file + " ---", true);
+        BufferedReader reader = null;
+        try {
+            reader = new BufferedReader(new FileReader(file));
+            for (String line = reader.readLine(); line != null; line = reader.readLine()) {
+                localLog(line, true);
+            }
+        } catch (FileNotFoundException e) {
+            localLog("Could not open " + file + ", " + e, true);
+        } catch (IOException e) {
+            localLog("Could not read " + file + ", " + e, true);
+        } finally {
             try {
-                reader = new BufferedReader(new FileReader(SUPPLICANT_CONFIG_FILE));
-                if (DBG) {
-                    localLog("--- Begin wpa_supplicant.conf Contents ---", true);
-                    for (String line = reader.readLine(); line != null; line = reader.readLine()) {
-                        localLog(line, true);
-                    }
-                    localLog("--- End wpa_supplicant.conf Contents ---", true);
+                if (reader != null) {
+                    reader.close();
                 }
-            } catch (FileNotFoundException e) {
-                localLog("Could not open " + SUPPLICANT_CONFIG_FILE + ", " + e, true);
             } catch (IOException e) {
-                localLog("Could not read " + SUPPLICANT_CONFIG_FILE + ", " + e, true);
-            } finally {
-                try {
-                    if (reader != null) {
-                        reader.close();
-                    }
-                } catch (IOException e) {
-                    // Just ignore the fact that we couldn't close
-                }
+                // Just ignore the fact that we couldn't close
             }
         }
+        localLog("--- End " + file + " Contents ---", true);
     }
 
     private Map<String, String> readNetworkVariablesFromSupplicantFile(String key) {
@@ -1627,6 +2011,37 @@
         return false;
     }
 
+    void readPasspointConfig() {
+
+        List<HomeSP> homeSPs;
+        try {
+            homeSPs = mMOManager.loadAllSPs();
+        } catch (IOException e) {
+            loge("Could not read " + PPS_FILE + " : " + e);
+            return;
+        }
+
+        mConfiguredNetworks.populatePasspointData(homeSPs, mWifiNative);
+    }
+
+    public void writePasspointConfigs(final String fqdn, final HomeSP homeSP) {
+        mWriter.write(PPS_FILE, new DelayedDiskWrite.Writer() {
+            @Override
+            public void onWriteCalled(DataOutputStream out) throws IOException {
+                try {
+                    if (homeSP != null) {
+                        mMOManager.addSP(homeSP);
+                    }
+                    else {
+                        mMOManager.removeSP(fqdn);
+                    }
+                } catch (IOException e) {
+                    loge("Could not write " + PPS_FILE + " : " + e);
+                }
+            }
+        }, false);
+    }
+
     public void writeKnownNetworkHistory(boolean force) {
         boolean needUpdate = force;
 
@@ -1675,7 +2090,7 @@
                                 + " nid:" + Integer.toString(config.networkId));
                     }
 
-                    if (config.isValid() == false)
+                    if (!WifiServiceImpl.isValid(config))
                         continue;
 
                     if (config.SSID == null) {
@@ -1687,133 +2102,142 @@
                     if (VDBG) {
                         loge("writeKnownNetworkHistory write config " + config.configKey());
                     }
-                    out.writeUTF(CONFIG_KEY + config.configKey() + SEPARATOR_KEY);
+                    out.writeUTF(CONFIG_KEY + SEPARATOR + config.configKey() + NL);
 
-                    out.writeUTF(SSID_KEY + config.SSID + SEPARATOR_KEY);
-                    out.writeUTF(FQDN_KEY + config.FQDN + SEPARATOR_KEY);
-
-                    out.writeUTF(PRIORITY_KEY + Integer.toString(config.priority) + SEPARATOR_KEY);
-                    out.writeUTF(STATUS_KEY + Integer.toString(config.autoJoinStatus)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(SUPPLICANT_STATUS_KEY + Integer.toString(config.status)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(SUPPLICANT_DISABLE_REASON_KEY
-                            + Integer.toString(config.disableReason)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(NETWORK_ID_KEY + Integer.toString(config.networkId)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(SELF_ADDED_KEY + Boolean.toString(config.selfAdded)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(DID_SELF_ADD_KEY + Boolean.toString(config.didSelfAdd)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(NO_INTERNET_ACCESS_REPORTS_KEY
-                            + Integer.toString(config.numNoInternetAccessReports)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(VALIDATED_INTERNET_ACCESS_KEY
-                            + Boolean.toString(config.validatedInternetAccess)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(EPHEMERAL_KEY
-                            + Boolean.toString(config.ephemeral)
-                            + SEPARATOR_KEY);
-                    if (config.peerWifiConfiguration != null) {
-                        out.writeUTF(PEER_CONFIGURATION_KEY + config.peerWifiConfiguration
-                                + SEPARATOR_KEY);
+                    if (config.SSID != null) {
+                        out.writeUTF(SSID_KEY + SEPARATOR + config.SSID + NL);
                     }
-                    out.writeUTF(NUM_CONNECTION_FAILURES_KEY
-                            + Integer.toString(config.numConnectionFailures)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(NUM_AUTH_FAILURES_KEY
-                            + Integer.toString(config.numAuthFailures)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(NUM_IP_CONFIG_FAILURES_KEY
-                            + Integer.toString(config.numIpConfigFailures)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(SCORER_OVERRIDE_KEY + Integer.toString(config.numScorerOverride)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(SCORER_OVERRIDE_AND_SWITCH_KEY
-                            + Integer.toString(config.numScorerOverrideAndSwitchedNetwork)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(NUM_ASSOCIATION_KEY
-                            + Integer.toString(config.numAssociation)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(JOIN_ATTEMPT_BOOST_KEY
-                            + Integer.toString(config.autoJoinUseAggressiveJoinAttemptThreshold)
-                            + SEPARATOR_KEY);
-                    //out.writeUTF(BLACKLIST_MILLI_KEY + Long.toString(config.blackListTimestamp)
-                    //        + SEPARATOR_KEY);
-                    out.writeUTF(CREATOR_UID_KEY + Integer.toString(config.creatorUid)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(CONNECT_UID_KEY + Integer.toString(config.lastConnectUid)
-                            + SEPARATOR_KEY);
-                    out.writeUTF(UPDATE_UID_KEY + Integer.toString(config.lastUpdateUid)
-                            + SEPARATOR_KEY);
+                    if (config.FQDN != null) {
+                        out.writeUTF(FQDN_KEY + SEPARATOR + config.FQDN + NL);
+                    }
+
+                    out.writeUTF(PRIORITY_KEY + SEPARATOR +
+                            Integer.toString(config.priority) + NL);
+                    out.writeUTF(STATUS_KEY + SEPARATOR +
+                            Integer.toString(config.autoJoinStatus) + NL);
+                    out.writeUTF(SUPPLICANT_STATUS_KEY + SEPARATOR +
+                            Integer.toString(config.status) + NL);
+                    out.writeUTF(SUPPLICANT_DISABLE_REASON_KEY + SEPARATOR +
+                            Integer.toString(config.disableReason) + NL);
+                    out.writeUTF(NETWORK_ID_KEY + SEPARATOR +
+                            Integer.toString(config.networkId) + NL);
+                    out.writeUTF(SELF_ADDED_KEY + SEPARATOR +
+                            Boolean.toString(config.selfAdded) + NL);
+                    out.writeUTF(DID_SELF_ADD_KEY + SEPARATOR +
+                            Boolean.toString(config.didSelfAdd) + NL);
+                    out.writeUTF(NO_INTERNET_ACCESS_REPORTS_KEY + SEPARATOR +
+                            Integer.toString(config.numNoInternetAccessReports) + NL);
+                    out.writeUTF(VALIDATED_INTERNET_ACCESS_KEY + SEPARATOR +
+                            Boolean.toString(config.validatedInternetAccess) + NL);
+                    out.writeUTF(EPHEMERAL_KEY + SEPARATOR +
+                            Boolean.toString(config.ephemeral) + NL);
+                    if (config.creationTime != null) {
+                        out.writeUTF(CREATION_TIME_KEY + SEPARATOR + config.creationTime + NL);
+                    }
+                    if (config.updateTime != null) {
+                        out.writeUTF(UPDATE_TIME_KEY + SEPARATOR + config.updateTime + NL);
+                    }
+                    if (config.peerWifiConfiguration != null) {
+                        out.writeUTF(PEER_CONFIGURATION_KEY + SEPARATOR +
+                                config.peerWifiConfiguration + NL);
+                    }
+                    out.writeUTF(NUM_CONNECTION_FAILURES_KEY + SEPARATOR +
+                            Integer.toString(config.numConnectionFailures) + NL);
+                    out.writeUTF(NUM_AUTH_FAILURES_KEY + SEPARATOR +
+                            Integer.toString(config.numAuthFailures) + NL);
+                    out.writeUTF(NUM_IP_CONFIG_FAILURES_KEY + SEPARATOR +
+                            Integer.toString(config.numIpConfigFailures) + NL);
+                    out.writeUTF(SCORER_OVERRIDE_KEY + SEPARATOR +
+                            Integer.toString(config.numScorerOverride) + NL);
+                    out.writeUTF(SCORER_OVERRIDE_AND_SWITCH_KEY + SEPARATOR +
+                            Integer.toString(config.numScorerOverrideAndSwitchedNetwork) + NL);
+                    out.writeUTF(NUM_ASSOCIATION_KEY + SEPARATOR +
+                            Integer.toString(config.numAssociation) + NL);
+                    out.writeUTF(JOIN_ATTEMPT_BOOST_KEY + SEPARATOR +
+                            Integer.toString(config.autoJoinUseAggressiveJoinAttemptThreshold)+ NL);
+                    //out.writeUTF(BLACKLIST_MILLI_KEY + SEPARATOR +
+                    // Long.toString(config.blackListTimestamp) + NL);
+                    out.writeUTF(CREATOR_UID_KEY + SEPARATOR +
+                            Integer.toString(config.creatorUid) + NL);
+                    out.writeUTF(CONNECT_UID_KEY + SEPARATOR +
+                            Integer.toString(config.lastConnectUid) + NL);
+                    out.writeUTF(UPDATE_UID_KEY + SEPARATOR +
+                            Integer.toString(config.lastUpdateUid) + NL);
+                    out.writeUTF(CREATOR_NAME_KEY + SEPARATOR +
+                            config.creatorName + NL);
+                    out.writeUTF(UPDATE_NAME_KEY + SEPARATOR +
+                            config.lastUpdateName + NL);
+                    out.writeUTF(USER_APPROVED_KEY + SEPARATOR +
+                            Integer.toString(config.userApproved) + NL);
                     String allowedKeyManagementString =
                             makeString(config.allowedKeyManagement,
                                     WifiConfiguration.KeyMgmt.strings);
-                    out.writeUTF(AUTH_KEY + allowedKeyManagementString + SEPARATOR_KEY);
+                    out.writeUTF(AUTH_KEY + SEPARATOR +
+                            allowedKeyManagementString + NL);
 
                     if (config.connectChoices != null) {
                         for (String key : config.connectChoices.keySet()) {
                             Integer choice = config.connectChoices.get(key);
-                            out.writeUTF(CHOICE_KEY + key + "="
-                                    + choice.toString() + SEPARATOR_KEY);
+                            out.writeUTF(CHOICE_KEY + SEPARATOR +
+                                    key + "=" + choice.toString() + NL);
                         }
                     }
                     if (config.linkedConfigurations != null) {
-                        loge("writeKnownNetworkHistory write linked "
+                        log("writeKnownNetworkHistory write linked "
                                 + config.linkedConfigurations.size());
 
                         for (String key : config.linkedConfigurations.keySet()) {
-                            out.writeUTF(LINK_KEY + key + SEPARATOR_KEY);
+                            out.writeUTF(LINK_KEY + SEPARATOR + key + NL);
                         }
                     }
 
                     String macAddress = config.defaultGwMacAddress;
                     if (macAddress != null) {
-                        out.writeUTF(DEFAULT_GW_KEY + macAddress + SEPARATOR_KEY);
+                        out.writeUTF(DEFAULT_GW_KEY + SEPARATOR + macAddress + NL);
                     }
 
-                    if (config.scanResultCache != null) {
-                        for (ScanResult result : config.scanResultCache.values()) {
-                            out.writeUTF(BSSID_KEY + result.BSSID + SEPARATOR_KEY);
+                    if (getScanDetailCache(config) != null) {
+                        for (ScanDetail scanDetail : getScanDetailCache(config).values()) {
+                            ScanResult result = scanDetail.getScanResult();
+                            out.writeUTF(BSSID_KEY + SEPARATOR +
+                                    result.BSSID + NL);
 
-                            out.writeUTF(FREQ_KEY + Integer.toString(result.frequency)
-                                    + SEPARATOR_KEY);
+                            out.writeUTF(FREQ_KEY + SEPARATOR +
+                                    Integer.toString(result.frequency) + NL);
 
-                            out.writeUTF(RSSI_KEY + Integer.toString(result.level)
-                                    + SEPARATOR_KEY);
+                            out.writeUTF(RSSI_KEY + SEPARATOR +
+                                    Integer.toString(result.level) + NL);
 
-                            out.writeUTF(BSSID_STATUS_KEY
-                                    + Integer.toString(result.autoJoinStatus)
-                                    + SEPARATOR_KEY);
+                            out.writeUTF(BSSID_STATUS_KEY + SEPARATOR +
+                                    Integer.toString(result.autoJoinStatus) + NL);
 
                             //if (result.seen != 0) {
-                            //    out.writeUTF(MILLI_KEY + Long.toString(result.seen)
-                            //            + SEPARATOR_KEY);
+                            //    out.writeUTF(MILLI_KEY + SEPARATOR + Long.toString(result.seen)
+                            //            + NL);
                             //}
-                            out.writeUTF(BSSID_KEY_END + SEPARATOR_KEY);
+                            out.writeUTF(BSSID_KEY_END + NL);
                         }
                     }
                     if (config.lastFailure != null) {
-                        out.writeUTF(FAILURE_KEY + config.lastFailure + SEPARATOR_KEY);
+                        out.writeUTF(FAILURE_KEY + SEPARATOR + config.lastFailure + NL);
                     }
-                    out.writeUTF(SEPARATOR_KEY);
+                    out.writeUTF(NL);
                     // Add extra blank lines for clarity
-                    out.writeUTF(SEPARATOR_KEY);
-                    out.writeUTF(SEPARATOR_KEY);
+                    out.writeUTF(NL);
+                    out.writeUTF(NL);
                 }
                 if (mDeletedSSIDs != null && mDeletedSSIDs.size() > 0) {
                     for (Long i : mDeletedSSIDs) {
                         out.writeUTF(DELETED_CRC32_KEY);
                         out.writeUTF(String.valueOf(i));
-                        out.writeUTF(SEPARATOR_KEY);
+                        out.writeUTF(NL);
                     }
                 }
                 if (mDeletedEphemeralSSIDs != null && mDeletedEphemeralSSIDs.size() > 0) {
                     for (String ssid : mDeletedEphemeralSSIDs) {
                         out.writeUTF(DELETED_EPHEMERAL_KEY);
                         out.writeUTF(ssid);
-                        out.writeUTF(SEPARATOR_KEY);
+                        out.writeUTF(NL);
                     }
                 }
             }
@@ -1857,720 +2281,279 @@
         if (showNetworks) {
             localLog("readNetworkHistory() path:" + networkHistoryConfigFile);
         }
-        DataInputStream in = null;
-        try {
-            in = new DataInputStream(new BufferedInputStream(new FileInputStream(
-                    networkHistoryConfigFile)));
+
+        try (DataInputStream in =
+                     new DataInputStream(new BufferedInputStream(
+                             new FileInputStream(networkHistoryConfigFile)))) {
+
+            String bssid = null;
+            String ssid = null;
+
+            int freq = 0;
+            int status = 0;
+            long seen = 0;
+            int rssi = WifiConfiguration.INVALID_RSSI;
+            String caps = null;
+
             WifiConfiguration config = null;
             while (true) {
-                int id = -1;
-                String key = in.readUTF();
-                String bssid = null;
-                String ssid = null;
+                String line = in.readUTF();
+                if (line == null) {
+                    break;
+                }
+                int colon = line.indexOf(':');
+                if (colon < 0) {
+                    continue;
+                }
 
-                int freq = 0;
-                int status = 0;
-                long seen = 0;
-                int rssi = WifiConfiguration.INVALID_RSSI;
-                String caps = null;
-                if (key.startsWith(CONFIG_KEY)) {
+                String key = line.substring(0, colon).trim();
+                String value = line.substring(colon + 1).trim();
 
-                    if (config != null) {
-                        config = null;
-                    }
-                    String configKey = key.replace(CONFIG_KEY, "");
-                    configKey = configKey.replace(SEPARATOR_KEY, "");
-                    // get the networkId for that config Key
-                    Integer n = mNetworkIds.get(configKey.hashCode());
+                if (key.equals(CONFIG_KEY)) {
+
+                    config = mConfiguredNetworks.getByConfigKey(value);
+                    
                     // skip reading that configuration data
                     // since we don't have a corresponding network ID
-                    if (n == null) {
-                        localLog("readNetworkHistory didnt find netid for hash="
-                                + Integer.toString(configKey.hashCode())
-                                + " key: " + configKey);
-                        continue;
-                    }
-                    config = mConfiguredNetworks.get(n);
                     if (config == null) {
-                        localLog("readNetworkHistory didnt find config for netid="
-                                + n.toString()
-                                + " key: " + configKey);
-                    }
-                    status = 0;
-                    ssid = null;
-                    bssid = null;
-                    freq = 0;
-                    seen = 0;
-                    rssi = WifiConfiguration.INVALID_RSSI;
-                    caps = null;
+                        localLog("readNetworkHistory didnt find netid for hash="
+                                + Integer.toString(value.hashCode())
+                                + " key: " + value);
+                        mLostConfigsDbg.add(value);
+                        continue;
+                    } else {
+                        // After an upgrade count old connections as owned by system
+                        if (config.creatorName == null || config.lastUpdateName == null) {
+                            config.creatorName =
+                                mContext.getPackageManager().getNameForUid(Process.SYSTEM_UID);
+                            config.lastUpdateName = config.creatorName;
 
+                            if (DBG) Log.w(TAG, "Upgrading network " + config.networkId
+                                    + " to " + config.creatorName);
+                        }
+                    }
                 } else if (config != null) {
-                    if (key.startsWith(SSID_KEY)) {
-                        ssid = key.replace(SSID_KEY, "");
-                        ssid = ssid.replace(SEPARATOR_KEY, "");
-                        if (config.SSID != null && !config.SSID.equals(ssid)) {
-                            loge("Error parsing network history file, mismatched SSIDs");
-                            config = null; //error
-                            ssid = null;
-                        } else {
-                            config.SSID = ssid;
-                        }
-                    }
-
-                    if (key.startsWith(FQDN_KEY)) {
-                        String fqdn = key.replace(FQDN_KEY, "");
-                        fqdn = fqdn.replace(SEPARATOR_KEY, "");
-                        config.FQDN = fqdn;
-                    }
-
-                    if (key.startsWith(DEFAULT_GW_KEY)) {
-                        String gateway = key.replace(DEFAULT_GW_KEY, "");
-                        gateway = gateway.replace(SEPARATOR_KEY, "");
-                        config.defaultGwMacAddress = gateway;
-                    }
-
-                    if (key.startsWith(STATUS_KEY)) {
-                        String st = key.replace(STATUS_KEY, "");
-                        st = st.replace(SEPARATOR_KEY, "");
-                        config.autoJoinStatus = Integer.parseInt(st);
-                    }
-
-                    if (key.startsWith(SUPPLICANT_DISABLE_REASON_KEY)) {
-                        String reason = key.replace(SUPPLICANT_DISABLE_REASON_KEY, "");
-                        reason = reason.replace(SEPARATOR_KEY, "");
-                        config.disableReason = Integer.parseInt(reason);
-                    }
-
-                    if (key.startsWith(SELF_ADDED_KEY)) {
-                        String selfAdded = key.replace(SELF_ADDED_KEY, "");
-                        selfAdded = selfAdded.replace(SEPARATOR_KEY, "");
-                        config.selfAdded = Boolean.parseBoolean(selfAdded);
-                    }
-
-                    if (key.startsWith(DID_SELF_ADD_KEY)) {
-                        String didSelfAdd = key.replace(DID_SELF_ADD_KEY, "");
-                        didSelfAdd = didSelfAdd.replace(SEPARATOR_KEY, "");
-                        config.didSelfAdd = Boolean.parseBoolean(didSelfAdd);
-                    }
-
-                    if (key.startsWith(NO_INTERNET_ACCESS_REPORTS_KEY)) {
-                        String access = key.replace(NO_INTERNET_ACCESS_REPORTS_KEY, "");
-                        access = access.replace(SEPARATOR_KEY, "");
-                        config.numNoInternetAccessReports = Integer.parseInt(access);
-                    }
-
-                    if (key.startsWith(VALIDATED_INTERNET_ACCESS_KEY)) {
-                        String access = key.replace(VALIDATED_INTERNET_ACCESS_KEY, "");
-                        access = access.replace(SEPARATOR_KEY, "");
-                        config.validatedInternetAccess = Boolean.parseBoolean(access);
-                    }
-
-                    if (key.startsWith(EPHEMERAL_KEY)) {
-                        String access = key.replace(EPHEMERAL_KEY, "");
-                        access = access.replace(SEPARATOR_KEY, "");
-                        config.ephemeral = Boolean.parseBoolean(access);
-                    }
-
-                    if (key.startsWith(CREATOR_UID_KEY)) {
-                        String uid = key.replace(CREATOR_UID_KEY, "");
-                        uid = uid.replace(SEPARATOR_KEY, "");
-                        config.creatorUid = Integer.parseInt(uid);
-                    }
-
-                    if (key.startsWith(BLACKLIST_MILLI_KEY)) {
-                        String milli = key.replace(BLACKLIST_MILLI_KEY, "");
-                        milli = milli.replace(SEPARATOR_KEY, "");
-                        config.blackListTimestamp = Long.parseLong(milli);
-                    }
-
-                    if (key.startsWith(NUM_CONNECTION_FAILURES_KEY)) {
-                        String num = key.replace(NUM_CONNECTION_FAILURES_KEY, "");
-                        num = num.replace(SEPARATOR_KEY, "");
-                        config.numConnectionFailures = Integer.parseInt(num);
-                    }
-
-                    if (key.startsWith(NUM_IP_CONFIG_FAILURES_KEY)) {
-                        String num = key.replace(NUM_IP_CONFIG_FAILURES_KEY, "");
-                        num = num.replace(SEPARATOR_KEY, "");
-                        config.numIpConfigFailures = Integer.parseInt(num);
-                    }
-
-                    if (key.startsWith(NUM_AUTH_FAILURES_KEY)) {
-                        String num = key.replace(NUM_AUTH_FAILURES_KEY, "");
-                        num = num.replace(SEPARATOR_KEY, "");
-                        config.numIpConfigFailures = Integer.parseInt(num);
-                    }
-
-                    if (key.startsWith(SCORER_OVERRIDE_KEY)) {
-                        String num = key.replace(SCORER_OVERRIDE_KEY, "");
-                        num = num.replace(SEPARATOR_KEY, "");
-                        config.numScorerOverride = Integer.parseInt(num);
-                    }
-
-                    if (key.startsWith(SCORER_OVERRIDE_AND_SWITCH_KEY)) {
-                        String num = key.replace(SCORER_OVERRIDE_AND_SWITCH_KEY, "");
-                        num = num.replace(SEPARATOR_KEY, "");
-                        config.numScorerOverrideAndSwitchedNetwork = Integer.parseInt(num);
-                    }
-
-                    if (key.startsWith(NUM_ASSOCIATION_KEY)) {
-                        String num = key.replace(NUM_ASSOCIATION_KEY, "");
-                        num = num.replace(SEPARATOR_KEY, "");
-                        config.numAssociation = Integer.parseInt(num);
-                    }
-
-                    if (key.startsWith(JOIN_ATTEMPT_BOOST_KEY)) {
-                        String num = key.replace(JOIN_ATTEMPT_BOOST_KEY, "");
-                        num = num.replace(SEPARATOR_KEY, "");
-                        config.autoJoinUseAggressiveJoinAttemptThreshold = Integer.parseInt(num);
-                    }
-
-                    if (key.startsWith(CONNECT_UID_KEY)) {
-                        String uid = key.replace(CONNECT_UID_KEY, "");
-                        uid = uid.replace(SEPARATOR_KEY, "");
-                        config.lastConnectUid = Integer.parseInt(uid);
-                    }
-
-                    if (key.startsWith(UPDATE_UID_KEY)) {
-                        String uid = key.replace(UPDATE_UID_KEY, "");
-                        uid = uid.replace(SEPARATOR_KEY, "");
-                        config.lastUpdateUid = Integer.parseInt(uid);
-                    }
-
-                    if (key.startsWith(FAILURE_KEY)) {
-                        config.lastFailure = key.replace(FAILURE_KEY, "");
-                        config.lastFailure = config.lastFailure.replace(SEPARATOR_KEY, "");
-                    }
-
-                    if (key.startsWith(PEER_CONFIGURATION_KEY)) {
-                        config.peerWifiConfiguration = key.replace(PEER_CONFIGURATION_KEY, "");
-                        config.peerWifiConfiguration =
-                                config.peerWifiConfiguration.replace(SEPARATOR_KEY, "");
-                    }
-
-                    if (key.startsWith(CHOICE_KEY)) {
-                        String choiceStr = key.replace(CHOICE_KEY, "");
-                        choiceStr = choiceStr.replace(SEPARATOR_KEY, "");
-                        String configKey = "";
-                        int choice = 0;
-                        Matcher match = mConnectChoice.matcher(choiceStr);
-                        if (!match.find()) {
-                            if (DBG) Log.d(TAG, "WifiConfigStore: connectChoice: " +
-                                    " Couldnt match pattern : " + choiceStr);
-                        } else {
-                            configKey = match.group(1);
-                            try {
-                                choice = Integer.parseInt(match.group(2));
-                            } catch (NumberFormatException e) {
-                                choice = 0;
+                    switch (key) {
+                        case SSID_KEY:
+                            if (config.isPasspoint()) {
+                                break;
                             }
-                            if (choice > 0) {
-                                if (config.connectChoices == null) {
-                                    config.connectChoices = new HashMap<String, Integer>();
+                            ssid = value;
+                            if (config.SSID != null && !config.SSID.equals(ssid)) {
+                                loge("Error parsing network history file, mismatched SSIDs");
+                                config = null; //error
+                                ssid = null;
+                            } else {
+                                config.SSID = ssid;
+                            }
+                            break;
+                        case FQDN_KEY:
+                            // Check for literal 'null' to be backwards compatible.
+                            config.FQDN = value.equals("null") ? null : value;
+                            break;
+                        case DEFAULT_GW_KEY:
+                            config.defaultGwMacAddress = value;
+                            break;
+                        case STATUS_KEY:
+                            config.autoJoinStatus = Integer.parseInt(value);
+                            break;
+                        case SUPPLICANT_DISABLE_REASON_KEY:
+                            config.disableReason = Integer.parseInt(value);
+                            break;
+                        case SELF_ADDED_KEY:
+                            config.selfAdded = Boolean.parseBoolean(value);
+                            break;
+                        case DID_SELF_ADD_KEY:
+                            config.didSelfAdd = Boolean.parseBoolean(value);
+                            break;
+                        case NO_INTERNET_ACCESS_REPORTS_KEY:
+                            config.numNoInternetAccessReports = Integer.parseInt(value);
+                            break;
+                        case VALIDATED_INTERNET_ACCESS_KEY:
+                            config.validatedInternetAccess = Boolean.parseBoolean(value);
+                            break;
+                        case CREATION_TIME_KEY:
+                            config.creationTime = value;
+                            break;
+                        case UPDATE_TIME_KEY:
+                            config.updateTime = value;
+                            break;
+                        case EPHEMERAL_KEY:
+                            config.ephemeral = Boolean.parseBoolean(value);
+                            break;
+                        case CREATOR_UID_KEY:
+                            config.creatorUid = Integer.parseInt(value);
+                            break;
+                        case BLACKLIST_MILLI_KEY:
+                            config.blackListTimestamp = Long.parseLong(value);
+                            break;
+                        case NUM_CONNECTION_FAILURES_KEY:
+                            config.numConnectionFailures = Integer.parseInt(value);
+                            break;
+                        case NUM_IP_CONFIG_FAILURES_KEY:
+                            config.numIpConfigFailures = Integer.parseInt(value);
+                            break;
+                        case NUM_AUTH_FAILURES_KEY:
+                            config.numIpConfigFailures = Integer.parseInt(value);
+                            break;
+                        case SCORER_OVERRIDE_KEY:
+                            config.numScorerOverride = Integer.parseInt(value);
+                            break;
+                        case SCORER_OVERRIDE_AND_SWITCH_KEY:
+                            config.numScorerOverrideAndSwitchedNetwork = Integer.parseInt(value);
+                            break;
+                        case NUM_ASSOCIATION_KEY:
+                            config.numAssociation = Integer.parseInt(value);
+                            break;
+                        case JOIN_ATTEMPT_BOOST_KEY:
+                            config.autoJoinUseAggressiveJoinAttemptThreshold =
+                                    Integer.parseInt(value);
+                            break;
+                        case CONNECT_UID_KEY:
+                            config.lastConnectUid = Integer.parseInt(value);
+                            break;
+                        case UPDATE_UID_KEY:
+                            config.lastUpdateUid = Integer.parseInt(value);
+                            break;
+                        case FAILURE_KEY:
+                            config.lastFailure = value;
+                            break;
+                        case PEER_CONFIGURATION_KEY:
+                            config.peerWifiConfiguration = value;
+                            break;
+                        case CHOICE_KEY:
+                            String configKey = "";
+                            int choice = 0;
+                            Matcher match = mConnectChoice.matcher(value);
+                            if (!match.find()) {
+                                if (DBG) Log.d(TAG, "WifiConfigStore: connectChoice: " +
+                                        " Couldnt match pattern : " + value);
+                            } else {
+                                configKey = match.group(1);
+                                try {
+                                    choice = Integer.parseInt(match.group(2));
+                                } catch (NumberFormatException e) {
+                                    choice = 0;
                                 }
-                                config.connectChoices.put(configKey, choice);
+                                if (choice > 0) {
+                                    if (config.connectChoices == null) {
+                                        config.connectChoices = new HashMap<>();
+                                    }
+                                    config.connectChoices.put(configKey, choice);
+                                }
                             }
-                        }
-                    }
-
-                    if (key.startsWith(LINK_KEY)) {
-                        String configKey = key.replace(LINK_KEY, "");
-                        configKey = configKey.replace(SEPARATOR_KEY, "");
-                        if (config.linkedConfigurations == null) {
-                            config.linkedConfigurations = new HashMap<String, Integer>();
-                        }
-                        if (config.linkedConfigurations != null) {
-                            config.linkedConfigurations.put(configKey, -1);
-                        }
-                    }
-
-                    if (key.startsWith(BSSID_KEY)) {
-                        if (key.startsWith(BSSID_KEY)) {
-                            bssid = key.replace(BSSID_KEY, "");
-                            bssid = bssid.replace(SEPARATOR_KEY, "");
+                            break;
+                        case LINK_KEY:
+                            if (config.linkedConfigurations == null) {
+                                config.linkedConfigurations = new HashMap<>();
+                            }
+                            else {
+                                config.linkedConfigurations.put(value, -1);
+                            }
+                            break;
+                        case BSSID_KEY:
+                            status = 0;
+                            ssid = null;
+                            bssid = null;
                             freq = 0;
                             seen = 0;
                             rssi = WifiConfiguration.INVALID_RSSI;
                             caps = "";
-                            status = 0;
-                        }
-
-                        if (key.startsWith(RSSI_KEY)) {
-                            String lvl = key.replace(RSSI_KEY, "");
-                            lvl = lvl.replace(SEPARATOR_KEY, "");
-                            rssi = Integer.parseInt(lvl);
-                        }
-
-                        if (key.startsWith(BSSID_STATUS_KEY)) {
-                            String st = key.replace(BSSID_STATUS_KEY, "");
-                            st = st.replace(SEPARATOR_KEY, "");
-                            status = Integer.parseInt(st);
-                        }
-
-                        if (key.startsWith(FREQ_KEY)) {
-                            String channel = key.replace(FREQ_KEY, "");
-                            channel = channel.replace(SEPARATOR_KEY, "");
-                            freq = Integer.parseInt(channel);
-                        }
-
-                        if (key.startsWith(DATE_KEY)) {
-                        /*
-                         * when reading the configuration from file we don't update the date
-                         * so as to avoid reading back stale or non-sensical data that would
-                         * depend on network time.
-                         * The date of a WifiConfiguration should only come from actual scan result.
-                         *
-                        String s = key.replace(FREQ_KEY, "");
-                        seen = Integer.getInteger(s);
-                        */
-                        }
-
-                        if (key.startsWith(BSSID_KEY_END)) {
+                            break;
+                        case RSSI_KEY:
+                            rssi = Integer.parseInt(value);
+                            break;
+                        case BSSID_STATUS_KEY:
+                            status = Integer.parseInt(value);
+                            break;
+                        case FREQ_KEY:
+                            freq = Integer.parseInt(value);
+                            break;
+                        case DATE_KEY:
+                            /*
+                             * when reading the configuration from file we don't update the date
+                             * so as to avoid reading back stale or non-sensical data that would
+                             * depend on network time.
+                             * The date of a WifiConfiguration should only come from actual scan result.
+                             *
+                            String s = key.replace(FREQ_KEY, "");
+                            seen = Integer.getInteger(s);
+                            */
+                            break;
+                        case BSSID_KEY_END:
                             if ((bssid != null) && (ssid != null)) {
 
-                                if (config.scanResultCache == null) {
-                                    config.scanResultCache = new HashMap<String, ScanResult>();
+                                if (getScanDetailCache(config) != null) {
+                                    WifiSsid wssid = WifiSsid.createFromAsciiEncoded(ssid);
+                                    ScanDetail scanDetail = new ScanDetail(wssid, bssid,
+                                            caps, rssi, freq, (long) 0, seen);
+                                    getScanDetailCache(config).put(scanDetail);
+                                    scanDetail.getScanResult().autoJoinStatus = status;
                                 }
-                                WifiSsid wssid = WifiSsid.createFromAsciiEncoded(ssid);
-                                ScanResult result = new ScanResult(wssid, bssid,
-                                        caps, rssi, freq, (long) 0);
-                                result.seen = seen;
-                                config.scanResultCache.put(bssid, result);
-                                result.autoJoinStatus = status;
                             }
-                        }
-
-                        if (key.startsWith(DELETED_CRC32_KEY)) {
-                            String crc = key.replace(DELETED_CRC32_KEY, "");
-                            Long c = Long.parseLong(crc);
-                            mDeletedSSIDs.add(c);
-                        }
-                        if (key.startsWith(DELETED_EPHEMERAL_KEY)) {
-                            String s = key.replace(DELETED_EPHEMERAL_KEY, "");
-                            if (!TextUtils.isEmpty(s)) {
-                                s = s.replace(SEPARATOR_KEY, "");
-                                mDeletedEphemeralSSIDs.add(s);
+                            break;
+                        case DELETED_CRC32_KEY:
+                            mDeletedSSIDs.add(Long.parseLong(value));
+                            break;
+                        case DELETED_EPHEMERAL_KEY:
+                            if (!TextUtils.isEmpty(value)) {
+                                mDeletedEphemeralSSIDs.add(value);
                             }
-                        }
+                            break;
+                        case CREATOR_NAME_KEY:
+                            config.creatorName = value;
+                            break;
+                        case UPDATE_NAME_KEY:
+                            config.lastUpdateName = value;
+                            break;
+                        case USER_APPROVED_KEY:
+                            config.userApproved = Integer.parseInt(value);
+                            break;
                     }
                 }
             }
-        } catch (EOFException ignore) {
-            if (in != null) {
-                try {
-                    in.close();
-                } catch (Exception e) {
-                    loge("readNetworkHistory: Error reading file" + e);
-                }
-            }
+        } catch (NumberFormatException e) {
+            Log.e(TAG, "readNetworkHistory: failed to read, revert to default, " + e, e);
+        } catch (EOFException e) {
+            // do nothing
         } catch (IOException e) {
-            loge("readNetworkHistory: No config file, revert to default" + e);
-        }
-
-        if(in!=null) {
-            try {
-                in.close();
-            } catch (Exception e) {
-                loge("readNetworkHistory: Error closing file" + e);
-            }
+            Log.e(TAG, "readNetworkHistory: No config file, revert to default, " + e, e);
         }
     }
 
     private void readAutoJoinConfig() {
-        BufferedReader reader = null;
-        try {
-
-            reader = new BufferedReader(new FileReader(autoJoinConfigFile));
-
+        try (BufferedReader reader = new BufferedReader(new FileReader(autoJoinConfigFile))) {
             for (String key = reader.readLine(); key != null; key = reader.readLine()) {
-                if (key != null) {
-                    Log.d(TAG, "readAutoJoinConfig line: " + key);
-                }
-                if (key.startsWith(ENABLE_AUTO_JOIN_WHILE_ASSOCIATED_KEY)) {
-                    String st = key.replace(ENABLE_AUTO_JOIN_WHILE_ASSOCIATED_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        enableAutoJoinWhenAssociated = Integer.parseInt(st) != 0;
-                        Log.d(TAG,"readAutoJoinConfig: enabled = " + enableAutoJoinWhenAssociated);
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
+                Log.d(TAG, "readAutoJoinConfig line: " + key);
+
+                int split = key.indexOf(':');
+                if (split < 0) {
+                    continue;
                 }
 
-                if (key.startsWith(ENABLE_FULL_BAND_SCAN_WHEN_ASSOCIATED_KEY)) {
-                    String st = key.replace(ENABLE_FULL_BAND_SCAN_WHEN_ASSOCIATED_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        enableFullBandScanWhenAssociated = Integer.parseInt(st) != 0;
-                        Log.d(TAG,"readAutoJoinConfig: enableFullBandScanWhenAssociated = "
-                                + enableFullBandScanWhenAssociated);
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
+                String name = key.substring(0, split);
+                Object reference = sKeyMap.get(name);
+                if (reference == null) {
+                    continue;
                 }
 
-                if (key.startsWith(ENABLE_AUTO_JOIN_SCAN_WHILE_ASSOCIATED_KEY)) {
-                    String st = key.replace(ENABLE_AUTO_JOIN_SCAN_WHILE_ASSOCIATED_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        enableAutoJoinScanWhenAssociated = Integer.parseInt(st) != 0;
-                        Log.d(TAG,"readAutoJoinConfig: enabled = "
-                                + enableAutoJoinScanWhenAssociated);
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(ENABLE_CHIP_WAKE_UP_WHILE_ASSOCIATED_KEY)) {
-                    String st = key.replace(ENABLE_CHIP_WAKE_UP_WHILE_ASSOCIATED_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        enableChipWakeUpWhenAssociated = Integer.parseInt(st) != 0;
-                        Log.d(TAG,"readAutoJoinConfig: enabled = "
-                                + enableChipWakeUpWhenAssociated);
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(ENABLE_RSSI_POLL_WHILE_ASSOCIATED_KEY)) {
-                    String st = key.replace(ENABLE_RSSI_POLL_WHILE_ASSOCIATED_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        enableRssiPollWhenAssociated = Integer.parseInt(st) != 0;
-                        Log.d(TAG,"readAutoJoinConfig: enabled = "
-                                + enableRssiPollWhenAssociated);
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_5G_KEY)) {
-                    String st =
-                            key.replace(THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_5G_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdInitialAutoJoinAttemptMin5RSSI = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdInitialAutoJoinAttemptMin5RSSI = "
-                                + Integer.toString(thresholdInitialAutoJoinAttemptMin5RSSI));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_24G_KEY)) {
-                    String st =
-                            key.replace(THRESHOLD_INITIAL_AUTO_JOIN_ATTEMPT_RSSI_MIN_24G_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdInitialAutoJoinAttemptMin24RSSI = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdInitialAutoJoinAttemptMin24RSSI = "
-                                + Integer.toString(thresholdInitialAutoJoinAttemptMin24RSSI));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(THRESHOLD_UNBLACKLIST_HARD_5G_KEY)) {
-                    String st = key.replace(THRESHOLD_UNBLACKLIST_HARD_5G_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdUnblacklistThreshold5Hard = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdUnblacklistThreshold5Hard = "
-                            + Integer.toString(thresholdUnblacklistThreshold5Hard));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(THRESHOLD_UNBLACKLIST_SOFT_5G_KEY)) {
-                    String st = key.replace(THRESHOLD_UNBLACKLIST_SOFT_5G_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdUnblacklistThreshold5Soft = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdUnblacklistThreshold5Soft = "
-                            + Integer.toString(thresholdUnblacklistThreshold5Soft));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(THRESHOLD_UNBLACKLIST_HARD_24G_KEY)) {
-                    String st = key.replace(THRESHOLD_UNBLACKLIST_HARD_24G_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdUnblacklistThreshold24Hard = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdUnblacklistThreshold24Hard = "
-                            + Integer.toString(thresholdUnblacklistThreshold24Hard));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(THRESHOLD_UNBLACKLIST_SOFT_24G_KEY)) {
-                    String st = key.replace(THRESHOLD_UNBLACKLIST_SOFT_24G_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdUnblacklistThreshold24Soft = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdUnblacklistThreshold24Soft = "
-                            + Integer.toString(thresholdUnblacklistThreshold24Soft));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(THRESHOLD_GOOD_RSSI_5_KEY)) {
-                    String st = key.replace(THRESHOLD_GOOD_RSSI_5_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdGoodRssi5 = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdGoodRssi5 = "
-                            + Integer.toString(thresholdGoodRssi5));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(THRESHOLD_LOW_RSSI_5_KEY)) {
-                    String st = key.replace(THRESHOLD_LOW_RSSI_5_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdLowRssi5 = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdLowRssi5 = "
-                            + Integer.toString(thresholdLowRssi5));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(THRESHOLD_BAD_RSSI_5_KEY)) {
-                    String st = key.replace(THRESHOLD_BAD_RSSI_5_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdBadRssi5 = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdBadRssi5 = "
-                            + Integer.toString(thresholdBadRssi5));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(THRESHOLD_GOOD_RSSI_24_KEY)) {
-                    String st = key.replace(THRESHOLD_GOOD_RSSI_24_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdGoodRssi24 = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdGoodRssi24 = "
-                            + Integer.toString(thresholdGoodRssi24));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(THRESHOLD_LOW_RSSI_24_KEY)) {
-                    String st = key.replace(THRESHOLD_LOW_RSSI_24_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdLowRssi24 = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdLowRssi24 = "
-                            + Integer.toString(thresholdLowRssi24));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(THRESHOLD_BAD_RSSI_24_KEY)) {
-                    String st = key.replace(THRESHOLD_BAD_RSSI_24_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        thresholdBadRssi24 = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: thresholdBadRssi24 = "
-                            + Integer.toString(thresholdBadRssi24));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(THRESHOLD_MAX_TX_PACKETS_FOR_NETWORK_SWITCHING_KEY)) {
-                    String st = key.replace(THRESHOLD_MAX_TX_PACKETS_FOR_NETWORK_SWITCHING_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        maxTxPacketForNetworkSwitching = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: maxTxPacketForNetworkSwitching = "
-                            + Integer.toString(maxTxPacketForNetworkSwitching));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(THRESHOLD_MAX_RX_PACKETS_FOR_NETWORK_SWITCHING_KEY)) {
-                    String st = key.replace(THRESHOLD_MAX_RX_PACKETS_FOR_NETWORK_SWITCHING_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        maxRxPacketForNetworkSwitching = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: maxRxPacketForNetworkSwitching = "
-                            + Integer.toString(maxRxPacketForNetworkSwitching));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(THRESHOLD_MAX_TX_PACKETS_FOR_FULL_SCANS_KEY)) {
-                    String st = key.replace(THRESHOLD_MAX_TX_PACKETS_FOR_FULL_SCANS_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        maxTxPacketForNetworkSwitching = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: maxTxPacketForFullScans = "
-                                + Integer.toString(maxTxPacketForFullScans));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(THRESHOLD_MAX_RX_PACKETS_FOR_FULL_SCANS_KEY)) {
-                    String st = key.replace(THRESHOLD_MAX_RX_PACKETS_FOR_FULL_SCANS_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        maxRxPacketForNetworkSwitching = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: maxRxPacketForFullScans = "
-                                + Integer.toString(maxRxPacketForFullScans));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(THRESHOLD_MAX_TX_PACKETS_FOR_PARTIAL_SCANS_KEY)) {
-                    String st = key.replace(THRESHOLD_MAX_TX_PACKETS_FOR_PARTIAL_SCANS_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        maxTxPacketForNetworkSwitching = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: maxTxPacketForPartialScans = "
-                                + Integer.toString(maxTxPacketForPartialScans));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(THRESHOLD_MAX_RX_PACKETS_FOR_PARTIAL_SCANS_KEY)) {
-                    String st = key.replace(THRESHOLD_MAX_RX_PACKETS_FOR_PARTIAL_SCANS_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        maxRxPacketForNetworkSwitching = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: maxRxPacketForPartialScans = "
-                                + Integer.toString(maxRxPacketForPartialScans));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-
-                if (key.startsWith(WIFI_VERBOSE_LOGS_KEY)) {
-                    String st = key.replace(WIFI_VERBOSE_LOGS_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        enableVerboseLogging = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: enable verbose logs = "
-                                + Integer.toString(enableVerboseLogging));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(A_BAND_PREFERENCE_RSSI_THRESHOLD_KEY)) {
-                    String st = key.replace(A_BAND_PREFERENCE_RSSI_THRESHOLD_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        bandPreferenceBoostThreshold5 = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: bandPreferenceBoostThreshold5 = "
-                            + Integer.toString(bandPreferenceBoostThreshold5));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(ASSOCIATED_PARTIAL_SCAN_PERIOD_KEY)) {
-                    String st = key.replace(ASSOCIATED_PARTIAL_SCAN_PERIOD_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        associatedPartialScanPeriodMilli = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: associatedScanPeriod = "
-                                + Integer.toString(associatedPartialScanPeriodMilli));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(ASSOCIATED_FULL_SCAN_BACKOFF_KEY)) {
-                    String st = key.replace(ASSOCIATED_FULL_SCAN_BACKOFF_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        associatedFullScanBackoff = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: associatedFullScanBackoff = "
-                                + Integer.toString(associatedFullScanBackoff));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(G_BAND_PREFERENCE_RSSI_THRESHOLD_KEY)) {
-                    String st = key.replace(G_BAND_PREFERENCE_RSSI_THRESHOLD_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        bandPreferencePenaltyThreshold5 = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: bandPreferencePenaltyThreshold5 = "
-                            + Integer.toString(bandPreferencePenaltyThreshold5));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(ALWAYS_ENABLE_SCAN_WHILE_ASSOCIATED_KEY)) {
-                    String st = key.replace(ALWAYS_ENABLE_SCAN_WHILE_ASSOCIATED_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        alwaysEnableScansWhileAssociated = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: alwaysEnableScansWhileAssociated = "
-                                + Integer.toString(alwaysEnableScansWhileAssociated));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(MAX_NUM_PASSIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY)) {
-                    String st = key.replace(MAX_NUM_PASSIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        maxNumPassiveChannelsForPartialScans = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: maxNumPassiveChannelsForPartialScans = "
-                                + Integer.toString(maxNumPassiveChannelsForPartialScans));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-                if (key.startsWith(MAX_NUM_ACTIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY)) {
-                    String st = key.replace(MAX_NUM_ACTIVE_CHANNELS_FOR_PARTIAL_SCANS_KEY, "");
-                    st = st.replace(SEPARATOR_KEY, "");
-                    try {
-                        maxNumActiveChannelsForPartialScans = Integer.parseInt(st);
-                        Log.d(TAG,"readAutoJoinConfig: maxNumActiveChannelsForPartialScans = "
-                                + Integer.toString(maxNumActiveChannelsForPartialScans));
-                    } catch (NumberFormatException e) {
-                        Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
-                    }
-                }
-            }
-        } catch (EOFException ignore) {
-            if (reader != null) {
                 try {
-                    reader.close();
-                    reader = null;
-                } catch (Exception e) {
-                    loge("readAutoJoinStatus: Error closing file" + e);
+                    int value = Integer.parseInt(key.substring(split+1).trim());
+                    if (reference.getClass() == AtomicBoolean.class) {
+                        ((AtomicBoolean)reference).set(value != 0);
+                    }
+                    else {
+                        ((AtomicInteger)reference).set(value);
+                    }
+                    Log.d(TAG,"readAutoJoinConfig: " + name + " = " + value);
                 }
-            }
-        } catch (FileNotFoundException ignore) {
-            if (reader != null) {
-                try {
-                    reader.close();
-                    reader = null;
-                } catch (Exception e) {
-                    loge("readAutoJoinStatus: Error closing file" + e);
+                catch (NumberFormatException nfe) {
+                    Log.d(TAG,"readAutoJoinConfig: incorrect format :" + key);
                 }
             }
         } catch (IOException e) {
             loge("readAutoJoinStatus: Error parsing configuration" + e);
         }
-
-        if (reader!=null) {
-           try {
-               reader.close();
-           } catch (Exception e) {
-               loge("readAutoJoinStatus: Error closing file" + e);
-           }
-        }
     }
 
 
@@ -2595,8 +2578,8 @@
 
         for (int i = 0; i < networks.size(); i++) {
             int id = networks.keyAt(i);
-            WifiConfiguration config = mConfiguredNetworks.get(mNetworkIds.get(id));
-
+            WifiConfiguration config = mConfiguredNetworks.getByConfigKeyID(id);
+            // This is the only place the map is looked up through a (dangerous) hash-value!
 
             if (config == null || config.autoJoinStatus == WifiConfiguration.AUTO_JOIN_DELETED ||
                     config.ephemeral) {
@@ -2615,9 +2598,8 @@
      * and that can confuses the supplicant because it uses space charaters as delimiters
      */
 
-    private String encodeSSID(String str){
-        String tmp = removeDoubleQuotes(str);
-        return String.format("%x", new BigInteger(1, tmp.getBytes(Charset.forName("UTF-8"))));
+    public static String encodeSSID(String str){
+        return Utils.toHex(removeDoubleQuotes(str).getBytes(StandardCharsets.UTF_8));
     }
 
     private NetworkUpdateResult addOrUpdateNetworkNative(WifiConfiguration config, int uid) {
@@ -2628,27 +2610,23 @@
          */
 
         if (VDBG) localLog("addOrUpdateNetworkNative " + config.getPrintableSsid());
+        if (config.isPasspoint() && !mMOManager.isEnabled()) {
+            Log.e(TAG, "Passpoint is not enabled");
+            return new NetworkUpdateResult(INVALID_NETWORK_ID);
+        }
 
         int netId = config.networkId;
         boolean newNetwork = false;
         // networkId of INVALID_NETWORK_ID means we want to create a new network
         if (netId == INVALID_NETWORK_ID) {
-            Integer savedNetId = mNetworkIds.get(configKey(config));
-            // Check if either we have a network Id or a WifiConfiguration
-            // matching the one we are trying to add.
-            if (savedNetId == null) {
-                for (WifiConfiguration test : mConfiguredNetworks.values()) {
-                    if (test.configKey().equals(config.configKey())) {
-                        savedNetId = test.networkId;
-                        loge("addOrUpdateNetworkNative " + config.configKey()
-                                + " was found, but no network Id");
-                        break;
-                    }
-                }
-            }
-            if (savedNetId != null) {
-                netId = savedNetId;
+            WifiConfiguration savedConfig = mConfiguredNetworks.getByConfigKey(config.configKey());
+            if (savedConfig != null) {
+                netId = savedConfig.networkId;
             } else {
+                if (mMOManager.getHomeSP(config.FQDN) != null) {
+                    loge("addOrUpdateNetworkNative passpoint " + config.FQDN
+                            + " was found, but no network Id");
+                }
                 newNetwork = true;
                 netId = mWifiNative.addNetwork();
                 if (netId < 0) {
@@ -2673,8 +2651,18 @@
                 break setVariables;
             }
 
+            if (config.isPasspoint()) {
+                if (!mWifiNative.setNetworkVariable(
+                            netId,
+                            idStringVarName,
+                            '"' + config.FQDN + '"')) {
+                    loge("failed to set id_str: " + config.FQDN);
+                    break setVariables;
+                }
+            }
+
             if (config.BSSID != null) {
-                loge("Setting BSSID for " + config.configKey() + " to " + config.BSSID);
+                log("Setting BSSID for " + config.configKey() + " to " + config.BSSID);
                 if (!mWifiNative.setNetworkVariable(
                         netId,
                         WifiConfiguration.bssidVarName,
@@ -2862,6 +2850,11 @@
                             // No need to try to set an obfuscated password, which will fail
                             continue;
                         }
+                        if (key.equals(WifiEnterpriseConfig.REALM_KEY)
+                                || key.equals(WifiEnterpriseConfig.PLMN_KEY)) {
+                            // No need to save realm or PLMN in supplicant
+                            continue;
+                        }
                         if (!mWifiNative.setNetworkVariable(
                                     netId,
                                     key,
@@ -2907,15 +2900,54 @@
                 currentConfig.lastConnectUid = config.lastConnectUid;
                 currentConfig.lastUpdateUid = config.lastUpdateUid;
                 currentConfig.creatorUid = config.creatorUid;
+                currentConfig.creatorName = config.creatorName;
+                currentConfig.lastUpdateName = config.lastUpdateName;
                 currentConfig.peerWifiConfiguration = config.peerWifiConfiguration;
+                currentConfig.FQDN = config.FQDN;
+                currentConfig.providerFriendlyName = config.providerFriendlyName;
+                currentConfig.roamingConsortiumIds = config.roamingConsortiumIds;
+                currentConfig.validatedInternetAccess = config.validatedInternetAccess;
+                currentConfig.numNoInternetAccessReports = config.numNoInternetAccessReports;
+                currentConfig.updateTime = config.updateTime;
+                currentConfig.creationTime = config.creationTime;
             }
             if (DBG) {
-                loge("created new config netId=" + Integer.toString(netId)
-                        + " uid=" + Integer.toString(currentConfig.creatorUid));
+                log("created new config netId=" + Integer.toString(netId)
+                        + " uid=" + Integer.toString(currentConfig.creatorUid)
+                        + " name=" + currentConfig.creatorName);
             }
         }
 
-        if (uid >= 0) {
+        /* save HomeSP object for passpoint networks */
+        HomeSP homeSP = null;
+
+        if (config.isPasspoint()) {
+            try {
+                Credential credential =
+                        new Credential(config.enterpriseConfig, mKeyStore, !newNetwork);
+                HashSet<Long> roamingConsortiumIds = new HashSet<Long>();
+                for (Long roamingConsortiumId : config.roamingConsortiumIds) {
+                    roamingConsortiumIds.add(roamingConsortiumId);
+                }
+
+                homeSP = new HomeSP(Collections.<String, Long>emptyMap(), config.FQDN,
+                        roamingConsortiumIds, Collections.<String>emptySet(),
+                        Collections.<Long>emptySet(), Collections.<Long>emptyList(),
+                        config.providerFriendlyName, null, credential);
+
+                log("created a homeSP object for " + config.networkId + ":" + config.SSID);
+
+                /* fix enterprise config properties for passpoint */
+                currentConfig.enterpriseConfig.setRealm(config.enterpriseConfig.getRealm());
+                currentConfig.enterpriseConfig.setPlmn(config.enterpriseConfig.getPlmn());
+            }
+            catch (IOException ioe) {
+                Log.e(TAG, "Failed to create Passpoint config: " + ioe);
+                return new NetworkUpdateResult(INVALID_NETWORK_ID);
+            }
+        }
+
+        if (uid != WifiConfiguration.UNKNOWN_UID) {
             if (newNetwork) {
                 currentConfig.creatorUid = uid;
             } else {
@@ -2923,8 +2955,18 @@
             }
         }
 
+        // For debug, record the time the configuration was modified
+        StringBuilder sb = new StringBuilder();
+        sb.append("time=");
+        Calendar c = Calendar.getInstance();
+        c.setTimeInMillis(System.currentTimeMillis());
+        sb.append(String.format("%tm-%td %tH:%tM:%tS.%tL", c, c, c, c, c, c));
+
         if (newNetwork) {
             currentConfig.dirty = true;
+            currentConfig.creationTime = sb.toString();
+        } else {
+            currentConfig.updateTime = sb.toString();
         }
 
         if (currentConfig.autoJoinStatus == WifiConfiguration.AUTO_JOIN_DELETED) {
@@ -2934,7 +2976,7 @@
             currentConfig.selfAdded = false;
             currentConfig.didSelfAdd = false;
             if (DBG) {
-                loge("remove deleted status netId=" + Integer.toString(netId)
+                log("remove deleted status netId=" + Integer.toString(netId)
                         + " " + currentConfig.configKey());
             }
         }
@@ -2948,26 +2990,59 @@
                 currentConfig.ephemeral) {
             // Make the config non-ephemeral since the user just explicitly clicked it.
             currentConfig.ephemeral = false;
-            if (DBG) loge("remove ephemeral status netId=" + Integer.toString(netId)
+            if (DBG) log("remove ephemeral status netId=" + Integer.toString(netId)
                     + " " + currentConfig.configKey());
         }
 
-        if (DBG) loge("will read network variables netId=" + Integer.toString(netId));
+        if (VDBG) log("will read network variables netId=" + Integer.toString(netId));
 
         readNetworkVariables(currentConfig);
 
+        // Persist configuration paramaters that are not saved by supplicant.
+        if (config.lastUpdateName != null) {
+            currentConfig.lastUpdateName = config.lastUpdateName;
+        }
+        if (config.lastUpdateUid != WifiConfiguration.UNKNOWN_UID) {
+            currentConfig.lastUpdateUid = config.lastUpdateUid;
+        }
+
         mConfiguredNetworks.put(netId, currentConfig);
-        mNetworkIds.put(configKey(currentConfig), netId);
 
         NetworkUpdateResult result = writeIpAndProxyConfigurationsOnChange(currentConfig, config);
         result.setIsNewNetwork(newNetwork);
         result.setNetworkId(netId);
 
+        if (homeSP != null) {
+            writePasspointConfigs(null, homeSP);
+        }
         writeKnownNetworkHistory(false);
 
         return result;
     }
 
+    public WifiConfiguration getWifiConfigForHomeSP(HomeSP homeSP) {
+        WifiConfiguration config = mConfiguredNetworks.getByFQDN(homeSP.getFQDN());
+        if (config == null) {
+            Log.e(TAG, "Could not find network for homeSP " + homeSP.getFQDN());
+        }
+        return config;
+    }
+
+    private HomeSP getHomeSPForConfig(WifiConfiguration config) {
+        WifiConfiguration storedConfig = mConfiguredNetworks.get(config.networkId);
+        return storedConfig != null && storedConfig.isPasspoint() ?
+                mMOManager.getHomeSP(storedConfig.FQDN) : null;
+    }
+
+    public ScanDetailCache getScanDetailCache(WifiConfiguration config) {
+        if (config == null) return null;
+        ScanDetailCache cache = mScanDetailCaches.get(config.networkId);
+        if (cache == null && config.networkId != WifiConfiguration.INVALID_NETWORK_ID) {
+            cache = new ScanDetailCache(config);
+            mScanDetailCaches.put(config.networkId, cache);
+        }
+        return cache;
+    }
 
     /**
      * This function run thru the Saved WifiConfigurations and check if some should be linked.
@@ -2975,7 +3050,7 @@
      */
     public void linkConfiguration(WifiConfiguration config) {
 
-        if (config.scanResultCache != null && config.scanResultCache.size() > 6) {
+        if (getScanDetailCache(config) != null && getScanDetailCache(config).size() > 6) {
             // Ignore configurations with large number of BSSIDs
             return;
         }
@@ -3000,7 +3075,8 @@
                 continue;
             }
 
-            if (link.scanResultCache != null && link.scanResultCache.size() > 6) {
+            ScanDetailCache linkedScanDetailCache = getScanDetailCache(link);
+            if (linkedScanDetailCache != null && linkedScanDetailCache.size() > 6) {
                 // Ignore configurations with large number of BSSIDs
                 continue;
             }
@@ -3019,10 +3095,11 @@
                 // hoping that WifiConfigurations are indeed behind the same gateway.
                 // once both WifiConfiguration have been tried and thus once both efault gateways
                 // are known we will revisit the choice of linking them
-                if ((config.scanResultCache != null) && (config.scanResultCache.size() <= 6)
-                        && (link.scanResultCache != null) && (link.scanResultCache.size() <= 6)) {
-                    for (String abssid : config.scanResultCache.keySet()) {
-                        for (String bbssid : link.scanResultCache.keySet()) {
+                if ((getScanDetailCache(config) != null)
+                        && (getScanDetailCache(config).size() <= 6)) {
+
+                    for (String abssid : getScanDetailCache(config).keySet()) {
+                        for (String bbssid : linkedScanDetailCache.keySet()) {
                             if (VVDBG) {
                                 loge("linkConfiguration try to link due to DBDC BSSID match "
                                         + link.SSID +
@@ -3052,8 +3129,8 @@
 
             if (doLink) {
                 if (VDBG) {
-                   loge("linkConfiguration: will link " + link.configKey()
-                           + " and " + config.configKey());
+                    loge("linkConfiguration: will link " + link.configKey()
+                            + " and " + config.configKey());
                 }
                 if (link.linkedConfigurations == null) {
                     link.linkedConfigurations = new HashMap<String, Integer>();
@@ -3092,139 +3169,6 @@
         }
     }
 
-    /*
-     * We try to link a scan result with a WifiConfiguration for which SSID and
-     * key management dont match,
-     * for instance, we try identify the 5GHz SSID of a DBDC AP,
-     * even though we know only of the 2.4GHz
-     *
-     * Obviously, this function is not optimal since it is used to compare every scan
-     * result with every Saved WifiConfiguration, with a string.equals operation.
-     * As a speed up, might be better to implement the mConfiguredNetworks store as a
-     * <String, WifiConfiguration> object instead of a <Integer, WifiConfiguration> object
-     * so as to speed this up. Also to prevent the tiny probability of hash collision.
-     *
-     */
-    public WifiConfiguration associateWithConfiguration(ScanResult result) {
-        boolean doNotAdd = false;
-        String configKey = WifiConfiguration.configKey(result);
-        if (configKey == null) {
-            if (DBG) loge("associateWithConfiguration(): no config key " );
-            return null;
-        }
-
-        // Need to compare with quoted string
-        String SSID = "\"" + result.SSID + "\"";
-
-        if (VVDBG) {
-            loge("associateWithConfiguration(): try " + configKey);
-        }
-
-        Checksum csum = new CRC32();
-        csum.update(SSID.getBytes(), 0, SSID.getBytes().length);
-        if (mDeletedSSIDs.contains(csum.getValue())) {
-            doNotAdd = true;
-        }
-
-        WifiConfiguration config = null;
-        for (WifiConfiguration link : mConfiguredNetworks.values()) {
-            boolean doLink = false;
-
-            if (link.autoJoinStatus == WifiConfiguration.AUTO_JOIN_DELETED || link.selfAdded ||
-                    link.ephemeral) {
-                if (VVDBG) loge("associateWithConfiguration(): skip selfadd " + link.configKey() );
-                // Make sure we dont associate the scan result to a deleted config
-                continue;
-            }
-
-            if (!link.allowedKeyManagement.get(KeyMgmt.WPA_PSK)) {
-                if (VVDBG) loge("associateWithConfiguration(): skip non-PSK " + link.configKey() );
-                // Make sure we dont associate the scan result to a non-PSK config
-                continue;
-            }
-
-            if (configKey.equals(link.configKey())) {
-                if (VVDBG) loge("associateWithConfiguration(): found it!!! " + configKey );
-                return link; // Found it exactly
-            }
-
-            if (!doNotAdd && (link.scanResultCache != null) && (link.scanResultCache.size() <= 6)) {
-                for (String bssid : link.scanResultCache.keySet()) {
-                    if (result.BSSID.regionMatches(true, 0, bssid, 0, 16)
-                            && SSID.regionMatches(false, 0, link.SSID, 0, 4)) {
-                        // If first 16 ascii characters of BSSID matches, and first 3
-                        // characters of SSID match, we assume this is a home setup
-                        // and thus we will try to transfer the password from the known
-                        // BSSID/SSID to the recently found BSSID/SSID
-
-                        // If (VDBG)
-                        //    loge("associateWithConfiguration OK " );
-                        doLink = true;
-                        break;
-                    }
-                }
-            }
-
-            if (doLink) {
-                // Try to make a non verified WifiConfiguration, but only if the original
-                // configuration was not self already added
-                if (VDBG) {
-                    loge("associateWithConfiguration: try to create " +
-                            result.SSID + " and associate it with: " + link.SSID
-                            + " key " + link.configKey());
-                }
-                config = wifiConfigurationFromScanResult(result);
-                if (config != null) {
-                    config.selfAdded = true;
-                    config.didSelfAdd = true;
-                    config.dirty = true;
-                    config.peerWifiConfiguration = link.configKey();
-                    if (config.allowedKeyManagement.equals(link.allowedKeyManagement) &&
-                            config.allowedKeyManagement.get(KeyMgmt.WPA_PSK)) {
-                        if (VDBG && config != null) {
-                            loge("associateWithConfiguration: got a config from beacon"
-                                    + config.SSID + " key " + config.configKey());
-                        }
-                        // Transfer the credentials from the configuration we are linking from
-                        String psk = readNetworkVariableFromSupplicantFile(link.SSID, "psk");
-                        if (psk != null) {
-                            config.preSharedKey = psk;
-                            if (VDBG) {
-                                if (config.preSharedKey != null)
-                                    loge(" transfer PSK : " + config.preSharedKey);
-                            }
-
-                            // Link configurations
-                            if (link.linkedConfigurations == null) {
-                                link.linkedConfigurations = new HashMap<String, Integer>();
-                            }
-                            if (config.linkedConfigurations == null) {
-                                config.linkedConfigurations = new HashMap<String, Integer>();
-                            }
-                            link.linkedConfigurations.put(config.configKey(), Integer.valueOf(1));
-                            config.linkedConfigurations.put(link.configKey(), Integer.valueOf(1));
-
-                            // Carry over the Ip configuration
-                            if (link.getIpConfiguration() != null) {
-                                config.setIpConfiguration(link.getIpConfiguration());
-                            }
-                        } else {
-                            config = null;
-                        }
-                    } else {
-                        config = null;
-                    }
-                    if (config != null) break;
-                }
-                if (VDBG && config != null) {
-                    loge("associateWithConfiguration: success, created: " + config.SSID
-                            + " key " + config.configKey());
-                }
-            }
-        }
-        return config;
-    }
-
     public HashSet<Integer> makeChannelList(WifiConfiguration config, int age, boolean restrict) {
         if (config == null)
             return null;
@@ -3233,7 +3177,7 @@
         HashSet<Integer> channels = new HashSet<Integer>();
 
         //get channels for this configuration, if there are at least 2 BSSIDs
-        if (config.scanResultCache == null && config.linkedConfigurations == null) {
+        if (getScanDetailCache(config) == null && config.linkedConfigurations == null) {
             return null;
         }
 
@@ -3242,8 +3186,8 @@
             dbg.append("makeChannelList age=" + Integer.toString(age)
                     + " for " + config.configKey()
                     + " max=" + maxNumActiveChannelsForPartialScans);
-            if (config.scanResultCache != null) {
-                dbg.append(" bssids=" + config.scanResultCache.size());
+            if (getScanDetailCache(config) != null) {
+                dbg.append(" bssids=" + getScanDetailCache(config).size());
             }
             if (config.linkedConfigurations != null) {
                 dbg.append(" linked=" + config.linkedConfigurations.size());
@@ -3252,10 +3196,11 @@
         }
 
         int numChannels = 0;
-        if (config.scanResultCache != null && config.scanResultCache.size() > 0) {
-            for (ScanResult result : config.scanResultCache.values()) {
+        if (getScanDetailCache(config) != null && getScanDetailCache(config).size() > 0) {
+            for (ScanDetail scanDetail : getScanDetailCache(config).values()) {
+                ScanResult result = scanDetail.getScanResult();
                 //TODO : cout active and passive channels separately
-                if (numChannels > maxNumActiveChannelsForPartialScans) {
+                if (numChannels > maxNumActiveChannelsForPartialScans.get()) {
                     break;
                 }
                 if (VDBG) {
@@ -3276,16 +3221,17 @@
                 WifiConfiguration linked = getWifiConfiguration(key);
                 if (linked == null)
                     continue;
-                if (linked.scanResultCache == null) {
+                if (getScanDetailCache(linked) == null) {
                     continue;
                 }
-                for (ScanResult result : linked.scanResultCache.values()) {
+                for (ScanDetail scanDetail : getScanDetailCache(linked).values()) {
+                    ScanResult result = scanDetail.getScanResult();
                     if (VDBG) {
                         loge("has link: " + result.BSSID
                                 + " freq=" + Integer.toString(result.frequency)
                                 + " age=" + Long.toString(now_ms - result.seen));
                     }
-                    if (numChannels > maxNumActiveChannelsForPartialScans) {
+                    if (numChannels > maxNumActiveChannelsForPartialScans.get()) {
                         break;
                     }
                     if (((now_ms - result.seen) < age)/*||(!restrict || result.is24GHz())*/) {
@@ -3298,15 +3244,214 @@
         return channels;
     }
 
+    private Map<HomeSP, PasspointMatch> matchPasspointNetworks(ScanDetail scanDetail) {
+        if (!mMOManager.isConfigured()) {
+            return null;
+        }
+        NetworkDetail networkDetail = scanDetail.getNetworkDetail();
+        if (!networkDetail.hasInterworking()) {
+            return null;
+        }
+        updateAnqpCache(scanDetail, networkDetail.getANQPElements());
+
+        Map<HomeSP, PasspointMatch> matches = matchNetwork(scanDetail, true);
+        Log.d(Utils.hs2LogTag(getClass()), scanDetail.getSSID() +
+                " pass 1 matches: " + toMatchString(matches));
+        return matches;
+    }
+
+    private Map<HomeSP, PasspointMatch> matchNetwork(ScanDetail scanDetail, boolean query) {
+        NetworkDetail networkDetail = scanDetail.getNetworkDetail();
+
+        ANQPData anqpData = mAnqpCache.getEntry(networkDetail);
+
+        Map<Constants.ANQPElementType, ANQPElement> anqpElements =
+                anqpData != null ? anqpData.getANQPElements() : null;
+
+        boolean queried = !query;
+        Collection<HomeSP> homeSPs = mMOManager.getLoadedSPs().values();
+        Map<HomeSP, PasspointMatch> matches = new HashMap<>(homeSPs.size());
+        Log.d(Utils.hs2LogTag(getClass()), "match nwk " + scanDetail.toKeyString() +
+                ", anqp " + ( anqpData != null ? "present" : "missing" ) +
+                ", query " + query + ", home sps: " + homeSPs.size());
+
+        for (HomeSP homeSP : homeSPs) {
+            PasspointMatch match = homeSP.match(networkDetail, anqpElements, mSIMAccessor);
+
+            Log.d(Utils.hs2LogTag(getClass()), " -- " +
+                    homeSP.getFQDN() + ": match " + match + ", queried " + queried);
+
+            if (match == PasspointMatch.Incomplete && !queried) {
+                if (mAnqpCache.initiate(networkDetail)) {
+                    mSupplicantBridge.startANQP(scanDetail);
+                }
+                queried = true;
+            }
+            matches.put(homeSP, match);
+        }
+        return matches;
+    }
+
+    public void notifyANQPDone(Long bssid, boolean success) {
+        mSupplicantBridge.notifyANQPDone(bssid, success);
+    }
+
+    public void notifyANQPResponse(ScanDetail scanDetail,
+                                   Map<Constants.ANQPElementType, ANQPElement> anqpElements) {
+
+        updateAnqpCache(scanDetail, anqpElements);
+        if (anqpElements == null || anqpElements.isEmpty()) {
+            return;
+        }
+        scanDetail.propagateANQPInfo(anqpElements);
+
+        Map<HomeSP, PasspointMatch> matches = matchNetwork(scanDetail, false);
+        Log.d(Utils.hs2LogTag(getClass()), scanDetail.getSSID() +
+                " pass 2 matches: " + toMatchString(matches));
+
+        cacheScanResultForPasspointConfigs(scanDetail, matches);
+    }
+
+
+    private void updateAnqpCache(ScanDetail scanDetail,
+                                 Map<Constants.ANQPElementType,ANQPElement> anqpElements)
+    {
+        NetworkDetail networkDetail = scanDetail.getNetworkDetail();
+
+        if (anqpElements == null) {
+            // Try to pull cached data if query failed.
+            ANQPData data = mAnqpCache.getEntry(networkDetail);
+            if (data != null) {
+                scanDetail.propagateANQPInfo(data.getANQPElements());
+            }
+            return;
+        }
+
+        mAnqpCache.update(networkDetail, anqpElements);
+    }
+
+    private static String toMatchString(Map<HomeSP, PasspointMatch> matches) {
+        StringBuilder sb = new StringBuilder();
+        for (Map.Entry<HomeSP, PasspointMatch> entry : matches.entrySet()) {
+            sb.append(' ').append(entry.getKey().getFQDN()).append("->").append(entry.getValue());
+        }
+        return sb.toString();
+    }
+
+    private void cacheScanResultForPasspointConfigs(ScanDetail scanDetail,
+                                           Map<HomeSP,PasspointMatch> matches) {
+
+        for (Map.Entry<HomeSP, PasspointMatch> entry : matches.entrySet()) {
+            PasspointMatch match = entry.getValue();
+            if (match == PasspointMatch.HomeProvider || match == PasspointMatch.RoamingProvider) {
+                WifiConfiguration config = getWifiConfigForHomeSP(entry.getKey());
+                if (config != null) {
+                    cacheScanResultForConfig(config, scanDetail, entry.getValue());
+                } else {
+		            Log.w(Utils.hs2LogTag(getClass()), "Failed to find config for '" +
+                            entry.getKey().getFQDN() + "'");
+                    /* perhaps the configuration was deleted?? */
+                }
+            }
+        }
+    }
+
+    private void cacheScanResultForConfig(
+            WifiConfiguration config, ScanDetail scanDetail, PasspointMatch passpointMatch) {
+
+        ScanResult scanResult = scanDetail.getScanResult();
+
+        if (config.autoJoinStatus >= WifiConfiguration.AUTO_JOIN_DELETED) {
+            if (VVDBG) {
+                loge("updateSavedNetworkHistory(): found a deleted, skip it...  "
+                        + config.configKey());
+            }
+            // The scan result belongs to a deleted config:
+            //   - increment numConfigFound to remember that we found a config
+            //            matching for this scan result
+            //   - dont do anything since the config was deleted, just skip...
+            return;
+        }
+
+        ScanDetailCache scanDetailCache = getScanDetailCache(config);
+        if (scanDetailCache == null) {
+            Log.w(TAG, "Could not allocate scan cache for " + config.SSID);
+            return;
+        }
+
+        // Adding a new BSSID
+        ScanResult result = scanDetailCache.get(scanResult.BSSID);
+        if (result != null) {
+            // transfer the black list status
+            scanResult.autoJoinStatus = result.autoJoinStatus;
+            scanResult.blackListTimestamp = result.blackListTimestamp;
+            scanResult.numIpConfigFailures = result.numIpConfigFailures;
+            scanResult.numConnection = result.numConnection;
+            scanResult.isAutoJoinCandidate = result.isAutoJoinCandidate;
+        }
+
+        if (config.ephemeral) {
+            // For an ephemeral Wi-Fi config, the ScanResult should be considered
+            // untrusted.
+            scanResult.untrusted = true;
+        }
+
+        if (scanDetailCache.size() > (maxNumScanCacheEntries + 64)) {
+            long now_dbg = 0;
+            if (VVDBG) {
+                loge(" Will trim config " + config.configKey()
+                        + " size " + scanDetailCache.size());
+
+                for (ScanDetail sd : scanDetailCache.values()) {
+                    loge("     " + sd.getBSSIDString() + " " + sd.getSeen());
+                }
+                now_dbg = SystemClock.elapsedRealtimeNanos();
+            }
+            // Trim the scan result cache to maxNumScanCacheEntries entries max
+            // Since this operation is expensive, make sure it is not performed
+            // until the cache has grown significantly above the trim treshold
+            scanDetailCache.trim(maxNumScanCacheEntries);
+            if (VVDBG) {
+                long diff = SystemClock.elapsedRealtimeNanos() - now_dbg;
+                loge(" Finished trimming config, time(ns) " + diff);
+                for (ScanDetail sd : scanDetailCache.values()) {
+                    loge("     " + sd.getBSSIDString() + " " + sd.getSeen());
+                }
+            }
+        }
+
+        // Add the scan result to this WifiConfiguration
+        if (passpointMatch != null)
+            scanDetailCache.put(scanDetail, passpointMatch, getHomeSPForConfig(config));
+        else
+            scanDetailCache.put(scanDetail);
+
+        // Since we added a scan result to this configuration, re-attempt linking
+        linkConfiguration(config);
+    }
+
+
     // Update the WifiConfiguration database with the new scan result
     // A scan result can be associated to multiple WifiConfigurations
-    public boolean updateSavedNetworkHistory(ScanResult scanResult) {
+    public boolean updateSavedNetworkHistory(ScanDetail scanDetail) {
+
+        ScanResult scanResult = scanDetail.getScanResult();
+        NetworkDetail networkDetail = scanDetail.getNetworkDetail();
+
         int numConfigFound = 0;
         if (scanResult == null)
             return false;
 
         String SSID = "\"" + scanResult.SSID + "\"";
 
+        if (networkDetail.hasInterworking()) {
+            Map<HomeSP, PasspointMatch> matches = matchPasspointNetworks(scanDetail);
+            if (matches != null) {
+                cacheScanResultForPasspointConfigs(scanDetail, matches);
+                return matches.size() != 0;
+            }
+        }
+
         for (WifiConfiguration config : mConfiguredNetworks.values()) {
             boolean found = false;
 
@@ -3344,70 +3489,7 @@
 
             if (found) {
                 numConfigFound ++;
-
-                if (config.autoJoinStatus >= WifiConfiguration.AUTO_JOIN_DELETED) {
-                    if (VVDBG) {
-                        loge("updateSavedNetworkHistory(): found a deleted, skip it...  "
-                                + config.configKey());
-                    }
-                    // The scan result belongs to a deleted config:
-                    //   - increment numConfigFound to remember that we found a config
-                    //            matching for this scan result
-                    //   - dont do anything since the config was deleted, just skip...
-                    continue;
-                }
-
-                if (config.scanResultCache == null) {
-                    config.scanResultCache = new HashMap<String, ScanResult>();
-                }
-
-                // Adding a new BSSID
-                ScanResult result = config.scanResultCache.get(scanResult.BSSID);
-                if (result == null) {
-                    config.dirty = true;
-                } else {
-                    // transfer the black list status
-                    scanResult.autoJoinStatus = result.autoJoinStatus;
-                    scanResult.blackListTimestamp = result.blackListTimestamp;
-                    scanResult.numIpConfigFailures = result.numIpConfigFailures;
-                    scanResult.numConnection = result.numConnection;
-                    scanResult.isAutoJoinCandidate = result.isAutoJoinCandidate;
-                }
-
-                if (config.ephemeral) {
-                    // For an ephemeral Wi-Fi config, the ScanResult should be considered
-                    // untrusted.
-                    scanResult.untrusted = true;
-                }
-
-                if (config.scanResultCache.size() > (maxNumScanCacheEntries + 64)) {
-                    long now_dbg = 0;
-                    if (VVDBG) {
-                        loge(" Will trim config " + config.configKey()
-                                + " size " + config.scanResultCache.size());
-
-                        for (ScanResult r : config.scanResultCache.values()) {
-                            loge("     " + result.BSSID + " " + result.seen);
-                        }
-                        now_dbg = SystemClock.elapsedRealtimeNanos();
-                    }
-                    // Trim the scan result cache to maxNumScanCacheEntries entries max
-                    // Since this operation is expensive, make sure it is not performed
-                    // until the cache has grown significantly above the trim treshold
-                    config.trimScanResultsCache(maxNumScanCacheEntries);
-                    if (VVDBG) {
-                        long diff = SystemClock.elapsedRealtimeNanos() - now_dbg;
-                        loge(" Finished trimming config, time(ns) " + diff);
-                        for (ScanResult r : config.scanResultCache.values()) {
-                            loge("     " + r.BSSID + " " + r.seen);
-                        }
-                    }
-                }
-
-                // Add the scan result to this WifiConfiguration
-                config.scanResultCache.put(scanResult.BSSID, scanResult);
-                // Since we added a scan result to this configuration, re-attempt linking
-                linkConfiguration(config);
+                cacheScanResultForConfig(config, scanDetail, null);
             }
 
             if (VDBG && found) {
@@ -3418,7 +3500,7 @@
                 loge("        got known scan result " +
                         scanResult.BSSID + " key : "
                         + config.configKey() + " num: " +
-                        Integer.toString(config.scanResultCache.size())
+                        Integer.toString(getScanDetailCache(config).size())
                         + " rssi=" + Integer.toString(scanResult.level)
                         + " freq=" + Integer.toString(scanResult.frequency)
                         + status);
@@ -3609,70 +3691,20 @@
             config.preSharedKey = null;
         }
 
-        value = mWifiNative.getNetworkVariable(config.networkId,
-                WifiConfiguration.Protocol.varName);
-        if (!TextUtils.isEmpty(value)) {
-            String vals[] = value.split(" ");
-            for (String val : vals) {
-                int index =
-                    lookupString(val, WifiConfiguration.Protocol.strings);
-                if (0 <= index) {
-                    config.allowedProtocols.set(index);
-                }
-            }
-        }
+        readNetworkBitsetVariable(config.networkId, config.allowedProtocols,
+                WifiConfiguration.Protocol.varName, WifiConfiguration.Protocol.strings);
 
-        value = mWifiNative.getNetworkVariable(config.networkId,
-                WifiConfiguration.KeyMgmt.varName);
-        if (!TextUtils.isEmpty(value)) {
-            String vals[] = value.split(" ");
-            for (String val : vals) {
-                int index =
-                    lookupString(val, WifiConfiguration.KeyMgmt.strings);
-                if (0 <= index) {
-                    config.allowedKeyManagement.set(index);
-                }
-            }
-        }
+        readNetworkBitsetVariable(config.networkId, config.allowedKeyManagement,
+                WifiConfiguration.KeyMgmt.varName, WifiConfiguration.KeyMgmt.strings);
 
-        value = mWifiNative.getNetworkVariable(config.networkId,
-                WifiConfiguration.AuthAlgorithm.varName);
-        if (!TextUtils.isEmpty(value)) {
-            String vals[] = value.split(" ");
-            for (String val : vals) {
-                int index =
-                    lookupString(val, WifiConfiguration.AuthAlgorithm.strings);
-                if (0 <= index) {
-                    config.allowedAuthAlgorithms.set(index);
-                }
-            }
-        }
+        readNetworkBitsetVariable(config.networkId, config.allowedAuthAlgorithms,
+                WifiConfiguration.AuthAlgorithm.varName, WifiConfiguration.AuthAlgorithm.strings);
 
-        value = mWifiNative.getNetworkVariable(config.networkId,
-                WifiConfiguration.PairwiseCipher.varName);
-        if (!TextUtils.isEmpty(value)) {
-            String vals[] = value.split(" ");
-            for (String val : vals) {
-                int index =
-                    lookupString(val, WifiConfiguration.PairwiseCipher.strings);
-                if (0 <= index) {
-                    config.allowedPairwiseCiphers.set(index);
-                }
-            }
-        }
+        readNetworkBitsetVariable(config.networkId, config.allowedPairwiseCiphers,
+                WifiConfiguration.PairwiseCipher.varName, WifiConfiguration.PairwiseCipher.strings);
 
-        value = mWifiNative.getNetworkVariable(config.networkId,
-                WifiConfiguration.GroupCipher.varName);
-        if (!TextUtils.isEmpty(value)) {
-            String vals[] = value.split(" ");
-            for (String val : vals) {
-                int index =
-                    lookupString(val, WifiConfiguration.GroupCipher.strings);
-                if (0 <= index) {
-                    config.allowedGroupCiphers.set(index);
-                }
-            }
-        }
+        readNetworkBitsetVariable(config.networkId, config.allowedGroupCiphers,
+                WifiConfiguration.GroupCipher.varName, WifiConfiguration.GroupCipher.strings);
 
         if (config.enterpriseConfig == null) {
             config.enterpriseConfig = new WifiEnterpriseConfig();
@@ -3746,7 +3778,9 @@
 
     /* return the allowed key management based on a scan result */
 
-    public WifiConfiguration wifiConfigurationFromScanResult(ScanResult result) {
+    public WifiConfiguration wifiConfigurationFromScanResult(ScanDetail scanDetail) {
+
+        ScanResult result = scanDetail.getScanResult();
         WifiConfiguration config = new WifiConfiguration();
 
         config.SSID = "\"" + result.SSID + "\"";
@@ -3771,10 +3805,7 @@
             config.allowedKeyManagement.set(KeyMgmt.IEEE8021X);
         }
 
-        config.scanResultCache = new HashMap<String, ScanResult>();
-        if (config.scanResultCache == null)
-            return null;
-        config.scanResultCache.put(result.BSSID, result);
+        /* getScanDetailCache(config).put(scanDetail); */
 
         return config;
     }
@@ -3790,16 +3821,26 @@
         pw.println("Dump of WifiConfigStore");
         pw.println("mLastPriority " + mLastPriority);
         pw.println("Configured networks");
-        for (WifiConfiguration conf : getConfiguredNetworks()) {
+        for (WifiConfiguration conf : getAllConfiguredNetworks()) {
             pw.println(conf);
         }
         pw.println();
-
+        if (mLostConfigsDbg != null && mLostConfigsDbg.size() > 0) {
+            pw.println("LostConfigs: ");
+            for (String s : mLostConfigsDbg) {
+                pw.println(s);
+            }
+        }
         if (mLocalLog != null) {
             pw.println("WifiConfigStore - Log Begin ----");
             mLocalLog.dump(fd, pw, args);
             pw.println("WifiConfigStore - Log End ----");
         }
+        if (mMOManager.isConfigured()) {
+            pw.println("Begin dump of ANQP Cache");
+            mAnqpCache.dump(pw);
+            pw.println("End dump of ANQP Cache");
+        }
     }
 
     public String getConfigFile() {
@@ -3821,6 +3862,14 @@
         }
     }
 
+    private void logKernelTime() {
+        long kernelTimeMs = System.nanoTime()/(1000*1000);
+        StringBuilder builder = new StringBuilder();
+        builder.append("kernel time = ").append(kernelTimeMs/1000).append(".").append
+                (kernelTimeMs%1000).append("\n");
+        localLog(builder.toString());
+    }
+
     protected void log(String s) {
         Log.d(TAG, s);
     }
@@ -3842,7 +3891,7 @@
         }
 
         WifiConfiguration config;
-        synchronized(mConfiguredNetworks) {
+        synchronized(mConfiguredNetworks) {             // !!! Useless synchronization
             config = mConfiguredNetworks.get(netId);
         }
 
@@ -3928,6 +3977,112 @@
         return false;
     }
 
+    boolean isNetworkConfigured(WifiConfiguration config) {
+        // Check if either we have a network Id or a WifiConfiguration
+        // matching the one we are trying to add.
+
+        if(config.networkId != INVALID_NETWORK_ID) {
+            return (mConfiguredNetworks.get(config.networkId) != null);
+        }
+
+        return (mConfiguredNetworks.getByConfigKey(config.configKey()) != null);
+    }
+
+    /**
+     * Checks if uid has access to modify the configuration corresponding to networkId.
+     *
+     * Factors involved in modifiability of a config are as follows.
+     *    If uid is a Device Owner app then it has full control over the device, including WiFi
+     * configs.
+     *    If the modification is only for administrative annotation (e.g. when connecting) or the
+     * config is not lockdown eligible (currently that means any config not last updated by the DO)
+     * then the creator of config or an app holding OVERRIDE_CONFIG_WIFI can modify the config.
+     *    If the config is lockdown eligible and the modification is substantial (not annotation)
+     * then the requirement to be able to modify the config by the uid is as follows:
+     *    a) the uid has to hold OVERRIDE_CONFIG_WIFI and
+     *    b) the lockdown feature should be disabled.
+     */
+    boolean canModifyNetwork(int uid, int networkId, boolean onlyAnnotate) {
+        WifiConfiguration config = mConfiguredNetworks.get(networkId);
+
+        if (config == null) {
+            loge("canModifyNetwork: cannot find config networkId " + networkId);
+            return false;
+        }
+
+        final DevicePolicyManagerInternal dpmi = LocalServices.getService(
+                DevicePolicyManagerInternal.class);
+
+        final boolean isUidDeviceOwner = dpmi != null && dpmi.isActiveAdminWithPolicy(uid,
+                DeviceAdminInfo.USES_POLICY_DEVICE_OWNER);
+
+        if (isUidDeviceOwner) {
+            // Device Owner has full control over the device, including WiFi Configs
+            return true;
+        }
+
+        final boolean isCreator = (config.creatorUid == uid);
+
+        if (onlyAnnotate) {
+            return isCreator || checkConfigOverridePermission(uid);
+        }
+
+        // Check if device has DPM capability. If it has and dpmi is still null, then we
+        // treat this case with suspicion and bail out.
+        if (mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_DEVICE_ADMIN)
+                && dpmi == null) {
+            return false;
+        }
+
+        // WiFi config lockdown related logic. At this point we know uid NOT to be a Device Owner.
+
+        final boolean isConfigEligibleForLockdown = dpmi != null && dpmi.isActiveAdminWithPolicy(
+                config.creatorUid, DeviceAdminInfo.USES_POLICY_DEVICE_OWNER);
+        if (!isConfigEligibleForLockdown) {
+            return isCreator || checkConfigOverridePermission(uid);
+        }
+
+        final ContentResolver resolver = mContext.getContentResolver();
+        final boolean isLockdownFeatureEnabled = Settings.Global.getInt(resolver,
+                Settings.Global.WIFI_DEVICE_OWNER_CONFIGS_LOCKDOWN, 0) != 0;
+        return !isLockdownFeatureEnabled && checkConfigOverridePermission(uid);
+    }
+
+    /**
+     * Checks if uid has access to modify config.
+     */
+    boolean canModifyNetwork(int uid, WifiConfiguration config, boolean onlyAnnotate) {
+        if (config == null) {
+            loge("canModifyNetowrk recieved null configuration");
+            return false;
+        }
+
+        // Resolve the correct network id.
+        int netid;
+        if (config.networkId != INVALID_NETWORK_ID){
+            netid = config.networkId;
+        } else {
+            WifiConfiguration test = mConfiguredNetworks.getByConfigKey(config.configKey());
+            if (test == null) {
+                return false;
+            } else {
+                netid = test.networkId;
+            }
+        }
+
+        return canModifyNetwork(uid, netid, onlyAnnotate);
+    }
+
+    boolean checkConfigOverridePermission(int uid) {
+        try {
+            return (AppGlobals.getPackageManager().checkUidPermission(
+                    android.Manifest.permission.OVERRIDE_WIFI_CONFIG, uid)
+                    == PackageManager.PERMISSION_GRANTED);
+        } catch (RemoteException e) {
+            return false;
+        }
+    }
+
     /** called when CS ask WiFistateMachine to disconnect the current network
      * because the score is bad.
      */
@@ -3962,16 +4117,17 @@
 
         // Look for the BSSID in our config store
         for (WifiConfiguration config : mConfiguredNetworks.values()) {
-            if (config.scanResultCache != null) {
-                for (ScanResult result: config.scanResultCache.values()) {
-                    if (result.BSSID.equals(BSSID)) {
+            if (getScanDetailCache(config) != null) {
+                for (ScanDetail scanDetail : getScanDetailCache(config).values()) {
+                    if (scanDetail.getBSSIDString().equals(BSSID)) {
                         if (enable) {
-                            result.setAutoJoinStatus(ScanResult.ENABLED);
+                            scanDetail.getScanResult().setAutoJoinStatus(ScanResult.ENABLED);
                         } else {
                             // Black list the BSSID we were trying to join
                             // so as the Roam state machine
                             // doesn't pick it up over and over
-                            result.setAutoJoinStatus(ScanResult.AUTO_ROAM_DISABLED);
+                            scanDetail.getScanResult().setAutoJoinStatus(
+                                    ScanResult.AUTO_ROAM_DISABLED);
                             found = true;
                         }
                     }
@@ -3987,20 +4143,48 @@
                 DEFAULT_MAX_DHCP_RETRIES);
     }
 
+    void clearBssidBlacklist() {
+        if (!mWifiStateMachine.useHalBasedAutoJoinOffload()) {
+            if(DBG) {
+                Log.d(TAG, "No blacklist allowed without epno enabled");
+            }
+            return;
+        }
+        mBssidBlacklist = new HashSet<String>();
+        mWifiNative.clearBlacklist();
+        mWifiNative.setBssidBlacklist(null);
+    }
+
+    void blackListBssid(String BSSID) {
+        if (!mWifiStateMachine.useHalBasedAutoJoinOffload()) {
+            if(DBG) {
+                Log.d(TAG, "No blacklist allowed without epno enabled");
+            }
+            return;
+        }
+        if (BSSID == null)
+            return;
+        mBssidBlacklist.add(BSSID);
+        // Blacklist at wpa_supplicant
+        mWifiNative.addToBlacklist(BSSID);
+        // Blacklist at firmware
+        String list[] = new String[mBssidBlacklist.size()];
+        int count = 0;
+        for (String bssid : mBssidBlacklist) {
+            list[count++] = bssid;
+        }
+        mWifiNative.setBssidBlacklist(list);
+    }
+
     void handleSSIDStateChange(int netId, boolean enabled, String message, String BSSID) {
         WifiConfiguration config = mConfiguredNetworks.get(netId);
         if (config != null) {
             if (enabled) {
-                loge("SSID re-enabled for  " + config.configKey() +
+                loge("Ignoring SSID re-enabled from supplicant:  " + config.configKey() +
                         " had autoJoinStatus=" + Integer.toString(config.autoJoinStatus)
                         + " self added " + config.selfAdded + " ephemeral " + config.ephemeral);
-                //TODO: http://b/16381983 Fix Wifi Network Blacklisting
-                //TODO: really I don't know if re-enabling is right but we
-                //TODO: should err on the side of trying to connect
-                //TODO: even if the attempt will fail
-                if (config.autoJoinStatus == WifiConfiguration.AUTO_JOIN_DISABLED_ON_AUTH_FAILURE) {
-                    config.setAutoJoinStatus(WifiConfiguration.AUTO_JOIN_ENABLED);
-                }
+                //We should not re-enable the BSSID based on Supplicant reanable.
+                // Framework will re-enable it after its own blacklist timer expires
             } else {
                 loge("SSID temp disabled for  " + config.configKey() +
                         " had autoJoinStatus=" + Integer.toString(config.autoJoinStatus)
@@ -4059,8 +4243,8 @@
                             // Also blacklist the BSSId if we find it
                             ScanResult result = null;
                             String bssidDbg = "";
-                            if (config.scanResultCache != null && BSSID != null) {
-                                result = config.scanResultCache.get(BSSID);
+                            if (getScanDetailCache(config) != null && BSSID != null) {
+                                result = getScanDetailCache(config).get(BSSID);
                             }
                             if (result != null) {
                                 result.numIpConfigFailures ++;
@@ -4130,7 +4314,7 @@
             ret = putCertInKeyStore(userCertName, config.getClientCertificate());
             if (ret == false) {
                 // Remove private key installed
-                mKeyStore.delKey(privKeyName, Process.WIFI_UID);
+                mKeyStore.delete(privKeyName, Process.WIFI_UID);
                 return ret;
             }
         }
@@ -4140,7 +4324,7 @@
             if (ret == false) {
                 if (config.getClientCertificate() != null) {
                     // Remove client key+cert
-                    mKeyStore.delKey(privKeyName, Process.WIFI_UID);
+                    mKeyStore.delete(privKeyName, Process.WIFI_UID);
                     mKeyStore.delete(userCertName, Process.WIFI_UID);
                 }
                 return ret;
@@ -4179,7 +4363,7 @@
         // a valid client certificate is configured
         if (!TextUtils.isEmpty(client)) {
             if (DBG) Log.d(TAG, "removing client private key and user cert");
-            mKeyStore.delKey(Credentials.USER_PRIVATE_KEY + client, Process.WIFI_UID);
+            mKeyStore.delete(Credentials.USER_PRIVATE_KEY + client, Process.WIFI_UID);
             mKeyStore.delete(Credentials.USER_CERTIFICATE + client, Process.WIFI_UID);
         }
 
@@ -4269,4 +4453,18 @@
         }
     }
 
+    private void readNetworkBitsetVariable(int netId, BitSet variable, String varName,
+            String[] strings) {
+        String value = mWifiNative.getNetworkVariable(netId, varName);
+        if (!TextUtils.isEmpty(value)) {
+            variable.clear();
+            String vals[] = value.split(" ");
+            for (String val : vals) {
+                int index = lookupString(val, strings);
+                if (0 <= index) {
+                    variable.set(index);
+                }
+            }
+        }
+    }
 }
diff --git a/service/java/com/android/server/wifi/WifiController.java b/service/java/com/android/server/wifi/WifiController.java
index 8f36cb7..3b41e3b 100644
--- a/service/java/com/android/server/wifi/WifiController.java
+++ b/service/java/com/android/server/wifi/WifiController.java
@@ -114,6 +114,7 @@
     static final int CMD_SET_AP                     = BASE + 10;
     static final int CMD_DEFERRED_TOGGLE            = BASE + 11;
     static final int CMD_USER_PRESENT               = BASE + 12;
+    static final int CMD_AP_START_FAILURE           = BASE + 13;
 
     private DefaultState mDefaultState = new DefaultState();
     private StaEnabledState mStaEnabledState = new StaEnabledState();
@@ -172,6 +173,7 @@
         IntentFilter filter = new IntentFilter();
         filter.addAction(ACTION_DEVICE_IDLE);
         filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
+        filter.addAction(WifiManager.WIFI_AP_STATE_CHANGED_ACTION);
         mContext.registerReceiver(
                 new BroadcastReceiver() {
                     @Override
@@ -182,6 +184,14 @@
                         } else if (action.equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
                             mNetworkInfo = (NetworkInfo) intent.getParcelableExtra(
                                     WifiManager.EXTRA_NETWORK_INFO);
+                        } else if (action.equals(WifiManager.WIFI_AP_STATE_CHANGED_ACTION)) {
+                            int state = intent.getIntExtra(
+                                    WifiManager.EXTRA_WIFI_AP_STATE,
+                                    WifiManager.WIFI_AP_STATE_FAILED);
+                            if(state == WifiManager.WIFI_AP_STATE_FAILED) {
+                                loge(TAG + "SoftAP start failed");
+                                sendMessage(CMD_AP_START_FAILURE);
+                            }
                         }
                     }
                 },
@@ -371,6 +381,7 @@
                 case CMD_WIFI_TOGGLED:
                 case CMD_AIRPLANE_TOGGLED:
                 case CMD_EMERGENCY_MODE_CHANGED:
+                case CMD_AP_START_FAILURE:
                     break;
                 case CMD_USER_PRESENT:
                     mFirstUserSignOnSeen = true;
@@ -398,6 +409,7 @@
             mDisabledTimestamp = SystemClock.elapsedRealtime();
             mDeferredEnableSerialNumber++;
             mHaveDeferredEnable = false;
+            mWifiStateMachine.clearANQPCache();
         }
         @Override
         public boolean processMessage(Message msg) {
@@ -519,6 +531,7 @@
             mDisabledTimestamp = SystemClock.elapsedRealtime();
             mDeferredEnableSerialNumber++;
             mHaveDeferredEnable = false;
+            mWifiStateMachine.clearANQPCache();
         }
 
         @Override
@@ -607,6 +620,12 @@
                         transitionTo(mApStaDisabledState);
                     }
                     break;
+                case CMD_AP_START_FAILURE:
+                    if(!mSettingsStore.isScanAlwaysAvailable()) {
+                        transitionTo(mApStaDisabledState);
+                    } else {
+                        transitionTo(mStaDisabledWithScanState);
+                    }
                 default:
                     return NOT_HANDLED;
             }
diff --git a/service/java/com/android/server/wifi/WifiLogger.java b/service/java/com/android/server/wifi/WifiLogger.java
new file mode 100644
index 0000000..8add779
--- /dev/null
+++ b/service/java/com/android/server/wifi/WifiLogger.java
@@ -0,0 +1,450 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.server.wifi;
+
+import com.android.internal.app.IBatteryStats;
+import com.android.internal.util.Protocol;
+
+import android.support.v4.util.CircularArray;
+import android.util.Base64;
+import android.util.LocalLog;
+import android.util.Log;
+
+import java.io.ByteArrayOutputStream;
+import java.io.FileDescriptor;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.zip.Deflater;
+
+/**
+ * Tracks various logs for framework
+ */
+class WifiLogger  {
+
+    private static final String TAG = "WifiLogger";
+    private static final boolean DBG = false;
+
+    /** log level flags; keep these consistent with wifi_logger.h */
+
+    /** No logs whatsoever */
+    public static final int VERBOSE_NO_LOG = 0;
+    /** No logs whatsoever */
+    public static final int VERBOSE_NORMAL_LOG = 1;
+    /** Be careful since this one can affect performance and power */
+    public static final int VERBOSE_LOG_WITH_WAKEUP  = 2;
+    /** Be careful since this one can affect performance and power and memory */
+    public static final int VERBOSE_DETAILED_LOG_WITH_WAKEUP  = 3;
+
+    /** ring buffer flags; keep these consistent with wifi_logger.h */
+    public static final int RING_BUFFER_FLAG_HAS_BINARY_ENTRIES     = 0x00000001;
+    public static final int RING_BUFFER_FLAG_HAS_ASCII_ENTRIES      = 0x00000002;
+    public static final int RING_BUFFER_FLAG_HAS_PER_PACKET_ENTRIES = 0x00000004;
+
+    /** various reason codes */
+    public static final int REPORT_REASON_NONE                      = 0;
+    public static final int REPORT_REASON_ASSOC_FAILURE             = 1;
+    public static final int REPORT_REASON_AUTH_FAILURE              = 2;
+    public static final int REPORT_REASON_AUTOROAM_FAILURE          = 3;
+    public static final int REPORT_REASON_DHCP_FAILURE              = 4;
+    public static final int REPORT_REASON_UNEXPECTED_DISCONNECT     = 5;
+    public static final int REPORT_REASON_SCAN_FAILURE              = 6;
+    public static final int REPORT_REASON_USER_ACTION               = 7;
+
+    /** number of ring buffer entries to cache */
+    public static final int MAX_RING_BUFFERS                        = 10;
+
+    /** number of bug reports to hold */
+    public static final int MAX_BUG_REPORTS                         = 4;
+
+    /** number of alerts to hold */
+    public static final int MAX_ALERT_REPORTS                       = 1;
+
+    /** minimum wakeup interval for each of the log levels */
+    private static final int MinWakeupIntervals[] = new int[] { 0, 3600, 60, 10 };
+    /** minimum buffer size for each of the log levels */
+    private static final int MinBufferSizes[] = new int[] { 0, 16384, 16384, 65536 };
+
+    private int mLogLevel = VERBOSE_NO_LOG;
+    private String mFirmwareVersion;
+    private String mDriverVersion;
+    private int mSupportedFeatureSet;
+    private WifiNative.RingBufferStatus[] mRingBuffers;
+    private WifiNative.RingBufferStatus mPerPacketRingBuffer;
+    private WifiStateMachine mWifiStateMachine;
+
+    public WifiLogger(WifiStateMachine wifiStateMachine) {
+        mWifiStateMachine = wifiStateMachine;
+    }
+
+    public synchronized void startLogging(boolean verboseEnabled) {
+        mFirmwareVersion = WifiNative.getFirmwareVersion();
+        mDriverVersion = WifiNative.getDriverVersion();
+        mSupportedFeatureSet = WifiNative.getSupportedLoggerFeatureSet();
+
+        if (mLogLevel == VERBOSE_NO_LOG)
+            WifiNative.setLoggingEventHandler(mHandler);
+
+        if (verboseEnabled) {
+            mLogLevel = VERBOSE_LOG_WITH_WAKEUP;
+        } else {
+            mLogLevel = VERBOSE_NORMAL_LOG;
+        }
+        if (mRingBuffers == null) {
+            if (fetchRingBuffers()) {
+                startLoggingAllExceptPerPacketBuffers();
+            }
+        }
+    }
+
+    public synchronized void startPacketLog() {
+        if (mPerPacketRingBuffer != null) {
+            startLoggingRingBuffer(mPerPacketRingBuffer);
+        } else {
+            if (DBG) Log.d(TAG, "There is no per packet ring buffer");
+        }
+    }
+
+    public synchronized void stopPacketLog() {
+        if (mPerPacketRingBuffer != null) {
+            stopLoggingRingBuffer(mPerPacketRingBuffer);
+        } else {
+            if (DBG) Log.d(TAG, "There is no per packet ring buffer");
+        }
+    }
+
+    public synchronized void stopLogging() {
+        if (mLogLevel != VERBOSE_NO_LOG) {
+            //resetLogHandler only can be used when you terminate all logging since all handler will
+            //be removed. This also stop alert logging
+            if(!WifiNative.resetLogHandler()) {
+                Log.e(TAG, "Fail to reset log handler");
+            } else {
+                if (DBG) Log.d(TAG,"Reset log handler");
+            }
+            stopLoggingAllBuffers();
+            mRingBuffers = null;
+            mLogLevel = VERBOSE_NO_LOG;
+        }
+    }
+
+    public synchronized void captureBugReportData(int reason) {
+        BugReport report = captureBugreport(reason, true);
+        mLastBugReports.addLast(report);
+    }
+
+    public synchronized void captureAlertData(int errorCode, byte[] alertData) {
+        BugReport report = captureBugreport(errorCode, /* captureFWDump = */ true);
+        report.alertData = alertData;
+        mLastAlerts.addLast(report);
+    }
+
+    public synchronized void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+        pw.println("Chipset information :-----------------------------------------------");
+        pw.println("FW Version is: " + mFirmwareVersion);
+        pw.println("Driver Version is: " + mDriverVersion);
+        pw.println("Supported Feature set: " + mSupportedFeatureSet);
+
+        for (int i = 0; i < mLastAlerts.size(); i++) {
+            pw.println("--------------------------------------------------------------------");
+            pw.println("Alert dump " + i);
+            pw.print(mLastAlerts.get(i));
+            pw.println("--------------------------------------------------------------------");
+        }
+
+        for (int i = 0; i < mLastBugReports.size(); i++) {
+            pw.println("--------------------------------------------------------------------");
+            pw.println("Bug dump " + i);
+            pw.print(mLastBugReports.get(i));
+            pw.println("--------------------------------------------------------------------");
+        }
+
+        pw.println("--------------------------------------------------------------------");
+    }
+
+    /* private methods and data */
+    private static class BugReport {
+        long systemTimeMs;
+        long kernelTimeNanos;
+        int errorCode;
+        HashMap<String, byte[][]> ringBuffers = new HashMap();
+        byte[] fwMemoryDump;
+        byte[] alertData;
+
+        public String toString() {
+            StringBuilder builder = new StringBuilder();
+
+            Calendar c = Calendar.getInstance();
+            c.setTimeInMillis(systemTimeMs);
+            builder.append("system time = ").append(
+                    String.format("%tm-%td %tH:%tM:%tS.%tL", c, c, c, c, c, c)).append("\n");
+
+            long kernelTimeMs = kernelTimeNanos/(1000*1000);
+            builder.append("kernel time = ").append(kernelTimeMs/1000).append(".").append
+                    (kernelTimeMs%1000).append("\n");
+
+            if (alertData == null)
+                builder.append("reason = ").append(errorCode).append("\n");
+            else {
+                builder.append("errorCode = ").append(errorCode);
+                builder.append("data \n");
+                builder.append(compressToBase64(alertData)).append("\n");
+            }
+
+            for (HashMap.Entry<String, byte[][]> e : ringBuffers.entrySet()) {
+                String ringName = e.getKey();
+                byte[][] buffers = e.getValue();
+                builder.append("ring-buffer = ").append(ringName).append("\n");
+
+                int size = 0;
+                for (int i = 0; i < buffers.length; i++) {
+                    size += buffers[i].length;
+                }
+
+                byte[] buffer = new byte[size];
+                int index = 0;
+                for (int i = 0; i < buffers.length; i++) {
+                    System.arraycopy(buffers[i], 0, buffer, index, buffers[i].length);
+                    index += buffers[i].length;
+                }
+
+                builder.append(compressToBase64(buffer));
+                builder.append("\n");
+            }
+
+            if (fwMemoryDump != null) {
+                builder.append("FW Memory dump \n");
+                builder.append(compressToBase64(fwMemoryDump));
+            }
+
+            return builder.toString();
+        }
+    }
+
+    static class LimitedCircularArray<E> {
+        private CircularArray<E> mArray;
+        private int mMax;
+        LimitedCircularArray(int max) {
+            mArray = new CircularArray<E>();
+            mMax = max;
+        }
+
+        public final void addLast(E e) {
+            if (mArray.size() >= mMax)
+                mArray.popFirst();
+            mArray.addLast(e);
+        }
+
+        public final int size() {
+            return mArray.size();
+        }
+
+        public final E get(int i) {
+            return mArray.get(i);
+        }
+    }
+
+    private final LimitedCircularArray<BugReport> mLastAlerts =
+            new LimitedCircularArray<BugReport>(MAX_ALERT_REPORTS);
+    private final LimitedCircularArray<BugReport> mLastBugReports =
+            new LimitedCircularArray<BugReport>(MAX_BUG_REPORTS);
+    private final HashMap<String, LimitedCircularArray<byte[]>> mRingBufferData = new HashMap();
+
+    private final WifiNative.WifiLoggerEventHandler mHandler =
+            new WifiNative.WifiLoggerEventHandler() {
+        @Override
+        public void onRingBufferData(WifiNative.RingBufferStatus status, byte[] buffer) {
+            WifiLogger.this.onRingBufferData(status, buffer);
+        }
+
+        @Override
+        public void onWifiAlert(int errorCode, byte[] buffer) {
+            WifiLogger.this.onWifiAlert(errorCode, buffer);
+        }
+    };
+
+    synchronized void onRingBufferData(WifiNative.RingBufferStatus status, byte[] buffer) {
+        LimitedCircularArray<byte[]> ring = mRingBufferData.get(status.name);
+        if (ring != null) {
+            ring.addLast(buffer);
+        }
+    }
+
+    synchronized void onWifiAlert(int errorCode, byte[] buffer) {
+        if (mWifiStateMachine != null) {
+            mWifiStateMachine.sendMessage(
+                    WifiStateMachine.CMD_FIRMWARE_ALERT, errorCode, 0, buffer);
+        }
+    }
+
+    private boolean fetchRingBuffers() {
+        if (mRingBuffers != null) return true;
+
+        mRingBuffers = WifiNative.getRingBufferStatus();
+        if (mRingBuffers != null) {
+            for (WifiNative.RingBufferStatus buffer : mRingBuffers) {
+                if (DBG) Log.d(TAG, "RingBufferStatus is: \n" + buffer.name);
+                if (mRingBufferData.containsKey(buffer.name) == false) {
+                    mRingBufferData.put(buffer.name,
+                            new LimitedCircularArray<byte[]>(MAX_RING_BUFFERS));
+                }
+                if ((buffer.flag & RING_BUFFER_FLAG_HAS_PER_PACKET_ENTRIES) != 0) {
+                    mPerPacketRingBuffer = buffer;
+                }
+            }
+        } else {
+            Log.e(TAG, "no ring buffers found");
+        }
+
+        return mRingBuffers != null;
+    }
+
+    private boolean startLoggingAllExceptPerPacketBuffers() {
+
+        if (mRingBuffers == null) {
+            if (DBG) Log.d(TAG, "No ring buffers to log anything!");
+            return false;
+        }
+
+        for (WifiNative.RingBufferStatus buffer : mRingBuffers){
+
+            if ((buffer.flag & RING_BUFFER_FLAG_HAS_PER_PACKET_ENTRIES) != 0) {
+                /* skip per-packet-buffer */
+                if (DBG) Log.d(TAG, "skipped per packet logging ring " + buffer.name);
+                continue;
+            }
+
+            startLoggingRingBuffer(buffer);
+        }
+
+        return true;
+    }
+
+    private boolean startLoggingRingBuffer(WifiNative.RingBufferStatus buffer) {
+
+        int minInterval = MinWakeupIntervals[mLogLevel];
+        int minDataSize = MinBufferSizes[mLogLevel];
+
+        if (WifiNative.startLoggingRingBuffer(
+                mLogLevel, 0, minInterval, minDataSize, buffer.name) == false) {
+            if (DBG) Log.e(TAG, "Could not start logging ring " + buffer.name);
+            return false;
+        }
+
+        return true;
+    }
+
+    private boolean stopLoggingRingBuffer(WifiNative.RingBufferStatus buffer) {
+        if (WifiNative.startLoggingRingBuffer(0, 0, 0, 0, buffer.name) == false) {
+            if (DBG) Log.e(TAG, "Could not stop logging ring " + buffer.name);
+        }
+        return true;
+    }
+
+    private boolean stopLoggingAllBuffers() {
+        if (mRingBuffers != null) {
+            for (WifiNative.RingBufferStatus buffer : mRingBuffers) {
+                stopLoggingRingBuffer(buffer);
+            }
+        }
+        return true;
+    }
+
+    private boolean getAllRingBufferData() {
+        if (mRingBuffers == null) {
+            Log.e(TAG, "Not ring buffers available to collect data!");
+            return false;
+        }
+
+        for (WifiNative.RingBufferStatus element : mRingBuffers){
+            boolean result = WifiNative.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;
+    }
+
+    private BugReport captureBugreport(int errorCode, boolean captureFWDump) {
+        BugReport report = new BugReport();
+        report.errorCode = errorCode;
+        report.systemTimeMs = System.currentTimeMillis();
+        report.kernelTimeNanos = System.nanoTime();
+
+        if (mRingBuffers != null) {
+            for (WifiNative.RingBufferStatus buffer : mRingBuffers) {
+                /* this will push data in mRingBuffers */
+                WifiNative.getRingBufferData(buffer.name);
+                LimitedCircularArray<byte[]> data = mRingBufferData.get(buffer.name);
+                byte[][] buffers = new byte[data.size()][];
+                for (int i = 0; i < data.size(); i++) {
+                    buffers[i] = data.get(i).clone();
+                }
+                report.ringBuffers.put(buffer.name, buffers);
+            }
+        }
+
+        if (captureFWDump) {
+            report.fwMemoryDump = WifiNative.getFwMemoryDump();
+        }
+        return report;
+    }
+
+    private static String compressToBase64(byte[] input) {
+        String result;
+        //compress
+        Deflater compressor = new Deflater();
+        compressor.setLevel(Deflater.BEST_COMPRESSION);
+        compressor.setInput(input);
+        compressor.finish();
+        ByteArrayOutputStream bos = new ByteArrayOutputStream(input.length);
+        final byte[] buf = new byte[1024];
+
+        while (!compressor.finished()) {
+            int count = compressor.deflate(buf);
+            bos.write(buf, 0, count);
+        }
+
+        try {
+            compressor.end();
+            bos.close();
+        } catch (IOException e) {
+            Log.e(TAG, "ByteArrayOutputStream close error");
+            result =  android.util.Base64.encodeToString(input, Base64.DEFAULT);
+            return result;
+        }
+
+        byte[] compressed = bos.toByteArray();
+        if (DBG) {
+            Log.d(TAG," length is:" + (compressed == null? "0" : compressed.length));
+        }
+
+        //encode
+        result = android.util.Base64.encodeToString(
+                compressed.length < input.length ? compressed : input , Base64.DEFAULT);
+
+        if (DBG) {
+            Log.d(TAG, "FwMemoryDump length is :" + result.length());
+        }
+
+        return result;
+    }
+}
diff --git a/service/java/com/android/server/wifi/WifiMonitor.java b/service/java/com/android/server/wifi/WifiMonitor.java
index b807a92..9758d57 100644
--- a/service/java/com/android/server/wifi/WifiMonitor.java
+++ b/service/java/com/android/server/wifi/WifiMonitor.java
@@ -27,10 +27,11 @@
 import android.net.wifi.p2p.WifiP2pProvDiscEvent;
 import android.net.wifi.p2p.nsd.WifiP2pServiceResponse;
 import android.os.Message;
-import android.os.SystemClock;
 import android.text.TextUtils;
+import android.util.LocalLog;
 import android.util.Log;
 
+import com.android.server.wifi.hotspot2.Utils;
 import com.android.server.wifi.p2p.WifiP2pServiceImpl.P2pStatus;
 
 import com.android.internal.util.Protocol;
@@ -66,9 +67,10 @@
     private static final int ASSOC_REJECT = 9;
     private static final int SSID_TEMP_DISABLE = 10;
     private static final int SSID_REENABLE = 11;
-    private static final int BSS_ADDED = 12;
-    private static final int BSS_REMOVED = 13;
+    private static final int BSS_ADDED    = 12;
+    private static final int BSS_REMOVED  = 13;
     private static final int UNKNOWN      = 14;
+    private static final int SCAN_FAILED  = 15;
 
     /** All events coming from the supplicant start with this prefix */
     private static final String EVENT_PREFIX_STR = "CTRL-EVENT-";
@@ -158,6 +160,13 @@
 
     /**
      * <pre>
+     * CTRL-EVENT-SCAN-FAILED ret=code[ retry=1]
+     * </pre>
+     */
+    private static final String SCAN_FAILED_STR =  "SCAN-FAILED";
+
+    /**
+     * <pre>
      * CTRL-EVENT-LINK-SPEED x Mb/s
      * </pre>
      * {@code x} is the link speed in Mb/sec.
@@ -189,6 +198,10 @@
      */
     private static final String EAP_AUTH_FAILURE_STR = "EAP authentication failed";
 
+    /* EAP authentication timeout events */
+    private static final String AUTH_EVENT_PREFIX_STR = "Authentication with";
+    private static final String AUTH_TIMEOUT_STR = "timed out.";
+
     /**
      * This indicates an assoc reject event
      */
@@ -263,7 +276,7 @@
             Pattern.compile("Associated with ((?:[0-9a-f]{2}:){5}[0-9a-f]{2}).*");
 
     /**
-     * Regex pattern for extracting SSIDs from request identity string.
+     * Regex pattern for extracting an external GSM sim authentication request from a string.
      * Matches a strings like the following:<pre>
      * CTRL-REQ-SIM-<network id>:GSM-AUTH:<RAND1>:<RAND2>[:<RAND3>] needed for SSID <SSID>
      * This pattern should find
@@ -277,6 +290,19 @@
             Pattern.compile("SIM-([0-9]*):GSM-AUTH((:[0-9a-f]+)+) needed for SSID (.+)");
 
     /**
+     * Regex pattern for extracting an external 3G sim authentication request from a string.
+     * Matches a strings like the following:<pre>
+     * CTRL-REQ-SIM-<network id>:UMTS-AUTH:<RAND>:<AUTN> needed for SSID <SSID>
+     * This pattern should find
+     *    1 - id
+     *    2 - Rand
+     *    3 - Autn
+     *    4 - SSID
+     */
+    private static Pattern mRequestUmtsAuthPattern =
+            Pattern.compile("SIM-([0-9]*):UMTS-AUTH:([0-9a-f]+):([0-9a-f]+) needed for SSID (.+)");
+
+    /**
      * Regex pattern for extracting SSIDs from request identity string.
      * Matches a strings like the following:<pre>
      * CTRL-REQ-IDENTITY-xx:Identity needed for SSID XXXX</pre>
@@ -396,6 +422,7 @@
     private static final String AP_STA_CONNECTED_STR = "AP-STA-CONNECTED";
     /* AP-STA-DISCONNECTED 42:fc:89:a8:96:09 */
     private static final String AP_STA_DISCONNECTED_STR = "AP-STA-DISCONNECTED";
+    private static final String ANQP_DONE_STR = "ANQP-QUERY-DONE";
 
     /* Supplicant events reported to a state machine */
     private static final int BASE = Protocol.BASE_WIFI_MONITOR;
@@ -436,6 +463,8 @@
     /* Request SIM Auth */
     public static final int SUP_REQUEST_SIM_AUTH                 = BASE + 16;
 
+    public static final int SCAN_FAILED_EVENT                    = BASE + 17;
+
     /* P2P events */
     public static final int P2P_DEVICE_FOUND_EVENT               = BASE + 21;
     public static final int P2P_DEVICE_LOST_EVENT                = BASE + 22;
@@ -462,6 +491,7 @@
 
     /* Indicates assoc reject event */
     public static final int ASSOCIATION_REJECTION_EVENT          = BASE + 43;
+    public static final int ANQP_DONE_EVENT                      = BASE + 44;
 
     /* hotspot 2.0 ANQP events */
     public static final int GAS_QUERY_START_EVENT                = BASE + 51;
@@ -569,8 +599,8 @@
                     if (mWifiNative.connectToSupplicant()) {
                         m.mMonitoring = true;
                         m.mStateMachine.sendMessage(SUP_CONNECTION_EVENT);
-                        new MonitorThread(mWifiNative, this).start();
                         mConnected = true;
+                        new MonitorThread(mWifiNative, this).start();
                         break;
                     }
                     if (connectTries++ < 5) {
@@ -579,7 +609,6 @@
                         } catch (InterruptedException ignore) {
                         }
                     } else {
-                        mIfaceMap.remove(iface);
                         m.mStateMachine.sendMessage(SUP_DISCONNECTION_EVENT);
                         Log.e(TAG, "startMonitoring(" + iface + ") failed!");
                         break;
@@ -633,6 +662,7 @@
 
         private synchronized boolean dispatchEvent(String eventStr) {
             String iface;
+            // IFNAME=wlan0 ANQP-QUERY-DONE addr=18:cf:5e:26:a4:88 result=SUCCESS
             if (eventStr.startsWith("IFNAME=")) {
                 int space = eventStr.indexOf(' ');
                 if (space != -1) {
@@ -705,6 +735,7 @@
     private static class MonitorThread extends Thread {
         private final WifiNative mWifiNative;
         private final WifiMonitorSingleton mWifiMonitorSingleton;
+        private final LocalLog mLocalLog = WifiNative.getLocalLog();
 
         public MonitorThread(WifiNative wifiNative, WifiMonitorSingleton wifiMonitorSingleton) {
             super("WifiMonitor");
@@ -713,13 +744,23 @@
         }
 
         public void run() {
+            if (DBG) {
+                Log.d(TAG, "MonitorThread start with mConnected=" +
+                     mWifiMonitorSingleton.mConnected);
+            }
             //noinspection InfiniteLoopStatement
             for (;;) {
+                if (!mWifiMonitorSingleton.mConnected) {
+                    if (DBG) Log.d(TAG, "MonitorThread exit because mConnected is false");
+                    break;
+                }
                 String eventStr = mWifiNative.waitForEvent();
 
-                // Skip logging the common but mostly uninteresting scan-results event
-                if (DBG && eventStr.indexOf(SCAN_RESULTS_STR) == -1) {
-                    Log.d(TAG, "Event [" + eventStr + "]");
+                // Skip logging the common but mostly uninteresting events
+                if (eventStr.indexOf(BSS_ADDED_STR) == -1
+                        && eventStr.indexOf(BSS_REMOVED_STR) == -1) {
+                    if (DBG) Log.d(TAG, "Event [" + eventStr + "]");
+                    mLocalLog.log("Event [" + eventStr + "]");
                 }
 
                 if (mWifiMonitorSingleton.dispatchEvent(eventStr)) {
@@ -764,13 +805,20 @@
                 handleP2pEvents(eventStr);
             } else if (eventStr.startsWith(HOST_AP_EVENT_PREFIX_STR)) {
                 handleHostApEvents(eventStr);
-            } else if (eventStr.startsWith(GAS_QUERY_PREFIX_STR)) {
+            } else if (eventStr.startsWith(ANQP_DONE_STR)) {
+                try {
+                    handleAnqpResult(eventStr);
+                }
+                catch (IllegalArgumentException iae) {
+                    Log.e(TAG, "Bad ANQP event string: '" + eventStr + "': " + iae);
+                }
+            } else if (eventStr.startsWith(GAS_QUERY_PREFIX_STR)) {        // !!! clean >>End
                 handleGasQueryEvents(eventStr);
             } else if (eventStr.startsWith(RX_HS20_ANQP_ICON_STR)) {
                 if (mStateMachine2 != null)
                     mStateMachine2.sendMessage(RX_HS20_ANQP_ICON_EVENT,
                             eventStr.substring(RX_HS20_ANQP_ICON_STR_LEN + 1));
-            } else if (eventStr.startsWith(HS20_PREFIX_STR)) {
+            } else if (eventStr.startsWith(HS20_PREFIX_STR)) {                  // !!! <<End
                 handleHs20Events(eventStr);
             } else if (eventStr.startsWith(REQUEST_PREFIX_STR)) {
                 handleRequests(eventStr);
@@ -778,6 +826,9 @@
                 handleTargetBSSIDEvent(eventStr);
             } else if (eventStr.startsWith(ASSOCIATED_WITH_STR)) {
                 handleAssociatedBSSIDEvent(eventStr);
+            } else if (eventStr.startsWith(AUTH_EVENT_PREFIX_STR) &&
+                    eventStr.endsWith(AUTH_TIMEOUT_STR)) {
+                mStateMachine.sendMessage(AUTHENTICATION_FAILURE_EVENT);
             } else {
                 if (DBG) Log.w(TAG, "couldn't identify event type - " + eventStr);
             }
@@ -806,6 +857,8 @@
             event = STATE_CHANGE;
         else if (eventName.equals(SCAN_RESULTS_STR))
             event = SCAN_RESULTS;
+        else if (eventName.equals(SCAN_FAILED_STR))
+            event = SCAN_FAILED;
         else if (eventName.equals(LINK_SPEED_STR))
             event = LINK_SPEED;
         else if (eventName.equals(TERMINATING_STR))
@@ -824,8 +877,7 @@
             event = BSS_ADDED;
         } else if (eventName.equals(BSS_REMOVED_STR)) {
             event = BSS_REMOVED;
-        }
-        else
+        } else
             event = UNKNOWN;
 
         String eventData = eventStr;
@@ -958,6 +1010,10 @@
                 mStateMachine.sendMessage(SCAN_RESULTS_EVENT);
                 break;
 
+            case SCAN_FAILED:
+                mStateMachine.sendMessage(SCAN_FAILED_EVENT);
+                break;
+
             case UNKNOWN:
                 if (DBG) {
                     logDbg("handleEvent unknown: " + Integer.toString(event) + "  " + remainder);
@@ -1053,14 +1109,34 @@
         return err;
     }
 
+    WifiP2pDevice getWifiP2pDevice(String dataString) {
+        try {
+            WifiP2pDevice device = new WifiP2pDevice(dataString);
+            return device;
+        } catch (IllegalArgumentException e) {
+            return null;
+        }
+    }
+
+    WifiP2pGroup getWifiP2pGroup(String dataString) {
+        try {
+            WifiP2pGroup group = new WifiP2pGroup(dataString);
+            return group;
+        } catch (IllegalArgumentException e) {
+            return null;
+        }
+    }
+
     /**
      * Handle p2p events
      */
     private void handleP2pEvents(String dataString) {
         if (dataString.startsWith(P2P_DEVICE_FOUND_STR)) {
-            mStateMachine.sendMessage(P2P_DEVICE_FOUND_EVENT, new WifiP2pDevice(dataString));
+            WifiP2pDevice device = getWifiP2pDevice(dataString);
+            if (device != null) mStateMachine.sendMessage(P2P_DEVICE_FOUND_EVENT, device);
         } else if (dataString.startsWith(P2P_DEVICE_LOST_STR)) {
-            mStateMachine.sendMessage(P2P_DEVICE_LOST_EVENT, new WifiP2pDevice(dataString));
+            WifiP2pDevice device = getWifiP2pDevice(dataString);
+            if (device != null) mStateMachine.sendMessage(P2P_DEVICE_LOST_EVENT, device);
         } else if (dataString.startsWith(P2P_FIND_STOPPED_STR)) {
             mStateMachine.sendMessage(P2P_FIND_STOPPED_EVENT);
         } else if (dataString.startsWith(P2P_GO_NEG_REQUEST_STR)) {
@@ -1075,9 +1151,11 @@
         } else if (dataString.startsWith(P2P_GROUP_FORMATION_FAILURE_STR)) {
             mStateMachine.sendMessage(P2P_GROUP_FORMATION_FAILURE_EVENT, p2pError(dataString));
         } else if (dataString.startsWith(P2P_GROUP_STARTED_STR)) {
-            mStateMachine.sendMessage(P2P_GROUP_STARTED_EVENT, new WifiP2pGroup(dataString));
+            WifiP2pGroup group = getWifiP2pGroup(dataString);
+            if (group != null) mStateMachine.sendMessage(P2P_GROUP_STARTED_EVENT, group);
         } else if (dataString.startsWith(P2P_GROUP_REMOVED_STR)) {
-            mStateMachine.sendMessage(P2P_GROUP_REMOVED_EVENT, new WifiP2pGroup(dataString));
+            WifiP2pGroup group = getWifiP2pGroup(dataString);
+            if (group != null) mStateMachine.sendMessage(P2P_GROUP_REMOVED_EVENT, group);
         } else if (dataString.startsWith(P2P_INVITATION_RECEIVED_STR)) {
             mStateMachine.sendMessage(P2P_INVITATION_RECEIVED_EVENT,
                     new WifiP2pGroup(dataString));
@@ -1121,6 +1199,38 @@
         }
     }
 
+    private static final String ADDR_STRING = "addr=";
+    private static final String RESULT_STRING = "result=";
+
+    // ANQP-QUERY-DONE addr=18:cf:5e:26:a4:88 result=SUCCESS
+
+    private void handleAnqpResult(String eventStr) {
+        int addrPos = eventStr.indexOf(ADDR_STRING);
+        int resPos = eventStr.indexOf(RESULT_STRING);
+        if (addrPos < 0 || resPos < 0) {
+            throw new IllegalArgumentException("Unexpected ANQP result notification");
+        }
+        int eoaddr = eventStr.indexOf(' ', addrPos + ADDR_STRING.length());
+        if (eoaddr < 0) {
+            eoaddr = eventStr.length();
+        }
+        int eoresult = eventStr.indexOf(' ', resPos + RESULT_STRING.length());
+        if (eoresult < 0) {
+            eoresult = eventStr.length();
+        }
+
+        try {
+            long bssid = Utils.parseMac(eventStr.substring(addrPos + ADDR_STRING.length(), eoaddr));
+            int result = eventStr.substring(
+                    resPos + RESULT_STRING.length(), eoresult).equalsIgnoreCase("success") ? 1 : 0;
+
+            mStateMachine.sendMessage(ANQP_DONE_EVENT, result, 0, bssid);
+        }
+        catch (IllegalArgumentException iae) {
+            Log.e(TAG, "Bad MAC address in ANQP response: " + iae.getMessage());
+        }
+    }
+
     /**
      * Handle ANQP events
      */
@@ -1208,15 +1318,24 @@
                 Log.e(TAG, "didn't find SSID " + requestName);
             }
             mStateMachine.sendMessage(SUP_REQUEST_IDENTITY, eventLogCounter, reason, SSID);
-        } if (requestName.startsWith(SIM_STR)) {
-            Matcher match = mRequestGsmAuthPattern.matcher(requestName);
-            if (match.find()) {
-                WifiStateMachine.SimAuthRequestData data =
-                        new WifiStateMachine.SimAuthRequestData();
-                data.networkId = Integer.parseInt(match.group(1));
+        } else if (requestName.startsWith(SIM_STR)) {
+            Matcher matchGsm = mRequestGsmAuthPattern.matcher(requestName);
+            Matcher matchUmts = mRequestUmtsAuthPattern.matcher(requestName);
+            WifiStateMachine.SimAuthRequestData data =
+                    new WifiStateMachine.SimAuthRequestData();
+            if (matchGsm.find()) {
+                data.networkId = Integer.parseInt(matchGsm.group(1));
                 data.protocol = WifiEnterpriseConfig.Eap.SIM;
-                data.ssid = match.group(4);
-                data.challenges = match.group(2).split(":");
+                data.ssid = matchGsm.group(4);
+                data.data = matchGsm.group(2).split(":");
+                mStateMachine.sendMessage(SUP_REQUEST_SIM_AUTH, data);
+            } else if (matchUmts.find()) {
+                data.networkId = Integer.parseInt(matchUmts.group(1));
+                data.protocol = WifiEnterpriseConfig.Eap.AKA;
+                data.ssid = matchUmts.group(4);
+                data.data = new String[2];
+                data.data[0] = matchUmts.group(2);
+                data.data[1] = matchUmts.group(3);
                 mStateMachine.sendMessage(SUP_REQUEST_SIM_AUTH, data);
             } else {
                 Log.e(TAG, "couldn't parse SIM auth request - " + requestName);
diff --git a/service/java/com/android/server/wifi/WifiNative.java b/service/java/com/android/server/wifi/WifiNative.java
index b95db28..899529d 100644
--- a/service/java/com/android/server/wifi/WifiNative.java
+++ b/service/java/com/android/server/wifi/WifiNative.java
@@ -19,21 +19,35 @@
 import android.net.wifi.BatchedScanSettings;
 import android.net.wifi.RttManager;
 import android.net.wifi.ScanResult;
+import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiLinkLayerStats;
+import android.net.wifi.WifiManager;
 import android.net.wifi.WifiScanner;
+import android.net.wifi.RttManager;
+import android.net.wifi.WifiSsid;
 import android.net.wifi.WpsInfo;
 import android.net.wifi.p2p.WifiP2pConfig;
 import android.net.wifi.p2p.WifiP2pGroup;
+import android.net.wifi.p2p.nsd.WifiP2pServiceInfo;
+import android.net.wifi.WifiEnterpriseConfig;
 import android.os.SystemClock;
 import android.text.TextUtils;
-import android.net.wifi.p2p.nsd.WifiP2pServiceInfo;
+import android.util.Base64;
 import android.util.LocalLog;
 import android.util.Log;
 
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
+import java.nio.charset.CharacterCodingException;
+import java.nio.charset.CharsetDecoder;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
-
+import java.util.zip.Deflater;
+import libcore.util.HexEncoding;
 /**
  * Native calls for bring up/shut down of the supplicant daemon and for
  * sending requests to the supplicant daemon
@@ -65,6 +79,10 @@
 
     private boolean mSuspendOptEnabled = false;
 
+    private static final int EID_HT_OPERATION = 61;
+    private static final int EID_VHT_OPERATION = 192;
+    private static final int EID_EXTENDED_CAPS = 127;
+    private static final int RTT_RESP_ENABLE_BIT = 70;
     /* Register native functions */
 
     static {
@@ -122,12 +140,12 @@
         }
     }
 
-    private static final LocalLog mLocalLog = new LocalLog(1024);
+    private static final LocalLog mLocalLog = new LocalLog(16384);
 
     // hold mLock before accessing mCmdIdLock
     private static int sCmdId;
 
-    public LocalLog getLocalLog() {
+    public static LocalLog getLocalLog() {
         return mLocalLog;
     }
 
@@ -171,6 +189,16 @@
         }
     }
 
+    private boolean doBooleanCommandWithoutLogging(String command) {
+        if (DBG) Log.d(mTAG, "doBooleanCommandWithoutLogging: " + command);
+        synchronized (mLock) {
+            int cmdId = getNewCmdIdLocked();
+            boolean result = doBooleanCommandNative(mInterfacePrefix + command);
+            if (DBG) Log.d(mTAG, command + ": returned " + result);
+            return result;
+        }
+    }
+
     private int doIntCommand(String command) {
         if (DBG) Log.d(mTAG, "doInt: " + command);
         synchronized (mLock) {
@@ -267,7 +295,12 @@
 
     public boolean setNetworkVariable(int netId, String name, String value) {
         if (TextUtils.isEmpty(name) || TextUtils.isEmpty(value)) return false;
-        return doBooleanCommand("SET_NETWORK " + netId + " " + name + " " + value);
+        if (name.equals(WifiConfiguration.pskVarName)
+                || name.equals(WifiEnterpriseConfig.PASSWORD_KEY)) {
+            return doBooleanCommandWithoutLogging("SET_NETWORK " + netId + " " + name + " " + value);
+        } else {
+            return doBooleanCommand("SET_NETWORK " + netId + " " + name + " " + value);
+        }
     }
 
     public String getNetworkVariable(int netId, String name) {
@@ -308,6 +341,11 @@
         return doBooleanCommand("DISABLE_NETWORK " + netId);
     }
 
+    public boolean selectNetwork(int netId) {
+        if (DBG) logDbg("selectNetwork nid=" + Integer.toString(netId));
+        return doBooleanCommand("SELECT_NETWORK " + netId);
+    }
+
     public boolean reconnect() {
         if (DBG) logDbg("RECONNECT ");
         return doBooleanCommand("RECONNECT");
@@ -345,6 +383,8 @@
         return null;
     }
 
+
+
     /**
      * Format of results:
      * =================
@@ -361,9 +401,29 @@
      * RANGE=ALL gets all scan results
      * RANGE=ID- gets results from ID
      * MASK=<N> see wpa_supplicant/src/common/wpa_ctrl.h for details
+     * 0                         0                        1                       0     2
+     *                           WPA_BSS_MASK_MESH_SCAN | WPA_BSS_MASK_DELIM    | WPA_BSS_MASK_WIFI_DISPLAY
+     * 0                         0                        0                       1     1   -> 9
+     * WPA_BSS_MASK_INTERNETW  | WPA_BSS_MASK_P2P_SCAN  | WPA_BSS_MASK_WPS_SCAN | WPA_BSS_MASK_SSID
+     * 1                         0                        0                       1     9   -> d
+     * WPA_BSS_MASK_FLAGS      | WPA_BSS_MASK_IE        | WPA_BSS_MASK_AGE      | WPA_BSS_MASK_TSF
+     * 1                         0                        0                       0     8
+     * WPA_BSS_MASK_LEVEL      | WPA_BSS_MASK_NOISE     | WPA_BSS_MASK_QUAL     | WPA_BSS_MASK_CAPABILITIES
+     * 0                         1                        1                       1     7
+     * WPA_BSS_MASK_BEACON_INT | WPA_BSS_MASK_FREQ      | WPA_BSS_MASK_BSSID    | WPA_BSS_MASK_ID
+     *
+     * WPA_BSS_MASK_INTERNETW adds ANQP info (ctrl_iface:4151-4176)
+     *
+     * ctrl_iface.c:wpa_supplicant_ctrl_iface_process:7884
+     *  wpa_supplicant_ctrl_iface_bss:4315
+     *  print_bss_info
      */
     public String scanResults(int sid) {
-        return doStringCommandWithoutLogging("BSS RANGE=" + sid + "- MASK=0x21987");
+        return doStringCommandWithoutLogging("BSS RANGE=" + sid + "- MASK=0x29d87");
+    }
+
+    public String doCustomCommand(String command) {
+        return doStringCommand(command);
     }
 
     /**
@@ -510,22 +570,24 @@
             && doBooleanCommand("DRIVER RXFILTER-START");
     }
 
-    public int getBand() {
-       String ret = doStringCommand("DRIVER GETBAND");
-        if (!TextUtils.isEmpty(ret)) {
-            //reply is "BAND X" where X is the band
-            String[] tokens = ret.split(" ");
-            try {
-                if (tokens.length == 2) return Integer.parseInt(tokens[1]);
-            } catch (NumberFormatException e) {
-                return -1;
-            }
-        }
-        return -1;
-    }
-
+    /**
+     * Set the operational frequency band
+     * @param band One of
+     *     {@link WifiManager#WIFI_FREQUENCY_BAND_AUTO},
+     *     {@link WifiManager#WIFI_FREQUENCY_BAND_5GHZ},
+     *     {@link WifiManager#WIFI_FREQUENCY_BAND_2GHZ},
+     * @return {@code true} if the operation succeeded, {@code false} otherwise
+     */
     public boolean setBand(int band) {
-        return doBooleanCommand("DRIVER SETBAND " + band);
+        String bandstr;
+
+        if (band == WifiManager.WIFI_FREQUENCY_BAND_5GHZ)
+            bandstr = "5G";
+        else if (band == WifiManager.WIFI_FREQUENCY_BAND_2GHZ)
+            bandstr = "2G";
+        else
+            bandstr = "AUTO";
+        return doBooleanCommand("SET SETBAND " + bandstr);
     }
 
     /**
@@ -586,15 +648,20 @@
     }
 
     public boolean setCountryCode(String countryCode) {
-        return doBooleanCommand("DRIVER COUNTRY " + countryCode.toUpperCase(Locale.ROOT));
+        if (countryCode != null)
+            return doBooleanCommand("DRIVER COUNTRY " + countryCode.toUpperCase(Locale.ROOT));
+        else
+            return doBooleanCommand("DRIVER COUNTRY");
     }
 
-    public void enableBackgroundScan(boolean enable) {
+    public boolean enableBackgroundScan(boolean enable) {
+        boolean ret;
         if (enable) {
-            doBooleanCommand("SET pno 1");
+            ret = doBooleanCommand("SET pno 1");
         } else {
-            doBooleanCommand("SET pno 0");
+            ret = doBooleanCommand("SET pno 0");
         }
+        return ret;
     }
 
     public void enableAutoConnect(boolean enable) {
@@ -697,9 +764,16 @@
         }
     }
 
-    public boolean simAuthResponse(int id, String response) {
+    public boolean simAuthResponse(int id, String type, String response) {
+        // with type = GSM-AUTH, UMTS-AUTH or UMTS-AUTS
         synchronized (mLock) {
-            return doBooleanCommand("CTRL-RSP-SIM-" + id + ":GSM-AUTH" + response);
+            return doBooleanCommand("CTRL-RSP-SIM-" + id + ":" + type + response);
+        }
+    }
+
+    public boolean simIdentityResponse(int id, String response) {
+        synchronized (mLock) {
+            return doBooleanCommand("CTRL-RSP-IDENTITY-" + id + ":" + response);
         }
     }
 
@@ -1132,379 +1206,6 @@
         return doBooleanCommand("ANQP_GET " + bssid + " " + subtypes);
     }
 
-    /* WIFI HAL support */
-
-    private static final String TAG = "WifiNative-HAL";
-    private static long sWifiHalHandle = 0;  /* used by JNI to save wifi_handle */
-    private static long[] sWifiIfaceHandles = null;  /* used by JNI to save interface handles */
-    private static int sWlan0Index = -1;
-    private static int sP2p0Index = -1;
-
-    private static boolean sHalIsStarted = false;
-    private static boolean sHalFailed = false;
-
-    private static native boolean startHalNative();
-    private static native void stopHalNative();
-    private static native void waitForHalEventNative();
-
-    private static class MonitorThread extends Thread {
-        public void run() {
-            Log.i(TAG, "Waiting for HAL events mWifiHalHandle=" + Long.toString(sWifiHalHandle));
-            waitForHalEventNative();
-        }
-    }
-
-    synchronized public static boolean startHal() {
-        Log.i(TAG, "startHal");
-        synchronized (mLock) {
-            if (sHalIsStarted)
-                return true;
-            if (sHalFailed)
-                return false;
-            if (startHalNative() && (getInterfaces() != 0) && (sWlan0Index != -1)) {
-                new MonitorThread().start();
-                sHalIsStarted = true;
-                return true;
-            } else {
-                Log.i(TAG, "Could not start hal");
-                sHalIsStarted = false;
-                sHalFailed = true;
-                return false;
-            }
-        }
-    }
-
-    synchronized public static void stopHal() {
-        stopHalNative();
-    }
-
-    private static native int getInterfacesNative();
-
-    synchronized public static int getInterfaces() {
-        synchronized (mLock) {
-            if (sWifiIfaceHandles == null) {
-                int num = getInterfacesNative();
-                int wifi_num = 0;
-                for (int i = 0; i < num; i++) {
-                    String name = getInterfaceNameNative(i);
-                    Log.i(TAG, "interface[" + i + "] = " + name);
-                    if (name.equals("wlan0")) {
-                        sWlan0Index = i;
-                        wifi_num++;
-                    } else if (name.equals("p2p0")) {
-                        sP2p0Index = i;
-                        wifi_num++;
-                    }
-                }
-                return wifi_num;
-            } else {
-                return sWifiIfaceHandles.length;
-            }
-        }
-    }
-
-    private static native String getInterfaceNameNative(int index);
-    synchronized public static String getInterfaceName(int index) {
-        return getInterfaceNameNative(index);
-    }
-
-    public static class ScanCapabilities {
-        public int  max_scan_cache_size;                 // in number of scan results??
-        public int  max_scan_buckets;
-        public int  max_ap_cache_per_scan;
-        public int  max_rssi_sample_size;
-        public int  max_scan_reporting_threshold;        // in number of scan results??
-        public int  max_hotlist_aps;
-        public int  max_significant_wifi_change_aps;
-    }
-
-    public static boolean getScanCapabilities(ScanCapabilities capabilities) {
-        return getScanCapabilitiesNative(sWlan0Index, capabilities);
-    }
-
-    private static native boolean getScanCapabilitiesNative(
-            int iface, ScanCapabilities capabilities);
-
-    private static native boolean startScanNative(int iface, int id, ScanSettings settings);
-    private static native boolean stopScanNative(int iface, int id);
-    private static native ScanResult[] getScanResultsNative(int iface, boolean flush);
-    private static native WifiLinkLayerStats getWifiLinkLayerStatsNative(int iface);
-
-    public static class ChannelSettings {
-        int frequency;
-        int dwell_time_ms;
-        boolean passive;
-    }
-
-    public static class BucketSettings {
-        int bucket;
-        int band;
-        int period_ms;
-        int report_events;
-        int num_channels;
-        ChannelSettings channels[];
-    }
-
-    public static class ScanSettings {
-        int base_period_ms;
-        int max_ap_per_scan;
-        int report_threshold;
-        int num_buckets;
-        BucketSettings buckets[];
-    }
-
-    public static interface ScanEventHandler {
-        void onScanResultsAvailable();
-        void onFullScanResult(ScanResult fullScanResult);
-        void onSingleScanComplete();
-        void onScanPaused();
-        void onScanRestarted();
-    }
-
-    synchronized static void onScanResultsAvailable(int id) {
-        if (sScanEventHandler  != null) {
-            sScanEventHandler.onScanResultsAvailable();
-        }
-    }
-
-    /* scan status, keep these values in sync with gscan.h */
-    private static int WIFI_SCAN_BUFFER_FULL = 0;
-    private static int WIFI_SCAN_COMPLETE = 1;
-
-    synchronized static void onScanStatus(int status) {
-        Log.i(TAG, "Got a scan status changed event, status = " + status);
-
-        if (status == WIFI_SCAN_BUFFER_FULL) {
-            /* we have a separate event to take care of this */
-        } else if (status == WIFI_SCAN_COMPLETE) {
-            if (sScanEventHandler  != null) {
-                sScanEventHandler.onSingleScanComplete();
-            }
-        }
-    }
-
-    synchronized static void onFullScanResult(int id, ScanResult result, byte bytes[]) {
-        if (DBG) Log.i(TAG, "Got a full scan results event, ssid = " + result.SSID + ", " +
-                "num = " + bytes.length);
-
-        if (sScanEventHandler == null) {
-            return;
-        }
-
-        int num = 0;
-        for (int i = 0; i < bytes.length; ) {
-            int type  = bytes[i] & 0xFF;
-            int len = bytes[i + 1] & 0xFF;
-
-            if (i + len + 2 > bytes.length) {
-                Log.w(TAG, "bad length " + len + " of IE " + type + " from " + result.BSSID);
-                Log.w(TAG, "ignoring the rest of the IEs");
-                break;
-            }
-            num++;
-            i += len + 2;
-            if (DBG) Log.i(TAG, "bytes[" + i + "] = [" + type + ", " + len + "]" + ", " +
-                    "next = " + i);
-        }
-
-        ScanResult.InformationElement elements[] = new ScanResult.InformationElement[num];
-        for (int i = 0, index = 0; i < num; i++) {
-            int type  = bytes[index] & 0xFF;
-            int len = bytes[index + 1] & 0xFF;
-            if (DBG) Log.i(TAG, "index = " + index + ", type = " + type + ", len = " + len);
-            ScanResult.InformationElement elem = new ScanResult.InformationElement();
-            elem.id = type;
-            elem.bytes = new byte[len];
-            for (int j = 0; j < len; j++) {
-                elem.bytes[j] = bytes[index + j + 2];
-            }
-            elements[i] = elem;
-            index += (len + 2);
-        }
-
-        result.informationElements = elements;
-        sScanEventHandler.onFullScanResult(result);
-    }
-
-    private static int sScanCmdId = 0;
-    private static ScanEventHandler sScanEventHandler;
-    private static ScanSettings sScanSettings;
-
-    synchronized public static boolean startScan(
-            ScanSettings settings, ScanEventHandler eventHandler) {
-        synchronized (mLock) {
-
-            if (sScanCmdId != 0) {
-                stopScan();
-            } else if (sScanSettings != null || sScanEventHandler != null) {
-                /* current scan is paused; no need to stop it */
-            }
-
-            sScanCmdId = getNewCmdIdLocked();
-
-            sScanSettings = settings;
-            sScanEventHandler = eventHandler;
-
-            if (startScanNative(sWlan0Index, sScanCmdId, settings) == false) {
-                sScanEventHandler = null;
-                sScanSettings = null;
-                return false;
-            }
-
-            return true;
-        }
-    }
-
-    synchronized public static void stopScan() {
-        synchronized (mLock) {
-            stopScanNative(sWlan0Index, sScanCmdId);
-            sScanSettings = null;
-            sScanEventHandler = null;
-            sScanCmdId = 0;
-        }
-    }
-
-    synchronized public static void pauseScan() {
-        synchronized (mLock) {
-            if (sScanCmdId != 0 && sScanSettings != null && sScanEventHandler != null) {
-                Log.d(TAG, "Pausing scan");
-                stopScanNative(sWlan0Index, sScanCmdId);
-                sScanCmdId = 0;
-                sScanEventHandler.onScanPaused();
-            }
-        }
-    }
-
-    synchronized public static void restartScan() {
-        synchronized (mLock) {
-            if (sScanCmdId == 0 && sScanSettings != null && sScanEventHandler != null) {
-                Log.d(TAG, "Restarting scan");
-                startScan(sScanSettings, sScanEventHandler);
-                sScanEventHandler.onScanRestarted();
-            }
-        }
-    }
-
-    synchronized public static ScanResult[] getScanResults() {
-        synchronized (mLock) {
-            return getScanResultsNative(sWlan0Index, /* flush = */ false);
-        }
-    }
-
-    public static interface HotlistEventHandler {
-        void onHotlistApFound (ScanResult[]result);
-    }
-
-    private static int sHotlistCmdId = 0;
-    private static HotlistEventHandler sHotlistEventHandler;
-
-    private native static boolean setHotlistNative(int iface, int id,
-            WifiScanner.HotlistSettings settings);
-    private native static boolean resetHotlistNative(int iface, int id);
-
-    synchronized public static boolean setHotlist(WifiScanner.HotlistSettings settings,
-                                    HotlistEventHandler eventHandler) {
-        synchronized (mLock) {
-            if (sHotlistCmdId != 0) {
-                return false;
-            } else {
-                sHotlistCmdId = getNewCmdIdLocked();
-            }
-
-            sHotlistEventHandler = eventHandler;
-            if (setHotlistNative(sWlan0Index, sScanCmdId, settings) == false) {
-                sHotlistEventHandler = null;
-                return false;
-            }
-
-            return true;
-        }
-    }
-
-    synchronized public static void resetHotlist() {
-        synchronized (mLock) {
-            if (sHotlistCmdId != 0) {
-                resetHotlistNative(sWlan0Index, sHotlistCmdId);
-                sHotlistCmdId = 0;
-                sHotlistEventHandler = null;
-            }
-        }
-    }
-
-    synchronized public static void onHotlistApFound(int id, ScanResult[] results) {
-        synchronized (mLock) {
-            if (sHotlistCmdId != 0) {
-                sHotlistEventHandler.onHotlistApFound(results);
-            } else {
-                /* this can happen because of race conditions */
-                Log.d(TAG, "Ignoring hotlist AP found change");
-            }
-        }
-    }
-
-    public static interface SignificantWifiChangeEventHandler {
-        void onChangesFound(ScanResult[] result);
-    }
-
-    private static SignificantWifiChangeEventHandler sSignificantWifiChangeHandler;
-    private static int sSignificantWifiChangeCmdId;
-
-    private static native boolean trackSignificantWifiChangeNative(
-            int iface, int id, WifiScanner.WifiChangeSettings settings);
-    private static native boolean untrackSignificantWifiChangeNative(int iface, int id);
-
-    synchronized public static boolean trackSignificantWifiChange(
-            WifiScanner.WifiChangeSettings settings, SignificantWifiChangeEventHandler handler) {
-        synchronized (mLock) {
-            if (sSignificantWifiChangeCmdId != 0) {
-                return false;
-            } else {
-                sSignificantWifiChangeCmdId = getNewCmdIdLocked();
-            }
-
-            sSignificantWifiChangeHandler = handler;
-            if (trackSignificantWifiChangeNative(sWlan0Index, sScanCmdId, settings) == false) {
-                sSignificantWifiChangeHandler = null;
-                return false;
-            }
-
-            return true;
-        }
-    }
-
-    synchronized static void untrackSignificantWifiChange() {
-        synchronized (mLock) {
-            if (sSignificantWifiChangeCmdId != 0) {
-                untrackSignificantWifiChangeNative(sWlan0Index, sSignificantWifiChangeCmdId);
-                sSignificantWifiChangeCmdId = 0;
-                sSignificantWifiChangeHandler = null;
-            }
-        }
-    }
-
-    synchronized static void onSignificantWifiChange(int id, ScanResult[] results) {
-        synchronized (mLock) {
-            if (sSignificantWifiChangeCmdId != 0) {
-                sSignificantWifiChangeHandler.onChangesFound(results);
-            } else {
-                /* this can happen because of race conditions */
-                Log.d(TAG, "Ignoring significant wifi change");
-            }
-        }
-    }
-
-    synchronized public static WifiLinkLayerStats getWifiLinkLayerStats(String iface) {
-        // TODO: use correct iface name to Index translation
-        if (iface == null) return null;
-        synchronized (mLock) {
-            if (!sHalIsStarted)
-                startHal();
-            if (sHalIsStarted)
-                return getWifiLinkLayerStatsNative(sWlan0Index);
-        }
-        return null;
-    }
-
     /*
      * NFC-related calls
      */
@@ -1528,9 +1229,594 @@
         return doBooleanCommand("NFC_REPORT_HANDOVER RESP P2P " + requestMessage + " 00");
     }
 
+    /* WIFI HAL support */
+
+    private static final String TAG = "WifiNative-HAL";
+    private static long sWifiHalHandle = 0;             /* used by JNI to save wifi_handle */
+    private static long[] sWifiIfaceHandles = null;     /* used by JNI to save interface handles */
+    private static int sWlan0Index = -1;
+    private static int sP2p0Index = -1;
+    private static MonitorThread sThread;
+    private static final int STOP_HAL_TIMEOUT_MS = 1000;
+
+    private static native boolean startHalNative();
+    private static native void stopHalNative();
+    private static native void waitForHalEventNative();
+
+    private static class MonitorThread extends Thread {
+        public void run() {
+            Log.i(TAG, "Waiting for HAL events mWifiHalHandle=" + Long.toString(sWifiHalHandle));
+            waitForHalEventNative();
+        }
+    }
+
+    synchronized public static boolean startHal() {
+
+        String debugLog = "startHal stack: ";
+        java.lang.StackTraceElement[] elements = Thread.currentThread().getStackTrace();
+        for (int i = 2; i < elements.length && i <= 7; i++ ) {
+            debugLog = debugLog + " - " + elements[i].getMethodName();
+        }
+
+        mLocalLog.log(debugLog);
+
+        synchronized (mLock) {
+            if (startHalNative() && (getInterfaces() != 0) && (sWlan0Index != -1)) {
+                sThread = new MonitorThread();
+                sThread.start();
+                return true;
+            } else {
+                if (DBG) mLocalLog.log("Could not start hal");
+                Log.e(TAG, "Could not start hal");
+                return false;
+            }
+        }
+    }
+
+    synchronized public static void stopHal() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                stopHalNative();
+                try {
+                    sThread.join(STOP_HAL_TIMEOUT_MS);
+                    Log.d(TAG, "HAL event thread stopped successfully");
+                } catch (InterruptedException e) {
+                    Log.e(TAG, "Could not stop HAL cleanly");
+                }
+                sThread = null;
+                sWifiHalHandle = 0;
+                sWifiIfaceHandles = null;
+                sWlan0Index = -1;
+                sP2p0Index = -1;
+            }
+        }
+    }
+
+    public static boolean isHalStarted() {
+        return (sWifiHalHandle != 0);
+    }
+    private static native int getInterfacesNative();
+
+    synchronized public static int getInterfaces() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if (sWifiIfaceHandles == null) {
+                    int num = getInterfacesNative();
+                    int wifi_num = 0;
+                    for (int i = 0; i < num; i++) {
+                        String name = getInterfaceNameNative(i);
+                        Log.i(TAG, "interface[" + i + "] = " + name);
+                        if (name.equals("wlan0")) {
+                            sWlan0Index = i;
+                            wifi_num++;
+                        } else if (name.equals("p2p0")) {
+                            sP2p0Index = i;
+                            wifi_num++;
+                        }
+                    }
+                    return wifi_num;
+                } else {
+                    return sWifiIfaceHandles.length;
+                }
+            } else {
+                return 0;
+            }
+        }
+    }
+
+    private static native String getInterfaceNameNative(int index);
+    synchronized public static String getInterfaceName(int index) {
+        return getInterfaceNameNative(index);
+    }
+
+    public static class ScanCapabilities {
+        public int  max_scan_cache_size;                 // in number of scan results??
+        public int  max_scan_buckets;
+        public int  max_ap_cache_per_scan;
+        public int  max_rssi_sample_size;
+        public int  max_scan_reporting_threshold;        // in number of scan results??
+        public int  max_hotlist_bssids;
+        public int  max_significant_wifi_change_aps;
+    }
+
+    synchronized public static boolean getScanCapabilities(ScanCapabilities capabilities) {
+        synchronized (mLock) {
+            return isHalStarted() && getScanCapabilitiesNative(sWlan0Index, capabilities);
+        }
+    }
+
+    private static native boolean getScanCapabilitiesNative(
+            int iface, ScanCapabilities capabilities);
+
+    private static native boolean startScanNative(int iface, int id, ScanSettings settings);
+    private static native boolean stopScanNative(int iface, int id);
+    private static native WifiScanner.ScanData[] getScanResultsNative(int iface, boolean flush);
+    private static native WifiLinkLayerStats getWifiLinkLayerStatsNative(int iface);
+    private static native void setWifiLinkLayerStatsNative(int iface, int enable);
+
+    public static class ChannelSettings {
+        int frequency;
+        int dwell_time_ms;
+        boolean passive;
+    }
+
+    public static class BucketSettings {
+        int bucket;
+        int band;
+        int period_ms;
+        int report_events;
+        int num_channels;
+        ChannelSettings channels[];
+    }
+
+    public static class ScanSettings {
+        int base_period_ms;
+        int max_ap_per_scan;
+        int report_threshold_percent;
+        int report_threshold_num_scans;
+        int num_buckets;
+        BucketSettings buckets[];
+    }
+
+    public static interface ScanEventHandler {
+        void onScanResultsAvailable();
+        void onFullScanResult(ScanResult fullScanResult);
+        void onScanStatus();
+        void onScanPaused(WifiScanner.ScanData[] data);
+        void onScanRestarted();
+    }
+
+    synchronized static void onScanResultsAvailable(int id) {
+        if (sScanEventHandler  != null) {
+            sScanEventHandler.onScanResultsAvailable();
+        }
+    }
+
+    /* scan status, keep these values in sync with gscan.h */
+    private static int WIFI_SCAN_BUFFER_FULL = 0;
+    private static int WIFI_SCAN_COMPLETE = 1;
+
+    synchronized static void onScanStatus(int status) {
+        if (status == WIFI_SCAN_BUFFER_FULL) {
+            /* we have a separate event to take care of this */
+        } else if (status == WIFI_SCAN_COMPLETE) {
+            if (sScanEventHandler  != null) {
+                sScanEventHandler.onScanStatus();
+            }
+        }
+    }
+
+    public static  WifiSsid createWifiSsid (byte[] rawSsid) {
+        String ssidHexString = String.valueOf(HexEncoding.encode(rawSsid));
+
+        if (ssidHexString == null) {
+            return null;
+        }
+
+        WifiSsid wifiSsid = WifiSsid.createFromHex(ssidHexString);
+
+        return wifiSsid;
+    }
+
+    public static String ssidConvert(byte[] rawSsid) {
+        String ssid;
+
+        CharsetDecoder decoder = StandardCharsets.UTF_8.newDecoder();
+        try {
+            CharBuffer decoded = decoder.decode(ByteBuffer.wrap(rawSsid));
+            ssid = decoded.toString();
+        } catch (CharacterCodingException cce) {
+            ssid = null;
+        }
+
+        if (ssid == null) {
+            ssid = new String(rawSsid, StandardCharsets.ISO_8859_1);
+        }
+
+        return ssid;
+    }
+
+    public static boolean setSsid(byte[] rawSsid, ScanResult result) {
+        if (rawSsid == null || rawSsid.length == 0 || result == null) {
+            return false;
+        }
+
+        result.SSID = ssidConvert(rawSsid);
+        result.wifiSsid = createWifiSsid(rawSsid);
+        return true;
+    }
+
+    static void populateScanResult(ScanResult result, byte bytes[], String dbg) {
+        int num = 0;
+        if (bytes == null) return;
+        if (dbg == null) dbg = "";
+        for (int i = 0; i < bytes.length - 1; ) {
+            int type  = bytes[i] & 0xFF;
+            int len = bytes[i + 1] & 0xFF;
+            if (i + len + 2 > bytes.length) {
+                Log.w(TAG, dbg + "bad length " + len + " of IE " + type + " from " + result.BSSID);
+                Log.w(TAG, dbg + "ignoring the rest of the IEs");
+                break;
+            }
+            num++;
+            if (DBG) Log.i(TAG, dbg + "bytes[" + i + "] = [" + type + ", " + len + "]" + ", " +
+                    "next = " + (i + len + 2));
+            i += len + 2;
+        }
+
+        int secondChanelOffset = 0;
+        byte channelMode = 0;
+        byte centerFreqIndex1 = 0;
+        byte centerFreqIndex2 = 0;
+
+        boolean is80211McRTTResponder = false;
+
+        ScanResult.InformationElement elements[] = new ScanResult.InformationElement[num];
+        for (int i = 0, index = 0; i < num; i++) {
+            int type  = bytes[index] & 0xFF;
+            int len = bytes[index + 1] & 0xFF;
+            if (DBG) Log.i(TAG, dbg + "index = " + index + ", type = " + type + ", len = " + len);
+            ScanResult.InformationElement elem = new ScanResult.InformationElement();
+            elem.id = type;
+            elem.bytes = new byte[len];
+            for (int j = 0; j < len; j++) {
+                elem.bytes[j] = bytes[index + j + 2];
+            }
+            elements[i] = elem;
+            int inforStart = index + 2;
+            index += (len + 2);
+
+            if(type == EID_HT_OPERATION) {
+                secondChanelOffset = bytes[inforStart + 1] & 0x3;
+            } else if(type == EID_VHT_OPERATION) {
+                channelMode = bytes[inforStart];
+                centerFreqIndex1 = bytes[inforStart + 1];
+                centerFreqIndex2 = bytes[inforStart + 2];
+            } else if (type == EID_EXTENDED_CAPS) {
+                int tempIndex = RTT_RESP_ENABLE_BIT / 8;
+                byte offset = RTT_RESP_ENABLE_BIT % 8;
+
+                if(len < tempIndex + 1) {
+                    is80211McRTTResponder = false;
+                } else {
+                    if ((bytes[inforStart + tempIndex] & ((byte)0x1 << offset)) != 0) {
+                        is80211McRTTResponder = true;
+                    } else {
+                        is80211McRTTResponder = false;
+                    }
+                }
+            }
+        }
+
+        if (is80211McRTTResponder) {
+            result.setFlag(ScanResult.FLAG_80211mc_RESPONDER);
+        } else {
+            result.clearFlag(ScanResult.FLAG_80211mc_RESPONDER);
+        }
+
+        //handle RTT related information
+        if (channelMode != 0) {
+            // 80 or 160 MHz
+            result.channelWidth = channelMode + 1;
+
+            //convert channel index to frequency in MHz, channel 36 is 5180MHz
+            result.centerFreq0 = (centerFreqIndex1 - 36) * 5 + 5180;
+
+            if(channelMode > 1) { //160MHz
+                result.centerFreq1 = (centerFreqIndex2 - 36) * 5 + 5180;
+            } else {
+                result.centerFreq1 = 0;
+            }
+        } else {
+            //20 or 40 MHz
+            if (secondChanelOffset != 0) {//40MHz
+                result.channelWidth = 1;
+                if (secondChanelOffset == 1) {
+                    result.centerFreq0 = result.frequency + 20;
+                } else if (secondChanelOffset == 3) {
+                    result.centerFreq0 = result.frequency - 20;
+                } else {
+                    result.centerFreq0 = 0;
+                    Log.e(TAG, dbg + ": Error on secondChanelOffset");
+                }
+            } else {
+                result.centerFreq0  = 0;
+                result.centerFreq1  = 0;
+            }
+            result.centerFreq1  = 0;
+        }
+        if(DBG) {
+            Log.d(TAG, dbg + "SSID: " + result.SSID + " ChannelWidth is: " + result.channelWidth +
+                    " PrimaryFreq: " + result.frequency +" mCenterfreq0: " + result.centerFreq0 +
+                    " mCenterfreq1: " + result.centerFreq1 + (is80211McRTTResponder ?
+                    "Support RTT reponder: " : "Do not support RTT responder"));
+        }
+
+        result.informationElements = elements;
+    }
+
+    synchronized static void onFullScanResult(int id, ScanResult result, byte bytes[]) {
+        if (DBG) Log.i(TAG, "Got a full scan results event, ssid = " + result.SSID + ", " +
+                "num = " + bytes.length);
+
+        if (sScanEventHandler == null) {
+            return;
+        }
+        populateScanResult(result, bytes, " onFullScanResult ");
+
+        sScanEventHandler.onFullScanResult(result);
+    }
+
+    private static int sScanCmdId = 0;
+    private static ScanEventHandler sScanEventHandler;
+    private static ScanSettings sScanSettings;
+
+    synchronized public static boolean startScan(
+            ScanSettings settings, ScanEventHandler eventHandler) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+
+                if (sScanCmdId != 0) {
+                    stopScan();
+                } else if (sScanSettings != null || sScanEventHandler != null) {
+                /* current scan is paused; no need to stop it */
+                }
+
+                sScanCmdId = getNewCmdIdLocked();
+
+                sScanSettings = settings;
+                sScanEventHandler = eventHandler;
+
+                if (startScanNative(sWlan0Index, sScanCmdId, settings) == false) {
+                    sScanEventHandler = null;
+                    sScanSettings = null;
+                    sScanCmdId = 0;
+                    return false;
+                }
+
+                return true;
+            } else {
+                return false;
+            }
+        }
+    }
+
+    synchronized public static void stopScan() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                stopScanNative(sWlan0Index, sScanCmdId);
+                sScanSettings = null;
+                sScanEventHandler = null;
+                sScanCmdId = 0;
+            }
+        }
+    }
+
+    synchronized public static void pauseScan() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if (sScanCmdId != 0 && sScanSettings != null && sScanEventHandler != null) {
+                    Log.d(TAG, "Pausing scan");
+                    WifiScanner.ScanData scanData[] = getScanResultsNative(sWlan0Index, true);
+                    stopScanNative(sWlan0Index, sScanCmdId);
+                    sScanCmdId = 0;
+                    sScanEventHandler.onScanPaused(scanData);
+                }
+            }
+        }
+    }
+
+    synchronized public static void restartScan() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if (sScanCmdId == 0 && sScanSettings != null && sScanEventHandler != null) {
+                    Log.d(TAG, "Restarting scan");
+                    ScanEventHandler handler = sScanEventHandler;
+                    ScanSettings settings = sScanSettings;
+                    if (startScan(sScanSettings, sScanEventHandler)) {
+                        sScanEventHandler.onScanRestarted();
+                    } else {
+                    /* we are still paused; don't change state */
+                        sScanEventHandler = handler;
+                        sScanSettings = settings;
+                    }
+                }
+            }
+        }
+    }
+
+    synchronized public static WifiScanner.ScanData[] getScanResults(boolean flush) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return getScanResultsNative(sWlan0Index, flush);
+            } else {
+                return null;
+            }
+        }
+    }
+
+    public static interface HotlistEventHandler {
+        void onHotlistApFound (ScanResult[] result);
+        void onHotlistApLost  (ScanResult[] result);
+    }
+
+    private static int sHotlistCmdId = 0;
+    private static HotlistEventHandler sHotlistEventHandler;
+
+    private native static boolean setHotlistNative(int iface, int id,
+            WifiScanner.HotlistSettings settings);
+    private native static boolean resetHotlistNative(int iface, int id);
+
+    synchronized public static boolean setHotlist(WifiScanner.HotlistSettings settings,
+                                    HotlistEventHandler eventHandler) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if (sHotlistCmdId != 0) {
+                    return false;
+                } else {
+                    sHotlistCmdId = getNewCmdIdLocked();
+                }
+
+                sHotlistEventHandler = eventHandler;
+                if (setHotlistNative(sWlan0Index, sHotlistCmdId, settings) == false) {
+                    sHotlistEventHandler = null;
+                    return false;
+                }
+
+                return true;
+            } else {
+                return false;
+            }
+        }
+    }
+
+    synchronized public static void resetHotlist() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if (sHotlistCmdId != 0) {
+                    resetHotlistNative(sWlan0Index, sHotlistCmdId);
+                    sHotlistCmdId = 0;
+                    sHotlistEventHandler = null;
+                }
+            }
+        }
+    }
+
+    synchronized public static void onHotlistApFound(int id, ScanResult[] results) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if (sHotlistCmdId != 0) {
+                    sHotlistEventHandler.onHotlistApFound(results);
+                } else {
+                /* this can happen because of race conditions */
+                    Log.d(TAG, "Ignoring hotlist AP found event");
+                }
+            }
+        }
+    }
+
+    synchronized public static void onHotlistApLost(int id, ScanResult[] results) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if (sHotlistCmdId != 0) {
+                    sHotlistEventHandler.onHotlistApLost(results);
+                } else {
+                /* this can happen because of race conditions */
+                    Log.d(TAG, "Ignoring hotlist AP lost event");
+                }
+            }
+        }
+    }
+
+    public static interface SignificantWifiChangeEventHandler {
+        void onChangesFound(ScanResult[] result);
+    }
+
+    private static SignificantWifiChangeEventHandler sSignificantWifiChangeHandler;
+    private static int sSignificantWifiChangeCmdId;
+
+    private static native boolean trackSignificantWifiChangeNative(
+            int iface, int id, WifiScanner.WifiChangeSettings settings);
+    private static native boolean untrackSignificantWifiChangeNative(int iface, int id);
+
+    synchronized public static boolean trackSignificantWifiChange(
+            WifiScanner.WifiChangeSettings settings, SignificantWifiChangeEventHandler handler) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if (sSignificantWifiChangeCmdId != 0) {
+                    return false;
+                } else {
+                    sSignificantWifiChangeCmdId = getNewCmdIdLocked();
+                }
+
+                sSignificantWifiChangeHandler = handler;
+                if (trackSignificantWifiChangeNative(sWlan0Index, sScanCmdId, settings) == false) {
+                    sSignificantWifiChangeHandler = null;
+                    return false;
+                }
+
+                return true;
+            } else {
+                return false;
+            }
+
+        }
+    }
+
+    synchronized static void untrackSignificantWifiChange() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if (sSignificantWifiChangeCmdId != 0) {
+                    untrackSignificantWifiChangeNative(sWlan0Index, sSignificantWifiChangeCmdId);
+                    sSignificantWifiChangeCmdId = 0;
+                    sSignificantWifiChangeHandler = null;
+                }
+            }
+        }
+    }
+
+    synchronized static void onSignificantWifiChange(int id, ScanResult[] results) {
+        synchronized (mLock) {
+            if (sSignificantWifiChangeCmdId != 0) {
+                sSignificantWifiChangeHandler.onChangesFound(results);
+            } else {
+            /* this can happen because of race conditions */
+                Log.d(TAG, "Ignoring significant wifi change");
+            }
+        }
+    }
+
+    synchronized public static WifiLinkLayerStats getWifiLinkLayerStats(String iface) {
+        // TODO: use correct iface name to Index translation
+        if (iface == null) return null;
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return getWifiLinkLayerStatsNative(sWlan0Index);
+            } else {
+                return null;
+            }
+        }
+    }
+
+    synchronized public static void setWifiLinkLayerStats(String iface, int enable) {
+        if (iface == null) return;
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                setWifiLinkLayerStatsNative(sWlan0Index, enable);
+            }
+        }
+    }
+
     public static native int getSupportedFeatureSetNative(int iface);
     synchronized public static int getSupportedFeatureSet() {
-        return getSupportedFeatureSetNative(sWlan0Index);
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return getSupportedFeatureSetNative(sWlan0Index);
+            } else {
+                Log.d(TAG, "Failing getSupportedFeatureset because HAL isn't started");
+                return 0;
+            }
+        }
     }
 
     /* Rtt related commands/events */
@@ -1547,7 +1833,7 @@
             sRttEventHandler.onRttResults(results);
             sRttCmdId = 0;
         } else {
-            Log.d(TAG, "Received event for unknown cmd = " + id + ", current id = " + sRttCmdId);
+            Log.d(TAG, "RTT Received event for unknown cmd = " + id + ", current id = " + sRttCmdId);
         }
     }
 
@@ -1559,25 +1845,39 @@
     synchronized public static boolean requestRtt(
             RttManager.RttParams[] params, RttEventHandler handler) {
         synchronized (mLock) {
-            if (sRttCmdId != 0) {
-                return false;
+            if (isHalStarted()) {
+                if (sRttCmdId != 0) {
+                    Log.v("TAG", "Last one is still under measurement!");
+                    return false;
+                } else {
+                    sRttCmdId = getNewCmdIdLocked();
+                }
+                sRttEventHandler = handler;
+                Log.v(TAG, "native issue RTT request");
+                return requestRangeNative(sWlan0Index, sRttCmdId, params);
             } else {
-                sRttCmdId = getNewCmdIdLocked();
+                return false;
             }
-            sRttEventHandler = handler;
-            return requestRangeNative(sWlan0Index, sRttCmdId, params);
         }
     }
 
     synchronized public static boolean cancelRtt(RttManager.RttParams[] params) {
         synchronized(mLock) {
-            if (sRttCmdId == 0) {
-                return false;
-            }
+            if (isHalStarted()) {
+                if (sRttCmdId == 0) {
+                    return false;
+                }
 
-            if (cancelRangeRequestNative(sWlan0Index, sRttCmdId, params)) {
-                sRttEventHandler = null;
-                return true;
+                sRttCmdId = 0;
+
+                if (cancelRangeRequestNative(sWlan0Index, sRttCmdId, params)) {
+                    sRttEventHandler = null;
+                    Log.v(TAG, "RTT cancel Request Successfully");
+                    return true;
+                } else {
+                    Log.e(TAG, "RTT cancel Request failed");
+                    return false;
+                }
             } else {
                 return false;
             }
@@ -1588,7 +1888,7 @@
 
     synchronized public static boolean setScanningMacOui(byte[] oui) {
         synchronized (mLock) {
-            if (startHal()) {
+            if (isHalStarted()) {
                 return setScanningMacOuiNative(sWlan0Index, oui);
             } else {
                 return false;
@@ -1601,11 +1901,494 @@
 
     synchronized public static int [] getChannelsForBand(int band) {
         synchronized (mLock) {
-            if (startHal()) {
+            if (isHalStarted()) {
                 return getChannelsForBandNative(sWlan0Index, band);
+	    } else {
+                return null;
+            }
+        }
+    }
+
+    private static native boolean isGetChannelsForBandSupportedNative();
+    synchronized public static boolean isGetChannelsForBandSupported(){
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return isGetChannelsForBandSupportedNative();
+	    } else {
+                return false;
+            }
+        }
+    }
+
+    private static native boolean setDfsFlagNative(int iface, boolean dfsOn);
+    synchronized public static boolean setDfsFlag(boolean dfsOn) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return setDfsFlagNative(sWlan0Index, dfsOn);
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private static native boolean toggleInterfaceNative(int on);
+    synchronized public static boolean toggleInterface(int on) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return toggleInterfaceNative(0);
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private static native RttManager.RttCapabilities getRttCapabilitiesNative(int iface);
+    synchronized public static RttManager.RttCapabilities getRttCapabilities() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return getRttCapabilitiesNative(sWlan0Index);
+            }else {
+                return null;
+            }
+        }
+    }
+
+    private static native boolean setCountryCodeHalNative(int iface, String CountryCode);
+    synchronized public static boolean setCountryCodeHal( String CountryCode) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return setCountryCodeHalNative(sWlan0Index, CountryCode);
+            } else {
+                return false;
+            }
+        }
+    }
+
+    /* Rtt related commands/events */
+    public abstract class TdlsEventHandler {
+        abstract public void onTdlsStatus(String macAddr, int status, int reason);
+    }
+
+    private static TdlsEventHandler sTdlsEventHandler;
+
+    private static native boolean enableDisableTdlsNative(int iface, boolean enable,
+            String macAddr);
+    synchronized public static boolean enableDisableTdls(boolean enable, String macAdd,
+            TdlsEventHandler tdlsCallBack) {
+        synchronized (mLock) {
+            sTdlsEventHandler = tdlsCallBack;
+            return enableDisableTdlsNative(sWlan0Index, enable, macAdd);
+        }
+    }
+
+    // Once TDLS per mac and event feature is implemented, this class definition should be
+    // moved to the right place, like WifiManager etc
+    public static class TdlsStatus {
+        int channel;
+        int global_operating_class;
+        int state;
+        int reason;
+    }
+    private static native TdlsStatus getTdlsStatusNative(int iface, String macAddr);
+    synchronized public static TdlsStatus getTdlsStatus (String macAdd) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return getTdlsStatusNative(sWlan0Index, macAdd);
             } else {
                 return null;
             }
         }
     }
+
+    //ToFix: Once TDLS per mac and event feature is implemented, this class definition should be
+    // moved to the right place, like WifiStateMachine etc
+    public static class TdlsCapabilities {
+        /* Maximum TDLS session number can be supported by the Firmware and hardware */
+        int maxConcurrentTdlsSessionNumber;
+        boolean isGlobalTdlsSupported;
+        boolean isPerMacTdlsSupported;
+        boolean isOffChannelTdlsSupported;
+    }
+
+
+
+    private static native TdlsCapabilities getTdlsCapabilitiesNative(int iface);
+    synchronized public static TdlsCapabilities getTdlsCapabilities () {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return getTdlsCapabilitiesNative(sWlan0Index);
+            } else {
+                return null;
+            }
+        }
+    }
+
+    synchronized private static boolean onTdlsStatus(String macAddr, int status, int reason) {
+         if (sTdlsEventHandler == null) {
+             return false;
+         } else {
+             sTdlsEventHandler.onTdlsStatus(macAddr, status, reason);
+             return true;
+         }
+    }
+
+    //---------------------------------------------------------------------------------
+
+    /* Wifi Logger commands/events */
+
+    public static native boolean startLogging(int iface);
+
+    public static interface WifiLoggerEventHandler {
+        void onRingBufferData(RingBufferStatus status, byte[] buffer);
+        void onWifiAlert(int errorCode, byte[] buffer);
+    }
+
+    private static WifiLoggerEventHandler sWifiLoggerEventHandler = null;
+
+    private static void onRingBufferData(RingBufferStatus status, byte[] buffer) {
+        if (sWifiLoggerEventHandler != null)
+            sWifiLoggerEventHandler.onRingBufferData(status, buffer);
+    }
+
+    private static void onWifiAlert(byte[] buffer, int errorCode) {
+        if (sWifiLoggerEventHandler != null)
+            sWifiLoggerEventHandler.onWifiAlert(errorCode, buffer);
+    }
+
+    private static int sLogCmdId = -1;
+    private static native boolean setLoggingEventHandlerNative(int iface, int id);
+    synchronized public static boolean setLoggingEventHandler(WifiLoggerEventHandler handler) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                int oldId =  sLogCmdId;
+                sLogCmdId = getNewCmdIdLocked();
+                if (!setLoggingEventHandlerNative(sWlan0Index, sLogCmdId)) {
+                    sLogCmdId = oldId;
+                    return false;
+                }
+                sWifiLoggerEventHandler = handler;
+                return true;
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private static native boolean startLoggingRingBufferNative(int iface, int verboseLevel,
+            int flags, int minIntervalSec ,int minDataSize, String ringName);
+    synchronized public static boolean startLoggingRingBuffer(int verboseLevel, int flags, int maxInterval,
+            int minDataSize, String ringName){
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                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 (isHalStarted()) {
+                return getSupportedLoggerFeatureSetNative(sWlan0Index);
+            } else {
+                return 0;
+            }
+        }
+    }
+
+    private static native boolean resetLogHandlerNative(int iface, int id);
+    synchronized public static boolean resetLogHandler() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if (sLogCmdId == -1) {
+                    Log.e(TAG,"Can not reset handler Before set any handler");
+                    return false;
+                }
+                sWifiLoggerEventHandler = null;
+                if (resetLogHandlerNative(sWlan0Index, sLogCmdId)) {
+                    sLogCmdId = -1;
+                    return true;
+                } else {
+                    return false;
+                }
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private static native String getDriverVersionNative(int iface);
+    synchronized public static String getDriverVersion() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return getDriverVersionNative(sWlan0Index);
+            } else {
+                return "";
+            }
+        }
+    }
+
+
+    private static native String getFirmwareVersionNative(int iface);
+    synchronized public static String getFirmwareVersion() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                return getFirmwareVersionNative(sWlan0Index);
+            } else {
+                return "";
+            }
+        }
+    }
+
+    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;
+        }
+    }
+
+    private static native RingBufferStatus[] getRingBufferStatusNative(int iface);
+    synchronized public static RingBufferStatus[] getRingBufferStatus() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                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 (isHalStarted()) {
+                return getRingBufferDataNative(sWlan0Index, ringName);
+            } else {
+                return false;
+            }
+        }
+    }
+
+    static private byte[] mFwMemoryDump;
+    private static void onWifiFwMemoryAvailable(byte[] buffer) {
+        mFwMemoryDump = buffer;
+        if (DBG) {
+            Log.d(TAG, "onWifiFwMemoryAvailable is called and buffer length is: " +
+                    (buffer == null ? 0 :  buffer.length));
+        }
+    }
+
+    private static native boolean getFwMemoryDumpNative(int iface);
+    synchronized public static byte[] getFwMemoryDump() {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                if(getFwMemoryDumpNative(sWlan0Index)) {
+                    byte[] fwMemoryDump = mFwMemoryDump;
+                    mFwMemoryDump = null;
+                    return fwMemoryDump;
+                } else {
+                    return null;
+                }
+            }
+
+            return null;
+        }
+    }
+
+    //---------------------------------------------------------------------------------
+    /* Configure ePNO */
+
+    public class WifiPnoNetwork {
+        String SSID;
+        int rssi_threshold;
+        int flags;
+        int auth;
+        String configKey; // kept for reference
+
+        WifiPnoNetwork(WifiConfiguration config, int threshold) {
+            if (config.SSID == null) {
+                this.SSID = "";
+                this.flags = 1;
+            } else {
+                this.SSID = config.SSID;
+            }
+            this.rssi_threshold = threshold;
+            if (config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK)) {
+                auth |= 2;
+            } else if (config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP) ||
+                    config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.IEEE8021X)) {
+                auth |= 4;
+            } else if (config.wepKeys[0] != null) {
+                auth |= 1;
+            } else {
+                auth |= 1;
+            }
+//            auth = 0;
+            flags |= 6; //A and G
+            configKey = config.configKey();
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder sbuf = new StringBuilder();
+            sbuf.append(this.SSID);
+            sbuf.append(" flags=").append(this.flags);
+            sbuf.append(" rssi=").append(this.rssi_threshold);
+            sbuf.append(" auth=").append(this.auth);
+            return sbuf.toString();
+        }
+    }
+
+    public static interface WifiPnoEventHandler {
+        void onPnoNetworkFound(ScanResult results[]);
+    }
+
+    private static WifiPnoEventHandler sWifiPnoEventHandler;
+
+    private static int sPnoCmdId = 0;
+
+    private native static boolean setPnoListNative(int iface, int id, WifiPnoNetwork list[]);
+
+    synchronized public static boolean setPnoList(WifiPnoNetwork list[],
+                                                  WifiPnoEventHandler eventHandler) {
+        Log.e(TAG, "setPnoList cmd " + sPnoCmdId);
+
+        synchronized (mLock) {
+            if (isHalStarted()) {
+
+                sPnoCmdId = getNewCmdIdLocked();
+
+                sWifiPnoEventHandler = eventHandler;
+                if (setPnoListNative(sWlan0Index, sPnoCmdId, list)) {
+                    return true;
+                }
+            }
+
+            sWifiPnoEventHandler = null;
+            return false;
+        }
+    }
+
+    synchronized public static void onPnoNetworkFound(int id, ScanResult[] results) {
+
+        if (results == null) {
+            Log.e(TAG, "onPnoNetworkFound null results");
+            return;
+
+        }
+        Log.d(TAG, "WifiNative.onPnoNetworkFound result " + results.length);
+
+        //Log.e(TAG, "onPnoNetworkFound length " + results.length);
+        //return;
+        for (int i=0; i<results.length; i++) {
+            Log.e(TAG, "onPnoNetworkFound SSID " + results[i].SSID
+                    + " " + results[i].level + " " + results[i].frequency);
+
+            populateScanResult(results[i], results[i].bytes, "onPnoNetworkFound ");
+            results[i].wifiSsid = WifiSsid.createFromAsciiEncoded(results[i].SSID);
+        }
+        synchronized (mLock) {
+            if (sPnoCmdId != 0 && sWifiPnoEventHandler != null) {
+                sWifiPnoEventHandler.onPnoNetworkFound(results);
+            } else {
+                /* this can happen because of race conditions */
+                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 setLazyRoamNative(int iface, int id,
+                                              boolean enabled, WifiLazyRoamParams param);
+
+    synchronized public static boolean setLazyRoam(boolean enabled, WifiLazyRoamParams params) {
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                sPnoCmdId = getNewCmdIdLocked();
+                return setLazyRoamNative(sWlan0Index, sPnoCmdId, enabled, params);
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private native static boolean setBssidBlacklistNative(int iface, int id,
+                                              String list[]);
+
+    synchronized public static boolean setBssidBlacklist(String list[]) {
+        int size = 0;
+        if (list != null) {
+            size = list.length;
+        }
+        Log.e(TAG, "setBssidBlacklist cmd " + sPnoCmdId + " size " + size);
+
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                sPnoCmdId = getNewCmdIdLocked();
+                return setBssidBlacklistNative(sWlan0Index, sPnoCmdId, list);
+            } else {
+                return false;
+            }
+        }
+    }
+
+    private native static boolean setSsidWhitelistNative(int iface, int id, String list[]);
+
+    synchronized public static boolean setSsidWhitelist(String list[]) {
+        int size = 0;
+        if (list != null) {
+            size = list.length;
+        }
+        Log.e(TAG, "setSsidWhitelist cmd " + sPnoCmdId + " size " + size);
+
+        synchronized (mLock) {
+            if (isHalStarted()) {
+                sPnoCmdId = getNewCmdIdLocked();
+
+                return setSsidWhitelistNative(sWlan0Index, sPnoCmdId, list);
+            } else {
+                return false;
+            }
+        }
+    }
 }
diff --git a/service/java/com/android/server/wifi/WifiNetworkScoreCache.java b/service/java/com/android/server/wifi/WifiNetworkScoreCache.java
index 0a7df0b..cf14c5f 100644
--- a/service/java/com/android/server/wifi/WifiNetworkScoreCache.java
+++ b/service/java/com/android/server/wifi/WifiNetworkScoreCache.java
@@ -139,7 +139,7 @@
     }
 
      private String buildNetworkKey(ScoredNetwork network) {
-        if (network.networkKey == null) return null;
+        if (network == null || network.networkKey == null) return null;
         if (network.networkKey.wifiKey == null) return null;
         if (network.networkKey.type == NetworkKey.TYPE_WIFI) {
             String key = network.networkKey.wifiKey.ssid;
@@ -153,7 +153,7 @@
     }
 
     private String buildNetworkKey(ScanResult result) {
-        if (result.SSID == null) {
+        if (result == null || result.SSID == null) {
             return null;
         }
         StringBuilder key = new StringBuilder("\"");
diff --git a/service/java/com/android/server/wifi/WifiNotificationController.java b/service/java/com/android/server/wifi/WifiNotificationController.java
index 20d64c9..406a764 100644
--- a/service/java/com/android/server/wifi/WifiNotificationController.java
+++ b/service/java/com/android/server/wifi/WifiNotificationController.java
@@ -65,7 +65,7 @@
     /**
      * The Notification object given to the NotificationManager.
      */
-    private Notification mNotification;
+    private Notification.Builder mNotificationBuilder;
     /**
      * Whether the notification is being shown, as set by us. That is, if the
      * user cancels the notification, we will not receive the callback so this
@@ -229,31 +229,32 @@
                 return;
             }
 
-            if (mNotification == null) {
-                // Cache the Notification object.
-                mNotification = new Notification();
-                mNotification.when = 0;
-                mNotification.icon = ICON_NETWORKS_AVAILABLE;
-                mNotification.flags = Notification.FLAG_AUTO_CANCEL;
-                mNotification.contentIntent = TaskStackBuilder.create(mContext)
-                        .addNextIntentWithParentStack(
-                                new Intent(WifiManager.ACTION_PICK_WIFI_NETWORK))
-                        .getPendingIntent(0, 0, null, UserHandle.CURRENT);
+            if (mNotificationBuilder == null) {
+                // Cache the Notification builder object.
+                mNotificationBuilder = new Notification.Builder(mContext)
+                        .setWhen(0)
+                        .setSmallIcon(ICON_NETWORKS_AVAILABLE)
+                        .setAutoCancel(true)
+                        .setContentIntent(TaskStackBuilder.create(mContext)
+                                .addNextIntentWithParentStack(
+                                        new Intent(WifiManager.ACTION_PICK_WIFI_NETWORK))
+                                .getPendingIntent(0, 0, null, UserHandle.CURRENT))
+                        .setColor(mContext.getResources().getColor(
+                                com.android.internal.R.color.system_notification_accent_color));
             }
 
             CharSequence title = mContext.getResources().getQuantityText(
                     com.android.internal.R.plurals.wifi_available, numNetworks);
             CharSequence details = mContext.getResources().getQuantityText(
                     com.android.internal.R.plurals.wifi_available_detailed, numNetworks);
-            mNotification.tickerText = title;
-            mNotification.color = mContext.getResources().getColor(
-                    com.android.internal.R.color.system_notification_accent_color);
-            mNotification.setLatestEventInfo(mContext, title, details, mNotification.contentIntent);
+            mNotificationBuilder.setTicker(title);
+            mNotificationBuilder.setContentTitle(title);
+            mNotificationBuilder.setContentText(details);
 
             mNotificationRepeatTime = System.currentTimeMillis() + NOTIFICATION_REPEAT_DELAY_MS;
 
-            notificationManager.notifyAsUser(null, ICON_NETWORKS_AVAILABLE, mNotification,
-                    UserHandle.ALL);
+            notificationManager.notifyAsUser(null, ICON_NETWORKS_AVAILABLE,
+                    mNotificationBuilder.build(), UserHandle.ALL);
         } else {
             notificationManager.cancelAsUser(null, ICON_NETWORKS_AVAILABLE, UserHandle.ALL);
         }
diff --git a/service/java/com/android/server/wifi/WifiScanningServiceImpl.java b/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
index 6dacfb4..8f2cd3b 100644
--- a/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
+++ b/service/java/com/android/server/wifi/WifiScanningServiceImpl.java
@@ -16,18 +16,24 @@
 
 package com.android.server.wifi;
 
+import android.Manifest;
 import android.app.AlarmManager;
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
+import android.content.pm.PackageManager;
 import android.net.wifi.IWifiScanner;
 import android.net.wifi.ScanResult;
 import android.net.wifi.WifiManager;
 import android.net.wifi.WifiScanner;
+import android.net.wifi.WifiScanner.BssidInfo;
+import android.net.wifi.WifiScanner.ChannelSpec;
+import android.net.wifi.WifiScanner.ScanData;
 import android.net.wifi.WifiScanner.ScanSettings;
 import android.net.wifi.WifiSsid;
+import android.os.Binder;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.HandlerThread;
@@ -36,13 +42,16 @@
 import android.os.Messenger;
 import android.os.RemoteException;
 import android.os.SystemClock;
+import android.os.WorkSource;
+import android.util.LocalLog;
 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;
@@ -51,26 +60,49 @@
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Iterator;
-import java.util.List;
 import java.util.Map;
 
 public class WifiScanningServiceImpl extends IWifiScanner.Stub {
 
     private static final String TAG = "WifiScanningService";
-    private static final boolean DBG = true;
+    private static final boolean DBG = false;
+    private static final boolean VDBG = false;
+
     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;
+
+    private static final LocalLog mLocalLog = new LocalLog(1024);
+
+    private static void localLog(String message) {
+        mLocalLog.log(message);
+    }
+
+    private static void logw(String message) {
+        Log.w(TAG, message);
+        mLocalLog.log(message);
+    }
+
+    private static void loge(String message) {
+        Log.e(TAG, message);
+        mLocalLog.log(message);
+    }
 
     @Override
     public Messenger getMessenger() {
-        return new Messenger(mClientHandler);
+        if (mClientHandler != null) {
+            return new Messenger(mClientHandler);
+        } else {
+            loge("WifiScanningServiceImpl trying to get messenger w/o initialization");
+            return null;
+        }
     }
 
     @Override
     public Bundle getAvailableChannels(int band) {
-        WifiScanner.ChannelSpec channelSpecs[] = getChannelsForBand(band);
+        ChannelSpec channelSpecs[] = getChannelsForBand(band);
         ArrayList<Integer> list = new ArrayList<Integer>(channelSpecs.length);
-        for (WifiScanner.ChannelSpec channelSpec : channelSpecs) {
+        for (ChannelSpec channelSpec : channelSpecs) {
             list.add(channelSpec.frequency);
         }
         Bundle b = new Bundle();
@@ -78,10 +110,11 @@
         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 {
@@ -93,50 +126,53 @@
         @Override
         public void handleMessage(Message msg) {
 
-            if (DBG) Log.d(TAG, "ClientHandler got" + msg);
+            if (DBG) localLog("ClientHandler got" + msg);
 
             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 {
-                        Slog.e(TAG, "Client connection failure, error=" + msg.arg1);
-                    }
-                    return;
-                case AsyncChannel.CMD_CHANNEL_DISCONNECTED:
-                    if (msg.arg1 == AsyncChannel.STATUS_SEND_UNSUCCESSFUL) {
-                        Slog.e(TAG, "Send failed, client connection lost");
-                    } else {
-                        if (DBG) Slog.d(TAG, "Client connection lost with reason: " + msg.arg1);
-                    }
-                    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 */
-                        ci.cleanup();
+                    if (msg.arg1 != AsyncChannel.STATUS_SUCCESSFUL) {
+                        loge("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) localLog("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) {
+                        loge("Send failed, client connection lost");
+                    } else {
+                        if (DBG) localLog("Client connection lost with reason: " + msg.arg1);
+                    }
+                    if (DBG) localLog("closing client " + msg.replyTo);
+                    ClientInfo ci = mClients.remove(msg.replyTo);
+                    if (ci != null) {                       /* can be null if send failed above */
+                        if (DBG) localLog("closing client " + ci.mUid);
+                        ci.cleanup();
+                    }
                     return;
             }
 
-            ClientInfo ci = mClients.get(msg.replyTo);
-            if (ci == null) {
-                Slog.e(TAG, "Could not find client info for message " + msg.replyTo);
-                replyFailed(msg, WifiScanner.REASON_INVALID_LISTENER, "Could not find listener");
+            try {
+                enforceLocationHardwarePermission(msg.sendingUid);
+            } catch (SecurityException e) {
+                localLog("failed to authorize app: " + e);
+                replyFailed(msg, WifiScanner.REASON_NOT_AUTHORIZED, "Not authorized");
                 return;
             }
 
-            try {
-                enforceConnectivityInternalPermission();
-            } catch (SecurityException e) {
-                replyFailed(msg, WifiScanner.REASON_NOT_AUTHORIZED, "Not authorized");
+            if (msg.what == WifiScanner.CMD_GET_SCAN_RESULTS) {
+                mStateMachine.sendMessage(Message.obtain(msg));
+                return;
+            }
+            ClientInfo ci = mClients.get(msg.replyTo);
+            if (ci == null) {
+                loge("Could not find client info for message " + msg.replyTo);
+                replyFailed(msg, WifiScanner.REASON_INVALID_LISTENER, "Could not find listener");
                 return;
             }
 
@@ -144,6 +180,8 @@
                     WifiScanner.CMD_SCAN,
                     WifiScanner.CMD_START_BACKGROUND_SCAN,
                     WifiScanner.CMD_STOP_BACKGROUND_SCAN,
+                    WifiScanner.CMD_START_SINGLE_SCAN,
+                    WifiScanner.CMD_STOP_SINGLE_SCAN,
                     WifiScanner.CMD_SET_HOTLIST,
                     WifiScanner.CMD_RESET_HOTLIST,
                     WifiScanner.CMD_CONFIGURE_WIFI_CHANGE,
@@ -173,10 +211,13 @@
     private static final int CMD_DRIVER_UNLOADED                     = BASE + 7;
     private static final int CMD_SCAN_PAUSED                         = BASE + 8;
     private static final int CMD_SCAN_RESTARTED                      = BASE + 9;
+    private static final int CMD_STOP_SCAN_INTERNAL                  = BASE + 10;
 
     private Context mContext;
     private WifiScanningStateMachine mStateMachine;
     private ClientHandler mClientHandler;
+    private IBatteryStats mBatteryStats;
+    private final WifiNative.ScanCapabilities mScanCapabilities = new WifiNative.ScanCapabilities();
 
     WifiScanningServiceImpl() { }
 
@@ -193,6 +234,7 @@
         mClientHandler = new ClientHandler(thread.getLooper());
         mStateMachine = new WifiScanningStateMachine(thread.getLooper());
         mWifiChangeStateMachine = new WifiChangeStateMachine(thread.getLooper());
+        mBatteryStats = BatteryStatsService.getService();
 
         mContext.registerReceiver(
                 new BroadcastReceiver() {
@@ -200,7 +242,7 @@
                     public void onReceive(Context context, Intent intent) {
                         int state = intent.getIntExtra(
                                 WifiManager.EXTRA_SCAN_AVAILABLE, WifiManager.WIFI_STATE_DISABLED);
-                        if (DBG) Log.d(TAG, "SCAN_AVAILABLE : " + state);
+                        if (DBG) localLog("SCAN_AVAILABLE : " + state);
                         if (state == WifiManager.WIFI_STATE_ENABLED) {
                             mStateMachine.sendMessage(CMD_DRIVER_LOADED);
                         } else if (state == WifiManager.WIFI_STATE_DISABLED) {
@@ -236,62 +278,67 @@
 
         @Override
         public void onScanResultsAvailable() {
-            if (DBG) Log.d(TAG, "onScanResultAvailable event received");
+            if (DBG) localLog("onScanResultAvailable event received");
             sendMessage(CMD_SCAN_RESULTS_AVAILABLE);
         }
 
         @Override
-        public void onSingleScanComplete() {
-            if (DBG) Log.d(TAG, "onSingleScanComplete event received");
+        public void onScanStatus() {
+            if (DBG) localLog("onScanStatus event received");
             sendMessage(CMD_SCAN_RESULTS_AVAILABLE);
         }
 
         @Override
         public void onFullScanResult(ScanResult fullScanResult) {
-            if (DBG) Log.d(TAG, "Full scanresult received");
+            if (DBG) localLog("Full scanresult received");
             sendMessage(CMD_FULL_SCAN_RESULTS, 0, 0, fullScanResult);
         }
 
         @Override
-        public void onScanPaused() {
-            sendMessage(CMD_SCAN_PAUSED);
+        public void onScanPaused(ScanData scanData[]) {
+            sendMessage(CMD_SCAN_PAUSED, scanData);
         }
 
         @Override
         public void onScanRestarted() {
+            if (DBG) localLog("onScanRestarted() event received");
             sendMessage(CMD_SCAN_RESTARTED);
         }
 
         @Override
         public void onHotlistApFound(ScanResult[] results) {
-            if (DBG) Log.d(TAG, "HotlistApFound event received");
+            if (DBG) localLog("HotlistApFound event received");
             sendMessage(CMD_HOTLIST_AP_FOUND, 0, 0, results);
         }
 
         @Override
+        public void onHotlistApLost(ScanResult[] results) {
+            if (DBG) localLog("HotlistApLost event received");
+            sendMessage(CMD_HOTLIST_AP_LOST, 0, 0, results);
+        }
+
+        @Override
         public void onChangesFound(ScanResult[] results) {
-            if (DBG) Log.d(TAG, "onWifiChangesFound event received");
+            if (DBG) localLog("onWifiChangesFound event received");
             sendMessage(CMD_WIFI_CHANGE_DETECTED, 0, 0, results);
         }
 
         class DefaultState extends State {
             @Override
             public void enter() {
-                if (DBG) Log.d(TAG, "DefaultState");
+                if (DBG) localLog("DefaultState");
             }
             @Override
             public boolean processMessage(Message msg) {
 
-                if (DBG) Log.d(TAG, "DefaultState got" + msg);
+                if (DBG) localLog("DefaultState got" + msg);
 
                 ClientInfo ci = mClients.get(msg.replyTo);
 
                 switch (msg.what) {
                     case CMD_DRIVER_LOADED:
-                        if (WifiNative.startHal() && WifiNative.getInterfaces() != 0) {
-                            WifiNative.ScanCapabilities capabilities =
-                                    new WifiNative.ScanCapabilities();
-                            if (WifiNative.getScanCapabilities(capabilities)) {
+                        if (WifiNative.getInterfaces() != 0) {
+                            if (WifiNative.getScanCapabilities(mScanCapabilities)) {
                                 transitionTo(mStartedState);
                             } else {
                                 loge("could not get scan capabilities");
@@ -303,20 +350,23 @@
                     case WifiScanner.CMD_SCAN:
                     case WifiScanner.CMD_START_BACKGROUND_SCAN:
                     case WifiScanner.CMD_STOP_BACKGROUND_SCAN:
+                    case WifiScanner.CMD_START_SINGLE_SCAN:
+                    case WifiScanner.CMD_STOP_SINGLE_SCAN:
                     case WifiScanner.CMD_SET_HOTLIST:
                     case WifiScanner.CMD_RESET_HOTLIST:
                     case WifiScanner.CMD_CONFIGURE_WIFI_CHANGE:
                     case WifiScanner.CMD_START_TRACKING_CHANGE:
                     case WifiScanner.CMD_STOP_TRACKING_CHANGE:
+                    case WifiScanner.CMD_GET_SCAN_RESULTS:
                         replyFailed(msg, WifiScanner.REASON_UNSPECIFIED, "not available");
                         break;
 
                     case CMD_SCAN_RESULTS_AVAILABLE:
-                        if (DBG) log("ignored scan results available event");
+                        if (DBG) localLog("ignored scan results available event");
                         break;
 
                     case CMD_FULL_SCAN_RESULTS:
-                        if (DBG) log("ignored full scan result event");
+                        if (DBG) localLog("ignored full scan result event");
                         break;
 
                     default:
@@ -331,13 +381,13 @@
 
             @Override
             public void enter() {
-                if (DBG) Log.d(TAG, "StartedState");
+                if (DBG) localLog("StartedState");
             }
 
             @Override
             public boolean processMessage(Message msg) {
 
-                if (DBG) Log.d(TAG, "StartedState got" + msg);
+                if (DBG) localLog("StartedState got" + msg);
 
                 ClientInfo ci = mClients.get(msg.replyTo);
 
@@ -350,7 +400,7 @@
                         break;
                     case WifiScanner.CMD_START_BACKGROUND_SCAN:
                         if (addScanRequest(ci, msg.arg2, (ScanSettings) msg.obj)) {
-                            replySucceeded(msg, null);
+                            replySucceeded(msg);
                         } else {
                             replyFailed(msg, WifiScanner.REASON_INVALID_REQUEST, "bad request");
                         }
@@ -359,18 +409,33 @@
                         removeScanRequest(ci, msg.arg2);
                         break;
                     case WifiScanner.CMD_GET_SCAN_RESULTS:
-                        replySucceeded(msg, getScanResults(ci));
+                        reportScanResults();
+                        replySucceeded(msg);
+                        break;
+                    case WifiScanner.CMD_START_SINGLE_SCAN:
+                        if (addSingleScanRequest(ci, msg.arg2, (ScanSettings) msg.obj)) {
+                            replySucceeded(msg);
+                        } else {
+                            replyFailed(msg, WifiScanner.REASON_INVALID_REQUEST, "bad request");
+                        }
+                        break;
+                    case WifiScanner.CMD_STOP_SINGLE_SCAN:
+                        removeScanRequest(ci, msg.arg2);
+                        break;
+                    case CMD_STOP_SCAN_INTERNAL:
+                        localLog("Removing single shot scan");
+                        removeScanRequest((ClientInfo) msg.obj, msg.arg2);
                         break;
                     case WifiScanner.CMD_SET_HOTLIST:
                         setHotlist(ci, msg.arg2, (WifiScanner.HotlistSettings) msg.obj);
-                        replySucceeded(msg, null);
+                        replySucceeded(msg);
                         break;
                     case WifiScanner.CMD_RESET_HOTLIST:
                         resetHotlist(ci, msg.arg2);
                         break;
                     case WifiScanner.CMD_START_TRACKING_CHANGE:
                         trackWifiChanges(ci, msg.arg2);
-                        replySucceeded(msg, null);
+                        replySucceeded(msg);
                         break;
                     case WifiScanner.CMD_STOP_TRACKING_CHANGE:
                         untrackWifiChanges(ci, msg.arg2);
@@ -379,7 +444,7 @@
                         configureWifiChange((WifiScanner.WifiChangeSettings) msg.obj);
                         break;
                     case CMD_SCAN_RESULTS_AVAILABLE: {
-                            ScanResult[] results = WifiNative.getScanResults();
+                            ScanData[] results = WifiNative.getScanResults(/* flush = */ true);
                             Collection<ClientInfo> clients = mClients.values();
                             for (ClientInfo ci2 : clients) {
                                 ci2.reportScanResults(results);
@@ -388,7 +453,7 @@
                         break;
                     case CMD_FULL_SCAN_RESULTS: {
                             ScanResult result = (ScanResult) msg.obj;
-                            if (DBG) Log.d(TAG, "reporting fullscan result for " + result.SSID);
+                            if (DBG) localLog("reporting fullscan result for " + result.SSID);
                             Collection<ClientInfo> clients = mClients.values();
                             for (ClientInfo ci2 : clients) {
                                 ci2.reportFullScanResult(result);
@@ -398,10 +463,19 @@
 
                     case CMD_HOTLIST_AP_FOUND: {
                             ScanResult[] results = (ScanResult[])msg.obj;
-                            if (DBG) Log.d(TAG, "Found " + results.length + " results");
+                            if (DBG) localLog("Found " + results.length + " results");
                             Collection<ClientInfo> clients = mClients.values();
                             for (ClientInfo ci2 : clients) {
-                                ci2.reportHotlistResults(results);
+                                ci2.reportHotlistResults(WifiScanner.CMD_AP_FOUND, results);
+                            }
+                        }
+                        break;
+                    case CMD_HOTLIST_AP_LOST: {
+                            ScanResult[] results = (ScanResult[])msg.obj;
+                            if (DBG) localLog("Lost " + results.length + " results");
+                            Collection<ClientInfo> clients = mClients.values();
+                            for (ClientInfo ci2 : clients) {
+                                ci2.reportHotlistResults(WifiScanner.CMD_AP_LOST, results);
                             }
                         }
                         break;
@@ -415,7 +489,15 @@
                             reportWifiStabilized(results);
                         }
                         break;
-
+                    case CMD_SCAN_PAUSED: {
+                            ScanData results[] = (ScanData[]) msg.obj;
+                            Collection<ClientInfo> clients = mClients.values();
+                            for (ClientInfo ci2 : clients) {
+                                ci2.reportScanResults(results);
+                            }
+                            transitionTo(mPausedState);
+                        }
+                        break;
                     default:
                         return NOT_HANDLED;
                 }
@@ -427,13 +509,13 @@
         class PausedState extends State {
             @Override
             public void enter() {
-                if (DBG) Log.d(TAG, "PausedState");
+                if (DBG) localLog("PausedState");
             }
 
             @Override
             public boolean processMessage(Message msg) {
 
-                if (DBG) Log.d(TAG, "PausedState got" + msg);
+                if (DBG) localLog("PausedState got" + msg);
 
                 switch (msg.what) {
                     case CMD_SCAN_RESTARTED:
@@ -450,11 +532,17 @@
 
         @Override
         public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
-            super.dump(fd, pw, args);
             pw.println("number of clients : " + mClients.size());
+            for (ClientInfo client : mClients.values()) {
+                client.dump(fd, pw, args);
+                pw.append("------\n");
+            }
             pw.println();
+            pw.println("localLog : ");
+            mLocalLog.dump(fd, pw, args);
+            pw.append("\n\n");
+            super.dump(fd, pw, args);
         }
-
     }
 
     /* client management */
@@ -464,28 +552,93 @@
         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;
-            if (DBG) Slog.d(TAG, "New client, channel: " + c + " messenger: " + m);
+            mUid = uid;
+            mWorkSource = new WorkSource(uid, TAG);
+            if (DBG) localLog("New client, channel: " + c + " messenger: " + m);
+        }
+
+        void reportBatchedScanStart() {
+            if (mUid == 0)
+                return;
+
+            int csph = getCsph();
+
+            try {
+                mBatteryStats.noteWifiBatchedScanStartedFromSource(mWorkSource, csph);
+                localLog("started scanning for UID " + mUid + ", csph = " + csph);
+            } catch (RemoteException e) {
+                logw("failed to report scan work: " + e.toString());
+            }
+        }
+
+        void reportBatchedScanStop() {
+            if (mUid == 0)
+                return;
+
+            try {
+                mBatteryStats.noteWifiBatchedScanStoppedFromSource(mWorkSource);
+                localLog("stopped scanning for UID " + mUid);
+            } catch (RemoteException e) {
+                logw("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();
             sb.append("mChannel ").append(mChannel).append("\n");
-            sb.append("mMessenger ").append(mMessenger).append("\n");
+            sb.append("mMessenger ").append(mMessenger);
+            return sb.toString();
+        }
+
+        void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+            StringBuilder sb = new StringBuilder();
+            sb.append(toString());
 
             Iterator<Map.Entry<Integer, ScanSettings>> it = mScanSettings.entrySet().iterator();
             for (; it.hasNext(); ) {
                 Map.Entry<Integer, ScanSettings> entry = it.next();
-                sb.append("[ScanId ").append(entry.getKey()).append("\n");
-                sb.append("ScanSettings ").append(entry.getValue()).append("\n");
-                sb.append("]");
+                sb.append("ScanId ").append(entry.getKey()).append("\n");
+
+                ScanSettings scanSettings = entry.getValue();
+                sb.append(describe(scanSettings));
+                sb.append("\n");
             }
 
-            return sb.toString();
+            pw.println(sb.toString());
         }
 
         HashMap<Integer, ScanSettings> mScanSettings = new HashMap<Integer, ScanSettings>(4);
@@ -493,13 +646,19 @@
 
         void addScanRequest(ScanSettings settings, int id) {
             mScanSettings.put(id, settings);
+            reportScanWorkUpdate();
         }
 
         void removeScanRequest(int id) {
-            mScanSettings.remove(id);
+            ScanSettings settings = mScanSettings.remove(id);
+            if (settings != null && settings.periodInMs == 0) {
+                /* this was a single shot scan */
+                mChannel.sendMessage(WifiScanner.CMD_SINGLE_SCAN_COMPLETED, 0, id);
+            }
+            reportScanWorkUpdate();
         }
 
-        Iterator<Map.Entry<Integer, WifiScanner.ScanSettings>> getScans() {
+        Iterator<Map.Entry<Integer, ScanSettings>> getScans() {
             return mScanSettings.entrySet().iterator();
         }
 
@@ -507,7 +666,7 @@
             return mScanSettings.values();
         }
 
-        void reportScanResults(ScanResult[] results) {
+        void reportScanResults(ScanData[] results) {
             Iterator<Integer> it = mScanSettings.keySet().iterator();
             while (it.hasNext()) {
                 int handler = it.next();
@@ -515,9 +674,9 @@
             }
         }
 
-        void reportScanResults(ScanResult[] results, int handler) {
+        void reportScanResults(ScanData[] results, int handler) {
             ScanSettings settings = mScanSettings.get(handler);
-            WifiScanner.ChannelSpec desiredChannels[] = settings.channels;
+            ChannelSpec desiredChannels[] = settings.channels;
             if (settings.band != WifiScanner.WIFI_BAND_UNSPECIFIED
                     || desiredChannels == null || desiredChannels.length == 0)  {
                 desiredChannels = getChannelsForBand(settings.band);
@@ -525,42 +684,62 @@
 
             // check the channels this client asked for ..
             int num_results = 0;
-            for (ScanResult result : results) {
-                for (WifiScanner.ChannelSpec channelSpec : desiredChannels) {
-                    if (channelSpec.frequency == result.frequency) {
+            for (ScanData result : results) {
+                boolean copyScanData = false;
+                for (ScanResult scanResult : result.getResults()) {
+                    for (ChannelSpec channelSpec : desiredChannels) {
+                        if (channelSpec.frequency == scanResult.frequency) {
+                            copyScanData = true;
+                            break;
+                        }
+                    }
+                    if (copyScanData) {
                         num_results++;
                         break;
                     }
                 }
             }
 
-            if (num_results == 0) {
-                // nothing to report
-                return;
-            }
+            localLog("results = " + results.length + ", num_results = " + num_results);
 
-            ScanResult results2[] = new ScanResult[num_results];
+            ScanData results2[] = new ScanData[num_results];
             int index = 0;
-            for (ScanResult result : results) {
-                for (WifiScanner.ChannelSpec channelSpec : desiredChannels) {
-                    if (channelSpec.frequency == result.frequency) {
-                        WifiSsid wifiSsid = WifiSsid.createFromAsciiEncoded(result.SSID);
-                        ScanResult newResult = new ScanResult(wifiSsid, result.BSSID, "",
-                                result.level, result.frequency, result.timestamp);
-                        results2[index] = newResult;
-                        index++;
+            for (ScanData result : results) {
+                boolean copyScanData = false;
+                for (ScanResult scanResult : result.getResults()) {
+                    for (ChannelSpec channelSpec : desiredChannels) {
+                        if (channelSpec.frequency == scanResult.frequency) {
+                            copyScanData = true;
+                            break;
+                        }
+                    }
+                    if (copyScanData) {
                         break;
                     }
                 }
+
+                if (copyScanData) {
+                    if (VDBG) {
+                        localLog("adding at " + index);
+                    }
+                    results2[index] = new WifiScanner.ScanData(result);
+                    index++;
+                }
             }
+            
+            localLog("delivering results, num = " + results2.length);
 
             deliverScanResults(handler, results2);
+            if (settings.periodInMs == 0) {
+                /* this is a single shot scan; stop the scan now */
+                mStateMachine.sendMessage(CMD_STOP_SCAN_INTERNAL, 0, handler, this);
+            }
         }
 
-        void deliverScanResults(int handler, ScanResult results[]) {
-            WifiScanner.ParcelableScanResults parcelableScanResults =
-                    new WifiScanner.ParcelableScanResults(results);
-            mChannel.sendMessage(WifiScanner.CMD_SCAN_RESULT, 0, handler, parcelableScanResults);
+        void deliverScanResults(int handler, ScanData results[]) {
+            WifiScanner.ParcelableScanData parcelableScanData =
+                    new WifiScanner.ParcelableScanData(results);
+            mChannel.sendMessage(WifiScanner.CMD_SCAN_RESULT, 0, handler, parcelableScanData);
         }
 
         void reportFullScanResult(ScanResult result) {
@@ -568,17 +747,15 @@
             while (it.hasNext()) {
                 int handler = it.next();
                 ScanSettings settings = mScanSettings.get(handler);
-                WifiScanner.ChannelSpec desiredChannels[] = settings.channels;
+                ChannelSpec desiredChannels[] = settings.channels;
                 if (settings.band != WifiScanner.WIFI_BAND_UNSPECIFIED
                         || desiredChannels == null || desiredChannels.length == 0)  {
                     desiredChannels = getChannelsForBand(settings.band);
                 }
-                for (WifiScanner.ChannelSpec channelSpec : desiredChannels) {
+                for (ChannelSpec channelSpec : desiredChannels) {
                     if (channelSpec.frequency == result.frequency) {
-                        WifiSsid wifiSsid = WifiSsid.createFromAsciiEncoded(result.SSID);
-                        ScanResult newResult = new ScanResult(wifiSsid, result.BSSID, "",
-                                result.level, result.frequency, result.timestamp);
-                        if (DBG) Log.d(TAG, "sending it to " + handler);
+                        ScanResult newResult = new ScanResult(result);
+                        if (DBG) localLog("sending it to " + handler);
                         newResult.informationElements = result.informationElements.clone();
                         mChannel.sendMessage(
                                 WifiScanner.CMD_FULL_SCAN_RESULT, 0, handler, newResult);
@@ -614,7 +791,7 @@
             return mHotlistSettings.values();
         }
 
-        void reportHotlistResults(ScanResult[] results) {
+        void reportHotlistResults(int what, ScanResult[] results) {
             Iterator<Map.Entry<Integer, WifiScanner.HotlistSettings>> it =
                     mHotlistSettings.entrySet().iterator();
             while (it.hasNext()) {
@@ -623,7 +800,7 @@
                 WifiScanner.HotlistSettings settings = entry.getValue();
                 int num_results = 0;
                 for (ScanResult result : results) {
-                    for (WifiScanner.BssidInfo BssidInfo : settings.bssidInfos) {
+                    for (BssidInfo BssidInfo : settings.bssidInfos) {
                         if (result.BSSID.equalsIgnoreCase(BssidInfo.bssid)) {
                             num_results++;
                             break;
@@ -639,7 +816,7 @@
                 ScanResult results2[] = new ScanResult[num_results];
                 int index = 0;
                 for (ScanResult result : results) {
-                    for (WifiScanner.BssidInfo BssidInfo : settings.bssidInfos) {
+                    for (BssidInfo BssidInfo : settings.bssidInfos) {
                         if (result.BSSID.equalsIgnoreCase(BssidInfo.bssid)) {
                             results2[index] = result;
                             index++;
@@ -650,7 +827,7 @@
                 WifiScanner.ParcelableScanResults parcelableScanResults =
                         new WifiScanner.ParcelableScanResults(results2);
 
-                mChannel.sendMessage(WifiScanner.CMD_AP_FOUND, 0, handler, parcelableScanResults);
+                mChannel.sendMessage(what, 0, handler, parcelableScanResults);
             }
         }
 
@@ -701,16 +878,15 @@
             }
 
             mSignificantWifiHandlers.clear();
-            Log.d(TAG, "Successfully stopped all requests for client " + this);
+            localLog("Successfully stopped all requests for client " + this);
         }
     }
 
-    void replySucceeded(Message msg, Object obj) {
+    void replySucceeded(Message msg) {
         if (msg.replyTo != null) {
             Message reply = Message.obtain();
             reply.what = WifiScanner.CMD_OP_SUCCEEDED;
             reply.arg2 = msg.arg2;
-            reply.obj = obj;
             try {
                 msg.replyTo.send(reply);
             } catch (RemoteException e) {
@@ -737,9 +913,9 @@
         }
     }
 
-    private static class SettingsComputer {
+    private class SettingsComputer {
 
-        private static class TimeBucket {
+        private class TimeBucket {
             int periodInSecond;
             int periodMinInSecond;
             int periodMaxInSecond;
@@ -751,53 +927,49 @@
             }
         }
 
-        private static final TimeBucket[] mTimeBuckets = new TimeBucket[] {
+        private final TimeBucket[] mTimeBuckets = new TimeBucket[] {
                 new TimeBucket( 1, 0, 5 ),
                 new TimeBucket( 5, 5, 10 ),
                 new TimeBucket( 10, 10, 25 ),
                 new TimeBucket( 30, 25, 55 ),
-                new TimeBucket( 60, 55, 100),
+                new TimeBucket( 60, 55, 240),
                 new TimeBucket( 300, 240, 500),
                 new TimeBucket( 600, 500, 1500),
                 new TimeBucket( 1800, 1500, WifiScanner.MAX_SCAN_PERIOD_MS) };
 
-        private static final int MAX_BUCKETS = 8;
-        private static final int MAX_CHANNELS = 8;
-        private static final int DEFAULT_MAX_AP_PER_SCAN = 10;
-        private static final int DEFAULT_REPORT_THRESHOLD = 10;
+        private static final int MAX_CHANNELS = 32;
         private static final int DEFAULT_BASE_PERIOD_MS = 5000;
+        private static final int DEFAULT_REPORT_THRESHOLD_NUM_SCANS = 10;
+        private static final int DEFAULT_REPORT_THRESHOLD_PERCENT = 100;
 
         private WifiNative.ScanSettings mSettings;
         {
             mSettings = new WifiNative.ScanSettings();
-            mSettings.max_ap_per_scan = DEFAULT_MAX_AP_PER_SCAN;
+            mSettings.max_ap_per_scan = mScanCapabilities.max_ap_cache_per_scan;
             mSettings.base_period_ms = DEFAULT_BASE_PERIOD_MS;
-            mSettings.report_threshold = DEFAULT_REPORT_THRESHOLD;
+            mSettings.report_threshold_percent = DEFAULT_REPORT_THRESHOLD_PERCENT;
+            mSettings.report_threshold_num_scans = DEFAULT_REPORT_THRESHOLD_NUM_SCANS;
 
-            mSettings.buckets = new WifiNative.BucketSettings[MAX_BUCKETS];
+            mSettings.buckets = new WifiNative.BucketSettings[mScanCapabilities.max_scan_buckets];
             for (int i = 0; i < mSettings.buckets.length; i++) {
                 WifiNative.BucketSettings bucketSettings = new WifiNative.BucketSettings();
                 bucketSettings.bucket = i;
                 bucketSettings.report_events = 0;
                 bucketSettings.channels = new WifiNative.ChannelSettings[MAX_CHANNELS];
                 bucketSettings.num_channels = 0;
-                for (int j = 0; j < bucketSettings.channels.length; j++) {
-                    WifiNative.ChannelSettings channelSettings = new WifiNative.ChannelSettings();
-                    bucketSettings.channels[j] = channelSettings;
-                }
                 mSettings.buckets[i] = bucketSettings;
             }
         }
 
         HashMap<Integer, Integer> mChannelToBucketMap = new HashMap<Integer, Integer>();
 
-        private int getBestBucket(WifiScanner.ScanSettings settings) {
+        private int getBestBucket(ScanSettings settings) {
 
             // check to see if any of the channels are being scanned already
             // and find the smallest bucket index (it represents the quickest
             // period of scan)
 
-            WifiScanner.ChannelSpec channels[] = settings.channels;
+            ChannelSpec channels[] = settings.channels;
             if (channels == null) {
                 // set channels based on band
                 channels = getChannelsForBand(settings.band);
@@ -805,13 +977,13 @@
 
             if (channels == null) {
                 // still no channels; then there's nothing to scan
-                Log.e(TAG, "No channels to scan!!");
+                loge("No channels to scan!!");
                 return -1;
             }
 
             int mostFrequentBucketIndex = mTimeBuckets.length;
 
-            for (WifiScanner.ChannelSpec desiredChannelSpec : channels) {
+            for (ChannelSpec desiredChannelSpec : channels) {
                 if (mChannelToBucketMap.containsKey(desiredChannelSpec.frequency)) {
                     int bucket = mChannelToBucketMap.get(desiredChannelSpec.frequency);
                     if (bucket < mostFrequentBucketIndex) {
@@ -832,36 +1004,36 @@
             }
 
             if (mostFrequentBucketIndex < bestBucketIndex) {
-                for (WifiScanner.ChannelSpec desiredChannelSpec : channels) {
+                for (ChannelSpec desiredChannelSpec : channels) {
                     mChannelToBucketMap.put(desiredChannelSpec.frequency, mostFrequentBucketIndex);
                 }
-                Log.d(TAG, "returning mf bucket number " + mostFrequentBucketIndex);
+                localLog("returning mf bucket number " + mostFrequentBucketIndex);
                 return mostFrequentBucketIndex;
             } else if (bestBucketIndex != -1) {
-                for (WifiScanner.ChannelSpec desiredChannelSpec : channels) {
+                for (ChannelSpec desiredChannelSpec : channels) {
                     mChannelToBucketMap.put(desiredChannelSpec.frequency, bestBucketIndex);
                 }
-                Log.d(TAG, "returning best bucket number " + bestBucketIndex);
+                localLog("returning best bucket number " + bestBucketIndex);
                 return bestBucketIndex;
             }
 
-            Log.e(TAG, "Could not find suitable bucket for period " + settings.periodInMs);
+            loge("Could not find suitable bucket for period " + settings.periodInMs);
             return -1;
         }
 
-        void prepChannelMap(WifiScanner.ScanSettings settings) {
+        void prepChannelMap(ScanSettings settings) {
             getBestBucket(settings);
         }
 
-        int addScanRequestToBucket(WifiScanner.ScanSettings settings) {
+        int addScanRequestToBucket(ScanSettings settings) {
 
             int bucketIndex = getBestBucket(settings);
             if (bucketIndex == -1) {
-                Log.e(TAG, "Ignoring invalid settings");
+                loge("Ignoring invalid settings");
                 return -1;
             }
 
-            WifiScanner.ChannelSpec desiredChannels[] = settings.channels;
+            ChannelSpec desiredChannels[] = settings.channels;
             if (settings.band != WifiScanner.WIFI_BAND_UNSPECIFIED
                     || desiredChannels == null
                     || desiredChannels.length == 0) {
@@ -869,28 +1041,29 @@
                 desiredChannels = getChannelsForBand(settings.band);
                 if (desiredChannels == null) {
                     // still no channels; then there's nothing to scan
-                    Log.e(TAG, "No channels to scan!!");
+                    loge("No channels to scan!!");
                     return -1;
                 }
             }
 
             // merge the channel lists for these buckets
-            Log.d(TAG, "merging " + desiredChannels.length + " channels "
-                    + " for period " + settings.periodInMs);
+            localLog("merging " + desiredChannels.length + " channels "
+                    + " for period " + settings.periodInMs
+                    + " maxScans " + settings.maxScansToCache);
 
             WifiNative.BucketSettings bucket = mSettings.buckets[bucketIndex];
             boolean added = (bucket.num_channels == 0)
                     && (bucket.band == WifiScanner.WIFI_BAND_UNSPECIFIED);
-            Log.d(TAG, "existing " + bucket.num_channels + " channels ");
+            localLog("existing " + bucket.num_channels + " channels ");
 
-            HashSet<WifiScanner.ChannelSpec> newChannels = new HashSet<WifiScanner.ChannelSpec>();
-            for (WifiScanner.ChannelSpec desiredChannelSpec : desiredChannels) {
+            HashSet<ChannelSpec> newChannels = new HashSet<ChannelSpec>();
+            for (ChannelSpec desiredChannelSpec : desiredChannels) {
 
-                Log.d(TAG, "desired channel " + desiredChannelSpec.frequency);
+                if (DBG) localLog("desired channel " + desiredChannelSpec.frequency);
 
                 boolean found = false;
-                for (WifiNative.ChannelSettings existingChannelSpec : bucket.channels) {
-                    if (desiredChannelSpec.frequency == existingChannelSpec.frequency) {
+                for (int i = 0; i < bucket.num_channels; i++) {
+                    if (desiredChannelSpec.frequency == bucket.channels[i].frequency) {
                         found = true;
                         break;
                     }
@@ -899,7 +1072,7 @@
                 if (!found) {
                     newChannels.add(desiredChannelSpec);
                 } else {
-                    if (DBG) Log.d(TAG, "Already scanning channel " + desiredChannelSpec.frequency);
+                    if (DBG) localLog("Already scanning channel " + desiredChannelSpec.frequency);
                 }
             }
 
@@ -910,24 +1083,25 @@
                 bucket.band = getBandFromChannels(bucket.channels)
                         | getBandFromChannels(desiredChannels);
                 bucket.channels = new WifiNative.ChannelSettings[0];
-                Log.d(TAG, "switching to using band " + bucket.band);
+                localLog("switching to using band " + bucket.band);
             } else {
-                for (WifiScanner.ChannelSpec desiredChannelSpec : newChannels) {
+                for (ChannelSpec desiredChannelSpec : newChannels) {
 
-                    Log.d(TAG, "adding new channel spec " + desiredChannelSpec.frequency);
+                    localLog("adding new channel spec " + desiredChannelSpec.frequency);
 
-                    WifiNative.ChannelSettings channelSettings = bucket.channels[bucket.num_channels];
+                    WifiNative.ChannelSettings channelSettings = new WifiNative.ChannelSettings();
                     channelSettings.frequency = desiredChannelSpec.frequency;
+                    bucket.channels[bucket.num_channels] = channelSettings;
                     bucket.num_channels++;
                     mChannelToBucketMap.put(bucketIndex, channelSettings.frequency);
                 }
             }
 
             if (bucket.report_events < settings.reportEvents) {
-                if (DBG) Log.d(TAG, "setting report_events to " + settings.reportEvents);
+                if (DBG) localLog("setting report_events to " + settings.reportEvents);
                 bucket.report_events = settings.reportEvents;
             } else {
-                if (DBG) Log.d(TAG, "report_events is " + settings.reportEvents);
+                if (DBG) localLog("report_events is " + settings.reportEvents);
             }
 
             if (added) {
@@ -935,8 +1109,16 @@
                 mSettings.num_buckets++;
             }
 
-            if (mSettings.max_ap_per_scan < settings.numBssidsPerScan) {
-                mSettings.max_ap_per_scan = settings.numBssidsPerScan;
+            if ( settings.numBssidsPerScan != 0) {
+                if (mSettings.max_ap_per_scan > settings.numBssidsPerScan) {
+                    mSettings.max_ap_per_scan = settings.numBssidsPerScan;
+                }
+            }
+
+            if (settings.maxScansToCache != 0) {
+                if (mSettings.report_threshold_num_scans > settings.maxScansToCache) {
+                    mSettings.report_threshold_num_scans = settings.maxScansToCache;
+                }
             }
 
             return bucket.period_ms;
@@ -980,13 +1162,13 @@
         for (ClientInfo ci : clients) {
             Iterator it = ci.getScans();
             while (it.hasNext()) {
-                Map.Entry<Integer, WifiScanner.ScanSettings> entry =
-                        (Map.Entry<Integer,WifiScanner.ScanSettings>)it.next();
+                Map.Entry<Integer, ScanSettings> entry =
+                        (Map.Entry<Integer,ScanSettings>)it.next();
                 int id = entry.getKey();
                 ScanSettings s = entry.getValue();
                 int newPeriodInMs = c.addScanRequestToBucket(s);
                 if (newPeriodInMs  == -1) {
-                    if (DBG) Log.d(TAG, "could not find a good bucket");
+                    if (DBG) localLog("could not find a good bucket");
                     return false;
                 }
                 if (newPeriodInMs != s.periodInMs) {
@@ -999,25 +1181,46 @@
 
         WifiNative.ScanSettings s = c.getComputedSettings();
         if (s.num_buckets == 0) {
-            if (DBG) Log.d(TAG, "Stopping scan because there are no buckets");
+            if (DBG) localLog("Stopping scan because there are no buckets");
             WifiNative.stopScan();
             return true;
         } else {
             if (WifiNative.startScan(s, mStateMachine)) {
-                if (DBG) Log.d(TAG, "Successfully started scan of " + s.num_buckets + " buckets at"
-                        + "time = " + SystemClock.elapsedRealtimeNanos()/1000);
+                localLog("Successfully started scan of " + s.num_buckets + " buckets at"
+                        + "time = " + SystemClock.elapsedRealtimeNanos() / 1000 + " period "
+                        + s.base_period_ms);
                 return true;
             } else {
-                if (DBG) Log.d(TAG, "Failed to start scan of " + s.num_buckets + " buckets");
+                loge("Failed to start scan of " + s.num_buckets + " buckets");
                 return false;
             }
         }
     }
 
+    void logScanRequest(String request, ClientInfo ci, int id, ScanSettings settings) {
+        StringBuffer sb = new StringBuffer();
+        sb.append(request);
+        sb.append("\nClient ");
+        sb.append(ci.toString());
+        sb.append("\nId ");
+        sb.append(id);
+        sb.append("\n");
+        if (settings != null) {
+            sb.append(describe(settings));
+            sb.append("\n");
+        }
+        sb.append("\n");
+        localLog(sb.toString());
+    }
+
     boolean addScanRequest(ClientInfo ci, int handler, ScanSettings settings) {
         // sanity check the input
+        if (ci == null) {
+            Log.d(TAG, "Failing scan request ClientInfo not found " + handler);
+            return false;
+        }
         if (settings.periodInMs < WifiScanner.MIN_SCAN_PERIOD_MS) {
-            Log.d(TAG, "Failing scan request because periodInMs is " + settings.periodInMs);
+            localLog("Failing scan request because periodInMs is " + settings.periodInMs);
             return false;
         }
 
@@ -1040,30 +1243,63 @@
         }
 
         if (settings.periodInMs < minSupportedPeriodMs) {
-            Log.d(TAG, "Failing scan request because minSupportedPeriodMs is "
+            localLog("Failing scan request because minSupportedPeriodMs is "
                     + minSupportedPeriodMs + " but the request wants " + settings.periodInMs);
             return false;
         }
 
+        logScanRequest("addScanRequest", ci, handler, settings);
         ci.addScanRequest(settings, handler);
         if (resetBuckets()) {
             return true;
         } else {
             ci.removeScanRequest(handler);
-            Log.d(TAG, "Failing scan request because failed to reset scan");
+            localLog("Failing scan request because failed to reset scan");
+            return false;
+        }
+    }
+
+    boolean addSingleScanRequest(ClientInfo ci, int handler, ScanSettings settings) {
+        if (ci == null) {
+            Log.d(TAG, "Failing single scan request ClientInfo not found " + handler);
+            return false;
+        }
+        if (settings.reportEvents == 0) {
+            settings.reportEvents = WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN;
+        }
+        if (settings.periodInMs == 0) {
+            settings.periodInMs = 10000;        // 10s - although second scan should never happen
+        }
+
+        logScanRequest("addSingleScanRequest", ci, handler, settings);
+        ci.addScanRequest(settings, handler);
+        if (resetBuckets()) {
+            /* reset periodInMs to 0 to indicate single shot scan */
+            settings.periodInMs = 0;
+            return true;
+        } else {
+            ci.removeScanRequest(handler);
+            localLog("Failing scan request because failed to reset scan");
             return false;
         }
     }
 
     void removeScanRequest(ClientInfo ci, int handler) {
-        ci.removeScanRequest(handler);
-        resetBuckets();
+        if (ci != null) {
+            logScanRequest("removeScanRequest", ci, handler, null);
+            ci.removeScanRequest(handler);
+            resetBuckets();
+        }
     }
 
-    ScanResult[] getScanResults(ClientInfo ci) {
-        ScanResult results[] = WifiNative.getScanResults();
-        ci.reportScanResults(results);
-        return results;
+    boolean reportScanResults() {
+        ScanData results[] = WifiNative.getScanResults(/* flush = */ true);
+        Collection<ClientInfo> clients = mClients.values();
+        for (ClientInfo ci2 : clients) {
+            ci2.reportScanResults(results);
+        }
+
+        return true;
     }
 
     void resetHotlist() {
@@ -1080,7 +1316,7 @@
         if (num_hotlist_ap == 0) {
             WifiNative.resetHotlist();
         } else {
-            WifiScanner.BssidInfo bssidInfos[] = new WifiScanner.BssidInfo[num_hotlist_ap];
+            BssidInfo bssidInfos[] = new BssidInfo[num_hotlist_ap];
             int index = 0;
             for (ClientInfo ci : clients) {
                 Collection<WifiScanner.HotlistSettings> settings = ci.getHotlistSettings();
@@ -1220,12 +1456,12 @@
         class DefaultState extends State {
             @Override
             public void enter() {
-                if (DBG) Log.d(TAG, "Entering IdleState");
+                if (DBG) localLog("Entering IdleState");
             }
 
             @Override
             public boolean processMessage(Message msg) {
-                if (DBG) Log.d(TAG, "DefaultState state got " + msg);
+                if (DBG) localLog("DefaultState state got " + msg);
                 switch (msg.what) {
                     case WIFI_CHANGE_CMD_ENABLE :
                         transitionTo(mMovingState);
@@ -1250,24 +1486,24 @@
         class StationaryState extends State {
             @Override
             public void enter() {
-                if (DBG) Log.d(TAG, "Entering StationaryState");
+                if (DBG) localLog("Entering StationaryState");
                 reportWifiStabilized(mCurrentBssids);
             }
 
             @Override
             public boolean processMessage(Message msg) {
-                if (DBG) Log.d(TAG, "Stationary state got " + msg);
+                if (DBG) localLog("Stationary state got " + msg);
                 switch (msg.what) {
                     case WIFI_CHANGE_CMD_ENABLE :
                         // do nothing
                         break;
                     case WIFI_CHANGE_CMD_CHANGE_DETECTED:
-                        if (DBG) Log.d(TAG, "Got wifi change detected");
+                        if (DBG) localLog("Got wifi change detected");
                         reportWifiChanged((ScanResult[])msg.obj);
                         transitionTo(mMovingState);
                         break;
                     case WIFI_CHANGE_CMD_DISABLE:
-                        if (DBG) Log.d(TAG, "Got Disable Wifi Change");
+                        if (DBG) localLog("Got Disable Wifi Change");
                         mCurrentBssids = null;
                         removeScanRequest();
                         untrackSignificantWifiChange();
@@ -1290,29 +1526,30 @@
 
             @Override
             public void enter() {
-                if (DBG) Log.d(TAG, "Entering MovingState");
+                if (DBG) localLog("Entering MovingState");
                 issueFullScan();
             }
 
             @Override
             public boolean processMessage(Message msg) {
-                if (DBG) Log.d(TAG, "MovingState state got " + msg);
+                if (DBG) localLog("MovingState state got " + msg);
                 switch (msg.what) {
                     case WIFI_CHANGE_CMD_ENABLE :
                         // do nothing
                         break;
                     case WIFI_CHANGE_CMD_DISABLE:
-                        if (DBG) Log.d(TAG, "Got Disable Wifi Change");
+                        if (DBG) localLog("Got Disable Wifi Change");
                         mCurrentBssids = null;
                         removeScanRequest();
                         untrackSignificantWifiChange();
                         transitionTo(mDefaultState);
                         break;
                     case WIFI_CHANGE_CMD_NEW_SCAN_RESULTS:
-                        if (DBG) Log.d(TAG, "Got scan results");
+                        if (DBG) localLog("Got scan results");
                         if (mScanResultsPending) {
-                            if (DBG) Log.d(TAG, "reconfiguring scan");
-                            reconfigureScan((ScanResult[])msg.obj, STATIONARY_SCAN_PERIOD_MS);
+                            if (DBG) localLog("reconfiguring scan");
+                            reconfigureScan((ScanData[])msg.obj,
+                                    STATIONARY_SCAN_PERIOD_MS);
                             mWifiChangeDetected = false;
                             mAlarmManager.setExact(AlarmManager.RTC_WAKEUP,
                                     System.currentTimeMillis() + MOVING_STATE_TIMEOUT_MS,
@@ -1321,7 +1558,7 @@
                         }
                         break;
                     case WIFI_CHANGE_CMD_CONFIGURE:
-                        if (DBG) Log.d(TAG, "Got configuration from app");
+                        if (DBG) localLog("Got configuration from app");
                         WifiScanner.WifiChangeSettings settings =
                                 (WifiScanner.WifiChangeSettings) msg.obj;
                         reconfigureScan(settings);
@@ -1333,14 +1570,14 @@
                                 mTimeoutIntent);
                         break;
                     case WIFI_CHANGE_CMD_CHANGE_DETECTED:
-                        if (DBG) Log.d(TAG, "Change detected");
+                        if (DBG) localLog("Change detected");
                         mAlarmManager.cancel(mTimeoutIntent);
                         reportWifiChanged((ScanResult[])msg.obj);
                         mWifiChangeDetected = true;
                         issueFullScan();
                         break;
                     case WIFI_CHANGE_CMD_CHANGE_TIMEOUT:
-                        if (DBG) Log.d(TAG, "Got timeout event");
+                        if (DBG) localLog("Got timeout event");
                         if (mWifiChangeDetected == false) {
                             transitionTo(mStationaryState);
                         }
@@ -1357,8 +1594,8 @@
             }
 
             void issueFullScan() {
-                if (DBG) Log.d(TAG, "Issuing full scan");
-                WifiScanner.ScanSettings settings = new WifiScanner.ScanSettings();
+                if (DBG) localLog("Issuing full scan");
+                ScanSettings settings = new ScanSettings();
                 settings.band = WifiScanner.WIFI_BAND_BOTH;
                 settings.periodInMs = MOVING_SCAN_PERIOD_MS;
                 settings.reportEvents = WifiScanner.REPORT_EVENT_AFTER_EACH_SCAN;
@@ -1368,10 +1605,10 @@
 
         }
 
-        void reconfigureScan(ScanResult[] results, int period) {
+        void reconfigureScan(ScanData[] results, int period) {
             // find brightest APs and set them as sentinels
             if (results.length < MAX_APS_TO_TRACK) {
-                Log.d(TAG, "too few APs (" + results.length + ") available to track wifi change");
+                localLog("too few APs (" + results.length + ") available to track wifi change");
                 return;
             }
 
@@ -1379,7 +1616,7 @@
 
             // remove duplicate BSSIDs
             HashMap<String, ScanResult> bssidToScanResult = new HashMap<String, ScanResult>();
-            for (ScanResult result : results) {
+            for (ScanResult result : results[0].getResults()) {
                 ScanResult saved = bssidToScanResult.get(result.BSSID);
                 if (saved == null) {
                     bssidToScanResult.put(result.BSSID, result);
@@ -1418,14 +1655,14 @@
                 }
             }
 
-            if (DBG) Log.d(TAG, "Found " + channels.size() + " channels");
+            if (DBG) localLog("Found " + channels.size() + " channels");
 
             // set scanning schedule
-            WifiScanner.ScanSettings settings = new WifiScanner.ScanSettings();
+            ScanSettings settings = new ScanSettings();
             settings.band = WifiScanner.WIFI_BAND_UNSPECIFIED;
-            settings.channels = new WifiScanner.ChannelSpec[channels.size()];
+            settings.channels = new ChannelSpec[channels.size()];
             for (int i = 0; i < channels.size(); i++) {
-                settings.channels[i] = new WifiScanner.ChannelSpec(channels.get(i));
+                settings.channels[i] = new ChannelSpec(channels.get(i));
             }
 
             settings.periodInMs = period;
@@ -1436,17 +1673,17 @@
             settings2.lostApSampleSize = 3;
             settings2.unchangedSampleSize = 3;
             settings2.minApsBreachingThreshold = 2;
-            settings2.bssidInfos = new WifiScanner.BssidInfo[brightest.length];
+            settings2.bssidInfos = new BssidInfo[brightest.length];
 
             for (int i = 0; i < brightest.length; i++) {
-                WifiScanner.BssidInfo BssidInfo = new WifiScanner.BssidInfo();
+                BssidInfo BssidInfo = new BssidInfo();
                 BssidInfo.bssid = brightest[i].BSSID;
                 int threshold = (100 + brightest[i].level) / 32 + 2;
                 BssidInfo.low = brightest[i].level - threshold;
                 BssidInfo.high = brightest[i].level + threshold;
                 settings2.bssidInfos[i] = BssidInfo;
 
-                if (DBG) Log.d(TAG, "Setting bssid=" + BssidInfo.bssid + ", " +
+                if (DBG) localLog("Setting bssid=" + BssidInfo.bssid + ", " +
                         "low=" + BssidInfo.low + ", high=" + BssidInfo.high);
             }
 
@@ -1457,12 +1694,12 @@
         void reconfigureScan(WifiScanner.WifiChangeSettings settings) {
 
             if (settings.bssidInfos.length < MAX_APS_TO_TRACK) {
-                Log.d(TAG, "too few APs (" + settings.bssidInfos.length
+                localLog("too few APs (" + settings.bssidInfos.length
                         + ") available to track wifi change");
                 return;
             }
 
-            if (DBG) Log.d(TAG, "Setting configuration specified by app");
+            if (DBG) localLog("Setting configuration specified by app");
 
             mCurrentBssids = new ScanResult[settings.bssidInfos.length];
             HashSet<Integer> channels = new HashSet<Integer>();
@@ -1478,12 +1715,12 @@
             removeScanRequest();
 
             // set new scanning schedule
-            WifiScanner.ScanSettings settings2 = new WifiScanner.ScanSettings();
+            ScanSettings settings2 = new ScanSettings();
             settings2.band = WifiScanner.WIFI_BAND_UNSPECIFIED;
-            settings2.channels = new WifiScanner.ChannelSpec[channels.size()];
+            settings2.channels = new ChannelSpec[channels.size()];
             int i = 0;
             for (Integer channel : channels) {
-                settings2.channels[i++] = new WifiScanner.ChannelSpec(channel);
+                settings2.channels[i++] = new ChannelSpec(channel);
             }
 
             settings2.periodInMs = settings.periodInMs;
@@ -1495,11 +1732,11 @@
 
         class ClientInfoLocal extends ClientInfo {
             ClientInfoLocal() {
-                super(null, null);
+                super(0, null, null);
             }
             @Override
-            void deliverScanResults(int handler, ScanResult results[]) {
-                if (DBG) Log.d(TAG, "Delivering messages directly");
+            void deliverScanResults(int handler, ScanData results[]) {
+                if (DBG) localLog("Delivering messages directly");
                 sendMessage(WIFI_CHANGE_CMD_NEW_SCAN_RESULTS, 0, 0, results);
             }
             @Override
@@ -1516,8 +1753,8 @@
         ClientInfo mClientInfo = new ClientInfoLocal();
         private static final int SCAN_COMMAND_ID = 1;
 
-        void addScanRequest(WifiScanner.ScanSettings settings) {
-            if (DBG) Log.d(TAG, "Starting scans");
+        void addScanRequest(ScanSettings settings) {
+            if (DBG) localLog("Starting scans");
             Message msg = Message.obtain();
             msg.what = WifiScanner.CMD_START_BACKGROUND_SCAN;
             msg.arg2 = SCAN_COMMAND_ID;
@@ -1526,7 +1763,7 @@
         }
 
         void removeScanRequest() {
-            if (DBG) Log.d(TAG, "Stopping scans");
+            if (DBG) localLog("Stopping scans");
             Message msg = Message.obtain();
             msg.what = WifiScanner.CMD_STOP_BACKGROUND_SCAN;
             msg.arg2 = SCAN_COMMAND_ID;
@@ -1544,44 +1781,156 @@
 
     }
 
-    private static WifiScanner.ChannelSpec[] getChannelsForBand(int band) {
-        int channels[] = WifiNative.getChannelsForBand(band);
-        if (channels != null) {
-            WifiScanner.ChannelSpec channelSpecs[] = new WifiScanner.ChannelSpec[channels.length];
-            for (int i = 0; i < channels.length; i++) {
-                channelSpecs[i] = new WifiScanner.ChannelSpec(channels[i]);
-            }
-            return channelSpecs;
-        } else {
-            return new WifiScanner.ChannelSpec[0];
+    private static ChannelSpec mChannels[][];
+
+    private static void copyChannels(
+            ChannelSpec channelSpec[], int offset, int channels[]) {
+        for (int i = 0; i < channels.length; i++) {
+            channelSpec[offset +i] = new ChannelSpec(channels[i]);
         }
     }
 
-    private static int getBandFromChannels(WifiScanner.ChannelSpec[] channels) {
+    private static boolean initChannels() {
+        if (mChannels != null) {
+            /* already initialized */
+            return true;
+        }
+
+        int channels24[] = WifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_24_GHZ);
+        if (channels24 == null) {
+            loge("Could not get channels for 2.4 GHz");
+            return false;
+        }
+
+        int channels5[] = WifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_5_GHZ);
+        if (channels5 == null) {
+            loge("Could not get channels for 5 GHz");
+            return false;
+        }
+
+        int channelsDfs[] = WifiNative.getChannelsForBand(WifiScanner.WIFI_BAND_5_GHZ_DFS_ONLY);
+        if (channelsDfs == null) {
+            loge("Could not get channels for DFS");
+            return false;
+        }
+
+        mChannels = new ChannelSpec[8][];
+
+        mChannels[0] = new ChannelSpec[0];
+
+        mChannels[1] = new ChannelSpec[channels24.length];
+        copyChannels(mChannels[1], 0, channels24);
+
+        mChannels[2] = new ChannelSpec[channels5.length];
+        copyChannels(mChannels[2], 0, channels5);
+
+        mChannels[3] = new ChannelSpec[channels24.length + channels5.length];
+        copyChannels(mChannels[3], 0, channels24);
+        copyChannels(mChannels[3], channels24.length, channels5);
+
+        mChannels[4] = new ChannelSpec[channelsDfs.length];
+        copyChannels(mChannels[4], 0, channelsDfs);
+
+        mChannels[5] = new ChannelSpec[channels24.length + channelsDfs.length];
+        copyChannels(mChannels[5], 0, channels24);
+        copyChannels(mChannels[5], channels24.length, channelsDfs);
+
+        mChannels[6] = new ChannelSpec[channels5.length + channelsDfs.length];
+        copyChannels(mChannels[6], 0, channels5);
+        copyChannels(mChannels[6], channels5.length, channelsDfs);
+
+        mChannels[7] = new ChannelSpec[
+                channels24.length + channels5.length + channelsDfs.length];
+        copyChannels(mChannels[7], 0, channels24);
+        copyChannels(mChannels[7], channels24.length, channels5);
+        copyChannels(mChannels[7], channels24.length + channels5.length, channelsDfs);
+
+        return true;
+    }
+
+    private static ChannelSpec[] getChannelsForBand(int band) {
+        initChannels();
+
+        if (band < WifiScanner.WIFI_BAND_24_GHZ || band > WifiScanner.WIFI_BAND_BOTH_WITH_DFS)
+            /* invalid value for band */
+            return mChannels[0];
+        else
+            return mChannels[band];
+    }
+
+    private static boolean isDfs(int channel) {
+        ChannelSpec[] dfsChannels = getChannelsForBand(WifiScanner
+                .WIFI_BAND_5_GHZ_DFS_ONLY);
+        for (int i = 0; i < dfsChannels.length; i++) {
+            if (channel == dfsChannels[i].frequency) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private static int getBandFromChannels(ChannelSpec[] channels) {
         int band = WifiScanner.WIFI_BAND_UNSPECIFIED;
-        for (WifiScanner.ChannelSpec channel : channels) {
+        for (ChannelSpec channel : channels) {
             if (2400 <= channel.frequency && channel.frequency < 2500) {
                 band |= WifiScanner.WIFI_BAND_24_GHZ;
+            } else if ( isDfs(channel.frequency)) {
+                band |= WifiScanner.WIFI_BAND_5_GHZ_DFS_ONLY;
             } else if (5100 <= channel.frequency && channel.frequency < 6000) {
                 band |= WifiScanner.WIFI_BAND_5_GHZ;
-            } else {
-                /* TODO: Add DFS Range */
             }
         }
         return band;
     }
+
     private static int getBandFromChannels(WifiNative.ChannelSettings[] channels) {
         int band = WifiScanner.WIFI_BAND_UNSPECIFIED;
         for (WifiNative.ChannelSettings channel : channels) {
-            if (2400 <= channel.frequency && channel.frequency < 2500) {
-                band |= WifiScanner.WIFI_BAND_24_GHZ;
-            } else if (5100 <= channel.frequency && channel.frequency < 6000) {
-                band |= WifiScanner.WIFI_BAND_5_GHZ;
-            } else {
-                /* TODO: Add DFS Range */
+            if (channel != null) {
+                if (2400 <= channel.frequency && channel.frequency < 2500) {
+                    band |= WifiScanner.WIFI_BAND_24_GHZ;
+                } else if ( isDfs(channel.frequency)) {
+                    band |= WifiScanner.WIFI_BAND_5_GHZ_DFS_ONLY;
+                } else if (5100 <= channel.frequency && channel.frequency < 6000) {
+                    band |= WifiScanner.WIFI_BAND_5_GHZ;
+                }
             }
         }
         return band;
     }
 
+    @Override
+    protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
+        if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
+                != PackageManager.PERMISSION_GRANTED) {
+            pw.println("Permission Denial: can't dump WifiScanner from from pid="
+                    + Binder.getCallingPid()
+                    + ", uid=" + Binder.getCallingUid()
+                    + " without permission "
+                    + android.Manifest.permission.DUMP);
+            return;
+        }
+        mStateMachine.dump(fd, pw, args);
+    }
+
+    static String describe(ScanSettings scanSettings) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("  band:").append(scanSettings.band);
+        sb.append("  period:").append(scanSettings.periodInMs);
+        sb.append("  reportEvents:").append(scanSettings.reportEvents);
+        sb.append("  numBssidsPerScan:").append(scanSettings.numBssidsPerScan);
+        sb.append("  maxScansToCache:").append(scanSettings.maxScansToCache).append("\n");
+
+        sb.append("  channels: ");
+
+        if (scanSettings.channels != null) {
+            for (int i = 0; i < scanSettings.channels.length; i++) {
+                sb.append(scanSettings.channels[i].frequency);
+                sb.append(" ");
+            }
+        }
+        sb.append("\n");
+        return sb.toString();
+    }
+
 }
diff --git a/service/java/com/android/server/wifi/WifiServiceImpl.java b/service/java/com/android/server/wifi/WifiServiceImpl.java
index cc5824e..ca85fbc 100644
--- a/service/java/com/android/server/wifi/WifiServiceImpl.java
+++ b/service/java/com/android/server/wifi/WifiServiceImpl.java
@@ -30,45 +30,71 @@
 import android.net.ConnectivityManager;
 import android.net.DhcpInfo;
 import android.net.DhcpResults;
-import android.net.IpConfiguration.ProxySettings;
-import android.net.LinkAddress;
+import android.net.Network;
+import android.net.NetworkScorerAppManager;
 import android.net.NetworkUtils;
-import android.net.RouteInfo;
-import android.net.wifi.*;
+import android.net.Uri;
+import android.net.wifi.BatchedScanResult;
+import android.net.wifi.BatchedScanSettings;
 import android.net.wifi.IWifiManager;
+import android.net.wifi.ScanResult;
+import android.net.wifi.ScanSettings;
+import android.net.wifi.WifiActivityEnergyInfo;
+import android.net.wifi.WifiChannel;
+import android.net.wifi.WifiConfiguration;
+import android.net.wifi.WifiConnectionStatistics;
+import android.net.wifi.WifiEnterpriseConfig;
+import android.net.wifi.WifiInfo;
+import android.net.wifi.WifiLinkLayerStats;
+import android.net.wifi.WifiManager;
 import android.os.AsyncTask;
 import android.os.Binder;
+import android.os.Build;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.Messenger;
+import android.os.PowerManager;
 import android.os.RemoteException;
+import android.os.SystemClock;
 import android.os.SystemProperties;
 import android.os.UserHandle;
 import android.os.UserManager;
 import android.os.WorkSource;
 import android.provider.Settings;
+import android.text.TextUtils;
 import android.util.Log;
 import android.util.Slog;
 
-import java.io.FileNotFoundException;
-import java.io.BufferedReader;
-import java.io.FileDescriptor;
-import java.io.FileReader;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.lang.Override;
-import java.net.InetAddress;
-import java.net.Inet4Address;
-import java.util.ArrayList;
-import java.util.List;
-
 import com.android.internal.R;
 import com.android.internal.app.IBatteryStats;
 import com.android.internal.telephony.TelephonyIntents;
 import com.android.internal.util.AsyncChannel;
 import com.android.server.am.BatteryStatsService;
+import com.android.server.wifi.configparse.ConfigBuilder;
+
+import org.xml.sax.SAXException;
+
+import java.io.BufferedReader;
+import java.io.FileDescriptor;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.net.Inet4Address;
+import java.net.InetAddress;
+import java.security.GeneralSecurityException;
+import java.security.KeyStore;
+import java.security.cert.CertPath;
+import java.security.cert.CertPathValidator;
+import java.security.cert.CertPathValidatorException;
+import java.security.cert.CertificateFactory;
+import java.security.cert.PKIXParameters;
+import java.security.cert.X509Certificate;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 
 import static com.android.server.wifi.WifiController.CMD_AIRPLANE_TOGGLED;
 import static com.android.server.wifi.WifiController.CMD_BATTERY_CHANGED;
@@ -89,6 +115,7 @@
 public final class WifiServiceImpl extends IWifiManager.Stub {
     private static final String TAG = "WifiService";
     private static final boolean DBG = true;
+    private static final boolean VDBG = false;
 
     final WifiStateMachine mWifiStateMachine;
 
@@ -109,7 +136,9 @@
     private int mMulticastDisabled;
 
     private final IBatteryStats mBatteryStats;
+    private final PowerManager mPowerManager;
     private final AppOpsManager mAppOps;
+    private final UserManager mUserManager;
 
     private String mInterfaceName;
 
@@ -123,8 +152,6 @@
     /* Tracks the persisted states for wi-fi & airplane mode */
     final WifiSettingsStore mSettingsStore;
 
-    final boolean mBatchedScanSupported;
-
     /**
      * Asynchronous channel to WifiStateMachine
      */
@@ -173,31 +200,21 @@
                     WifiConfiguration config = (WifiConfiguration) msg.obj;
                     int networkId = msg.arg1;
                     if (msg.what == WifiManager.SAVE_NETWORK) {
-                        if (config != null) {
-                            if (config.networkId == WifiConfiguration.INVALID_NETWORK_ID) {
-                                config.creatorUid = Binder.getCallingUid();
-                            } else {
-                                config.lastUpdateUid = Binder.getCallingUid();
-                            }
-                        }
                         Slog.e("WiFiServiceImpl ", "SAVE"
                                 + " nid=" + Integer.toString(networkId)
-                                + " uid=" + Integer.toString(config.creatorUid)
-                                + "/" + Integer.toString(config.lastUpdateUid));
+                                + " uid=" + msg.sendingUid
+                                + " name="
+                                + mContext.getPackageManager().getNameForUid(msg.sendingUid));
                     }
                     if (msg.what == WifiManager.CONNECT_NETWORK) {
-                        if (config != null) {
-                            if (config.networkId == WifiConfiguration.INVALID_NETWORK_ID) {
-                                config.creatorUid = Binder.getCallingUid();
-                            } else {
-                                config.lastUpdateUid = Binder.getCallingUid();
-                            }
-                        }
                         Slog.e("WiFiServiceImpl ", "CONNECT "
                                 + " nid=" + Integer.toString(networkId)
-                                + " uid=" + Binder.getCallingUid());
+                                + " uid=" + msg.sendingUid
+                                + " name="
+                                + mContext.getPackageManager().getNameForUid(msg.sendingUid));
                     }
-                    if (config != null && config.isValid()) {
+
+                    if (config != null && isValid(config)) {
                         if (DBG) Slog.d(TAG, "Connect with config" + config);
                         mWifiStateMachine.sendMessage(Message.obtain(msg));
                     } else if (config == null
@@ -306,7 +323,9 @@
         mWifiStateMachine = new WifiStateMachine(mContext, mInterfaceName, mTrafficPoller);
         mWifiStateMachine.enableRssiPolling(true);
         mBatteryStats = BatteryStatsService.getService();
+        mPowerManager = context.getSystemService(PowerManager.class);
         mAppOps = (AppOpsManager)context.getSystemService(Context.APP_OPS_SERVICE);
+        mUserManager = UserManager.get(mContext);
 
         mNotificationController = new WifiNotificationController(mContext, mWifiStateMachine);
         mSettingsStore = new WifiSettingsStore(mContext);
@@ -316,9 +335,6 @@
         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);
     }
 
 
@@ -350,6 +366,8 @@
         // can result in race conditions when apps toggle wifi in the background
         // without active user involvement. Always receive broadcasts.
         registerForBroadcasts();
+        registerForPackageOrUserRemoval();
+        mInIdleMode = mPowerManager.isDeviceIdleMode();
 
         mWifiController.start();
 
@@ -390,6 +408,7 @@
 
     // Start a location scan.
     // L release: A location scan is implemented as a normal scan and avoids scanning DFS channels
+    // Deprecated: Will soon remove implementation
     public void startLocationRestrictedScan(WorkSource workSource) {
         enforceChangePermission();
         enforceLocationHardwarePermission();
@@ -421,6 +440,23 @@
      */
     public void startScan(ScanSettings settings, WorkSource workSource) {
         enforceChangePermission();
+        synchronized (this) {
+            if (mInIdleMode) {
+                // Need to send an immediate scan result broadcast in case the
+                // caller is waiting for a result ..
+
+                // clear calling identity to send broadcast
+                long callingIdentity = Binder.clearCallingIdentity();
+                try {
+                    mWifiStateMachine.sendScanResultsAvailableBroadcast(/* scanSucceeded = */ false);
+                } finally {
+                    // restore calling identity
+                    Binder.restoreCallingIdentity(callingIdentity);
+                }
+                mScanPending = true;
+                return;
+            }
+        }
         if (settings != null) {
             settings = new ScanSettings(settings);
             if (!settings.isValid()) {
@@ -438,42 +474,11 @@
                 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>();
-
     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();
@@ -485,145 +490,36 @@
      */
     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);
-        }
+        return null;
     }
 
-    public void stopBatchedScan(BatchedScanSettings settings) {
-        enforceChangePermission();
-        if (mBatchedScanSupported == false) return;
-        stopBatchedScan(settings, getCallingUid(), getCallingPid());
-    }
+    public void stopBatchedScan(BatchedScanSettings settings) { }
 
-    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();
-            }
-        }
-    }
+    boolean mInIdleMode;
+    boolean mScanPending;
 
-    private void resolveBatchedScannersLocked() {
-        BatchedScanSettings setting = new BatchedScanSettings();
-        WorkSource responsibleWorkSource = null;
-        int responsibleUid = 0;
-        double responsibleCsph = 0; // Channel Scans Per Hour
-
-        if (mBatchedScanners.size() == 0) {
-            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);
+    void handleIdleModeChanged() {
+        boolean doScan = false;
+        synchronized (this) {
+            boolean idle = mPowerManager.isDeviceIdleMode();
+            if (mInIdleMode != idle) {
+                mInIdleMode = idle;
+                if (!idle) {
+                    if (mScanPending) {
+                        mScanPending = false;
+                        doScan = true;
                     }
-                } // 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);
+        if (doScan) {
+            // Someone requested a scan while we were idle; do a full scan now.
+            startScan(null, null);
+        }
     }
 
     private void enforceAccessPermission() {
@@ -633,7 +529,7 @@
 
     private void enforceChangePermission() {
         mContext.enforceCallingOrSelfPermission(android.Manifest.permission.CHANGE_WIFI_STATE,
-                                                "WifiService");
+                "WifiService");
     }
 
     private void enforceLocationHardwarePermission() {
@@ -719,12 +615,11 @@
     public void setWifiApEnabled(WifiConfiguration wifiConfig, boolean enabled) {
         enforceChangePermission();
         ConnectivityManager.enforceTetherChangePermission(mContext);
-        UserManager um = UserManager.get(mContext);
-        if (um.hasUserRestriction(UserManager.DISALLOW_CONFIG_TETHERING)) {
+        if (mUserManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_TETHERING)) {
             throw new SecurityException("DISALLOW_CONFIG_TETHERING is enabled for this user.");
         }
         // null wifiConfig is a meaningful input for CMD_SET_AP
-        if (wifiConfig == null || wifiConfig.isValid()) {
+        if (wifiConfig == null || isValid(wifiConfig)) {
             mWifiController.obtainMessage(CMD_SET_AP, enabled ? 1 : 0, 0, wifiConfig).sendToTarget();
         } else {
             Slog.e(TAG, "Invalid WifiConfiguration");
@@ -754,6 +649,25 @@
     }
 
     /**
+     * see {@link WifiManager#buildWifiConfig()}
+     * @return a WifiConfiguration.
+     */
+    public WifiConfiguration buildWifiConfig(String uriString, String mimeType, byte[] data) {
+        if (mimeType.equals(ConfigBuilder.WifiConfigType)) {
+            try {
+                return ConfigBuilder.buildConfig(uriString, data, mContext);
+            }
+            catch (IOException | GeneralSecurityException | SAXException e) {
+                Log.e(TAG, "Failed to parse wi-fi configuration: " + e);
+            }
+        }
+        else {
+            Log.i(TAG, "Unknown wi-fi config type: " + mimeType);
+        }
+        return null;
+    }
+
+    /**
      * see {@link WifiManager#setWifiApConfiguration(WifiConfiguration)}
      * @param wifiConfig WifiConfiguration details for soft access point
      */
@@ -761,7 +675,7 @@
         enforceChangePermission();
         if (wifiConfig == null)
             return;
-        if (wifiConfig.isValid()) {
+        if (isValid(wifiConfig)) {
             mWifiStateMachine.setWifiApConfiguration(wifiConfig);
         } else {
             Slog.e(TAG, "Invalid WifiConfiguration");
@@ -816,7 +730,7 @@
     }
 
     /**
-     * see {@link android.net.wifi.WifiAdapter#reportActivityInfo}
+     * see {@link android.net.wifi.WifiManager#getControllerActivityEnergyInfo(int)}
      */
     public WifiActivityEnergyInfo reportActivityInfo() {
         enforceAccessPermission();
@@ -825,11 +739,39 @@
         if (mWifiStateMachineChannel != null) {
             stats = mWifiStateMachine.syncGetLinkLayerStats(mWifiStateMachineChannel);
             if (stats != null) {
+                final long rxIdleCurrent = mContext.getResources().getInteger(
+                        com.android.internal.R.integer.config_wifi_idle_receive_cur_ma);
+                final long rxCurrent = mContext.getResources().getInteger(
+                        com.android.internal.R.integer.config_wifi_active_rx_cur_ma);
+                final long txCurrent = mContext.getResources().getInteger(
+                        com.android.internal.R.integer.config_wifi_tx_cur_ma);
+                final double voltage = mContext.getResources().getInteger(
+                        com.android.internal.R.integer.config_wifi_operating_voltage_mv)
+                        / 1000.0;
+
+                final long rxIdleTime = stats.on_time - stats.tx_time - stats.rx_time;
+                final long energyUsed = (long)((stats.tx_time * txCurrent +
+                        stats.rx_time * rxCurrent +
+                        rxIdleTime * rxIdleCurrent) * voltage);
+                if (VDBG || rxIdleTime < 0 || stats.on_time < 0 || stats.tx_time < 0 ||
+                        stats.rx_time < 0 || energyUsed < 0) {
+                    StringBuilder sb = new StringBuilder();
+                    sb.append(" rxIdleCur=" + rxIdleCurrent);
+                    sb.append(" rxCur=" + rxCurrent);
+                    sb.append(" txCur=" + txCurrent);
+                    sb.append(" voltage=" + voltage);
+                    sb.append(" on_time=" + stats.on_time);
+                    sb.append(" tx_time=" + stats.tx_time);
+                    sb.append(" rx_time=" + stats.rx_time);
+                    sb.append(" rxIdleTime=" + rxIdleTime);
+                    sb.append(" energy=" + energyUsed);
+                    Log.e(TAG, " reportActivityInfo: " + sb.toString());
+                }
+
                 // Convert the LinkLayerStats into EnergyActivity
-                energyInfo = new WifiActivityEnergyInfo(
+                energyInfo = new WifiActivityEnergyInfo(SystemClock.elapsedRealtime(),
                         WifiActivityEnergyInfo.STACK_STATE_STATE_IDLE, stats.tx_time,
-                        stats.rx_time, stats.on_time - stats.tx_time - stats.rx_time,
-                        0 /* TBD */);
+                        stats.rx_time, rxIdleTime, energyUsed);
             }
             return energyInfo;
         } else {
@@ -869,15 +811,47 @@
     }
 
     /**
+     * Returns a WifiConfiguration matching this ScanResult
+     * @param scanResult scanResult that represents the BSSID
+     * @return {@link WifiConfiguration} that matches this BSSID or null
+     */
+    public WifiConfiguration getMatchingWifiConfig(ScanResult scanResult) {
+        enforceAccessPermission();
+        return mWifiStateMachine.syncGetMatchingWifiConfig(scanResult, mWifiStateMachineChannel);
+    }
+
+
+    /**
      * see {@link android.net.wifi.WifiManager#addOrUpdateNetwork(WifiConfiguration)}
      * @return the supplicant-assigned identifier for the new or updated
      * network if the operation succeeds, or {@code -1} if it fails
      */
     public int addOrUpdateNetwork(WifiConfiguration config) {
         enforceChangePermission();
-        if (config.isValid()) {
+        if (isValid(config) && isValidPasspoint(config)) {
+
+            WifiEnterpriseConfig enterpriseConfig = config.enterpriseConfig;
+
+            if (config.isPasspoint() &&
+                    (enterpriseConfig.getEapMethod() == WifiEnterpriseConfig.Eap.TLS ||
+                enterpriseConfig.getEapMethod() == WifiEnterpriseConfig.Eap.TTLS)) {
+                try {
+                    verifyCert(enterpriseConfig.getCaCertificate());
+                } catch (CertPathValidatorException cpve) {
+                    Slog.e(TAG, "CA Cert " +
+                            enterpriseConfig.getCaCertificate().getSubjectX500Principal() +
+                            " untrusted: " + cpve.getMessage());
+                    return -1;
+                } catch (GeneralSecurityException | IOException e) {
+                    Slog.e(TAG, "Failed to verify certificate" +
+                            enterpriseConfig.getCaCertificate().getSubjectX500Principal() +
+                            ": " + e);
+                    return -1;
+                }
+            }
+
             //TODO: pass the Uid the WifiStateMachine as a message parameter
-            Slog.e("addOrUpdateNetwork", " uid = " + Integer.toString(Binder.getCallingUid())
+            Slog.i("addOrUpdateNetwork", " uid = " + Integer.toString(Binder.getCallingUid())
                     + " SSID " + config.SSID
                     + " nid=" + Integer.toString(config.networkId));
             if (config.networkId == WifiConfiguration.INVALID_NETWORK_ID) {
@@ -897,7 +871,21 @@
         }
     }
 
-     /**
+    public static void verifyCert(X509Certificate caCert)
+            throws GeneralSecurityException, IOException {
+        CertificateFactory factory = CertificateFactory.getInstance("X.509");
+        CertPathValidator validator =
+                CertPathValidator.getInstance(CertPathValidator.getDefaultType());
+        CertPath path = factory.generateCertPath(
+                Arrays.asList(caCert));
+        KeyStore ks = KeyStore.getInstance("AndroidCAStore");
+        ks.load(null, null);
+        PKIXParameters params = new PKIXParameters(ks);
+        params.setRevocationEnabled(false);
+        validator.validate(path, params);
+    }
+
+    /**
      * See {@link android.net.wifi.WifiManager#removeNetwork(int)}
      * @param netId the integer that identifies the network configuration
      * to the supplicant
@@ -975,9 +963,20 @@
         enforceAccessPermission();
         int userId = UserHandle.getCallingUserId();
         int uid = Binder.getCallingUid();
+        boolean canReadPeerMacAddresses = checkPeersMacAddress();
+        boolean isActiveNetworkScorer =
+                NetworkScorerAppManager.isCallerActiveScorer(mContext, uid);
         boolean hasInteractUsersFull = checkInteractAcrossUsersFull();
         long ident = Binder.clearCallingIdentity();
         try {
+            if (!canReadPeerMacAddresses && !isActiveNetworkScorer
+                    && !isLocationEnabled()) {
+                return new ArrayList<ScanResult>();
+            }
+            if (!canReadPeerMacAddresses && !isActiveNetworkScorer
+                    && !checkCallerCanAccessScanResults(callingPackage, uid)) {
+                return new ArrayList<ScanResult>();
+            }
             if (mAppOps.noteOp(AppOpsManager.OP_WIFI_SCAN, uid, callingPackage)
                     != AppOpsManager.MODE_ALLOWED) {
                 return new ArrayList<ScanResult>();
@@ -991,6 +990,11 @@
         }
     }
 
+    private boolean isLocationEnabled() {
+        return Settings.Secure.getInt(mContext.getContentResolver(), Settings.Secure.LOCATION_MODE,
+                Settings.Secure.LOCATION_MODE_OFF) != Settings.Secure.LOCATION_MODE_OFF;
+    }
+
     /**
      * Returns true if the caller holds INTERACT_ACROSS_USERS_FULL.
      */
@@ -1001,6 +1005,14 @@
     }
 
     /**
+     * Returns true if the caller holds PEERS_MAC_ADDRESS.
+     */
+    private boolean checkPeersMacAddress() {
+        return mContext.checkCallingOrSelfPermission(
+                android.Manifest.permission.PEERS_MAC_ADDRESS) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    /**
      * Returns true if the calling user is the current one or a profile of the
      * current user..
      */
@@ -1009,7 +1021,7 @@
         if (userId == currentUser) {
             return true;
         }
-        List<UserInfo> profiles = UserManager.get(mContext).getProfiles(currentUser);
+        List<UserInfo> profiles = mUserManager.getProfiles(currentUser);
         for (UserInfo user : profiles) {
             if (userId == user.id) {
                 return true;
@@ -1031,7 +1043,7 @@
             if (userId == ownerUser) {
                 return true;
             }
-            List<UserInfo> profiles = UserManager.get(mContext).getProfiles(ownerUser);
+            List<UserInfo> profiles = mUserManager.getProfiles(ownerUser);
             for (UserInfo profile : profiles) {
                 if (userId == profile.id) {
                     return true;
@@ -1083,6 +1095,15 @@
         }
     }
 
+     /**
+     * Get the country code
+     * @return ISO 3166 country code.
+     */
+    public String getCountryCode() {
+        enforceConnectivityInternalPermission();
+        String country = mWifiStateMachine.getCountryCode();
+        return country;
+    }
     /**
      * Set the operational frequency band
      * @param band One of
@@ -1350,6 +1371,8 @@
             } else if (action.equals(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED)) {
                 boolean emergencyMode = intent.getBooleanExtra("phoneinECMState", false);
                 mWifiController.sendMessage(CMD_EMERGENCY_MODE_CHANGED, emergencyMode ? 1 : 0, 0);
+            } else if (action.equals(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED)) {
+                handleIdleModeChanged();
             }
         }
     };
@@ -1380,9 +1403,41 @@
         intentFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
         intentFilter.addAction(BluetoothAdapter.ACTION_CONNECTION_STATE_CHANGED);
         intentFilter.addAction(TelephonyIntents.ACTION_EMERGENCY_CALLBACK_MODE_CHANGED);
+        intentFilter.addAction(PowerManager.ACTION_DEVICE_IDLE_MODE_CHANGED);
         mContext.registerReceiver(mReceiver, intentFilter);
     }
 
+    private void registerForPackageOrUserRemoval() {
+        IntentFilter intentFilter = new IntentFilter();
+        intentFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
+        intentFilter.addAction(Intent.ACTION_USER_REMOVED);
+        mContext.registerReceiverAsUser(new BroadcastReceiver() {
+            @Override
+            public void onReceive(Context context, Intent intent) {
+                switch (intent.getAction()) {
+                    case Intent.ACTION_PACKAGE_REMOVED: {
+                        if (intent.getBooleanExtra(Intent.EXTRA_REPLACING, false)) {
+                            return;
+                        }
+                        int uid = intent.getIntExtra(Intent.EXTRA_UID, -1);
+                        Uri uri = intent.getData();
+                        if (uid == -1 || uri == null) {
+                            return;
+                        }
+                        String pkgName = uri.getSchemeSpecificPart();
+                        mWifiStateMachine.removeAppConfigs(pkgName, uid);
+                        break;
+                    }
+                    case Intent.ACTION_USER_REMOVED: {
+                        int userHandle = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, 0);
+                        mWifiStateMachine.removeUserConfigs(userHandle);
+                        break;
+                    }
+                }
+            }
+        }, UserHandle.ALL, intentFilter, null, null);
+    }
+
     @Override
     protected void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         if (mContext.checkCallingOrSelfPermission(android.Manifest.permission.DUMP)
@@ -1398,6 +1453,8 @@
                                        Settings.Global.STAY_ON_WHILE_PLUGGED_IN, 0));
         pw.println("mMulticastEnabled " + mMulticastEnabled);
         pw.println("mMulticastDisabled " + mMulticastDisabled);
+        pw.println("mInIdleMode " + mInIdleMode);
+        pw.println("mScanPending " + mScanPending);
         mWifiController.dump(fd, pw, args);
         mSettingsStore.dump(fd, pw, args);
         mNotificationController.dump(fd, pw, args);
@@ -1439,6 +1496,12 @@
         pw.println("Locks held:");
         mLocks.dump(pw);
 
+        pw.println("Multicast Locks held:");
+        for (Multicaster l : mMulticasters) {
+            pw.print("    ");
+            pw.println(l);
+        }
+
         mWifiWatchdogStateMachine.dump(fd, pw, args);
         pw.println();
         mWifiStateMachine.dump(fd, pw, args);
@@ -1840,6 +1903,25 @@
         return mWifiStateMachine.getAllowScansWithTraffic();
     }
 
+    public boolean enableAutoJoinWhenAssociated(boolean enabled) {
+        enforceChangePermission();
+        return mWifiStateMachine.enableAutoJoinWhenAssociated(enabled);
+    }
+
+    public boolean getEnableAutoJoinWhenAssociated() {
+        enforceAccessPermission();
+        return mWifiStateMachine.getEnableAutoJoinWhenAssociated();
+    }
+    public void setHalBasedAutojoinOffload(int enabled) {
+        enforceConnectivityInternalPermission();
+        mWifiStateMachine.setHalBasedAutojoinOffload(enabled);
+    }
+
+    public int getHalBasedAutojoinOffload() {
+        enforceAccessPermission();
+        return mWifiStateMachine.getHalBasedAutojoinOffload();
+    }
+
     /* Return the Wifi Connection statistics object */
     public WifiConnectionStatistics getConnectionStatistics() {
         enforceAccessPermission();
@@ -1851,4 +1933,162 @@
             return null;
         }
     }
+
+    public void factoryReset() {
+        enforceConnectivityInternalPermission();
+
+        if (mUserManager.hasUserRestriction(UserManager.DISALLOW_NETWORK_RESET)) {
+            return;
+        }
+
+        if (!mUserManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_TETHERING)) {
+            // Turn mobile hotspot off
+            setWifiApEnabled(null, false);
+        }
+
+        if (!mUserManager.hasUserRestriction(UserManager.DISALLOW_CONFIG_WIFI)) {
+            // Enable wifi
+            setWifiEnabled(true);
+            // Delete all Wifi SSIDs
+            List<WifiConfiguration> networks = getConfiguredNetworks();
+            if (networks != null) {
+                for (WifiConfiguration config : networks) {
+                    removeNetwork(config.networkId);
+                }
+                saveConfiguration();
+            }
+        }
+    }
+
+    /* private methods */
+    static boolean logAndReturnFalse(String s) {
+        Log.d(TAG, s);
+        return false;
+    }
+
+    public static boolean isValid(WifiConfiguration config) {
+        String validity = checkValidity(config);
+        return validity == null || logAndReturnFalse(validity);
+    }
+
+    public static boolean isValidPasspoint(WifiConfiguration config) {
+        String validity = checkPasspointValidity(config);
+        return validity == null || logAndReturnFalse(validity);
+    }
+
+    public static String checkValidity(WifiConfiguration config) {
+        if (config.allowedKeyManagement == null)
+            return "allowed kmgmt";
+
+        if (config.allowedKeyManagement.cardinality() > 1) {
+            if (config.allowedKeyManagement.cardinality() != 2) {
+                return "cardinality != 2";
+            }
+            if (!config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP)) {
+                return "not WPA_EAP";
+            }
+            if ((!config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.IEEE8021X))
+                    && (!config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK))) {
+                return "not PSK or 8021X";
+            }
+        }
+        return null;
+    }
+
+    public static String checkPasspointValidity(WifiConfiguration config) {
+        if (!TextUtils.isEmpty(config.FQDN)) {
+            /* this is passpoint configuration; it must not have an SSID */
+            if (!TextUtils.isEmpty(config.SSID)) {
+                return "SSID not expected for Passpoint: '" + config.SSID +
+                        "' FQDN " + toHexString(config.FQDN);
+            }
+            /* this is passpoint configuration; it must have a providerFriendlyName */
+            if (TextUtils.isEmpty(config.providerFriendlyName)) {
+                return "no provider friendly name";
+            }
+            WifiEnterpriseConfig enterpriseConfig = config.enterpriseConfig;
+            /* this is passpoint configuration; it must have enterprise config */
+            if (enterpriseConfig == null
+                    || enterpriseConfig.getEapMethod() == WifiEnterpriseConfig.Eap.NONE ) {
+                return "no enterprise config";
+            }
+            if ((enterpriseConfig.getEapMethod() == WifiEnterpriseConfig.Eap.TLS ||
+                    enterpriseConfig.getEapMethod() == WifiEnterpriseConfig.Eap.TTLS ||
+                    enterpriseConfig.getEapMethod() == WifiEnterpriseConfig.Eap.PEAP) &&
+                    enterpriseConfig.getCaCertificate() == null) {
+                return "no CA certificate";
+            }
+        }
+        return null;
+    }
+
+    public Network getCurrentNetwork() {
+        enforceAccessPermission();
+        return mWifiStateMachine.getCurrentNetwork();
+    }
+
+    public static String toHexString(String s) {
+        if (s == null) {
+            return "null";
+        }
+        StringBuilder sb = new StringBuilder();
+        sb.append('\'').append(s).append('\'');
+        for (int n = 0; n < s.length(); n++) {
+            sb.append(String.format(" %02x", s.charAt(n) & 0xffff));
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Checks that calling process has android.Manifest.permission.ACCESS_COARSE_LOCATION or
+     * android.Manifest.permission.ACCESS_FINE_LOCATION and a corresponding app op is allowed
+     */
+    private boolean checkCallerCanAccessScanResults(String callingPackage, int uid) {
+        if (ActivityManager.checkUidPermission(Manifest.permission.ACCESS_FINE_LOCATION, uid)
+                == PackageManager.PERMISSION_GRANTED
+                && isAppOppAllowed(AppOpsManager.OP_FINE_LOCATION, callingPackage, uid)) {
+            return true;
+        }
+
+        if (ActivityManager.checkUidPermission(Manifest.permission.ACCESS_COARSE_LOCATION, uid)
+                == PackageManager.PERMISSION_GRANTED
+                && isAppOppAllowed(AppOpsManager.OP_COARSE_LOCATION, callingPackage, uid)) {
+            return true;
+        }
+        // Enforce location permission for apps targeting M and later versions
+        boolean enforceLocationPermission = true;
+        try {
+            enforceLocationPermission = mContext.getPackageManager().getApplicationInfo(
+                    callingPackage, 0).targetSdkVersion >= Build.VERSION_CODES.M;
+        } catch (PackageManager.NameNotFoundException e) {
+            // In case of exception, enforce permission anyway
+        }
+        if (enforceLocationPermission) {
+            throw new SecurityException("Need ACCESS_COARSE_LOCATION or "
+                    + "ACCESS_FINE_LOCATION permission to get scan results");
+        }
+        // Pre-M apps running in the foreground should continue getting scan results
+        if (isForegroundApp(callingPackage)) {
+            return true;
+        }
+        Log.e(TAG, "Permission denial: Need ACCESS_COARSE_LOCATION or ACCESS_FINE_LOCATION "
+                + "permission to get scan results");
+        return false;
+    }
+
+    private boolean isAppOppAllowed(int op, String callingPackage, int uid) {
+        return mAppOps.noteOp(op, uid, callingPackage) == AppOpsManager.MODE_ALLOWED;
+    }
+
+    /**
+     * Return true if the specified package name is a foreground app.
+     *
+     * @param pkgName application package name.
+     */
+    private boolean isForegroundApp(String pkgName) {
+        ActivityManager am = (ActivityManager)mContext.getSystemService(Context.ACTIVITY_SERVICE);
+        List<ActivityManager.RunningTaskInfo> tasks = am.getRunningTasks(1);
+        return !tasks.isEmpty() && pkgName.equals(tasks.get(0).topActivity.getPackageName());
+    }
+
 }
diff --git a/service/java/com/android/server/wifi/WifiStateMachine.java b/service/java/com/android/server/wifi/WifiStateMachine.java
index fb9e9fd..4bc62b3 100644
--- a/service/java/com/android/server/wifi/WifiStateMachine.java
+++ b/service/java/com/android/server/wifi/WifiStateMachine.java
@@ -31,6 +31,7 @@
  */
 import static android.net.wifi.WifiManager.WIFI_STATE_UNKNOWN;
 
+import android.Manifest;
 import android.app.ActivityManager;
 import android.app.AlarmManager;
 import android.app.PendingIntent;
@@ -40,12 +41,18 @@
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
+import android.content.pm.ApplicationInfo;
+import android.content.pm.IPackageManager;
 import android.content.pm.PackageManager;
 import android.database.ContentObserver;
 import android.net.ConnectivityManager;
 import android.net.DhcpResults;
+import android.net.BaseDhcpStateMachine;
 import android.net.DhcpStateMachine;
+import android.net.Network;
+import android.net.dhcp.DhcpClient;
 import android.net.InterfaceConfiguration;
+import android.net.IpReachabilityMonitor;
 import android.net.LinkAddress;
 import android.net.LinkProperties;
 import android.net.NetworkAgent;
@@ -58,8 +65,6 @@
 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;
@@ -71,12 +76,14 @@
 import android.net.wifi.WifiInfo;
 import android.net.wifi.WifiLinkLayerStats;
 import android.net.wifi.WifiManager;
+import android.net.wifi.WifiScanner;
 import android.net.wifi.WifiSsid;
 import android.net.wifi.WpsInfo;
 import android.net.wifi.WpsResult;
 import android.net.wifi.WpsResult.Status;
 import android.net.wifi.p2p.IWifiP2pManager;
 import android.os.BatteryStats;
+import android.os.Binder;
 import android.os.Bundle;
 import android.os.IBinder;
 import android.os.INetworkManagementService;
@@ -104,6 +111,9 @@
 import com.android.internal.util.State;
 import com.android.internal.util.StateMachine;
 import com.android.server.net.NetlinkTracker;
+import com.android.server.wifi.hotspot2.NetworkDetail;
+import com.android.server.wifi.hotspot2.SupplicantBridge;
+import com.android.server.wifi.hotspot2.Utils;
 import com.android.server.wifi.p2p.WifiP2pServiceImpl;
 
 import java.io.BufferedReader;
@@ -115,14 +125,15 @@
 import java.net.Inet4Address;
 import java.net.InetAddress;
 import java.util.ArrayList;
+import java.util.Calendar;
 import java.util.HashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Locale;
 import java.util.Queue;
+import java.util.Random;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
 /**
@@ -136,14 +147,16 @@
  *
  * @hide
  */
-public class WifiStateMachine extends StateMachine {
+public class WifiStateMachine extends StateMachine implements WifiNative.WifiPnoEventHandler {
 
     private static final String NETWORKTYPE = "WIFI";
     private static final String NETWORKTYPE_UNTRUSTED = "WIFI_UT";
     private static boolean DBG = false;
     private static boolean VDBG = false;
     private static boolean VVDBG = false;
+    private static boolean USE_PAUSE_SCANS = false;
     private static boolean mLogMessages = false;
+    private static final String TAG = "WifiStateMachine";
 
     private static final int ONE_HOUR_MILLI = 1000 * 60 * 60;
 
@@ -165,8 +178,11 @@
     protected void loge(String s) {
         Log.e(getName(), s);
     }
+    protected void logd(String s) {
+        Log.d(getName(), s);
+    }
     protected void log(String s) {;
-        Log.e(getName(), s);
+        Log.d(getName(), s);
     }
 
     private WifiMonitor mWifiMonitor;
@@ -175,35 +191,29 @@
     private WifiAutoJoinController mWifiAutoJoinController;
     private INetworkManagementService mNwService;
     private ConnectivityManager mCm;
-
+    private WifiLogger mWifiLogger;
+    private WifiApConfigStore mWifiApConfigStore;
     private final boolean mP2pSupported;
     private final AtomicBoolean mP2pConnected = new AtomicBoolean(false);
     private boolean mTemporarilyDisconnectWifi = false;
     private final String mPrimaryDeviceType;
 
     /* Scan results handling */
-    private List<ScanResult> mScanResults = new ArrayList<ScanResult>();
+    private List<ScanDetail> mScanResults = new ArrayList<>();
     private static final Pattern scanResultPattern = Pattern.compile("\t+");
     private static final int SCAN_RESULT_CACHE_SIZE = 160;
-    private final LruCache<String, ScanResult> mScanResultCache;
+    private final LruCache<NetworkDetail, ScanDetail> mScanResultCache;
     // For debug, number of known scan results that were found as part of last scan result event,
     // as well the number of scans results returned by the supplicant with that message
     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 */
     private final boolean mBackgroundScanSupported;
 
-    private String mInterfaceName;
+    private final String mInterfaceName;
     /* Tethering interface could be separate from wlan interface */
     private String mTetherInterfaceName;
 
@@ -212,12 +222,66 @@
     private int mLastNetworkId; // The network Id we successfully joined
     private boolean linkDebouncing = false;
 
+    private boolean mHalBasedPnoDriverSupported = false;
+
+    // Below booleans are configurations coming from the Developper Settings
+    private boolean mEnableAssociatedNetworkSwitchingInDevSettings = true;
+    private boolean mHalBasedPnoEnableInDevSettings = false;
+
+
+    private int mHalFeatureSet = 0;
+    private static int mPnoResultFound = 0;
+
+    @Override
+    public void onPnoNetworkFound(ScanResult results[]) {
+        if (DBG) {
+            Log.e(TAG, "onPnoNetworkFound event received num = " + results.length);
+            for (int i = 0; i < results.length; i++) {
+                Log.e(TAG, results[i].toString());
+            }
+        }
+        sendMessage(CMD_PNO_NETWORK_FOUND, results.length, 0, results);
+    }
+
+    public void processPnoNetworkFound(ScanResult results[]) {
+        ScanSettings settings = new ScanSettings();
+        settings.channelSet = new ArrayList<WifiChannel>();
+        StringBuilder sb = new StringBuilder();
+        sb.append("");
+        for (int i=0; i<results.length; i++) {
+            WifiChannel channel = new WifiChannel();
+            channel.freqMHz = results[i].frequency;
+            settings.channelSet.add(channel);
+            sb.append(results[i].SSID).append(" ");
+        }
+
+        stopPnoOffload();
+
+        Log.e(TAG, "processPnoNetworkFound starting scan cnt=" + mPnoResultFound);
+        startScan(PNO_NETWORK_FOUND_SOURCE, mPnoResultFound,  settings, null);
+        mPnoResultFound ++;
+        //sendMessage(CMD_SCAN_RESULTS_AVAILABLE);
+        int delay = 30 * 1000;
+        // reconfigure Pno after 1 minutes if we're still in disconnected state
+        sendMessageDelayed(CMD_RESTART_AUTOJOIN_OFFLOAD, delay,
+                mRestartAutoJoinOffloadCounter, " processPnoNetworkFound " + sb.toString(),
+                (long)delay);
+        mRestartAutoJoinOffloadCounter++;
+    }
+
+    public void registerNetworkDisabled(int netId) {
+        // Restart legacy PNO and autojoin offload if needed
+        sendMessage(CMD_RESTART_AUTOJOIN_OFFLOAD, 0,
+                mRestartAutoJoinOffloadCounter, " registerNetworkDisabled " + netId);
+        mRestartAutoJoinOffloadCounter++;
+    }
+
     // Testing various network disconnect cases by sending lots of spurious
     // disconnect to supplicant
     private boolean testNetworkDisconnect = false;
 
     private boolean mEnableRssiPolling = false;
-    private boolean mEnableBackgroundScan = false;
+    private boolean mLegacyPnoEnabled = false;
     private int mRssiPollToken = 0;
     /* 3 operational states for STA operation: CONNECT_MODE, SCAN_ONLY_MODE, SCAN_ONLY_WIFI_OFF_MODE
     * In CONNECT_MODE, the STA can scan and connect to an access point
@@ -237,15 +301,13 @@
     private static final int SET_ALLOW_UNTRUSTED_SOURCE = -4;
     private static final int ENABLE_WIFI = -5;
     public static final int DFS_RESTRICTED_SCAN_REQUEST = -6;
+    public static final int PNO_NETWORK_FOUND_SOURCE = -7;
 
     private static final int SCAN_REQUEST_BUFFER_MAX_SIZE = 10;
     private static final String CUSTOMIZED_SCAN_SETTING = "customized_scan_settings";
     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.
      */
@@ -298,6 +360,12 @@
     private int mDriverStartToken = 0;
 
     /**
+     * Don't select new network when previous network selection is
+     * pending connection for this much time
+     */
+    private static final int CONNECT_TIMEOUT_MSEC = 3000;
+
+    /**
      * The link properties of the wifi interface.
      * Do not modify this directly; use updateLinkProperties instead.
      */
@@ -313,11 +381,13 @@
 
     private final Object mDhcpResultsLock = new Object();
     private DhcpResults mDhcpResults;
+
+    // NOTE: Do not return to clients - use #getWiFiInfoForUid(int)
     private WifiInfo mWifiInfo;
     private NetworkInfo mNetworkInfo;
     private NetworkCapabilities mNetworkCapabilities;
     private SupplicantStateTracker mSupplicantStateTracker;
-    private DhcpStateMachine mDhcpStateMachine;
+    private BaseDhcpStateMachine mDhcpStateMachine;
     private boolean mDhcpActive = false;
 
     private int mWifiLinkLayerStatsSupported = 4; // Temporary disable
@@ -346,6 +416,9 @@
     // Used as debug to indicate which configuration last was removed
     private WifiConfiguration lastForgetConfigurationAttempt = null;
 
+    //Random used by softAP channel Selection
+    private static Random mRandom = new Random(Calendar.getInstance().getTimeInMillis());
+
     boolean isRoaming() {
         return mAutoRoaming == WifiAutoJoinController.AUTO_JOIN_ROAMING
                 || mAutoRoaming == WifiAutoJoinController.AUTO_JOIN_EXTENDED_ROAMING;
@@ -367,12 +440,11 @@
         if (!mTargetRoamBSSID.equals("any") && bssid.equals("any")) {
             // Changing to ANY
             if (!mWifiConfigStore.roamOnAny) {
-                ret =  false; // Nothing to do
+                ret = false; // Nothing to do
             }
         }
         if (VDBG) {
-           loge("autoRoamSetBSSID " + bssid
-                   + " key=" + config.configKey());
+            logd("autoRoamSetBSSID " + bssid + " key=" + config.configKey());
         }
         config.autoJoinBSSID = bssid;
         mTargetRoamBSSID = bssid;
@@ -381,17 +453,71 @@
     }
 
     /**
+     * Save the UID correctly depending on if this is a new or existing network.
+     * @return true if operation is authorized, false otherwise
+     */
+    boolean recordUidIfAuthorized(WifiConfiguration config, int uid, boolean onlyAnnotate) {
+        if (!mWifiConfigStore.isNetworkConfigured(config)) {
+            config.creatorUid = uid;
+            config.creatorName = mContext.getPackageManager().getNameForUid(uid);
+        } else if (!mWifiConfigStore.canModifyNetwork(uid, config, onlyAnnotate)) {
+            return false;
+        }
+
+        config.lastUpdateUid = uid;
+        config.lastUpdateName = mContext.getPackageManager().getNameForUid(uid);
+
+        return true;
+
+    }
+
+    /**
+     * Checks to see if user has specified if the apps configuration is connectable.
+     * If the user hasn't specified we query the user and return true.
+     *
+     * @param message The message to be deferred
+     * @param netId Network id of the configuration to check against
+     * @param allowOverride If true we won't defer to the user if the uid of the message holds the
+     *                      CONFIG_OVERRIDE_PERMISSION
+     * @return True if we are waiting for user feedback or netId is invalid. False otherwise.
+     */
+    boolean deferForUserInput(Message message, int netId, boolean allowOverride){
+        final WifiConfiguration config = mWifiConfigStore.getWifiConfiguration(netId);
+
+        // We can only evaluate saved configurations.
+        if (config == null) {
+            logd("deferForUserInput: configuration for netId=" + netId + " not stored");
+            return true;
+        }
+
+        switch (config.userApproved) {
+            case WifiConfiguration.USER_APPROVED:
+            case WifiConfiguration.USER_BANNED:
+                return false;
+            case WifiConfiguration.USER_PENDING:
+            default: // USER_UNSPECIFIED
+               /* the intention was to ask user here; but a dialog box is   *
+                * too invasive; so we are going to allow connection for now */
+                config.userApproved = WifiConfiguration.USER_APPROVED;
+                return false;
+        }
+    }
+
+    /**
      * Subset of link properties coming from netlink.
      * Currently includes IPv4 and IPv6 addresses. In the future will also include IPv6 DNS servers
      * and domains obtained from router advertisements (RFC 6106).
      */
     private NetlinkTracker mNetlinkTracker;
 
+    private IpReachabilityMonitor mIpReachabilityMonitor;
+
     private AlarmManager mAlarmManager;
     private PendingIntent mScanIntent;
     private PendingIntent mDriverStopIntent;
-    private PendingIntent mBatchedScanIntervalIntent;
+    private PendingIntent mPnoIntent;
 
+    private int mDisconnectedPnoAlarmCount = 0;
     /* Tracks current frequency mode */
     private AtomicInteger mFrequencyBand = new AtomicInteger(WifiManager.WIFI_FREQUENCY_BAND_AUTO);
 
@@ -407,11 +533,15 @@
     private AsyncChannel mWifiP2pChannel;
     private AsyncChannel mWifiApConfigChannel;
 
+    private WifiScanner mWifiScanner;
+
     private int mConnectionRequests = 0;
     private WifiNetworkFactory mNetworkFactory;
     private UntrustedWifiNetworkFactory mUntrustedNetworkFactory;
     private WifiNetworkAgent mNetworkAgent;
 
+    private String[] mWhiteListedSsids = null;
+
     // Keep track of various statistics, for retrieval by System Apps, i.e. under @SystemApi
     // We should really persist that into the networkHistory.txt file, and read it back when
     // WifiStateMachine starts up
@@ -423,87 +553,87 @@
     /* The base for wifi message types */
     static final int BASE = Protocol.BASE_WIFI;
     /* Start the supplicant */
-    static final int CMD_START_SUPPLICANT                 = BASE + 11;
+    static final int CMD_START_SUPPLICANT                               = BASE + 11;
     /* Stop the supplicant */
-    static final int CMD_STOP_SUPPLICANT                  = BASE + 12;
+    static final int CMD_STOP_SUPPLICANT                                = BASE + 12;
     /* Start the driver */
-    static final int CMD_START_DRIVER                     = BASE + 13;
+    static final int CMD_START_DRIVER                                   = BASE + 13;
     /* Stop the driver */
-    static final int CMD_STOP_DRIVER                      = BASE + 14;
+    static final int CMD_STOP_DRIVER                                    = BASE + 14;
     /* Indicates Static IP succeeded */
-    static final int CMD_STATIC_IP_SUCCESS                = BASE + 15;
+    static final int CMD_STATIC_IP_SUCCESS                              = BASE + 15;
     /* Indicates Static IP failed */
-    static final int CMD_STATIC_IP_FAILURE                = BASE + 16;
+    static final int CMD_STATIC_IP_FAILURE                              = BASE + 16;
     /* Indicates supplicant stop failed */
-    static final int CMD_STOP_SUPPLICANT_FAILED           = BASE + 17;
+    static final int CMD_STOP_SUPPLICANT_FAILED                         = BASE + 17;
     /* Delayed stop to avoid shutting down driver too quick*/
-    static final int CMD_DELAYED_STOP_DRIVER              = BASE + 18;
+    static final int CMD_DELAYED_STOP_DRIVER                            = BASE + 18;
     /* A delayed message sent to start driver when it fail to come up */
-    static final int CMD_DRIVER_START_TIMED_OUT           = BASE + 19;
+    static final int CMD_DRIVER_START_TIMED_OUT                         = BASE + 19;
 
     /* Start the soft access point */
-    static final int CMD_START_AP                         = BASE + 21;
+    static final int CMD_START_AP                                       = BASE + 21;
     /* Indicates soft ap start succeeded */
-    static final int CMD_START_AP_SUCCESS                 = BASE + 22;
+    static final int CMD_START_AP_SUCCESS                               = BASE + 22;
     /* Indicates soft ap start failed */
-    static final int CMD_START_AP_FAILURE                 = BASE + 23;
+    static final int CMD_START_AP_FAILURE                               = BASE + 23;
     /* Stop the soft access point */
-    static final int CMD_STOP_AP                          = BASE + 24;
+    static final int CMD_STOP_AP                                        = BASE + 24;
     /* Set the soft access point configuration */
-    static final int CMD_SET_AP_CONFIG                    = BASE + 25;
+    static final int CMD_SET_AP_CONFIG                                  = BASE + 25;
     /* Soft access point configuration set completed */
-    static final int CMD_SET_AP_CONFIG_COMPLETED          = BASE + 26;
+    static final int CMD_SET_AP_CONFIG_COMPLETED                        = BASE + 26;
     /* Request the soft access point configuration */
-    static final int CMD_REQUEST_AP_CONFIG                = BASE + 27;
+    static final int CMD_REQUEST_AP_CONFIG                              = BASE + 27;
     /* Response to access point configuration request */
-    static final int CMD_RESPONSE_AP_CONFIG               = BASE + 28;
+    static final int CMD_RESPONSE_AP_CONFIG                             = BASE + 28;
     /* Invoked when getting a tether state change notification */
-    static final int CMD_TETHER_STATE_CHANGE              = BASE + 29;
+    static final int CMD_TETHER_STATE_CHANGE                            = BASE + 29;
     /* A delayed message sent to indicate tether state change failed to arrive */
-    static final int CMD_TETHER_NOTIFICATION_TIMED_OUT    = BASE + 30;
+    static final int CMD_TETHER_NOTIFICATION_TIMED_OUT                  = BASE + 30;
 
-    static final int CMD_BLUETOOTH_ADAPTER_STATE_CHANGE   = BASE + 31;
+    static final int CMD_BLUETOOTH_ADAPTER_STATE_CHANGE                 = BASE + 31;
 
     /* Supplicant commands */
     /* Is supplicant alive ? */
-    static final int CMD_PING_SUPPLICANT                  = BASE + 51;
+    static final int CMD_PING_SUPPLICANT                                = BASE + 51;
     /* Add/update a network configuration */
-    static final int CMD_ADD_OR_UPDATE_NETWORK            = BASE + 52;
+    static final int CMD_ADD_OR_UPDATE_NETWORK                          = BASE + 52;
     /* Delete a network */
-    static final int CMD_REMOVE_NETWORK                   = BASE + 53;
+    static final int CMD_REMOVE_NETWORK                                 = BASE + 53;
     /* Enable a network. The device will attempt a connection to the given network. */
-    static final int CMD_ENABLE_NETWORK                   = BASE + 54;
+    static final int CMD_ENABLE_NETWORK                                 = BASE + 54;
     /* Enable all networks */
-    static final int CMD_ENABLE_ALL_NETWORKS              = BASE + 55;
+    static final int CMD_ENABLE_ALL_NETWORKS                            = BASE + 55;
     /* Blacklist network. De-prioritizes the given BSSID for connection. */
-    static final int CMD_BLACKLIST_NETWORK                = BASE + 56;
+    static final int CMD_BLACKLIST_NETWORK                              = BASE + 56;
     /* Clear the blacklist network list */
-    static final int CMD_CLEAR_BLACKLIST                  = BASE + 57;
+    static final int CMD_CLEAR_BLACKLIST                                = BASE + 57;
     /* Save configuration */
-    static final int CMD_SAVE_CONFIG                      = BASE + 58;
+    static final int CMD_SAVE_CONFIG                                    = BASE + 58;
     /* Get configured networks */
-    static final int CMD_GET_CONFIGURED_NETWORKS          = BASE + 59;
+    static final int CMD_GET_CONFIGURED_NETWORKS                        = BASE + 59;
     /* Get available frequencies */
-    static final int CMD_GET_CAPABILITY_FREQ              = BASE + 60;
+    static final int CMD_GET_CAPABILITY_FREQ                            = BASE + 60;
     /* Get adaptors */
-    static final int CMD_GET_SUPPORTED_FEATURES           = BASE + 61;
+    static final int CMD_GET_SUPPORTED_FEATURES                         = BASE + 61;
     /* Get configured networks with real preSharedKey */
-    static final int CMD_GET_PRIVILEGED_CONFIGURED_NETWORKS = BASE + 62;
+    static final int CMD_GET_PRIVILEGED_CONFIGURED_NETWORKS             = BASE + 62;
     /* Get Link Layer Stats thru HAL */
-    static final int CMD_GET_LINK_LAYER_STATS             = BASE + 63;
+    static final int CMD_GET_LINK_LAYER_STATS                           = BASE + 63;
     /* Supplicant commands after driver start*/
     /* Initiate a scan */
-    static final int CMD_START_SCAN                       = BASE + 71;
+    static final int CMD_START_SCAN                                     = BASE + 71;
     /* Set operational mode. CONNECT, SCAN ONLY, SCAN_ONLY with Wi-Fi off mode */
-    static final int CMD_SET_OPERATIONAL_MODE             = BASE + 72;
+    static final int CMD_SET_OPERATIONAL_MODE                           = BASE + 72;
     /* Disconnect from a network */
-    static final int CMD_DISCONNECT                       = BASE + 73;
+    static final int CMD_DISCONNECT                                     = BASE + 73;
     /* Reconnect to a network */
-    static final int CMD_RECONNECT                        = BASE + 74;
+    static final int CMD_RECONNECT                                      = BASE + 74;
     /* Reassociate to a network */
-    static final int CMD_REASSOCIATE                      = BASE + 75;
+    static final int CMD_REASSOCIATE                                    = BASE + 75;
     /* Get Connection Statistis */
-    static final int CMD_GET_CONNECTION_STATISTICS        = BASE + 76;
+    static final int CMD_GET_CONNECTION_STATISTICS                      = BASE + 76;
 
     /* Controls suspend mode optimizations
      *
@@ -516,38 +646,66 @@
      * - turn off roaming
      * - DTIM wake up settings
      */
-    static final int CMD_SET_HIGH_PERF_MODE               = BASE + 77;
+    static final int CMD_SET_HIGH_PERF_MODE                             = BASE + 77;
     /* Set the country code */
-    static final int CMD_SET_COUNTRY_CODE                 = BASE + 80;
+    static final int CMD_SET_COUNTRY_CODE                               = BASE + 80;
     /* Enables RSSI poll */
-    static final int CMD_ENABLE_RSSI_POLL                 = BASE + 82;
+    static final int CMD_ENABLE_RSSI_POLL                               = BASE + 82;
     /* RSSI poll */
-    static final int CMD_RSSI_POLL                        = BASE + 83;
+    static final int CMD_RSSI_POLL                                      = BASE + 83;
     /* Set up packet filtering */
-    static final int CMD_START_PACKET_FILTERING           = BASE + 84;
+    static final int CMD_START_PACKET_FILTERING                         = BASE + 84;
     /* Clear packet filter */
-    static final int CMD_STOP_PACKET_FILTERING            = BASE + 85;
+    static final int CMD_STOP_PACKET_FILTERING                          = BASE + 85;
     /* Enable suspend mode optimizations in the driver */
-    static final int CMD_SET_SUSPEND_OPT_ENABLED          = BASE + 86;
+    static final int CMD_SET_SUSPEND_OPT_ENABLED                        = BASE + 86;
     /* Delayed NETWORK_DISCONNECT */
-    static final int CMD_DELAYED_NETWORK_DISCONNECT       = BASE + 87;
+    static final int CMD_DELAYED_NETWORK_DISCONNECT                     = BASE + 87;
     /* When there are no saved networks, we do a periodic scan to notify user of
      * an open network */
-    static final int CMD_NO_NETWORKS_PERIODIC_SCAN        = BASE + 88;
+    static final int CMD_NO_NETWORKS_PERIODIC_SCAN                      = BASE + 88;
     /* Test network Disconnection NETWORK_DISCONNECT */
-    static final int CMD_TEST_NETWORK_DISCONNECT          = BASE + 89;
+    static final int CMD_TEST_NETWORK_DISCONNECT                        = BASE + 89;
+
     private int testNetworkDisconnectCounter = 0;
 
     /* arg1 values to CMD_STOP_PACKET_FILTERING and CMD_START_PACKET_FILTERING */
-    static final int MULTICAST_V6  = 1;
-    static final int MULTICAST_V4  = 0;
+    static final int MULTICAST_V6 = 1;
+    static final int MULTICAST_V4 = 0;
 
-   /* Set the frequency band */
-    static final int CMD_SET_FREQUENCY_BAND               = BASE + 90;
+    /* Set the frequency band */
+    static final int CMD_SET_FREQUENCY_BAND                             = BASE + 90;
     /* Enable TDLS on a specific MAC address */
-    static final int CMD_ENABLE_TDLS                      = BASE + 92;
+    static final int CMD_ENABLE_TDLS                                    = BASE + 92;
     /* DHCP/IP configuration watchdog */
-    static final int CMD_OBTAINING_IP_ADDRESS_WATCHDOG_TIMER    = BASE + 93;
+    static final int CMD_OBTAINING_IP_ADDRESS_WATCHDOG_TIMER            = BASE + 93;
+
+    /**
+     * Watchdog for protecting against b/16823537
+     * Leave time for 4-way handshake to succeed
+     */
+    static final int ROAM_GUARD_TIMER_MSEC = 15000;
+
+    int roamWatchdogCount = 0;
+    /* Roam state watchdog */
+    static final int CMD_ROAM_WATCHDOG_TIMER                            = BASE + 94;
+    /* Screen change intent handling */
+    static final int CMD_SCREEN_STATE_CHANGED                           = BASE + 95;
+
+    /* Disconnecting state watchdog */
+    static final int CMD_DISCONNECTING_WATCHDOG_TIMER                   = BASE + 96;
+
+    /* Remove a packages associated configrations */
+    static final int CMD_REMOVE_APP_CONFIGURATIONS                      = BASE + 97;
+
+    /* Disable an ephemeral network */
+    static final int CMD_DISABLE_EPHEMERAL_NETWORK                      = BASE + 98;
+
+    /* Get matching network */
+    static final int CMD_GET_MATCHING_CONFIG                            = BASE + 99;
+
+    /* alert from firmware */
+    static final int CMD_FIRMWARE_ALERT                                 = BASE + 100;
 
     /**
      * Make this timer 40 seconds, which is about the normal DHCP timeout.
@@ -560,84 +718,82 @@
 
     /* Commands from/to the SupplicantStateTracker */
     /* Reset the supplicant state tracker */
-    static final int CMD_RESET_SUPPLICANT_STATE           = BASE + 111;
-
-
-    /**
-     * Watchdog for protecting against b/16823537
-     * Leave time for 4-ways handshake to succeed
-     */
-    static final int ROAM_GUARD_TIMER_MSEC = 15000;
-
-    int roamWatchdogCount = 0;
-    /* Roam state watchdog */
-    static final int CMD_ROAM_WATCHDOG_TIMER    = BASE + 94;
-    /* Screen change intent handling */
-    static final int CMD_SCREEN_STATE_CHANGED              = BASE + 95;
+    static final int CMD_RESET_SUPPLICANT_STATE                         = BASE + 111;
 
     int disconnectingWatchdogCount = 0;
     static final int DISCONNECTING_GUARD_TIMER_MSEC = 5000;
 
-    /* Disconnecting state watchdog */
-    static final int CMD_DISCONNECTING_WATCHDOG_TIMER     = BASE + 96;
-
-    /* Disable an ephemeral network */
-    static final int CMD_DISABLE_EPHEMERAL_NETWORK = BASE + 98;
-
     /* P2p commands */
     /* We are ok with no response here since we wont do much with it anyway */
-    public static final int CMD_ENABLE_P2P                = BASE + 131;
+    public static final int CMD_ENABLE_P2P                              = BASE + 131;
     /* In order to shut down supplicant cleanly, we wait till p2p has
      * been disabled */
-    public static final int CMD_DISABLE_P2P_REQ           = BASE + 132;
-    public static final int CMD_DISABLE_P2P_RSP           = BASE + 133;
+    public static final int CMD_DISABLE_P2P_REQ                         = BASE + 132;
+    public static final int CMD_DISABLE_P2P_RSP                         = BASE + 133;
 
-    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;
+    public static final int CMD_BOOT_COMPLETED                          = BASE + 134;
 
     /* We now have a valid IP configuration. */
-    static final int CMD_IP_CONFIGURATION_SUCCESSFUL      = BASE + 138;
+    static final int CMD_IP_CONFIGURATION_SUCCESSFUL                    = BASE + 138;
     /* We no longer have a valid IP configuration. */
-    static final int CMD_IP_CONFIGURATION_LOST            = BASE + 139;
+    static final int CMD_IP_CONFIGURATION_LOST                          = BASE + 139;
     /* Link configuration (IP address, DNS, ...) changes notified via netlink */
-    static final int CMD_UPDATE_LINKPROPERTIES            = BASE + 140;
+    static final int CMD_UPDATE_LINKPROPERTIES                          = BASE + 140;
 
     /* Supplicant is trying to associate to a given BSSID */
-    static final int CMD_TARGET_BSSID                     = BASE + 141;
+    static final int CMD_TARGET_BSSID                                   = BASE + 141;
 
     /* Reload all networks and reconnect */
-    static final int CMD_RELOAD_TLS_AND_RECONNECT         = BASE + 142;
+    static final int CMD_RELOAD_TLS_AND_RECONNECT                       = BASE + 142;
 
-    static final int CMD_AUTO_CONNECT                     = BASE + 143;
+    static final int CMD_AUTO_CONNECT                                   = BASE + 143;
 
-    static final int network_status_unwanted_disconnect = 0;
-    static final int network_status_unwanted_disable_autojoin = 1;
+    private static final int NETWORK_STATUS_UNWANTED_DISCONNECT         = 0;
+    private static final int NETWORK_STATUS_UNWANTED_VALIDATION_FAILED  = 1;
+    private static final int NETWORK_STATUS_UNWANTED_DISABLE_AUTOJOIN   = 2;
 
-    static final int CMD_UNWANTED_NETWORK                 = BASE + 144;
+    static final int CMD_UNWANTED_NETWORK                               = BASE + 144;
 
-    static final int CMD_AUTO_ROAM                        = BASE + 145;
+    static final int CMD_AUTO_ROAM                                      = BASE + 145;
 
-    static final int CMD_AUTO_SAVE_NETWORK                = BASE + 146;
+    static final int CMD_AUTO_SAVE_NETWORK                              = BASE + 146;
 
-    static final int CMD_ASSOCIATED_BSSID                = BASE + 147;
+    static final int CMD_ASSOCIATED_BSSID                               = BASE + 147;
 
-    static final int CMD_NETWORK_STATUS                  = BASE + 148;
+    static final int CMD_NETWORK_STATUS                                 = BASE + 148;
+
+    /* A layer 3 neighbor on the Wi-Fi link became unreachable. */
+    static final int CMD_IP_REACHABILITY_LOST                           = BASE + 149;
+
+    /* Remove a packages associated configrations */
+    static final int CMD_REMOVE_USER_CONFIGURATIONS                     = BASE + 152;
+
+    static final int CMD_ACCEPT_UNVALIDATED                             = BASE + 153;
+
+    /* used to restart PNO when it was stopped due to association attempt */
+    static final int CMD_RESTART_AUTOJOIN_OFFLOAD                       = BASE + 154;
+
+    static int mRestartAutoJoinOffloadCounter = 0;
+
+    /* used to log if PNO was started */
+    static final int CMD_STARTED_PNO_DBG                                = BASE + 155;
+
+    static final int CMD_PNO_NETWORK_FOUND                              = BASE + 156;
+
+    /* used to log if PNO was started */
+    static final int CMD_UPDATE_ASSOCIATED_SCAN_PERMISSION              = BASE + 158;
+
+    /* used to log if GSCAN was started */
+    static final int CMD_STARTED_GSCAN_DBG                              = BASE + 159;
+
 
     /* Wifi state machine modes of operation */
     /* CONNECT_MODE - connect to any 'known' AP when it becomes available */
-    public static final int CONNECT_MODE                   = 1;
+    public static final int CONNECT_MODE = 1;
     /* SCAN_ONLY_MODE - don't connect to any APs; scan, but only while apps hold lock */
-    public static final int SCAN_ONLY_MODE                 = 2;
+    public static final int SCAN_ONLY_MODE = 2;
     /* SCAN_ONLY_WITH_WIFI_OFF - scan, but don't connect to any APs */
-    public static final int SCAN_ONLY_WITH_WIFI_OFF_MODE   = 3;
+    public static final int SCAN_ONLY_WITH_WIFI_OFF_MODE = 3;
 
     private static final int SUCCESS = 1;
     private static final int FAILURE = -1;
@@ -649,9 +805,9 @@
      */
     private int mSuspendOptNeedsDisabled = 0;
 
-    private static final int SUSPEND_DUE_TO_DHCP       = 1;
-    private static final int SUSPEND_DUE_TO_HIGH_PERF  = 1<<1;
-    private static final int SUSPEND_DUE_TO_SCREEN     = 1<<2;
+    private static final int SUSPEND_DUE_TO_DHCP = 1;
+    private static final int SUSPEND_DUE_TO_HIGH_PERF = 1 << 1;
+    private static final int SUSPEND_DUE_TO_SCREEN = 1 << 2;
 
     /* Tracks if user has enabled suspend optimizations through settings */
     private AtomicBoolean mUserWantsSuspendOpt = new AtomicBoolean(true);
@@ -665,7 +821,11 @@
      */
     private final int mDefaultFrameworkScanIntervalMs;
 
-    private int mDisconnectedScanPeriodMs = 10000;
+
+    /**
+     * Scan period for the NO_NETWORKS_PERIIDOC_SCAN_FEATURE
+     */
+    private final int mNoNetworksPeriodicScan;
 
     /**
      * Supplicant scan interval in milliseconds.
@@ -690,7 +850,7 @@
      * autojoin while connected with screen lit
      * Max time is 5 minutes
      */
-    private static final long  maxFullBandConnectedTimeIntervalMilli = 1000 * 60 * 5;
+    private static final long maxFullBandConnectedTimeIntervalMilli = 1000 * 60 * 5;
 
     /**
      * Minimum time interval between enabling all networks.
@@ -710,13 +870,14 @@
     private int mDelayedStopCounter;
     private boolean mInDelayedStop = false;
 
-    // sometimes telephony gives us this data before boot is complete and we can't store it
-    // until after, so the write is deferred
-    private volatile String mPersistedCountryCode;
+    // there is a delay between StateMachine change country code and Supplicant change country code
+    // here save the current WifiStateMachine set country code
+    private volatile String mSetCountryCode = null;
 
     // Supplicant doesn't like setting the same country code multiple times (it may drop
-    // currently connected network), so we save the country code here to avoid redundency
-    private String mLastSetCountryCode;
+    // currently connected network), so we save the current device set country code here to avoid
+    // redundency
+    private String mDriverSetCountryCode = null;
 
     /* Default parent state */
     private State mDefaultState = new DefaultState();
@@ -773,9 +934,40 @@
     /* Waiting for untether confirmation before stopping soft Ap */
     private State mUntetheringState = new UntetheringState();
 
+
+
+    private class WifiScanListener implements WifiScanner.ScanListener {
+        @Override
+        public void onSuccess() {
+            Log.e(TAG, "WifiScanListener onSuccess");
+        };
+        @Override
+        public void onFailure(int reason, String description) {
+            Log.e(TAG, "WifiScanListener onFailure");
+        };
+        @Override
+        public void onPeriodChanged(int periodInMs) {
+            Log.e(TAG, "WifiScanListener onPeriodChanged  period=" + periodInMs);
+        }
+        @Override
+        public void onResults(WifiScanner.ScanData[] results) {
+            Log.e(TAG, "WifiScanListener onResults2 "  + results.length);
+        }
+        @Override
+        public void onFullResult(ScanResult fullScanResult) {
+            Log.e(TAG, "WifiScanListener onFullResult " + fullScanResult.toString());
+        }
+
+        WifiScanListener() {}
+    }
+
+    WifiScanListener mWifiScanListener = new WifiScanListener();
+
+
     private class TetherStateChange {
         ArrayList<String> available;
         ArrayList<String> active;
+
         TetherStateChange(ArrayList<String> av, ArrayList<String> ac) {
             available = av;
             active = ac;
@@ -786,50 +978,42 @@
         int networkId;
         int protocol;
         String ssid;
-        String[] challenges;
-    }
-
-    public static class SimAuthResponseData {
-        int id;
-        String Kc1;
-        String SRES1;
-        String Kc2;
-        String SRES2;
-        String Kc3;
-        String SRES3;
+        // EAP-SIM: data[] contains the 3 rand, one for each of the 3 challenges
+        // EAP-AKA/AKA': data[] contains rand & authn couple for the single challenge
+        String[] data;
     }
 
     /**
      * One of  {@link WifiManager#WIFI_STATE_DISABLED},
-     *         {@link WifiManager#WIFI_STATE_DISABLING},
-     *         {@link WifiManager#WIFI_STATE_ENABLED},
-     *         {@link WifiManager#WIFI_STATE_ENABLING},
-     *         {@link WifiManager#WIFI_STATE_UNKNOWN}
-     *
+     * {@link WifiManager#WIFI_STATE_DISABLING},
+     * {@link WifiManager#WIFI_STATE_ENABLED},
+     * {@link WifiManager#WIFI_STATE_ENABLING},
+     * {@link WifiManager#WIFI_STATE_UNKNOWN}
      */
     private final AtomicInteger mWifiState = new AtomicInteger(WIFI_STATE_DISABLED);
 
     /**
      * One of  {@link WifiManager#WIFI_AP_STATE_DISABLED},
-     *         {@link WifiManager#WIFI_AP_STATE_DISABLING},
-     *         {@link WifiManager#WIFI_AP_STATE_ENABLED},
-     *         {@link WifiManager#WIFI_AP_STATE_ENABLING},
-     *         {@link WifiManager#WIFI_AP_STATE_FAILED}
-     *
+     * {@link WifiManager#WIFI_AP_STATE_DISABLING},
+     * {@link WifiManager#WIFI_AP_STATE_ENABLED},
+     * {@link WifiManager#WIFI_AP_STATE_ENABLING},
+     * {@link WifiManager#WIFI_AP_STATE_FAILED}
      */
     private final AtomicInteger mWifiApState = new AtomicInteger(WIFI_AP_STATE_DISABLED);
 
     private static final int SCAN_REQUEST = 0;
     private static final String ACTION_START_SCAN =
-        "com.android.server.WifiManager.action.START_SCAN";
+            "com.android.server.WifiManager.action.START_SCAN";
+
+    private static final int PNO_START_REQUEST = 0;
+    private static final String ACTION_START_PNO =
+            "com.android.server.WifiManager.action.START_PNO";
 
     private static final String DELAYED_STOP_COUNTER = "DelayedStopCounter";
     private static final int DRIVER_STOP_REQUEST = 0;
     private static final String ACTION_DELAYED_DRIVER_STOP =
-        "com.android.server.WifiManager.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.
      */
@@ -852,17 +1036,6 @@
 
     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 String mTcpBufferSizes = null;
 
     // Used for debug and stats gathering
@@ -870,10 +1043,17 @@
 
     final static int frameworkMinScanIntervalSaneValue = 10000;
 
+    boolean mPnoEnabled;
+    boolean mLazyRoamEnabled;
+    long mGScanStartTimeMilli;
+    long mGScanPeriodMilli;
+
     public WifiStateMachine(Context context, String wlanInterface,
-            WifiTrafficPoller trafficPoller){
+                            WifiTrafficPoller trafficPoller) {
         super("WifiStateMachine");
         mContext = context;
+        mSetCountryCode = Settings.Global.getString(
+                mContext.getContentResolver(), Settings.Global.WIFI_COUNTRY_CODE);
         mInterfaceName = wlanInterface;
         mNetworkInfo = new NetworkInfo(ConnectivityManager.TYPE_WIFI, 0, NETWORKTYPE, "");
         mBatteryStats = IBatteryStats.Stub.asInterface(ServiceManager.getService(
@@ -886,17 +1066,21 @@
                 PackageManager.FEATURE_WIFI_DIRECT);
 
         mWifiNative = new WifiNative(mInterfaceName);
-        mWifiConfigStore = new WifiConfigStore(context, mWifiNative);
+        mWifiConfigStore = new WifiConfigStore(context,this,  mWifiNative);
         mWifiAutoJoinController = new WifiAutoJoinController(context, this,
                 mWifiConfigStore, mWifiConnectionStatistics, mWifiNative);
         mWifiMonitor = new WifiMonitor(this, mWifiNative);
+        mWifiLogger = new WifiLogger(this);
+
         mWifiInfo = new WifiInfo();
         mSupplicantStateTracker = new SupplicantStateTracker(context, this, mWifiConfigStore,
                 getHandler());
         mLinkProperties = new LinkProperties();
 
         IBinder s1 = ServiceManager.getService(Context.WIFI_P2P_SERVICE);
-        mWifiP2pServiceImpl = (WifiP2pServiceImpl)IWifiP2pManager.Stub.asInterface(s1);
+        mWifiP2pServiceImpl = (WifiP2pServiceImpl) IWifiP2pManager.Stub.asInterface(s1);
+
+        IBinder s2 = ServiceManager.getService(Context.WIFI_PASSPOINT_SERVICE);
 
         mNetworkInfo.setIsAvailable(false);
         mLastBssid = null;
@@ -914,9 +1098,9 @@
             loge("Couldn't register netlink tracker: " + e.toString());
         }
 
-        mAlarmManager = (AlarmManager)mContext.getSystemService(Context.ALARM_SERVICE);
+        mAlarmManager = (AlarmManager) mContext.getSystemService(Context.ALARM_SERVICE);
         mScanIntent = getPrivateBroadcast(ACTION_START_SCAN, SCAN_REQUEST);
-        mBatchedScanIntervalIntent = getPrivateBroadcast(ACTION_REFRESH_BATCHED_SCAN, 0);
+        mPnoIntent = getPrivateBroadcast(ACTION_START_PNO, PNO_START_REQUEST);
 
         // Make sure the interval is not configured less than 10 seconds
         int period = mContext.getResources().getInteger(
@@ -925,6 +1109,10 @@
             period = frameworkMinScanIntervalSaneValue;
         }
         mDefaultFrameworkScanIntervalMs = period;
+
+        mNoNetworksPeriodicScan = mContext.getResources().getInteger(
+                R.integer.config_wifi_no_network_periodic_scan_interval);
+
         mDriverStopDelayMs = mContext.getResources().getInteger(
                 R.integer.config_wifi_driver_stop_delay);
 
@@ -935,7 +1123,7 @@
                 R.string.config_wifi_p2p_device_type);
 
         mUserWantsSuspendOpt.set(Settings.Global.getInt(mContext.getContentResolver(),
-                    Settings.Global.WIFI_SUSPEND_OPTIMIZATIONS_ENABLED, 1) == 1);
+                Settings.Global.WIFI_SUSPEND_OPTIMIZATIONS_ENABLED, 1) == 1);
 
         mNetworkCapabilitiesFilter.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);
         mNetworkCapabilitiesFilter.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
@@ -946,16 +1134,16 @@
         mNetworkCapabilities = new NetworkCapabilities(mNetworkCapabilitiesFilter);
 
         mContext.registerReceiver(
-            new BroadcastReceiver() {
-                @Override
-                public void onReceive(Context context, Intent intent) {
-                    ArrayList<String> available = intent.getStringArrayListExtra(
-                            ConnectivityManager.EXTRA_AVAILABLE_TETHER);
-                    ArrayList<String> active = intent.getStringArrayListExtra(
-                            ConnectivityManager.EXTRA_ACTIVE_TETHER);
-                    sendMessage(CMD_TETHER_STATE_CHANGE, new TetherStateChange(available, active));
-                }
-            },new IntentFilter(ConnectivityManager.ACTION_TETHER_STATE_CHANGED));
+                new BroadcastReceiver() {
+                    @Override
+                    public void onReceive(Context context, Intent intent) {
+                        ArrayList<String> available = intent.getStringArrayListExtra(
+                                ConnectivityManager.EXTRA_AVAILABLE_TETHER);
+                        ArrayList<String> active = intent.getStringArrayListExtra(
+                                ConnectivityManager.EXTRA_ACTIVE_TETHER);
+                        sendMessage(CMD_TETHER_STATE_CHANGE, new TetherStateChange(available, active));
+                    }
+                }, new IntentFilter(ConnectivityManager.ACTION_TETHER_STATE_CHANGED));
 
         mContext.registerReceiver(
                 new BroadcastReceiver() {
@@ -964,15 +1152,27 @@
                         sScanAlarmIntentCount++; // Used for debug only
                         startScan(SCAN_ALARM_SOURCE, mDelayedScanCounter.incrementAndGet(), null, null);
                         if (VDBG)
-                            loge("WiFiStateMachine SCAN ALARM -> " + mDelayedScanCounter.get());
+                            logd("SCAN ALARM -> " + mDelayedScanCounter.get());
                     }
                 },
                 new IntentFilter(ACTION_START_SCAN));
 
+        mContext.registerReceiver(
+                new BroadcastReceiver() {
+                    @Override
+                    public void onReceive(Context context, Intent intent) {
+                        sendMessage(CMD_RESTART_AUTOJOIN_OFFLOAD, 0,
+                                mRestartAutoJoinOffloadCounter, "pno alarm");
+                        if (DBG)
+                            logd("PNO START ALARM sent");
+                    }
+                },
+                new IntentFilter(ACTION_START_PNO));
+
+
         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
@@ -983,8 +1183,6 @@
                             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);
@@ -993,14 +1191,14 @@
                 new BroadcastReceiver() {
                     @Override
                     public void onReceive(Context context, Intent intent) {
-                       int counter = intent.getIntExtra(DELAYED_STOP_COUNTER, 0);
-                       sendMessage(CMD_DELAYED_STOP_DRIVER, counter, 0);
+                        int counter = intent.getIntExtra(DELAYED_STOP_COUNTER, 0);
+                        sendMessage(CMD_DELAYED_STOP_DRIVER, counter, 0);
                     }
                 },
                 new IntentFilter(ACTION_DELAYED_DRIVER_STOP));
 
         mContext.getContentResolver().registerContentObserver(Settings.Global.getUriFor(
-                Settings.Global.WIFI_SUSPEND_OPTIMIZATIONS_ENABLED), false,
+                        Settings.Global.WIFI_SUSPEND_OPTIMIZATIONS_ENABLED), false,
                 new ContentObserver(getHandler()) {
                     @Override
                     public void onChange(boolean selfChange) {
@@ -1018,9 +1216,9 @@
                 },
                 new IntentFilter(Intent.ACTION_BOOT_COMPLETED));
 
-        mScanResultCache = new LruCache<String, ScanResult>(SCAN_RESULT_CACHE_SIZE);
+        mScanResultCache = new LruCache<>(SCAN_RESULT_CACHE_SIZE);
 
-        PowerManager powerManager = (PowerManager)mContext.getSystemService(Context.POWER_SERVICE);
+        PowerManager powerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
         mWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, getName());
 
         mSuspendWakeLock = powerManager.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "WifiSuspend");
@@ -1074,7 +1272,8 @@
     PendingIntent getPrivateBroadcast(String action, int requestCode) {
         Intent intent = new Intent(action, null);
         intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
-        intent.setPackage(this.getClass().getPackage().getName());
+        //intent.setPackage(this.getClass().getPackage().getName());
+        intent.setPackage("android");
         return PendingIntent.getBroadcast(mContext, requestCode, intent, 0);
     }
 
@@ -1099,6 +1298,7 @@
             mLogMessages = false;
             mWifiNative.setSupplicantLogLevel("INFO");
         }
+        mWifiLogger.startLogging(mVerboseLoggingLevel > 0);
         mWifiAutoJoinController.enableVerboseLogging(verbose);
         mWifiMonitor.enableVerboseLogging(verbose);
         mWifiNative.enableVerboseLogging(verbose);
@@ -1106,6 +1306,99 @@
         mSupplicantStateTracker.enableVerboseLogging(verbose);
     }
 
+    public void setHalBasedAutojoinOffload(int enabled) {
+        // Shoult be used for debug only, triggered form developper settings
+        // enabling HAl based PNO dynamically is not safe and not a normal operation
+        mHalBasedPnoEnableInDevSettings = enabled > 0;
+        mWifiConfigStore.enableHalBasedPno.set(mHalBasedPnoEnableInDevSettings);
+        mWifiConfigStore.enableSsidWhitelist.set(mHalBasedPnoEnableInDevSettings);
+        sendMessage(CMD_DISCONNECT);
+    }
+
+    int getHalBasedAutojoinOffload() {
+        return mHalBasedPnoEnableInDevSettings ? 1 : 0;
+    }
+
+    boolean useHalBasedAutoJoinOffload() {
+        // all three settings need to be true:
+        // - developper settings switch
+        // - driver support
+        // - config option
+        return mHalBasedPnoEnableInDevSettings
+                && mHalBasedPnoDriverSupported
+                && mWifiConfigStore.enableHalBasedPno.get();
+    }
+
+    boolean allowFullBandScanAndAssociated() {
+
+        if (!getEnableAutoJoinWhenAssociated()) {
+            if (DBG) {
+                Log.e(TAG, "allowFullBandScanAndAssociated: "
+                        + " enableAutoJoinWhenAssociated : disallow");
+            }
+            return false;
+        }
+
+        if (mWifiInfo.txSuccessRate >
+                mWifiConfigStore.maxTxPacketForFullScans
+                || mWifiInfo.rxSuccessRate >
+                mWifiConfigStore.maxRxPacketForFullScans) {
+            if (DBG) {
+                Log.e(TAG, "allowFullBandScanAndAssociated: packet rate tx"
+                        + mWifiInfo.txSuccessRate + "  rx "
+                        + mWifiInfo.rxSuccessRate
+                        + " allow scan with traffic " + getAllowScansWithTraffic());
+            }
+            // Too much traffic at the interface, hence no full band scan
+            if (getAllowScansWithTraffic() == 0) {
+                return false;
+            }
+        }
+
+        if (getCurrentState() != mConnectedState) {
+            if (DBG) {
+                Log.e(TAG, "allowFullBandScanAndAssociated: getCurrentState() : disallow");
+            }
+            return false;
+        }
+
+        return true;
+    }
+
+    long mLastScanPermissionUpdate = 0;
+    boolean mConnectedModeGScanOffloadStarted = false;
+    // Don't do a G-scan enable/re-enable cycle more than once within 20seconds
+    // The function updateAssociatedScanPermission() can be called quite frequently, hence
+    // we want to throttle the GScan Stop->Start transition
+    static final long SCAN_PERMISSION_UPDATE_THROTTLE_MILLI = 20000;
+    void updateAssociatedScanPermission() {
+
+        if (useHalBasedAutoJoinOffload()) {
+            boolean allowed = allowFullBandScanAndAssociated();
+
+            long now = System.currentTimeMillis();
+            if (mConnectedModeGScanOffloadStarted && !allowed) {
+                if (DBG) {
+                    Log.e(TAG, " useHalBasedAutoJoinOffload stop offload");
+                }
+                stopPnoOffload();
+                stopGScan(" useHalBasedAutoJoinOffload");
+            }
+            if (!mConnectedModeGScanOffloadStarted && allowed) {
+                if ((now - mLastScanPermissionUpdate) > SCAN_PERMISSION_UPDATE_THROTTLE_MILLI) {
+                    // Re-enable Gscan offload, this will trigger periodic scans and allow firmware
+                    // to look for 5GHz BSSIDs and better networks
+                    if (DBG) {
+                        Log.e(TAG, " useHalBasedAutoJoinOffload restart offload");
+                    }
+                    startGScanConnectedModeOffload("updatePermission "
+                            + (now - mLastScanPermissionUpdate) + "ms");
+                    mLastScanPermissionUpdate = now;
+                }
+            }
+        }
+    }
+
     private int mAggressiveHandover = 0;
 
     int getAggressiveHandover() {
@@ -1116,31 +1409,46 @@
         mAggressiveHandover = enabled;
     }
 
+    public void clearANQPCache() {
+        mWifiConfigStore.trimANQPCache(true);
+    }
+
     public void setAllowScansWithTraffic(int enabled) {
-        mWifiConfigStore.alwaysEnableScansWhileAssociated = enabled;
+        mWifiConfigStore.alwaysEnableScansWhileAssociated.set(enabled);
     }
 
     public int getAllowScansWithTraffic() {
-        return mWifiConfigStore.alwaysEnableScansWhileAssociated;
+        return mWifiConfigStore.alwaysEnableScansWhileAssociated.get();
     }
 
+    public boolean enableAutoJoinWhenAssociated(boolean enabled) {
+        boolean old_state = getEnableAutoJoinWhenAssociated();
+        mWifiConfigStore.enableAutoJoinWhenAssociated.set(enabled);
+        if (!old_state && enabled && mScreenOn && getCurrentState() == mConnectedState) {
+            startDelayedScan(mWifiConfigStore.wifiAssociatedShortScanIntervalMilli.get(), null,
+                    null);
+        }
+        return true;
+    }
+
+    public boolean getEnableAutoJoinWhenAssociated() {
+        return mWifiConfigStore.enableAutoJoinWhenAssociated.get();
+    }
     /*
      *
      * Framework scan control
      */
 
     private boolean mAlarmEnabled = false;
-    /* This is set from the overlay config file or from a secure setting.
-     * A value of 0 disables scanning in the framework.
-     */
-    private long mFrameworkScanIntervalMs = 10000;
 
     private AtomicInteger mDelayedScanCounter = new AtomicInteger();
 
     private void setScanAlarm(boolean enabled) {
         if (PDBG) {
-            loge("setScanAlarm " + enabled
-                    + " period " + mDefaultFrameworkScanIntervalMs
+            String state;
+            if (enabled) state = "enabled"; else state = "disabled";
+            logd("setScanAlarm " + state
+                    + " defaultperiod " + mDefaultFrameworkScanIntervalMs
                     + " mBackgroundScanSupported " + mBackgroundScanSupported);
         }
         if (mBackgroundScanSupported == false) {
@@ -1166,11 +1474,11 @@
 
     private void cancelDelayedScan() {
         mDelayedScanCounter.incrementAndGet();
-        loge("cancelDelayedScan -> " + mDelayedScanCounter);
     }
 
     private boolean checkAndRestartDelayedScan(int counter, boolean restart, int milli,
-