Android网络状态监听实现

功能分析

背景介绍

为了给用户一个好的使用体验，尤其是一些视频、图片类型的app，我们经常需要在用户网络状态发生变化的时候给用户一些及时的提示，比如当前从Wi-Fi切换到GPRS，那么就需要给用户提示是否需要继续播放并会产生多少流量。对于网络状态变化的监听方法很简单，不管是用广播还是NetworkCallback都可以很好实现。本文从一个小架构的角度，尝试把网络状态的监听功能抽出封装成一个lib库，便于任何一个项目、版本使用。

功能分析

要监听网络状态发生变化，以及对于Android不同版本的支持，站在一个lib角度来实现该功能的话，我们就需要做到以下几点：

• 定义好网络的状态
• 根据不同版本使用不同的网络监听方法
• 让使用的地方尽可能的少集成即可使用该功能

网络状态定义

对于手机而言，我们关注的网络状态大体有三种：没网情况、Wi-Fi情况、移动蜂窝GPRS，对于状态的定义，我们要用到java的枚举类型来定义这些类型。

网络状态变化监听方法

• BroadcastReceiver

一开始的时候，我们可能都习惯于用BroadcastReceiver来监听网络状态的变化，BroadcastReceiver的注册分为静态manifest注册和动态注册，虽然通过manifest注册比较简单，但是在Android 7.0（targetSdkVersion >= 24）以后，新版本移除了一些隐式的广播，意味着7.0及以上版本无法通过manifest注册广播来监听网络状态变化，所以通过BroadcastReceiver的方式我们只能在代码中动态注册广播了。

• NetworkCallback

我们要做的功能时监听网络状态的变化，Android 21版本时增加了NetworkCallback类来监听网络状态的变化，源码如下：

public static class NetworkCallback {
    public NetworkCallback() {
        throw new RuntimeException("Stub!");
    }

    public void onAvailable(Network network) {//网络可用的时候调用
        throw new RuntimeException("Stub!");
    }

    public void onLosing(Network network, int maxMsToLive) {//网络正在减弱，链接会丢失数据，即将断开网络时调用
        throw new RuntimeException("Stub!");
    }

    public void onLost(Network network) {//网络断开时调用
        throw new RuntimeException("Stub!");
    }

    public void onUnavailable() {//网络缺失network时调用
        throw new RuntimeException("Stub!");
    }

    public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {//网络功能发生改变时调用
        throw new RuntimeException("Stub!");
    }

   //网络连接属性发生改变时调用
    public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
        throw new RuntimeException("Stub!");
    }
}

NetworkCallback的监听有两种方法：

• registerDefaultNetworkCallback(NetworkCallback callback) //Android API 26时加入

• registerNetworkCallback(NetworkRequest request,NetworkCallback callback) //Android API 21时加入

Android 官方建议API 28及以上通过NetworkCallback的方式来监听网络状态的变化

其他功能考虑

接收到消息变化了，接下来我们需要实现将变化的状态消息传递到使用的地方，这里就用到消息分发通信的机制了，我们有两个方案供选择：

• 通过接口

定义一个接口，每一个是用到的地方实现接口对象，并将该对象注册保存起来，在网络状态变化时调用即可。

• 通过EventBus那样的消息分发机制

像EventBus那样，通过消息分发机制，通过注解的标注，收集起需要接受状态变化的方法，在网络状态变化时通过反射调用执行。

网络状态有多个，可能在某些场景下，我们只需要关注切换到某一个状态的情况，以及对于代码书写和耦合性考虑，这里采用第二种方案。

代码实现

根据上面的分析，我们创建一个Android lib的module之后，有以下几个类元素需要写：

网络状态枚举

网络状态简单来说，可分为没网情况、Wi-Fi情况、移动蜂窝GPRS，详细分类的话，当然，详细分的话还可以分2G、3G、Wi-Fi没网情况，我们先知考虑简单的情况：

package com.anonyper.networkmonitor.bean;

/**
 * 网络状态枚举
 * AnnotationApplication
 * Created by anonyper on 2019/6/10.
 */
public enum NetWorkState {
    WIFI,//Wi-Fi网络
    GPRS,//移动蜂窝网络
    NONE//没有网络

}

标注注解

该注解是运行时，标注在方法上的：

@Retention(RetentionPolicy.RUNTIME)//运行时注解
@Target(ElementType.METHOD)//标记在方法上
public @interface NetWorkMonitor {
    //监听的网络状态变化 默认全部监听并提示
    NetWorkState[] monitorFilter() default {NetWorkState.GPRS, NetWorkState.WIFI, NetWorkState.NONE};
}

