Android（Java）：如何用非废弃API检测用户网络连接状态

必要权限配置 #

首先确保在AndroidManifest.xml中添加网络权限：

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

方案1：同步实时检测网络状态 #

适合在请求插屏广告前直接调用，同步检查当前是否有可用的互联网连接：

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;

public class NetworkUtils {

    public static boolean isConnectingToInternet(Context context) {
        ConnectivityManager connectivityManager = 
            (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        
        if (connectivityManager == null) {
            return false;
        }

        // 获取当前活跃网络
        Network activeNetwork = connectivityManager.getActiveNetwork();
        if (activeNetwork == null) {
            return false;
        }

        // 获取网络能力详情
        NetworkCapabilities networkCapabilities = 
            connectivityManager.getNetworkCapabilities(activeNetwork);
        
        if (networkCapabilities == null) {
            return false;
        }

        // 验证是否具备可访问互联网的有效连接
        return networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                && networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
    }
}

说明

• NET_CAPABILITY_VALIDATED是核心判断条件：它确保网络不仅已连接，还通过了互联网访问验证，避免连接到无法上网的Wi-Fi、VPN等无效网络，完全适配广告请求的场景需求。

方案2：缓存式网络状态监听（高效频繁调用） #

如果需要多次判断网络状态（比如频繁触发广告请求），可以用NetworkCallback监听网络变化并缓存状态，避免重复系统调用：

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkRequest;
import androidx.annotation.NonNull;

public class NetworkStatusManager {
    private static NetworkStatusManager instance;
    private boolean isNetworkAvailable;
    private ConnectivityManager.NetworkCallback networkCallback;

    private NetworkStatusManager(Context context) {
        ConnectivityManager connectivityManager = 
            (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        
        if (connectivityManager == null) {
            isNetworkAvailable = false;
            return;
        }

        // 初始化网络状态回调
        networkCallback = new ConnectivityManager.NetworkCallback() {
            @Override
            public void onAvailable(@NonNull Network network) {
                super.onAvailable(network);
                updateNetworkStatus(connectivityManager, network);
            }

            @Override
            public void onLost(@NonNull Network network) {
                super.onLost(network);
                isNetworkAvailable = false;
            }

            @Override
            public void onCapabilitiesChanged(@NonNull Network network, @NonNull NetworkCapabilities networkCapabilities) {
                super.onCapabilitiesChanged(network, networkCapabilities);
                isNetworkAvailable = networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                        && networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
            }
        };

        // 注册网络监听
        connectivityManager.registerNetworkCallback(
                new NetworkRequest.Builder()
                        .addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                        .build(),
                networkCallback);

        // 初始化当前网络状态
        Network activeNetwork = connectivityManager.getActiveNetwork();
        if (activeNetwork != null) {
            updateNetworkStatus(connectivityManager, activeNetwork);
        } else {
            isNetworkAvailable = false;
        }
    }

    private void updateNetworkStatus(ConnectivityManager manager, Network network) {
        NetworkCapabilities capabilities = manager.getNetworkCapabilities(network);
        isNetworkAvailable = capabilities != null 
                && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                && capabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
    }

    public static synchronized NetworkStatusManager getInstance(Context context) {
        if (instance == null) {
            instance = new NetworkStatusManager(context.getApplicationContext());
        }
        return instance;
    }

    public boolean isConnectingToInternet() {
        return isNetworkAvailable;
    }

    // 应用退出时注销回调，避免内存泄漏
    public void unregisterCallback(Context context) {
        ConnectivityManager connectivityManager = 
            (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (connectivityManager != null && networkCallback != null) {
            connectivityManager.unregisterNetworkCallback(networkCallback);
        }
    }
}

使用方式

1. 在Application或启动页初始化：

NetworkStatusManager networkManager = NetworkStatusManager.getInstance(getApplicationContext());

2. 广告请求前判断：

if (networkManager.isConnectingToInternet()) {
    // 请求插屏广告
}

3. 在应用销毁时注销回调（比如Application的onTerminate方法）：

networkManager.unregisterCallback(getApplicationContext());

内容的提问来源于stack exchange，提问作者Eldestornillador