常用wifi功能集合工具类

import java.io.IOException;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.List;
import java.util.Random;

import org.apache.http.conn.util.InetAddressUtils;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.DhcpInfo;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;

import com.clly.filemaster.conf.Constants;

/**
 * @创建者 CSDN_LQR
 * @创建时间 2016-3-21 下午8:23:43
 * @描述 wifi及热点工具类
 */
public class WifiUtils {

    private static WifiUtils mWifiUtils;
    private WifiManager mWifiManager;
    private Context context;
    private WifiApStateListener mWifiApStateListener;
    private WifiStateListener mWifiStateListener;

    // 热点监听的回调接口的Setter方法
    public void setWifiApStateListener(WifiApStateListener wifiApStateListener) {
        mWifiApStateListener = wifiApStateListener;
    }

    // wifi监听的回调接口的Setter方法
    public void setWifiStateListener(WifiStateListener wifiStateListener) {
        mWifiStateListener = wifiStateListener;
    }

    // app标记，用于设置ap的名字头
    private static final String APPTAG = Constants.APPNAME;
    // wifi热点状态的意图广播
    private static final String WIFI_AP_STATE = "android.net.wifi.WIFI_AP_STATE_CHANGED";
    // 意图中的一个传值
    private static final String WIFI_STATE = "wifi_state";

    // 热点名字和密码的标记
    public static final String SSID = "SSID";
    public static final String PASSWORD = "PASSWORD";

    // 热点的名字和密码
    private String mySSID = "";
    private String myPassword = "";

    private WifiApStateReceiver mWifiApStateReceiver;
    private WifiStateReceiver mWifiStateReceiver;

    private WifiUtils(Context context) {
        super();
        this.context = context;
        // 在构造方法中实例化WifiManager
        mWifiManager = (WifiManager) context
                .getSystemService(Context.WIFI_SERVICE);

        // 设置默认的热点ssid和passwrod
        // mySSID = APPTAG + getRandomPassword();
        // myPassword = getRandomPassword();
        mySSID = APPTAG + "12345678";
        myPassword = "12345678";
    }

    /**
     * 单例模式得到wifiUtils对象
     * 
     * @param context
     * @return
     */
    public static WifiUtils getInstace(Context context) {
        if (mWifiUtils == null) {
            synchronized (WifiUtils.class) {
                if (mWifiUtils == null) {
                    mWifiUtils = new WifiUtils(context);
                }
            }
        }
        return mWifiUtils;
    }

    /* ============================ wifi热点方法begin ============================ */

    /**
     * 设置热点
     * 
     * @param SSID
     *            热点的名字
     * @param PASSWORD
     *            热点的密码
     */
    public void setWifiAPInfo(String SSID, String PASSWORD) {
        this.mySSID = SSID;
        this.myPassword = PASSWORD;
    }

    /**
     * 返回热点的ssid和password
     * 
     * @return
     */
    public HashMap<String, String> getWifiAPInfo() {
        HashMap<String, String> hashMap = new HashMap<String, String>();
        hashMap.put(SSID, mySSID);
        hashMap.put(PASSWORD, myPassword);
        return hashMap;
    }