存储需要运行方法的对象

我们要收集起需要接受网络状态变化的方法对象，通过反射的方式来调用执行，和我们前面讲过的运行时注解一样，我们定义一个NetWorkStateReceiverMethod对象，里面包含：

• 该方法所属的对象
• 该方法的Method对象
• 该方法需要监听的网络状态变化类型，即上面注解的属性值：monitorFilter

这个里面我们没有写出方法需要的执行的参数，是因为监听网络状态变化接受的方法里面的参数有且仅有一个，就是当前的网络状态，所以我们不需要保存，同时也可以根据参数类型来过滤不必要的方法。

package com.anonyper.networkmonitor.bean;

import java.lang.reflect.Method;

/**
 * 保存接受状态变化的方法对象
 * AnnotationApplication
 * Created by anonyper on 2019/6/10.
 */
public class NetWorkStateReceiverMethod {
    /**
     * 网络改变执行的方法
     */
    Method method;
    /**
     * 网络改变执行的方法所属的类
     */
    Object object;
    /**
     * 监听的网络改变类型
     */
    NetWorkState[] netWorkState = {NetWorkState.GPRS, NetWorkState.WIFI, NetWorkState.NONE};

    public Method getMethod() {
        return method;
    }

    public void setMethod(Method method) {
        this.method = method;
    }

    public Object getObject() {
        return object;
    }

    public void setObject(Object object) {
        this.object = object;
    }

    public NetWorkState[] getNetWorkState() {
        return netWorkState;
    }

    public void setNetWorkState(NetWorkState[] netWorkState) {
        this.netWorkState = netWorkState;
    }
}

管理类

对外提供的统一的入口，所以我们这个管理类需要有以下几点功能：

• 全局单一
• 接受传入Application（注册广播，监听网络状态用）
• 提供注册和反注册入口
• 处理好不同版本网络监听的方法兼容
• 存储所有需要接受网络状态变化消息的方法
• 网络状态变化时，根据状态类型，通知对应的方法

源码如下：

package com.anonyper.networkmonitor;

import android.app.Application;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.LinkProperties;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkRequest;
import android.os.Build;

import com.anonyper.networkmonitor.annotation.NetWorkMonitor;
import com.anonyper.networkmonitor.bean.NetWorkState;
import com.anonyper.networkmonitor.bean.NetWorkStateReceiverMethod;
import com.anonyper.utillibrary.NetStateUtils;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

/**
 * AnnotationApplication
 * Created by anonyper on 2019/6/10.
 */
public class NetWorkMonitorManager {
    public static final String TAG = "NetWorkMonitor >>> : ";
    private static NetWorkMonitorManager ourInstance;
    private Application application;

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

    /**
     * 存储接受网络状态变化消息的方法的map
     */
    Map<Object, NetWorkStateReceiverMethod> netWorkStateChangedMethodMap = new HashMap<>();

    private NetWorkMonitorManager() {
    }

    /**
     * 初始化 传入application
     *
     * @param application
     */
    public void init(Application application) {
        if (application == null) {
            throw new NullPointerException("application can not be null");
        }
        this.application = application;
        initMonitor();
    }

    /**
     * 初始化网络监听 根据不同版本做不同的处理
     */
    private void initMonitor() {
        ConnectivityManager connectivityManager = (ConnectivityManager) this.application.getSystemService(Context.CONNECTIVITY_SERVICE);

        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {//API 大于26时
            connectivityManager.registerDefaultNetworkCallback(networkCallback);
        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {//API 大于21时
            NetworkRequest.Builder builder = new NetworkRequest.Builder();
            NetworkRequest request = builder.build();
            connectivityManager.registerNetworkCallback(request, networkCallback);
        } else {//低版本
            IntentFilter intentFilter = new IntentFilter();
            intentFilter.addAction(ANDROID_NET_CHANGE_ACTION);
            this.application.registerReceiver(receiver, intentFilter);
        }
    }

    /**
     * 反注册广播
     */
    private void onDestroy() {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.LOLLIPOP) {
            this.application.unregisterReceiver(receiver);
        }
    }

    /**
     * 注入
     * @param object
     */
    public void register(Object object) {
        if (this.application == null) {
            throw new NullPointerException("application can not be null,please call the method init(Application application) to add the Application");
        }
        if (object != null) {
            NetWorkStateReceiverMethod netWorkStateReceiverMethod = findMethod(object);
            if (netWorkStateReceiverMethod != null) {
                netWorkStateChangedMethodMap.put(object, netWorkStateReceiverMethod);
            }
        }
    }

