Android即时网络监听(一)-BroadcastReceiver

通常我们在进行网络请求之前，会先进行网络状态判断，再决定是否进行网络请求，常用方法如下：

/**
* 判断网络是否可用
*
* @return true/false
*/
@SuppressLint("MissingPermission")
public static boolean isNetworkAvailable() {
    ConnectivityManager connMgr = (ConnectivityManager) NetworkListener.getInstance().getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
    if (connMgr == null) {
        return false;
    }
    NetworkInfo[] infos = connMgr.getAllNetworkInfo();
    if (infos != null) {
        for (NetworkInfo info : infos) {
            if (info.getState() == NetworkInfo.State.CONNECTED) {
                return true;
            }
        }
    }
    return false;
}

/**
* 获取当前网络类型
*
* @return NetType
*/
@SuppressLint("MissingPermission")
public static NetType getNetType() {
    ConnectivityManager connMgr = (ConnectivityManager) NetworkListener.getInstance().getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
    if (connMgr == null) {
        return NetType.NONE;
    }
    NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
    if (networkInfo == null) {
        return NetType.NONE;
    }
    int nType = networkInfo.getType();
    if (nType == ConnectivityManager.TYPE_MOBILE) {
        if ("cmnet".equals(networkInfo.getExtraInfo().toLowerCase())) {
            return NetType.CMNET;
        } else {
            return NetType.CMWAP;
        }
    } else if (nType == ConnectivityManager.TYPE_WIFI) {
        return NetType.WIFI;
    }
    return NetType.NONE;
}

但这种做法无法做到即时网络监听，例如在播放视频或下载文件过程中，网络状态发生变化，我们无法做到即时处理，解决方式有2种：
1、使用广播方式
2、使用ConnectivityManager.NetworkCallback方式
本次我们先使用广播监听的方式进行网络变化监听。
我们知道，网络状态发生变化的时候，系统会发出android.net.CONNECTIVITY_CHANGE广播，所以我们可以用监听此广播的方式来判断网络连接：
1、权限申请

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

2、创建常量

//网络连接改变广播
public static final String ANDROID_NET_CHANGE_ACTION = "android.net.conn.CONNECTIVITY_CHANGE";

3、定义枚举类，表示网络状态：

public enum NetType {
    //任意网络
    AUTO,
    //WIFI
    WIFI,
    CMNET,
    //手机上网
    CMWAP,
    //无网络
    NONE
}

4、定义网络监听接口

public interface NetChangeListener {
    /**
     * 已连接
     * @param netType NetType
     */
    void onConnect(NetType netType);

    /**
     * 连接断开
     */
    void onDisConnect();
}

5、创建广播接收者

public class NetworkStateReceiver extends BroadcastReceiver {
    private static final String TAG = "NetworkStateReceiver";
    private NetType netType;//网络类型
    private NetChangeListener listener;

    public NetworkStateReceiver() {
        //初始化网络连接状态
        this.netType = NetType.NONE;
    }

    public void setListener(NetChangeListener listener) {
        this.listener = listener;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent == null || intent.getAction() == null) {
            Log.e(TAG, "onReceive: 异常");
            return;
        }
        if (intent.getAction().equals(Constants.ANDROID_NET_CHANGE_ACTION)) {
            Log.d(TAG, "onReceive: 网络发生变化");
            //获取当前联网的网络类型
            netType = NetworkUtils.getNetType();
            if (NetworkUtils.isNetworkAvailable()) {
                Log.d(TAG, "onReceive: 网络连接成功");
                if (listener != null) {
                    listener.onConnect(netType);
                }
            } else {
                Log.e(TAG, "onReceive: 网络连接失败");
                if (listener != null) {
                    listener.onDisConnect();
                }
            }
        }
    }
}

6、定义NetworkListener类(单例)用于初始化监听

public class NetworkListener {
    private Context context;
    private NetworkStateReceiver receiver;

    /**
     * 私有化构造方法
     */
    private NetworkListener() {
        receiver = new NetworkStateReceiver();
    }

    private static final SingletonTemplate<NetworkListener> INSTANCE = new SingletonTemplate<NetworkListener>() {
        @Override
        protected NetworkListener create() {
            return new NetworkListener();
        }
    };

    public static NetworkListener getInstance() {
        return INSTANCE.get();
    }

    public Context getContext() {
        return context;
    }

    public void setListener(NetChangeListener listener) {
        receiver.setListener(listener);
    }

    /**
     * 初始化
     *
     * @param context context
     */
    @SuppressLint("MissingPermission")
    public void init(Context context) {
        this.context = context;
        IntentFilter filter = new IntentFilter();
        filter.addAction(Constants.ANDROID_NET_CHANGE_ACTION);
        context.registerReceiver(receiver, filter);
    }
}

