CubeAoleyunSN/app/src/main/java/com/aoleyun/sn/utils/WiFiUtils.java

package com.aoleyun.sn.utils;

import android.annotation.SuppressLint;
import android.content.Context;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiManager;
import android.text.TextUtils;
import android.util.Log;

import com.aoleyun.sn.bean.WiFiAlias;
import com.aoleyun.sn.comm.CommonConfig;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;
import com.tencent.mmkv.MMKV;

import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.List;

/**
 * @author : fanhuitong
 * e-mail :
 * @date : 2021/10/25 10:20
 * desc   :
 * version: 1.0
 */
public class WiFiUtils {
    private static WiFiUtils sInstance;
    private static WifiManager mWifiManager;
    @SuppressLint("StaticFieldLeak")
    private Context mContext;
    private static String TAG = WiFiUtils.class.getSimpleName();

    public WiFiUtils(Context context) {
        this.mContext = context;
    }

    public static void init(Context context) {
        mWifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
        if (sInstance == null) {
            Log.e(TAG, "init: ");
            sInstance = new WiFiUtils(context);
        }
    }

    public static WiFiUtils getInstance() {
        if (sInstance == null) {
            throw new IllegalStateException("You must be init WiFiUtils first");
        }
        return sInstance;
    }

    /**
     * wifi是否打开
     *
     * @return
     */
    public boolean isWifiEnable() {
        boolean isEnable = false;
        if (mWifiManager != null) {
            if (mWifiManager.isWifiEnabled()) {
                isEnable = true;
            }
        }
        return isEnable;
    }

    /**
     * 打开WiFi
     */
    public void openWifi() {
        if (mWifiManager != null && !isWifiEnable()) {
            mWifiManager.setWifiEnabled(true);
        }
    }

    /**
     * 关闭WiFi
     */
    public void closeWifi() {
        if (mWifiManager != null && isWifiEnable()) {
            mWifiManager.setWifiEnabled(false);
        }
    }

    /**
     * 获取WiFi列表
     *
     * @return
     */
    public List<ScanResult> getWifiList() {
        List<ScanResult> resultList = new ArrayList<>();
        if (mWifiManager != null && isWifiEnable()) {
            resultList.addAll(mWifiManager.getScanResults());
        }
        return resultList;
    }


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

    /**
     * 无密码连接
     *
     * @param ssid
     */
    public void connectWifiNoPws(String ssid) {
//        mWifiManager.disableNetwork(mWifiManager.getConnectionInfo().getNetworkId());
        int netId = mWifiManager.addNetwork(getWifiConfig(ssid, "", false));
        mWifiManager.enableNetwork(netId, true);
    }

    /**
     * wifi设置
     *
     * @param ssid
     * @param pws
     * @param isHasPws
     */
    private static WifiConfiguration getWifiConfig(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);
        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) {
        List<WifiConfiguration> configs = mWifiManager.getConfiguredNetworks();
        for (WifiConfiguration config : configs) {
            if (config.SSID.equals("\"" + ssid + "\"")) {
                return config;
            }
        }
        return null;
    }


    synchronized public static void saveWiFiPasswd(List<WiFiAlias> passwd) {
        String jsonString = MMKV.mmkvWithID(CommonConfig.MMKV_ID, MMKV.MULTI_PROCESS_MODE).decodeString("WiFiPassword", "");
        Log.e(TAG, "saveWiFiPasswd: " + jsonString);
        Gson gson = new Gson();
        Type listType = new TypeToken<List<WiFiAlias>>() {
        }.getType();
        List<WiFiAlias> oldList = gson.fromJson(jsonString, listType);
        comparedWiFiAlias(oldList, passwd);
    }

    private static void comparedWiFiAlias(List<WiFiAlias> oldWiFiAlias, List<WiFiAlias> newWiFiAlias) {
        Log.e("comparedWiFiAlias", "oldWiFiAlias: " + oldWiFiAlias);
        Log.e("comparedWiFiAlias", "newWiFiAlias: " + newWiFiAlias);
        if (newWiFiAlias == null || newWiFiAlias.size() == 0) {
            if (oldWiFiAlias == null || oldWiFiAlias.size() == 0) {
                return;
            }
            for (WiFiAlias wiFiAlias : oldWiFiAlias) {
                WifiConfiguration tempConfig = isExist(wiFiAlias.getName());
                if (tempConfig != null) {
                    mWifiManager.removeNetwork(tempConfig.networkId);
                }
            }
        } else if (oldWiFiAlias == null || oldWiFiAlias.size() == 0) {
            for (WiFiAlias wiFiAlias : newWiFiAlias) {
                addWiFiNetwork(wiFiAlias);
            }
        } else {
            List<WiFiAlias> removedWiFiAlias = new ArrayList<>(oldWiFiAlias);
            List<WiFiAlias> addedWiFiAlias = new ArrayList<>();
            List<WiFiAlias> tempWiFiAlias = new ArrayList<>();
            for (WiFiAlias alias : newWiFiAlias) {
                if (oldWiFiAlias.contains(alias)) {
                    //减少的
                    removedWiFiAlias.remove(alias);
                    tempWiFiAlias.add(alias);
                } else {
                    //增加的
                    addedWiFiAlias.add(alias);
                }
            }
            Log.e("comparedWiFiAlias", "removedWiFiAlias: " + removedWiFiAlias);
            Log.e("comparedWiFiAlias", "addedWiFiAlias: " + addedWiFiAlias);
            if (removedWiFiAlias.size() != 0) {
                for (WiFiAlias alias : removedWiFiAlias) {
                    WifiConfiguration tempConfig = isExist(alias.getName());
                    if (tempConfig != null) {
                        mWifiManager.removeNetwork(tempConfig.networkId);
                        Log.e("comparedWiFiAlias", "removedWiFiAlias: " + alias.getName());
                    }
                }
            }
            Log.e("comparedWiFiAlias", "tempWiFiAlias: " + tempWiFiAlias);
            if (addedWiFiAlias.size() != 0) {
                for (WiFiAlias alias : tempWiFiAlias) {
                    if (!wifiSaved(alias.getName())) {
                        addWiFiNetwork(alias);
                    }
                }
                for (WiFiAlias alias : addedWiFiAlias) {
                    addWiFiNetwork(alias);
                }
            }
        }
        mWifiManager.reconnect();
    }

    private static void addWiFiNetwork(WiFiAlias alias) {
        int netId;
        if (TextUtils.isEmpty(alias.getPwd())) {
            netId = mWifiManager.addNetwork(getWifiConfig(alias.getName(), "", false));
        } else {
            netId = mWifiManager.addNetwork(getWifiConfig(alias.getName(), alias.getPwd(), true));
        }
        mWifiManager.enableNetwork(netId, true);
    }


    synchronized private static boolean wifiSaved(String ssid) {
        // 获取已保存wifi配置链表
        List<WifiConfiguration> configs = mWifiManager.getConfiguredNetworks();
        boolean saved = false;
        for (WifiConfiguration configuration : configs) {
            if (ssid.equals(configuration.SSID)) {
                saved = true;
            }
        }
        return saved;
    }
}