    /**
     * 删除
     *
     * @param object
     */


    public void unregister(Object object) {
        if (object != null && netWorkStateChangedMethodMap != null) {
            netWorkStateChangedMethodMap.remove(object);
        }
    }

    /**
     * 网络状态发生变化，需要去通知更改
     * @param netWorkState
     */
    private void postNetState(NetWorkState netWorkState) {
        Set<Object> set = netWorkStateChangedMethodMap.keySet();
        Iterator iterator = set.iterator();
        while (iterator.hasNext()) {
            Object object = iterator.next();
            NetWorkStateReceiverMethod netWorkStateReceiverMethod = netWorkStateChangedMethodMap.get(object);
            invokeMethod(netWorkStateReceiverMethod, netWorkState);

        }
    }

    /**
     * 具体执行方法
     *
     * @param netWorkStateReceiverMethod
     * @param netWorkState
     */
    private void invokeMethod(NetWorkStateReceiverMethod netWorkStateReceiverMethod, NetWorkState netWorkState) {
        if (netWorkStateReceiverMethod != null) {
            try {
                NetWorkState[] netWorkStates = netWorkStateReceiverMethod.getNetWorkState();
                for (NetWorkState myState : netWorkStates) {
                    if (myState == netWorkState) {
                        netWorkStateReceiverMethod.getMethod().invoke(netWorkStateReceiverMethod.getObject(), netWorkState);
                        return;
                    }
                }

            } catch (IllegalAccessException e) {
                e.printStackTrace();
            } catch (InvocationTargetException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 找到对应的方法
     *
     * @param object
     * @return
     */
    private NetWorkStateReceiverMethod findMethod(Object object) {
        NetWorkStateReceiverMethod targetMethod = null;
        if (object != null) {
            Class myClass = object.getClass();
            //获取所有的方法
            Method[] methods = myClass.getDeclaredMethods();
            for (Method method : methods) {
                //如果参数个数不是1个 直接忽略
                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
                    if (method.getParameterCount() != 1) {
                        continue;
                    }
                }
                //获取方法参数
                Class[] parameters = method.getParameterTypes();
                if (parameters == null || parameters.length != 1) {
                    continue;
                }
                //参数的类型需要时NetWorkState类型
                if (parameters[0].getName().equals(NetWorkState.class.getName())) {
                    //是NetWorkState类型的参数
                    NetWorkMonitor netWorkMonitor = method.getAnnotation(NetWorkMonitor.class);
                    targetMethod = new NetWorkStateReceiverMethod();
                    //如果没有添加注解，默认就是所有网络状态变化都通知
                    if (netWorkMonitor != null) {
                        NetWorkState[] netWorkStates = netWorkMonitor.monitorFilter();
                        targetMethod.setNetWorkState(netWorkStates);
                    }
                    targetMethod.setMethod(method);
                    targetMethod.setObject(object);
                    //只添加第一个符合的方法
                    return targetMethod;
                }
            }
        }
        return targetMethod;
    }


    private static final String ANDROID_NET_CHANGE_ACTION = "android.net.conn.CONNECTIVITY_CHANGE";
    BroadcastReceiver receiver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            if (intent.getAction().equalsIgnoreCase(ANDROID_NET_CHANGE_ACTION)) {
                //网络发生变化 没有网络-0：WIFI网络1：4G网络-4：3G网络-3：2G网络-2
                int netType = NetStateUtils.getAPNType(context);
                NetWorkState netWorkState = NetWorkState.NONE;
                switch (netType) {
                    case 0://None
                        netWorkState = NetWorkState.NONE;
                        break;
                    case 1://Wifi
                        netWorkState = NetWorkState.WIFI;
                        break;
                    default://GPRS
                        netWorkState = NetWorkState.GPRS;
                        break;
                }
                postNetState(netWorkState);
            }
        }
    };