7、使用：
Application中初始化：

NetworkListener.getInstance().init(this);

在需要监听的Activity中实现NetChangeListener接口，并在onCreate()中初始化NetworkListener，如下：

public class MainActivity extends AppCompatActivity implements NetChangeListener {
    private static final String TAG = "MainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        NetworkListener.getInstance().setListener(this);
    }

    @Override
    public void onConnect(NetType netType) {
        Log.d(TAG, "onConnect: 网络连接成功：状态_" + netType.name());
    }

    @Override
    public void onDisConnect() {
        Log.e(TAG, "onDisConnect: 网络连接断开");
    }
}

通过以上代码，我们可以实现在APP运行过程中实时监听网络连接状态，此方式使用广播监听结合接口回调实现。
但此种方式也有个缺点：我们每次需要进行网络监听都需要实现NetChangeListener这个接口，并且如果我们只需要对某一个网络连接如WIFI或者GPRS进行处理的话，也需要写很多判断代码，会显得比较繁琐，那么有没有一种更好的实现方式呢，当然有！我们可以借助注解的方式实现监听，下面我们来看一下具体操作：
1、自定义注解

@Target(ElementType.METHOD)//作用在方法之上
@Retention(RetentionPolicy.RUNTIME)//jvm运行时，通过反射获取该注解的值
public @interface Network {
    NetType netType();
}

2、每个类中可能有多个注解方法，那么我们需要将APP里所有添加注解的类放入一个全局的集合中

private Map<Object,List<MethodManager>> networkMap;

其中Key是类(Activity/Fragment)，Value是类中使用了注解的方法Method。MethodManager保存了符合要求的网络监听注解方法，可以根据方法的参数类型、网络类型来确定：

/**
 * 保存符合要求的网络监听注解方法
 * Created by ywd on 2019/6/12.
 */
public class MethodManager {
    //方法的类型(NetType)
    private Class<?> type;
    //网络类型(netType = NetType.WIFI)
    private NetType netType;
    //需要执行的方法(自动执行)
    private Method method;

    public MethodManager(Class<?> type, NetType netType, Method method) {
        this.type = type;
        this.netType = netType;
        this.method = method;
    }

    public Class<?> getType() {
        return type;
    }

    public void setType(Class<?> type) {
        this.type = type;
    }

    public NetType getNetType() {
        return netType;
    }

    public void setNetType(NetType netType) {
        this.netType = netType;
    }

    public Method getMethod() {
        return method;
    }

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

3、定义了集合之后，我们需要为Activity/Fragment添加注册和移除方法，该方法只在NetworkListener类中提供对外方法，核心实现需要在Receiver中：

/**
 * 网络监听
 * Created by ywd on 2019/6/5.
 */

public class NetworkListenerWithAnno {
    private Context context;
    private NetworkStateReceiverWithAnno receiver;

    /**
     * 私有化构造方法
     */
    private NetworkListenerWithAnno() {
        receiver = new NetworkStateReceiverWithAnno();
    }

    private static final SingletonTemplate<NetworkListenerWithAnno> INSTANCE = new SingletonTemplate<NetworkListenerWithAnno>() {
        @Override
        protected NetworkListenerWithAnno create() {
            return new NetworkListenerWithAnno();
        }
    };

    public static NetworkListenerWithAnno getInstance() {
        return INSTANCE.get();
    }

    public Context getContext() {
        return context;
    }

    /**
     * 初始化
     *
     * @param context context
     */
    @SuppressLint("MissingPermission")
    public void init(Context context) {
        this.context = context;
        IntentFilter filter = new IntentFilter();
        filter.addAction(Constants.ANDROID_NET_CHANGE_ACTION);
        context.registerReceiver(receiver, filter);
    }

    /**
     * 注册
     *
     * @param observer 观察者(Activity/Fragment)
     */
    public void registerObserver(Object observer) {
        receiver.registerObserver(observer);
    }

