Android7.0+ 获取WiFi列表以及连接WiFi

获取WiFi列表并连接

这段时间项目中涉及到需要获取WiFi列表以及连接，在这里记录下
其中就有一个坑，在Android7.0以上还需要打开定位（也就是手机中”位置信息“）
WifiManager和LocationManager都需要获取下系统服务

mWifiManager = (WifiManager) getActivity().getSystemService(getActivity().WIFI_SERVICE);
locationManager = (LocationManager) getActivity().getSystemService(Context.LOCATION_SERVICE);

这里LocationManager是为了判断手机有没有打开这个“位置信息”
好的，前戏已经准备好了，接下来就是正轨了…

1. 监听WiFi的广播接收器是必不可少的

public class WifiBroadcastReceiver extends BroadcastReceiver {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {
                //wifi开关变化
                int state = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
                switch (state) {
                    case WifiManager.WIFI_STATE_DISABLED: {
                        //wifi关闭
                        Log.i(TAG, "已经关闭");
                        break;
                    }
                    case WifiManager.WIFI_STATE_DISABLING: {
                        //wifi正在关闭
                        Log.i(TAG, "正在关闭");
                        break;
                    }
                    case WifiManager.WIFI_STATE_ENABLED: {
                        //wifi已经打开
                        Log.i(TAG, "WIFI已打开");
                        break;
                    }
                    case WifiManager.WIFI_STATE_ENABLING: {
                        //wifi正在打开
                        Log.i(TAG, "正在打开");
                        break;
                    }
                    case WifiManager.WIFI_STATE_UNKNOWN: {
                        //未知
                        Log.i(TAG, "未知状态");
                        break;
                    }
                }
            } else if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction())) {
                //监听wifi连接状态
                NetworkInfo info = intent.getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
//                Log.i(TAG, "--NetworkInfo--" + info.toString());
                if (NetworkInfo.State.DISCONNECTED == info.getState()) {//wifi没连接上
                    Log.i(TAG, "wifi没连接上");
                } else if (NetworkInfo.State.CONNECTED == info.getState()) {//wifi连接上了
                    mScanResultList = MyWifiManager.getWifiList(mWifiManager);//获取Wifi列表
                   for (int i = 0; i < mScanResultList.size(); i++) {
                   		mScanResultList.get(i).SSID//Wifi名称
                   		mScanResultList.get(i).level//wifi信号强度
                   		//其他就不列举了，根据自己的需求去取
                   		//在这增加一个获取当前已连接WiFi的名称以及信号强度
                   		 WifiInfo wifiInfo = mWifiManager .getConnectionInfo();
       					 String name = wifiInfo.getSSID();//名称
       					 WifiInfo wifiInfo = manager.getConnectionInfo();
        				int wiFiLevel = wifiInfo.getRssi();//信号强度
                   }
                } else if (NetworkInfo.State.CONNECTING == info.getState()) {//正在连接
                    Log.i(TAG, "wifi正在连接");
                    tvConnectionCtatus.setText("正在连接");
                }
            } else if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(intent.getAction())) {
                //监听wifi列表变化
                Log.i(TAG, "wifi列表发生变化");
            }
        }
    }

广播到这就结束了，后面我会封装一个WifiManager工具类。咱继续哈
2. 注册广播（这里选择是动态注册）

 wifiReceiver = new WifiBroadcastReceiver();
        IntentFilter filter = new IntentFilter();
        filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);//监听wifi是开关变化的状态
        filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);//监听wifi连接状态
        filter.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);//监听wifi列表变化（开启一个热点或者关闭一个热点）
        registerReceiver(wifiReceiver, filter);

记得要unregistered(receiver)；
3. 最后把封装的WifiManager工具给大家贴出来

