安卓之service学习总结

Service启动流程

context.startService()  -> onCreate()  -> onStart()  -> Service running  -> context.stopService()  -> onDestroy()  -> Service stop 

如果Service还没有运行，则android先调用onCreate()，然后调用onStart()；

如果Service已经运行，则只调用onStart()，所以一个Service的onStart方法可能会重复调用多次。 

如果stopService的时候会直接onDestroy，如果是调用者自己直接退出而没有调用stopService的话，Service会一直在后台运行，该Service的调用者再启动起来后可以通过stopService关闭Service。

所以调用startService的生命周期为：onCreate --> onStart (可多次调用) --> onDestroy

Intent myIntent = new Intent(FileActivity.this, MyService.class);startService(myIntent);// 发送Intent启动Service

stopService(new Intent(FileActivity.this, MyService.class));

和activity还有广播 一样，service也需要注册一个，在xml文件中：

  </service>        <service android:name="com.example.widgetflashlight.MyService" >

在service内，如果需要进行一些延时类的操作，如隔几秒之后检查一次系统的状态，或者发送广播。则需要新建一个线程。方法有

new一个Runnable。

private Runnable mTasks = new Runnable() {   public void run() {                }};

或者new一个Thread

 

  new Thread(){                        public void run(){}                          }.start();

还有一个即写即用的方法：

new Thread(new Runnable() {boolean flag = true;public void run() {Looper.prepare();while (flag) {new Thread(new Runnable() {public void run() {Looper.prepare();}}}).start();

这是一个嵌套。是从实际工程中copy出来的（为了清楚删除了一些处理代码）。关于Looper在下面的叙述，Looper.prepare()方法

如果想让该 线程具有消息队列和消息循环，需要在线程中首先调用Looper.prepare()来创建消息队列，然后调用Looper.loop()进入消息循环。

在实际开发中一个多线程的操作很少使用Thread类，而是通过Runnable接口完成。

在程序开发中只要是多线程肯定永远以实现Runnable接口为主，因为实现Runnable接口相比继承Thread类有如下好处：

• 避免点继承的局限，一个类可以继承多个接口。
• 适合于资源的共享

当使用多线程时一般需要和handler一起使用：关于handler
Handler可以分发Message对象和Runnable对象到主线程中, 每个Handler实例,都会绑定到创建他的线程中(一般是位于主线程),
        它有两个作用: (1):  安排消息或Runnable 在某个主线程中某个地方执行, (2)安排一个动作在不同的线程中执行
      
        Handler中分发消息的一些方法
        post(Runnable)
        removeCallbacks(Runnable)
        postAtTime(Runnable,long)
        postDelayed(Runnable long) 
        sendEmptyMessage(int)
        sendMessage(Message)
        sendMessageAtTime(Message,long)
        sendMessageDelayed(Message,long)

     Delayed()方法是延迟一定时间后，将Runnable添加入队列  

     AtTime()方法是定时将Runnable添加入队列

        以上post类方法允许你排列一个Runnable对象到主线程队列中,

        removeCallbacks()方法则是将Runnable移出队列，如程序需要结束时。

        sendMessage类方法, 允许你安排一个带数据的Message对象到队列中，等待更新.

 

private void sendMsg (int what) {//发送消息的方法Message msg = new Message();msg.what = what;handler.sendMessage(msg);}

   在activity中处理消息所用的函数方法：

private class Check extends Handler {public CheckWebserver_Handler(Looper mainLooper) {super(mainLooper);// TODO Auto-generated constructor stub}public void handleMessage(Message msg) {switch (msg.what) {case 0: // 进行后续处理 case 1: }}}

avtivity中调用处理消息方法：

Looper mainLooper = Looper.getMainLooper();Check  handler = new CheckWebserver_Handler(mainLooper);new NetCheckWebServer(handler);

关于looper和handler这些：

Message：消息，其中包含了消息ID，消息处理对象以及处理的数据等，由MessageQueue统一列队，终由Handler处理。

Handler：处理者，负责Message的发送及处理。使用Handler时，需要实现handleMessage(Message msg)方法来对特定的Message进行处理，例如更新UI等。

MessageQueue：消息队列，用来存放Handler发送过来的消息，并按照FIFO规则执行。当然，存放Message并非实际意义的保存，而是将Message以链表的方式串联起来的，等待Looper的抽取。

Looper：消息泵，不断地从MessageQueue中抽取Message执行。因此，一个MessageQueue需要一个Looper。

Thread：线程，负责调度整个消息循环，即消息循环的执行场所。

除此之外还有一种service为bindservice()，它和普通的service之间的区别是

BindService中使用bindService()方法来绑定服务，调用者和绑定者绑在一起，调用者一旦退出服务也就终止了【onCreate()->onBind()->onUnbind()->onDestroy()】。

我们在什么情况下要使用这种service呢？

也就是我们需要获得service这个对象，并且需要调用service内的方法的时候，用这种service再合适不过了。

由于没有示例代码，所以从网上借鉴了一份哈。

public class LocalServiceActivity extends Activity {    /** Called when the activity is first created. */    private MyService myService;     @Override    public void onCreate(Bundle savedInstanceState) {        super.onCreate(savedInstanceState);        setContentView(R.layout.main);         Intent intent = new Intent(this, MyService.class);        bindService(intent, connection, Context.BIND_AUTO_CREATE);    }     private ServiceConnection connection = new ServiceConnection() {         @Override        public void onServiceDisconnected(ComponentName name) {            myService = null;        }         @Override        public void onServiceConnected(ComponentName name, IBinder service) {            myService = ((MyService.MyBinder) service).getService();            System.out.println("Service连接成功");            // 执行Service内部自己的方法            myService.excute();        }    };     protected void onDestroy() {        super.onDestroy();        unbindService(connection);    };}

bindservice：

public class MyService extends Service {    private final IBinder binder = new MyBinder();     @Override    public IBinder onBind(Intent intent) {        return binder;    }     public class MyBinder extends Binder {        MyService getService() {            return MyService.this;        }    }     public void excute() {        System.out.println("通过Binder得到Service的引用来调用Service内部的方法");    }     @Override    public void onDestroy() {        // 当调用者退出(即使没有调用unbindService)或者主动停止服务时会调用        super.onDestroy();    }     @Override    public boolean onUnbind(Intent intent) {        // 当调用者退出(即使没有调用unbindService)或者主动停止服务时会调用        System.out.println("调用者退出了");        return super.onUnbind(intent);    }}