超媒网络 v3.0.0版本的 MD5 值为：e72248abb238993f421967424d9a9515

以下内容为反编译后的 NetworkUtils.java 源代码，内容仅作参考

package com.blankj.utilcode.util;

import android.annotation.SuppressLint;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.text.format.Formatter;
import android.util.Log;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresPermission;
import com.blankj.utilcode.util.Utils;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.InterfaceAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import p.a.y.e.a.s.e.net.k8;
public final class NetworkUtils {

    public static final class NetworkChangedReceiver extends BroadcastReceiver {
        private NetworkType lite_do;
        private Set<g> lite_if = new HashSet();

        public class a implements Runnable {
            public final g lite_static;

            public a(g gVar) {
                this.lite_static = gVar;
            }

            @Override
            @SuppressLint({"MissingPermission"})
            public void run() {
                int size = NetworkChangedReceiver.this.lite_if.size();
                NetworkChangedReceiver.this.lite_if.add(this.lite_static);
                if (size == 0 && NetworkChangedReceiver.this.lite_if.size() == 1) {
                    NetworkChangedReceiver.this.lite_do = NetworkUtils.lite_long();
                    Utils.lite_byte().registerReceiver(NetworkChangedReceiver.lite_do(), new IntentFilter("android.net.conn.CONNECTIVITY_CHANGE"));
                }
            }
        }

        public class b implements Runnable {
            public final g lite_static;

            public b(g gVar) {
                this.lite_static = gVar;
            }

            @Override
            public void run() {
                int size = NetworkChangedReceiver.this.lite_if.size();
                NetworkChangedReceiver.this.lite_if.remove(this.lite_static);
                if (size == 1 && NetworkChangedReceiver.this.lite_if.size() == 0) {
                    Utils.lite_byte().unregisterReceiver(NetworkChangedReceiver.lite_do());
                }
            }
        }

        public class c implements Runnable {
            public c() {
            }

            @Override
            public void run() {
                NetworkType lite_long = NetworkUtils.lite_long();
                if (NetworkChangedReceiver.this.lite_do == lite_long) {
                    return;
                }
                LogUtils.lite_class(lite_long);
                NetworkChangedReceiver.this.lite_do = lite_long;
                if (lite_long == NetworkType.NETWORK_NO) {
                    for (g gVar : NetworkChangedReceiver.this.lite_if) {
                        gVar.lite_if();
                    }
                    return;
                }
                for (g gVar2 : NetworkChangedReceiver.this.lite_if) {
                    gVar2.lite_do(lite_long);
                }
            }
        }

        public static class d {
            private static final NetworkChangedReceiver lite_do = new NetworkChangedReceiver();

            private d() {
            }
        }

        public static NetworkChangedReceiver lite_do() {
            return lite_new();
        }

        private static NetworkChangedReceiver lite_new() {
            return d.lite_do;
        }

        public void lite_byte(g gVar) {
            if (gVar == null) {
                return;
            }
            Utils.lite_const(new b(gVar));
        }

        public void lite_try(g gVar) {
            if (gVar == null) {
                return;
            }
            Utils.lite_const(new a(gVar));
        }

        @Override
        @SuppressLint({"MissingPermission"})
        public void onReceive(Context context, Intent intent) {
            if ("android.net.conn.CONNECTIVITY_CHANGE".equals(intent.getAction())) {
                Utils.lite_final(new c(), 1000L);
            }
        }
    }

    public enum NetworkType {
        NETWORK_ETHERNET,
        NETWORK_WIFI,
        NETWORK_4G,
        NETWORK_3G,
        NETWORK_2G,
        NETWORK_UNKNOWN,
        NETWORK_NO
    }

    public static class a extends Utils.g<Boolean> {
        public a(Utils.c cVar) {
            super(cVar);
        }

