WifiAdmin.java 源代码

package utils;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.LinkProperties;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.net.NetworkRequest;
import android.net.wifi.ScanResult;
import android.net.wifi.WifiConfiguration;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.net.wifi.WifiNetworkSpecifier;
import android.net.wifi.WifiNetworkSuggestion;
import android.os.Build;
import android.os.Handler;
import android.os.PatternMatcher;
import android.support.v4.app.ActivityCompat;
import com.hichip.base.HiLog;
import com.kuaishou.weapon.p0.g;
import com.xiaomi.mipush.sdk.Constants;
import common.HiDataValue;
import java.util.ArrayList;
import java.util.List;

public class WifiAdmin {
    private ConnectivityManager connectivityManager;
    private Context context;
    private List<WifiConfiguration> mWifiConfiguration;
    public WifiInfo mWifiInfo;
    private List<ScanResult> mWifiList;
    WifiManager.WifiLock mWifiLock;
    public WifiManager mWifiManager;
    private int m_addNetworkQ_num = 0;
    private ConnectivityManager.NetworkCallback networkCallback;
    private ConnectivityManager.NetworkCallback networkCallback2;

    static int access$008(WifiAdmin wifiAdmin) {
        int i = wifiAdmin.m_addNetworkQ_num;
        wifiAdmin.m_addNetworkQ_num = i + 1;
        return i;
    }

    public WifiAdmin(Context context) {
        this.context = context;
        WifiManager wifiManager = (WifiManager) context.getSystemService("wifi");
        this.mWifiManager = wifiManager;
        this.mWifiInfo = wifiManager.getConnectionInfo();
    }

    public void openWifi() {
        if (this.mWifiManager.isWifiEnabled()) {
            return;
        }
        this.mWifiManager.setWifiEnabled(true);
    }

    public void closeWifi() {
        if (this.mWifiManager.isWifiEnabled()) {
            this.mWifiManager.setWifiEnabled(false);
        }
    }

    public int checkState() {
        return this.mWifiManager.getWifiState();
    }

    public void acquireWifiLock() {
        this.mWifiLock.acquire();
    }

    public void releaseWifiLock() {
        if (this.mWifiLock.isHeld()) {
            this.mWifiLock.acquire();
        }
    }

    public void creatWifiLock() {
        this.mWifiLock = this.mWifiManager.createWifiLock("Test");
    }

    public List<WifiConfiguration> getConfiguration() {
        return this.mWifiConfiguration;
    }

    public void connectConfiguration(int i) {
        if (i > this.mWifiConfiguration.size()) {
            return;
        }
        this.mWifiManager.enableNetwork(this.mWifiConfiguration.get(i).networkId, true);
    }

    public void startScan() {
        this.mWifiManager.startScan();
        this.mWifiList = this.mWifiManager.getScanResults();
        if (ActivityCompat.checkSelfPermission(this.context, g.g) != 0) {
            return;
        }
        this.mWifiConfiguration = this.mWifiManager.getConfiguredNetworks();
    }

    public List<ScanResult> getWifiList() {
        return this.mWifiList;
    }

    public StringBuilder lookUpScan() {
        StringBuilder sb = new StringBuilder();
        int i = 0;
        while (i < this.mWifiList.size()) {
            StringBuilder sb2 = new StringBuilder();
            sb2.append("Index_");
            int i2 = i + 1;
            sb2.append(new Integer(i2).toString());
            sb2.append(Constants.COLON_SEPARATOR);
            sb.append(sb2.toString());
            sb.append(this.mWifiList.get(i).toString());
            sb.append("/n");
            i = i2;
        }
        return sb;
    }

    public String getMacAddress() {
        WifiInfo wifiInfo = this.mWifiInfo;
        return wifiInfo == null ? "NULL" : wifiInfo.getMacAddress();
    }

    public String getBSSID() {
        WifiInfo wifiInfo = this.mWifiInfo;
        return wifiInfo == null ? "NULL" : wifiInfo.getBSSID();
    }

    public int getIPAddress() {
        WifiInfo wifiInfo = this.mWifiInfo;
        if (wifiInfo == null) {
            return 0;
        }
        return wifiInfo.getIpAddress();
    }

