android WifiUtils

package com.utils.WifiConnect;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import android.content.Context;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.util.Log;

public class WifiConnect {
    private static final String TAG = "WifiConnect";
    private WifiManager wifiManager;
    private Context mContext;

    public enum WifiCipherType {
        WIFICIPHER_WEP, WIFICIPHER_WPA, WIFICIPHER_NOPASS, WIFICIPHER_INVALID
    }

    public boolean setWifi(Context context, boolean isEnable) {
        boolean wifiStatus = true;

        if (isEnable) {

            if (!wifiManager.isWifiEnabled()) {
                wifiStatus = wifiManager.setWifiEnabled(true);
            }
        } else {

            if (wifiManager.isWifiEnabled()) {
                wifiStatus = wifiManager.setWifiEnabled(false);
            }
        }
        return wifiStatus;
    }

    public WifiConnect(WifiManager wifiManager) {
        this.wifiManager = wifiManager;
    }

    public WifiConnect(Context mContext) {
        this.mContext = mContext;
        wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
    }

    private boolean openWifi() {
        boolean bRet = true;
        if (!wifiManager.isWifiEnabled()) {
            bRet = wifiManager.setWifiEnabled(true);
        }
        return bRet;
    }

    public boolean connect(String SSID, String Password, WifiCipherType Type) {
        if (!this.openWifi()) {
            return false;
        }
        while (wifiManager.getWifiState() == WifiManager.WIFI_STATE_ENABLING) {
            try {
                Thread.currentThread();
                Thread.sleep(100);
            } catch (InterruptedException ie) {
            }
        }        

      WifiConfiguration wifiConfig = this.createWifiInfo(SSID, Password, Type);
        Log.d(TAG, "wifiConfig:" + wifiConfig);
        if (wifiConfig == null) {
            return false;
        }

        int netID = wifiManager.addNetwork(wifiConfig);
        wifiManager.enableNetwork(netID, true);
        boolean bRet = wifiManager.reconnect();
        Log.d(TAG, "wifiConfig:bRet:" + bRet);
        return bRet;
    }

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

    public int getMaxPriority() {
        try {
            List<WifiConfiguration> localList = this.wifiManager.getConfiguredNetworks();
            int i = 0;
            Iterator<WifiConfiguration> localIterator = localList.iterator();
            while (true) {
                if (!localIterator.hasNext())
                    return i;
                WifiConfiguration localWifiConfiguration = (WifiConfiguration) localIterator.next();
                if (localWifiConfiguration.priority <= i)
                    continue;
                i = localWifiConfiguration.priority;
            }
        } catch (Exception e) {
            // TODO: handle exception
        }
        return 0;
    }

    private WifiConfiguration createWifiInfo(String SSID, String Password, WifiCipherType Type) {
        WifiConfiguration config = new WifiConfiguration();
        config.allowedAuthAlgorithms.clear();
        config.allowedGroupCiphers.clear();
        config.allowedKeyManagement.clear();
        config.allowedPairwiseCiphers.clear();
        config.allowedProtocols.clear();
        config.SSID = "\"" + SSID + "\"";

        try {
            WifiConfiguration tempConfig = this.isExsits(SSID);
            if (tempConfig != null) {
                wifiManager.removeNetwork(tempConfig.networkId);       
           }          
        } catch (Exception e) {

        }
        if (Type == WifiCipherType.WIFICIPHER_NOPASS) {
            Log.d(TAG, "WIFICIPHER_NOPASS");
            Log.d(TAG, "SSID:" + SSID);
            // config.wepKeys[0] = "";
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
            // config.wepTxKeyIndex = 0;
            config.status = WifiConfiguration.Status.ENABLED;
            config.priority = getMaxPriority() + 1;
        } else if (Type == WifiCipherType.WIFICIPHER_WEP) {
            config.preSharedKey = "\"" + Password + "\"";
            config.hiddenSSID = true;
            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;
            config.status = WifiConfiguration.Status.ENABLED;
            config.priority = getMaxPriority() + 1;
        } else if (Type == WifiCipherType.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;
            config.priority = getMaxPriority() + 1;
        } else {
            Log.d(TAG, "NO TYPE!!");
            return null;
        }
        Log.d(TAG, "return config" + config.toString());
        return config;
    }

    public String[] getSaveSSID() {
        List<String> list = new ArrayList<String>();
        for (WifiConfiguration config : wifiManager.getConfiguredNetworks()) {
            list.add(config.SSID);
            Log.i(TAG, "getSaveSSID:" + config.SSID);
        }
        int size = list.size();
        String[] arr = (String[]) list.toArray(new String[size]);
        return arr;
    }

    public List<Integer> getSaveNetWorkID() {

        try {
            List<Integer> list = new ArrayList<Integer>();
            for (WifiConfiguration config : wifiManager.getConfiguredNetworks()) {
                list.add(config.networkId);
                Log.i(TAG, "getSaveSSID:" + config.SSID);
            }
            int size = list.size();
            return list;
        } catch (Exception e) {
            Log.d(TAG, "getSaveNetWorkID:" + e);
        }
        return null;
    }

    /**
     * 搜索附近的热点信息，并返回所有热点为信息的SSID集合数据
     */
    public List<String> getScanWifiResult() {
        // 扫描的热点数据
        List<ScanResult> resultList;
        // 开始扫描热点
        wifiManager.startScan();
        Log.d(TAG, "isScanAlwaysAvailable:"+wifiManager.isScanAlwaysAvailable());      
        resultList = wifiManager.getScanResults();       
        ArrayList<String> ssids = new ArrayList<String>();
        if (resultList != null) {
            for (ScanResult scan : resultList) {
                ssids.add("SSID:" + scan.SSID + "  BSSID:" + scan.BSSID + "  level:" + scan.level);// 遍历数据，取得ssid数据集"capabilities"+scan.capabilities+
                Log.d(TAG, "SSID:" + scan.SSID + "  BSSID:" + scan.BSSID + "  level:" + scan.level);
            }
        }
        return ssids;
    }
}