    /**
     * wifi热点开关
     * 
     * @param enabled
     *            是否可用
     * @return
     */
    public boolean setWifiApEnabled(boolean enabled) {
        if (enabled) {
            // wifi和热点不能同时打开，所以打开热点的时候需要关闭wifi
            setWifiEnabled(false);
            // 一关闭wifi就关闭广播监听
            if (mWifiStateReceiver != null) {
                context.unregisterReceiver(mWifiStateReceiver);
                mWifiStateReceiver = null;
            }

            // 开启wifi热点时就开启广播监听，监听热点的状态
            IntentFilter filter = new IntentFilter();
            filter.addAction(WIFI_AP_STATE);
            mWifiApStateReceiver = new WifiApStateReceiver();
            context.registerReceiver(mWifiApStateReceiver, filter);

        } else {
            // 一关闭wifi热点就关闭广播监听
            if (mWifiApStateReceiver != null) {
                context.unregisterReceiver(mWifiApStateReceiver);
                mWifiApStateReceiver = null;
            }
        }

        try {

            // 热点的配置类
            WifiConfiguration apConfig = new WifiConfiguration();
            // 配置热点的名称
            apConfig.SSID = mySSID;
            // 配置热点的密码
            apConfig.preSharedKey = myPassword;

            // 一些热点的详细配置
            apConfig.allowedAuthAlgorithms
                    .set(WifiConfiguration.AuthAlgorithm.OPEN);
            apConfig.allowedProtocols.set(WifiConfiguration.Protocol.RSN);
            apConfig.allowedProtocols.set(WifiConfiguration.Protocol.WPA);
            apConfig.allowedKeyManagement
                    .set(WifiConfiguration.KeyMgmt.WPA_PSK);
            apConfig.allowedPairwiseCiphers
                    .set(WifiConfiguration.PairwiseCipher.CCMP);
            apConfig.allowedPairwiseCiphers
                    .set(WifiConfiguration.PairwiseCipher.TKIP);
            apConfig.allowedGroupCiphers
                    .set(WifiConfiguration.GroupCipher.CCMP);
            apConfig.allowedGroupCiphers
                    .set(WifiConfiguration.GroupCipher.TKIP);
            // 通过反射调用设置热点
            Method method = mWifiManager.getClass().getMethod(
                    "setWifiApEnabled", WifiConfiguration.class, Boolean.TYPE);
            // 返回热点打开状态
            return (Boolean) method.invoke(mWifiManager, apConfig, enabled);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /* ============================ wifi热点方法end ============================ */
    /**
     * 获得本机的ip地址
     */
    public String getServerIp() {
        DhcpInfo info = mWifiManager.getDhcpInfo();
        String ip = intToIp(info.serverAddress);
        return ip;
    }

    public String getIp() {
        String ipaddress = "";
        try {
            Enumeration<NetworkInterface> en = NetworkInterface
                    .getNetworkInterfaces();
            while (en.hasMoreElements()) {
                NetworkInterface nif = en.nextElement();
                Enumeration<InetAddress> inet = nif.getInetAddresses();
                while (inet.hasMoreElements()) {
                    InetAddress ip = inet.nextElement();
                    if (!ip.isLoopbackAddress()
                            && InetAddressUtils.isIPv4Address(ip
                                    .getHostAddress())) {
                        return ipaddress = ip.getHostAddress();
                    }
                }
            }
        } catch (SocketException e) {
            e.printStackTrace();
        }
        return ipaddress;
    }

    /**
     * 把int形式的ip地址转换劢string形式
     * 
     * @param i
     * @return
     */
    private String intToIp(int i) {

        return (i & 0xFF) + "." + ((i >> 8) & 0xFF) + "." + ((i >> 16) & 0xFF)
                + "." + (i >> 24 & 0xFF);
    }

    /**
     * 得到一连串的10位数字，用于生成随机密码
     * 
     * @return
     */
    private String getRandomPassword() {
        String result = "";
        Random random = new Random();
        for (int i = 0; i < 10; i++) {
            result += random.nextInt(10) + "";
        }
        return result;
    }

    /**
     * 热点的广播接收者
     * 
     * @author Administrator
     * 
     */
    class WifiApStateReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {

            if (WIFI_AP_STATE.equals(intent.getAction())) {
                // 便携式热点的状态为：10---正在关闭；11---已关闭；12---正在开启；13---已开启
                int state = intent.getIntExtra(WIFI_STATE, 0);
                switch (state) {
                case 10:
                    if (mWifiApStateListener != null)
                        mWifiApStateListener.onClosing();
                    break;
                case 11:
                    if (mWifiApStateListener != null)
                        mWifiApStateListener.onClosed();
                    break;
                case 12:
                    if (mWifiApStateListener != null)
                        mWifiApStateListener.onStarting();
                    break;
                case 13:
                    if (mWifiApStateListener != null)
                        mWifiApStateListener.onStarted();
                    break;

                default:
                    break;
                }
            }
        }
    }

    /**
     * wifi热点状态监听接口
     * 
     * @author Administrator
     * 
     */
    public interface WifiApStateListener {
        // 10---正在关闭；11---已关闭；12---正在开启；13---已开启
        void onClosing();

        void onClosed();

        void onStarting();

        void onStarted();
    }

    /* ============================ wifi方法 begin ============================ */

    /**
     * 判断wifi是否处理开启状态
     * 
     * @param context
     * @return
     */
    public boolean isWifiOpen(Context context) {
        // 获取系统服务
        ConnectivityManager manager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        // 获取状态
        State wifi = manager.getNetworkInfo(ConnectivityManager.TYPE_WIFI)
                .getState();
        // 判断wifi已连接的条件
        if (wifi == State.CONNECTED || wifi == State.CONNECTING) {
            return true;
        }
        return false;
    }

    /**
     * 得到当前连接的Wifi名称(ssid)
     * 
     * @return
     */
    public String getConnectWifiSsid(Context context) {
        WifiManager wifiManager = (WifiManager) context
                .getSystemService(Context.WIFI_SERVICE);
        WifiInfo wifiInfo = wifiManager.getConnectionInfo();
        // Log.d("wifiInfo", wifiInfo.toString());
        // Log.d("SSID", wifiInfo.getSSID());
        return wifiInfo.getSSID();
    }

    /**
     * 设置Wifi开关
     * 
     */
    public void setWifiEnabled(boolean enabled) {

        // 打开Wifi
        if (enabled) {
            // 关闭AP热点
            setWifiApEnabled(false);
            // 一关闭wifi热点就关闭广播监听
            if (mWifiApStateReceiver != null) {
                context.unregisterReceiver(mWifiApStateReceiver);
                mWifiApStateReceiver = null;
            }

            // 开启wifi时就开启广播监听，监听热点的状态
            IntentFilter filter = new IntentFilter();
            filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
            filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
            filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
            mWifiStateReceiver = new WifiStateReceiver();
            context.registerReceiver(mWifiStateReceiver, filter);

        } else {
            // 关闭wifi时，取消监听
            if (mWifiStateReceiver != null) {
                context.unregisterReceiver(mWifiStateReceiver);
                mWifiStateReceiver = null;
            }
        }

        // 打开wifi或关闭wifi
        mWifiManager.setWifiEnabled(enabled);

    }

    /**
     * 添加一个网络并连接
     * 
     * @param wcg
     */
    private boolean addNetwork(WifiConfiguration wcg) {
        int wcgID = mWifiManager.addNetwork(wcg);
        return mWifiManager.enableNetwork(wcgID, true);
    }

    /**
     * 创建一个wifi信息
     * 
     * @param SSID
     * @param Password
     * @param Type
     * @return
     */
    private 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 = 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;
    }

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