    ConnectivityManager.NetworkCallback networkCallback = new ConnectivityManager.NetworkCallback() {
        /**
         * 网络可用的回调连接成功
         */
        @Override
        public void onAvailable(Network network) {
            super.onAvailable(network);
            int netType = NetStateUtils.getAPNType(NetWorkMonitorManager.this.application);
            NetWorkState netWorkState = NetWorkState.NONE;
            switch (netType) {
                case 0://None
                    netWorkState = NetWorkState.NONE;
                    break;
                case 1://Wifi
                    netWorkState = NetWorkState.WIFI;
                    break;
                default://GPRS
                    netWorkState = NetWorkState.GPRS;
                    break;
            }
            postNetState(netWorkState);
        }

        /**
         * 网络不可用时调用和onAvailable成对出现
         */
        @Override
        public void onLost(Network network) {
            super.onLost(network);
            postNetState(NetWorkState.NONE);
        }

        /**
         * 在网络连接正常的情况下，丢失数据会有回调 即将断开时
         */
        @Override
        public void onLosing(Network network, int maxMsToLive) {
            super.onLosing(network, maxMsToLive);
        }

        /**
         * 网络功能更改 满足需求时调用
         * @param network
         * @param networkCapabilities
         */
        @Override
        public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {
            super.onCapabilitiesChanged(network, networkCapabilities);
        }

        /**
         * 网络连接属性修改时调用
         * @param network
         * @param linkProperties
         */
        @Override
        public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
            super.onLinkPropertiesChanged(network, linkProperties);
        }

        /**
         * 网络缺失network时调用
         */
        @Override
        public void onUnavailable() {
            super.onUnavailable();
        }
    };

}

里面引用的一个NetStateUtils类是网上找到关于网络的工具类：

/**
 * 获取当前的网络状态 ：没有网络-0：WIFI网络1：4G网络-4：3G网络-3：2G网络-2
 * 自定义
 *
 * @param context
 * @return
 */
public static int getAPNType(Context context) {
    //结果返回值
    int netType = 0;
    //获取手机所有连接管理对象
    ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
            .CONNECTIVITY_SERVICE);
    //获取NetworkInfo对象
    NetworkInfo networkInfo = manager.getActiveNetworkInfo();
    //NetworkInfo对象为空 则代表没有网络
    if (networkInfo == null) {
        return netType;
    }
    //否则 NetworkInfo对象不为空 则获取该networkInfo的类型
    int nType = networkInfo.getType();
    if (nType == ConnectivityManager.TYPE_WIFI) {
        //WIFI
        netType = 1;
    } else if (nType == ConnectivityManager.TYPE_MOBILE) {
        int nSubType = networkInfo.getSubtype();
        TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService
                (Context.TELEPHONY_SERVICE);
        //3G   联通的3G为UMTS或HSDPA 电信的3G为EVDO
        if (nSubType == TelephonyManager.NETWORK_TYPE_LTE
                && !telephonyManager.isNetworkRoaming()) {
            netType = 4;
        } else if (nSubType == TelephonyManager.NETWORK_TYPE_UMTS
                || nSubType == TelephonyManager.NETWORK_TYPE_HSDPA
                || nSubType == TelephonyManager.NETWORK_TYPE_EVDO_0
                && !telephonyManager.isNetworkRoaming()) {
            netType = 3;
            //2G 移动和联通的2G为GPRS或EGDE，电信的2G为CDMA
        } else if (nSubType == TelephonyManager.NETWORK_TYPE_GPRS
                || nSubType == TelephonyManager.NETWORK_TYPE_EDGE
                || nSubType == TelephonyManager.NETWORK_TYPE_CDMA
                && !telephonyManager.isNetworkRoaming()) {
            netType = 2;
        } else {
            netType = 2;
        }
    }
    return netType;
}

具体使用

在app的build.gradle中引入上述lib库，在app的Application中添加：

public class AnonyperApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        NetWorkMonitorManager.getInstance().init(this);
    }


}

然后在使用的地方：

@Override
protected void onStart() {
    super.onStart();
    NetWorkMonitorManager.getInstance().register(this);
}

@Override
protected void onDestroy() {
    super.onDestroy();
    NetWorkMonitorManager.getInstance().unregister(this);
}
//不加注解默认监听所有的状态，方法名随意，只需要参数是一个NetWorkState即可
//@NetWorkMonitor(monitorFilter = {NetWorkState.GPRS})//只接受网络状态变为GPRS类型的消息
public void onNetWorkStateChange(NetWorkState netWorkState) {
    Log.i("TAG", "onNetWorkStateChange >>> :" + netWorkState.name());
}

当然，需要在manifest中添加网络状态变化监听的权限：

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

关掉WIfi后log：

2019-06-11 19:45:34.825 13778-13809/com.anonyper.annotationapplication I/Anonyper >>>: onNetWorkStateChange >>> :NONE
2019-06-11 19:45:35.525 13778-13809/com.anonyper.annotationapplication I/Anonyper >>>: onNetWorkStateChange >>> :GPRS

以上，我们就完成了一个网络状态变化监听的lib库。