        @Override
        @RequiresPermission("android.permission.INTERNET")
        public Boolean lite_for() {
            return Boolean.valueOf(NetworkUtils.lite_catch());
        }
    }

    public static class b extends Utils.g<Boolean> {
        public final String lite_finally;

        public b(Utils.c cVar, String str) {
            super(cVar);
            this.lite_finally = str;
        }

        @Override
        @RequiresPermission("android.permission.INTERNET")
        public Boolean lite_for() {
            return Boolean.valueOf(NetworkUtils.lite_throw(this.lite_finally));
        }
    }

    public static class c extends Utils.g<Boolean> {
        public final String lite_finally;

        public c(Utils.c cVar, String str) {
            super(cVar);
            this.lite_finally = str;
        }

        @Override
        @RequiresPermission("android.permission.INTERNET")
        public Boolean lite_for() {
            return Boolean.valueOf(NetworkUtils.lite_final(this.lite_finally));
        }
    }

    public static class d extends Utils.g<Boolean> {
        public d(Utils.c cVar) {
            super(cVar);
        }

        @Override
        @RequiresPermission(allOf = {"android.permission.ACCESS_WIFI_STATE", "android.permission.INTERNET"})
        public Boolean lite_for() {
            return Boolean.valueOf(NetworkUtils.lite_return());
        }
    }

    public static class e extends Utils.g<String> {
        public final boolean lite_finally;

        public e(Utils.c cVar, boolean z) {
            super(cVar);
            this.lite_finally = z;
        }

        @Override
        @RequiresPermission("android.permission.INTERNET")
        public String lite_for() {
            return NetworkUtils.lite_try(this.lite_finally);
        }
    }

    public static class f extends Utils.g<String> {
        public final String lite_finally;

        public f(Utils.c cVar, String str) {
            super(cVar);
            this.lite_finally = str;
        }

        @Override
        @RequiresPermission("android.permission.INTERNET")
        public String lite_for() {
            return NetworkUtils.lite_for(this.lite_finally);
        }
    }

    public interface g {
        void lite_do(NetworkType networkType);

        void lite_if();
    }

    private NetworkUtils() {
        throw new UnsupportedOperationException("u can't instantiate me...");
    }

    public static void lite_boolean(g gVar) {
        NetworkChangedReceiver.lite_do().lite_try(gVar);
    }

    @RequiresPermission("android.permission.ACCESS_NETWORK_STATE")
    public static boolean lite_break() {
        NetworkInfo lite_do = lite_do();
        return lite_do != null && lite_do.isAvailable() && lite_do.getSubtype() == 13;
    }

    public static Utils.g<String> lite_byte(@NonNull boolean z, Utils.c<String> cVar) {
        Objects.requireNonNull(cVar, "Argument 'callback' of type Utils.Callback<String> (#1 out of 2, zero-based) is marked by @androidx.annotation.NonNull but got null for it");
        return Utils.lite_for(new e(cVar, z));
    }

    @RequiresPermission("android.permission.ACCESS_WIFI_STATE")
    public static String lite_case() {
        WifiManager wifiManager = (WifiManager) Utils.lite_byte().getSystemService("wifi");
        return wifiManager == null ? "" : Formatter.formatIpAddress(wifiManager.getDhcpInfo().ipAddress);
    }

    @RequiresPermission("android.permission.INTERNET")
    public static boolean lite_catch() {
        return lite_const() || lite_throw(null);
    }

    public static boolean lite_char() {
        TelephonyManager telephonyManager;
        try {
            telephonyManager = (TelephonyManager) Utils.lite_byte().getSystemService("phone");
        } catch (Exception e2) {
            Log.e("NetworkUtils", "getMobileDataEnabled: ", e2);
        }
        if (telephonyManager == null) {
            return false;
        }
        if (Build.VERSION.SDK_INT >= 26) {
            return telephonyManager.isDataEnabled();
        }
        Method declaredMethod = telephonyManager.getClass().getDeclaredMethod("getDataEnabled", new Class[0]);
        if (declaredMethod != null) {
            return ((Boolean) declaredMethod.invoke(telephonyManager, new Object[0])).booleanValue();
        }
        return false;
    }

