通過監(jiān)聽廣播的形式連接WiFi

今天要說的是通過監(jiān)聽廣播的形式連接WiFi，實(shí)現(xiàn)的需求如下所示：


這里寫圖片描述

好了，現(xiàn)在就讓我們實(shí)現(xiàn)起來吧
1.Receiver.java

package com.example.mode;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.text.TextUtils;
import android.util.Log;

/**
 * @author: lijuan
 * @description: wifi連接監(jiān)聽廣播器
 * @date: 2017-06-05
 * @time: 15:05
 */
public class Receiver extends BroadcastReceiver {
    public static final String TAG = "Receiver";
    private static final String ACTION = "type";
    private static final String SSID = "wifi-ssid";
    private static final String PWD = "wifi-pwd";
    private static final String WIFI = "wifi";
    public static WifiUtils mWifiUtils;
    private Context mContext;

    @Override
    public void onReceive(Context context, Intent intent) {
        this.mContext = context;
        mWifiUtils = WifiUtils.getInstance(context);
        final String ssid = intent.getStringExtra(SSID);
        final String pwd = intent.getStringExtra(PWD);
        final String wifi = intent.getStringExtra(WIFI);
        if (!TextUtils.isEmpty(ssid) && !TextUtils.isEmpty(pwd)) {
            connectWifi(ssid, pwd);
        }
        if (!TextUtils.isEmpty(wifi) && wifi.equals("clear")) {
            mWifiUtils.removeExistWiFiConfiguration();
        }
    }

