android四大组件--android service详解

一、android service简介

1、Android中的服务和windows中的服务是类似的东西，服务一般没有用户操作界面，它运行于系统中不容易被用户发觉，可以使用它开发如监控之类的程序。

2、在Android中，Activity主要负责前台页面的展示，Service主要负责需要长期运行的任务。例如，一个从service播放音乐的音乐播放器，应被设置为前台运行，因为用户会明确地注意它的运行．在状态栏中的通知可能会显示当前的歌曲并且允许用户启动一个activity来与音乐播放器交互。

3、在我们实际开发中，就会常常遇到Activity与Service之间的通信，我们一般在Activity中启动后台Service，通过Intent来启动，Intent中我们可以传递数据给Service，而当我们Service执行某些操作之后想要更新UI线程，我们应该怎么做呢？接下来我就介绍两种方式来实现Service与Activity之间的通信问题。

二.Android Service的实现
服务主要有以下两种形式:
1. Start
通过调用应用程序组件(例如Activity)的startService()方法来启动一个服务.一旦启动,服务就会在后台一直运行,即使应用程序组件此时被关闭.通常,已经启动的服务会处理一些单一功能,并且也不需要返回结果给调用者.例如,在网络上下载或上传文件.当服务的工作处理结束,才会自己关闭服务.
2. Bound
通过调用应用程序组件的bindService()方法来绑定一个服务.已绑定的服务会提供一个客户端-服务端交互接口.该接口主要用来与应用程序交互,发送请求,获取结果,甚至通过IPC来访问进程.只要一个程序组件绑定服务就会运行绑定服务,多个应用程序组件可以同时时间绑定一个服务.当所有的应用程序组件都解除绑定,该绑定服务器就会被销毁.
下面我们分别对"Started Service"和"Bound Servie"作一个介绍.

三、创建和配置service

1、要创建一个service，你必须创建一个Service类(或某个已存在的子类)的子类．在你的实现中，你应覆写一些处理有关service生命期的关键方面的回调方法并且提供一个能让组件绑定到service的机制（如果需要）．你应覆写的最重要的回调方法是：

onStartCommand()
　　系统在其它组件比如activity通过调用startService()请求service启动时调用这个方法．一旦这个方法执行，service就启动并且在后台长期运行．如果你实现了它，你需要负责在service完成任务时停止它，通过调用stopSelf()或stopService()．(如果你只想提供绑定，你不需实现此方法)．

OnBind()
　　当组件调用bindService()想要绑定到service时(比如想要执行进程间通讯)系统调用此方法．在你的实现中，你必须提供一个返回一个IBinder来以使客户端能够使用它与service通讯，你必须总是实现这个方法，但是如果你不允许绑定，那么你应返回null．

OnCreate()
　　系统在service第一次创建时执行此方法，来执行只运行一次的初始化工作(在调用它方法如onStartCommand()或onBind()之前)．如果service已经运行，这个方法不会被调用．

OnDestroy()
　　系统在service不再被使用并要销毁时调用此方法．你的service应在此方法中释放资源，比如线程，已注册的侦听器，接收器等等．这是service收到的最后一个调用．
　　如果一个组件通过调用startService()启动一个service(最终导致onStartCommand()被调用)，之后service会保持运行，直到它通过stopSelf()停止自己或另外的组件调用stopService()停止它．

　　如果一个组件调用bindService()来创建service(onStartCommand()不会被调用)，那么service只是运行在绑定期间．一旦service从所有的客户端解除绑定，系统就会杀了它．

2、在manifest中声明一个service
　　跟activity以及其它组件一样，你必须在你的应用的manifest文件中声明所有的service．
　　要声明你的service，添加一个<service>元素作为<application>元素的儿子．例如：

<manifest ... >  
  ...  
  <application ... >  
      <service android:name=".ExampleService" />  
      <intent-filter>
                <action android:name=".service.ExampleService" >
                </action>
       </intent-filter>
  </application>  
