自定义 WIFI 自动记住密码 自动连接

package com.example.xufeng.launchwatch.utils;

/**
 * Created by Administrator on 2019/3/29 0029.
 */

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

import android.annotation.SuppressLint;
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.text.TextUtils;
import android.widget.Toast;

@SuppressLint("WrongConstant")
public class WifiAdmin {
    // 定义WifiManager对象
    private WifiManager mWifiManager;
    // 定义WifiInfo对象
    private WifiInfo mWifiInfo;
    // 扫描出的网络连接列表
    private List<ScanResult> mWifiList;
    // 网络连接列表
    private List<WifiConfiguration> mWifiConfiguration;
    // 定义一个WifiLock
    WifiLock mWifiLock;

    // 构造器
    public WifiAdmin(Context context) {
        // 取得WifiManager对象
        mWifiManager = (WifiManager) context
                .getSystemService(Context.WIFI_SERVICE);
        // 取得WifiInfo对象
        mWifiInfo = mWifiManager.getConnectionInfo();
    }

    // 打开WIFI

    public void openWifi(Context context) {
        if (!mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(true);
        } else if (mWifiManager.getWifiState() == 2) {
            Toast.makeText(context, "亲，Wifi正在开启，不用再开了", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(context, "亲，Wifi已经开启,不用再开了", Toast.LENGTH_SHORT).show();
        }
    }

    // 关闭WIFI
    public void closeWifi(Context context) {
        if (mWifiManager.isWifiEnabled()) {
            mWifiManager.setWifiEnabled(false);
        } else if (mWifiManager.getWifiState() == 1) {
            Toast.makeText(context, "亲，Wifi已经关闭，不用再关了", Toast.LENGTH_SHORT).show();
        } else if (mWifiManager.getWifiState() == 0) {
            Toast.makeText(context, "亲，Wifi正在关闭，不用再关了", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(context, "请重新关闭", Toast.LENGTH_SHORT).show();
        }
    }

    // 检查当前WIFI状态
    public void checkState(Context context) {
        if (mWifiManager.getWifiState() == 0) {
            Toast.makeText(context, "Wifi正在关闭", Toast.LENGTH_SHORT).show();
        } else if (mWifiManager.getWifiState() == 1) {
            Toast.makeText(context, "Wifi已经关闭", Toast.LENGTH_SHORT).show();
        } else if (mWifiManager.getWifiState() == 2) {
            Toast.makeText(context, "Wifi正在开启", Toast.LENGTH_SHORT).show();
        } else if (mWifiManager.getWifiState() == 3) {
            Toast.makeText(context, "Wifi已经开启", Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(context, "没有获取到WiFi状态", Toast.LENGTH_SHORT).show();
        }
    }

    //返回当前WIFI状态
    public int getState() {
        return mWifiManager.getWifiState();
    }

    // 锁定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 mWifiConfiguration;
    }

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

    public void startScan(Context context) {
        mWifiManager.startScan();
    }

    // 得到网络列表
    public List<ScanResult> getWifiList(Context context) {
        //得到扫描结果
        List<ScanResult> results = mWifiManager.getScanResults();
        // 得到配置好的网络连接
        mWifiConfiguration = mWifiManager.getConfiguredNetworks();
        if (results == null) {
            if (mWifiManager.getWifiState() == 3) {
                Toast.makeText(context, "当前区域没有无线网络", Toast.LENGTH_SHORT).show();
            } else if (mWifiManager.getWifiState() == 2) {
                Toast.makeText(context, "wifi正在开启，请稍后扫描", Toast.LENGTH_SHORT).show();
            } else {
                Toast.makeText(context, "WiFi没有开启", Toast.LENGTH_SHORT).show();
            }
        } else {
            mWifiList = new ArrayList();
            for (ScanResult result : results) {
                if (result.SSID == null || result.SSID.length() == 0 || result.capabilities.contains("[IBSS]")) {
                    continue;
                }
                boolean found = false;
                for (ScanResult item : mWifiList) {
                    if (item.SSID.equals(result.SSID) && item.capabilities.equals(result.capabilities)) {
                        found = true;
                        break;
                    }
                }
                if (!found) {
                    mWifiList.add(result);
                }
            }
        }
        return mWifiList;
    }

    // 得到网络列表
    public List getWifiList() {
        return mWifiManager.getScanResults();
    }

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

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

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

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

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

    // 得到WifiInfo的所有信息包
    public WifiInfo getWifiInfo() {
        return mWifiManager.getConnectionInfo();
    }

    // 添加一个网络并连接
    public void addNetwork(WifiConfiguration wcg) {
        if (wcg != null) {
            int wcgID = mWifiManager.addNetwork(wcg);
            boolean b = mWifiManager.enableNetwork(wcgID, true);
            if (b) {
                mWifiManager.saveConfiguration();
            }
            System.out.println("a--" + wcgID);
            System.out.println("b--" + b);
        }
    }

    // 断开指定ID的网络
    public void disconnectWifi(int netId) {
        mWifiManager.disableNetwork(netId);
        mWifiManager.disconnect();
    }

    public void removeWifi(int netId) {
        disconnectWifi(netId);
        mWifiManager.removeNetwork(netId);
        mWifiManager.saveConfiguration();
    }

//然后是一个实际应用方法，只验证过没有密码的情况：

    public WifiConfiguration CreateWifiInfo(String SSID, String Password, int Type) {
//        if (Type == -1) {
//            return null;
//        }

        WifiConfiguration config = new WifiConfiguration();
        config.allowedAuthAlgorithms.clear();
        config.allowedGroupCiphers.clear();
        config.allowedKeyManagement.clear();
        config.allowedPairwiseCiphers.clear();
        config.allowedProtocols.clear();
        config.SSID = "\"" + SSID + "\"";

        WifiConfiguration tempConfig = this.IsExsits(SSID);
        if (tempConfig != null) {
            mWifiManager.removeNetwork(tempConfig.networkId);
            mWifiManager.saveConfiguration();
        }

        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;
    }

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

    public int getCipherType(String ssid) {
        List<ScanResult> list = mWifiManager.getScanResults();
        for (ScanResult scResult : list) {

            if (!TextUtils.isEmpty(scResult.SSID)
                    && (scResult.SSID.trim().equalsIgnoreCase(
                    "\"" + ssid + "\"") || scResult.SSID.trim()
                    .equalsIgnoreCase(ssid))) {
                String capabilities = scResult.capabilities;

                if (!TextUtils.isEmpty(capabilities)) {

                    if (capabilities.contains("WPA")
                            || capabilities.contains("wpa")) {
                        return 3;

                    } else if (capabilities.contains("WEP")
                            || capabilities.contains("wep")) {
                        return 2;
                    } else {
                        return 1;
                    }
                }
            }
        }
        return -1;
    }

    public boolean ifWifiExsits(String ssid) {
        mWifiList = getWifiList();
        if (mWifiList == null) {
            return false;
        }
        for (int i = 0; i < mWifiList.size(); i++) {
            if (mWifiList.get(i).SSID.equalsIgnoreCase("\"" + ssid + "\"")
                    || mWifiList.get(i).SSID.equalsIgnoreCase(ssid)) {
                return true;
            }
        }
        return false;
    }

    public String getTrueSSID(String ssid) {
        mWifiList = getWifiList();
        if (mWifiList == null) {
            return ssid;
        }
        for (int i = 0; i < mWifiList.size(); i++) {
            if (mWifiList.get(i).SSID.equalsIgnoreCase("\"" + ssid + "\"")
                    || mWifiList.get(i).SSID.equalsIgnoreCase(ssid)) {
                return mWifiList.get(i).SSID;
            }
        }
        return ssid;
    }

    public boolean isConnect(String ssid) {
        WifiInfo wifiInfo = mWifiManager.getConnectionInfo();
        if (wifiInfo != null) {
            return wifiInfo.getSSID().equalsIgnoreCase("\"" + ssid + "\"")
                    || wifiInfo.getSSID().equalsIgnoreCase(ssid);
        }
        return false;
    }
}

package com.example.xufeng.launchwatch.pageThree.setting.setWifi;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.graphics.Color;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.ScanResult;
import android.net.wifi.SupplicantState;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Bundle;
import android.os.CountDownTimer;
import android.os.Parcelable;
import android.support.v7.widget.LinearLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ImageView;
import android.widget.RelativeLayout;
import android.widget.TextView;
import android.widget.Toast;

import com.example.xufeng.launchwatch.AppApplication;
import com.example.xufeng.launchwatch.R;
import com.example.xufeng.launchwatch.SlideActivity;
import com.example.xufeng.launchwatch.config.FlagConfig;
import com.example.xufeng.launchwatch.utils.ACache;
import com.example.xufeng.launchwatch.utils.WifiAdmin;
import com.suke.widget.SwitchButton;

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

/**
 * Created by Administrator on 2019/3/28 0028.
 */

public class SetWifiActivity extends SlideActivity implements SwitchButton.OnCheckedChangeListener {
    private final String CONNECTED = "已连接";
    private final String CONNECTED_FAIL = "连接失败";
    private final String CONNECTED_ING = "正在连接";
    private RecyclerView mRecycleView;
    private WifiAdapter mWifAdapter;
    private WifiAdmin wifiAdmin;
    private List<ScanResult> mlist = new ArrayList<>();
    private NetworkReceiver mNetworkReceiver;
    private boolean ifOpen = false;
    private boolean ifEnabel = true;
    private String mConnectSSID = "";
    private String mConnectStr = "";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_wifi_set);
        initView();
    }