    /**
     * 解除注册
     *
     * @param observer 观察者(Activity/Fragment)
     */
    public void unRegisterObserver(Object observer) {
        receiver.unRegisterObserver(observer);
    }
}

Receiver中的实现：

/**
* 注册
* 获取Activity/Fragment中的注解方法并添加到networkList中
*
* @param observer 观察者(Activity/Fragment)
*/
public void registerObserver(Object observer) {
    List<MethodManager> methodList = networkMap.get(observer);
    if (methodList == null) {
        methodList = findAnnotationMethod(observer);
        networkMap.put(observer, methodList);
    }
}

/**
* 解除注册
*
* @param observer 观察者(Activity/Fragment)
*/
public void unRegisterObserver(Object observer) {
    if (!networkMap.isEmpty()) {
        networkMap.remove(observer);
    }
    Log.d(TAG, "unRegisterObserver:" + observer.getClass().getName() + "注销成功");
}

findAnnotationMethod(observer)方法为获取Activity/Fragment中的注解方法，可以在此类中进行过滤，具体实现如下：

/**
* 获取Activity/Fragment中的注解方法
* @param observer 观察者(Activity/Fragment)
* @return
*/
private List<MethodManager> findAnnotationMethod(Object observer) {
    List<MethodManager> methodList = new ArrayList<>();
    Class<?> clazz = observer.getClass();
    //获取Activity中的所有公有方法，包括其父类及其实现的接口的方法，因方法数过多，此处使用getDeclaredMethods()
    //Method[] methods = clazz.getMethods();
    //获取Activity中的所有方法，包括公共、保护、默认(包)访问和私有方法,当然也包括它所实现接口的方法，但不包括继承的方法
    Method[] methods = clazz.getDeclaredMethods();
    for (Method method : methods) {
        //获取方法的注解
        Network network = method.getAnnotation(Network.class);
        if (network == null) {
            continue;
        }
        //方法参数校验
        Class<?>[] parameterTypes = method.getParameterTypes();
        if (parameterTypes.length != 1) {
            throw new RuntimeException(method.getName() + "方法有且只有一个参数");
        }
        //参数类型校验
        String name = parameterTypes[0].getName();
        if (name.equals(NetType.class.getName())) {
            MethodManager methodManager = new MethodManager(parameterTypes[0], network.netType(), method);
            methodList.add(methodManager);
        }
    }
    return methodList;
}

获取到Activity/Fragment中的所有注解方法之后，就可以在网络发生变化时进行事件分发了，接下来我们在onReceive中进行处理：

if (intent == null || intent.getAction() == null) {
    Log.e(TAG, "onReceive: 异常");
    return;
}
if (intent.getAction().equals(Constants.ANDROID_NET_CHANGE_ACTION)) {
    Log.d(TAG, "onReceive: 网络发生变化");
    netType = NetworkUtils.getNetType();
    if (NetworkUtils.isNetworkAvailable()) {
        Log.d(TAG, "onReceive: 网络连接成功");
    } else {
        Log.e(TAG, "onReceive: 网络连接失败");
    }
    post(netType);
}

post方法实现：

/**
* 分发
*
* @param netType NetType
*/
private void post(NetType netType) {
    //Activity集合
    Set<Object> set = networkMap.keySet();
    for (Object observer : set) {
        //所有注解的方法
        List<MethodManager> methodList = networkMap.get(observer);
        if (methodList != null) {
            for (MethodManager methodManager : methodList) {
                //两者参数比较
                if (methodManager.getType().isAssignableFrom(netType.getClass())) {
                    switch (methodManager.getNetType()) {
                        case AUTO:
                            invoke(methodManager, observer, netType);
                            break;
                        case WIFI:
                            if (netType == NetType.WIFI || netType == NetType.NONE) {
                                invoke(methodManager, observer, netType);
                            }
                            break;
                        case CMWAP:
                            if (netType == NetType.CMWAP || netType == NetType.NONE) {
                                invoke(methodManager, observer, netType);
                            }
                            break;
                        case CMNET:
                            if (netType == NetType.CMNET || netType == NetType.NONE) {
                                invoke(methodManager, observer, netType);
                            }
                            break;
                    }
                }
            }
        }
    }
}

invoke方法:

/**
 * 在Activity中执行方法，参数为NetType
 *
 * @param methodManager
 * @param observer
 * @param netType
 */
private void invoke(MethodManager methodManager, Object observer, NetType netType) {
    try {
        methodManager.getMethod().invoke(observer, netType);
    } catch (IllegalAccessException | InvocationTargetException e) {
        e.printStackTrace();
    }
}

使用：

@Network(netType = NetType.WIFI)
public void onNetChanged(NetType netType) {
    Log.d(TAG, "onNetChanged: 网络发生改变" + netType.name());
}

可以看到，通过反射+注解形式，在使用上更加简洁，同时相比接口回调形式更加解耦。
注意：Android7.0为了提高用户体验和提升设备性能移除了这个隐式广播，所以利用静态注册的方式是不能接收到该广播的，如果需要使用广播方式监听网络变化可以使用动态注册的方式进行接收。
代码详见Demo
PS:本文为某平台公开课笔记，在此记录下，文中实现还可以再次进行优化。
另附使用ConnectivityManager.NetworkCallback方式实现网络监听：
详见
Android即时网络监听(二)-ConnectivityManager.NetworkCallback