检查网络状态

    public class NetWorkStatus {
        private ConnectivityManager manager;//网络连接管理对象
        //网络类型标志
        public static final int NO_NETWORK = 0; //无网络
        public static final int WiFi = 1; //WiFi
        public static final int GPRS_2G = 2;//2G
        public static final int GPRS_3G = 3;//3G
        public static final int GPRS_4G = 4;//4G
        public static final int ETHERNET = 5;//以太网
        public NetWorkStatus(Context context) {
            //获取网络状态管理者对象
            manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            getNetWorkStatus();
        }

        /**
         * 获取网络状态
         * @return 网络连接状态  true  有网络  false 无网络
         */
        public boolean getNetWorkStatus() {
            boolean isNetWork = false;
            //wifi
            NetworkInfo wifiInfo = manager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
            if (wifiInfo != null) {
                NetworkInfo.State wifiState = wifiInfo.getState();
                if (wifiState.equals(NetworkInfo.State.CONNECTED)) {
                    isNetWork = true;
                }
            }
            //以太网
            NetworkInfo ethernetInfo = manager.getNetworkInfo(ConnectivityManager.TYPE_ETHERNET);
            if (ethernetInfo != null) {
                NetworkInfo.State ethernetState = ethernetInfo.getState();
                if (ethernetState.equals(NetworkInfo.State.CONNECTED)) {
                    isNetWork = true;
                }
            }

            //mobile
            NetworkInfo mobileInfo = manager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
            if (mobileInfo != null) {
                NetworkInfo.State mobileState = mobileInfo.getState();
                if (mobileState.equals(NetworkInfo.State.CONNECTED)) {
                    isNetWork = true;
                }
            }
            return isNetWork;
        }

        /**
         * 获取网络类型
         * @return 网络状态  0=无网络  1=WiFi  2=2G  3=3G  4=4G  5=以太网
         */
        public int getNetworkType() {
            int type = -1;
            if (getNetWorkStatus()) {//有网络
                NetworkInfo activeNetworkInfo = manager.getActiveNetworkInfo();
                int netWorkType = activeNetworkInfo.getType();
                if (netWorkType == ConnectivityManager.TYPE_WIFI) {//WiFi连接
                    type = WiFi;
                } else if (netWorkType == ConnectivityManager.TYPE_ETHERNET) {//以太网连接
                    type = ETHERNET;
                } else if (netWorkType == ConnectivityManager.TYPE_MOBILE) {//数据网络连接
                    int subtype = activeNetworkInfo.getSubtype();
                    if (subtype == TelephonyManager.NETWORK_TYPE_LTE) {//4G网络
                        type = GPRS_4G;
                    } else if (subtype == TelephonyManager.NETWORK_TYPE_UMTS) {//3G网络
                        type = GPRS_3G;
                    } else if (subtype == TelephonyManager.NETWORK_TYPE_GPRS || subtype == TelephonyManager.NETWORK_TYPE_EDGE) {//2G网络
                        type = GPRS_2G;
                    }
                }
            } else {//无网络
                type = NO_NETWORK;
            }
            return type;
        }
    }

  //******************************************************************************************//
    public class StatusBarSercive extends Service {
        private final String  TAG        = getClass().getName();
        private       boolean isAlive    = true;//控制线程 为true时线程循环  为false时线程停止循环
        private       int     lastStatus = -1;//记录上一次的网路状态 0  表示无网络 1表示 WiFi 2 表示2G 3 表示3G 4表示4G

        @Override
        public int onStartCommand(Intent intent, int flags, int startId) {
            return super.onStartCommand(intent, flags, startId);
        }

        @Nullable
        @Override
        public IBinder onBind(Intent intent) {
            return new updateNetWork(this);
        }

        public class updateNetWork extends Binder {
            private Context mContext;

            public updateNetWork(Context mContext) {
                this.mContext = mContext;
                //
                init(mContext);
            }

            private NetWorkStatus netWorkStatus; //网络状态类对象

            private void init(Context mContext) {
                netWorkStatus = new NetWorkStatus(mContext);
                new Thread(new Runnable() {
                    @Override
                    public void run() {
                        while (isAlive) {//循环更新网络状态
                            try {
                                Thread.sleep(1 * 1000);
                                //获取网络类型
                                int networkType = netWorkStatus.getNetworkType();
                                switch (networkType) {
                                    case NetWorkStatus.NO_NETWORK://无网络
                                        UpdateStatusByType(NetWorkStatus.NO_NETWORK);
                                        break;
                                    case NetWorkStatus.WiFi://WiFi连接
                                        UpdateStatusByType(NetWorkStatus.WiFi);
                                        break;
                                    case NetWorkStatus.ETHERNET://WiFi连接
                                        UpdateStatusByType(NetWorkStatus.ETHERNET);
                                        break;
                                    case NetWorkStatus.GPRS_2G://2G网
                                        UpdateStatusByType(NetWorkStatus.GPRS_2G);
                                        break;
                                    case NetWorkStatus.GPRS_3G://3G网
                                        UpdateStatusByType(NetWorkStatus.GPRS_3G);
                                        break;
                                    case NetWorkStatus.GPRS_4G://4G网
                                        UpdateStatusByType(NetWorkStatus.GPRS_4G);
                                        break;
                                }

                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }).start();
            }

            private StatusBarChangeListener listener;//状态监听接口对象

            /**
             * 设置状态栏监听
             *
             * @param listener 监听接口对象
             */
            public void setListener(StatusBarChangeListener listener) {
                this.listener = listener;
            }

            /**
             * 根据网络类型 更新网络状态
             * @param type 网络类型[NetWorkStatus中的常量 如:NetWorkStatus.NETWORK_DISCONN ]
             */
            private void UpdateStatusByType(int type) {
                if (listener != null){
                    listener.onNetworkChange(type);
                }
            }
        }

        /**
         * 状态栏变化的监听接口
         */
        public interface StatusBarChangeListener {
            void onNetworkChange(int networkType);
        }

        @Override
        public boolean onUnbind(Intent intent) {
            isAlive = false;
            return super.onUnbind(intent);
        }
    }
    //************************************************************************//
    使用
    1.
    @Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_rabbit_mq_arr);
    //绑定网络状态服务
    bindNetWorkService();
}

private ServiceConnection mConn;
private void bindNetWorkService() {
    mConn = new ServiceConnection() {
        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            StatusBarSercive.updateNetWork mUpdateNetWork = (StatusBarSercive.updateNetWork) service;
            mUpdateNetWork.setListener(new StatusBarSercive.StatusBarChangeListener() {
                @Override
                public void onNetworkChange(int networkType) {
                    switch (networkType) {
                        case NetWorkStatus.NO_NETWORK:
                            handlerNetWork.sendEmptyMessage(NETWORK_DISCONN);
                            break;
                        default:
                            handlerNetWork.sendEmptyMessage(NETWORK_CONN);
                            break;
                    }
                }
            });
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
        }
    };
    Intent intent = new Intent(MainActivity.this, StatusBarSercive.class);
    intent.setAction("com.fszn.network.networkSercive");
    bindService(intent, mConn, Service.BIND_AUTO_CREATE);
}
    2.
             @Override
        protected void onDestroy() {
            super.onDestroy();
            if (mConn != null) {
                unbindService(mConn);
            }
        }