操作Wifi的工具类

有时候需要打开关闭wifi，或者是坚持状态什么的，这里我写了个工具类来完成各种操作，今后还会添加其他的功能。比如链接某个加密/不加密的wifi

WifiAdmin.java

package com.example.testforwifilinkdemo;

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

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.net.wifi.WifiManager.WifiLock;
import android.util.Log;

public class WifiAdmin {
    private final static String TAG = "WifiAdmin";
    public static final int IS_OPENING = 1,IS_CLOSING = 2,IS_OPENED = 3,IS_CLOSED = 4;
    
    private StringBuffer mStringBuffer = new StringBuffer();
    private List<ScanResult> scanResultList;
    private ScanResult mScanResult;
    // 定义WifiManager对象
    private WifiManager mWifiManager;
    // 定义WifiInfo对象
    private WifiInfo mWifiInfo;
    // 网络连接列表
    private List<WifiConfiguration> mWifiConfigList;
    // 定义一个WifiLock
    WifiLock mWifiLock;

    /**
     * 构造方法
     */
    public WifiAdmin(Context context) {
        mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        mWifiInfo = mWifiManager.getConnectionInfo();
        mWifiConfigList = mWifiManager.getConfiguredNetworks();
    }

    /**
     * 打开Wifi网卡，能打开就返回true，无法打开返回false
     */
    public boolean openNetCard() {
        if (!mWifiManager.isWifiEnabled()) {
            return mWifiManager.setWifiEnabled(true);
        }
        else{
            return false;
        }
    }

    /**
     * 关闭Wifi网卡，能关闭返回true，不能关就返回false
     */
    public boolean closeNetCard() {
        if (mWifiManager.isWifiEnabled()) {
            return mWifiManager.setWifiEnabled(false);
        }
        else{
            return false;
        }
    }

    /**
     * 检查当前Wifi网卡状态，返回四种状态，如果出错返回-1
     */
    public int getWifitate() {
        int result = -1;
        switch (mWifiManager.getWifiState()) {
        case 0:
            Log.i(TAG, "网卡正在关闭");
            result = IS_CLOSING;
            break;
        case 1:
            Log.i(TAG, "网卡已经关闭");
            result = IS_CLOSED;
            break;
        case 2:
            Log.i(TAG, "网卡正在打开");
            result = IS_OPENING;
            break;
        case 3:
            Log.i(TAG, "网卡已经打开");
            result = IS_OPENED;
            break;
        default:
            Log.i(TAG, "---_---晕......没有获取到状态---_---");
            result = -1;
            break;
        }
        return result;
    }

    /**
     * 扫描周边网络，判断周边是否有wifi，有就返回true，没有就返回false
     */
    public boolean scan() {
        if (getWifitate() == IS_OPENED) {
            //开始扫描
            mWifiManager.startScan();
            //将扫描结果存入数据列中
            scanResultList = mWifiManager.getScanResults();
            if (scanResultList != null) {
                return true;
            }
        }
        return false;
    }

    /**
     * 得到附近wifi的扫描结果，是ScanResult对象
     * 得到的是附近网络的结果集，没有就返回null
     */
    public ArrayList<ScanResult> getScanResult() {
        // 每次点击扫描之前清空上一次的扫描结果
        if (mStringBuffer != null) {
            mStringBuffer = new StringBuffer();
        }
        
        scan();// 开始扫描网络
        ArrayList<ScanResult> scanResultsList = new ArrayList<ScanResult>();
        if (scanResultList != null) {
            for (int i = 0; i < scanResultList.size(); i++) {
                mScanResult = scanResultList.get(i);
                scanResultsList.add(mScanResult);
                
                /*mStringBuffer = mStringBuffer.append("NO.").append(i)
                        .append(" :")
                        .append(mScanResult.SSID).append("->")
                        .append(mScanResult.BSSID).append("->")
                        .append(mScanResult.capabilities).append("->")
                        .append(mScanResult.frequency).append("->")
                        .append(mScanResult.level).append("->")
                        .append(mScanResult.describeContents()).append("\n\n");*/
            }
            //Log.i(TAG, mStringBuffer.toString());
            return scanResultsList;
        }
        else {
            return null;
        }
    }
    
    /**
     * 判断指定的网络是否能被扫描到
     * @param wifi_SSID
     * @return 如果能够在周边发现指定的网络就返回true，否则返回false
     */
    public boolean canScannable(String wifi_SSID) {
        boolean canScannable = false;
        scan();//开始扫描周边网络
        //得到扫描到的wifi列表
        if (scanResultList != null) {
            for (int i = 0; i < scanResultList.size(); i++) {
                System.out.println("scanResultList " + i + "----->" + scanResultList.get(i).SSID);
                if (scanResultList.get(i).SSID.equals(wifi_SSID)) {
                    canScannable = true;//如果想要链接的wifi能够扫描到，那么就说明能够链接
                    break;
                }
            }
        }
        return canScannable;
    }
    
    /**
     * 得到指定网络的index（从0开始计数），找不到就返回-1
     */
    public int getTagWifiId(String netName){
        // 开始扫描网络
        scan();
        scanResultList = mWifiManager.getScanResults();
        if (scanResultList != null) {
            for (int i = 0; i < scanResultList.size(); i++) {
                mScanResult = scanResultList.get(i);
                if(mScanResult.SSID.equals(netName)){
                    return i;
                }
                String show = "No = "+i + 
                        " SSID = "+mScanResult.SSID + 
                        " capabilities = "+mScanResult.capabilities + 
                        " level = "+mScanResult.level;
                Log.i(TAG, show);
            }
        }
        return -1;
    }
    