    /**
     * 連接Wifi
     *
     * @param ssid     wifi名
     * @param password wifi密碼
     */
    public void connectWifi(final String ssid, final String password) {
        if (!isWifiEnabled()) {
            mWifiUtils.openWifi();
            new Thread(new Runnable() {
                @Override
                public void run() {
                    try {
                        Thread.sleep(2000);
                        Log.i(TAG, "已經(jīng)打開WiFi，現(xiàn)連接WiFi，ssid:" + ssid + "，密碼:" + password);
                        mWifiUtils.connectWiFi(ssid, password, 3, true);
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            }).start();
        } else {
            if (mWifiUtils.getWifiName().equals(ssid)) return;
            Log.i(TAG, "連接WiFi，ssid:" + ssid + "，密碼:" + password);
            mWifiUtils.connectWiFi(ssid, password, 3, true);
        }
    }

    /**
     * 判斷WIFI是否打開
     */
    public boolean isWifiEnabled() {
        ConnectivityManager connectivityManager = (ConnectivityManager) mContext
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connectivityManager.getActiveNetworkInfo();
        if (networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
            return true;
        }
        return false;
    }
}

2.在AndroidManifest.xml中聲明receiver

<receiver android:name=".Receiver">
            <intent-filter>
                <action android:name="com.example.mode" />
            </intent-filter>
        </receiver>

3.好吧，順便再貼上wifi工具類吧，WifiUtils.java

package com.example.mode;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
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.text.TextUtils;
import android.util.Log;

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

/**
 * @author: lijuan
 * @description: 對Wifi的操作進(jìn)行一次封裝
 * @date: 2016-12-01
 * @time: 14:44
 */
public class WifiUtils {
    // 上下文
    private Context mContext;
    // 定義WifiManager對象
    private WifiManager mWifiManager;
    // 定義WifiInfo對象
    private WifiInfo mWifiInfo;
    // 排序后的WiFi掃描結(jié)果列表
    private List<WifiModel> mWifiModels;
    private final static String CONNECTING = "CONNECTING";
    private final static String CONNECTED = "CONNECTED";
    private final static String DISCONNECTED = "DISCONNECTED";
    // private Timer timer;
    private static final int CONNECT_WIFI_TIMEOUT = 50000; //50秒
    /**
     * 當(dāng)前正要連接的wifi
     */
    private String ssid;
    /**
     * 當(dāng)前已經(jīng)連接上的wifi
     */
    private String wifiName;

    private String TAG = "Wifi";

    private static WifiUtils instance;

    public static WifiUtils getInstance(Context context) {
        if (instance == null) {
            instance = new WifiUtils(context);
        }
        return instance;
    }

    /**
     * 構(gòu)造器
     *
     * @param context 上下文
     */
    public WifiUtils(Context context) {
        // 初始化WifiManager對象
        mWifiManager = (WifiManager) context
                .getSystemService(Context.WIFI_SERVICE);
        // 初始化WifiInfo對象
        mWifiInfo = mWifiManager.getConnectionInfo();
        // 初始化WiFi掃描結(jié)果列表
        mWifiModels = new ArrayList<>();
        this.mContext = context;
//        this.timer = new Timer();
        startBroadcastReceiver();
    }

    public void unregisterReceiver() {
        try {
            mContext.unregisterReceiver(WiFiStateReceiver);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 獲取WiFi結(jié)果列表
     *
     * @return
     */
    public List<ScanResult> getScanResultList() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiManager.startScan();
        }
        return mWifiManager.getScanResults();
    }

    /**
     * 獲取已排序后的wifi掃描列表
     *
     * @return
     */
    public List<WifiModel> getScanList() {
        List<ScanResult> list = getScanResultList();
        StringBuffer mStringBuffer = new StringBuffer();
        if (list != null) {
            // 每次點(diǎn)擊掃描之前清空上一次的掃描結(jié)果
            mWifiModels.clear();
            for (int i = 0; i < list.size(); i++) {
                ScanResult mScanResult = list.get(i);
                WifiModel model = new WifiModel(i, mScanResult.SSID, getSignalLevel(mScanResult.level));
                if (!TextUtils.isEmpty(mScanResult.SSID)) mWifiModels.add(model);
                mStringBuffer = mStringBuffer
                        .append(mScanResult.SSID).append("    ")
                        .append(mScanResult.BSSID).append("    ")
                        .append(mScanResult.capabilities).append("    ")
                        .append(mScanResult.frequency).append("    ")
                        .append(mScanResult.level).append("    ")
                        .append("\n");
            }
        }
        // 打印掃描到的wifi列表詳情信息
        Log.e(TAG, mStringBuffer.toString());
        Log.e(TAG, "獲取wifi列表總共有：" + mWifiModels.size() + "條數(shù)據(jù)");
        return mWifiModels;
    }

    /**
     * 獲取wifi信號強(qiáng)度
     *
     * @param rssi 在RSSI測量的信號的功率
     * @return 0-4 信號為4的時(shí)候?yàn)樽顝?qiáng)
     */
    public int getSignalLevel(int rssi) {
        return mWifiManager.calculateSignalLevel(rssi, 5);
    }

    /**
     * 獲取當(dāng)前連接的wifi的信號強(qiáng)度
     *
     * @return 0-4 信號為4的時(shí)候?yàn)樽顝?qiáng)
     */
    public int getSignalLevel() {
        return mWifiManager.calculateSignalLevel(mWifiInfo.getRssi(), 5);
    }

    /**
     * 打開WIFI
     */
    public void openWifi() {
        if (!mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(true);
        }
    }

    /**
     * 關(guān)閉WIFI
     */
    public void closeWifi() {
        if (mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(false);
        }
    }

    /**
     * 檢查當(dāng)前WIFI狀態(tài)
     * 0:WIFI_STATE_DISABLING->wifi正在禁用
     * 1:WIFI_STATE_DISABLED->wifi已禁用
     * 2:WIFI_STATE_ENABLING->wifi正在啟用
     * 3:WIFI_STATE_ENABLED->wifi已啟用
     * 4:WIFI_STATE_UNKNOWN->wifi為未知
     *
     * @return
     */
    public int checkState() {
        return mWifiManager.getWifiState();
    }

    /**
     * 獲取IP地址
     *
     * @return
     */
    public int getIPAddress() {
        return (mWifiInfo == null) ? 0 : mWifiInfo.getIpAddress();
    }

    /**
     * 獲取連接的ID
     *
     * @return
     */
    public int getNetworkId() {
        return (mWifiInfo == null) ? 0 : mWifiInfo.getNetworkId();
    }

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

    /**
     * 得到接入點(diǎn)的BSSID
     *
     * @return
     */
    public String getBSSID() {
        return (mWifiInfo == null) ? "NULL" : mWifiInfo.getBSSID();
    }

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

    /**
     * 獲取當(dāng)前已連接的網(wǎng)路名稱
     *
     * @return
     */
    public String getWifiName() {
        if (!TextUtils.isEmpty(wifiName)) {
            Log.e(TAG, "當(dāng)前已經(jīng)連接的wifi：" + wifiName);
            return wifiName;
        } else {
            return (mWifiInfo == null) ? "NULL" : mWifiInfo.getSSID();
        }
    }

    /**
     * 添加一個(gè)網(wǎng)絡(luò)并連接
     *
     * @param wcg
     */
    public void addNetwork(WifiConfiguration wcg) {
        int wcgID = mWifiManager.addNetwork(wcg);
        mWifiManager.enableNetwork(wcgID, true);
    }

    /**
     * 斷開指定ID的網(wǎng)絡(luò)
     *
     * @param netId
     */
    public void disconnectWifi(int netId) {
        mWifiManager.disableNetwork(netId);
        mWifiManager.disconnect();
    }

    /**
     * 連接wifi
     *
     * @param configuration wifi連接信息
     * @return 本次連接的netWorkId
     */
    public boolean connectWiFi(WifiConfiguration configuration, boolean disableOther) {
        ssid = configuration.SSID.substring(1, configuration.SSID.length() - 2);
        int index = mWifiManager.addNetwork(configuration);
        mWifiManager.saveConfiguration();
        return mWifiManager.enableNetwork(index, disableOther);
    }

    /**
     * 連接wifi
     *
     * @param ssid         ssid
     * @param password     密碼
     * @param type         wifi類型
     * @param disableOther 是否其他連接失效
     * @return 本次連接的networkId
     */
    public Boolean connectWiFi(String ssid, String password, int type, boolean disableOther) {
        this.ssid = ssid;
        WifiConfiguration wifi = createWifiConfiguration(ssid, password, type);
        int index = mWifiManager.addNetwork(wifi);
        mWifiManager.saveConfiguration();
        return mWifiManager.enableNetwork(index, disableOther);
    }

    /**
     * 啟動(dòng)監(jiān)聽廣播事件，wifi狀態(tài)
     */
    public void startBroadcastReceiver() {
        IntentFilter filter = new IntentFilter();
        filter.addAction(WifiManager.RSSI_CHANGED_ACTION);
        filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
        filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
        mContext.registerReceiver(WiFiStateReceiver, filter);
    }

    /**
     * wifi狀態(tài)監(jiān)聽廣播器
     */
    private BroadcastReceiver WiFiStateReceiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            //wifi連接狀態(tài)發(fā)生改變
            if (intent.getAction().equals(WifiManager.NETWORK_STATE_CHANGED_ACTION)) {
                NetworkInfo info = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
                wifiName = info.getExtraInfo().replace("\"", "");
                switch (info.getState().name()) {
                    case CONNECTING:
                        Log.e(TAG, "正在連接：" + wifiName);
                        break;
                    case CONNECTED:
                        if (wifiName.equals("\"" + ssid + "\"")) {
                            Log.e(TAG, "已連接：" + wifiName);
                        } else {
                            Log.e(TAG, "已自動(dòng)連接：" + wifiName);
                        }
                        break;
                    case DISCONNECTED:
                        if (info.getDetailedState().equals(NetworkInfo.DetailedState.DISCONNECTED) && info.getExtraInfo().equals("\"" + ssid + "\"")) {
                            Log.e(TAG, ssid + "連接失敗");
                        }
                        break;
                    default:
                        break;
                }
            }
        }
    };