    public int getNetworkId() {
        WifiInfo wifiInfo = this.mWifiInfo;
        if (wifiInfo == null) {
            return 0;
        }
        return wifiInfo.getNetworkId();
    }

    public String getWifiInfo() {
        WifiInfo wifiInfo = this.mWifiInfo;
        return wifiInfo == null ? "NULL" : wifiInfo.toString();
    }

    public void addNetwork(WifiConfiguration wifiConfiguration) {
        int addNetwork = this.mWifiManager.addNetwork(wifiConfiguration);
        boolean enableNetwork = this.mWifiManager.enableNetwork(addNetwork, true);
        this.mWifiManager.reconnect();
        System.out.println("a--" + addNetwork);
        System.out.println("b--" + enableNetwork);
    }

    public void disconnectWifi(int i) {
        HiLog.e("");
        HiLog.e(Constants.COLON_SEPARATOR + this.mWifiManager.disableNetwork(i) + "::" + this.mWifiManager.disconnect());
    }

    public WifiConfiguration CreateWifiInfo(String str, String str2, int i) {
        WifiConfiguration wifiConfiguration = new WifiConfiguration();
        wifiConfiguration.allowedAuthAlgorithms.clear();
        wifiConfiguration.allowedGroupCiphers.clear();
        wifiConfiguration.allowedKeyManagement.clear();
        wifiConfiguration.allowedPairwiseCiphers.clear();
        wifiConfiguration.allowedProtocols.clear();
        wifiConfiguration.SSID = "\"" + str + "\"";
        WifiConfiguration IsExsits = IsExsits(str);
        if (IsExsits != null) {
            this.mWifiManager.removeNetwork(IsExsits.networkId);
        }
        if (i == 1) {
            wifiConfiguration.wepKeys[0] = "";
            wifiConfiguration.allowedKeyManagement.set(0);
            wifiConfiguration.wepTxKeyIndex = 0;
        }
        if (i == 2) {
            wifiConfiguration.hiddenSSID = true;
            wifiConfiguration.wepKeys[0] = "\"" + str2 + "\"";
            wifiConfiguration.allowedAuthAlgorithms.set(1);
            wifiConfiguration.allowedGroupCiphers.set(3);
            wifiConfiguration.allowedGroupCiphers.set(2);
            wifiConfiguration.allowedGroupCiphers.set(0);
            wifiConfiguration.allowedGroupCiphers.set(1);
            wifiConfiguration.allowedKeyManagement.set(0);
            wifiConfiguration.wepTxKeyIndex = 0;
        }
        if (i == 3) {
            wifiConfiguration.preSharedKey = "\"" + str2 + "\"";
            wifiConfiguration.hiddenSSID = true;
            wifiConfiguration.allowedAuthAlgorithms.set(0);
            wifiConfiguration.allowedGroupCiphers.set(2);
            wifiConfiguration.allowedKeyManagement.set(1);
            wifiConfiguration.allowedPairwiseCiphers.set(1);
            wifiConfiguration.allowedGroupCiphers.set(3);
            wifiConfiguration.allowedPairwiseCiphers.set(2);
            wifiConfiguration.status = 2;
        }
        return wifiConfiguration;
    }

    public WifiConfiguration IsExsits(String str) {
        List<WifiConfiguration> configuredNetworks;
        if (ActivityCompat.checkSelfPermission(this.context, g.g) == 0 && (configuredNetworks = this.mWifiManager.getConfiguredNetworks()) != null) {
            for (WifiConfiguration wifiConfiguration : configuredNetworks) {
                if (wifiConfiguration.SSID.equals("\"" + str + "\"")) {
                    return wifiConfiguration;
                }
            }
        }
        return null;
    }

    public void ddfasdf(Context context, String str, String str2, Handler handler) {
        WifiNetworkSuggestion.Builder builder = new WifiNetworkSuggestion.Builder();
        builder.setSsid("wifi-ap-ssid");
        builder.setWpa2Passphrase("wifi-ap-password");
        WifiNetworkSuggestion build = builder.build();
        ArrayList arrayList = new ArrayList();
        arrayList.add(build);
        WifiManager wifiManager = (WifiManager) context.getSystemService("wifi");
        wifiManager.removeNetworkSuggestions(new ArrayList());
        wifiManager.addNetworkSuggestions(arrayList);
    }

