auto import from //depot/cupcake/@135843

1 files changed, 281 insertions, 0 deletions

diff --git a/wifi/java/android/net/wifi/WifiInfo.java b/wifi/java/android/net/wifi/WifiInfo.java
new file mode 100644
index 0000000..4312bfd
--- /dev/null
+++ b/wifi/java/android/net/wifi/WifiInfo.java
@@ -0,0 +1,281 @@
+/*
+ * 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];
+            }
+        };
+}