    @RequiresPermission("android.permission.INTERNET")
    public static Utils.g<Boolean> lite_class(@NonNull Utils.c<Boolean> cVar) {
        Objects.requireNonNull(cVar, "Argument 'callback' of type Utils.Callback<Boolean> (#0 out of 1, zero-based) is marked by @androidx.annotation.NonNull but got null for it");
        return Utils.lite_for(new a(cVar));
    }

    @RequiresPermission("android.permission.INTERNET")
    public static boolean lite_const() {
        return lite_final("");
    }

    @RequiresPermission("android.permission.CHANGE_WIFI_STATE")
    public static void lite_default(boolean z) {
        WifiManager wifiManager = (WifiManager) Utils.lite_byte().getSystemService("wifi");
        if (wifiManager == null || z == wifiManager.isWifiEnabled()) {
            return;
        }
        wifiManager.setWifiEnabled(z);
    }

    @RequiresPermission("android.permission.ACCESS_NETWORK_STATE")
    private static NetworkInfo lite_do() {
        ConnectivityManager connectivityManager = (ConnectivityManager) Utils.lite_byte().getSystemService("connectivity");
        if (connectivityManager == null) {
            return null;
        }
        return connectivityManager.getActiveNetworkInfo();
    }

    @RequiresPermission("android.permission.INTERNET")
    public static void lite_double(Utils.c<Boolean> cVar) {
        lite_while("", cVar);
    }

    @RequiresPermission("android.permission.ACCESS_WIFI_STATE")
    public static String lite_else() {
        WifiManager wifiManager = (WifiManager) Utils.lite_byte().getSystemService("wifi");
        return wifiManager == null ? "" : Formatter.formatIpAddress(wifiManager.getDhcpInfo().netmask);
    }

    public static void lite_extends(g gVar) {
        NetworkChangedReceiver.lite_do().lite_byte(gVar);
    }

    @RequiresPermission("android.permission.INTERNET")
    public static boolean lite_final(String str) {
        if (TextUtils.isEmpty(str)) {
            str = "www.baidu.com";
        }
        try {
            return InetAddress.getByName(str) != null;
        } catch (UnknownHostException e2) {
            e2.printStackTrace();
            return false;
        }
    }

    @RequiresPermission("android.permission.INTERNET")
    public static Utils.g lite_float(@NonNull String str, Utils.c<Boolean> cVar) {
        Objects.requireNonNull(cVar, "Argument 'callback' of type Utils.Callback<Boolean> (#1 out of 2, zero-based) is marked by @androidx.annotation.NonNull but got null for it");
        return Utils.lite_for(new c(cVar, str));
    }

    @RequiresPermission("android.permission.INTERNET")
    public static String lite_for(String str) {
        try {
            return InetAddress.getByName(str).getHostAddress();
        } catch (UnknownHostException e2) {
            e2.printStackTrace();
            return "";
        }
    }

    public static String lite_goto() {
        TelephonyManager telephonyManager = (TelephonyManager) Utils.lite_byte().getSystemService("phone");
        return telephonyManager == null ? "" : telephonyManager.getNetworkOperatorName();
    }

    public static String lite_if() {
        try {
            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
            new LinkedList();
            while (networkInterfaces.hasMoreElements()) {
                NetworkInterface nextElement = networkInterfaces.nextElement();
                if (nextElement.isUp() && !nextElement.isLoopback()) {
                    List<InterfaceAddress> interfaceAddresses = nextElement.getInterfaceAddresses();
                    int size = interfaceAddresses.size();
                    for (int i = 0; i < size; i++) {
                        InetAddress broadcast = interfaceAddresses.get(i).getBroadcast();
                        if (broadcast != null) {
                            return broadcast.getHostAddress();
                        }
                    }
                    continue;
                }
            }
            return "";
        } catch (SocketException e2) {
            e2.printStackTrace();
            return "";
        }
    }