</manifest> 

就像一个activity，一个service可以定义intent过滤器来使得其它组件使用明确的intent调用自己．通过声明intent过滤器，你设备上的任意应用中的组件都可以通过给startService()传递匹配的intent来启动你的sevice．
如果你打算只在本应用内使用自己的service，那么你不需指定任何intent过滤器．不使用intent过滤器，你必须使用一个明确指定service的类名的intent来启动你的service．
3、开始一个Service

服务不能自己运行，需要通过调用Context.startService()或Context.bindService()方法启动服务。这两个方法都可以启动Service，但是它们的使用场合有所不同。

使用startService()方法启用服务，访问者与服务之间没有关连，即使访问者退出了，服务仍然运行。

使用bindService()方法启用服务，访问者与服务绑定在了一起，访问者一旦退出，服务也就终止，大有“不求同时生，必须同时死”的特点。

采用Context.startService()方法启动服务，只能调用Context.stopService()方法结束服务，服务结束时会调用onDestroy()方法。

如果service没有提供绑定功能，传给startService()的intent是应用组件与service之间唯一的通讯方式．然而，如果你希望service回发一个结果，那么启动这个service的客户端可以创建一个用于广播(使用getBroadcast())的PendingIntent然后放在intent中传给service，service然后就可以使用广播来回送结果．

PS：两种方式启动服务的区别:

通过startService()和stopService()启动关闭服务。适用于服务和访问者之间没有交互的情况。如果服务和访问者之间需要方法调用或者传递参数，侧需要使用bindService()和unbindService()方法启动关闭服务。

采用Context.bindService()方法启动服务，在服务未被创建时，系统会先调用服务的onCreate()方法，接着调用onBind()方法，这个时候访问者和服务绑定在一起。

 如果访问者要与服务进行通信，那么，onBind()方法必须返回Ibinder对象。如果访问者退出了，系统就会先调用服务的onUnbind()方法，接着调用onDestroy()方法。如果调用bindService()方法前服务已经被绑定，多次调用bindService()方法并不会导致多次创建服务及绑定(也就是说onCreate()和onBind()方法并不会被多次调用)。如果访问者希望与正在绑定的服务解除绑定，可以调用unbindService()方法，调用该方法也会导致系统调用服务的onUnbind()-->onDestroy()方法。

4、停止一个service

一个＂启动的＂service必须管理其自己的生命期．这表示，系统不会停止或销毁这种service，除非内存不够用了并且service在onStartCommand()返回后会继续运行．所以，service必须调用stopSelf()停止自己或由另一个组件调用stopService()来停止它．

　　一旦通过stopSelf()或stopService()发出了停止请求，系统就会尽可能快地销毁service．

　　然而，同时使用 startService 与 bindService 要注意到，Service 的终止，需要unbindService与stopService同时调用，才能终止 Service，不管 startService 与 bindService 的调用顺序，如果先调用 unbindService 此时服务不会自动终止，再调用 stopService 之后服务才会停止，如果先调用 stopService 此时服务也不会终止，而再调用 unbindService 或者 之前调用 bindService 的 Context 不存在了（如Activity 被 finish 的时候）之后服务才会自动停止；

　　注意：你的应用在完成工作后停止它所有的service是非常重要的．这可以避免浪费系统资源和消耗电量．如果需要，其它的组件可以调用stopService()停止service．即使你为service启用了绑定，你也必须自己停止service，甚至它收到了对onStartCommand()的调用也这样．

四、服务的生命周期回调方法

服务的生命周期跟启动服务的方法有关：
 1、当采用Context.startService()方法启动服务，与之有关的生命周期方法
onCreate()--> onStart()--> onDestroy()
onCreate()该方法在服务被创建时调用，该方法只会被调用一次，无论调用多少次startService()或bindService()方法，服务也只被创建一次。
onStart() 只有采用Context.startService()方法启动服务时才会回调该方法。该方法在服务开始运行时被调用。多次调用startService()方法尽管不会多次创建服务，但onStart() 方法会被多次调用。
onDestroy()该方法在服务被终止时调用。

