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);
         }
     }

 }