    @RequiresPermission("android.permission.ACCESS_NETWORK_STATE")
    public static boolean lite_import() {
        NetworkInfo lite_do = lite_do();
        return lite_do != null && lite_do.isConnected();
    }

    @RequiresPermission("android.permission.INTERNET")
    public static Utils.g<String> lite_int(@NonNull String str, Utils.c<String> cVar) {
        Objects.requireNonNull(cVar, "Argument 'callback' of type Utils.Callback<String> (#1 out of 2, zero-based) is marked by @androidx.annotation.NonNull but got null for it");
        return Utils.lite_for(new f(cVar, str));
    }

    @RequiresPermission("android.permission.ACCESS_NETWORK_STATE")
    public static NetworkType lite_long() {
        if (lite_native()) {
            return NetworkType.NETWORK_ETHERNET;
        }
        NetworkInfo lite_do = lite_do();
        if (lite_do == null || !lite_do.isAvailable()) {
            return NetworkType.NETWORK_NO;
        }
        if (lite_do.getType() == 1) {
            return NetworkType.NETWORK_WIFI;
        }
        if (lite_do.getType() == 0) {
            switch (lite_do.getSubtype()) {
                case 1:
                case 2:
                case 4:
                case 7:
                case 11:
                case 16:
                    return NetworkType.NETWORK_2G;
                case 3:
                case 5:
                case 6:
                case 8:
                case 9:
                case 10:
                case 12:
                case 14:
                case 15:
                case 17:
                    return NetworkType.NETWORK_3G;
                case 13:
                case 18:
                    return NetworkType.NETWORK_4G;
                default:
                    String subtypeName = lite_do.getSubtypeName();
                    return (subtypeName.equalsIgnoreCase("TD-SCDMA") || subtypeName.equalsIgnoreCase("WCDMA") || subtypeName.equalsIgnoreCase("CDMA2000")) ? NetworkType.NETWORK_3G : NetworkType.NETWORK_UNKNOWN;
            }
        }
        return NetworkType.NETWORK_UNKNOWN;
    }

    @RequiresPermission("android.permission.ACCESS_NETWORK_STATE")
    private static boolean lite_native() {
        NetworkInfo networkInfo;
        NetworkInfo.State state;
        ConnectivityManager connectivityManager = (ConnectivityManager) Utils.lite_byte().getSystemService("connectivity");
        if (connectivityManager == null || (networkInfo = connectivityManager.getNetworkInfo(9)) == null || (state = networkInfo.getState()) == null) {
            return false;
        }
        return state == NetworkInfo.State.CONNECTED || state == NetworkInfo.State.CONNECTING;
    }

    @RequiresPermission("android.permission.ACCESS_WIFI_STATE")
    public static String lite_new() {
        WifiManager wifiManager = (WifiManager) Utils.lite_byte().getSystemService("wifi");
        return wifiManager == null ? "" : Formatter.formatIpAddress(wifiManager.getDhcpInfo().gateway);
    }

    @RequiresPermission("android.permission.ACCESS_NETWORK_STATE")
    public static boolean lite_public() {
        NetworkInfo lite_do = lite_do();
        return lite_do != null && lite_do.isAvailable() && lite_do.getType() == 0;
    }

    @RequiresPermission(allOf = {"android.permission.ACCESS_WIFI_STATE", "android.permission.INTERNET"})
    public static boolean lite_return() {
        return lite_void() && lite_catch();
    }

    @RequiresPermission("android.permission.INTERNET")
    public static void lite_short(Utils.c<Boolean> cVar) {
        lite_float("", cVar);
    }

