android开发 wifi开发工具类

package com.bihu.tcarspeakdevice.util;

import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.util.Iterator;
import java.util.List;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.DhcpInfo;
import android.net.NetworkInfo;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.util.Log;
public class CusWifiUtil {

//    private static CusWifiUtil mWifiUtils = null;
    private List<WifiConfiguration> mWifiConfiguration;
    private WifiInfo mWifiInfo;
    private DhcpInfo mDhcpInfo;
    private List<ScanResult> mWifiList;
    private WifiManager.WifiLock mWifiLock;
    public WifiManager mWifiManager;
    private NetworkInfo mNetworkInfo;

    private String TAG ="WifiUtils"; 
    private Context mContext;
    
    public CusWifiUtil(Context paramContext) {
        mContext = paramContext;
        mWifiManager = (WifiManager) paramContext.getSystemService(Context.WIFI_SERVICE);
        mDhcpInfo = mWifiManager.getDhcpInfo();
        mWifiInfo = mWifiManager.getConnectionInfo();
        mNetworkInfo = ((ConnectivityManager) paramContext.getSystemService(Context.CONNECTIVITY_SERVICE)).getNetworkInfo(ConnectivityManager.TYPE_WIFI);
    }

    public void setNewWifiManagerInfo() {
        mWifiInfo = mWifiManager.getConnectionInfo();
        mDhcpInfo = mWifiManager.getDhcpInfo();
    }

    private WifiConfiguration isExsits(String paramString) {
        Iterator<WifiConfiguration> localIterator = mWifiManager.getConfiguredNetworks().iterator();
        WifiConfiguration localWifiConfiguration;
        do {
            if (!localIterator.hasNext())
                return null;
            localWifiConfiguration = (WifiConfiguration) localIterator.next();
        }
        while (!localWifiConfiguration.SSID.equals("\"" + paramString + "\""));
        return localWifiConfiguration;
    }

    /**
     * 获取热点状态
     * 
     * @return boolean值，对应热点的开启(true)和关闭(false)
     */
    public boolean getWifiApState() {
        try {
            int i = ((Integer) mWifiManager.getClass().getMethod("getWifiApState", new Class[0])
                    .invoke(mWifiManager, new Object[0])).intValue();
            return (3 == i) || (13 == i);
        }
        catch (Exception localException) {
        }
        return false;
    }

    /**
     * 判断是否连接上wifi
     * 
     * @return boolean值(isConnect),对应已连接(true)和未连接(false)
     */
    public boolean isWifiConnect() {
        return mNetworkInfo.isConnected();
    }

    public void AcquireWifiLock() {
        mWifiLock.acquire();
    }

    public void CreatWifiLock() {
        mWifiLock = mWifiManager.createWifiLock("Test");
    }

    public void OpenWifi() {
        Log.v(TAG, "OpenWifi");
        if (!mWifiManager.isWifiEnabled())
            mWifiManager.setWifiEnabled(true);
    }

    public void ReleaseWifiLock() {
        if (mWifiLock.isHeld())
            mWifiLock.release();
    }

    public void closeWifi() {
        mWifiManager.setWifiEnabled(false);
    }

    public void connectConfiguration(int paramInt) {
        if (paramInt > mWifiConfiguration.size())
            return;
        mWifiManager.enableNetwork(
                ((WifiConfiguration) mWifiConfiguration.get(paramInt)).networkId, true);
    }

    public void removeNetwork(int netId) {
        if (mWifiManager != null) {
            mWifiManager.removeNetwork(netId);
        }
    }

    public void createWiFiAP(WifiConfiguration paramWifiConfiguration, boolean paramBoolean) {
        try {
            Class<? extends WifiManager> localClass = mWifiManager.getClass();
            Class[] arrayOfClass = new Class[2];
            arrayOfClass[0] = WifiConfiguration.class;
            arrayOfClass[1] = Boolean.TYPE;
            Method localMethod = localClass.getMethod("setWifiApEnabled", arrayOfClass);
            WifiManager localWifiManager = mWifiManager;
            Object[] arrayOfObject = new Object[2];
            arrayOfObject[0] = paramWifiConfiguration;
            arrayOfObject[1] = Boolean.valueOf(paramBoolean);
            localMethod.invoke(localWifiManager, arrayOfObject);
            return;
        }
        catch (Exception localException) {
        }
    }