    CountDownTimer timer = new CountDownTimer(3 * 1000, 1000) {
        @Override
        public void onTick(long l) {

        }

        @Override
        public void onFinish() {
            ifEnabel = true;
            mWifAdapter.notifyDataSetChanged();
        }
    };

    private void initView() {
        wifiAdmin = new WifiAdmin(this);
        mWifAdapter = new WifiAdapter();
        mRecycleView = (RecyclerView) findViewById(R.id.recycleView);
        mRecycleView.setLayoutManager(new LinearLayoutManager(this));
        mRecycleView.setAdapter(mWifAdapter);

        mNetworkReceiver = new NetworkReceiver();
        IntentFilter intent = new IntentFilter();
        intent.addAction("android.net.wifi.WIFI_STATE_CHANGED");
        intent.addAction("android.net.wifi.STATE_CHANGE");
        intent.addAction("android.net.wifi.supplicant.STATE_CHANGE");
        intent.addAction("android.net.wifi.NETWORK_IDS_CHANGED");
        intent.addAction(WifiManager.SCAN_RESULTS_AVAILABLE_ACTION);
        Intent nowIntent = registerReceiver(mNetworkReceiver, intent);
//        SupplicantState supplicantState = nowIntent.getParcelableExtra(WifiManager.EXTRA_NEW_STATE);
//        NetworkInfo.DetailedState state = WifiInfo.getDetailedStateOf(supplicantState);
//        if (state.equals(NetworkInfo.DetailedState.CONNECTED)) {
//            mConnectStr = CONNECTED;
//        }

        if (wifiAdmin.getState() == 3) {
            ifOpen = true;
            wifiAdmin.startScan(SetWifiActivity.this);
        } else {
            ifOpen = false;
        }
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        try {
            if (mNetworkReceiver != null) {
                unregisterReceiver(mNetworkReceiver);
            }
        } catch (Exception e) {

        }
    }

