auto import from //depot/cupcake/@135843

13 files changed, 0 insertions, 4290 deletions

diff --git a/wifi/java/android/net/wifi/IWifiManager.aidl b/wifi/java/android/net/wifi/IWifiManager.aidl
deleted file mode 100644
index f9a0845..0000000
--- a/wifi/java/android/net/wifi/IWifiManager.aidl
+++ /dev/null
@@ -1,73 +0,0 @@
-/**
- * Copyright (c) 2008, 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 android.net.wifi;
-
-import android.net.wifi.WifiInfo;
-import android.net.wifi.WifiConfiguration;
-import android.net.wifi.ScanResult;
-import android.net.DhcpInfo;
-
-/**
- * Interface that allows controlling and querying Wi-Fi connectivity.
- *
- * {@hide}
- */
-interface IWifiManager
-{
-    List<WifiConfiguration> getConfiguredNetworks();
-    
-    int addOrUpdateNetwork(in WifiConfiguration config);
-
-    boolean removeNetwork(int netId);
-
-    boolean enableNetwork(int netId, boolean disableOthers);
-
-    boolean disableNetwork(int netId);
-
-    boolean pingSupplicant();
-
-    boolean startScan();
-
-    List<ScanResult> getScanResults();
-
-    boolean disconnect();
-
-    boolean reconnect();
-    
-    boolean reassociate();
-
-    WifiInfo getConnectionInfo();
-
-    boolean setWifiEnabled(boolean enable);
-
-    int getWifiEnabledState();
-
-    int getNumAllowedChannels();
-
-    boolean setNumAllowedChannels(int numChannels);
-
-    int[] getValidChannelCounts();
-    
-    boolean saveConfiguration();
-
-    DhcpInfo getDhcpInfo();
-
-    boolean acquireWifiLock(IBinder lock, int lockType, String tag);
-
-    boolean releaseWifiLock(IBinder lock);
-}
-
diff --git a/wifi/java/android/net/wifi/ScanResult.aidl b/wifi/java/android/net/wifi/ScanResult.aidl
deleted file mode 100644
index bb66722..0000000
--- a/wifi/java/android/net/wifi/ScanResult.aidl
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
- * Copyright (c) 2008, 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 android.net.wifi;
-
-parcelable ScanResult;
diff --git a/wifi/java/android/net/wifi/ScanResult.java b/wifi/java/android/net/wifi/ScanResult.java
deleted file mode 100644
index 32261de..0000000
--- a/wifi/java/android/net/wifi/ScanResult.java
+++ /dev/null
@@ -1,116 +0,0 @@
-/*
- * Copyright (C) 2008 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 android.net.wifi;
-
-import android.os.Parcelable;
-import android.os.Parcel;
-
-/**
- * Describes information about a detected access point. In addition
- * to the attributes described here, the supplicant keeps track of
- * {@code quality}, {@code noise}, and {@code maxbitrate} attributes,
- * but does not currently report them to external clients.
- */
-public class ScanResult implements Parcelable {
-    /** The network name. */
-    public String SSID;
-    /** The address of the access point. */
-    public String BSSID;
-    /**
-     * Describes the authentication, key management, and encryption schemes
-     * supported by the access point.
-     */
-    public String capabilities;
-    /**
-     * The detected signal level in dBm. At least those are the units used by
-     * the TI driver.
-     */
-    public int level;
-    /**
-     * The frequency in MHz of the channel over which the client is communicating
-     * with the access point.
-     */
-    public int frequency;
-
-    /**
-     * We'd like to obtain the following attributes,
-     * but they are not reported via the socket
-     * interface, even though they are known
-     * internally by wpa_supplicant.
-     * {@hide}
-     */
-    public ScanResult(String SSID, String BSSID, String caps, int level, int frequency) {
-        this.SSID = SSID;
-        this.BSSID = BSSID;
-        this.capabilities = caps;
-        this.level = level;
-        this.frequency = frequency;
-        //networkConfig = null;
-    }
-
-    @Override
-    public String toString() {
-        StringBuffer sb = new StringBuffer();
-        String none = "<none>";
-
-        sb.append("SSID: ").
-            append(SSID == null ? none : SSID).
-            append(", BSSID: ").
-            append(BSSID == null ? none : BSSID).
-            append(", capabilities: ").
-            append(capabilities == null ? none : capabilities).
-            append(", level: ").
-            append(level).
-            append(", frequency: ").
-            append(frequency);
-
-        return sb.toString();
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public int describeContents() {
-        return 0;
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public void writeToParcel(Parcel dest, int flags) {
-        dest.writeString(SSID);
-        dest.writeString(BSSID);
-        dest.writeString(capabilities);
-        dest.writeInt(level);
-        dest.writeInt(frequency);
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public static final Creator<ScanResult> CREATOR =
-        new Creator<ScanResult>() {
-            public ScanResult createFromParcel(Parcel in) {
-                return new ScanResult(
-                    in.readString(),
-                    in.readString(),
-                    in.readString(),
-                    in.readInt(),
-                    in.readInt()
-                );
-            }
-
-            public ScanResult[] newArray(int size) {
-                return new ScanResult[size];
-            }
-        };
-
-}
diff --git a/wifi/java/android/net/wifi/SupplicantState.java b/wifi/java/android/net/wifi/SupplicantState.java
deleted file mode 100644
index 169b2d6..0000000
--- a/wifi/java/android/net/wifi/SupplicantState.java
+++ /dev/null
@@ -1,177 +0,0 @@
-/*
- * Copyright (C) 2008 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 android.net.wifi;
-
-import android.os.Parcel;
-import android.os.Parcelable;
-
-/**
- * From <code>defs.h</code> in <code>wpa_supplicant</code>.
- * <p/>
- * These enumeration values are used to indicate the current wpa_supplicant
- * state. This is more fine-grained than most users will be interested in.
- * In general, it is better to use
- * {@link android.net.NetworkInfo.State NetworkInfo.State}.
- * <p/>
- * Note, the order of these enum constants must match the numerical values of the
- * state constants in <code>defs.h</code> in <code>wpa_supplicant</code>.
- */
-public enum SupplicantState implements Parcelable {
-    /**
-     * This state indicates that client is not associated, but is likely to
-     * start looking for an access point. This state is entered when a
-     * connection is lost.
-     */
-    DISCONNECTED,
-
-    /**
-     * Inactive state (wpa_supplicant disabled).
-     * <p/>
-     * This state is entered if there are no enabled networks in the
-     * configuration. wpa_supplicant is not trying to associate with a new
-     * network and external interaction (e.g., ctrl_iface call to add or
-     * enable a network) is needed to start association.
-     */
-    INACTIVE,
-
-    /**
-     * Scanning for a network.
-     * <p/>
-     * This state is entered when wpa_supplicant starts scanning for a
-     * network.
-     */
-    SCANNING,
-
-    /**
-     * Trying to associate with a BSS/SSID.
-     * <p/>
-     * This state is entered when wpa_supplicant has found a suitable BSS
-     * to associate with and the driver is configured to try to associate
-     * with this BSS in ap_scan=1 mode. When using ap_scan=2 mode, this
-     * state is entered when the driver is configured to try to associate
-     * with a network using the configured SSID and security policy.
-     */
-    ASSOCIATING,
-
-    /**
-     * Association completed.
-     * <p/>
-     * This state is entered when the driver reports that association has
-     * been successfully completed with an AP. If IEEE 802.1X is used
-     * (with or without WPA/WPA2), wpa_supplicant remains in this state
-     * until the IEEE 802.1X/EAPOL authentication has been completed.
-     */
-    ASSOCIATED,
-
-    /**
-     * WPA 4-Way Key Handshake in progress.
-     * <p/>
-     * This state is entered when WPA/WPA2 4-Way Handshake is started. In
-     * case of WPA-PSK, this happens when receiving the first EAPOL-Key
-     * frame after association. In case of WPA-EAP, this state is entered
-     * when the IEEE 802.1X/EAPOL authentication has been completed.
-     */
-    FOUR_WAY_HANDSHAKE,
-
-    /**
-     * WPA Group Key Handshake in progress.
-     * <p/>
-     * This state is entered when 4-Way Key Handshake has been completed
-     * (i.e., when the supplicant sends out message 4/4) and when Group
-     * Key rekeying is started by the AP (i.e., when supplicant receives
-     * message 1/2).
-     */
-    GROUP_HANDSHAKE,
-
-    /**
-     * All authentication completed.
-     * <p/>
-     * This state is entered when the full authentication process is
-     * completed. In case of WPA2, this happens when the 4-Way Handshake is
-     * successfully completed. With WPA, this state is entered after the
-     * Group Key Handshake; with IEEE 802.1X (non-WPA) connection is
-     * completed after dynamic keys are received (or if not used, after
-     * the EAP authentication has been completed). With static WEP keys and
-     * plaintext connections, this state is entered when an association
-     * has been completed.
-     * <p/>
-     * This state indicates that the supplicant has completed its
-     * processing for the association phase and that data connection is
-     * fully configured. Note, however, that there may not be any IP
-     * address associated with the connection yet. Typically, a DHCP
-     * request needs to be sent at this point to obtain an address.
-     */
-    COMPLETED,
-
-    /**
-     * An Android-added state that is reported when a client issues an
-     * explicit DISCONNECT command. In such a case, the supplicant is
-     * not only dissociated from the current access point (as for the
-     * DISCONNECTED state above), but it also does not attempt to connect
-     * to any access point until a RECONNECT or REASSOCIATE command
-     * is issued by the client.
-     */
-    DORMANT,
-
-    /**
-     * No connection to wpa_supplicant.
-     * <p/>
-     * This is an additional pseudo-state to handle the case where
-     * wpa_supplicant is not running and/or we have not been able
-     * to establish a connection to it.
-     */
-    UNINITIALIZED,
-
-    /**
-     * A pseudo-state that should normally never be seen.
-     */
-    INVALID;
-
-    /**
-     * Returns {@code true} if the supplicant state is valid and {@code false}
-     * otherwise.
-     * @param state The supplicant state
-     * @return {@code true} if the supplicant state is valid and {@code false}
-     * otherwise.
-     */
-    public static boolean isValidState(SupplicantState state) {
-        return state != UNINITIALIZED && state != INVALID;
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public int describeContents() {
-        return 0;
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public void writeToParcel(Parcel dest, int flags) {
-        dest.writeString(name());
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public static final Creator<SupplicantState> CREATOR =
-        new Creator<SupplicantState>() {
-            public SupplicantState createFromParcel(Parcel in) {
-                return SupplicantState.valueOf(in.readString());
-            }
-
-            public SupplicantState[] newArray(int size) {
-                return new SupplicantState[size];
-            }
-        };
-
-}
diff --git a/wifi/java/android/net/wifi/WifiConfiguration.aidl b/wifi/java/android/net/wifi/WifiConfiguration.aidl
deleted file mode 100644
index 237a74d..0000000
--- a/wifi/java/android/net/wifi/WifiConfiguration.aidl
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
- * Copyright (c) 2008, 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 android.net.wifi;
-
-parcelable WifiConfiguration;
diff --git a/wifi/java/android/net/wifi/WifiConfiguration.java b/wifi/java/android/net/wifi/WifiConfiguration.java
deleted file mode 100644
index d6277fa..0000000
--- a/wifi/java/android/net/wifi/WifiConfiguration.java
+++ /dev/null
@@ -1,427 +0,0 @@
-/*
- * Copyright (C) 2008 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 android.net.wifi;
-
-import android.os.Parcelable;
-import android.os.Parcel;
-
-import java.util.BitSet;
-
-/**
- * A class representing a configured Wi-Fi network, including the
- * security configuration. Android will not necessarily support
- * all of these security schemes initially.
- */
-public class WifiConfiguration implements Parcelable {
-
-    /** {@hide} */
-    public static final String ssidVarName = "ssid";
-    /** {@hide} */
-    public static final String bssidVarName = "bssid";
-    /** {@hide} */
-    public static final String pskVarName = "psk";
-    /** {@hide} */
-    public static final String[] wepKeyVarNames = { "wep_key0", "wep_key1", "wep_key2", "wep_key3" };
-    /** {@hide} */
-    public static final String wepTxKeyIdxVarName = "wep_tx_keyidx";
-    /** {@hide} */
-    public static final String priorityVarName = "priority";
-    /** {@hide} */
-    public static final String hiddenSSIDVarName = "scan_ssid";
-
-    /**
-     * Recognized key management schemes.
-     */
-    public static class KeyMgmt {
-        private KeyMgmt() { }
-        
-        /** WPA is not used; plaintext or static WEP could be used. */
-        public static final int NONE = 0;
-        /** WPA pre-shared key (requires {@code preSharedKey} to be specified). */
-        public static final int WPA_PSK = 1;
-        /** WPA using EAP authentication. Generally used with an external authentication server. */
-        public static final int WPA_EAP = 2;
-        /** IEEE 802.1X using EAP authentication and (optionally) dynamically
-         * generated WEP keys. */
-        public static final int IEEE8021X = 3;
-
-        public static final String varName = "key_mgmt";
-
-        public static final String[] strings = { "NONE", "WPA_PSK", "WPA_EAP", "IEEE8021X" };
-    }
-    
-    /**
-     * Recognized security protocols.
-     */
-    public static class Protocol {
-        private Protocol() { }
-
-        /** WPA/IEEE 802.11i/D3.0 */
-        public static final int WPA = 0;
-        /** WPA2/IEEE 802.11i */
-        public static final int RSN = 1;
-
-        public static final String varName = "proto";
-
-        public static final String[] strings = { "WPA", "RSN" };
-    }
-
-    /**
-     * Recognized IEEE 802.11 authentication algorithms.
-     */
-    public static class AuthAlgorithm {
-        private AuthAlgorithm() { }
-
-        /** Open System authentication (required for WPA/WPA2) */
-        public static final int OPEN = 0;
-        /** Shared Key authentication (requires static WEP keys) */
-        public static final int SHARED = 1;
-        /** LEAP/Network EAP (only used with LEAP) */
-        public static final int LEAP = 2;
-
-        public static final String varName = "auth_alg";
-
-        public static final String[] strings = { "OPEN", "SHARED", "LEAP" };
-    }
-
-    /**
-     * Recognized pairwise ciphers for WPA.
-     */
-    public static class PairwiseCipher {
-        private PairwiseCipher() { }
-
-        /** Use only Group keys (deprecated) */
-        public static final int NONE = 0;
-        /** Temporal Key Integrity Protocol [IEEE 802.11i/D7.0] */
-        public static final int TKIP = 1;
-        /** AES in Counter mode with CBC-MAC [RFC 3610, IEEE 802.11i/D7.0] */
-        public static final int CCMP = 2;
-
-        public static final String varName = "pairwise";
-        
-        public static final String[] strings = { "NONE", "TKIP", "CCMP" };
-    }
-
-    /**
-     * Recognized group ciphers.
-     * <pre>
-     * CCMP = AES in Counter mode with CBC-MAC [RFC 3610, IEEE 802.11i/D7.0]
-     * TKIP = Temporal Key Integrity Protocol [IEEE 802.11i/D7.0]
-     * WEP104 = WEP (Wired Equivalent Privacy) with 104-bit key
-     * WEP40 = WEP (Wired Equivalent Privacy) with 40-bit key (original 802.11)
-     * </pre>
-     */
-    public static class GroupCipher {
-        private GroupCipher() { }
-
-        /** WEP40 = WEP (Wired Equivalent Privacy) with 40-bit key (original 802.11) */
-        public static final int WEP40 = 0;
-        /** WEP104 = WEP (Wired Equivalent Privacy) with 104-bit key */
-        public static final int WEP104 = 1;
-        /** Temporal Key Integrity Protocol [IEEE 802.11i/D7.0] */
-        public static final int TKIP = 2;
-        /** AES in Counter mode with CBC-MAC [RFC 3610, IEEE 802.11i/D7.0] */
-        public static final int CCMP = 3;
-
-        public static final String varName = "group";
-
-        public static final String[] strings = { "WEP40", "WEP104", "TKIP", "CCMP" };
-    }
-
-    /** Possible status of a network configuration. */
-    public static class Status {
-        private Status() { }
-
-        /** this is the network we are currently connected to */
-        public static final int CURRENT = 0;
-        /** supplicant will not attempt to use this network */
-        public static final int DISABLED = 1;
-        /** supplicant will consider this network available for association */
-        public static final int ENABLED = 2;
-
-        public static final String[] strings = { "current", "disabled", "enabled" };
-    }
-
-    /**
-     * The ID number that the supplicant uses to identify this
-     * network configuration entry. This must be passed as an argument
-     * to most calls into the supplicant.
-     */
-    public int networkId;
-
-    /**
-     * The current status of this network configuration entry.
-     * @see Status
-     */
-    public int status;
-    /**
-     * The network's SSID. Can either be an ASCII string,
-     * which must be enclosed in double quotation marks
-     * (e.g., {@code &quot;MyNetwork&quot;}, or a string of
-     * hex digits,which are not enclosed in quotes
-     * (e.g., {@code 01a243f405}).
-     */
-    public String SSID;
-    /**
-     * When set, this network configuration entry should only be used when
-     * associating with the AP having the specified BSSID. The value is
-     * a string in the format of an Ethernet MAC address, e.g.,
-     * <code>XX:XX:XX:XX:XX:XX</code> where each <code>X</code> is a hex digit.
-     */
-    public String BSSID;
-
-    /**
-     * Pre-shared key for use with WPA-PSK.
-     * <p/>
-     * When the value of this key is read, the actual key is
-     * not returned, just a "*" if the key has a value, or the null
-     * string otherwise.
-     */
-    public String preSharedKey;
-    /**
-     * Up to four WEP keys. Either an ASCII string enclosed in double
-     * quotation marks (e.g., {@code &quot;abcdef&quot;} or a string
-     * of hex digits (e.g., {@code 0102030405}).
-     * <p/>
-     * When the value of one of these keys is read, the actual key is
-     * not returned, just a "*" if the key has a value, or the null
-     * string otherwise.
-     */
-    public String[] wepKeys;
-    
-    /** Default WEP key index, ranging from 0 to 3. */
-    public int wepTxKeyIndex;
-
-    /**
-     * Priority determines the preference given to a network by {@code wpa_supplicant}
-     * when choosing an access point with which to associate.
-     */
-    public int priority;
-
-    /**
-     * This is a network that does not broadcast its SSID, so an
-     * SSID-specific probe request must be used for scans.
-     */
-    public boolean hiddenSSID;
-
-    /**
-     * The set of key management protocols supported by this configuration.
-     * See {@link KeyMgmt} for descriptions of the values.
-     * Defaults to WPA-PSK WPA-EAP.
-     */
-    public BitSet allowedKeyManagement;
-    /**
-     * The set of security protocols supported by this configuration.
-     * See {@link Protocol} for descriptions of the values.
-     * Defaults to WPA RSN.
-     */
-    public BitSet allowedProtocols;
-    /**
-     * The set of authentication protocols supported by this configuration.
-     * See {@link AuthAlgorithm} for descriptions of the values.
-     * Defaults to automatic selection.
-     */
-    public BitSet allowedAuthAlgorithms;
-    /**
-     * The set of pairwise ciphers for WPA supported by this configuration.
-     * See {@link PairwiseCipher} for descriptions of the values.
-     * Defaults to CCMP TKIP.
-     */
-    public BitSet allowedPairwiseCiphers;
-    /**
-     * The set of group ciphers supported by this configuration.
-     * See {@link GroupCipher} for descriptions of the values.
-     * Defaults to CCMP TKIP WEP104 WEP40.
-     */
-    public BitSet allowedGroupCiphers;
-
-    public WifiConfiguration() {
-        networkId = -1;
-        SSID = null;
-        BSSID = null;
-        priority = 0;
-        hiddenSSID = false;
-        allowedKeyManagement = new BitSet();
-        allowedProtocols = new BitSet();
-        allowedAuthAlgorithms = new BitSet();
-        allowedPairwiseCiphers = new BitSet();
-        allowedGroupCiphers = new BitSet();
-        wepKeys = new String[4];
-        for (int i = 0; i < wepKeys.length; i++)
-            wepKeys[i] = null;
-    }
-
-    /** {@hide pending API Council approval} */
-    public String toString() {
-        StringBuffer sbuf = new StringBuffer();
-        if (this.status == WifiConfiguration.Status.CURRENT) {
-            sbuf.append("* ");
-        } else if (this.status == WifiConfiguration.Status.DISABLED) {
-            sbuf.append("- ");
-        }
-        sbuf.append("ID: ").append(this.networkId).append(" SSID: ").append(this.SSID).
-                append(" BSSID: ").append(this.BSSID).append(" PRIO: ").append(this.priority).
-                append('\n');
-        sbuf.append(" KeyMgmt:");
-        for (int k = 0; k < this.allowedKeyManagement.size(); k++) {
-            if (this.allowedKeyManagement.get(k)) {
-                sbuf.append(" ");
-                if (k < KeyMgmt.strings.length) {
-                    sbuf.append(KeyMgmt.strings[k]);
-                } else {
-                    sbuf.append("??");
-                }
-            }
-        }
-        sbuf.append(" Protocols:");
-        for (int p = 0; p < this.allowedProtocols.size(); p++) {
-            if (this.allowedProtocols.get(p)) {
-                sbuf.append(" ");
-                if (p < Protocol.strings.length) {
-                    sbuf.append(Protocol.strings[p]);
-                } else {
-                    sbuf.append("??");
-                }
-            }
-        }
-        sbuf.append('\n');
-        sbuf.append(" AuthAlgorithms:");
-        for (int a = 0; a < this.allowedAuthAlgorithms.size(); a++) {
-            if (this.allowedAuthAlgorithms.get(a)) {
-                sbuf.append(" ");
-                if (a < AuthAlgorithm.strings.length) {
-                    sbuf.append(AuthAlgorithm.strings[a]);
-                } else {
-                    sbuf.append("??");
-                }
-            }
-        }
-        sbuf.append('\n');
-        sbuf.append(" PairwiseCiphers:");
-        for (int pc = 0; pc < this.allowedPairwiseCiphers.size(); pc++) {
-            if (this.allowedPairwiseCiphers.get(pc)) {
-                sbuf.append(" ");
-                if (pc < PairwiseCipher.strings.length) {
-                    sbuf.append(PairwiseCipher.strings[pc]);
-                } else {
-                    sbuf.append("??");
-                }
-            }
-        }
-        sbuf.append('\n');
-        sbuf.append(" GroupCiphers:");
-        for (int gc = 0; gc < this.allowedGroupCiphers.size(); gc++) {
-            if (this.allowedGroupCiphers.get(gc)) {
-                sbuf.append(" ");
-                if (gc < GroupCipher.strings.length) {
-                    sbuf.append(GroupCipher.strings[gc]);
-                } else {
-                    sbuf.append("??");
-                }
-            }
-        }
-        sbuf.append('\n');
-        if (this.preSharedKey != null) {
-            sbuf.append(" PSK: ").append('*');
-        }
-        return sbuf.toString();
-    }
-
-    /**
-     * Construct a WifiConfiguration from a scanned network
-     * @param scannedAP the scan result used to construct the config entry
-     * TODO: figure out whether this is a useful way to construct a new entry.
-     *
-    public WifiConfiguration(ScanResult scannedAP) {
-        networkId = -1;
-        SSID = scannedAP.SSID;
-        BSSID = scannedAP.BSSID;
-    }
-    */
-
-    private static BitSet readBitSet(Parcel src) {
-        int cardinality = src.readInt();
-
-        BitSet set = new BitSet();
-        for (int i = 0; i < cardinality; i++)
-            set.set(src.readInt());
-
-        return set;
-    }
-
-    private static void writeBitSet(Parcel dest, BitSet set) {
-        int nextSetBit = -1;
-
-        dest.writeInt(set.cardinality());
-
-        while ((nextSetBit = set.nextSetBit(nextSetBit + 1)) != -1)
-            dest.writeInt(nextSetBit);
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public int describeContents() {
-        return 0;
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public void writeToParcel(Parcel dest, int flags) {
-        dest.writeInt(networkId);
-        dest.writeInt(status);
-        dest.writeString(SSID);
-        dest.writeString(BSSID);
-        dest.writeString(preSharedKey);
-        for (String wepKey : wepKeys)
-            dest.writeString(wepKey);
-        dest.writeInt(wepTxKeyIndex);
-        dest.writeInt(priority);
-        dest.writeInt(hiddenSSID ? 1 : 0);
-
-        writeBitSet(dest, allowedKeyManagement);
-        writeBitSet(dest, allowedProtocols);
-        writeBitSet(dest, allowedAuthAlgorithms);
-        writeBitSet(dest, allowedPairwiseCiphers);
-        writeBitSet(dest, allowedGroupCiphers);
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public static final Creator<WifiConfiguration> CREATOR =
-        new Creator<WifiConfiguration>() {
-            public WifiConfiguration createFromParcel(Parcel in) {
-                WifiConfiguration config = new WifiConfiguration();
-                config.networkId = in.readInt();
-                config.status = in.readInt();
-                config.SSID = in.readString();
-                config.BSSID = in.readString();
-                config.preSharedKey = in.readString();
-                for (int i = 0; i < config.wepKeys.length; i++)
-                    config.wepKeys[i] = in.readString();
-                config.wepTxKeyIndex = in.readInt();
-                config.priority = in.readInt();
-                config.hiddenSSID = in.readInt() != 0;
-                config.allowedKeyManagement   = readBitSet(in);
-                config.allowedProtocols       = readBitSet(in);
-                config.allowedAuthAlgorithms  = readBitSet(in);
-                config.allowedPairwiseCiphers = readBitSet(in);
-                config.allowedGroupCiphers    = readBitSet(in);
-                return config;
-            }
-
-            public WifiConfiguration[] newArray(int size) {
-                return new WifiConfiguration[size];
-            }
-        };
-}
diff --git a/wifi/java/android/net/wifi/WifiInfo.aidl b/wifi/java/android/net/wifi/WifiInfo.aidl
deleted file mode 100644
index db47f0b..0000000
--- a/wifi/java/android/net/wifi/WifiInfo.aidl
+++ /dev/null
@@ -1,19 +0,0 @@
-/**
- * Copyright (c) 2008, 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 android.net.wifi;
-
-parcelable WifiInfo;
diff --git a/wifi/java/android/net/wifi/WifiInfo.java b/wifi/java/android/net/wifi/WifiInfo.java
deleted file mode 100644
index 4312bfd..0000000
--- a/wifi/java/android/net/wifi/WifiInfo.java
+++ /dev/null
@@ -1,281 +0,0 @@
-/*
- * Copyright (C) 2008 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 android.net.wifi;
-
-import android.os.Parcelable;
-import android.os.Parcel;
-import android.net.NetworkInfo.DetailedState;
-
-import java.util.EnumMap;
-
-/**
- * Describes the state of any Wifi connection that is active or
- * is in the process of being set up.
- */
-public class WifiInfo implements Parcelable {
-    /**
-     * This is the map described in the Javadoc comment above. The positions
-     * of the elements of the array must correspond to the ordinal values
-     * of <code>DetailedState</code>.
-     */
-    private static final EnumMap<SupplicantState, DetailedState> stateMap =
-        new EnumMap<SupplicantState, DetailedState>(SupplicantState.class);
-
-    static {
-        stateMap.put(SupplicantState.DISCONNECTED, DetailedState.DISCONNECTED);
-        stateMap.put(SupplicantState.INACTIVE, DetailedState.IDLE);
-        stateMap.put(SupplicantState.SCANNING, DetailedState.SCANNING);
-        stateMap.put(SupplicantState.ASSOCIATING, DetailedState.CONNECTING);
-        stateMap.put(SupplicantState.ASSOCIATED, DetailedState.CONNECTING);
-        stateMap.put(SupplicantState.FOUR_WAY_HANDSHAKE, DetailedState.AUTHENTICATING);
-        stateMap.put(SupplicantState.GROUP_HANDSHAKE, DetailedState.AUTHENTICATING);
-        stateMap.put(SupplicantState.COMPLETED, DetailedState.OBTAINING_IPADDR);
-        stateMap.put(SupplicantState.DORMANT, DetailedState.DISCONNECTED);
-        stateMap.put(SupplicantState.UNINITIALIZED, DetailedState.IDLE);
-        stateMap.put(SupplicantState.INVALID, DetailedState.FAILED);
-    }
-
-    private SupplicantState mSupplicantState;
-    private String mBSSID;
-    private String mSSID;
-    private int mNetworkId;
-    private boolean mHiddenSSID;
-    /** Received Signal Strength Indicator */
-    private int mRssi;
-
-    /** Link speed in Mbps */
-    public static final String LINK_SPEED_UNITS = "Mbps";
-    private int mLinkSpeed;
-
-    private int mIpAddress;
-
-    private String mMacAddress;
-
-    WifiInfo() {
-        mSSID = null;
-        mBSSID = null;
-        mNetworkId = -1;
-        mSupplicantState = SupplicantState.UNINITIALIZED;
-        mRssi = -9999;
-        mLinkSpeed = -1;
-        mIpAddress = 0;
-        mHiddenSSID = false;
-    }
-
-    void setSSID(String SSID) {
-        mSSID = SSID;
-        // network is considered not hidden by default
-        mHiddenSSID = false;
-    }
-
-    /**
-     * Returns the service set identifier (SSID) of the current 802.11 network.
-     * If the SSID is an ASCII string, it will be returned surrounded by double
-     * quotation marks.Otherwise, it is returned as a string of hex digits. The
-     * SSID may be {@code null} if there is no network currently connected.
-     * @return the SSID
-     */
-    public String getSSID() {
-        return mSSID;
-    }
-
-    void setBSSID(String BSSID) {
-        mBSSID = BSSID;
-    }
-
-    /**
-     * Return the basic service set identifier (BSSID) of the current access point.
-     * The BSSID may be {@code null} if there is no network currently connected.
-     * @return the BSSID, in the form of a six-byte MAC address: {@code XX:XX:XX:XX:XX:XX}
-     */
-    public String getBSSID() {
-        return mBSSID;
-    }
-
-    /**
-     * Returns the received signal strength indicator of the current 802.11
-     * network.
-     * <p><strong>This is not normalized, but should be!</strong></p>
-     * @return the RSSI, in the range ??? to ???
-     */
-    public int getRssi() {
-        return mRssi;
-    }
-
-    void setRssi(int rssi) {
-        mRssi = rssi;
-    }
-
-    /**
-     * Returns the current link speed in {@link #LINK_SPEED_UNITS}.
-     * @return the link speed.
-     * @see #LINK_SPEED_UNITS
-     */
-    public int getLinkSpeed() {
-        return mLinkSpeed;
-    }
-
-    void setLinkSpeed(int linkSpeed) {
-        this.mLinkSpeed = linkSpeed;
-    }
-
-    /**
-     * Record the MAC address of the WLAN interface
-     * @param macAddress the MAC address in {@code XX:XX:XX:XX:XX:XX} form
-     */
-    void setMacAddress(String macAddress) {
-        this.mMacAddress = macAddress;
-    }
-
-    public String getMacAddress() {
-        return mMacAddress;
-    }
-
-    void setNetworkId(int id) {
-        mNetworkId = id;
-    }
-
-    /**
-     * Each configured network has a unique small integer ID, used to identify
-     * the network when performing operations on the supplicant. This method
-     * returns the ID for the currently connected network.
-     * @return the network ID, or -1 if there is no currently connected network
-     */
-    public int getNetworkId() {
-        return mNetworkId;
-    }
-
-    /**
-     * Return the detailed state of the supplicant's negotiation with an
-     * access point, in the form of a {@link SupplicantState SupplicantState} object.
-     * @return the current {@link SupplicantState SupplicantState}
-     */
-    public SupplicantState getSupplicantState() {
-        return mSupplicantState;
-    }
-
-    void setSupplicantState(SupplicantState state) {
-        mSupplicantState = state;
-    }
-
-    void setIpAddress(int address) {
-        mIpAddress = address;
-    }
-
-    public int getIpAddress() {
-        return mIpAddress;
-    }
-
-    /**
-     * @return {@code true} if this network does not broadcast its SSID, so an
-     * SSID-specific probe request must be used for scans.
-     */
-    public boolean getHiddenSSID() {
-        return mHiddenSSID;
-    }
-
-    /** {@hide} */
-    public void setHiddenSSID(boolean hiddenSSID) {
-        mHiddenSSID = hiddenSSID;
-    }
-
-   /**
-     * Map a supplicant state into a fine-grained network connectivity state.
-     * @param suppState the supplicant state
-     * @return the corresponding {@link DetailedState}
-     */
-    public static DetailedState getDetailedStateOf(SupplicantState suppState) {
-        return stateMap.get(suppState);
-    }
-
-    /**
-     * Set the <code>SupplicantState</code> from the string name
-     * of the state.
-     * @param stateName the name of the state, as a <code>String</code> returned
-     * in an event sent by {@code wpa_supplicant}.
-     */
-    void setSupplicantState(String stateName) {
-        mSupplicantState = valueOf(stateName);
-    }
-
-    static SupplicantState valueOf(String stateName) {
-        if ("4WAY_HANDSHAKE".equalsIgnoreCase(stateName))
-            return SupplicantState.FOUR_WAY_HANDSHAKE;
-        else {
-            try {
-                return SupplicantState.valueOf(stateName.toUpperCase());
-            } catch (IllegalArgumentException e) {
-                return SupplicantState.INVALID;
-            }
-        }
-    }
-
-    @Override
-    public String toString() {
-        StringBuffer sb = new StringBuffer();
-        String none = "<none>";
-
-        sb.append("SSID: ").append(mSSID == null ? none : mSSID).
-            append(", BSSID: ").append(mBSSID == null ? none : mBSSID).
-            append(", MAC: ").append(mMacAddress == null ? none : mMacAddress).
-            append(", Supplicant state: ").
-            append(mSupplicantState == null ? none : mSupplicantState).
-            append(", RSSI: ").append(mRssi).
-            append(", Link speed: ").append(mLinkSpeed).
-            append(", Net ID: ").append(mNetworkId);
-
-        return sb.toString();
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public int describeContents() {
-        return 0;
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public void writeToParcel(Parcel dest, int flags) {
-        dest.writeInt(mNetworkId);
-        dest.writeInt(mRssi);
-        dest.writeInt(mLinkSpeed);
-        dest.writeInt(mIpAddress);
-        dest.writeString(getSSID());
-        dest.writeString(mBSSID);
-        dest.writeString(mMacAddress);
-        mSupplicantState.writeToParcel(dest, flags);
-    }
-
-    /** Implement the Parcelable interface {@hide} */
-    public static final Creator<WifiInfo> CREATOR =
-        new Creator<WifiInfo>() {
-            public WifiInfo createFromParcel(Parcel in) {
-                WifiInfo info = new WifiInfo();
-                info.setNetworkId(in.readInt());
-                info.setRssi(in.readInt());
-                info.setLinkSpeed(in.readInt());
-                info.setIpAddress(in.readInt());
-                info.setSSID(in.readString());
-                info.mBSSID = in.readString();
-                info.mMacAddress = in.readString();
-                info.mSupplicantState = SupplicantState.CREATOR.createFromParcel(in);
-                return info;
-            }
-
-            public WifiInfo[] newArray(int size) {
-                return new WifiInfo[size];
-            }
-        };
-}
diff --git a/wifi/java/android/net/wifi/WifiManager.java b/wifi/java/android/net/wifi/WifiManager.java
deleted file mode 100644
index 483e0fa..0000000
--- a/wifi/java/android/net/wifi/WifiManager.java
+++ /dev/null
@@ -1,830 +0,0 @@
-/*
- * Copyright (C) 2008 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 android.net.wifi;
-
-import android.annotation.SdkConstant;
-import android.annotation.SdkConstant.SdkConstantType;
-import android.net.DhcpInfo;
-import android.os.Binder;
-import android.os.IBinder;
-import android.os.Handler;
-import android.os.RemoteException;
-
-import java.util.List;
-
-/**
- * This class provides the primary API for managing all aspects of Wi-Fi
- * connectivity. Get an instance of this class by calling
- * {@link android.content.Context#getSystemService(String) Context.getSystemService(Context.WIFI_SERVICE)}.
-
- * It deals with several categories of items:
- * <ul>
- * <li>The list of configured networks. The list can be viewed and updated,
- * and attributes of individual entries can be modified.</li>
- * <li>The currently active Wi-Fi network, if any. Connectivity can be
- * established or torn down, and dynamic information about the state of
- * the network can be queried.</li>
- * <li>Results of access point scans, containing enough information to
- * make decisions about what access point to connect to.</li>
- * <li>It defines the names of various Intent actions that are broadcast
- * upon any sort of change in Wi-Fi state.
- * </ul>
- * This is the API to use when performing Wi-Fi specific operations. To
- * perform operations that pertain to network connectivity at an abstract
- * level, use {@link android.net.ConnectivityManager}.
- */
-public class WifiManager {
-
-    // Supplicant error codes:
-    /**
-     * The error code if there was a problem authenticating.
-     */
-    public static final int ERROR_AUTHENTICATING = 1;
-
-    /**
-     * Broadcast intent action indicating that Wi-Fi has been enabled, disabled,
-     * enabling, disabling, or unknown. One extra provides this state as an int.
-     * Another extra provides the previous state, if available.
-     * 
-     * @see #EXTRA_WIFI_STATE
-     * @see #EXTRA_PREVIOUS_WIFI_STATE
-     */
-    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
-    public static final String WIFI_STATE_CHANGED_ACTION =
-        "android.net.wifi.WIFI_STATE_CHANGED";
-    /**
-     * The lookup key for an int that indicates whether Wi-Fi is enabled,
-     * disabled, enabling, disabling, or unknown.  Retrieve it with
-     * {@link android.content.Intent#getIntExtra(String,int)}.
-     * 
-     * @see #WIFI_STATE_DISABLED
-     * @see #WIFI_STATE_DISABLING
-     * @see #WIFI_STATE_ENABLED
-     * @see #WIFI_STATE_ENABLING
-     * @see #WIFI_STATE_UNKNOWN
-     */
-    public static final String EXTRA_WIFI_STATE = "wifi_state";
-    /**
-     * The previous Wi-Fi state.
-     * 
-     * @see #EXTRA_WIFI_STATE
-     */
-    public static final String EXTRA_PREVIOUS_WIFI_STATE = "previous_wifi_state";
-    
-    /**
-     * Wi-Fi is currently being disabled. The state will change to {@link #WIFI_STATE_DISABLED} if
-     * it finishes successfully.
-     * 
-     * @see #WIFI_STATE_CHANGED_ACTION
-     * @see #getWifiState()
-     */
-    public static final int WIFI_STATE_DISABLING = 0;
-    /**
-     * Wi-Fi is disabled.
-     * 
-     * @see #WIFI_STATE_CHANGED_ACTION
-     * @see #getWifiState()
-     */
-    public static final int WIFI_STATE_DISABLED = 1;
-    /**
-     * Wi-Fi is currently being enabled. The state will change to {@link #WIFI_STATE_ENABLED} if
-     * it finishes successfully.
-     * 
-     * @see #WIFI_STATE_CHANGED_ACTION
-     * @see #getWifiState()
-     */
-    public static final int WIFI_STATE_ENABLING = 2;
-    /**
-     * Wi-Fi is enabled.
-     * 
-     * @see #WIFI_STATE_CHANGED_ACTION
-     * @see #getWifiState()
-     */
-    public static final int WIFI_STATE_ENABLED = 3;
-    /**
-     * Wi-Fi is in an unknown state. This state will occur when an error happens while enabling
-     * or disabling.
-     * 
-     * @see #WIFI_STATE_CHANGED_ACTION
-     * @see #getWifiState()
-     */
-    public static final int WIFI_STATE_UNKNOWN = 4;
-    
-    /**
-     * Broadcast intent action indicating that a connection to the supplicant has
-     * been established (and it is now possible
-     * to perform Wi-Fi operations) or the connection to the supplicant has been
-     * lost. One extra provides the connection state as a boolean, where {@code true}
-     * means CONNECTED.
-     * @see #EXTRA_SUPPLICANT_CONNECTED
-     */
-    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
-    public static final String SUPPLICANT_CONNECTION_CHANGE_ACTION =
-        "android.net.wifi.supplicant.CONNECTION_CHANGE";
-    /**
-     * The lookup key for a boolean that indicates whether a connection to
-     * the supplicant daemon has been gained or lost. {@code true} means
-     * a connection now exists.
-     * Retrieve it with {@link android.content.Intent#getBooleanExtra(String,boolean)}.
-     */
-    public static final String EXTRA_SUPPLICANT_CONNECTED = "connected";
-    /**
-     * Broadcast intent action indicating that the state of Wi-Fi connectivity
-     * has changed. One extra provides the new state
-     * in the form of a {@link android.net.NetworkInfo} object. If the new state is
-     * CONNECTED, a second extra may provide the BSSID of the access point,
-     * as a {@code String}.
-     * @see #EXTRA_NETWORK_INFO
-     * @see #EXTRA_BSSID
-     */
-    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
-    public static final String NETWORK_STATE_CHANGED_ACTION = "android.net.wifi.STATE_CHANGE";
-    /**
-     * The lookup key for a {@link android.net.NetworkInfo} object associated with the
-     * Wi-Fi network. Retrieve with
-     * {@link android.content.Intent#getParcelableExtra(String)}.
-     */
-    public static final String EXTRA_NETWORK_INFO = "networkInfo";
-    /**
-     * The lookup key for a String giving the BSSID of the access point to which
-     * we are connected. Only present when the new state is CONNECTED.
-     * Retrieve with
-     * {@link android.content.Intent#getStringExtra(String)}.
-     */
-    public static final String EXTRA_BSSID = "bssid";
-    /**
-     * Broadcast intent action indicating that the state of establishing a connection to
-     * an access point has changed.One extra provides the new
-     * {@link SupplicantState}. Note that the supplicant state is Wi-Fi specific, and
-     * is not generally the most useful thing to look at if you are just interested in
-     * the overall state of connectivity.
-     * @see #EXTRA_NEW_STATE
-     * @see #EXTRA_SUPPLICANT_ERROR
-     */
-    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
-    public static final String SUPPLICANT_STATE_CHANGED_ACTION =
-        "android.net.wifi.supplicant.STATE_CHANGE";
-    /**
-     * The lookup key for a {@link SupplicantState} describing the new state
-     * Retrieve with
-     * {@link android.content.Intent#getParcelableExtra(String)}.
-     */
-    public static final String EXTRA_NEW_STATE = "newState";
-
-    /**
-     * The lookup key for a {@link SupplicantState} describing the supplicant
-     * error code if any
-     * Retrieve with
-     * {@link android.content.Intent#getIntExtra(String, int)}.
-     * @see #ERROR_AUTHENTICATING
-     */
-    public static final String EXTRA_SUPPLICANT_ERROR = "supplicantError";
-
-    /**
-     * An access point scan has completed, and results are available from the supplicant.
-     * Call {@link #getScanResults()} to obtain the results.
-     */
-    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
-    public static final String SCAN_RESULTS_AVAILABLE_ACTION = "android.net.wifi.SCAN_RESULTS";
-    /**
-     * The RSSI (signal strength) has changed.
-     * @see #EXTRA_NEW_RSSI
-     */
-    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
-    public static final String RSSI_CHANGED_ACTION = "android.net.wifi.RSSI_CHANGED";
-    /**
-     * The lookup key for an {@code int} giving the new RSSI in dBm.
-     */
-    public static final String EXTRA_NEW_RSSI = "newRssi";
-
-    /**
-     * The network IDs of the configured networks could have changed.
-     */
-    @SdkConstant(SdkConstantType.BROADCAST_INTENT_ACTION)
-    public static final String NETWORK_IDS_CHANGED_ACTION = "android.net.wifi.NETWORK_IDS_CHANGED";
-    
-    /**
-     * Activity Action: Pick a Wi-Fi network to connect to.
-     * <p>Input: Nothing.
-     * <p>Output: Nothing.
-     */
-    @SdkConstant(SdkConstantType.ACTIVITY_INTENT_ACTION)
-    public static final String ACTION_PICK_WIFI_NETWORK = "android.net.wifi.PICK_WIFI_NETWORK";
-
-    /**
-     * In this mode, Wi-Fi will be kept active,
-     * and will behave normally, i.e., it will attempt to automatically
-     * establish a connection to a remembered access point that is
-     * within range, and will do periodic scans if there are remembered
-     * access points but none are in range.
-     * @hide pending API council review
-     */
-    public static final int WIFI_MODE_FULL = 1;
-    /**
-     * In this mode, Wi-Fi will be kept active,
-     * but the only operation that will be supported is initiation of
-     * scans, and the subsequent reporting of scan results. No attempts
-     * will be made to automatically connect to remembered access points,
-     * nor will periodic scans be automatically performed looking for
-     * remembered access points. Scans must be explicitly requested by
-     * an application in this mode.
-     * @hide pending API council review
-     */
-    public static final int WIFI_MODE_SCAN_ONLY = 2;
-
-    /** Anything worse than or equal to this will show 0 bars. */
-    private static final int MIN_RSSI = -100;
-    
-    /** Anything better than or equal to this will show the max bars. */
-    private static final int MAX_RSSI = -55;
-    
-    IWifiManager mService;
-    Handler mHandler;
-
-    /**
-     * Create a new WifiManager instance.
-     * Applications will almost always want to use
-     * {@link android.content.Context#getSystemService Context.getSystemService()} to retrieve
-     * the standard {@link android.content.Context#WIFI_SERVICE Context.WIFI_SERVICE}.
-     * @param service the Binder interface
-     * @param handler target for messages
-     * @hide - hide this because it takes in a parameter of type IWifiManager, which
-     * is a system private class.
-     */
-    public WifiManager(IWifiManager service, Handler handler) {
-        mService = service;
-        mHandler = handler;
-    }
-
-    /**
-     * Return a list of all the networks configured in the supplicant.
-     * Not all fields of WifiConfiguration are returned. Only the following
-     * fields are filled in:
-     * <ul>
-     * <li>networkId</li>
-     * <li>SSID</li>
-     * <li>BSSID</li>
-     * <li>priority</li>
-     * <li>allowedProtocols</li>
-     * <li>allowedKeyManagement</li>
-     * <li>allowedAuthAlgorithms</li>
-     * <li>allowedPairwiseCiphers</li>
-     * <li>allowedGroupCiphers</li>
-     * </ul>
-     * @return a list of network configurations in the form of a list
-     * of {@link WifiConfiguration} objects.
-     */
-    public List<WifiConfiguration> getConfiguredNetworks() {
-        try {
-            return mService.getConfiguredNetworks();
-        } catch (RemoteException e) {
-            return null;
-        }
-    }
-
-    /**
-     * Add a new network description to the set of configured networks.
-     * The {@code networkId} field of the supplied configuration object
-     * is ignored.
-     * <p/>
-     * The new network will be marked DISABLED by default. To enable it,
-     * called {@link #enableNetwork}.
-     * 
-     * @param config the set of variables that describe the configuration,
-     *            contained in a {@link WifiConfiguration} object.
-     * @return the ID of the newly created network description. This is used in
-     *         other operations to specified the network to be acted upon.
-     *         Returns {@code -1} on failure.
-     */
-    public int addNetwork(WifiConfiguration config) {
-        if (config == null) {
-            return -1;
-        }
-        config.networkId = -1;
-        return addOrUpdateNetwork(config);
-    }
-
-    /**
-     * Update the network description of an existing configured network.
-     *
-     * @param config the set of variables that describe the configuration,
-     *            contained in a {@link WifiConfiguration} object. It may
-     *            be sparse, so that only the items that are being changed
-     *            are non-<code>null</code>. The {@code networkId} field
-     *            must be set to the ID of the existing network being updated.
-     * @return Returns the {@code networkId} of the supplied
-     *         {@code WifiConfiguration} on success.
-     *         <br/>
-     *         Returns {@code -1} on failure, including when the {@code networkId}
-     *         field of the {@code WifiConfiguration} does not refer to an
-     *         existing network.
-     */
-    public int updateNetwork(WifiConfiguration config) {
-        if (config == null || config.networkId < 0) {
-            return -1;
-        }
-        return addOrUpdateNetwork(config);
-    }
-
-    /**
-     * Internal method for doing the RPC that creates a new network description
-     * or updates an existing one.
-     * 
-     * @param config The possibly sparse object containing the variables that
-     *         are to set or updated in the network description.
-     * @return the ID of the network on success, {@code -1} on failure.
-     */
-    private int addOrUpdateNetwork(WifiConfiguration config) {
-        try {
-            return mService.addOrUpdateNetwork(config);
-        } catch (RemoteException e) {
-            return -1;
-        }
-    }
-
-    /**
-     * Remove the specified network from the list of configured networks.
-     * This may result in the asynchronous delivery of state change
-     * events.
-     * @param netId the integer that identifies the network configuration
-     * to the supplicant
-     * @return {@code true} if the operation succeeded
-     */
-    public boolean removeNetwork(int netId) {
-        try {
-            return mService.removeNetwork(netId);
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Allow a previously configured network to be associated with. If
-     * <code>disableOthers</code> is true, then all other configured
-     * networks are disabled, and an attempt to connect to the selected
-     * network is initiated. This may result in the asynchronous delivery
-     * of state change events.
-     * @param netId the ID of the network in the list of configured networks
-     * @param disableOthers if true, disable all other networks. The way to
-     * select a particular network to connect to is specify {@code true}
-     * for this parameter.
-     * @return {@code true} if the operation succeeded
-     */
-    public boolean enableNetwork(int netId, boolean disableOthers) {
-        try {
-            return mService.enableNetwork(netId, disableOthers);
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Disable a configured network. The specified network will not be
-     * a candidate for associating. This may result in the asynchronous
-     * delivery of state change events.
-     * @param netId the ID of the network as returned by {@link #addNetwork}.
-     * @return {@code true} if the operation succeeded
-     */
-    public boolean disableNetwork(int netId) {
-        try {
-            return mService.disableNetwork(netId);
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Disassociate from the currently active access point. This may result
-     * in the asynchronous delivery of state change events.
-     * @return {@code true} if the operation succeeded
-     */
-    public boolean disconnect() {
-        try {
-            return mService.disconnect();
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Reconnect to the currently active access point, if we are currently
-     * disconnected. This may result in the asynchronous delivery of state
-     * change events.
-     * @return {@code true} if the operation succeeded
-     */
-    public boolean reconnect() {
-        try {
-            return mService.reconnect();
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Reconnect to the currently active access point, even if we are already
-     * connected. This may result in the asynchronous delivery of state
-     * change events.
-     * @return {@code true} if the operation succeeded
-     */
-    public boolean reassociate() {
-        try {
-            return mService.reassociate();
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Check that the supplicant daemon is responding to requests.
-     * @return {@code true} if we were able to communicate with the supplicant and
-     * it returned the expected response to the PING message.
-     */
-    public boolean pingSupplicant() {
-        if (mService == null)
-            return false;
-        try {
-            return mService.pingSupplicant();
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Request a scan for access points. Returns immediately. The availability
-     * of the results is made known later by means of an asynchronous event sent
-     * on completion of the scan.
-     * @return {@code true} if the operation succeeded, i.e., the scan was initiated
-     */
-    public boolean  startScan() {
-        try {
-            return mService.startScan();
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Return dynamic information about the current Wi-Fi connection, if any is active.
-     * @return the Wi-Fi information, contained in {@link WifiInfo}.
-     */
-    public WifiInfo getConnectionInfo() {
-        try {
-            return mService.getConnectionInfo();
-        } catch (RemoteException e) {
-            return null;
-        }
-    }
-
-    /**
-     * Return the results of the latest access point scan.
-     * @return the list of access points found in the most recent scan.
-     */
-    public List<ScanResult> getScanResults() {
-        try {
-            return mService.getScanResults();
-        } catch (RemoteException e) {
-            return null;
-        }
-    }
-
-    /**
-     * Tell the supplicant to persist the current list of configured networks.
-     * <p>
-     * Note: It is possible for this method to change the network IDs of
-     * existing networks. You should assume the network IDs can be different
-     * after calling this method.
-     * 
-     * @return {@code true} if the operation succeeded
-     */
-    public boolean saveConfiguration() {
-        try {
-            return mService.saveConfiguration();
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Return the number of frequency channels that are allowed
-     * to be used in the current regulatory domain.
-     * @return the number of allowed channels, or {@code -1} if an error occurs
-     *
-     * @hide pending API council
-     */
-    public int getNumAllowedChannels() {
-        try {
-            return mService.getNumAllowedChannels();
-        } catch (RemoteException e) {
-            return -1;
-        }
-    }
-
-    /**
-     * Set the number of frequency channels that are allowed to be used
-     * in the current regulatory domain. This method should be used only
-     * if the correct number of channels cannot be determined automatically
-     * for some reason.
-     * @param numChannels the number of allowed channels. Must be greater than 0
-     * and less than or equal to 16.
-     * @return {@code true} if the operation succeeds, {@code false} otherwise, e.g.,
-     * {@code numChannels} is out of range.
-     *
-     * @hide pending API council
-     */
-    public boolean setNumAllowedChannels(int numChannels) {
-        try {
-            return mService.setNumAllowedChannels(numChannels);
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Return the list of valid values for the number of allowed radio channels
-     * for various regulatory domains.
-     * @return the list of channel counts, or {@code null} if the operation fails
-     *
-     * @hide pending API council review
-     */
-    public int[] getValidChannelCounts() {
-        try {
-            return mService.getValidChannelCounts();
-        } catch (RemoteException e) {
-            return null;
-        }
-   }
-
-    /**
-     * Return the DHCP-assigned addresses from the last successful DHCP request,
-     * if any.
-     * @return the DHCP information
-     */
-    public DhcpInfo getDhcpInfo() {
-        try {
-            return mService.getDhcpInfo();
-        } catch (RemoteException e) {
-            return null;
-        }
-    }
-
-
-    /**
-     * Enable or disable Wi-Fi.
-     * @param enabled {@code true} to enable, {@code false} to disable.
-     * @return {@code true} if the operation succeeds (or if the existing state
-     *         is the same as the requested state).
-     */
-    public boolean setWifiEnabled(boolean enabled) {
-        try {
-            return mService.setWifiEnabled(enabled);
-        } catch (RemoteException e) {
-            return false;
-        }
-    }
-
-    /**
-     * Gets the Wi-Fi enabled state.
-     * @return One of {@link #WIFI_STATE_DISABLED},
-     *         {@link #WIFI_STATE_DISABLING}, {@link #WIFI_STATE_ENABLED},
-     *         {@link #WIFI_STATE_ENABLING}, {@link #WIFI_STATE_UNKNOWN}
-     * @see #isWifiEnabled()
-     */
-    public int getWifiState() {
-        try {
-            return mService.getWifiEnabledState();
-        } catch (RemoteException e) {
-            return WIFI_STATE_UNKNOWN;
-        }
-    }
-    
-    /**
-     * Return whether Wi-Fi is enabled or disabled. 
-     * @return {@code true} if Wi-Fi is enabled
-     * @see #getWifiState()
-     */
-    public boolean isWifiEnabled() {
-        return getWifiState() == WIFI_STATE_ENABLED;
-    }
-    
-    /**
-     * Calculates the level of the signal. This should be used any time a signal
-     * is being shown.
-     * 
-     * @param rssi The power of the signal measured in RSSI.
-     * @param numLevels The number of levels to consider in the calculated
-     *            level.
-     * @return A level of the signal, given in the range of 0 to numLevels-1
-     *         (both inclusive).
-     */
-    public static int calculateSignalLevel(int rssi, int numLevels) {
-        if (rssi <= MIN_RSSI) {
-            return 0;
-        } else if (rssi >= MAX_RSSI) {
-            return numLevels - 1;
-        } else {
-            int partitionSize = (MAX_RSSI - MIN_RSSI) / (numLevels - 1);
-            return (rssi - MIN_RSSI) / partitionSize;
-        }
-    }
-    
-    /**
-     * Compares two signal strengths.
-     * 
-     * @param rssiA The power of the first signal measured in RSSI.
-     * @param rssiB The power of the second signal measured in RSSI.
-     * @return Returns <0 if the first signal is weaker than the second signal,
-     *         0 if the two signals have the same strength, and >0 if the first
-     *         signal is stronger than the second signal.
-     */
-    public static int compareSignalLevel(int rssiA, int rssiB) {
-        return rssiA - rssiB;
-    }
-
-    /**
-     * Allows an application to keep the Wi-Fi radio awake.
-     * Normally the Wi-Fi radio may turn off when the user has not used the device in a while.
-     * Acquiring a WifiLock will keep the radio on until the lock is released.  Multiple 
-     * applications may hold WifiLocks, and the radio will only be allowed to turn off when no
-     * WifiLocks are held in any application.
-     *
-     * Before using a WifiLock, consider carefully if your application requires Wi-Fi access, or
-     * could function over a mobile network, if available.  A program that needs to download large
-     * files should hold a WifiLock to ensure that the download will complete, but a program whose
-     * network usage is occasional or low-bandwidth should not hold a WifiLock to avoid adversely
-     * affecting battery life.
-     *
-     * Note that WifiLocks cannot override the user-level "Wi-Fi Enabled" setting, nor Airplane
-     * Mode.  They simply keep the radio from turning off when Wi-Fi is already on but the device
-     * is idle.
-     */
-    public class WifiLock {
-        private String mTag;
-        private final IBinder mBinder;
-        private int mRefCount;
-        int mLockType;
-        private boolean mRefCounted;
-        private boolean mHeld;
-
-        private WifiLock(int lockType, String tag) {
-            mTag = tag;
-            mLockType = lockType;
-            mBinder = new Binder();
-            mRefCount = 0;
-            mRefCounted = true;
-            mHeld = false;
-        }
-
-        /**
-         * Locks the Wi-Fi radio on until {@link #release} is called.
-         *
-         * If this WifiLock is reference-counted, each call to {@code acquire} will increment the
-         * reference count, and the radio will remain locked as long as the reference count is 
-         * above zero.
-         *
-         * If this WifiLock is not reference-counted, the first call to {@code acquire} will lock
-         * the radio, but subsequent calls will be ignored.  Only one call to {@link #release}
-         * will be required, regardless of the number of times that {@code acquire} is called.
-         */
-        public void acquire() {
-            synchronized (mBinder) {
-                if (mRefCounted ? (++mRefCount > 0) : (!mHeld)) {
-                    try {
-                        mService.acquireWifiLock(mBinder, mLockType, mTag);
-                    } catch (RemoteException ignore) {
-                    }
-                    mHeld = true;
-                }
-            }
-        }
-
-        /**
-         * Unlocks the Wi-Fi radio, allowing it to turn off when the device is idle.
-         *
-         * If this WifiLock is reference-counted, each call to {@code release} will decrement the
-         * reference count, and the radio will be unlocked only when the reference count reaches
-         * zero.  If the reference count goes below zero (that is, if {@code release} is called
-         * a greater number of times than {@link #acquire}), an exception is thrown.
-         *
-         * If this WifiLock is not reference-counted, the first call to {@code release} (after
-         * the radio was locked using {@link #acquire}) will unlock the radio, and subsequent
-         * calls will be ignored.
-         */
-        public void release() {
-            synchronized (mBinder) {
-                if (mRefCounted ? (--mRefCount == 0) : (mHeld)) {
-                    try {
-                        mService.releaseWifiLock(mBinder);
-                    } catch (RemoteException ignore) {
-                    }
-                    mHeld = false;
-                }
-                if (mRefCount < 0) {
-                    throw new RuntimeException("WifiLock under-locked " + mTag);
-                }
-            }
-        }
-
-        /**
-         * Controls whether this is a reference-counted or non-reference-counted WifiLock.
-         *
-         * Reference-counted WifiLocks keep track of the number of calls to {@link #acquire} and
-         * {@link #release}, and only allow the radio to sleep when every call to {@link #acquire}
-         * has been balanced with a call to {@link #release}.  Non-reference-counted WifiLocks
-         * lock the radio whenever {@link #acquire} is called and it is unlocked, and unlock the
-         * radio whenever {@link #release} is called and it is locked.
-         *
-         * @param refCounted true if this WifiLock should keep a reference count
-         */
-        public void setReferenceCounted(boolean refCounted) {
-            mRefCounted = refCounted;
-        }
-
-        /**
-         * Checks whether this WifiLock is currently held.
-         *
-         * @return true if this WifiLock is held, false otherwise
-         */
-        public boolean isHeld() {
-            synchronized (mBinder) {
-                return mHeld;
-            }
-        }
-
-        public String toString() {
-            String s1, s2, s3;
-            synchronized (mBinder) {
-                s1 = Integer.toHexString(System.identityHashCode(this));
-                s2 = mHeld ? "held; " : "";
-                if (mRefCounted) {
-                    s3 = "refcounted: refcount = " + mRefCount;
-                } else {
-                    s3 = "not refcounted";
-                }
-                return "WifiLock{ " + s1 + "; " + s2 + s3 + " }";
-            }
-        }
-
-        @Override
-        protected void finalize() throws Throwable {
-            super.finalize();
-            synchronized (mBinder) {
-                if (mHeld) {
-                    try {
-                        mService.releaseWifiLock(mBinder);
-                    } catch (RemoteException ignore) {
-                    }
-                }
-            }
-        }
-    }
-
-    /**
-     * Creates a new WifiLock.
-     *
-     * @param lockType the type of lock to create. See {@link #WIFI_MODE_FULL} and
-     * {@link #WIFI_MODE_SCAN_ONLY} for descriptions of the types of Wi-Fi locks.
-     * @param tag a tag for the WifiLock to identify it in debugging messages.  This string is 
-     *            never shown to the user under normal conditions, but should be descriptive 
-     *            enough to identify your application and the specific WifiLock within it, if it
-     *            holds multiple WifiLocks.
-     *
-     * @return a new, unacquired WifiLock with the given tag.
-     *
-     * @see WifiLock
-     *
-     * @hide pending API council review
-     */
-    public WifiLock createWifiLock(int lockType, String tag) {
-        return new WifiLock(lockType, tag);
-    }
-    
-    /**
-     * Creates a new WifiLock.
-     *
-     * @param tag a tag for the WifiLock to identify it in debugging messages.  This string is
-     *            never shown to the user under normal conditions, but should be descriptive
-     *            enough to identify your application and the specific WifiLock within it, if it
-     *            holds multiple WifiLocks.
-     *
-     * @return a new, unacquired WifiLock with the given tag.
-     *
-     * @see WifiLock
-     */
-    public WifiLock createWifiLock(String tag) {
-        return new WifiLock(WIFI_MODE_FULL, tag);
-    }
-}
diff --git a/wifi/java/android/net/wifi/WifiMonitor.java b/wifi/java/android/net/wifi/WifiMonitor.java
deleted file mode 100644
index fc750e2..0000000
--- a/wifi/java/android/net/wifi/WifiMonitor.java
+++ /dev/null
@@ -1,362 +0,0 @@
-/*
- * Copyright (C) 2008 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 android.net.wifi;
-
-import android.util.Log;
-import android.util.Config;
-import android.net.NetworkInfo;
-import android.net.NetworkStateTracker;
-
-import java.util.regex.Pattern;
-import java.util.regex.Matcher;
-
-/**
- * Listens for events from the wpa_supplicant server, and passes them on
- * to the {@link WifiStateTracker} for handling. Runs in its own thread.
- *
- * @hide
- */
-public class WifiMonitor {
-
-    private static final String TAG = "WifiMonitor";
-
-    /** Events we receive from the supplicant daemon */
-
-    private static final int CONNECTED    = 1;
-    private static final int DISCONNECTED = 2;
-    private static final int STATE_CHANGE = 3;
-    private static final int SCAN_RESULTS = 4;
-    private static final int LINK_SPEED   = 5;
-    private static final int TERMINATING  = 6;
-    private static final int DRIVER_STATE = 7;
-    private static final int UNKNOWN      = 8;
-
-    /** All events coming from the supplicant start with this prefix */
-    private static final String eventPrefix = "CTRL-EVENT-";
-    private static final int eventPrefixLen = eventPrefix.length();
-
-    /** All WPA events coming from the supplicant start with this prefix */
-    private static final String wpaEventPrefix = "WPA:";
-    private static final String passwordKeyMayBeIncorrectEvent =
-       "pre-shared key may be incorrect";
-
-    /**
-     * Names of events from wpa_supplicant (minus the prefix). In the
-     * format descriptions, * &quot;<code>x</code>&quot;
-     * designates a dynamic value that needs to be parsed out from the event
-     * string
-     */
-    /**
-     * <pre>
-     * CTRL-EVENT-CONNECTED - Connection to xx:xx:xx:xx:xx:xx completed
-     * </pre>
-     * <code>xx:xx:xx:xx:xx:xx</code> is the BSSID of the associated access point
-     */
-    private static final String connectedEvent =    "CONNECTED";
-    /**
-     * <pre>
-     * CTRL-EVENT-DISCONNECTED - Disconnect event - remove keys
-     * </pre>
-     */
-    private static final String disconnectedEvent = "DISCONNECTED";
-    /**
-     * <pre>
-     * CTRL-EVENT-STATE-CHANGE x
-     * </pre>
-     * <code>x</code> is the numerical value of the new state.
-     */
-    private static final String stateChangeEvent =  "STATE-CHANGE";
-    /**
-     * <pre>
-     * CTRL-EVENT-SCAN-RESULTS ready
-     * </pre>
-     */
-    private static final String scanResultsEvent =  "SCAN-RESULTS";
-
-    /**
-     * <pre>
-     * CTRL-EVENT-LINK-SPEED x Mb/s
-     * </pre>
-     * {@code x} is the link speed in Mb/sec.
-     */
-    private static final String linkSpeedEvent = "LINK-SPEED";
-    /**
-     * <pre>
-     * CTRL-EVENT-TERMINATING - signal x
-     * </pre>
-     * <code>x</code> is the signal that caused termination.
-     */
-    private static final String terminatingEvent =  "TERMINATING";
-    /**
-     * <pre>
-     * CTRL-EVENT-DRIVER-STATE state
-     * </pre>
-     * <code>state</code> is either STARTED or STOPPED
-     */
-    private static final String driverStateEvent = "DRIVER-STATE";
-
-    /**
-     * Regex pattern for extracting an Ethernet-style MAC address from a string.
-     * Matches a strings like the following:<pre>
-     * CTRL-EVENT-CONNECTED - Connection to 00:1e:58:ec:d5:6d completed (reauth) [id=1 id_str=]</pre>
-     */
-    private static Pattern mConnectedEventPattern =
-        Pattern.compile("((?:[0-9a-f]{2}:){5}[0-9a-f]{2}) .* \\[id=([0-9]+) ");
-
-    private final WifiStateTracker mWifiStateTracker;
-
-    public WifiMonitor(WifiStateTracker tracker) {
-        mWifiStateTracker = tracker;
-    }
-
-    public void startMonitoring() {
-        new MonitorThread().start();
-    }
-
-    public NetworkStateTracker getNetworkStateTracker() {
-        return mWifiStateTracker;
-    }
-
-    class MonitorThread extends Thread {
-        public MonitorThread() {
-            super("WifiMonitor");
-        }
-        
-        public void run() {
-
-            if (connectToSupplicant()) {
-                // Send a message indicating that it is now possible to send commands
-                // to the supplicant
-                mWifiStateTracker.notifySupplicantConnection();
-            } else {
-                mWifiStateTracker.notifySupplicantLost();
-                return;
-            }
-
-            //noinspection InfiniteLoopStatement
-            for (;;) {
-                String eventStr = WifiNative.waitForEvent();
-
-                if (eventStr == null) {
-                    continue;
-                }
-
-                // Skip logging the common but mostly uninteresting scan-results event
-                if (Config.LOGD && eventStr.indexOf(scanResultsEvent) == -1) {
-                    Log.v(TAG, "Event [" + eventStr + "]");
-                }
-                if (!eventStr.startsWith(eventPrefix)) {
-                    if (eventStr.startsWith(wpaEventPrefix) && 0 < eventStr.indexOf(passwordKeyMayBeIncorrectEvent)) {
-                        handlePasswordKeyMayBeIncorrect();
-                    }
-                    continue;
-                }
-
-                String eventName = eventStr.substring(eventPrefixLen);
-                int nameEnd = eventName.indexOf(' ');
-                if (nameEnd != -1)
-                    eventName = eventName.substring(0, nameEnd);
-                if (eventName.length() == 0) {
-                    if (Config.LOGD) Log.i(TAG, "Received wpa_supplicant event with empty event name");
-                    continue;
-                }
-                /*
-                 * Map event name into event enum
-                 */
-                int event;
-                if (eventName.equals(connectedEvent))
-                    event = CONNECTED;
-                else if (eventName.equals(disconnectedEvent))
-                    event = DISCONNECTED;
-                else if (eventName.equals(stateChangeEvent))
-                    event = STATE_CHANGE;
-                else if (eventName.equals(scanResultsEvent))
-                    event = SCAN_RESULTS;
-                else if (eventName.equals(linkSpeedEvent))
-                    event = LINK_SPEED;
-                else if (eventName.equals(terminatingEvent))
-                    event = TERMINATING;
-                else if (eventName.equals(driverStateEvent)) {
-                    event = DRIVER_STATE;
-                }
-                else
-                    event = UNKNOWN;
-
-                String eventData = eventStr;
-                if (event == DRIVER_STATE || event == LINK_SPEED)
-                    eventData = eventData.split(" ")[1];
-                else if (event == STATE_CHANGE) {
-                    int ind = eventStr.indexOf(" ");
-                    if (ind != -1) {
-                        eventData = eventStr.substring(ind + 1);
-                    }
-                } else {
-                    int ind = eventStr.indexOf(" - ");
-                    if (ind != -1) {
-                        eventData = eventStr.substring(ind + 3);
-                    }
-                }
-
-                if (event == STATE_CHANGE) {
-                    handleSupplicantStateChange(eventData);
-                } else if (event == DRIVER_STATE) {
-                    handleDriverEvent(eventData);
-                } else if (event == TERMINATING) {
-                    mWifiStateTracker.notifySupplicantLost();
-                    // If supplicant is gone, exit the thread
-                    break;
-                } else {
-                    handleEvent(event, eventData);
-                }
-            }
-        }
-
-        private boolean connectToSupplicant() {
-            int connectTries = 0;
-
-            while (true) {
-                synchronized (mWifiStateTracker) {
-                    if (WifiNative.connectToSupplicant()) {
-                        return true;
-                    }
-                }
-                if (connectTries++ < 3) {
-                    nap(5);
-                } else {
-                    break;
-                }
-            }
-            return false;
-        }
-
-        private void handlePasswordKeyMayBeIncorrect() {
-            mWifiStateTracker.notifyPasswordKeyMayBeIncorrect();
-        }
-
-        private void handleDriverEvent(String state) {
-            if (state == null) {
-                return;
-            }
-            if (state.equals("STOPPED")) {
-                mWifiStateTracker.notifyDriverStopped();
-            } else if (state.equals("STARTED")) {
-                mWifiStateTracker.notifyDriverStarted();
-            }
-        }
-
-        /**
-         * Handle all supplicant events except STATE-CHANGE
-         * @param event the event type
-         * @param remainder the rest of the string following the
-         * event name and &quot;&#8195;&#8212;&#8195;&quot;
-         */
-        void handleEvent(int event, String remainder) {
-            switch (event) {
-                case DISCONNECTED:
-                    handleNetworkStateChange(NetworkInfo.DetailedState.DISCONNECTED, remainder);
-                    break;
-
-                case CONNECTED:
-                    handleNetworkStateChange(NetworkInfo.DetailedState.CONNECTED, remainder);
-                    break;
-
-                case SCAN_RESULTS:
-                    mWifiStateTracker.notifyScanResultsAvailable();
-                    break;
-
-                case UNKNOWN:
-                    break;
-            }
-        }
-
-        /**
-         * Handle the supplicant STATE-CHANGE event
-         * @param dataString New supplicant state string in the format:
-         * id=network-id state=new-state
-         */
-        private void handleSupplicantStateChange(String dataString) {
-            String[] dataTokens = dataString.split(" ");
-
-            int networkId = -1;
-            int newState  = -1;
-            for (String token : dataTokens) {
-                String[] nameValue = token.split("=");
-                if (nameValue.length != 2) {
-                    continue;
-                }
-
-                int value;
-                try {
-                    value = Integer.parseInt(nameValue[1]);
-                } catch (NumberFormatException e) {
-                    Log.w(TAG, "STATE-CHANGE non-integer parameter: " + token);
-                    continue;
-                }
-
-                if (nameValue[0].equals("id")) {
-                    networkId = value;
-                } else if (nameValue[0].equals("state")) {
-                    newState = value;
-                }
-            }
-
-            if (newState == -1) return;
-
-            SupplicantState newSupplicantState = SupplicantState.INVALID;
-            for (SupplicantState state : SupplicantState.values()) {
-                if (state.ordinal() == newState) {
-                    newSupplicantState = state;
-                    break;
-                }
-            }
-            if (newSupplicantState == SupplicantState.INVALID) {
-                Log.w(TAG, "Invalid supplicant state: " + newState);
-            }
-            mWifiStateTracker.notifyStateChange(networkId, newSupplicantState);
-        }
-    }
-
-    private void handleNetworkStateChange(NetworkInfo.DetailedState newState, String data) {
-        String BSSID = null;
-        int networkId = -1;
-        if (newState == NetworkInfo.DetailedState.CONNECTED) {
-            Matcher match = mConnectedEventPattern.matcher(data);
-            if (!match.find()) {
-                if (Config.LOGD) Log.d(TAG, "Could not find BSSID in CONNECTED event string");
-            } else {
-                BSSID = match.group(1);
-                try {
-                    networkId = Integer.parseInt(match.group(2));
-                } catch (NumberFormatException e) {
-                    networkId = -1;
-                }
-            }
-        }
-        mWifiStateTracker.notifyStateChange(newState, BSSID, networkId);
-    }
-
-    /**
-     * Sleep for a period of time.
-     * @param secs the number of seconds to sleep
-     */
-    private static void nap(int secs) {
-        try {
-            Thread.sleep(secs * 1000);
-        } catch (InterruptedException ignore) {
-        }
-    }
-}
diff --git a/wifi/java/android/net/wifi/WifiNative.java b/wifi/java/android/net/wifi/WifiNative.java
deleted file mode 100644
index 2a47a71..0000000
--- a/wifi/java/android/net/wifi/WifiNative.java
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Copyright (C) 2008 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 android.net.wifi;
-
-import android.net.DhcpInfo;
-
-/**
- * Native calls for sending requests to the supplicant daemon, and for
- * receiving asynchronous events. All methods of the form "xxxxCommand()"
- * must be single-threaded, to avoid requests and responses initiated
- * from multiple threads from being intermingled.
- * <p/>
- * Note that methods whose names are not of the form "xxxCommand()" do
- * not talk to the supplicant daemon.
- *
- * {@hide}
- */
-public class WifiNative {
-
-    static final int BLUETOOTH_COEXISTENCE_MODE_ENABLED = 0;
-    static final int BLUETOOTH_COEXISTENCE_MODE_DISABLED = 1;
-    static final int BLUETOOTH_COEXISTENCE_MODE_SENSE = 2;
-    
-    public native static String getErrorString(int errorCode);
-
-    public native static boolean loadDriver();
-    
-    public native static boolean unloadDriver();
-
-    public native static boolean startSupplicant();
-    
-    public native static boolean stopSupplicant();
-
-    public native static boolean connectToSupplicant();
-
-    public native static void closeSupplicantConnection();
-
-    public native static boolean pingCommand();
-
-    public native static boolean scanCommand();
-    
-    public native static boolean setScanModeCommand(boolean setActive);
-
-    public native static String listNetworksCommand();
-
-    public native static int addNetworkCommand();
-
-    public native static boolean setNetworkVariableCommand(int netId, String name, String value);
-
-    public native static String getNetworkVariableCommand(int netId, String name);
-
-    public native static boolean removeNetworkCommand(int netId);
-
-    public native static boolean enableNetworkCommand(int netId, boolean disableOthers);
-    
-    public native static boolean disableNetworkCommand(int netId);
-
-    public native static boolean reconnectCommand();
-
-    public native static boolean reassociateCommand();
-
-    public native static boolean disconnectCommand();
-
-    public native static String statusCommand();
-
-    public native static int getRssiCommand();
-
-    public native static int getLinkSpeedCommand();
-
-    public native static String getMacAddressCommand();
-
-    public native static String scanResultsCommand();
-
-    public native static boolean startDriverCommand();
-
-    public native static boolean stopDriverCommand();
-
-    /**
-     * Start filtering out multicast packets, to reduce battery consumption
-     * that would result from processing them, only to discard them.
-     * @return {@code true} if the operation succeeded, {@code false} otherwise
-     */
-    public native static boolean startPacketFiltering();
-
-    /**
-     * Stop filtering out multicast packets.
-     * @return {@code true} if the operation succeeded, {@code false} otherwise
-     */
-    public native static boolean stopPacketFiltering();
-
-    public native static boolean setPowerModeCommand(int mode);
-
-    public native static boolean setNumAllowedChannelsCommand(int numChannels);
-
-    public native static int getNumAllowedChannelsCommand();
-
-    /**
-     * Sets the bluetooth coexistence mode.
-     * 
-     * @param mode One of {@link #BLUETOOTH_COEXISTENCE_MODE_DISABLED},
-     *            {@link #BLUETOOTH_COEXISTENCE_MODE_ENABLED}, or
-     *            {@link #BLUETOOTH_COEXISTENCE_MODE_SENSE}.
-     * @return Whether the mode was successfully set.
-     */
-    public native static boolean setBluetoothCoexistenceModeCommand(int mode);
-    
-    public native static boolean saveConfigCommand();
-
-    public native static boolean reloadConfigCommand();
-
-    public native static boolean setScanResultHandlingCommand(int mode);
-
-    public native static boolean addToBlacklistCommand(String bssid);
-
-    public native static boolean clearBlacklistCommand();
-
-    public native static boolean doDhcpRequest(DhcpInfo results);
-
-    public native static String getDhcpError();
-
-    /**
-     * Wait for the supplicant to send an event, returning the event string.
-     * @return the event string sent by the supplicant.
-     */
-    public native static String waitForEvent();
-}
diff --git a/wifi/java/android/net/wifi/WifiStateTracker.java b/wifi/java/android/net/wifi/WifiStateTracker.java
deleted file mode 100644
index f0009be..0000000
--- a/wifi/java/android/net/wifi/WifiStateTracker.java
+++ /dev/null
@@ -1,1815 +0,0 @@
-/*
- * Copyright (C) 2008 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 android.net.wifi;
-
-import android.app.ActivityManagerNative;
-import android.net.NetworkInfo;
-import android.net.NetworkStateTracker;
-import android.net.DhcpInfo;
-import android.net.NetworkUtils;
-import android.net.ConnectivityManager;
-import android.net.NetworkInfo.DetailedState;
-import android.net.NetworkInfo.State;
-import android.os.Message;
-import android.os.Parcelable;
-import android.os.Handler;
-import android.os.HandlerThread;
-import android.os.SystemProperties;
-import android.os.Looper;
-import android.provider.Settings;
-import android.text.TextUtils;
-import android.util.EventLog;
-import android.util.Log;
-import android.util.Config;
-import android.app.Notification;
-import android.app.PendingIntent;
-import android.bluetooth.BluetoothHeadset;
-import android.content.ContentResolver;
-import android.content.Intent;
-import android.content.Context;
-import android.database.ContentObserver;
-
-import java.util.List;
-import java.util.ArrayList;
-import java.net.UnknownHostException;
-
-/**
- * Track the state of Wifi connectivity. All event handling is done here,
- * and all changes in connectivity state are initiated here.
- *
- * @hide
- */
-public class WifiStateTracker extends NetworkStateTracker {
-
-    private static final boolean LOCAL_LOGD = Config.LOGD || false;
-    
-    private static final String TAG = "WifiStateTracker";
-
-    // Event log tags (must be in sync with event-log-tags)
-    private static final int EVENTLOG_NETWORK_STATE_CHANGED = 50021;
-    private static final int EVENTLOG_SUPPLICANT_STATE_CHANGED = 50022;
-    private static final int EVENTLOG_DRIVER_STATE_CHANGED = 50023;
-    private static final int EVENTLOG_INTERFACE_CONFIGURATION_STATE_CHANGED = 50024;
-    private static final int EVENTLOG_SUPPLICANT_CONNECTION_STATE_CHANGED = 50025;
-
-    // Event codes
-    private static final int EVENT_SUPPLICANT_CONNECTION             = 1;
-    private static final int EVENT_SUPPLICANT_DISCONNECT             = 2;
-    private static final int EVENT_SUPPLICANT_STATE_CHANGED          = 3;
-    private static final int EVENT_NETWORK_STATE_CHANGED             = 4;
-    private static final int EVENT_SCAN_RESULTS_AVAILABLE            = 5;
-    private static final int EVENT_INTERFACE_CONFIGURATION_SUCCEEDED = 6;
-    private static final int EVENT_INTERFACE_CONFIGURATION_FAILED    = 7;
-    private static final int EVENT_POLL_INTERVAL                     = 8;
-    private static final int EVENT_DHCP_START                        = 9;
-    private static final int EVENT_DEFERRED_DISCONNECT               = 10;
-    private static final int EVENT_DEFERRED_RECONNECT                = 11;
-    /**
-     * The driver is started or stopped. The object will be the state: true for
-     * started, false for stopped.
-     */ 
-    private static final int EVENT_DRIVER_STATE_CHANGED              = 12;
-    private static final int EVENT_PASSWORD_KEY_MAY_BE_INCORRECT     = 13;
-
-    /**
-     * Interval in milliseconds between polling for connection
-     * status items that are not sent via asynchronous events.
-     * An example is RSSI (signal strength).
-     */
-    private static final int POLL_STATUS_INTERVAL_MSECS = 3000;
-
-    /**
-     * The max number of the WPA supplicant loop iterations before we
-     * decide that the loop should be terminated:
-     */
-    private static final int MAX_SUPPLICANT_LOOP_ITERATIONS = 4;
-
-    /**
-     * When a DISCONNECT event is received, we defer handling it to
-     * allow for the possibility that the DISCONNECT is about to
-     * be followed shortly by a CONNECT to the same network we were
-     * just connected to. In such a case, we don't want to report
-     * the network as down, nor do we want to reconfigure the network
-     * interface, etc. If we get a CONNECT event for another network
-     * within the delay window, we immediately handle the pending
-     * disconnect before processing the CONNECT.<p/>
-     * The five second delay is chosen somewhat arbitrarily, but is
-     * meant to cover most of the cases where a DISCONNECT/CONNECT
-     * happens to a network.
-     */
-    private static final int DISCONNECT_DELAY_MSECS = 5000;
-    /**
-     * When the supplicant goes idle after we do an explicit disconnect
-     * following a DHCP failure, we need to kick the supplicant into
-     * trying to associate with access points.
-     */
-    private static final int RECONNECT_DELAY_MSECS = 2000;
-
-    /**
-     * The maximum number of times we will retry a connection to an access point
-     * for which we have failed in acquiring an IP address from DHCP. A value of
-     * N means that we will make N+1 connection attempts in all.
-     * <p>
-     * See {@link Settings.Secure#WIFI_MAX_DHCP_RETRY_COUNT}. This is the default
-     * value if a Settings value is not present.
-     */
-    private static final int DEFAULT_MAX_DHCP_RETRIES = 2;
-
-    private static final int DRIVER_POWER_MODE_AUTO = 0;
-    private static final int DRIVER_POWER_MODE_ACTIVE = 1;
-
-    /**
-     * The current WPA supplicant loop state (used to detect looping behavior):
-     */
-    private SupplicantState mSupplicantLoopState = SupplicantState.DISCONNECTED;
-
-    /**
-     * The current number of WPA supplicant loop iterations:
-     */
-    private int mNumSupplicantLoopIterations = 0;
-
-    /**
-     * True if we received an event that that a password-key may be incorrect.
-     * If the next incoming supplicant state change event is DISCONNECT,
-     * broadcast a message that we have a possible password error and disable
-     * the network.
-     */
-    private boolean mPasswordKeyMayBeIncorrect = false;
-
-    public static final int SUPPL_SCAN_HANDLING_NORMAL = 1;
-    public static final int SUPPL_SCAN_HANDLING_LIST_ONLY = 2;
-
-    private WifiMonitor mWifiMonitor;
-    private WifiInfo mWifiInfo;
-    private List<ScanResult> mScanResults;
-    private WifiManager mWM;
-    private boolean mHaveIPAddress;
-    private boolean mObtainingIPAddress;
-    private boolean mTornDownByConnMgr;
-    /**
-     * A DISCONNECT event has been received, but processing it
-     * is being deferred.
-     */
-    private boolean mDisconnectPending;
-    /**
-     * An operation has been performed as a result of which we expect the next event
-     * will be a DISCONNECT.
-     */
-    private boolean mDisconnectExpected;
-    private DhcpHandler mDhcpTarget;
-    private DhcpInfo mDhcpInfo;
-    private int mLastSignalLevel = -1;
-    private String mLastBssid;
-    private String mLastSsid;
-    private int mLastNetworkId = -1;
-    private boolean mUseStaticIp = false;
-    private int mReconnectCount;
-
-    // Variables relating to the 'available networks' notification
-    
-    /**
-     * The icon to show in the 'available networks' notification. This will also
-     * be the ID of the Notification given to the NotificationManager.
-     */
-    private static final int ICON_NETWORKS_AVAILABLE =
-            com.android.internal.R.drawable.stat_notify_wifi_in_range;
-    /**
-     * When a notification is shown, we wait this amount before possibly showing it again.
-     */
-    private final long NOTIFICATION_REPEAT_DELAY_MS;
-    /**
-     * Whether the user has set the setting to show the 'available networks' notification.
-     */
-    private boolean mNotificationEnabled;
-    /**
-     * Observes the user setting to keep {@link #mNotificationEnabled} in sync.
-     */
-    private NotificationEnabledSettingObserver mNotificationEnabledSettingObserver;
-    /**
-     * The {@link System#currentTimeMillis()} must be at least this value for us
-     * to show the notification again.
-     */
-    private long mNotificationRepeatTime;
-    /**
-     * The Notification object given to the NotificationManager.
-     */
-    private Notification mNotification;
-    /**
-     * 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
-     * will still be true. We only guarantee if this is false, then the
-     * notification is not showing.
-     */
-    private boolean mNotificationShown;
-    /**
-     * The number of continuous scans that must occur before consider the
-     * supplicant in a scanning state. This allows supplicant to associate with
-     * remembered networks that are in the scan results.
-     */
-    private static final int NUM_SCANS_BEFORE_ACTUALLY_SCANNING = 3;
-    /**
-     * The number of scans since the last network state change. When this
-     * exceeds {@link #NUM_SCANS_BEFORE_ACTUALLY_SCANNING}, we consider the
-     * supplicant to actually be scanning. When the network state changes to
-     * something other than scanning, we reset this to 0.
-     */
-    private int mNumScansSinceNetworkStateChange;
-    /**
-     * Observes the static IP address settings.
-     */
-    private SettingsObserver mSettingsObserver;
-    
-    private boolean mIsScanModeActive;
-    private boolean mIsScanModeSetDueToAHiddenNetwork;
-
-    // Wi-Fi run states:
-    private static final int RUN_STATE_STARTING = 1;
-    private static final int RUN_STATE_RUNNING  = 2;
-    private static final int RUN_STATE_STOPPING = 3;
-    private static final int RUN_STATE_STOPPED  = 4;
-    private int mRunState;
-
-    private boolean mIsScanOnly;
-    
-    private String mInterfaceName;
-    private static String LS = System.getProperty("line.separator");
-
-    private Runnable mReleaseWakeLockCallback;
-
-    private static String[] sDnsPropNames;
-
-    /**
-     * A structure for supplying information about a supplicant state
-     * change in the STATE_CHANGE event message that comes from the
-     * WifiMonitor
-     * thread.
-     */
-    private static class SupplicantStateChangeResult {
-        SupplicantStateChangeResult(int networkId, SupplicantState state) {
-            this.state = state;
-            this.networkId = networkId;
-        }
-        int networkId;
-        SupplicantState state;
-    }
-
-    /**
-     * A structure for supplying information about a connection in
-     * the CONNECTED event message that comes from the WifiMonitor
-     * thread.
-     */
-    private static class NetworkStateChangeResult {
-        NetworkStateChangeResult(DetailedState state, String BSSID, int networkId) {
-            this.state = state;
-            this.BSSID = BSSID;
-            this.networkId = networkId;
-        }
-        DetailedState state;
-        String BSSID;
-        int networkId;
-    }
-
-    public WifiStateTracker(Context context, Handler target) {
-        super(context, target, ConnectivityManager.TYPE_WIFI, 0, "WIFI", "");
-        
-        mWifiInfo = new WifiInfo();
-        mWifiMonitor = new WifiMonitor(this);
-        mHaveIPAddress = false;
-        mObtainingIPAddress = false;
-        setTornDownByConnMgr(false);
-        mDisconnectPending = false;
-        mScanResults = new ArrayList<ScanResult>();
-        // Allocate DHCP info object once, and fill it in on each request
-        mDhcpInfo = new DhcpInfo();
-        mIsScanModeSetDueToAHiddenNetwork = false;
-        mRunState = RUN_STATE_STARTING;
-
-        // Setting is in seconds
-        NOTIFICATION_REPEAT_DELAY_MS = Settings.Secure.getInt(context.getContentResolver(), 
-                Settings.Secure.WIFI_NETWORKS_AVAILABLE_REPEAT_DELAY, 900) * 1000l;
-        mNotificationEnabledSettingObserver = new NotificationEnabledSettingObserver(new Handler());
-        mNotificationEnabledSettingObserver.register();
-
-        mSettingsObserver = new SettingsObserver(new Handler());
-
-        mInterfaceName = SystemProperties.get("wifi.interface", "tiwlan0");
-        sDnsPropNames = new String[] {
-            "dhcp." + mInterfaceName + ".dns1",
-            "dhcp." + mInterfaceName + ".dns2"
-        };
-    }
-
-    /**
-     * Helper method: sets the supplicant state and keeps the network
-     * info updated.
-     * @param state the new state
-     */
-    private void setSupplicantState(SupplicantState state) {
-        mWifiInfo.setSupplicantState(state);
-        updateNetworkInfo();
-    }
-
-    public SupplicantState getSupplicantState() {
-        return mWifiInfo.getSupplicantState();
-    }
-
-    /**
-     * Helper method: sets the supplicant state and keeps the network
-     * info updated (string version).
-     * @param stateName the string name of the new state
-     */
-    private void setSupplicantState(String stateName) {
-        mWifiInfo.setSupplicantState(stateName);
-        updateNetworkInfo();
-    }
-
-    /**
-     * Helper method: sets the boolean indicating that the connection
-     * manager asked the network to be torn down (and so only the connection
-     * manager can set it up again).
-     * network info updated.
-     * @param flag {@code true} if explicitly disabled.
-     */
-    private void setTornDownByConnMgr(boolean flag) {
-        mTornDownByConnMgr = flag;
-        updateNetworkInfo();
-    }
-
-    /**
-     * Return the IP addresses of the DNS servers available for the WLAN
-     * network interface.
-     * @return a list of DNS addresses, with no holes.
-     */
-    public String[] getNameServers() {
-        return getNameServerList(sDnsPropNames);
-    }
-
-    /**
-     * Return the system properties name associated with the tcp buffer sizes
-     * for this network.
-     */
-    public String getTcpBufferSizesPropName() {
-        return "net.tcp.buffersize.wifi";
-    }
-
-    public void startMonitoring() {
-        /*
-         * Get a handle on the WifiManager. This cannot be done in our
-         * constructor, because the Wifi service is not yet registered.
-         */
-        mWM = (WifiManager)mContext.getSystemService(Context.WIFI_SERVICE);
-    }
-
-    public void startEventLoop() {
-        mWifiMonitor.startMonitoring();
-    }
-
-    /**
-     * Wi-Fi is considered available as long as we have a connection to the
-     * supplicant daemon and there is at least one enabled network. If a teardown
-     * was explicitly requested, then Wi-Fi can be restarted with a reconnect
-     * request, so it is considered available. If the driver has been stopped
-     * for any reason other than a teardown request, Wi-Fi is considered
-     * unavailable.
-     * @return {@code true} if Wi-Fi connections are possible
-     */
-    public synchronized boolean isAvailable() {
-        /*
-         * TODO: Need to also look at scan results to see whether we're
-         * in range of any access points. If we have scan results that
-         * are no more than N seconds old, use those, otherwise, initiate
-         * a scan and wait for the results. This only matters if we
-         * allow mobile to be the preferred network.
-         */
-        SupplicantState suppState = mWifiInfo.getSupplicantState();
-        return suppState != SupplicantState.UNINITIALIZED &&
-                suppState != SupplicantState.INACTIVE &&
-                (mTornDownByConnMgr || !isDriverStopped());
-    }
-
-    /**
-     * {@inheritDoc}
-     * There are currently no defined Wi-Fi subtypes.
-     */
-    public int getNetworkSubtype() {
-        return 0;
-    }
-
-    /**
-     * Helper method: updates the network info object to keep it in sync with
-     * the Wi-Fi state tracker.
-     */
-    private void updateNetworkInfo() {
-        mNetworkInfo.setIsAvailable(isAvailable());
-    }
-
-    /**
-     * Report whether the Wi-Fi connection is fully configured for data.
-     * @return {@code true} if the {@link SupplicantState} is
-     * {@link android.net.wifi.SupplicantState#COMPLETED COMPLETED}.
-     */
-    public boolean isConnectionCompleted() {
-        return mWifiInfo.getSupplicantState() == SupplicantState.COMPLETED;
-    }
-
-    /**
-     * Send the tracker a notification that a user-entered password key
-     * may be incorrect (i.e., caused authentication to fail).
-     */
-    void notifyPasswordKeyMayBeIncorrect() {
-        sendEmptyMessage(EVENT_PASSWORD_KEY_MAY_BE_INCORRECT);
-    }
-
-    /**
-     * Send the tracker a notification that a connection to the supplicant
-     * daemon has been established.
-     */
-    void notifySupplicantConnection() {
-        sendEmptyMessage(EVENT_SUPPLICANT_CONNECTION);
-    }
-
-    /**
-     * Send the tracker a notification that the state of the supplicant
-     * has changed.
-     * @param networkId the configured network on which the state change occurred
-     * @param newState the new {@code SupplicantState}
-     */
-    void notifyStateChange(int networkId, SupplicantState newState) {
-        Message msg = Message.obtain(
-            this, EVENT_SUPPLICANT_STATE_CHANGED,
-            new SupplicantStateChangeResult(networkId, newState));
-        msg.sendToTarget();
-    }
-
-    /**
-     * Send the tracker a notification that the state of Wifi connectivity
-     * has changed.
-     * @param networkId the configured network on which the state change occurred
-     * @param newState the new network state
-     * @param BSSID when the new state is {@link DetailedState#CONNECTED
-     * NetworkInfo.DetailedState.CONNECTED},
-     * this is the MAC address of the access point. Otherwise, it
-     * is {@code null}.
-     */
-    void notifyStateChange(DetailedState newState, String BSSID, int networkId) {
-        Message msg = Message.obtain(
-            this, EVENT_NETWORK_STATE_CHANGED,
-            new NetworkStateChangeResult(newState, BSSID, networkId));
-        msg.sendToTarget();
-    }
-
-    /**
-     * Send the tracker a notification that a scan has completed, and results
-     * are available.
-     */
-    void notifyScanResultsAvailable() {
-        // reset the supplicant's handling of scan results to "normal" mode
-        synchronized (this) {
-            WifiNative.setScanResultHandlingCommand(SUPPL_SCAN_HANDLING_NORMAL);
-        }
-        sendEmptyMessage(EVENT_SCAN_RESULTS_AVAILABLE);
-    }
-
-    /**
-     * Send the tracker a notification that we can no longer communicate with
-     * the supplicant daemon.
-     */
-    void notifySupplicantLost() {
-        sendEmptyMessage(EVENT_SUPPLICANT_DISCONNECT);
-    }
-
-    /**
-     * Send the tracker a notification that the Wi-Fi driver has been stopped.
-     */
-    void notifyDriverStopped() {
-       mRunState = RUN_STATE_STOPPED;
-
-        // Send a driver stopped message to our handler
-        Message.obtain(this, EVENT_DRIVER_STATE_CHANGED, 0, 0).sendToTarget();
-    }
-
-    /**
-     * Send the tracker a notification that the Wi-Fi driver has been restarted after
-     * having been stopped.
-     */
-    void notifyDriverStarted() {
-        // Send a driver started message to our handler
-        Message.obtain(this, EVENT_DRIVER_STATE_CHANGED, 1, 0).sendToTarget();
-    }
-    
-    /**
-     * Set the interval timer for polling connection information
-     * that is not delivered asynchronously.
-     */
-    private synchronized void setPollTimer () {
-        if (!hasMessages(EVENT_POLL_INTERVAL)) {
-            sendEmptyMessageDelayed(EVENT_POLL_INTERVAL, POLL_STATUS_INTERVAL_MSECS);
-        }
-    }
-
-    private synchronized boolean isDriverStopped() {
-        return mRunState == RUN_STATE_STOPPED || mRunState == RUN_STATE_STOPPING;
-    }
-
-    /**
-     * Set the number of allowed radio frequency channels from the system
-     * setting value, if any.
-     * @return {@code true} if the operation succeeds, {@code false} otherwise, e.g.,
-     * the number of channels is invalid.
-     */
-    public boolean setNumAllowedChannels() {
-        try {
-            return setNumAllowedChannels(
-                    Settings.Secure.getInt(mContext.getContentResolver(),
-                                           Settings.Secure.WIFI_NUM_ALLOWED_CHANNELS));
-        } catch (Settings.SettingNotFoundException e) {
-            // if setting doesn't exist, stick with the driver default
-        }
-        return true;
-    }
-
-    /**
-     * Set the number of radio frequency channels that are allowed to be used
-     * in the current regulatory domain.
-     * @param numChannels the number of allowed channels. Must be greater than 0
-     * and less than or equal to 16.
-     * @return {@code true} if the operation succeeds, {@code false} otherwise, e.g.,
-     * {@code numChannels} is outside the valid range.
-     */
-    public synchronized boolean setNumAllowedChannels(int numChannels) {
-        return WifiNative.setNumAllowedChannelsCommand(numChannels);
-    }
-
-    /**
-     * Set the run state to either "normal" or "scan-only".
-     * @param scanOnlyMode true if the new mode should be scan-only.
-     */
-    public synchronized void setScanOnlyMode(boolean scanOnlyMode) {
-        // do nothing unless scan-only mode is changing
-        if (mIsScanOnly != scanOnlyMode) {
-            int scanType = (scanOnlyMode ?
-                    SUPPL_SCAN_HANDLING_LIST_ONLY : SUPPL_SCAN_HANDLING_NORMAL);
-            if (LOCAL_LOGD) Log.v(TAG, "Scan-only mode changing to " + scanOnlyMode + " scanType=" + scanType);
-            if (WifiNative.setScanResultHandlingCommand(scanType)) {
-                mIsScanOnly = scanOnlyMode;
-                if (!isDriverStopped()) {
-                    if (scanOnlyMode) {
-                        WifiNative.disconnectCommand();
-                    } else {
-                        WifiNative.reconnectCommand();
-                    }
-                }
-            }
-        }
-    }
-
-    @Override
-    public void releaseWakeLock() {
-        if (mReleaseWakeLockCallback != null) {
-            mReleaseWakeLockCallback.run();
-        }
-    }
-    
-    public void setReleaseWakeLockCallback(Runnable callback) {
-        mReleaseWakeLockCallback = callback;
-    }
-
-    /**
-     * Tracks the WPA supplicant states to detect "loop" situations.
-     * @param newSupplicantState The new WPA supplicant state.
-     * @return {@code true} if the supplicant loop should be stopped
-     * and {@code false} if it should continue.
-     */
-    private boolean isSupplicantLooping(SupplicantState newSupplicantState) {
-        if (SupplicantState.ASSOCIATING.ordinal() <= newSupplicantState.ordinal()
-            && newSupplicantState.ordinal() < SupplicantState.COMPLETED.ordinal()) {
-            if (mSupplicantLoopState != newSupplicantState) {
-                if (newSupplicantState.ordinal() < mSupplicantLoopState.ordinal()) {
-                    ++mNumSupplicantLoopIterations;
-                }
-
-                mSupplicantLoopState = newSupplicantState;
-            }
-        } else if (newSupplicantState == SupplicantState.COMPLETED) {
-            resetSupplicantLoopState();
-        }
-
-        return mNumSupplicantLoopIterations >= MAX_SUPPLICANT_LOOP_ITERATIONS;
-    }
-
-    /**
-     * Resets the WPA supplicant loop state.
-     */
-    private void resetSupplicantLoopState() {
-        mNumSupplicantLoopIterations = 0;
-    }
-
-    @Override
-    public void handleMessage(Message msg) {
-        Intent intent;
-
-        switch (msg.what) {
-            case EVENT_SUPPLICANT_CONNECTION:
-                mRunState = RUN_STATE_RUNNING;
-                checkUseStaticIp();
-                /*
-                 * DHCP requests are blocking, so run them in a separate thread.
-                 */
-                HandlerThread dhcpThread = new HandlerThread("DHCP Handler Thread");
-                dhcpThread.start();
-                mDhcpTarget = new DhcpHandler(dhcpThread.getLooper(), this);
-                mIsScanModeActive = true;
-                mTornDownByConnMgr = false;
-                mLastBssid = null;
-                mLastSsid = null;
-                requestConnectionInfo();
-                SupplicantState supplState = mWifiInfo.getSupplicantState();
-                /**
-                 * The MAC address isn't going to change, so just request it
-                 * once here.
-                 */
-                String macaddr;
-                synchronized (this) {
-                    macaddr = WifiNative.getMacAddressCommand();
-                }
-                if (macaddr != null) {
-                    mWifiInfo.setMacAddress(macaddr);
-                }
-                if (LOCAL_LOGD) Log.v(TAG, "Connection to supplicant established, state=" +
-                    supplState);
-                // Wi-Fi supplicant connection state changed:
-                // [31- 2] Reserved for future use
-                // [ 1- 0] Connected to supplicant (1), disconnected from supplicant (0) ,
-                //         or supplicant died (2)
-                EventLog.writeEvent(EVENTLOG_SUPPLICANT_CONNECTION_STATE_CHANGED, 1);
-                /*
-                 * The COMPLETED state change from the supplicant may have occurred
-                 * in between polling for supplicant availability, in which case
-                 * we didn't perform a DHCP request to get an IP address.
-                 */
-                if (supplState == SupplicantState.COMPLETED) {
-                    mLastBssid = mWifiInfo.getBSSID();
-                    mLastSsid = mWifiInfo.getSSID();
-                    configureInterface();
-                }
-                if (ActivityManagerNative.isSystemReady()) {
-                    intent = new Intent(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION);
-                    intent.putExtra(WifiManager.EXTRA_SUPPLICANT_CONNECTED, true);
-                    mContext.sendBroadcast(intent);
-                }
-                if (supplState == SupplicantState.COMPLETED && mHaveIPAddress) {
-                    setDetailedState(DetailedState.CONNECTED);
-                } else {
-                    setDetailedState(WifiInfo.getDetailedStateOf(supplState));
-                }
-                /*
-                 * Filter out multicast packets. This saves battery power, since
-                 * the CPU doesn't have to spend time processing packets that
-                 * are going to end up being thrown away. Obviously, if we
-                 * ever want to support multicast, this will have to change.
-                 */
-                synchronized (this) {
-                    WifiNative.startPacketFiltering();
-                }
-                break;
-
-            case EVENT_SUPPLICANT_DISCONNECT:
-                int wifiState = mWM.getWifiState();
-                boolean died = wifiState != WifiManager.WIFI_STATE_DISABLED &&
-                        wifiState != WifiManager.WIFI_STATE_DISABLING;
-                if (died) {
-                    if (LOCAL_LOGD) Log.v(TAG, "Supplicant died unexpectedly");
-                } else {
-                    if (LOCAL_LOGD) Log.v(TAG, "Connection to supplicant lost");
-                }
-                // Wi-Fi supplicant connection state changed:
-                // [31- 2] Reserved for future use
-                // [ 1- 0] Connected to supplicant (1), disconnected from supplicant (0) ,
-                //         or supplicant died (2)
-                EventLog.writeEvent(EVENTLOG_SUPPLICANT_CONNECTION_STATE_CHANGED, died ? 2 : 0);
-                synchronized (this) {
-                    WifiNative.closeSupplicantConnection();
-                }
-                if (died) {
-                    resetInterface();
-                }
-                // When supplicant dies, kill the DHCP thread
-                if (mDhcpTarget != null) {
-                    mDhcpTarget.getLooper().quit();
-                    mDhcpTarget = null;
-                }
-                mContext.removeStickyBroadcast(new Intent(WifiManager.NETWORK_STATE_CHANGED_ACTION));
-                if (ActivityManagerNative.isSystemReady()) {
-                    intent = new Intent(WifiManager.SUPPLICANT_CONNECTION_CHANGE_ACTION);
-                    intent.putExtra(WifiManager.EXTRA_SUPPLICANT_CONNECTED, false);
-                    mContext.sendBroadcast(intent);
-                }
-                setDetailedState(DetailedState.DISCONNECTED);
-                setSupplicantState(SupplicantState.UNINITIALIZED);
-                mHaveIPAddress = false;
-                mObtainingIPAddress = false;
-                if (died) {
-                    mWM.setWifiEnabled(false);
-                }
-                break;
-
-            case EVENT_SUPPLICANT_STATE_CHANGED:
-                SupplicantStateChangeResult supplicantStateResult =
-                    (SupplicantStateChangeResult) msg.obj;
-                SupplicantState newState = supplicantStateResult.state;
-                SupplicantState currentState = mWifiInfo.getSupplicantState();
-
-                // Wi-Fi supplicant state changed:
-                // [31- 6] Reserved for future use
-                // [ 5- 0] Supplicant state ordinal (as defined by SupplicantState)
-                int eventLogParam = (newState.ordinal() & 0x3f);
-                EventLog.writeEvent(EVENTLOG_SUPPLICANT_STATE_CHANGED, eventLogParam);
-
-                if (LOCAL_LOGD) Log.v(TAG, "Changing supplicant state: "
-                                      + currentState +
-                                      " ==> " + newState);
-
-                int networkId = supplicantStateResult.networkId;
-
-                /*
-                 * Did we get to DISCONNECTED state due to an
-                 * authentication (password) failure?
-                 */
-                boolean failedToAuthenticate = false;
-                if (newState == SupplicantState.DISCONNECTED) {
-                    failedToAuthenticate = mPasswordKeyMayBeIncorrect;
-                }
-                mPasswordKeyMayBeIncorrect = false;
-
-                /*
-                 * Keep track of the supplicant state and check if we should
-                 * disable the network
-                 */
-                boolean disabledNetwork = false;
-                if (isSupplicantLooping(newState)) {
-                    if (LOCAL_LOGD) {
-                        Log.v(TAG,
-                              "Stop WPA supplicant loop and disable network");
-                    }
-                    disabledNetwork = wifiManagerDisableNetwork(networkId);
-                }
-
-                if (disabledNetwork) {
-                    /*
-                     * Reset the loop state if we disabled the network
-                     */
-                    resetSupplicantLoopState();
-                } else if (newState != currentState ||
-                        (newState == SupplicantState.DISCONNECTED && isDriverStopped())) {
-                    setSupplicantState(newState);
-                    if (newState == SupplicantState.DORMANT) {
-                        DetailedState newDetailedState;
-                        if (mIsScanOnly || mRunState == RUN_STATE_STOPPING) {
-                            newDetailedState = DetailedState.IDLE;
-                        } else {
-                            newDetailedState = DetailedState.FAILED;
-                        }
-                        handleDisconnectedState(newDetailedState);
-                        if (mRunState == RUN_STATE_RUNNING && !mIsScanOnly) {
-                            sendEmptyMessageDelayed(EVENT_DEFERRED_RECONNECT, RECONNECT_DELAY_MSECS);
-                        } else if (mRunState == RUN_STATE_STOPPING) {
-                            synchronized (this) {
-                                WifiNative.stopDriverCommand();
-                            }
-                        } else if (mRunState == RUN_STATE_STARTING && !mIsScanOnly) {
-                            synchronized (this) {
-                                WifiNative.reconnectCommand();
-                            }
-                        }
-                    } else if (newState == SupplicantState.DISCONNECTED) {
-                        if (isDriverStopped() || mDisconnectExpected) {
-                            handleDisconnectedState(DetailedState.DISCONNECTED);
-                        } else {
-                            scheduleDisconnect();
-                        }
-                    } else if (newState != SupplicantState.COMPLETED && !mDisconnectPending) {
-                        /**
-                         * Ignore events that don't change the connectivity state,
-                         * such as WPA rekeying operations.
-                         */
-                        if (!(currentState == SupplicantState.COMPLETED &&
-                               (newState == SupplicantState.ASSOCIATING ||
-                                newState == SupplicantState.ASSOCIATED ||
-                                newState == SupplicantState.FOUR_WAY_HANDSHAKE ||
-                                newState == SupplicantState.GROUP_HANDSHAKE))) {
-                            setDetailedState(WifiInfo.getDetailedStateOf(newState));
-                        }
-                    }
-
-                    mDisconnectExpected = false;
-                    intent = new Intent(WifiManager.SUPPLICANT_STATE_CHANGED_ACTION);
-                    intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
-                    intent.putExtra(WifiManager.EXTRA_NEW_STATE, (Parcelable)newState);
-                    if (failedToAuthenticate) {
-                        if (LOCAL_LOGD) Log.d(TAG, "Failed to authenticate, disabling network " + networkId);
-                        wifiManagerDisableNetwork(networkId);
-                        intent.putExtra(
-                            WifiManager.EXTRA_SUPPLICANT_ERROR,
-                            WifiManager.ERROR_AUTHENTICATING);
-                    }
-                    mContext.sendStickyBroadcast(intent);
-                }
-                break;
-
-            case EVENT_NETWORK_STATE_CHANGED:
-                /*
-                 * Each CONNECT or DISCONNECT generates a pair of events.
-                 * One is a supplicant state change event, and the other
-                 * is a network state change event. For connects, the
-                 * supplicant event always arrives first, followed by
-                 * the network state change event. Only the latter event
-                 * has the BSSID, which we are interested in capturing.
-                 * For disconnects, the order is the opposite -- the
-                 * network state change event comes first, followed by
-                 * the supplicant state change event.
-                 */
-                NetworkStateChangeResult result =
-                    (NetworkStateChangeResult) msg.obj;
-
-                // Wi-Fi network state changed:
-                // [31- 6] Reserved for future use
-                // [ 5- 0] Detailed state ordinal (as defined by NetworkInfo.DetailedState)   
-                eventLogParam = (result.state.ordinal() & 0x3f);
-                EventLog.writeEvent(EVENTLOG_NETWORK_STATE_CHANGED, eventLogParam);
-                
-                if (LOCAL_LOGD) Log.v(TAG, "New network state is " + result.state);
-                /*
-                 * If we're in scan-only mode, don't advance the state machine, and
-                 * don't report the state change to clients.
-                 */
-                if (mIsScanOnly) {
-                    if (LOCAL_LOGD) Log.v(TAG, "Dropping event in scan-only mode");
-                    break;
-                }
-                if (result.state != DetailedState.SCANNING) {
-                    /*
-                     * Reset the scan count since there was a network state
-                     * change. This could be from supplicant trying to associate
-                     * with a network.
-                     */
-                    mNumScansSinceNetworkStateChange = 0;
-                }
-                /*
-                 * If the supplicant sent us a CONNECTED event, we don't
-                 * want to send out an indication of overall network
-                 * connectivity until we have our IP address. If the
-                 * supplicant sent us a DISCONNECTED event, we delay
-                 * sending a notification in case a reconnection to
-                 * the same access point occurs within a short time.
-                 */
-                if (result.state == DetailedState.DISCONNECTED) {
-                    if (mWifiInfo.getSupplicantState() != SupplicantState.DORMANT) {
-                        scheduleDisconnect();
-                    }
-                    break;
-                }
-                requestConnectionStatus(mWifiInfo);
-                if (!(result.state == DetailedState.CONNECTED &&
-                        (!mHaveIPAddress || mDisconnectPending))) {
-                    setDetailedState(result.state);
-                }
-
-                if (result.state == DetailedState.CONNECTED) {
-                    /*
-                     * Remove the 'available networks' notification when we
-                     * successfully connect to a network.
-                     */
-                    setNotificationVisible(false, 0, false, 0);
-                    boolean wasDisconnectPending = mDisconnectPending;
-                    cancelDisconnect();
-                    if (!TextUtils.equals(mWifiInfo.getSSID(), mLastSsid)) {
-                        /*
-                         * The connection is fully configured as far as link-level
-                         * connectivity is concerned, but we may still need to obtain
-                         * an IP address. But do this only if we are connecting to
-                         * a different network than we were connected to previously.
-                         */
-                        if (wasDisconnectPending) {
-                            DetailedState saveState = getNetworkInfo().getDetailedState();
-                            handleDisconnectedState(DetailedState.DISCONNECTED);
-                            setDetailedStateInternal(saveState);
-                        }
-                        configureInterface();
-                    }
-                    mLastBssid = result.BSSID;
-                    mLastSsid = mWifiInfo.getSSID();
-                    mLastNetworkId = result.networkId;
-                    if (mHaveIPAddress) {
-                        setDetailedState(DetailedState.CONNECTED);
-                    } else {
-                        setDetailedState(DetailedState.OBTAINING_IPADDR);
-                    }
-                }
-                sendNetworkStateChangeBroadcast(mWifiInfo.getBSSID());
-                break;
-
-            case EVENT_SCAN_RESULTS_AVAILABLE:
-                if (ActivityManagerNative.isSystemReady()) {
-                    mContext.sendBroadcast(new Intent(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION));
-                }
-                sendScanResultsAvailable();
-                /**
-                 * On receiving the first scan results after connecting to
-                 * the supplicant, switch scan mode over to passive.
-                 */
-                if (!mIsScanModeSetDueToAHiddenNetwork) {
-                    // This is the only place at the moment where we set
-                    // the scan mode NOT due to a hidden network. This is
-                    // what the second parameter value (false) stands for.
-                    setScanMode(false, false);
-                }
-                break;
-
-            case EVENT_POLL_INTERVAL:
-                if (mWifiInfo.getSupplicantState() != SupplicantState.UNINITIALIZED) {
-                    requestPolledInfo(mWifiInfo);
-                    if (mWifiInfo.getSupplicantState() == SupplicantState.COMPLETED) {
-                        setPollTimer();
-                    }
-                }
-                break;
-            
-            case EVENT_DEFERRED_DISCONNECT:
-                if (mWifiInfo.getSupplicantState() != SupplicantState.UNINITIALIZED) {
-                    handleDisconnectedState(DetailedState.DISCONNECTED);
-                }
-                break;
-
-            case EVENT_DEFERRED_RECONNECT:
-                /*
-                 * If we've exceeded the maximum number of retries for reconnecting
-                 * to a given network, disable the network so that the supplicant
-                 * will try some other network, if any is available.
-                 * TODO: network ID may have changed since we stored it.
-                 */
-                if (mWifiInfo.getSupplicantState() != SupplicantState.UNINITIALIZED) {
-                    if (++mReconnectCount > getMaxDhcpRetries()) {
-                        mWM.disableNetwork(mLastNetworkId);
-                    }
-                    synchronized(this) {
-                        WifiNative.reconnectCommand();
-                    }
-                }
-                break;
-
-            case EVENT_INTERFACE_CONFIGURATION_SUCCEEDED:
-                /**
-                 * Since this event is sent from another thread, it might have been
-                 * sent after we closed our connection to the supplicant in the course
-                 * of disabling Wi-Fi. In that case, we should just ignore the event.
-                 */
-                if (mWifiInfo.getSupplicantState() == SupplicantState.UNINITIALIZED) {
-                    break;
-                }
-                mReconnectCount = 0;
-                mHaveIPAddress = true;
-                mObtainingIPAddress = false;
-                mWifiInfo.setIpAddress(mDhcpInfo.ipAddress);
-                mLastSignalLevel = -1; // force update of signal strength
-                if (mNetworkInfo.getDetailedState() != DetailedState.CONNECTED) {
-                    setDetailedState(DetailedState.CONNECTED);
-                    sendNetworkStateChangeBroadcast(mWifiInfo.getBSSID());
-                } else {
-                    mTarget.sendEmptyMessage(EVENT_CONFIGURATION_CHANGED);
-                }
-                if (LOCAL_LOGD) Log.v(TAG, "IP configuration: " + mDhcpInfo);
-                // Wi-Fi interface configuration state changed:
-                // [31- 1] Reserved for future use
-                // [ 0- 0] Interface configuration succeeded (1) or failed (0)   
-                EventLog.writeEvent(EVENTLOG_INTERFACE_CONFIGURATION_STATE_CHANGED, 1);
-
-                // We've connected successfully, so allow the notification again in the future
-                resetNotificationTimer();
-                break;
-
-            case EVENT_INTERFACE_CONFIGURATION_FAILED:
-                if (mWifiInfo.getSupplicantState() != SupplicantState.UNINITIALIZED) {
-                    // Wi-Fi interface configuration state changed:
-                    // [31- 1] Reserved for future use
-                    // [ 0- 0] Interface configuration succeeded (1) or failed (0)
-                    EventLog.writeEvent(EVENTLOG_INTERFACE_CONFIGURATION_STATE_CHANGED, 0);
-                
-                    mHaveIPAddress = false;
-                    mWifiInfo.setIpAddress(0);
-                    mObtainingIPAddress = false;
-                    synchronized(this) {
-                        WifiNative.disconnectCommand();
-                    }
-                }
-                break;
-                
-            case EVENT_DRIVER_STATE_CHANGED:
-                boolean driverStarted = msg.arg1 != 0;
-                
-                // Wi-Fi driver state changed:
-                // [31- 1] Reserved for future use
-                // [ 0- 0] Driver start (1) or stopped (0)   
-                eventLogParam = driverStarted ? 1 : 0;
-                EventLog.writeEvent(EVENTLOG_DRIVER_STATE_CHANGED, eventLogParam);
-                
-                if (driverStarted) {
-                    /**
-                     * Set the number of allowed radio channels according
-                     * to the system setting, since it gets reset by the
-                     * driver upon changing to the STARTED state.
-                     */
-                    setNumAllowedChannels();
-                    synchronized (this) {
-                        if (mRunState == RUN_STATE_STARTING) {
-                            mRunState = RUN_STATE_RUNNING;
-                            if (!mIsScanOnly) {
-                                WifiNative.reconnectCommand();
-                            } else {
-                                // In some situations, supplicant needs to be kickstarted to
-                                // start the background scanning
-                                WifiNative.scanCommand();
-                            }
-                        }
-                    }
-                }
-                break;
-
-            case EVENT_PASSWORD_KEY_MAY_BE_INCORRECT:
-                mPasswordKeyMayBeIncorrect = true;
-                break;
-        }
-    }
-
-    private boolean wifiManagerDisableNetwork(int networkId) {
-        boolean disabledNetwork = false;
-        if (0 <= networkId) {
-            disabledNetwork = mWM.disableNetwork(networkId);
-            if (LOCAL_LOGD) {
-                if (disabledNetwork) {
-                    Log.v(TAG, "Disabled network: " + networkId);
-                }
-            }
-        }
-        if (LOCAL_LOGD) {
-            if (!disabledNetwork) {
-                Log.e(TAG, "Failed to disable network:" +
-                      " invalid network id: " + networkId);
-            }
-        }
-        return disabledNetwork;
-    }
-
-    public synchronized void setScanMode(
-        boolean isScanModeActive, boolean setDueToAHiddenNetwork) {
-        mIsScanModeSetDueToAHiddenNetwork = setDueToAHiddenNetwork;
-        if (mIsScanModeActive != isScanModeActive) {
-            WifiNative.setScanModeCommand(mIsScanModeActive = isScanModeActive);
-        }
-    }
-
-    private void configureInterface() {
-        setPollTimer();
-        mLastSignalLevel = -1;
-        if (!mUseStaticIp) {
-            if (!mHaveIPAddress && !mObtainingIPAddress) {
-                mObtainingIPAddress = true;
-                mDhcpTarget.sendEmptyMessage(EVENT_DHCP_START);
-            }
-        } else {
-            int event;
-            if (NetworkUtils.configureInterface(mInterfaceName, mDhcpInfo)) {
-                mHaveIPAddress = true;
-                event = EVENT_INTERFACE_CONFIGURATION_SUCCEEDED;
-                if (LOCAL_LOGD) Log.v(TAG, "Static IP configuration succeeded");
-            } else {
-                mHaveIPAddress = false;
-                event = EVENT_INTERFACE_CONFIGURATION_FAILED;
-                if (LOCAL_LOGD) Log.v(TAG, "Static IP configuration failed");
-            }
-            sendEmptyMessage(event);
-        }
-    }
-
-    /**
-     * Reset our IP state and send out broadcasts following a disconnect.
-     * @param newState the {@code DetailedState} to set. Should be either
-     * {@code DISCONNECTED} or {@code FAILED}.
-     */
-    private void handleDisconnectedState(DetailedState newState) {
-        if (LOCAL_LOGD) Log.d(TAG, "Deconfiguring interface and stopping DHCP");
-        if (mDisconnectPending) {
-            cancelDisconnect();
-        }
-        mDisconnectExpected = false;
-        resetInterface();
-        setDetailedState(newState);
-        sendNetworkStateChangeBroadcast(mLastBssid);
-        mWifiInfo.setBSSID(null);
-        mLastBssid = null;
-        mLastSsid = null;
-        mDisconnectPending = false;
-    }
-
-    /**
-     * Resets the Wi-Fi interface by clearing any state, resetting any sockets
-     * using the interface, stopping DHCP, and disabling the interface.
-     */
-    public void resetInterface() {
-        mHaveIPAddress = false;
-        mObtainingIPAddress = false;
-        mWifiInfo.setIpAddress(0);
-
-        /*
-         * Reset connection depends on both the interface and the IP assigned,
-         * so it should be done before any chance of the IP being lost.
-         */  
-        NetworkUtils.resetConnections(mInterfaceName);
-        
-        // Stop DHCP
-        if (mDhcpTarget != null) {
-            mDhcpTarget.setCancelCallback(true);
-            mDhcpTarget.removeMessages(EVENT_DHCP_START);
-        }
-        if (!NetworkUtils.stopDhcp(mInterfaceName)) {
-            Log.e(TAG, "Could not stop DHCP");
-        }
-        
-        NetworkUtils.disableInterface(mInterfaceName);
-    }
-
-    /**
-     * The supplicant is reporting that we are disconnected from the current
-     * access point. Often, however, a disconnect will be followed very shortly
-     * by a reconnect to the same access point. Therefore, we delay resetting
-     * the connection's IP state for a bit.
-     */
-    private void scheduleDisconnect() {
-        mDisconnectPending = true;
-        if (!hasMessages(EVENT_DEFERRED_DISCONNECT)) {
-            sendEmptyMessageDelayed(EVENT_DEFERRED_DISCONNECT, DISCONNECT_DELAY_MSECS);
-        }
-    }
-
-    private void cancelDisconnect() {
-        mDisconnectPending = false;
-        removeMessages(EVENT_DEFERRED_DISCONNECT);
-    }
-
-    public DhcpInfo getDhcpInfo() {
-        return mDhcpInfo;
-    }
-
-    public synchronized List<ScanResult> getScanResultsList() {
-        return mScanResults;
-    }
-
-    public synchronized void setScanResultsList(List<ScanResult> scanList) {
-        mScanResults = scanList;
-    }
-
-    /**
-     * Get status information for the current connection, if any.
-     * @return a {@link WifiInfo} object containing information about the current connection
-     */
-    public WifiInfo requestConnectionInfo() {
-        requestConnectionStatus(mWifiInfo);
-        requestPolledInfo(mWifiInfo);
-        return mWifiInfo;
-    }
-
-    private void requestConnectionStatus(WifiInfo info) {
-        String reply;
-        synchronized (this) {
-            reply = WifiNative.statusCommand();
-        }
-        if (reply == null) {
-            return;
-        }
-        /*
-         * Parse the reply from the supplicant to the status command, and update
-         * local state accordingly. The reply is a series of lines of the form
-         * "name=value".
-         */
-        String SSID = null;
-        String BSSID = null;
-        String suppState = null;
-        int netId = -1;
-        String[] lines = reply.split("\n");
-        for (String line : lines) {
-            String[] prop = line.split(" *= *");
-            if (prop.length < 2)
-                continue;
-            String name = prop[0];
-            String value = prop[1];
-            if (name.equalsIgnoreCase("id"))
-                netId = Integer.parseInt(value);
-            else if (name.equalsIgnoreCase("ssid"))
-                SSID = value;
-            else if (name.equalsIgnoreCase("bssid"))
-                BSSID = value;
-            else if (name.equalsIgnoreCase("wpa_state"))
-                suppState = value;
-        }
-        info.setNetworkId(netId);
-        info.setSSID(SSID);
-        info.setBSSID(BSSID);
-        /*
-         * We only set the supplicant state if the previous state was
-         * UNINITIALIZED. This should only happen when we first connect to
-         * the supplicant. Once we're connected, we should always receive
-         * an event upon any state change, but in this case, we want to
-         * make sure any listeners are made aware of the state change.
-         */
-        if (mWifiInfo.getSupplicantState() == SupplicantState.UNINITIALIZED && suppState != null)
-            setSupplicantState(suppState);
-    }
-
-    /**
-     * Get the dynamic information that is not reported via events.
-     * @param info the object into which the information should be captured.
-     */
-    private synchronized void requestPolledInfo(WifiInfo info)
-    {
-        int newRssi = WifiNative.getRssiCommand();
-        if (newRssi != -1 && -200 < newRssi && newRssi < 100) { // screen out invalid values
-            info.setRssi(newRssi);
-            /*
-             * Rather then sending the raw RSSI out every time it
-             * changes, we precalculate the signal level that would
-             * be displayed in the status bar, and only send the
-             * broadcast if that much more coarse-grained number
-             * changes. This cuts down greatly on the number of
-             * broadcasts, at the cost of not informing others
-             * interested in RSSI of all the changes in signal
-             * level.
-             */
-            // TODO: The second arg to the call below needs to be a symbol somewhere, but
-            // it's actually the size of an array of icons that's private
-            // to StatusBar Policy.
-            int newSignalLevel = WifiManager.calculateSignalLevel(newRssi, 4);
-            if (newSignalLevel != mLastSignalLevel) {
-                sendRssiChangeBroadcast(newRssi);
-            }
-            mLastSignalLevel = newSignalLevel;
-        } else {
-            info.setRssi(-200);
-        }
-        int newLinkSpeed = WifiNative.getLinkSpeedCommand();
-        if (newLinkSpeed != -1) {
-            info.setLinkSpeed(newLinkSpeed);
-        }
-    }
-
-    private void sendRssiChangeBroadcast(final int newRssi) {
-        if (ActivityManagerNative.isSystemReady()) {
-            Intent intent = new Intent(WifiManager.RSSI_CHANGED_ACTION);
-            intent.putExtra(WifiManager.EXTRA_NEW_RSSI, newRssi);
-            mContext.sendBroadcast(intent);
-        }
-    }
-
-    private void sendNetworkStateChangeBroadcast(String bssid) {
-        Intent intent = new Intent(WifiManager.NETWORK_STATE_CHANGED_ACTION);
-        intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT);
-        intent.putExtra(WifiManager.EXTRA_NETWORK_INFO, mNetworkInfo);
-        if (bssid != null)
-            intent.putExtra(WifiManager.EXTRA_BSSID, bssid);
-        mContext.sendStickyBroadcast(intent);
-    }
-
-    /**
-     * Disable Wi-Fi connectivity by stopping the driver.
-     */
-    public boolean teardown() {
-        if (!mTornDownByConnMgr) {
-            if (disconnectAndStop()) {
-                setTornDownByConnMgr(true);
-                return true;
-            } else {
-                return false;
-            }
-        } else {
-            return true;
-        }
-    }
-
-    /**
-     * Reenable Wi-Fi connectivity by restarting the driver.
-     */
-    public boolean reconnect() {
-        if (mTornDownByConnMgr) {
-            if (restart()) {
-                setTornDownByConnMgr(false);
-                return true;
-            } else {
-                return false;
-            }
-        } else {
-            return true;
-        }
-    }
-
-    public synchronized boolean disconnectAndStop() {
-        if (mRunState != RUN_STATE_STOPPING && mRunState != RUN_STATE_STOPPED) {
-            // Take down any open network notifications
-            setNotificationVisible(false, 0, false, 0);
-
-            mRunState = RUN_STATE_STOPPING;
-            return WifiNative.disconnectCommand();
-        } else {
-            /*
-             * The "driver-stop" wake lock normally is released from the
-             * connectivity manager after the mobile data connection has
-             * been established, or after a timeout period, if that never
-             * happens. Because WifiService.updateWifiState() can get called
-             * multiple times, we can end up acquiring the wake lock and calling
-             * disconnectAndStop() even when a disconnect or stop operation
-             * is already in progress. In that case, we want to ignore the
-             * disconnectAndStop request and release the (ref-counted) wake
-             * lock, so that eventually, when the mobile data connection is
-             * established, the ref count will drop to zero.
-             */
-            releaseWakeLock();
-        }
-        return true;
-    }
-
-    public synchronized boolean restart() {
-        if (mRunState == RUN_STATE_STOPPED) {
-            mRunState = RUN_STATE_STARTING;
-            return WifiNative.startDriverCommand();
-        } else if (mRunState == RUN_STATE_STOPPING) {
-            mRunState = RUN_STATE_STARTING;
-        }
-        return true;
-    }
-
-    public synchronized boolean removeNetwork(int networkId) {
-        return mDisconnectExpected = WifiNative.removeNetworkCommand(networkId);
-    }
-
-    public boolean setRadio(boolean turnOn) {
-        return mWM.setWifiEnabled(turnOn);
-    }
-
-    /**
-     * {@inheritDoc}
-     * There are currently no Wi-Fi-specific features supported.
-     * @param feature the name of the feature
-     * @return {@code -1} indicating failure, always
-     */
-    public int startUsingNetworkFeature(String feature, int callingPid, int callingUid) {
-        return -1;
-    }
-    
-    /**
-     * {@inheritDoc}
-     * There are currently no Wi-Fi-specific features supported.
-     * @param feature the name of the feature
-     * @return {@code -1} indicating failure, always
-     */
-    public int stopUsingNetworkFeature(String feature, int callingPid, int callingUid) {
-        return -1;
-    }
-
-    @Override
-    public void interpretScanResultsAvailable() {
-        
-        // If we shouldn't place a notification on available networks, then
-        // don't bother doing any of the following
-        if (!mNotificationEnabled) return;
-        
-        NetworkInfo networkInfo = getNetworkInfo();
-
-        State state = networkInfo.getState();
-        if ((state == NetworkInfo.State.DISCONNECTED)
-                || (state == NetworkInfo.State.UNKNOWN)) {
-
-            // Look for an open network
-            List<ScanResult> scanResults = getScanResultsList();
-            if (scanResults != null) {
-                int numOpenNetworks = 0;
-                for (int i = scanResults.size() - 1; i >= 0; i--) {
-                    ScanResult scanResult = scanResults.get(i);
-
-                    if (TextUtils.isEmpty(scanResult.capabilities)) {
-                        numOpenNetworks++;
-                    }
-                }
-            
-                if (numOpenNetworks > 0) {
-                    if (++mNumScansSinceNetworkStateChange >= NUM_SCANS_BEFORE_ACTUALLY_SCANNING) {
-                        /*
-                         * We've scanned continuously at least
-                         * NUM_SCANS_BEFORE_NOTIFICATION times. The user
-                         * probably does not have a remembered network in range,
-                         * since otherwise supplicant would have tried to
-                         * associate and thus resetting this counter.
-                         */
-                        setNotificationVisible(true, numOpenNetworks, false, 0);
-                    }
-                    return;
-                }
-            }
-        }
-        
-        // No open networks in range, remove the notification
-        setNotificationVisible(false, 0, false, 0);
-    }
-
-    /**
-     * Display or don't display a notification that there are open Wi-Fi networks.
-     * @param visible {@code true} if notification should be visible, {@code false} otherwise
-     * @param numNetworks the number networks seen
-     * @param force {@code true} to force notification to be shown/not-shown,
-     * even if it is already shown/not-shown.
-     * @param delay time in milliseconds after which the notification should be made
-     * visible or invisible.
-     */
-    public void setNotificationVisible(boolean visible, int numNetworks, boolean force, int delay) {
-        
-        // Since we use auto cancel on the notification, when the
-        // mNetworksAvailableNotificationShown is true, the notification may
-        // have actually been canceled.  However, when it is false we know
-        // for sure that it is not being shown (it will not be shown any other
-        // place than here)
-        
-        // If it should be hidden and it is already hidden, then noop
-        if (!visible && !mNotificationShown && !force) {
-            return;
-        }
-
-        Message message;
-        if (visible) {
-            
-            // Not enough time has passed to show the notification again
-            if (System.currentTimeMillis() < mNotificationRepeatTime) {
-                return;
-            }
-            
-            if (mNotification == null) {
-                // Cache the Notification mainly so we can remove the
-                // EVENT_NOTIFICATION_CHANGED message with this Notification from
-                // the queue later
-                mNotification = new Notification();
-                mNotification.when = 0;
-                mNotification.icon = ICON_NETWORKS_AVAILABLE;
-                mNotification.flags = Notification.FLAG_AUTO_CANCEL;
-                mNotification.contentIntent = PendingIntent.getActivity(mContext, 0,
-                        new Intent(WifiManager.ACTION_PICK_WIFI_NETWORK), 0);
-            }
-
-            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.setLatestEventInfo(mContext, title, details, mNotification.contentIntent);
-            
-            mNotificationRepeatTime = System.currentTimeMillis() + NOTIFICATION_REPEAT_DELAY_MS;
-
-            message = mTarget.obtainMessage(EVENT_NOTIFICATION_CHANGED, 1,
-                    ICON_NETWORKS_AVAILABLE, mNotification);
-            
-        } else {
-
-            // Remove any pending messages to show the notification
-            mTarget.removeMessages(EVENT_NOTIFICATION_CHANGED, mNotification);
-            
-            message = mTarget.obtainMessage(EVENT_NOTIFICATION_CHANGED, 0, ICON_NETWORKS_AVAILABLE);
-        }
-
-        mTarget.sendMessageDelayed(message, delay);
-        
-        mNotificationShown = visible;
-    }
-
-    /**
-     * Clears variables related to tracking whether a notification has been
-     * shown recently.
-     * <p>
-     * After calling this method, the timer that prevents notifications from
-     * being shown too often will be cleared.
-     */
-    private void resetNotificationTimer() {
-        mNotificationRepeatTime = 0;
-        mNumScansSinceNetworkStateChange = 0;
-    }
-    
-    public synchronized boolean addToBlacklist(String bssid) {
-        return WifiNative.addToBlacklistCommand(bssid);
-    }
-    
-    public synchronized boolean clearBlacklist() {
-        return WifiNative.clearBlacklistCommand();
-    }
-    
-    @Override
-    public String toString() {
-        StringBuffer sb = new StringBuffer();
-        sb.append("interface ").append(mInterfaceName).
-                append(" runState=").append(mRunState).append(LS);
-        sb.append(mWifiInfo).append(LS);
-        sb.append(mDhcpInfo).append(LS);
-        sb.append("haveIpAddress=").append(mHaveIPAddress).
-                append(", obtainingIpAddress=").append(mObtainingIPAddress).
-                append(", scanModeActive=").append(mIsScanModeActive).append(LS).
-                append("lastSignalLevel=").append(mLastSignalLevel).
-                append(", explicitlyDisabled=").append(mTornDownByConnMgr);
-        return sb.toString();
-    }
-
-    private class DhcpHandler extends Handler {
-
-        private Handler mTarget;
-        
-        /**
-         * Whether to skip the DHCP result callback to the target. For example,
-         * this could be set if the network we were requesting an IP for has
-         * since been disconnected.
-         * <p>
-         * Note: There is still a chance where the client's intended DHCP
-         * request not being canceled. For example, we are request for IP on
-         * A, and he queues request for IP on B, and then cancels the request on
-         * B while we're still requesting from A.
-         */
-        private boolean mCancelCallback;
-
-        /**
-         * Instance of the bluetooth headset helper. This needs to be created
-         * early because there is a delay before it actually 'connects', as
-         * noted by its javadoc. If we check before it is connected, it will be
-         * in an error state and we will not disable coexistence.
-         */
-        private BluetoothHeadset mBluetoothHeadset;
-        
-        public DhcpHandler(Looper looper, Handler target) {
-            super(looper);
-            mTarget = target;
-            
-            mBluetoothHeadset = new BluetoothHeadset(mContext, null);
-        }
-
-        public void handleMessage(Message msg) {
-            int event;
-
-            switch (msg.what) {
-                case EVENT_DHCP_START:
-                    
-                    boolean modifiedBluetoothCoexistenceMode = false;
-                    if (shouldDisableCoexistenceMode()) {
-                        /*
-                         * There are problems setting the Wi-Fi driver's power
-                         * mode to active when bluetooth coexistence mode is
-                         * enabled or sense.
-                         * <p>
-                         * We set Wi-Fi to active mode when
-                         * obtaining an IP address because we've found
-                         * compatibility issues with some routers with low power
-                         * mode.
-                         * <p>
-                         * In order for this active power mode to properly be set,
-                         * we disable coexistence mode until we're done with
-                         * obtaining an IP address.  One exception is if we
-                         * are currently connected to a headset, since disabling
-                         * coexistence would interrupt that connection.
-                         */
-                        modifiedBluetoothCoexistenceMode = true;
-
-                        // Disable the coexistence mode
-                        synchronized (WifiStateTracker.this) {
-                            WifiNative.setBluetoothCoexistenceModeCommand(
-                                    WifiNative.BLUETOOTH_COEXISTENCE_MODE_DISABLED);
-                        }
-                    }
-                    
-                    synchronized (WifiStateTracker.this) {
-                        WifiNative.setPowerModeCommand(DRIVER_POWER_MODE_ACTIVE);
-                    }
-                    synchronized (this) {
-                        // A new request is being made, so assume we will callback
-                        mCancelCallback = false;
-                    }
-                    Log.d(TAG, "DhcpHandler: DHCP request started");
-                    if (NetworkUtils.runDhcp(mInterfaceName, mDhcpInfo)) {
-                        event = EVENT_INTERFACE_CONFIGURATION_SUCCEEDED;
-                        if (LOCAL_LOGD) Log.v(TAG, "DhcpHandler: DHCP request succeeded");
-                    } else {
-                        event = EVENT_INTERFACE_CONFIGURATION_FAILED;
-                        Log.i(TAG, "DhcpHandler: DHCP request failed: " +
-                            NetworkUtils.getDhcpError());
-                    }
-                    synchronized (WifiStateTracker.this) {
-                        WifiNative.setPowerModeCommand(DRIVER_POWER_MODE_AUTO);
-                    }
-                    
-                    if (modifiedBluetoothCoexistenceMode) {
-                        // Set the coexistence mode back to its default value
-                        synchronized (WifiStateTracker.this) {
-                            WifiNative.setBluetoothCoexistenceModeCommand(
-                                    WifiNative.BLUETOOTH_COEXISTENCE_MODE_SENSE);
-                        }
-                    }
-                    
-                    synchronized (this) {
-                        if (!mCancelCallback) {
-                            mTarget.sendEmptyMessage(event);
-                        }
-                    }
-                    break;
-            }
-        }
-        
-        public synchronized void setCancelCallback(boolean cancelCallback) {
-            mCancelCallback = cancelCallback;
-        }
-
-        /**
-         * Whether to disable coexistence mode while obtaining IP address. This
-         * logic will return true only if the current bluetooth
-         * headset/handsfree state is disconnected. This means if it is in an
-         * error state, we will NOT disable coexistence mode to err on the side
-         * of safety.
-         * 
-         * @return Whether to disable coexistence mode.
-         */
-        private boolean shouldDisableCoexistenceMode() {
-            int state = mBluetoothHeadset.getState();
-            return state == BluetoothHeadset.STATE_DISCONNECTED;
-        }
-    }
-    
-    private void checkUseStaticIp() {
-        mUseStaticIp = false;
-        final ContentResolver cr = mContext.getContentResolver();
-        try {
-            if (Settings.System.getInt(cr, Settings.System.WIFI_USE_STATIC_IP) == 0) {
-                return;
-            }
-        } catch (Settings.SettingNotFoundException e) {
-            return;
-        }
-
-        try {
-            String addr = Settings.System.getString(cr, Settings.System.WIFI_STATIC_IP);
-            if (addr != null) {
-                mDhcpInfo.ipAddress = stringToIpAddr(addr);
-            } else {
-                return;
-            }
-            addr = Settings.System.getString(cr, Settings.System.WIFI_STATIC_GATEWAY);
-            if (addr != null) {
-                mDhcpInfo.gateway = stringToIpAddr(addr);
-            } else {
-                return;
-            }
-            addr = Settings.System.getString(cr, Settings.System.WIFI_STATIC_NETMASK);
-            if (addr != null) {
-                mDhcpInfo.netmask = stringToIpAddr(addr);
-            } else {
-                return;
-            }
-            addr = Settings.System.getString(cr, Settings.System.WIFI_STATIC_DNS1);
-            if (addr != null) {
-                mDhcpInfo.dns1 = stringToIpAddr(addr);
-            } else {
-                return;
-            }
-            addr = Settings.System.getString(cr, Settings.System.WIFI_STATIC_DNS2);
-            if (addr != null) {
-                mDhcpInfo.dns2 = stringToIpAddr(addr);
-            } else {
-                mDhcpInfo.dns2 = 0;
-            }
-        } catch (UnknownHostException e) {
-            return;
-        }
-        mUseStaticIp = true;
-    }
-
-    private static int stringToIpAddr(String addrString) throws UnknownHostException {
-        try {
-            String[] parts = addrString.split("\\.");
-            if (parts.length != 4) {
-                throw new UnknownHostException(addrString);
-            }
-
-            int a = Integer.parseInt(parts[0])      ;
-            int b = Integer.parseInt(parts[1]) <<  8;
-            int c = Integer.parseInt(parts[2]) << 16;
-            int d = Integer.parseInt(parts[3]) << 24;
-
-            return a | b | c | d;
-        } catch (NumberFormatException ex) {
-            throw new UnknownHostException(addrString);
-        }
-    }
-
-    private int getMaxDhcpRetries() {
-        return Settings.Secure.getInt(mContext.getContentResolver(),
-                                      Settings.Secure.WIFI_MAX_DHCP_RETRY_COUNT,
-                                      DEFAULT_MAX_DHCP_RETRIES);
-    }
-
-    private class SettingsObserver extends ContentObserver {
-        public SettingsObserver(Handler handler) {
-            super(handler);
-            ContentResolver cr = mContext.getContentResolver();
-            cr.registerContentObserver(Settings.System.getUriFor(
-                Settings.System.WIFI_USE_STATIC_IP), false, this);
-            cr.registerContentObserver(Settings.System.getUriFor(
-                Settings.System.WIFI_STATIC_IP), false, this);
-            cr.registerContentObserver(Settings.System.getUriFor(
-                Settings.System.WIFI_STATIC_GATEWAY), false, this);
-            cr.registerContentObserver(Settings.System.getUriFor(
-                Settings.System.WIFI_STATIC_NETMASK), false, this);
-            cr.registerContentObserver(Settings.System.getUriFor(
-                Settings.System.WIFI_STATIC_DNS1), false, this);
-            cr.registerContentObserver(Settings.System.getUriFor(
-                Settings.System.WIFI_STATIC_DNS2), false, this);
-        }
-
-        public void onChange(boolean selfChange) {
-            super.onChange(selfChange);
-
-            boolean wasStaticIp = mUseStaticIp;
-            int oIp, oGw, oMsk, oDns1, oDns2;
-            oIp = oGw = oMsk = oDns1 = oDns2 = 0;
-            if (wasStaticIp) {
-                oIp = mDhcpInfo.ipAddress;
-                oGw = mDhcpInfo.gateway;
-                oMsk = mDhcpInfo.netmask;
-                oDns1 = mDhcpInfo.dns1;
-                oDns2 = mDhcpInfo.dns2;
-            }
-            checkUseStaticIp();
-
-            if (mWifiInfo.getSupplicantState() == SupplicantState.UNINITIALIZED) {
-                return;
-            }
-
-            boolean changed =
-                (wasStaticIp != mUseStaticIp) ||
-                    (wasStaticIp && (
-                        oIp   != mDhcpInfo.ipAddress ||
-                        oGw   != mDhcpInfo.gateway ||
-                        oMsk  != mDhcpInfo.netmask ||
-                        oDns1 != mDhcpInfo.dns1 ||
-                        oDns2 != mDhcpInfo.dns2));
-
-            if (changed) {
-                resetInterface();
-                configureInterface();
-                if (mUseStaticIp) {
-                    mTarget.sendEmptyMessage(EVENT_CONFIGURATION_CHANGED);
-                }
-            }
-        }
-    }
-
-    private class NotificationEnabledSettingObserver extends ContentObserver {
-
-        public NotificationEnabledSettingObserver(Handler handler) {
-            super(handler);
-        }
-
-        public void register() {
-            ContentResolver cr = mContext.getContentResolver();
-            cr.registerContentObserver(Settings.Secure.getUriFor(
-                Settings.Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON), true, this);
-            mNotificationEnabled = getValue();
-        }
-
-        @Override
-        public void onChange(boolean selfChange) {
-            super.onChange(selfChange);
-
-            mNotificationEnabled = getValue();
-            if (!mNotificationEnabled) {
-                // Remove any notification that may be showing
-                setNotificationVisible(false, 0, true, 0);
-            }
-
-            resetNotificationTimer();
-        }
-
-        private boolean getValue() {
-            return Settings.Secure.getInt(mContext.getContentResolver(),
-                    Settings.Secure.WIFI_NETWORKS_AVAILABLE_NOTIFICATION_ON, 1) == 1;
-        }
-    }
-}
diff --git a/wifi/java/android/net/wifi/package.html b/wifi/java/android/net/wifi/package.html
deleted file mode 100644
index 530313d..0000000
--- a/wifi/java/android/net/wifi/package.html
+++ /dev/null
@@ -1,12 +0,0 @@
-<HTML>
-<BODY>
-Provides classes to manage Wi-Fi functionality on the device.
-<p>The Wi-Fi APIs provide a means by which applications can communicate 
-with the lower-level wireless stack that provides Wi-Fi network access. Almost all
-information from the device supplicant is available, including the connected network's
-link speed, IP address, negotiation state, and more, plus information about other
-networks that are available. Some other API features include the ability to
-scan, add, save, terminate and initiate Wi-Fi connections.</p>
-<p>Remember, not all Android devices are guaranteed to have Wi-Fi functionality.</p>
-</BODY>
-</HTML>