    /**
     * 断开当前连接的网络
     */
    public void disconnectWifi() {
        int netId = getCurrentNetworkId();
        mWifiManager.disableNetwork(netId);
        mWifiManager.disconnect();
        mWifiInfo = null;
    }

    /**
     * 检查当前网络状态
     * 如果有wifi链接，返回true，如果没有就返回false
     */
    public boolean getWifiConnectState() {
        return mWifiInfo != null ? true : false;
    }
    
    /**
     * @return 当前网络的名字，如果没有就返回null，否则返回string
     */
    public String getCurrentSSID(){
        return (mWifiInfo == null) ? null :mWifiInfo.getSSID();
    }
    
    /**
     * 得到连接的ID，如果没有就返回0，否则返回正确的id
     */
    public int getCurrentNetworkId() {
        return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
    }

    /**
     * 得到IP地址，出错时返回0
     */
    public int getCurrentIPAddress() {
        return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
    }
    
    /**
     * 得到MAC地址
     * @return 出錯了返回null
     */
    public String getCurrentMacAddress() {
        return (mWifiInfo == null) ? null : mWifiInfo.getMacAddress();
    }

    /**
     * 得到接入点的BSSID
     * @return 出錯返回null
     */
    public String getCurrentBSSID() {
        return (mWifiInfo == null) ? null : mWifiInfo.getBSSID();
    }

    /**
     * 得到WifiInfo的所有信息包
     * @return 出错了返回null
     */
    public WifiInfo getCurrentWifiInfo() {
        return (mWifiInfo == null) ? null : mWifiInfo;
    }

    // 锁定WifiLock
    public void acquireWifiLock() {
        mWifiLock.acquire();
    }

    // 解锁WifiLock
    public void releaseWifiLock() {
        // 判断时候锁定
        if (mWifiLock.isHeld()) {
            mWifiLock.acquire();
        }
    }

    // 创建一个WifiLock
    public void creatWifiLock() {
        mWifiLock = mWifiManager.createWifiLock("Test");
    }

    // 得到配置好的网络
    public List<WifiConfiguration> getConfiguration() {
        return mWifiConfigList; 
    }

    /**
     * @param index
     * @return 没有连接到返回false，正在连接则返回true
     */
    public boolean connectConfiguratedWifi(String wifi_SSID) {
        //如果当前网络不是想要链接的网络，要连接的网络是配置过的，并且要连接的网络能够被扫描到
        if (getCurrentSSID().indexOf(wifi_SSID) == -1 ) {
            if (getWifiConfigurated(wifi_SSID) != -1 && canScannable(wifi_SSID)) {
                mWifiManager.enableNetwork(getWifiConfigurated(wifi_SSID), true);
            }
            else {
                return false;
            }
        }
        return true;
    }
    
    /**
     * 判断要连接的wifi名是否已经配置过了
     * @return 返回要连接的wifi的ID，如果找不到就返回-1
     */
    public int getWifiConfigurated(String wifi_SSID) {
        int id = -1;
        if (mWifiConfigList != null) {
            for (int j = 0; j < mWifiConfigList.size(); j++) {
                if (mWifiConfigList.get(j).SSID.equals("\"" + wifi_SSID + "\"")) {
                    //如果要连接的wifi在已经配置好的列表中，那就设置允许链接，并且得到id
                    id = mWifiConfigList.get(j).networkId;
                    break;
                }
            }
        }
        return id;
    }

    
}

 

 

 

 

测试代码

package com.kale.socketactivity;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;

import android.net.wifi.ScanResult;
import android.os.Bundle;
import android.support.v7.app.ActionBarActivity;

public class MainActivity extends ActionBarActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        WifiAdmin wifi = new WifiAdmin(this);

        //wifi.closeNetCard();
        //wifi.openNetCard();
        /*switch (wifi.getNetCardState()) {
        case WifiAdmin.IS_CLOSED:
            System.out.println(WifiAdmin.IS_CLOSED);
            break;
        case WifiAdmin.IS_CLOSING:
            System.out.println(WifiAdmin.IS_CLOSING);
            break;
        case WifiAdmin.IS_OPENED:
            System.out.println(WifiAdmin.IS_OPENED);
            break;
        case WifiAdmin.IS_OPENING:
            System.out.println(WifiAdmin.IS_OPENING);
            break;
        default:
            break;
        }*/
        //wifi.scan();
        //wifi.getScanResult();
        /*List<ScanResult> list = wifi.getScanResult();
        for (int i = 0; i < list.size(); i++) {
            System.out.println("No = "+ i);
            System.out.println("BSSID = "+ list.get(i).BSSID);
            System.out.println("capabilities = " + list.get(i).capabilities);
            System.out.println("frequency = " + list.get(i).frequency);
            System.out.println("level = " + list.get(i).level);
            System.out.println("SSID = " + list.get(i).SSID);
            System.out.println("timestamp = " + list.get(i).timestamp);
            
        }*/
        
        //System.out.println("你选择的网络的index为"+wifi.getUniqueId("CMCC-EDU"));
        //wifi.disconnectWifi();
        //wifi.getWifiConnectState();
/*        System.out.println("当前网络的BSSID = "+wifi.getCurrentBSSID() + "\n"
                +"Ip = "+wifi.getCurrentIPAddress() + "\n"
        +"Mac = "+wifi.getCurrentMacAddress() + "\n"
        +"id = "+wifi.getCurrentNetworkId() + "\n"
        +"ssid = "+wifi.getCurrentSSID() + "\n"
        +"wifiInfo = "+wifi.getCurrentWifiInfo());*/
        
    }

    
}