    /**
     * 創(chuàng)建一個(gè)wifi連接信息
     *
     * @param ssid ssid
     * @param pass password
     * @param type 連接類型
     * @return wifi連接信息
     */
    private WifiConfiguration createWifiConfiguration(String ssid, String pass, int type) {
        WifiConfiguration configuration = new WifiConfiguration();
        //清除一些默認(rèn)wifi的配置
        configuration.allowedAuthAlgorithms.clear();
        configuration.allowedGroupCiphers.clear();
        configuration.allowedKeyManagement.clear();
        configuration.allowedPairwiseCiphers.clear();
        configuration.allowedProtocols.clear();
        configuration.SSID = "\"" + ssid + "\"";
        //清除已存在的相應(yīng)的ssid
        removeExistWiFiConfiguration(ssid);

        // 分為三種情況：1沒有密碼2用wep加密3用wpa加密
        switch (type) {
            case 1:       //沒有密碼
                configuration.wepKeys[0] = "";
                configuration.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
                configuration.wepTxKeyIndex = 0;
                break;
            case 2:      //wep密碼
                configuration.hiddenSSID = true;
                configuration.wepKeys[0] = "\"" + pass + "\"";
                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;
                break;
            case 3:   //wpa or wpa2 密碼
                configuration.preSharedKey = "\"" + pass + "\"";
                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;
                break;
        }
        return configuration;
    }