2、 当采用Context.bindService()方法启动服务，与之有关的生命周期方法
onCreate()--> onBind() --> onUnbind() --> onDestroy()
onBind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务绑定时被调用，当调用者与服务已经绑定，多次调用Context.bindService()方法并不会导致该方法被多次调用。
onUnbind()只有采用Context.bindService()方法启动服务时才会回调该方法。该方法在调用者与服务解除绑定时被调用。

如果先采用startService()方法启动服务,然后调用bindService()方法绑定到服务，再调用unbindService()方法解除绑定，最后调用bindService()方法再次绑定到服务，触发的生命周期方法如下：
onCreate()-->onStart()-->onBind()-->onUnbind()[重载后的方法需返回true-->onRebind()

下面这张流程图很好的诠释了"startService()"和"bindService()"两个方法调用的生命周期。

PS:

一个service的生命期比一个activity要简单得多．然而，你依然需要密切关注你的service是如何被创建又是如何被销毁的，因为一个service可以运行于后台而用户看不到它．
　service的生命期—从它被创建到它被销毁—有两条路可走：

一个＂启动的＂service
　　在其它组件调用startService()时创建．然后service就长期运行并且必须调用stopSelf()自己停止自己．另一个组件也可以调用stopService()来停止它．当service停止后，系统就销毁它．

一个绑定的service
　　当另一个组件(一个客户端)调用bindService()时创建．然后客户端通过一个IBinder接口与service通信．客户端可以调用unbindService()停止通信．多个客户端可以绑定到同一个service并且当所有的客户端都解除绑定后，系统就销毁掉这个service．(service不需停止自己．)

　　这两条路并不是完全分离的．也就是，你是可以绑定到用startService()启动的service的．例如，一个后台音乐service在通过传入指明要播放的音乐的intent来调用startService()后启动．之后，当用户想对播放器进行一些操作或要获取当前歌曲的信息时，一个activity可以通过调用bindService()绑定到service．在此情况下，stopService()或stopSelf()不会真正的停止service，除非所有的客户端都取消绑定了．

五、创建一个绑定的Service

1、要创建一个绑定的service，你必须实现回调方法onBind()，还要在其中返回一个IBinder，这个IBinder定义了与service通讯的接口．其它应用组件就可以在之后调用bindService()来接收这个接口并开始调用service的方法．service只在有应用组件绑定到它时才活着，所以当没有组件绑定到它时，系统就会kill它(你不需去停止一个绑定的service，跟用onStartCommand()启动的service不一样)．
2、要创建一个绑定的service，首先要做的就是定义客户端如何与service通讯的接口．这个接口必须是IBinder的一个实现，并且必须被回调方法onBind()返回．一旦客户端接收到IBinder，它就可以开始与service进行交互．
3、多个客户端可以一起绑定到一个service．当一个客户端完成与service的交互，它调用unbindService()来解除绑定．一旦不再有任何客户端绑定到service，系统就kill这个service．

下面是如何建立它：

1、在你的service中，创建一个Binder实例，提供以下三种功能之一：

   Binder包含一些可供客户端调用的公开方法．

   返回当前的Service实例，它具有一些客户端可以调用的公开方法．

   或者，返回另一个类的实例，这个类具有客户端可调用的公开方法并托管于service．

2、在回调方法onBind()中返回这个Binder的实例．

3、在客户端，从回调方法onServiceConnected()中接收这个Binder并使用１中所述的公开方法调用绑定service．

例如：下面这个service提供让客户端通过一个Binder实现调用service中的方法的功能：

public class LocalService extends Service {
    // Binder given to clients
    private final IBinder mBinder = new LocalBinder();
    // Random number generator
    private final Random mGenerator = new Random();

    /**
     * 这里定义吧一个Binder类，用在onBind()有方法里，这样Activity那边可以获取到
     * 在 Local Service 中我们直接继承 Binder 而不是 IBinder,因为 Binder 实现了 IBinder 接口，这样我们可以少做很多工作。
     */
    public class LocalBinder extends Binder {
        LocalService getService() {
            // 返回本service的实例到客户端，于是客户端可以调用本service的公开方法
            return LocalService.this;
        }
    }

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

    /**客户端所要调用的方法*/
    public int getRandomNumber() {
      return mGenerator.nextInt(100);
    }
}

public class BindingActivity extends Activity {
    LocalService mService;
    boolean mBound = false;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
    }

    @Override
    protected void onStart() {
        super.onStart();
        // 绑定到类LocalService的实例
        Intent intent = new Intent(this, LocalService.class);
        bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 从service解除绑定
        if (mBound) {
            unbindService(mConnection);
            mBound = false;
        }
    }

    /** 当按钮按下时调用(在layout文件中定义的button并用android:onClick 属性指定响应到本方法) */
    public void onButtonClick(View v) {
        if (mBound) {
            // 调用LocalService的一个方法
            // 然而，如果这个调用中有挂起操作，那么这个请求应发
            // 生在另一个线程来避免拉低activity的性能．
            int num = mService.getRandomNumber();
            Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show();
        }
    }

    /** 定义service绑定的回调，传给bindService() 的*/
    private ServiceConnection mConnection = new ServiceConnection() {

        @Override
        public void onServiceConnected(ComponentName className,
                IBinder service) {
            //我们已经绑定到了LocalService，把IBinder进行强制类型转换并且获取LocalService实例．
            LocalBinder binder = (LocalBinder) service;
            mService = binder.getService();
            mBound = true;
        }

        @Override
        public void onServiceDisconnected(ComponentName arg0) {
            mBound = false;
        }
    };
}