    public void addNetwork1_Q(final String str, String str2, final Handler handler) {
        ConnectivityManager.NetworkCallback networkCallback;
        HiLog.e("" + Build.VERSION.SDK_INT + "::" + str + "::" + str2);
        if (Build.VERSION.SDK_INT < 29) {
            return;
        }
        WifiNetworkSpecifier.Builder builder = new WifiNetworkSpecifier.Builder();
        builder.setSsid(str);
        builder.setWpa2Passphrase(str2);
        WifiNetworkSpecifier build = builder.build();
        NetworkRequest.Builder builder2 = new NetworkRequest.Builder();
        builder2.addTransportType(1);
        builder2.addCapability(14);
        builder2.removeCapability(12);
        builder2.removeCapability(16);
        builder2.setNetworkSpecifier(build);
        NetworkRequest build2 = builder2.build();
        HiLog.e("");
        ConnectivityManager connectivityManager = this.connectivityManager;
        if (connectivityManager != null && (networkCallback = this.networkCallback) != null) {
            connectivityManager.unregisterNetworkCallback(networkCallback);
            ConnectivityManager.NetworkCallback networkCallback2 = this.networkCallback2;
            if (networkCallback2 != null) {
                this.connectivityManager.unregisterNetworkCallback(networkCallback2);
            }
            if (Build.VERSION.SDK_INT >= 29) {
                this.connectivityManager.bindProcessToNetwork(null);
            }
            this.connectivityManager = null;
            this.networkCallback = null;
            this.networkCallback2 = null;
        }
        HiLog.e("");
        this.m_addNetworkQ_num = 0;
        ConnectivityManager connectivityManager2 = (ConnectivityManager) this.context.getSystemService("connectivity");
        this.connectivityManager = connectivityManager2;
        if (connectivityManager2 != null) {
            ConnectivityManager.NetworkCallback networkCallback3 = new ConnectivityManager.NetworkCallback() {
                @Override
                public void onAvailable(Network network) {
                    WifiAdmin.access$008(WifiAdmin.this);
                    HiLog.e("Got the following address: not address");
                    HiDataValue.mHi_wifiConnect_Q = str;
                    Handler handler2 = handler;
                    if (handler2 != null) {
                        handler2.sendEmptyMessage(121);
                    }
                    if (Build.VERSION.SDK_INT >= 29 && WifiAdmin.this.connectivityManager != null) {
                        WifiAdmin.this.connectivityManager.bindProcessToNetwork(network);
                    }
                    super.onAvailable(network);
                }

                @Override
                public void onUnavailable() {
                    HiLog.e("");
                    HiDataValue.mHi_wifiConnect_Q = "";
                    Handler handler2 = handler;
                    if (handler2 != null) {
                        handler2.sendEmptyMessage(118);
                    }
                    super.onUnavailable();
                }

                @Override
                public void onLosing(Network network, int i) {
                    HiLog.e("");
                    super.onLosing(network, i);
                }

                @Override
                public void onLost(Network network) {
                    WifiAdmin.access$008(WifiAdmin.this);
                    HiLog.e("");
                    HiDataValue.mHi_wifiConnect_Q = "";
                    if (handler != null) {
                        if (WifiAdmin.this.m_addNetworkQ_num < 6) {
                            handler.sendEmptyMessage(120);
                        } else {
                            handler.sendEmptyMessage(119);
                        }
                    }
                    if (Build.VERSION.SDK_INT >= 29 && WifiAdmin.this.connectivityManager != null) {
                        WifiAdmin.this.connectivityManager.bindProcessToNetwork(null);
                    }
                    super.onLost(network);
                }

                @Override
                public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {
                    HiLog.e("");
                    super.onCapabilitiesChanged(network, networkCapabilities);
                    HiLog.d("net status change! 网络连接改变");
                    if (networkCapabilities.hasCapability(16)) {
                        if (networkCapabilities.hasTransport(1)) {
                            HiLog.d("当前在使用WiFi上网");
                        } else if (networkCapabilities.hasTransport(0)) {
                            HiLog.d("当前在使用数据网络上网");
                        } else {
                            HiLog.d("当前在使用其他网络");
                        }
                    }
                }

                @Override
                public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
                    HiLog.e("");
                    super.onLinkPropertiesChanged(network, linkProperties);
                }

                @Override
                public void onBlockedStatusChanged(Network network, boolean z) {
                    HiLog.e("");
                    super.onBlockedStatusChanged(network, z);
                }
            };
            this.networkCallback = networkCallback3;
            this.connectivityManager.requestNetwork(build2, networkCallback3);
            ConnectivityManager.NetworkCallback networkCallback4 = new ConnectivityManager.NetworkCallback() {
                @Override
                public void onAvailable(Network network) {
                    super.onAvailable(network);
                    if (Build.VERSION.SDK_INT < 29 || WifiAdmin.this.connectivityManager == null) {
                        return;
                    }
                    WifiAdmin.this.connectivityManager.bindProcessToNetwork(network);
                }

                @Override
                public void onLost(Network network) {
                    HiLog.e("");
                    if (Build.VERSION.SDK_INT >= 29 && WifiAdmin.this.connectivityManager != null) {
                        WifiAdmin.this.connectivityManager.bindProcessToNetwork(null);
                    }
                    super.onLost(network);
                }
            };
            this.networkCallback2 = networkCallback4;
            this.connectivityManager.registerNetworkCallback(build2, networkCallback4);
        }
    }

    public void addNetwork2_Q(String str, String str2) {
        ConnectivityManager.NetworkCallback networkCallback;
        if (Build.VERSION.SDK_INT >= 29) {
            NetworkRequest build = new NetworkRequest.Builder().addTransportType(1).removeCapability(12).setNetworkSpecifier(new WifiNetworkSpecifier.Builder().setSsidPattern(new PatternMatcher(str, 1)).setWpa2Passphrase(str2).build()).build();
            ConnectivityManager connectivityManager = this.connectivityManager;
            if (connectivityManager != null && (networkCallback = this.networkCallback) != null) {
                connectivityManager.unregisterNetworkCallback(networkCallback);
                this.connectivityManager = null;
                this.networkCallback = null;
            }
            HiLog.e("");
            this.connectivityManager = (ConnectivityManager) this.context.getSystemService("connectivity");
            ConnectivityManager.NetworkCallback networkCallback2 = new ConnectivityManager.NetworkCallback() {
                @Override
                public void onAvailable(Network network) {
                    HiLog.e("");
                }

                @Override
                public void onUnavailable() {
                    HiLog.e("");
                }
            };
            this.networkCallback = networkCallback2;
            this.connectivityManager.requestNetwork(build, networkCallback2);
        }
    }

    public void removeNetwork_Q() {
        this.m_addNetworkQ_num = 0;
        if (this.connectivityManager == null || this.networkCallback == null) {
            return;
        }
        HiLog.e("");
        this.connectivityManager.unregisterNetworkCallback(this.networkCallback);
        ConnectivityManager.NetworkCallback networkCallback = this.networkCallback2;
        if (networkCallback != null) {
            this.connectivityManager.unregisterNetworkCallback(networkCallback);
        }
        if (Build.VERSION.SDK_INT >= 29) {
            this.connectivityManager.bindProcessToNetwork(null);
        }
        this.connectivityManager = null;
        this.networkCallback = null;
        this.networkCallback2 = null;
        HiDataValue.mHi_wifiConnect_Q = "";
    }

    public void ddaf() {
        if (Build.VERSION.SDK_INT >= 23) {
            ConnectivityManager connectivityManager = (ConnectivityManager) this.context.getSystemService("connectivity");
            HiLog.e("");
            for (Network network : connectivityManager.getAllNetworks()) {
                NetworkInfo networkInfo = connectivityManager.getNetworkInfo(network);
                HiLog.e(networkInfo.getType() + "::" + networkInfo.getTypeName() + "::" + networkInfo.toString());
            }
        }
    }
}