Android获取网络连接状态新方法整理_Android

一. 问题背景

android12上，有的app模块判断当前网络的类型和连接状态时，还是使用的旧的api，导致返回的结果不准确，影响代码逻辑判断，本篇文章就这一问题，整理一下判断网络类型和连接状态的新方法。

二. 原因分析

在android 10以前的版本，大家都是通过networkinfo.java 的gettype()方法获取网络类型，通过isconnected()方法来判断是否连接上，判断网络连接的旧方法如下：

1.是否连接：

2. 网络类型

但是在android10之后，这些方法已过时，官方不推荐使用，我们先来看下官方的源码说明

左边是android10，右边是android9的源码 , 在10上已经标记deprecated，新加的注释也推荐了使用的api。

还有一个旧广播string connectivity_action = "android.net.conn.connectivity_change" 在android 9之后也废弃，不推荐使用，之前的使用方法：

看下官方说明：

官方标记deprecated，是避免在高版本的设备上获取返回的网络状态不对，并且给了推荐的api，以android10为一个分界点，之后的版本都推荐使用新的api方法。

三. 官方推荐api

官方推荐：监控 android 中的互联网连接，可以使用connectivitymanager类，这是一个允许您查询网络状态的系统服务类, 还有一个networkcapabilities类，代表活动网络的功能。

体使用方法如下：

registernetworkcallback()：此函数注册一个networkcallback对象来监听网络状态变化。它以一个networkcallback对象作为参数。
unregisternetworkcallback()：此函数取消注册以前注册的networkcallback对象。

接下来重点关注networkcallback中的回调方法描述

回调方法	描述
oncapabilitieschanged	当网络状态改变时回调，比如信号强度切换，或者连接上网络—>断开网络，或者 mobile网络切换到wifi网络，都会回调
onavailable	网络连接成功但不能判断该网络是否可以正常上网
onunavailable	当网络连接超时或网络请求达不到可用要求时调用
onblockedstatuschanged	当访问指定的网络被阻止或解除阻塞时调用
onlosing	当网络正在断开连接时调用
onlost	当网络已断开连接时调用
onlinkpropertieschanged	当网络连接的属性被修改时调用

接下来再说一下

networkcapabilities.java类中的net_capability_validated字段，描述为：

表示此网络上的连接已成功验证。例如，对于具有net_capability_internet的网络，这意味着已成功检测到internet连接。

通过实际log来描述说明一下：

1. 连接上可上网的wifi，可看到validated的标记：

2. 连接上需要认证和不能上网的wifi，找不到validated标记：

3. 用数据流量上网，可以看到validated的标记：

我们可以通过networkcapabilities.hascapability(networkcapabilities.net_capability_validated)这个方法作为（连接可以正常上网的网络）判断条件。进一步通过networkcapabilities.hastransport方法来判断当前的网络类型。

四. 使用方法

看代码更直接一点：

mainactivity.java

@suppresslint("newapi")
public class mainactivity extends appcompatactivity {
 
    private static final string tag = "connectmanager";
 
    private connectivitymanager networkservice;
 
    @override
    protected void oncreate(bundle savedinstancestate) {
        super.oncreate(savedinstancestate);
        setcontentview(r.layout.activity_main);
        networkservice = (connectivitymanager) this.getsystemservice(context.connectivity_service);
        if (networkservice != null) {
            //注册 networkcallback
            networkservice.registerdefaultnetworkcallback(networkcallback);
        }
    }
 
 
    /*
    * 测试网络工具类方法
    * */
    @override
    protected void onresume() {
        super.onresume();
        //log.e(tag,  "=====在onresume方法中判断 ： ismobilenetwork ：" + networkutils.ismobilenetwork(this));
        //log.e(tag,  "=====在onresume方法中判断 ： iswifinetwork ：" + networkutils.iswifinetwork(this));
        //log.e(tag,  "=====在onresume方法中判断 ： getconnectednetworktype ：" + networkutils.getconnectednetworktype(this));
    }
 
    @override
    protected void ondestroy() {
        super.ondestroy();
        if (networkservice != null && networkcallback != null) {
            networkservice.unregisternetworkcallback(networkcallback);
        }
    }
 
