2025年04月24日17:47:15

wjc

2025-04-24 1402cca44aae4eef9509ea6051ace918e635d23f

 app/src/main/java/com/hdl/photovoltaic/utils/NetworkUtils.java

@@ -1,32 +1,246 @@
package com.hdl.photovoltaic.utils;

import static android.Manifest.permission.ACCESS_NETWORK_STATE;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkInfo;
import android.net.NetworkRequest;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.telephony.TelephonyManager;

import androidx.annotation.RequiresApi;
import androidx.annotation.RequiresPermission;

import com.hdl.photovoltaic.HDLApp;

import java.lang.ref.WeakReference;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.NetworkInterface;
import java.net.SocketException;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.Executors;


/**
 * Created by Tong on 2022/7/13.
 */
public class NetworkUtils {

    private static NetworkUtils mNetworkUtils;

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

    public interface OnNetworkStatusChangedListener {
        void onDisconnected();

        void onConnected(NetworkType networkType);
    }

    public static void init(Context context) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            NetworkCallbackImpl.getInstance().init(context);
        } else {
            NetworkChangedReceiver.getInstance().init(context);
        }
    }


    public static NetworkUtils getInstance() {
        if (null == mNetworkUtils) {
            synchronized (NetworkUtils.class) {
                if (null == mNetworkUtils) {
                    mNetworkUtils = new NetworkUtils();
                }
    public static void registerNetworkStatusChangedListener(final OnNetworkStatusChangedListener listener) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            NetworkCallbackImpl.getInstance().registerListener(listener);
        } else {
            NetworkChangedReceiver.getInstance().registerListener(listener);
        }


    }

    public static void unregisterListener(final OnNetworkStatusChangedListener listener) {

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            NetworkCallbackImpl.getInstance().unregisterListener(listener);
        } else {
            NetworkChangedReceiver.getInstance().unregisterListener(listener);
        }
    }

    public static final class NetworkChangedReceiver extends BroadcastReceiver {

        private WeakReference<Context> mContext;

        private NetworkChangedReceiver() {
        }

        private static class SingletonInstance {
            private static final NetworkChangedReceiver INSTANCE = new NetworkChangedReceiver();
        }

        public static NetworkChangedReceiver getInstance() {
            return SingletonInstance.INSTANCE;
        }

        private NetworkType mType;
        private final Set<OnNetworkStatusChangedListener> mListeners = new HashSet<>();

        public void init(Context context) {
            if (mContext == null) {
                getInstance().mContext = new WeakReference<>(context.getApplicationContext());
            }
        }
        return mNetworkUtils;

        @RequiresPermission(ACCESS_NETWORK_STATE)
        public void registerListener(final OnNetworkStatusChangedListener listener) {
            if (listener == null) return;
            Executors.newSingleThreadExecutor().execute(new Runnable() {
                @Override
                public void run() {
                    int preSize = mListeners.size();
                    mListeners.add(listener);
                    if (preSize == 0 && mListeners.size() == 1 && null != mContext.get()) {
                        mType = getNetworkType();
                        IntentFilter intentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
                        mContext.get().registerReceiver(NetworkChangedReceiver.getInstance(), intentFilter);
                    }

                }
            });

        }

        public boolean isRegistered(final OnNetworkStatusChangedListener listener) {
            if (listener == null) return false;
            return mListeners.contains(listener);
        }

        public void unregisterListener(final OnNetworkStatusChangedListener listener) {
            if (listener == null) return;
            Executors.newSingleThreadExecutor().execute(new Runnable() {
                @Override
                public void run() {
                    int preSize = mListeners.size();
                    mListeners.remove(listener);
                    if (preSize == 1 && mListeners.size() == 0 && mContext.get() != null) {
                        mContext.get().unregisterReceiver(NetworkChangedReceiver.getInstance());
                    }
                }
            });
        }

        @Override
        public void onReceive(Context context, Intent intent) {
            if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
                Executors.newSingleThreadExecutor().execute(new Runnable() {
                    @Override
                    public void run() {
                        NetworkType networkType = NetworkUtils.getNetworkType();
                        if (mType == networkType) return;
                        mType = networkType;
                        if (networkType == NetworkType.NETWORK_NO) {
                            for (OnNetworkStatusChangedListener listener : mListeners) {
                                listener.onDisconnected();
                            }
                        } else {
                            for (OnNetworkStatusChangedListener listener : mListeners) {
                                listener.onConnected(networkType);
                            }
                        }
                    }
                });
            }
        }


    }

    @RequiresPermission(ACCESS_NETWORK_STATE)
    private static boolean isEthernet() {
        final ConnectivityManager cm =
                (ConnectivityManager) HDLApp.getInstance().getSystemService(Context.CONNECTIVITY_SERVICE);
        if (cm == null) return false;
        final NetworkInfo info = cm.getNetworkInfo(ConnectivityManager.TYPE_ETHERNET);
        if (info == null) return false;
        NetworkInfo.State state = info.getState();
        if (null == state) return false;
        return state == NetworkInfo.State.CONNECTED || state == NetworkInfo.State.CONNECTING;
    }

    @RequiresPermission(ACCESS_NETWORK_STATE)
    public static NetworkType getNetworkType() {
        if (isEthernet()) {
            return NetworkType.NETWORK_ETHERNET;
        }
        NetworkInfo info = getActiveNetworkInfo();
        if (info != null && info.isAvailable()) {
            if (info.getType() == ConnectivityManager.TYPE_WIFI) {
                return NetworkType.NETWORK_WIFI;
            } else if (info.getType() == ConnectivityManager.TYPE_MOBILE) {
                switch (info.getSubtype()) {
                    case TelephonyManager.NETWORK_TYPE_GSM:
                    case TelephonyManager.NETWORK_TYPE_GPRS:
                    case TelephonyManager.NETWORK_TYPE_CDMA:
                    case TelephonyManager.NETWORK_TYPE_EDGE:
                    case TelephonyManager.NETWORK_TYPE_1xRTT:
                    case TelephonyManager.NETWORK_TYPE_IDEN:
                        return NetworkType.NETWORK_2G;

                    case TelephonyManager.NETWORK_TYPE_TD_SCDMA:
                    case TelephonyManager.NETWORK_TYPE_EVDO_A:
                    case TelephonyManager.NETWORK_TYPE_UMTS:
                    case TelephonyManager.NETWORK_TYPE_EVDO_0:
                    case TelephonyManager.NETWORK_TYPE_HSDPA:
                    case TelephonyManager.NETWORK_TYPE_HSUPA:
                    case TelephonyManager.NETWORK_TYPE_HSPA:
                    case TelephonyManager.NETWORK_TYPE_EVDO_B:
                    case TelephonyManager.NETWORK_TYPE_EHRPD:
                    case TelephonyManager.NETWORK_TYPE_HSPAP:
                        return NetworkType.NETWORK_3G;

                    case TelephonyManager.NETWORK_TYPE_IWLAN:
                    case TelephonyManager.NETWORK_TYPE_LTE:
                        return NetworkType.NETWORK_4G;
                    case 20:
                        return NetworkType.NETWORK_5G;
                    default:
                        String subtypeName = info.getSubtypeName();
                        if (subtypeName.equalsIgnoreCase("TD-SCDMA")
                                || subtypeName.equalsIgnoreCase("WCDMA")
                                || subtypeName.equalsIgnoreCase("CDMA2000")) {
                            return NetworkType.NETWORK_3G;
                        } else {
                            return NetworkType.NETWORK_UNKNOWN;
                        }
                }
            } else {
                return NetworkType.NETWORK_UNKNOWN;
            }
        }
        return NetworkType.NETWORK_NO;
    }


    @RequiresPermission(ACCESS_NETWORK_STATE)
    private static NetworkInfo getActiveNetworkInfo() {
        ConnectivityManager cm =
                (ConnectivityManager) HDLApp.getInstance().getSystemService(Context.CONNECTIVITY_SERVICE);
        if (cm == null) return null;
        return cm.getActiveNetworkInfo();
    }

    /**
@@ -34,7 +248,7 @@
     * 一：是wifi下；
     * 二：是移动网络下；
     */
    public String getIPAddress(Context context) {
    public static String getIPAddress(Context context) {
        NetworkInfo info = ((ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
        if (info != null && info.isConnected()) {
@@ -80,4 +294,110 @@
    }


    @RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
    private static class NetworkCallbackImpl extends ConnectivityManager.NetworkCallback {


        private final Set<OnNetworkStatusChangedListener> mListeners = new HashSet<>();
        private ConnectivityManager mConnectivityManager;

        private WeakReference<Context> mContext;

        public NetworkCallbackImpl() {
        }

        private static class SingletonInstance {
            private static final NetworkCallbackImpl INSTANCE = new NetworkCallbackImpl();
        }

        public static NetworkCallbackImpl getInstance() {
            return SingletonInstance.INSTANCE;
        }


        public void init(Context context) {
            if (mContext == null) {
                getInstance().mContext = new WeakReference<>(context.getApplicationContext());
            }
        }


        @RequiresPermission(ACCESS_NETWORK_STATE)
        public void registerListener(final OnNetworkStatusChangedListener listener) {
            if (listener == null || mContext == null || mContext.get() == null) return;

            Executors.newSingleThreadExecutor().execute(new Runnable() {

                @Override
                public void run() {
                    if (mContext.get() == null) return;
                    int preSize = mListeners.size();
                    mListeners.add(listener);
                    if (preSize == 0 && mListeners.size() == 1) {
                        NetworkRequest.Builder builder = new NetworkRequest.Builder();
                        NetworkRequest request = builder.build();
                        mConnectivityManager = (ConnectivityManager) mContext.get().getSystemService(Context.CONNECTIVITY_SERVICE);
                        mConnectivityManager.requestNetwork(request, getInstance());
                    }

                }
            });

        }


        public void unregisterListener(final OnNetworkStatusChangedListener listener) {
            if (listener == null) return;
            Executors.newSingleThreadExecutor().execute(new Runnable() {
                @Override
                public void run() {
                    int preSize = mListeners.size();
                    mListeners.remove(listener);
                    if (preSize == 1 && mListeners.size() == 0 && mConnectivityManager != null) {
                        mConnectivityManager.unregisterNetworkCallback(getInstance());
                    }
                }
            });
        }

        @Override
        public void onAvailable(Network network) {
            super.onAvailable(network);

            //网络连接
            Executors.newSingleThreadExecutor().execute(new Runnable() {
                @Override
                public void run() {
                    NetworkInfo networkInfo = mConnectivityManager.getNetworkInfo(network);
                    if (networkInfo != null) {
                        NetworkType networkType = getNetworkType();
                        for (OnNetworkStatusChangedListener listener : mListeners) {
                            listener.onConnected(networkType);
                        }
                    }

                }
            });

        }

        @Override
        public void onLost(Network network) {
            super.onLost(network);
            //网络已断开
            Executors.newSingleThreadExecutor().execute(new Runnable() {
                @Override
                public void run() {
                    for (OnNetworkStatusChangedListener listener : mListeners) {
                        listener.onDisconnected();
                    }
                }
            });
        }


    }


}