/**
     * 开始扫描wifi
     */
    public static void startScanWifi(WifiManager manager) {
        if (manager != null) {
            manager.startScan();
        }
    }


    /**
     * 获取wifi列表
     */
    public static List<ScanResult> getWifiList(WifiManager mWifiManager) {
        return mWifiManager.getScanResults();
    }


    /**
     * 保存网络
     */
    public static void saveNetworkByConfig(WifiManager manager, WifiConfiguration config) {
        if (manager == null) {
            return;
        }
        try {
            Method save = manager.getClass().getDeclaredMethod("save", WifiConfiguration.class, Class.forName("android.net.wifi.WifiManager$ActionListener"));
            if (save != null) {
                save.setAccessible(true);
                save.invoke(manager, config, null);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 断开连接
     */
    public static boolean disconnectNetwork(WifiManager manager) {
        return manager != null && manager.disconnect();
    }


    /**
     * 获取当前wifi名字
     *
     * @return
     */
    public static String getWiFiName(WifiManager manager) {
        WifiInfo wifiInfo = manager.getConnectionInfo();
        String name = wifiInfo.getSSID();
        return name.replace("\"", "");
    }

    /**
     * 获取当前WIFI信号强度
     *
     * @param manager
     * @return
     */
    public static int getWiFiLevel(WifiManager manager) {
        WifiInfo wifiInfo = manager.getConnectionInfo();
        return wifiInfo.getRssi();
    }

    /**
     * 获取wifi加密方式
     */
    public static String getEncrypt(WifiManager mWifiManager, ScanResult scanResult) {
        if (mWifiManager != null) {
            String capabilities = scanResult.capabilities;
            if (!TextUtils.isEmpty(capabilities)) {
                if (capabilities.contains("WPA") || capabilities.contains("wpa")) {
                    return "WPA";
                } else if (capabilities.contains("WEP") || capabilities.contains("wep")) {
                    return "WEP";
                } else {
                    return "没密码";
                }
            }
        }
        return "获取失败";
    }

    /**
     * 是否开启wifi，没有的话打开wifi
     */
    public static void openWifi(WifiManager mWifiManager) {
        if (!mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(true);
        }
    }

    /**
     * 是否开启wifi，没有的话打开wifi
     */
    public static void closeWifi(WifiManager mWifiManager) {
        mWifiManager.setWifiEnabled(false);
    }

    /**
     * 有密码连接
     *
     * @param ssid
     * @param pws
     */
    public static void connectWifiPws(WifiManager mWifiManager, String ssid, String pws) {
        mWifiManager.disableNetwork(mWifiManager.getConnectionInfo().getNetworkId());
        int netId = mWifiManager.addNetwork(getWifiConfig(mWifiManager, ssid, pws, true));
        mWifiManager.enableNetwork(netId, true);
    }

    /**
     * wifi设置
     *
     * @param ssid
     * @param pws
     * @param isHasPws
     */
    private static WifiConfiguration getWifiConfig(WifiManager mWifiManager, String ssid, String pws, boolean isHasPws) {
        WifiConfiguration config = new WifiConfiguration();
        config.allowedAuthAlgorithms.clear();
        config.allowedGroupCiphers.clear();
        config.allowedKeyManagement.clear();
        config.allowedPairwiseCiphers.clear();
        config.allowedProtocols.clear();
        config.SSID = "\"" + ssid + "\"";

        WifiConfiguration tempConfig = isExist(ssid, mWifiManager);
        if (tempConfig != null) {
            mWifiManager.removeNetwork(tempConfig.networkId);
        }
        if (isHasPws) {
            config.preSharedKey = "\"" + pws + "\"";
            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.allowedGroupCiphers.set(WifiConfiguration.GroupCipher.CCMP);
            config.allowedPairwiseCiphers.set(WifiConfiguration.PairwiseCipher.CCMP);
            config.status = WifiConfiguration.Status.ENABLED;
        } else {
            config.allowedKeyManagement.set(WifiConfiguration.KeyMgmt.NONE);
        }
        return config;
    }

    /**
     * 得到配置好的网络连接
     *
     * @param ssid
     * @return
     */
    private static WifiConfiguration isExist(String ssid, WifiManager mWifiManager) {
        List<WifiConfiguration> configs = mWifiManager.getConfiguredNetworks();
        for (WifiConfiguration config : configs) {
            if (config.SSID.equals("\"" + ssid + "\"")) {
                return config;
            }
        }
        return null;
    }

当然最少不了的权限，6.0以后啊都是需要动态获取权限的，相信都会吧
下一篇博客就会写到动态获取权限，是一个封装好的工具类，使用起来非常方便，举个例子

第二个参数就是app需要进行检测的权限数组
PermissUtil.checkPermissions(this, PermissUtil.appNeedPermissions);

有不妥之处还请大家多多指教，谢谢！（持续关注哦）