1、应用组件(客户端)可以调用bindService()绑定到一个service．Android系统之后调用service的onBind()方法，它返回一个用来与service交互的IBinder．

2、绑定是异步的．bindService()会立即返回，它不会返回IBinder给客户端．要接收IBinder，客户端必须创建一个ServiceConnection的实例并传给bindService()．ServiceConnection包含一个回调方法，系统调用这个方法来传递要返回的IBinder．

3、从你的客户端绑定到一个service，你必须：

  1）实现ServiceConnection.
你的实现必须重写两个回调方法：
onServiceConnected()
系统调用这个来传送在service的onBind()中返回的IBinder．
OnServiceDisconnected()
Android系统在同service的连接意外丢失时调用这个．比如当service崩溃了或被强杀了．当客户端解除绑定时，这个方法不会被调用．
  2）调用bindService()，传给它ServiceConnection的实现．
  3）当系统调用你的onServiceConnected()方法时，你就可以使用接口定义的方法们开始调用service了．
  4）要与service断开连接，调用unbindService()．
　　当你的客户端被销毁，它将从service解除绑定，但是你必须总是在你完成与service的交互时或当你的activity暂停于是service在不被使用时可以关闭此两种情况下解除绑定．(下面会讨论更多在适当的时候绑定和解除绑定的问题．

4、使用这个ServiceConnection，客户端可以绑定到一个service，通过把它传给bindService()．例如：

Intentintent = new Intent(this, LocalService.class);
bindService(intent,mConnection, Context.BIND_AUTO_CREATE);

第一个bindService()的参数是一个明确指定了要绑定的service的Intent．

第二个参数是ServiceConnection对象．

第三个参数是一个标志，它表明绑定中的操作．它一般应是BIND_AUTO_CREATE，这样就会在service不存在时创建一个．其它可选的值是BIND_DEBUG_UNBIND和BIND_NOT_FOREGROUND,不想指定时设为0即可．

android四大组件--android service详解,,5-wow.com