    @Override
    public void onCheckedChanged(SwitchButton view, boolean isChecked) {
        ifOpen = isChecked;
        ifEnabel = false;
        if (isChecked) {
            wifiAdmin.openWifi(SetWifiActivity.this);
        } else {
            wifiAdmin.closeWifi(SetWifiActivity.this);
        }
        timer.start();
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (resultCode == 1001) {
            try {
                String mPwd = data.getExtras().getString(FlagConfig.WIFI_PWD);
                if (mPwd != null && mPwd.length() > 7) {
//                    wifiAdmin.removeWifi(wifiAdmin.IsExsits(mConnectSSID).networkId);
                    mConnectSSID = data.getExtras().getString(FlagConfig.WIFI_SSID);
                    wifiAdmin.addNetwork(wifiAdmin.CreateWifiInfo(mConnectSSID, mPwd, wifiAdmin.getCipherType(mConnectSSID)));
                }
            } catch (Exception e) {

            }
        } else if (resultCode == 1002) {
            mConnectSSID = data.getExtras().getString(FlagConfig.WIFI_SSID);
            wifiAdmin.removeWifi(wifiAdmin.IsExsits(mConnectSSID).networkId);
            mConnectSSID = "";
            mWifAdapter.notifyDataSetChanged();
        }
    }

    public class WifiAdapter extends RecyclerView.Adapter<WifiAdapter.MyHolder> {

        public WifiAdapter() {

        }

        @Override
        public MyHolder onCreateViewHolder(ViewGroup viewGroup, int i) {
            MyHolder view = null;
            if (getItemViewType(i) == 0) {
                view = new MyHolder(LayoutInflater.from(SetWifiActivity.this).inflate(R.layout.item_wifi_top, viewGroup, false));
            } else {
                view = new MyHolder(LayoutInflater.from(SetWifiActivity.this).inflate(R.layout.item_wifi_bottom, viewGroup, false));
            }
            return view;
        }

