Android开发 ConnectivityManager

鬂已星星也 · 发表于 2020-6-22 17:50:00

版权声明

本文来自博客园，作者：观心静，转载请注明原文链接：https://www.cnblogs.com/guanxinjing/p/13178067.html

本文版权归作者和博客园共有，欢迎转载，但必须给出原文链接，并保留此段声明，否则保留追究法律责任的权利。

前言

　　ConnectivityManager类用于查询网络状态，并且也能被动监听网络状态的变化。

判断是否有网络

下面这个getActiveNetworkInfo 方法是过时的旧方法。这里记录一下，请注意如果获取到的是null，那么等于当前设备没有连接网络。注意这里是使用kotlin代码调用的（个人最近在切换到kotlin）

    private fun hasNetwork(): Boolean {
        val connectivity = getSystemService(CONNECTIVITY_SERVICE) as ConnectivityManager
        val networkInfo = connectivity.activeNetworkInfo
        return networkInfo != null && networkInfo.isAvailable //networkInfo如果是null也是没有网络
    }

新方法请使用getActiveNetwork，，同上如果获取到的是null，那么等于当前设备没有连接网络

    private fun hasNetwork2(): Boolean {
        var connectivityManager: ConnectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            val network = connectivityManager.activeNetwork
            return network != null //如果是null代表没有网络
        }
        return false
    }

判断外部网络是否连接

有时候WiFi连接了不等于外部网络也连接了，我们有时候需要判断外部网络。以前的都是教使用shell来ping外部网络来判断的。这多多少少有点过时了。这里我们可以直接通过连接网络来判断

代码

private fun hasExternalNetwork(application: Application): Boolean {
    var connectivityManager: ConnectivityManager = application.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
        val network = connectivityManager.activeNetwork
        if (network == null){
            return false
        }
        //这里创建2个验证网络连接的公共网络地址，你也可以按需多增加几个
        val urlList = listOf<String>("https://223.5.5.5/", //阿里
            "https://www.baidu.com/" //百度
        )
        var notConnectCount = 0
        urlList.forEach {
            try {
                val openConnection = network.openConnection(URL(it))
                openConnection.connect()
            } catch (e:IOException){
                notConnectCount++
                Log.e("zh", "无法连接")
            }
        }
        return notConnectCount < 2
    }
    return false
}

判断当前正在使用的网络类型

/**
 * 当前网络类型 1:WIFI 2:移动网络 0:未知
 */
private fun currentNetworkType():Int {
    val cm = App.app.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
    val activeNetwork = cm.activeNetwork
    activeNetwork?.let { network ->
        cm.getNetworkCapabilities(network)?.let { capabilities ->
            if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI)) {
                return 1
            } else if (capabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR)) {
                return 2
            }
        }
    }
    return 0
}

监听网络状态

如果你的需求只是关注是否有网络，你只需要关心 onAvailable回调（有网络时回调）与 onLost回调（无网络时回调）