    @RequiresPermission(allOf = {"android.permission.ACCESS_WIFI_STATE", "android.permission.INTERNET"})
    public static Utils.g<Boolean> lite_static(@NonNull Utils.c<Boolean> cVar) {
        Objects.requireNonNull(cVar, "Argument 'callback' of type Utils.Callback<Boolean> (#0 out of 1, zero-based) is marked by @androidx.annotation.NonNull but got null for it");
        return Utils.lite_for(new d(cVar));
    }

    @RequiresPermission("android.permission.INTERNET")
    public static boolean lite_super() {
        return lite_throw("");
    }

    @RequiresPermission("android.permission.ACCESS_NETWORK_STATE")
    public static boolean lite_switch() {
        NetworkInfo activeNetworkInfo;
        ConnectivityManager connectivityManager = (ConnectivityManager) Utils.lite_byte().getSystemService("connectivity");
        return (connectivityManager == null || (activeNetworkInfo = connectivityManager.getActiveNetworkInfo()) == null || activeNetworkInfo.getType() != 1) ? false : true;
    }

    @RequiresPermission("android.permission.ACCESS_WIFI_STATE")
    public static String lite_this() {
        WifiManager wifiManager = (WifiManager) Utils.lite_byte().getSystemService("wifi");
        return wifiManager == null ? "" : Formatter.formatIpAddress(wifiManager.getDhcpInfo().serverAddress);
    }

    @RequiresPermission("android.permission.INTERNET")
    public static boolean lite_throw(String str) {
        if (TextUtils.isEmpty(str)) {
            str = "223.5.5.5";
        }
        return k8.lite_do(String.format("ping -c 1 %s", str), false).lite_do == 0;
    }

    public static void lite_throws() {
        Utils.lite_byte().startActivity(new Intent("android.settings.WIRELESS_SETTINGS").setFlags(268435456));
    }

    @RequiresPermission("android.permission.INTERNET")
    public static String lite_try(boolean z) {
        try {
            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
            LinkedList linkedList = new LinkedList();
            while (networkInterfaces.hasMoreElements()) {
                NetworkInterface nextElement = networkInterfaces.nextElement();
                if (nextElement.isUp() && !nextElement.isLoopback()) {
                    Enumeration<InetAddress> inetAddresses = nextElement.getInetAddresses();
                    while (inetAddresses.hasMoreElements()) {
                        linkedList.addFirst(inetAddresses.nextElement());
                    }
                }
            }
            Iterator it = linkedList.iterator();
            while (it.hasNext()) {
                InetAddress inetAddress = (InetAddress) it.next();
                if (!inetAddress.isLoopbackAddress()) {
                    String hostAddress = inetAddress.getHostAddress();
                    boolean z2 = hostAddress.indexOf(58) < 0;
                    if (z) {
                        if (z2) {
                            return hostAddress;
                        }
                    } else if (!z2) {
                        int indexOf = hostAddress.indexOf(37);
                        return indexOf < 0 ? hostAddress.toUpperCase() : hostAddress.substring(0, indexOf).toUpperCase();
                    }
                }
            }
            return "";
        } catch (SocketException e2) {
            e2.printStackTrace();
            return "";
        }
    }

    @RequiresPermission("android.permission.ACCESS_WIFI_STATE")
    public static boolean lite_void() {
        WifiManager wifiManager = (WifiManager) Utils.lite_byte().getSystemService("wifi");
        if (wifiManager == null) {
            return false;
        }
        return wifiManager.isWifiEnabled();
    }

    @RequiresPermission("android.permission.INTERNET")
    public static Utils.g<Boolean> lite_while(@NonNull String str, Utils.c<Boolean> cVar) {
        Objects.requireNonNull(cVar, "Argument 'callback' of type Utils.Callback<Boolean> (#1 out of 2, zero-based) is marked by @androidx.annotation.NonNull but got null for it");
        return Utils.lite_for(new b(cVar, str));
    }
}