    // 然后是一个实际应用方法，只验证过没有密码的情况：
//     public WifiConfiguration CreateWifiInfo(String SSID, String Password,int Type) {
//         WifiConfiguration config = new WifiConfiguration();
//         config.allowedAuthAlgorithms.clear();
//         config.allowedGroupCiphers.clear();
//         config.allowedKeyManagement.clear();
//         config.allowedPairwiseCiphers.clear();
//         config.allowedProtocols.clear();
////         config.SSID = "\"" + SSID + "\"";
//         config.SSID = SSID;
//
//         WifiConfiguration tempConfig = this.IsExsits(SSID);
//         if (tempConfig != null) {
//             mWifiManager.removeNetwork(tempConfig.networkId);
//         }
//
//         if (Type == 1) // WIFICIPHER_NOPASS
//         {
//             config.wepKeys[0] = "";
//             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
//             config.wepTxKeyIndex = 0;
//         }
//         if (Type == 2) // WIFICIPHER_WEP
//         {
//             config.hiddenSSID = true;
////             config.wepKeys[0] = "\"" + Password + "\"";
//             config.wepKeys[0] = Password;
//             config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
//             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
//             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
//             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
//             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
//             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
//             config.wepTxKeyIndex = 0;
//         }
//         if (Type == 3) // WIFICIPHER_WPA
//         {
////             config.preSharedKey = "\"" + Password + "\"";
//             config.preSharedKey =Password;
//             config.hiddenSSID = true;
//             config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
//             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
//             config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
//             config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
//             // config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
//             config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
//             config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
//             config.status = WifiConfiguration.Status.ENABLED;
//         }
//         return config;
//     }
    public WifiConfiguration CreateWifiInfo(String SSID, String Password,
            int Type) {
        WifiConfiguration config = new WifiConfiguration();
        config.allowedAuthAlgorithms.clear();
        config.allowedGroupCiphers.clear();
        config.allowedKeyManagement.clear();
        config.allowedPairwiseCiphers.clear();
        config.allowedProtocols.clear();
        config.SSID = "\"" + SSID + "\"";

        WifiConfiguration tempConfig = this.IsExsits(SSID);
        if (tempConfig != null) {
            mWifiManager.removeNetwork(tempConfig.networkId);
        }

        if (Type == 1) // WIFICIPHER_NOPASS
        {
            config.wepKeys[0] = "";
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            config.wepTxKeyIndex = 0;
        }
        if (Type == 2) // WIFICIPHER_WEP
        {
            config.hiddenSSID = true;
            config.wepKeys[0] = "\"" + Password + "\"";
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.SHARED);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP40);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.WEP104);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            config.wepTxKeyIndex = 0;
        }
        if (Type == 3) // WIFICIPHER_WPA
        {
            config.preSharedKey = "\"" + Password + "\"";
            config.hiddenSSID = true;
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            // config.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            config.status = WifiConfiguration.Status.ENABLED;
        }
        return config;
    }
    public void disconnectWifi(int paramInt) {
        mWifiManager.disableNetwork(paramInt);
    }

    public String getApSSID() {
        try {
            Method localMethod = mWifiManager.getClass().getDeclaredMethod(
                    "getWifiApConfiguration", new Class[0]);
            if (localMethod == null)
                return null;
            Object localObject1 = localMethod.invoke(mWifiManager, new Object[0]);
            if (localObject1 == null)
                return null;
            WifiConfiguration localWifiConfiguration = (WifiConfiguration) localObject1;
            if (localWifiConfiguration.SSID != null)
                return localWifiConfiguration.SSID;
            Field localField1 = WifiConfiguration.class.getDeclaredField("mWifiApProfile");
            if (localField1 == null)
                return null;
            localField1.setAccessible(true);
            Object localObject2 = localField1.get(localWifiConfiguration);
            localField1.setAccessible(false);
            if (localObject2 == null)
                return null;
            Field localField2 = localObject2.getClass().getDeclaredField("SSID");
            localField2.setAccessible(true);
            Object localObject3 = localField2.get(localObject2);
            if (localObject3 == null)
                return null;
            localField2.setAccessible(false);
            String str = (String) localObject3;
            return str;
        }
        catch (Exception localException) {
        }
        return null;
    }

    public String getBSSID() {
        if (mWifiInfo == null)
            return "NULL";
        return mWifiInfo.getBSSID();
    }

    public String getSSID() {
        if (mWifiInfo == null)
            return "NULL";
        return mWifiInfo.getSSID();
    }

    public List<WifiConfiguration> getConfiguration() {
        return mWifiConfiguration;
    }

    public String getLocalIPAddress() {
        if (mWifiInfo == null)
            return "NULL";
        return intToIp(mWifiInfo.getIpAddress());
    }

    public String getServerIPAddress() {
        if (mDhcpInfo == null)
            return "NULL";
        return intToIp(mDhcpInfo.serverAddress);
    }

    public String getMacAddress() {
        if (mWifiInfo == null)
            return "NULL";
        return mWifiInfo.getMacAddress();
    }

    public int getNetworkId() {
        if (mWifiInfo == null)
            return 0;
        return mWifiInfo.getNetworkId();
    }

    public int getWifiApStateInt() {
        try {
            int i = ((Integer) mWifiManager.getClass().getMethod("getWifiApState", new Class[0])
                    .invoke(mWifiManager, new Object[0])).intValue();
            return i;
        }
        catch (Exception localException) {
        }
        return 4;
    }

    public WifiInfo getWifiInfo() {
        return mWifiManager.getConnectionInfo();
    }

    public List<ScanResult> getWifiList() {
        return mWifiList;
    }

    public StringBuilder lookUpScan() {
        StringBuilder localStringBuilder = new StringBuilder();
        for (int i = 0;; i++) {
            if (i >= 2)
                return localStringBuilder;
            localStringBuilder.append("Index_" + Integer.valueOf(i + 1).toString() + ":");
            localStringBuilder.append(((ScanResult) mWifiList.get(i)).toString());
            localStringBuilder.append("/n");
        }
    }

    public void setWifiList() {
        mWifiList = mWifiManager.getScanResults();
    }

    public void startScan() {
        mWifiManager.startScan();
    }

    public String intToIp(int paramIntip) {
        return (paramIntip & 0xFF) + "." + ((paramIntip >> 8) & 0xFF) + "."
                + ((paramIntip >> 16) & 0xFF) + "." + ((paramIntip >> 24) & 0xFF);
    }
    /***********************************/
    // 打开WIFI
    public boolean openWifi() {
        if (!mWifiManager.isWifiEnabled()) {
            return mWifiManager.setWifiEnabled(true);
        }
        return true;
    }
    // 添加一个网络并连接
     public boolean addNetwork(WifiConfiguration wcg) {
         if (!this.openWifi()) {
             Log.v("addNetwork", "openWifi is false");
             return false;
         }
         mWifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
         // 开启wifi功能需要一段时间(我在手机上测试一般需要1-3秒左右)，所以要等到wifi
         // 状态变成WIFI_STATE_ENABLED的时候才能执行下面的语句
         while (mWifiManager.getWifiState() == WifiManager.WIFI_STATE_ENABLING) {
             try {
                 // 为了避免程序一直while循环，让它睡个200毫秒在检测……

                 Thread.currentThread();
                 Thread.sleep(200);
             } catch (InterruptedException ie) {
                 ie.printStackTrace();
             }
         }
         if (wcg == null) {
             Log.v("addNetwork", "wcg == null");
             return false;
         }
         
         WifiConfiguration tempConfig = this.IsExsits(wcg.SSID);

         if (tempConfig != null) {
             Log.v("addNetwork", "tempConfig != null");
             mWifiManager.removeNetwork(tempConfig.networkId);
         }

         int netID = mWifiManager.addNetwork(wcg);
         Log.v("addNetwork", "netID：" + netID+";ssid="+wcg.SSID+";pwd="+wcg.preSharedKey);
         boolean bRet = mWifiManager.enableNetwork(netID, true);
         boolean bConn = mWifiManager.reconnect();
         return bConn&bRet;
     }

    private WifiConfiguration IsExsits(String SSID) {
        List<WifiConfiguration> existingConfigs = mWifiManager
                .getConfiguredNetworks();
        if (existingConfigs == null)
            return null;
        for (WifiConfiguration existingConfig : existingConfigs) {
            if (existingConfig.SSID.equals("\"" + SSID + "\"")) {
                return existingConfig;
            }
        }
        return null;
    }
}