4大组件

BroadcastReceiver

可以注册广播来监听网络变化，主要用的是BroadcastReceiver来监听系统的消息。
网络状态变化的Action是”android.net.conn.CONNECTIVITY_CHANGE”
需要权限：
需要用到ConnectivityManager类来得到网络信息类NetworkInfo，然后可以networkInfo.isAvailable()；判断网络。

public class MainActivity extends Activity {
    private MyBroadcastReceiver myBroadcastReceiver;
    private IntentFilter intentFilter;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        intentFilter=new IntentFilter();
        intentFilter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
        myBroadcastReceiver=new MyBroadcastReceiver();
        registerReceiver(myBroadcastReceiver, intentFilter);
    }
    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        unregisterReceiver(myBroadcastReceiver);
    }
    private class MyBroadcastReceiver extends BroadcastReceiver{

        @Override
        public void onReceive(Context context, Intent intent) {
            ConnectivityManager connectivityManager=(ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo=connectivityManager.getActiveNetworkInfo();
            if(networkInfo.isAvailable()&&networkInfo!=null){
                Toast.makeText(getApplicationContext(), "有网络", 0).show();
            }else{
                Toast.makeText(getApplicationContext(), "没有网络", 0).show();
            }
        }

    }
}

广播是可以跨进程的，只要监听广播的Action就可以接收到。
sendOrderdBroadcast(intent,null)可以发送有序广播，设置广播的priority可以设置广播的优先级，按照优先级发送广播。
abortBroadcast()可以拦截广播。

本地广播
由于安全性的问题，如果想要只在本应用中使用广播，可以使用LocalBroadcastManager发送本地广播。
本地广播是无法静态注册的，不可以在清单文件中注册。

public class MainActivity extends Activity {
    private Button btn;
    private LocalBroadcastManager localBroadcastManager;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        localBroadcastManager = LocalBroadcastManager.getInstance(this);
        btn=(Button) findViewById(R.id.btn);
        btn.setOnClickListener(new OnClickListener() {

            @Override
            public void onClick(View v) {
                Intent intent=new Intent();
                intent.setAction("com.example.mybroadcastrecevierdemo.guangbo");
                localBroadcastManager.sendBroadcast(intent);
            }
        });
        IntentFilter intentFilter=new IntentFilter();
        intentFilter.addAction("com.example.mybroadcastrecevierdemo.guangbo");
        MyBroadcastReceiver broadcastReceiver=new MyBroadcastReceiver();
        localBroadcastManager.registerReceiver(broadcastReceiver,intentFilter);
    }

    private  class MyBroadcastReceiver extends BroadcastReceiver {

        @Override
        public void onReceive(Context context, Intent intent) {
            Toast.makeText(context, "收到广播", 0).show();
        }
    }
}

Service

如果想要启动一个服务来执行一些耗时操作，执行完关闭服务。
那么可以在自定义的Service的onStartCommand()方法中执行，这个方法在Service的onCreate()创建之后就会执行。
在onStartCommand()中开启一个子线程(因为Service也是运行在主线程中的，耗时操作要放在子线程)，然后在run(){}方法执行的最后，stopSelf()就可以在子线程结束后关闭服务。

后台定时任务
//总体来说就是Activity中开启服务，服务定义定时器任务并执行，而且隔一段时间去通知广播接收者，让广播接收者再去开始服务，这样循环就完成了一个后台的定时任务。
//首先在Activity中开启了服务

public class MainActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Intent intent=new Intent(this,MySerive.class);
        startService(intent);
    }
}

//然后在服务中定义一个定时器AlarmManager 执行任务；定义好一个固定时间；然后用Intent，PendingIntent去包装一个广播接收者，最后让AlarmManager根据定时器的模式，时间，和Pending去设置这个定时器任务。

public class MySerive extends Service {
    private static final String TIME="TIME";
    @Override
    public IBinder onBind(Intent intent) {
        return null;
    }
    //从onStartCommand方法开始，也就是启动服务之后，就开始执行此任务，这里选择的是
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        new Thread(new Runnable() {

            @Override
            public void run() {
                Log.d("TIME", "定时任务在执行..");
            }
        }).start();
        //定义一个警报管理者，可以进行定时任务。
        AlarmManager alarmManager=(AlarmManager) getSystemService(Context.ALARM_SERVICE);
        long time=SystemClock.elapsedRealtime()+1000*10;
        //指向广播接受者的intent
        Intent receiverIntent=new Intent(this,MyBroadcastReceiver.class);
        //封装了广播接受者的PendingIntent。
        PendingIntent pendingIntent=PendingIntent.getBroadcast(this, 0, receiverIntent, 0);
        //第一个参数是模式，
            //AlarmManager.ELAPSED_REALTIME_WAKEUP：定时任务从开机的时间计算，并且会唤醒CPU。
            //AlarmManager.ELAPSED_REALTIME       ：定时任务从开机的时间计算，不会唤醒CPU。
            //AlarmManager.RTC_WAKEUP：表示从1970年1月1日0点开始计算时间的毫秒数，并且会唤醒CPU。
            //AlarmManager.RTC        ：表示从1970年1月1日0点开始计算时间的毫秒数，不会唤醒CPU。
        //第二个参数是间隔时间。
        //第三个参数是可以执行广播的PesndingIntent。
        alarmManager.set(AlarmManager.ELAPSED_REALTIME_WAKEUP, time, pendingIntent);
        return super.onStartCommand(intent, flags, startId);
    }
}

//这个广播接收者去开启服务

public class MyBroadcastReceiver extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        Intent serviceIntent=new Intent(context,MySerive.class);
        context.startService(serviceIntent);
    }
}