Android 开发工具类 19_NetworkStateReceiver

检测网络状态改变类：

1、注册网络状态广播；

2、检查网络状态；

3、注销网络状态广播；

4、获取当前网络状态，true为网络连接成功，否则网络连接失败；

5、注册网络连接观察者；

6、注销网络连接观察者。

import java.util.ArrayList;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.util.Log;

import com.example.androidnetworkdemo.observer.NetChangeObserver;
import com.example.androidnetworkdemo.utils.NetWorkUtil;
import com.example.androidnetworkdemo.utils.NetWorkUtil.NetType;

/**
 * 是一个检测网络状态改变的，需要配置 
 *         <receiver android:name="com.osrad.common.receiver.OSNetworkStateReceiver" >
 *          <intent-filter> 
 *              <action android:name="android.net.conn.CONNECTIVITY_CHANGE" /> 
 *              <action android:name="os.android.net.conn.CONNECTIVITY_CHANGE" />
 *          </intent-filter>
 *      </receiver>
 * 需要开启权限       <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" />
 *              <uses-permission android:name="android.permission.CHANGE_WIFI_STATE" />
 *              <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
 *              <uses-permission android:name="android.permission.ACCESS_WIFI_STATE" />
 */
public class NetworkStateReceiver extends BroadcastReceiver {
    
    private static Boolean networkAvailable = false;
    private static NetType netType;
    private static ArrayList<NetChangeObserver> netChangeObserverArrayList = new ArrayList<NetChangeObserver>();
    private final static String ANDROID_NET_CHANGE_ACTION = "android.net.conn.CONNECTIVITY_CHANGE";
    public final static String OS_ANDROID_NET_CHANGE_ACTION = "os.android.net.conn.CONNECTIVITY_CHANGE";
    private static BroadcastReceiver receiver;

    private static BroadcastReceiver getReceiver() {
        if (receiver == null) {
            receiver = new NetworkStateReceiver();
        }
        return receiver;
    }

    @Override
    public void onReceive(Context context, Intent intent) {
        receiver = NetworkStateReceiver.this;
        if (intent.getAction().equalsIgnoreCase(ANDROID_NET_CHANGE_ACTION) || intent.getAction().equalsIgnoreCase(OS_ANDROID_NET_CHANGE_ACTION)) {
            if (!NetWorkUtil.isNetworkAvailable(context)) {
                networkAvailable = false;
            } else {
                netType = NetWorkUtil.getAPNType(context);
                networkAvailable = true;
            }
            notifyObserver();
        }
    }

    /**
     * 注册网络状态广播
     * 
     * @param mContext
     */
    public static void registerNetworkStateReceiver(Context mContext) {
        
        IntentFilter filter = new IntentFilter();
        filter.addAction(OS_ANDROID_NET_CHANGE_ACTION);
        filter.addAction(ANDROID_NET_CHANGE_ACTION);
        mContext.getApplicationContext().registerReceiver(getReceiver(), filter);
    }

    /**
     * 检查网络状态
     * 
     * @param mContext
     */
    public static void checkNetworkState(Context mContext) {
        
        Intent intent = new Intent();
        intent.setAction(OS_ANDROID_NET_CHANGE_ACTION);
        mContext.sendBroadcast(intent);
    }

    /**
     * 注销网络状态广播
     * 
     * @param mContext
     */
    public static void unRegisterNetworkStateReceiver(Context mContext) {
        if (receiver != null) {
            try {
                mContext.getApplicationContext().unregisterReceiver(receiver);
            } catch (Exception e) {
                Log.d(NetworkStateReceiver.class.getName(), e.getMessage());
            }
        }

    }

    /**
     * 获取当前网络状态，true为网络连接成功，否则网络连接失败
     * 
     * @return
     */
    public static Boolean isNetworkAvailable() {
        return networkAvailable;
    }

    public static NetType getAPNType() {
        return netType;
    }

    private void notifyObserver() {

        for (int i = 0; i < netChangeObserverArrayList.size(); i++) {
            NetChangeObserver observer = netChangeObserverArrayList.get(i);
            if (observer != null) {
                if (isNetworkAvailable()) {
                    observer.onNetConnect(netType);
                } else {
                    observer.onNetDisconnect();
                }
            }
        }
    }

    /**
     * 注册网络连接观察者
     * 
     * @param observer 观察者实例
     */
    public static void registerObserver(NetChangeObserver observer) {
        if (netChangeObserverArrayList == null) {
            netChangeObserverArrayList = new ArrayList<NetChangeObserver>();
        }
        netChangeObserverArrayList.add(observer);
    }

    /**
     * 注销网络连接观察者
     * 
     * @param observer 观察者实例
     */
    public static void removeRegisterObserver(NetChangeObserver observer) {
        if (netChangeObserverArrayList != null) {
            netChangeObserverArrayList.remove(observer);
        }
    }

}

 检测网络改变的观察者

import com.example.androidnetworkdemo.utils.NetWorkUtil.NetType;

/**
 *  是检测网络改变的观察者
 */
public interface NetChangeObserver
{
    /**
     * 网络连接连接时调用
     */
    public void onNetConnect(NetType type);

    /**
     * 当前没有网络连接
     */
    public void onNetDisconnect();
}

调用示例

public class BaseApplication extends Application {
    
    private NetChangeObserver changeObserver = null;
    
    public static Activity currentActivity;
    
    @Override
    public void onCreate() {
        super.onCreate();
        // 做初始化操作
        doOnCreate();
    }
    
    /**
     * 此方法做初始化操作
     */
    private void doOnCreate() {
        // 声明observer注册到网络状态广播接收器中
        changeObserver = new NetChangeObserver() {
            @Override
            public void onNetConnect(NetType type) {
                BaseApplication.this.onNetConnect(type);
            }

            @Override
            public void onNetDisconnect() {
                BaseApplication.this.onNetDisconnect();
            }
        };
        // 注册网络状态监听对象
        NetworkStateReceiver.registerObserver(changeObserver);
    }
    
    /**
     * 当前没有网络连接
     */
    public void onNetDisconnect() {
        if (currentActivity != null && currentActivity instanceof BaseActivity) {
            ((BaseActivity)currentActivity).onNetDisconnect();
        }
    }

    /**
     * 网络连接连接时调用
     */
    protected void onNetConnect(NetType type) {
        if (currentActivity != null && currentActivity instanceof BaseActivity) {
            ((BaseActivity)currentActivity).onNetConnect(type);
        }
    }
    
}