代码如下

package com.example.commonui;

import android.Manifest;
import android.content.Context;
import android.content.pm.PackageManager;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkRequest;
import android.os.Build;
import android.telephony.TelephonyManager;
import android.util.Log;

import androidx.annotation.IntDef;
import androidx.annotation.NonNull;
import androidx.annotation.RequiresApi;
import androidx.core.app.ActivityCompat;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;

import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.processors.PublishProcessor;
import io.reactivex.rxjava3.schedulers.Schedulers;

public class NetworkManager {
    private String TAG = "xiaochangyan";
    private int cuNetWorkState;
    private boolean isConnected;
    public PublishProcessor<Integer> netWorkState = PublishProcessor.create();
    public PublishProcessor<Boolean> connected = PublishProcessor.create();
    private static NetworkManager networkManager;
    private boolean isStart;

    public NetworkManager() {
    }

    public static NetworkManager getInstance() {
        if (networkManager == null) {
            synchronized (NetworkManager.class) {
                if (networkManager == null) {
                    networkManager = new NetworkManager();
                }
            }
        }
        return networkManager;
    }

    public void start(Context context) {
        if (isStart) return;
        isStart = true;
        NetworkRequest.Builder builder = new NetworkRequest.Builder();
        NetworkRequest request = builder.build();
        ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        connMgr.registerNetworkCallback(request, new ConnectivityManager.NetworkCallback() {
            @RequiresApi(api = Build.VERSION_CODES.N)
            @Override
            public void onAvailable(@NonNull Network network) {
                super.onAvailable(network);
                isConnected = true;
                connected.onNext(true);
                Log.d(TAG, "onAvailable: 网络已连接");
                pingNetWork();
            }

            @Override
            public void onLost(@NonNull Network network) {
                super.onLost(network);
                isConnected = false;
                connected.onNext(false);
                Log.d(TAG, "onAvailable: 网络已断开");
            }

            @RequiresApi(api = Build.VERSION_CODES.N)
            @Override
            public void onCapabilitiesChanged(@NonNull Network network, @NonNull NetworkCapabilities networkCapabilities) {
                super.onCapabilitiesChanged(network, networkCapabilities);
                if (networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED)) {
                    cuNetWorkState = NetworkState.StrongNetWork;
                    if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                        Log.d(TAG, "onCapabilitiesChanged: 网络类型为wifi");
                    } else if (networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                        Log.d(TAG, "onCapabilitiesChanged: 蜂窝网络");
                        checkNDataNetworkType(context);
                    } else {
                        Log.d(TAG, "onCapabilitiesChanged: 其他网络");
                    }
                }
            }
        });
    }

    public boolean isNetworkConnected() {
        return isConnected;
    }

    public int getCuNetWorkState() {
        return cuNetWorkState;
    }

    private String getNetworkClass(Context context) {
        TelephonyManager mTelephonyManager = (TelephonyManager)
                context.getSystemService(Context.TELEPHONY_SERVICE);
        int networkType = mTelephonyManager.getNetworkType();
        switch (networkType) {
            case TelephonyManager.NETWORK_TYPE_GPRS:
            case TelephonyManager.NETWORK_TYPE_EDGE:
            case TelephonyManager.NETWORK_TYPE_CDMA:
            case TelephonyManager.NETWORK_TYPE_1xRTT:
            case TelephonyManager.NETWORK_TYPE_IDEN:
                return "2G";
            case TelephonyManager.NETWORK_TYPE_UMTS:
            case TelephonyManager.NETWORK_TYPE_EVDO_0:
            case TelephonyManager.NETWORK_TYPE_EVDO_A:
            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 "3G";
            case TelephonyManager.NETWORK_TYPE_LTE:
                return "4G";
            case TelephonyManager.NETWORK_TYPE_NR:
                return "5G";
            default:
                return "Unknown";
        }
    }

    private void pingNetWork() {
        Observable.create(emitter -> {
            Runtime runtime = Runtime.getRuntime();
            try {
                Process ipProcess = runtime.exec("ping -c 3 www.baidu.com");
                int value = ipProcess.waitFor();
                Log.i(TAG, "Process:" + value);
                if (value != 1) {
                    isConnected = false;
                    connected.onNext(false);
                }
            } catch (Exception ex) {
                ex.printStackTrace();
            }
        }).subscribeOn(Schedulers.io()).subscribe();
    }

    @RequiresApi(api = Build.VERSION_CODES.N)
    private void checkNDataNetworkType(Context context){
        TelephonyManager tm = (TelephonyManager) context
                .getSystemService(Context.TELEPHONY_SERVICE);
        if (ActivityCompat.checkSelfPermission(context, Manifest.permission.READ_PHONE_STATE) != PackageManager.PERMISSION_GRANTED) {
            return;
        }
        int type = tm.getDataNetworkType();
        switch (type) {
            case TelephonyManager.NETWORK_TYPE_GPRS: // 联通2g
            case TelephonyManager.NETWORK_TYPE_CDMA: // 电信2g
            case TelephonyManager.NETWORK_TYPE_EDGE: // 移动2g
            case TelephonyManager.NETWORK_TYPE_1xRTT:
            case TelephonyManager.NETWORK_TYPE_IDEN:
                cuNetWorkState = NetworkState.WeakNetWork;
                netWorkState.onNext(cuNetWorkState);
                break;
        }
    }

    @Retention(RetentionPolicy.SOURCE)
    @IntDef({
            NetworkState.StrongNetWork,
            NetworkState.WeakNetWork
    })
    public @interface NetworkState {
        int StrongNetWork = 1;
        int WeakNetWork = 2;
    }

}

权限

<uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.READ_PHONE_STATE" />