    /**
     * 连接到指定Wifi
     * 
     * @param ssid
     * @param password
     * @param wifiStateListener
     */
    public boolean connectToWifi(String ssid, String password) {
        WifiConfiguration createWifiInfo = CreateWifiInfo(ssid, password, 3);
        return addNetwork(createWifiInfo);
    }

    /**
     * wifi的广播接收者
     * 
     * @author Administrator
     * 
     */
    private class WifiStateReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (WifiManager.WIFI_STATE_CHANGED_ACTION
                    .equals(intent.getAction())) {// 这个监听wifi的打开与关闭，与wifi的连接无关
                int wifiState = intent.getIntExtra(
                        WifiManager.EXTRA_WIFI_STATE, 0);
                switch (wifiState) {
                case WifiManager.WIFI_STATE_DISABLED:
                    if (mWifiStateListener != null)
                        mWifiStateListener.onDisabled();
                    break;
                case WifiManager.WIFI_STATE_DISABLING:
                    if (mWifiStateListener != null)
                        mWifiStateListener.onDisabling();
                    break;
                case WifiManager.WIFI_STATE_ENABLED:
                    if (mWifiStateListener != null)
                        mWifiStateListener.onEnabled();
                    break;
                case WifiManager.WIFI_STATE_ENABLING:
                    if (mWifiStateListener != null)
                        mWifiStateListener.onEnabling();
                    break;
                case WifiManager.WIFI_STATE_UNKNOWN:
                    if (mWifiStateListener != null)
                        mWifiStateListener.onUnknow();
                    break;
                }
            }
        }
    }

    /**
     * wifi状态监听接口
     * 
     * @author Administrator
     * 
     */
    public interface WifiStateListener {
        void onDisabled();

        void onDisabling();

        void onEnabled();

        void onEnabling();

        void onUnknow();
    }

    /**
     * 得到周围的wifi
     * 
     * @return
     */
    public List<ScanResult> getWifiScanResult() {
        // 使用wifiManager得到周边所有的wifi
        List<ScanResult> scanResults = mWifiManager.getScanResults();
        // 信号从强到弱排序
        sortByLevel(scanResults);
        return scanResults;
    }

    // 将搜索到的wifi根据信号强度从强到弱进行排序
    private void sortByLevel(List<ScanResult> list) {
        for (int i = 1; i <= list.size(); i++) {
            for (int j = list.size() - 1; j >= 1; j--) {
                if (list.get(j).level > list.get(j - 1).level) {

                    ScanResult temp = null;
                    temp = list.get(j);
                    list.set(j, list.get(j - 1));
                    list.set(j - 1, temp);
                }
            }
        }
    }

    /**
     * 判断wifi网络是否稳定(需要子线程)
     * 
     * @return
     */
    public boolean isWifiStable() {
        boolean isStable = false;

        try {
            /*
             * ping -c 3 -w 100 中 ， -c 是指ping的次数 3是指ping 3次 ， -w
             * 100以秒为单位指定超时间隔，是指超时时间为100秒
             */
            Process process = Runtime.getRuntime().exec(
                    "ping -c 3 -w 5 192.168.43.1");
            int status = process.waitFor();

            if (status == 0) {
                // 连接正常
                isStable = true;
            } else {
                // 连接异常
                // Fail:Host unreachable
                isStable = false;
            }
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

        return isStable;
    }

    /* ============================ wifi方法 end ============================ */

    /* ============================ 加密ssid和password ============================ */
    /**
     * 加密连接参数（热点的ssid和密码）
     * 
     * @return encrypt(ssid + tag + password)
     */
    public String getEncryptParams(String ssid, String password) {
        // 对真正的ssid和password加密
        String encryptParams = "";
        try {
            // 加密ssid + tag + password
            encryptParams = AESUtils
                    .encrypt(ssid + Constants.APPTAG + password);
        } catch (Exception e) {
            e.printStackTrace();
        }
        // 返回加密后的ssid + tag + password
        return encryptParams;
    }
}