Android 监听网络是否连接可用

   如果不需要实时性，网络是否连接的时间不需要精确的知晓，那么在使用Retrofit2.0发http协议的时候，在发之前判断一下就行了

  /**
         * 先判断网络连接状态和网络是否可用，放在回调那里好呢，还是放这里每次请求都去判断下网络是否可用好呢？
         * 如果放在请求前面太耗时了，如果放回掉提示的速度慢，要10秒钟请求超时后才提示。
         * 最后采取的方法是判断网络是否连接放在外面，网络是否可用放在回掉。
         */
        if (!NetworkUtils.isConnected()) {
            ToastUtils.showShortToast("网络连接已断开");
            if (target != null) {
                target.setState(AppConstants.STATE_ERROR);
            }
            return;
        }

  如果需要实时性，比如界面上有网络是否连接的UI图标，时刻显示当前的网络连接状态，那么就要使用一个Service,让它在后台通过ConnectivityManager监听网络的状态，为了保证这个Service不被杀死能一直监听，还需要使用Service的保活，保证Service即使被杀死也能立刻再重新调用起来。

public class MessageService extends Service {

    public final static ConnectReceiver conncetReceiver = new ConnectReceiver();

    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }

    @Override
    public void onCreate() {
        Log.d(TAG, "onCreate");
        super.onCreate();
        startGuardService();
        DeviceEngine.getInst().init( this.getApplicationContext() );


        IntentFilter filter = new IntentFilter();
        filter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
        filter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
        filter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
        filter.addAction(Intent.ACTION_SCREEN_ON);
        filter.addAction(Intent.ACTION_SCREEN_OFF);
        filter.addAction(Intent.ACTION_USER_PRESENT);
        filter.addAction("android.intent.action.USER_PRESENT");
        registerReceiver( conncetReceiver , filter);

        Notification notification = new Notification();
        notification.flags = Notification.FLAG_ONGOING_EVENT;
        notification.flags |= Notification.FLAG_NO_CLEAR;
        notification.flags |= Notification.FLAG_FOREGROUND_SERVICE;
        this.startForeground(1, notification);

    }

    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        Log.d(TAG, "ServiceDemo onStartCommand");
        flags = START_STICKY;
        return super.onStartCommand(intent, flags, startId);

    }

    @Override
    public void onDestroy() {
        Log.d(TAG, "onDestroy");
        super.onDestroy();
        Intent intent = new Intent( ACTION );
        sendBroadcast(intent);
        unregisterReceiver( conncetReceiver );
        Log.d(TAG, "sendBroadcast[" + ACTION + "]");
    }


    public void startGuardService()
    {
        Intent intent = new Intent();
        intent.setClass(this, GuardService.class);
        startService(intent);
    }



    private final static String TAG = "MessageService";
    public final static String ACTION = "com.luobeitech.automgr.guard.CONNECT_SERVICE";
}

public class ConnectReceiver extends BroadcastReceiver {

    private static Receiver receiver = null;
    public static void setReceiver( Receiver _receiver )
    {
        receiver = _receiver;
    }
    private final static String TAG = "ConnectReceiver";


    @Override
    public void onReceive(Context context, Intent intent) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);

        NetworkInfo info = null;
        String action = intent.getAction();
        if (action.equals(ConnectivityManager.CONNECTIVITY_ACTION)) {
            Log.d("mylog", "网络状态已经改变");
            info = connectivityManager.getActiveNetworkInfo();
            if(info != null && info.isAvailable()) {
                String name = info.getTypeName();
                Log.d("mylog", "当前网络名称：" + name);

//                if( receiver != null) {
////                    receiver.onConnect( context.getApplicationContext() , name );
//                }
            } else {
                Log.d("mylog", "没有可用网络");
//                if( receiver != null) {
//                    receiver.onDisconnect();
//                }
                EventBus.getDefault().post(new OnlineStateEvent(-1));
            }
        } else if (Intent.ACTION_SCREEN_ON.equals(action)) {
            // 开屏

            KeyguardManager mKeyguardManager = (KeyguardManager) context.getSystemService(Context.KEYGUARD_SERVICE);
            boolean flag = mKeyguardManager.inKeyguardRestrictedInputMode();
            if (flag) {
                BusinessUtil.getInst().lockScreenState = true;
            } else {
                BusinessUtil.getInst().lockScreenState = false;
            }
            Log.d("mylog", "开屏" + flag);
        } else if (Intent.ACTION_SCREEN_OFF.equals(action)) {
            // 锁屏
            BusinessUtil.getInst().lockScreenState = true;
            Log.d("mylog", "锁屏");
        } else if (Intent.ACTION_USER_PRESENT.equals(action)) {
            // 解锁
            BusinessUtil.getInst().lockScreenState = false;
            Log.d("mylog", "解锁");
        }

    }

    public interface Receiver {
        void onDisconnect();
        void onConnect(Context context, String name);
    }


}

关于线程保活的技术，会再写一个进行记录