        @Override
        public void onBindViewHolder(MyHolder myHolder, final int i) {

            if (getItemViewType(i) == 0) {
                if (ifOpen) {
                    myHolder.switchButton.setChecked(true);
                } else {
                    myHolder.switchButton.setChecked(false);
                }
                myHolder.switchButton.setEnabled(ifEnabel);
                myHolder.switchButton.setOnCheckedChangeListener(SetWifiActivity.this);
            } else {
                final ScanResult scanResult = mlist.get(i - 1);
                myHolder.textName.setText(scanResult.SSID);
                myHolder.imgWifi.setImageResource(getWifiImg(scanResult.level));
                if (scanResult.SSID.equals(mConnectSSID) && !mConnectSSID.isEmpty()) {
                    myHolder.textType.setText(mConnectStr);
                    myHolder.textType.setTextColor(Color.parseColor("#39BE20"));
                } else {
                    myHolder.textType.setText(getCapabilities(scanResult.capabilities));
                    myHolder.textType.setTextColor(Color.parseColor("#3d3d3d"));
                }
                myHolder.relative.setOnClickListener(new View.OnClickListener() {
                    @Override
                    public void onClick(View v) {
                        if (mConnectSSID.equals(scanResult.SSID) && mConnectStr.equals(CONNECTED)) {
                            //已连接 是否删除网络
                            Intent intent = new Intent(SetWifiActivity.this, SetWifiDeleteActivity.class);
                            intent.putExtra(FlagConfig.WIFI_SSID, scanResult.SSID);
                            startActivityForResult(intent, 1002);
                        } else {
                            //未连接 开始连接
                            Intent intent = new Intent(SetWifiActivity.this, SetWifiAddActivity.class);
                            intent.putExtra(FlagConfig.WIFI_SSID, scanResult.SSID);
                            startActivityForResult(intent, 1001);
                        }
                    }
                });
            }
        }

        @Override
        public int getItemCount() {
            return mlist.size() + 1;
        }

        @Override
        public int getItemViewType(int position) {
            if (position == 0) {
                return 0;
            }
            return 1;
        }

        class MyHolder extends RecyclerView.ViewHolder {
            SwitchButton switchButton;
            TextView textName;
            TextView textType;
            ImageView imgWifi;
            RelativeLayout relative;

            public MyHolder(View itemView) {
                super(itemView);
                switchButton = itemView.findViewById(R.id.switchBtn);
                textName = itemView.findViewById(R.id.textName);
                textType = itemView.findViewById(R.id.textType);
                imgWifi = itemView.findViewById(R.id.imgWifi);
                relative = itemView.findViewById(R.id.relative);
            }
        }
    }

    /**
     * wifi广播监听
     */
    public class NetworkReceiver extends BroadcastReceiver {

        public static final int STATE1 = 1;//密码错误
        public static final int STATE2 = 2;//连接成功
        public static final int STATE3 = 3;//连接失败
        public static final int STATE4 = 4;//正在获取ip地址
        public static final int STATE5 = 5;//正在连接