    private final connectivitymanager.networkcallback networkcallback = new connectivitymanager.networkcallback(){
        //当网络状态修改但仍旧是可用状态时调用
        @override
        public void oncapabilitieschanged(@nonnull network network, @nonnull networkcapabilities networkcapabilities) {
            super.oncapabilitieschanged(network, networkcapabilities);
            if (networkutils.isconnectedavailablenetwork(getbasecontext())) {
                log.d(tag, "oncapabilitieschanged ---> ====网络可正常上网===网络类型为： "+ networkutils.getconnectednetworktype(mainactivity.this));
            }
 
            //表明此网络连接验证成功
            if(networkcapabilities.hascapability(networkcapabilities.net_capability_validated)) {
                if (networkcapabilities.hastransport(networkcapabilities.transport_cellular)) {
                    log.d(tag, "===当前在使用mobile流量上网===");
                } else if (networkcapabilities.hastransport(networkcapabilities.transport_wifi)) {
                    log.d(tag, "====当前在使用wifi上网===");
                } else if (networkcapabilities.hastransport(networkcapabilities.transport_bluetooth)) {
                    log.d(tag, "=====当前使用蓝牙上网=====");
                } else if (networkcapabilities.hastransport(networkcapabilities.transport_ethernet)) {
                    log.d(tag, "=====当前使用以太网上网=====");
                } else if (networkcapabilities.hastransport(networkcapabilities.transport_vpn)) {
                    log.d(tag, "===当前使用vpn上网====");
                } else if (networkcapabilities.hastransport(networkcapabilities.transport_wifi_aware)) {
                    log.d(tag, "===表示此网络使用wi-fi感知传输====");
                } else if (networkcapabilities.hastransport(networkcapabilities.transport_lowpan)) {
                    log.d(tag, "=====表示此网络使用lowpan传输=====");
                } else if (networkcapabilities.hastransport(networkcapabilities.transport_usb)) {
                    log.d(tag, "=====表示此网络使用usb传输=====");
                }
            }
 
 
        }
 
        @override
        public void onavailable(@nonnull network network) {
            super.onavailable(network);
            log.e(tag, "==网络连接成功，通知可以使用的时候调用====onavailable===");
        }
 
        @override
        public void onunavailable() {
            log.e(tag, "==当网络连接超时或网络请求达不到可用要求时调用====onunavailable===");
            super.onunavailable();
        }
 
        @override
        public void onblockedstatuschanged(@nonnull network network, boolean blocked) {
            log.e(tag, "==当访问指定的网络被阻止或解除阻塞时调用===onblockedstatuschanged==");
            super.onblockedstatuschanged(network, blocked);
        }
 
        @override
        public void onlosing(@nonnull network network, int maxmstolive) {
            log.e(tag, "==当网络正在断开连接时调用===onlosing===");
            super.onlosing(network, maxmstolive);
        }
 
        @override
        public void onlost(@nonnull network network) {
            log.e(tag, "==当网络已断开连接时调用===onlost===");
            super.onlost(network);
        }
 
 
        @override
        public void onlinkpropertieschanged(@nonnull network network, @nonnull linkproperties linkproperties) {
            log.e(tag, "==当网络连接的属性被修改时调用===onlinkpropertieschanged===");
            super.onlinkpropertieschanged(network, linkproperties);
        }
    };
 
}

网络工具类networkutils.java

@suppresslint("newapi")
public class networkutils {
 
    private static final string tag = "connectmanager";
 
    /**
     * indicates this network uses a cellular transport.
     */
    public static final int transport_cellular = 0;
 
    /**
     * indicates this network uses a wi-fi transport.
     */
    public static final int transport_wifi = 1;
 
    /**
     * indicates this network uses a bluetooth transport.
     */
    public static final int transport_bluetooth = 2;
 
    /**
     * indicates this network uses an ethernet transport.
     */
    public static final int transport_ethernet = 3;
 
    /**
     * indicates this network uses a vpn transport.
     */
    public static final int transport_vpn = 4;
 
    /**
     * indicates this network uses a wi-fi aware transport.
     */
    public static final int transport_wifi_aware = 5;
 
    /**
     * indicates this network uses a lowpan transport.
     */
    public static final int transport_lowpan = 6;
 
    /**
     * indicates this network uses a test-only virtual interface as a transport.
     * @hide
     */
    public static final int transport_test = 7;
 
    /**
     * indicates this network uses a usb transport.
     */
    public static final int transport_usb = 8;
 
 
 
    /**
     * >= android 10（q版本）推荐
     *
     * 当前使用mobile流量上网
     */
    public static boolean ismobilenetwork(context context) {
        connectivitymanager cm = (connectivitymanager) context.getsystemservice(context.connectivity_service);
 
        network network = cm.getactivenetwork();
        if (null == network) {
            return false;
        }
 
        networkcapabilities capabilities = cm.getnetworkcapabilities(network);
        if (null == capabilities) {
            return false;
        }
        return capabilities.hastransport(networkcapabilities.transport_cellular)
                && capabilities.hascapability(networkcapabilities.net_capability_validated);
    }
 
 
    /**
     * >= android 10（q版本）推荐
     *
     * 当前使用wifi上网
     */
 