private void networkListener() {
        ConnectivityManager connectivity = (ConnectivityManager) getContext().getApplicationContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkRequest.Builder builder = new NetworkRequest.Builder();
        NetworkRequest request = builder.addCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
                .addTransportType(NetworkCapabilities.TRANSPORT_WIFI)    //表示此网络使用Wi-Fi传输
                .addTransportType(NetworkCapabilities.TRANSPORT_CELLULAR)//表示此网络使用蜂窝传输
                .build();
        connectivity.registerNetworkCallback(request, new ConnectivityManager.NetworkCallback() {
            @Override
            public void onAvailable(Network network) {
                super.onAvailable(network);
                //网络可用
                ToastUtils.showShortToast("网络可用");
                Log.e("调试_临时_log", "this_onAvailable");

            }

            @Override
            public void onUnavailable() {
                super.onUnavailable();
                //如果在指定的超时时间内未找到网络，则调用
                Log.e("调试_临时_log", "this_onUnavailable");
            }

            @Override
            public void onLost(@NonNull Network network) {
                super.onLost(network);
                //当框架的网络严重中断或正常故障结束时调用
                Log.e("调试_临时_log", "this_onLost");
            }

            @Override
            public void onBlockedStatusChanged(@NonNull Network network, boolean blocked) {
                super.onBlockedStatusChanged(network, blocked);
                //当对指定网络的访问被阻止或取消阻止时调用
                Log.e("调试_临时_log", "this_onBlockedStatusChanged");
            }

            @Override
            public void onCapabilitiesChanged(@NonNull Network network, @NonNull NetworkCapabilities networkCapabilities) {
                super.onCapabilitiesChanged(network, networkCapabilities);
                //当网络连接到此请求的框架*更改功能但仍满足规定的需求时调用。
                boolean isInternet = networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);//获取是否能连接Internet网
                Log.e("调试_临时_log", "this_onCapabilitiesChanged : isInternet = " + isInternet);
            }

            @Override
            public void onLosing(@NonNull Network network, int maxMsToLive) {
                super.onLosing(network, maxMsToLive);
                //当网络即将断开时调用。通常与新替换网络的呼叫配对，
                //以实现优雅的切换。如果我们有严重损失*（损失而没有警告），则可能无法调用此方法。
                Log.e("调试_临时_log", "this_onLosing");
            }

            @Override
            public void onLinkPropertiesChanged(@NonNull Network network, @NonNull LinkProperties linkProperties) {
                super.onLinkPropertiesChanged(network, linkProperties);
                //当与该请求连接的框架网络更改时调用。
                Log.e("调试_临时_log", "this_onLinkPropertiesChanged");
            }
        });
    }

另外你可以在配置的时候addTransportType指定监听某个网络状态比如WiFi或者移动网络，NetworkCapabilities类里还有更多类型：

    /**
     * 表示此网络使用移动蜂窝传输。
     */
    public static final int TRANSPORT_CELLULAR = 0;

    /**
     *表示此网络使用Wi-Fi传输。
     */
    public static final int TRANSPORT_WIFI = 1;

    /**
     * 表示此网络使用蓝牙传输
     */
    public static final int TRANSPORT_BLUETOOTH = 2;

    /**
     * 表示此网络使用以太网传输。
     */
    public static final int TRANSPORT_ETHERNET = 3;

    /**
     * 指示此网络使用VPN传输。
     */
    public static final int TRANSPORT_VPN = 4;

    /**
     * 表示此网络使用支持 Wi-Fi Aware 的传输。
     */
    public static final int TRANSPORT_WIFI_AWARE = 5;

    /**
     * 表示此网络使用低功耗传输。
     */
    public static final int TRANSPORT_LOWPAN = 6;

Java写法的网络工具类

方便一些用java的开发，直接复制黏贴使用

import static android.content.Context.CONNECTIVITY_SERVICE;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import java.io.IOException;
import java.net.URL;
import java.net.URLConnection;

/**
 * 网络工具类
 */
public class NetworkUtil {

    /**
     * 检查是否有本地网络，这里的本地网络是指设备是否有连接Wifi网络，但是不保证此网络可以连接外部
     * @return
     */
    public static Boolean hasLocalityNetwork(Context context) {
        ConnectivityManager connectivity = (ConnectivityManager) context.getApplicationContext().getSystemService(CONNECTIVITY_SERVICE);
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            Network network = connectivity.getActiveNetwork();
            return network != null; //如果是null代表没有网络
        }
        return false;
    }

    /**
     * 检查是否有外部网络
     * @param context
     * @return
     */
    public static Boolean hasExternalNetwork(Context context) {
        ConnectivityManager connectivity = (ConnectivityManager) context.getApplicationContext().getSystemService(CONNECTIVITY_SERVICE);
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            Network network = connectivity.getActiveNetwork();
            if (network == null){
                return false;
            }
            //这里创建2个验证网络连接的公共网络地址，你也可以按需多增加几个
            String[] urlArray = {"https://223.5.5.5/", "https://www.baidu.com/"};
            int notConnectCount = 0;
            for (String item :urlArray){
                try {
                    URLConnection openConnection = network.openConnection(new URL(item));
                    openConnection.connect();
                } catch (IOException e){
                    notConnectCount++;
                }
            }
            return notConnectCount < 2;
        }
        return false;
    }
}

End