自定义wifi管理类

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

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

/*
 * 自定义wifi管理类
 */
public class WiFiAdimin {



    public enum WifiCipherType {
        WIFICIPHER_WEP, WIFICIPHER_WPA, WIFICIPHER_NOPASS, WIFICIPHER_INVALID
    }
    public static final String Tag = "WiFiAdmin";
    // wifimanager对象
    private final WifiManager mWifiManager;
    // wifiInfo对象
    private WifiInfo mWifiInfo;
    // 扫描出的网络连接列表
    private List<ScanResult> mWifiList;
    private List nWifiList;
    // 网络连接列表
    private List<WifiConfiguration> mWifiConfigurations;
    private WifiManager.WifiLock mwifiLock;

    public WiFiAdimin(Context context) {
        // 取得wifimannager
        mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        // 取得wifiinfo
        mWifiInfo = mWifiManager.getConnectionInfo();
        mWifiList = new ArrayList<ScanResult>();
        mWifiConfigurations = new ArrayList<WifiConfiguration>();
    }

    /**
     * 接入某个wifi热点
     */
    public  boolean addNetWork(WifiConfiguration config) {
        WifiInfo wifiinfo = mWifiManager.getConnectionInfo();
        if (null != wifiinfo) {
            mWifiManager.disableNetwork(wifiinfo.getNetworkId());
        }
        boolean result = false;
        if (config.networkId > 0) {
            mWifiManager.updateNetwork(config);
            result = mWifiManager.enableNetwork(config.networkId, true);
        } else {
            int i = mWifiManager.addNetwork(config);
            result = false;
            if (i > 0) {
                mWifiManager.saveConfiguration();
                return mWifiManager.enableNetwork(i, true);
            }
        }
        return result;
    }
    // 添加一个网络并连接
    public int AddNetworka(WifiConfiguration configuration) {
        int configurationId = mWifiManager.addNetwork(configuration);
        boolean b = mWifiManager.enableNetwork(configurationId, true);

        return configurationId;
    }
    // 打开WIFI
    public void OpenWifi() {
        if (!mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(true);
        }
    }

    public List<WifiConfiguration> getConfiguredNetworks() {
      return    mWifiManager.getConfiguredNetworks();
    }
    // 关闭WIFI
    public void CloseWifi() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(false);
        }
    }

    // 得到WIFI当前状态
    public int GetWifiState() {
        return mWifiManager.getWifiState();
    }

    // 锁定wifilock
    public void AcquireWifiLock() {
        mwifiLock.acquire();
    }

    // 释放wifilock
    public void RelaseWifiLock() {
        if (mwifiLock.isHeld()) {
            mwifiLock.release();
        }
    }

    // 创建一个wifilock
    public void CreatWifilock() {
        mwifiLock = mWifiManager.createWifiLock("WIFILOCK");
    }

    // 得到配置好的网络
    public List<WifiConfiguration> getConfigurations() {
        // 得到配置好的网络连接
        return mWifiConfigurations;
    }

    // 指定配置好的网络进行连接
    public void ConnectConfiguration(int index) {
        // 输入的索引大于配置的索引则返回
        if (index > mWifiConfigurations.size()) {
            return;
        }
        // 连接到指定的网络
        mWifiManager.enableNetwork(mWifiConfigurations.get(index).networkId,
                true);
    }

    public    List<ScanResult> StartScan() {
        mWifiManager.startScan();
        // 得到扫描结果
        mWifiList = mWifiManager.getScanResults();
        Log.e(Tag, "mWifiList" + mWifiList);
        //删除mWifiList中的重复元素
        for (int i = 0; i < mWifiList.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (mWifiList.get(i).SSID.equals(mWifiList.get(j).SSID)) {
                    mWifiList.remove(i);
                    i = i - 1;
                    break;
                }
            }
        }

        // 得到配置好的网络连接
        mWifiConfigurations = mWifiManager.getConfiguredNetworks();
        Log.v("mWifiManager", mWifiManager + "");
        Log.v("mWifiList", mWifiList + "");
        Log.v("mWifiConfigurations", mWifiConfigurations + "");
        return mWifiList;
    }

    public WifiInfo  getWifiConnectInfo() {
        mWifiInfo = mWifiManager.getConnectionInfo();
        return  mWifiInfo;
    }

    // 得到网络列表
    public List<ScanResult> GetWifilist() {
        return mWifiList;
    }

    // 查看扫描结果
    public StringBuilder CheckupScan() {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < mWifiList.size(); i++) {
            stringBuilder
                    .append("Index_" + (i + 1) + ":");
            // 将Scanresult转换成一个字符串包
            // 其中包括:BSSID SSID capabilities frequency level
            stringBuilder.append(mWifiList.get(i).toString());
            stringBuilder.append("/n");
        }
        return stringBuilder;
    }

    // 得到MAC地址
    public String GetMacAdress() {
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getMacAddress();
    }

    //得到SSID
    public String GetSSID() {
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getSSID();
    }

    // 得到接入点的BSSID
    public String GetBSSID() {
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
    }

    // 得到ip地址
    public int GetIpAdress() {
        return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
    }

    // 得打连接的ID
    public int GetNetworkID() {
        return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
    }

    // 得到wifiinfo的所有信息包
    public String GetWifiinfo() {
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.toString();
    }



    // 断开指定ID的网络，忘记网络密码
    public void disconnectWifi(WifiConfiguration wifiConfiguration) {
        if(wifiConfiguration!=null){
            mWifiManager.disableNetwork(wifiConfiguration.networkId);
            mWifiManager.disconnect();
            removeNetwork(wifiConfiguration);
        }

    }
    public void removeNetwork(WifiConfiguration wifiConfiguration) {
        if(wifiConfiguration!=null){
            mWifiManager.removeNetwork(wifiConfiguration.networkId);
            mWifiManager.saveConfiguration();
        }
    }


    public WifiConfiguration CreatConfiguration(String ssid, String password, int type) {
        WifiConfiguration configuration = new WifiConfiguration();
        configuration.allowedAuthAlgorithms.clear();
        configuration.allowedGroupCiphers.clear();
        configuration.allowedKeyManagement.clear();
        configuration.allowedPairwiseCiphers.clear();
        configuration.allowedProtocols.clear();
        configuration.SSID = "\"" + ssid + "\"";
        WifiConfiguration tempConfiguration = IsExits(ssid, mWifiManager);
        if (tempConfiguration != null) {
            mWifiManager.removeNetwork(tempConfiguration.networkId);
        }
        // WIFICIPHER_NOPASS
        if (type == 1) {
            configuration.wepKeys[0] = "";
            configuration.allowedKeyManagement
                    .set(WifiConfiguration.KeyMgmt.NONE);
            configuration.wepTxKeyIndex = 0;
        }
        // WIFICIPHER_WEP
        if (type == 2) {
            configuration.hiddenSSID = true;
            configuration.wepKeys[0] = "\"" + password + "\"";
            configuration.allowedAuthAlgorithms
                    .set(WifiConfiguration.AuthAlgorithm.SHARED);
            configuration.allowedGroupCiphers
                    .set(WifiConfiguration.GroupCipher.CCMP);
            configuration.allowedGroupCiphers
                    .set(WifiConfiguration.GroupCipher.TKIP);
            configuration.allowedGroupCiphers
                    .set(WifiConfiguration.GroupCipher.WEP40);
            configuration.allowedGroupCiphers
                    .set(WifiConfiguration.GroupCipher.WEP104);
            configuration.allowedKeyManagement
                    .set(WifiConfiguration.KeyMgmt.NONE);
            configuration.wepTxKeyIndex = 0;
        }
        // WIFICIPHER_WPA
        if (type == 3) {
            configuration.preSharedKey = "\"" + password + "\"";
            configuration.hiddenSSID = true;
            configuration.allowedAuthAlgorithms

                    .set(WifiConfiguration.AuthAlgorithm.OPEN);
            configuration.allowedGroupCiphers
                    .set(WifiConfiguration.GroupCipher.TKIP);
            configuration.allowedKeyManagement
                    .set(WifiConfiguration.KeyMgmt.WPA_PSK);
            configuration.allowedPairwiseCiphers
                    .set(WifiConfiguration.PairwiseCipher.TKIP);
            configuration.allowedGroupCiphers
                    .set(WifiConfiguration.GroupCipher.CCMP);
            configuration.allowedPairwiseCiphers
                    .set(WifiConfiguration.PairwiseCipher.CCMP);
            configuration.status = WifiConfiguration.Status.ENABLED;
        }
        return configuration;
    }

    //判断wifi是否存在
    public static WifiConfiguration IsExits(String ssid, WifiManager manager) {
        List<WifiConfiguration> exitsConfigurations = manager.getConfiguredNetworks();
        for (WifiConfiguration configuration : exitsConfigurations) {
            if (configuration.SSID.equals("\"" + ssid + "\"")) {
                return configuration;
            }
        }
        return null;
    }

    public WifiManager getWifiManager() {
        return mWifiManager;
    }

    public boolean isWifiEnable() {
        return mWifiManager.isWifiEnabled();
    }