    public static boolean iswifinetwork(context context) {
        connectivitymanager cm = (connectivitymanager)context.getsystemservice(context.connectivity_service);
        network network = cm.getactivenetwork();
        if (null == network) {
            return false;
        }
        networkcapabilities capabilities = cm.getnetworkcapabilities(network);
        if (null == capabilities) {
            return false;
        }
        return capabilities.hastransport(networkcapabilities.transport_wifi)
                && capabilities.hascapability(networkcapabilities.net_capability_validated);
    }
 
 
    /**
     *  >= android 10（q版本）推荐
     *
     * 当前使用以太网上网
     */
    public static boolean isethernetnetwork(context context) {
        connectivitymanager cm = (connectivitymanager)context.getsystemservice(context.connectivity_service);
        network network = cm.getactivenetwork();
        if (null == network) {
            return false;
        }
        networkcapabilities capabilities = cm.getnetworkcapabilities(network);
        if (null == capabilities) {
            return false;
        }
        return capabilities.hastransport(networkcapabilities.transport_ethernet)
                && capabilities.hascapability(networkcapabilities.net_capability_validated);
    }
 
 
 
    /**
     * >= android 10（q版本）推荐
     *
     * networkcapabilities.net_capability_internet，表示此网络应该(maybe)能够访问internet
     *
     *  判断当前网络可以正常上网
     *  表示此连接此网络并且能成功上网。  例如，对于具有net_capability_internet的网络，这意味着已成功检测到internet连接。
     */
    public static boolean isconnectedavailablenetwork(context context) {
        connectivitymanager cm = (connectivitymanager)context.getsystemservice(context.connectivity_service);
        network network = cm.getactivenetwork();
        if (null == network) {
            return false;
        }
        networkcapabilities capabilities = cm.getnetworkcapabilities(network);
        if (null == capabilities) {
            return false;
        }
        return capabilities.hascapability(networkcapabilities.net_capability_internet)
                && capabilities.hascapability(networkcapabilities.net_capability_validated);
    }
 
 
    /**
     * >= android 10（q版本）推荐
     *
     * 获取成功上网的网络类型
     * value = {
     *    transport_cellular,   0 表示此网络使用蜂窝传输。
     *    transport_wifi,       1 表示此网络使用wi-fi传输。
     *    transport_bluetooth,  2 表示此网络使用蓝牙传输。
     *    transport_ethernet,   3 表示此网络使用以太网传输。
     *    transport_vpn,        4 表示此网络使用vpn传输。
     *    transport_wifi_aware, 5 表示此网络使用wi-fi感知传输。
     *    transport_lowpan,     6 表示此网络使用lowpan传输。
     *    transport_test,       7 指示此网络使用仅限测试的虚拟接口作为传输。
     *    transport_usb,        8 表示此网络使用usb传输
     * }
     */
    public static int getconnectednetworktype(context context) {
        connectivitymanager cm = (connectivitymanager)context.getsystemservice(context.connectivity_service);
        network network = cm.getactivenetwork();
        if (null == network) {
            return -1;
        }
        networkcapabilities capabilities = cm.getnetworkcapabilities(network);
        if (null == capabilities) {
            return -1;
        }
        if (capabilities.hascapability(networkcapabilities.net_capability_validated)) {
            if (capabilities.hastransport(networkcapabilities.transport_cellular)) {
                return networkcapabilities.transport_cellular;
            } else if (capabilities.hastransport(networkcapabilities.transport_wifi)) {
                return networkcapabilities.transport_wifi;
            } else if (capabilities.hastransport(networkcapabilities.transport_bluetooth)) {
                return networkcapabilities.transport_bluetooth;
            } else if (capabilities.hastransport(networkcapabilities.transport_ethernet)) {
                return networkcapabilities.transport_ethernet;
            } else if (capabilities.hastransport(networkcapabilities.transport_vpn)) {
                return networkcapabilities.transport_vpn;
            } else if (capabilities.hastransport(networkcapabilities.transport_wifi_aware)) {
                return networkcapabilities.transport_wifi_aware;
            } else if (capabilities.hastransport(networkcapabilities.transport_lowpan)) {
                return networkcapabilities.transport_lowpan;
            } else if (capabilities.hastransport(networkcapabilities.transport_usb)) {
                return networkcapabilities.transport_usb;
            }
        }
        return -1;
    }
}

android10之后，请使用新的api方法，工具类可以根据业务需求去扩展，供参考。