    /**
     * 移除已保存的連接列表中存在的ssid
     *
     * @param ssid ssid
     */
    public void removeExistWiFiConfiguration(String ssid) {
        List<WifiConfiguration> wificonfigList = mWifiManager.getConfiguredNetworks();
        if (wificonfigList == null) return;
        if (wificonfigList.size() < 1) return;
        for (WifiConfiguration wifi : wificonfigList) {
            if (wifi.SSID.equals("\"" + ssid + "\"")) {
                mWifiManager.removeNetwork(wifi.networkId);
                mWifiManager.saveConfiguration();
            }
        }
    }

    /**
     * 移除所有保存在列表的wifi信息
     */
    public void removeExistWiFiConfiguration() {
        List<WifiConfiguration> wificonfigList = mWifiManager.getConfiguredNetworks();
        if (wificonfigList == null) return;
        if (wificonfigList.size() < 1) return;
        for (WifiConfiguration wifi : wificonfigList) {
            mWifiManager.removeNetwork(wifi.networkId);
            mWifiManager.saveConfiguration();
            Log.e(TAG, "刪除保存的wifi信息：" + wifi.networkId);
        }
    }
}

4.實(shí)體類 WifiModel.java

package com.example.mode;

/**
 * @author: lijuan
 * @description:
 * @date: 2016-12-02
 * @time: 10:11
 */
public class WifiModel {
    private int id;
    private String name;
    private int signalLevel;

    public WifiModel(int id, String name, int signalLevel) {
        this.id = id;
        this.name = name;
        this.signalLevel = signalLevel;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSignalLevel() {
        return signalLevel;
    }

    public void setSignalLevel(int signalLevel) {
        this.signalLevel = signalLevel;
    }
}

5.還有一點(diǎn)不要忘記哦，要添加權(quán)限滴：

<uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
    <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
    <uses-permission android:name="android.permission.WRITE_SETTINGS"/>

6.好啦，現(xiàn)在我們來測試一下吧

am broadcast -a com.example.mode --es wifi-ssid "wifi名" --es wifi-pwd "wifi密碼"
這里寫圖片描述
am broadcast -a com.example.mode --es wifi "clear"
這里寫圖片描述
最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請結(jié)合常識與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡書系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

友情鏈接更多精彩內(nèi)容