//转换IP地址

    public String GetIntIp() {
        int i = GetIpAdress();
        if (i == 0) {
            return "";
        }
        return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "." + ((i >> 16) & 0xFF)
                + "." + ((i >> 24) & 0xFF);
    }
    /**
     * 判断wifi热点支持的加密方式
     */
    public static WifiCipherType getWifiCipher(String s) {

        if (s.isEmpty()) {
            return WifiCipherType.WIFICIPHER_INVALID;
        } else if (s.contains("WEP")) {
            return WifiCipherType.WIFICIPHER_WEP;
        } else if (s.contains("WPA") || s.contains("WPA2") || s.contains("WPS")) {
            return WifiCipherType.WIFICIPHER_WPA;
        } else {
            return WifiCipherType.WIFICIPHER_NOPASS;
        }
    }
    //加密方式
    public String getSecurity(WifiConfiguration config) {
        if (config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_PSK)) {
            return "WPA-PSK/WPA2-PSK";
        }
        if (config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.WPA_EAP) || config.allowedKeyManagement.get(WifiConfiguration.KeyMgmt.IEEE8021X)) {
            return "WPA/WPA2";
        }
        return (config.wepKeys[0] != null) ? "WEP" : "NONE";
    }

    //查看以前是否也配置过这个网络
    public  WifiConfiguration isExsits(String SSID) {

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

    public static WifiConfiguration createWifiConfig(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 + "\"";

        if (type == WifiCipherType.WIFICIPHER_NOPASS) {
//            config.wepKeys[0] = "";  //注意这里
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
//            config.wepTxKeyIndex = 0;
        }

        if (type == WifiCipherType.WIFICIPHER_WEP) {
            config.preSharedKey = "\"" + password + "\"";
            config.hiddenSSID = true;
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            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 == WifiCipherType.WIFICIPHER_WPA) {
            config.preSharedKey = "\"" + password + "\"";
            config.hiddenSSID = true;
            config.allowedAuthAlgorithms.set(WifiConfiguration.AuthAlgorithm.OPEN);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.TKIP);
            config.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.WPA_PSK);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.TKIP);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            config.status = WifiConfiguration.Status.ENABLED;

        }

        return config;

    }
}