        @Override
        public void onReceive(Context context, Intent intent) {
            if (WifiManager.SUPPLICANT_STATE_CHANGED_ACTION.equals(intent.getAction())) {
                //密码错误广播,是不是正在获得IP地址
                int linkWifiResult = intent.getIntExtra(WifiManager.EXTRA_SUPPLICANT_ERROR, -1);
                if (linkWifiResult == WifiManager.ERROR_AUTHENTICATING) {
                    //密码错误
                    Toast.makeText(SetWifiActivity.this, "认证失败", Toast.LENGTH_LONG).show();
//                    ToastUtils.showTipMsg(R.string.password_wrong);
//                    sendNetworkStateChange(new NetWorkInfo().setState(STATE1));
                    mConnectStr = CONNECTED_FAIL;
                }
                SupplicantState supplicantState = intent.getParcelableExtra(WifiManager.EXTRA_NEW_STATE);
                NetworkInfo.DetailedState state = WifiInfo.getDetailedStateOf(supplicantState);
                if (state == NetworkInfo.DetailedState.CONNECTING) {
                    //正在连接
                    mConnectStr = CONNECTED_ING;
//                    ToastUtils.showTipMsg(R.string.linking);
//                    sendNetworkStateChange(new NetWorkInfo().setState(STATE5));
                } else if (state == NetworkInfo.DetailedState.FAILED
                        || state == NetworkInfo.DetailedState.DISCONNECTING) {
                    //连接失败
                    mConnectStr = CONNECTED_FAIL;
//                    sendNetworkStateChange(new NetWorkInfo().setState(STATE3));
//                    ToastUtils.showTipMsg(R.string.linked_failed);
                } else if (state == NetworkInfo.DetailedState.CONNECTED) {
                    //连接成功
                    mConnectStr = CONNECTED;
//                    ToastUtils.showTipMsg(R.string.linked_success);
                } else if (state == NetworkInfo.DetailedState.OBTAINING_IPADDR) {
                    //正在获取ip地址
//                    mConnectStr = "正在获取ip地址";
//                    sendNetworkStateChange(new NetWorkInfo().setState(STATE4));
                } else if (state == NetworkInfo.DetailedState.IDLE) {
                    //闲置的
                    ConnectivityManager connectManager = (ConnectivityManager) SetWifiActivity.this
                            .getSystemService(Context.CONNECTIVITY_SERVICE);
                    NetworkInfo activeNetworkInfo = null;
                    if (connectManager != null) {
                        activeNetworkInfo = connectManager.getActiveNetworkInfo();
                    }
                    if (activeNetworkInfo == null) {
                        mConnectStr = CONNECTED_FAIL;
//                        sendNetworkStateChange(new NetWorkInfo().setState(STATE3));
//                        ToastUtils.showTipMsg(R.string.linked_failed);
                    }
                }
                connectingPos();
                mWifAdapter.notifyDataSetChanged();
            } else 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_DISABLING://正在停止0
//                        ToastUtils.showTipMsg(R.string.close_wifi);
                        break;
                    case WifiManager.WIFI_STATE_DISABLED://已停止1
                        mlist.clear();
                        mWifAdapter.notifyDataSetChanged();
                        break;
                    case WifiManager.WIFI_STATE_UNKNOWN://未知4
                        break;
                    case WifiManager.WIFI_STATE_ENABLING://正在打开2
//                        ToastUtils.showTipMsg(R.string.opening_wifi);
                        break;
                    case WifiManager.WIFI_STATE_ENABLED://已开启3

                        wifiAdmin.startScan(SetWifiActivity.this);
                        break;
                    default:
                        break;
                }
            } else if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction())) {
                // 监听wifi的连接状态即是否连上了一个有效无线路由
                Parcelable parcelableExtra = intent
                        .getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
                if (null != parcelableExtra) {
                    // 获取联网状态的NetWorkInfo对象
                    NetworkInfo networkInfo = (NetworkInfo) parcelableExtra;
                    //获取的State对象则代表着连接成功与否等状态
                    NetworkInfo.State state = networkInfo.getState();
                    //判断网络是否已经连接
                    boolean isConnected = state == NetworkInfo.State.CONNECTED;
//                    Log.v(Constants.HTTP_WZ, "isConnected:" + isConnected);
                    if (isConnected) {
                        mConnectSSID = networkInfo.getExtraInfo().replace("\"", "");
                        mConnectStr = CONNECTED;
                    } else {
                        mConnectStr = "";
                    }
                    mWifAdapter.notifyDataSetChanged();
                    mRecycleView.smoothScrollToPosition(0);
                }
            } else if (WifiManager.SCAN_RESULTS_AVAILABLE_ACTION.equals(intent.getAction())) {
                mlist = sortByLevel(wifiAdmin.getWifiList(SetWifiActivity.this));
                connectingPos();
                mWifAdapter.notifyDataSetChanged();
            }
        }
    }

    //将搜索到的wifi根据信号强度从强到弱进行排序
    private List<ScanResult> sortByLevel(List<ScanResult> resultList) {
        for (int i = 0; i < resultList.size(); i++)
            for (int j = 1; j < resultList.size(); j++) {
                if (resultList.get(i).level < resultList.get(j).level)    //level属性即为强度
                {
                    ScanResult temp = null;
                    temp = resultList.get(i);
                    resultList.set(i, resultList.get(j));
                    resultList.set(j, temp);
                }
            }
        return resultList;
    }

    /**
     * 判断信号强弱
     */
    private int getWifiImg(int level) {
        if (level <= 0 && level >= -50) {
            return R.mipmap.wifi05;
        } else if (level < -50 && level >= -70) {
            return R.mipmap.wifi04;
        } else if (level < -70 && level >= -80) {
            return R.mipmap.wifi03;
        } else if (level < -80 && level >= -100) {
            return R.mipmap.wifi02;
        }
        return R.mipmap.wifi01;
    }

    private String getCapabilities(String capabilities) {
        if (capabilities.contains("WPA") && capabilities.contains("WPA2")) {
            return "WPA/WPA2";
        }
        return "";
    }

    private void connectingPos() {
        for (int i = 0; i < mlist.size(); i++) {
            final ScanResult scanResult = mlist.get(i);
            if (mConnectSSID.equals(scanResult.SSID) && !mConnectSSID.isEmpty()) {
                Collections.swap(mlist, 0, i);
                return;
            }
        }
    }
}