Android中bindService基本使用方法概述

Android中有兩種主要方式使用Service，通過調用Context的startService方法或調用Context的bindService方法，本文只探討純bindService的使用，不涉及任何startService方法調用的情況。如果想了解startService相關的使用，請參見《Android中startService基本使用方法概述》。

bindService啟動服務的特點

相比於用startService啟動的Service，bindService啟動的服務具有如下特點:
1. bindService啟動的服務在調用者和服務之間是典型的client-server的接口，即調用者是客戶端，service是服務端，service就一個，但是連接綁定到service上面的客戶端client可以是一個或多個。這裡特別要說明的是，這裡所提到的client指的是組件，比如某個Activity。
2. 客戶端client（即調用bindService的一方，比如某個Activity）可以通過IBinder接口獲取Service的實例，從而可以實現在client端直接調用Service中的方法以實現靈活的交互，並且可借助IBinder實現跨進程的client-server的交互，這在純startService啟動的Service中是無法實現的。
3. 不同於startService啟動的服務默認無限期執行（可以通過Context的stopService或Service的stopSelf方法停止運行），bindService啟動的服務的生命周期與其綁定的client息息相關。當client銷毀的時候，client會自動與Service解除綁定，當然client也可以通過明確調用Context的unbindService方法與Service解除綁定。當沒有任何client與Service綁定的時候，Service會自行銷毀（通過startService啟動的除外）。
4. startService和bindService二者執行的回調方法不同：startService啟動的服務會涉及Service的的onStartCommand回調方法，而通過bindService啟動的服務會涉及Service的onBind、onUnbind等回調方法。

bindService代碼示例

使用bindService主要分兩種情形:
1. Service的調用者client與Service在同一個App中；
2. Service的調用者client是App1中的一個Activity，而Service是App2中的Service，client與service分屬兩個App，這種情形下主要用於實現跨進程的通信。

為了簡單起見，本文只討論第一種情形，即Service的調用者client與Service在同一個App中，該情形也是我們在實際開發中用到最多的情形。如果想了解通過bindService在兩個不同的進程中讓客戶端與Service通信，可參見另一篇博文《Android中通過Messenger與Service實現進程間雙向通信》。

下面我們通過一個例子演示一下第一種情形下bindService的基本使用流程。

首先我們有一個TestService，該類繼承自Service，其是client-server接口中的server端。我們在其主要的生命周期回調方法中都加入了輸出語句。TestService代碼如下:

package com.ispring.startservicedemo;

import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

import java.util.Random;

public class TestService extends Service {

  public class MyBinder extends Binder{

    public TestService getService(){
      return TestService.this;
    }

  }

  //通過binder實現調用者client與Service之間的通信
  private MyBinder binder = new MyBinder();

  private final Random generator = new Random();

  @Override
  public void onCreate() {
    Log.i("DemoLog","TestService -> onCreate, Thread: " + Thread.currentThread().getName());
    super.onCreate();
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    Log.i("DemoLog", "TestService -> onStartCommand, startId: " + startId + ", Thread: " + Thread.currentThread().getName());
    return START_NOT_STICKY;
  }

  @Override
  public IBinder onBind(Intent intent) {
    Log.i("DemoLog", "TestService -> onBind, Thread: " + Thread.currentThread().getName());
    return binder;
  }

  @Override
  public boolean onUnbind(Intent intent) {
    Log.i("DemoLog", "TestService -> onUnbind, from:" + intent.getStringExtra("from"));
    return false;
  }

  @Override
  public void onDestroy() {
    Log.i("DemoLog", "TestService -> onDestroy, Thread: " + Thread.currentThread().getName());
    super.onDestroy();
  }

  //getRandomNumber是Service暴露出去供client調用的公共方法
  public int getRandomNumber(){
    return generator.nextInt();
  }
}

在該App中，除了TestService，還有兩個Activity: ActivityA和ActivityB，它們都是Service的調用者，即client-server接口中的client。

ActivityA是App的啟動界面，界面如下:

ActivityA的代碼如下:

package com.ispring.startservicedemo;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;
import android.widget.Button;


public class ActivityA extends Activity implements Button.OnClickListener {

  private TestService service = null;

  private boolean isBound = false;

  private ServiceConnection conn = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder binder) {
      isBound = true;
      TestService.MyBinder myBinder = (TestService.MyBinder)binder;
      service = myBinder.getService();
      Log.i("DemoLog", "ActivityA onServiceConnected");
      int num = service.getRandomNumber();
      Log.i("DemoLog", "ActivityA 中調用 TestService的getRandomNumber方法, 結果: " + num);
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
      isBound = false;
      Log.i("DemoLog", "ActivityA onServiceDisconnected");
    }
  };

  @Override
  protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_a);
    Log.i("DemoLog", "ActivityA -> onCreate, Thread: " + Thread.currentThread().getName());
  }

  @Override
  public void onClick(View v) {
    if(v.getId() == R.id.btnBindService){
      //單擊了“bindService”按鈕
      Intent intent = new Intent(this, TestService.class);
      intent.putExtra("from", "ActivityA");
      Log.i("DemoLog", "----------------------------------------------------------------------");
      Log.i("DemoLog", "ActivityA 執行 bindService");
      bindService(intent, conn, BIND_AUTO_CREATE);
    }else if(v.getId() == R.id.btnUnbindService){
      //單擊了“unbindService”按鈕
      if(isBound){
        Log.i("DemoLog", "----------------------------------------------------------------------");
        Log.i("DemoLog", "ActivityA 執行 unbindService");
        unbindService(conn);
      }
    }else if(v.getId() == R.id.btnStartActivityB){
      //單擊了“start ActivityB”按鈕
      Intent intent = new Intent(this, ActivityB.class);
      Log.i("DemoLog", "----------------------------------------------------------------------");
      Log.i("DemoLog", "ActivityA 啟動 ActivityB");
      startActivity(intent);
    }else if(v.getId() == R.id.btnFinish){
      //單擊了“Finish”按鈕
      Log.i("DemoLog", "----------------------------------------------------------------------");
      Log.i("DemoLog", "ActivityA 執行 finish");
      this.finish();
    }
  }

  @Override
  protected void onDestroy() {
    super.onDestroy();
    Log.i("DemoLog", "ActivityA -> onDestroy");
  }
}

通過單擊ActivityA上的“start ActivityB”可以啟動ActivityB，ActivityB的界面如下:

ActivityB的代碼如下:

package com.ispring.startservicedemo;

import android.app.Activity;
import android.content.ComponentName;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.util.Log;
import android.view.View;
import android.widget.Button;


public class ActivityB extends Activity implements Button.OnClickListener {

  private TestService service = null;

  private boolean isBound = false;

  private ServiceConnection conn = new ServiceConnection() {
    @Override
    public void onServiceConnected(ComponentName name, IBinder binder) {
      isBound = true;
      TestService.MyBinder myBinder = (TestService.MyBinder)binder;
      service = myBinder.getService();
      Log.i("DemoLog", "ActivityB onServiceConnected");
      int num = service.getRandomNumber();
      Log.i("DemoLog", "ActivityB 中調用 TestService的getRandomNumber方法, 結果: " + num);
    }

    @Override
    public void onServiceDisconnected(ComponentName name) {
      isBound = false;
      Log.i("DemoLog", "ActivityB onServiceDisconnected");
    }
  };

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

  @Override
  public void onClick(View v) {
    if(v.getId() == R.id.btnBindService){
      Intent intent = new Intent(this, TestService.class);
      intent.putExtra("from", "ActivityB");
      Log.i("DemoLog", "----------------------------------------------------------------------");
      Log.i("DemoLog", "ActivityB 執行 bindService");
      bindService(intent, conn, BIND_AUTO_CREATE);
    }else if(v.getId() == R.id.btnUnbindService){
      if(isBound){
        Log.i("DemoLog", "----------------------------------------------------------------------");
        Log.i("DemoLog", "ActivityB 執行 unbindService");
        unbindService(conn);
      }
    }else if(v.getId() == R.id.btnFinish){
      //單擊了“Finish”按鈕
      Log.i("DemoLog", "----------------------------------------------------------------------");
      Log.i("DemoLog", "ActivityB 執行 finish");
      this.finish();
    }
  }

  @Override
  public void onDestroy(){
    super.onDestroy();
    Log.i("DemoLog", "ActivityB -> onDestroy");
  }
}

我們暫時不點擊上面的按鈕，先看一下TestService和ActivityA的代碼。

調用者（客戶端client）要想和Service進行交互，那麼Service和調用者必須都要做好准備。

我們先看Service要做的工作。
使用bindService將client與server聯系在一起的關鍵是binder，在TestService中，我們在其中寫了一個內部類MyBinder，該類有個公共方法getService，通過該方法我們可以獲取包含MyBinder的TestService。如果想要自己的Service支持bindService啟動方式，就必須在Service的onBind中返回一個IBinder類型的實例。在示例中，我們實例化了一個MyBinder的實例binder作為TestService的字段，並且將其作為onBind的返回值。
我們總結一下如果想讓Service支持bindService調用方式，Service需要做以下事情:
1. 在Service的onBind方法中返回IBinder類型的實例。
2. onBind方法返回的IBinder的實例需要能夠返回Service實例本身或者通過binder暴露出Service公共方法。通常情況下，最簡單明了的做法就是將binder弄成Service的內部類，然後在binder中加入類似於getService之類的方法返回包含binder的Service，這樣client可以通過該方法得到Service實例。

我們已經知道了Service需要做的事情，我們接下來看一下調用者需要做的工作。
在我們的示例中，調用者（也就是客戶端client）是ActivityA，我們在其中初始化了一個ServiceConnection類型的實例，需要重寫其onServiceConnected方法以及onServiceDisconnected方法。我們需要將這個ServiceConnection類型的實例作為參數傳給bindService方法，當Service還沒有創建的時候，Android會先創建Service的實例，然後執行Service的onBind方法，得到IBinder類型的實例，將該方法作為參數傳入client端的ServiceConnection的onServiceConnected方法中，onServiceConnected方法的執行表明client端可以獲取到Service的IBinder類型的實例，然後將IBinder轉換為自己實際的Binder類型，然後可以通過其直接獲取Service的實例或者通過Binder直接執行公共方法，這取決於Service中Binder的具體實現。在本例中，在onServiceConnected方法中，調用者ActivityA通過binder的getService方法獲取到了與其對應的Service，然後我們就可以直接調用Service的公共方法以達到使用Service的目的，這樣client與Service之間就通過IBinder建立了連接，從而進行交互。當client與Service失去連接時會觸發onServiceDisconnected方法。
我們總結一下client端要做的事情:
1. 創建ServiceConnection類型的實例，並重寫其onServiceConnected方法和onServiceDisconnected方法。
2. 當Android執行onServiceConnected回調方法時，我們可以通過IBinder實例得到Service的實例對象或直接調用binder的公共方法，這樣就實現了client與Service的連接。
3. 當Android執行onServiceDisconnected回調方法時，表示client與Service之間斷開了連接，我們在此處要寫一些斷開連接後需要做的處理。

在知道了如何讓client與Service進行交互之後，我們運行我們的App，觀察各個回調方法的執行過程，我們有三個測試流程。

測試流程A

該測試涉及到ActivityA，但不涉及ActivityB.
首先我們點擊ActivityA中的“bindService”按鈕，然後點擊”unbindService”按鈕，輸出結果如下所示:

首先，通過上面的代碼我們可以看到Service中執行的回調方法都是執行在主線程中的。
當我們調用bindService方法時，我們需要將Intent、ServiceConnection等實例傳入，Intent包含了我們要綁定的Service，ServiceConnection我們在上面提到過，實現了其onServiceConnected方法和onServiceDisconnected方法。 在調用了bindService之後，由於Service此時還不存在，那麼Android就會首先創建一個TestService的實例，並執行其onCreate回調方法，onCreate方法在其生命周期中只會被調用一次。然後會調用Service的onBind方法，該方法只有在第一次bindService調用後才會執行，onBind執行後會返回一個IBinder類型的實例，此時Android會將該IBinder實例存起來，這個IBinder實例是對所有client共享的。當下次其他的client執行bindService的時候，不會再執行onBind方法，因為我們之前已經得到了一個IBinder實例，Android會直接使用這個IBinder實例。 在得到了IBinder實例之後，Android會執行client端ServiceConnection中的onServiceConnected方法，在該方法中我們會得到IBinder實例，並通過該IBinder實例得到了TestService實例，這樣我們的客戶端ActivityA就通過IBinder與TestService建立了連接，我們就可以調用TestService的公共方法，比如調用其getRandomNumber方法獲得隨機數。

總結一下調用bindService之後發生的事情:
client 執行 bindService ->
如果Service不存在，Service 執行 onCreate ->
如果沒有執行過onBind，Service 執行 onBind ->
client的實例ServiceConnection 執行 onServiceConnected

在執行了bindService之後，一共有一個client連接到了TestService，即ActivityA，每次client在調用了unbindService方法之後，該client會與Service解除綁定，在與某個client解除綁定之後，Service會檢測是否還有其他的client與其連接綁定，如果沒有其他任何client與其處於連接狀態，那麼Service會執行onUnbind方法，然後執行onDestroy方法，最終銷毀自己。當ActivityA執行unbindService的時候，唯一的一個client與TestService解除了綁定的關系，TestService就執行了onUnbind方法，進而執行onDestroy方法。

總結一下調用unbindService之後發生的事情:
client 執行 unbindService ->
client 與 Service 解除綁定連接狀態 ->
Service 檢測是否還有其他client與其連接，如果沒有 ->
Service 執行onUnbind ->
Service 執行onDestroy

測試流程B

我們在測試完第一種流程後，關掉App，重啟App，進行第二種測試流程。
該測試也只涉及ActivityA，不涉及ActivityB。首先先點擊ActivityA中的“bindService”按鈕，然後點擊”Finish”按鈕，輸出結果如下圖所示:

在該測試中，我們首先通過點擊”bindService”按鈕，使得ActivityA綁定了TestService，但是我們沒有調用unbindService，而是直接通過調用“Finish”按鈕讓ActivityA直接銷毀，通過上面的輸出結果我們可以看到，在ActivityA銷毀的時候，執行了ActivityA的onDestroy回調方法，之後TestService依次執行了onUnbind、onDestroy回調方法，TestService銷毀。client與Service通過bindService連接起來之後，如果client銷毀，那麼client會自動與Service解除綁定，相當於在destroy之前會執行unbindService，在ActivityA銷毀之後，ActivityA與Service解除了綁定，此時再沒有client與Service處於連接綁定狀態，這樣Service就會執行onUnbind回調方法，表示沒有client和我玩了，最後執行onDestroy回調方法。

測試流程C

我們在之前的兩次測試流程中都只涉及ActivtityA，本測試流程會同時涉及ActivityA以及ActivityB。
首先關掉App，重啟App，按照以下步驟測試:
1. 點擊ActivityA中的”bindService”按鈕
2. 點擊ActivityA中的”start ActivityB”按鈕，界面切換到ActivityB
3. 點擊ActivityB中的”bindService”按鈕
4. 點擊ActivityB中的”unbindService”按鈕
5. 點擊ActivityB中的”Finish”按鈕
6. 點擊ActivityA中的”unbindService”按鈕

LogCat輸出結果如下:

下面我們依次分析每一步產生的影響，以便於完整地理解通過bindService啟動的Service的生命周期:

點擊ActivityA中的”bindService”按鈕
由於初始情況下TestService實例不存在，也就是TestService沒有運行。第一次調用bindService會實例化TestService，然後會執行其onBind方法，得到IBinder類型的實例，然後將其作為參數傳入ActivityA的ServiceConnection的onServiceConnected方法中，標志著ActivityA與TestService建立了綁定連接，此時只有ActivityA這一個客戶端client與TestService綁定。

點擊ActivityA中的”start ActivityB”按鈕，界面切換到ActivityB

點擊ActivityB中的”bindService”按鈕
由於TestService已經處於運行狀態，所以ActivityB調用bindService時，不會重新創建TestService的實例，所以也不會執行TestService的onCreate回調方法，由於在ActivityA執行bindService的時候就已經執行了TestService的onBind回調方法而獲取IBinder實例，並且該IBinder實例在所有的client之間是共享的，所以當ActivityB執行bindService的時候，不會執行其onBind回調方法，而是直接獲取上次已經獲取到的IBinder實例。並將其作為參數傳入ActivityB的ServiceConnection的onServiceConnected方法中，標志著ActivityB與TestService建立了綁定連接，此時有兩個客戶單client（ActivityA和ActivityB）與TestService綁定。

點擊ActivityB中的”unbindService”按鈕
ActivityB執行了unbindService之後，ActivityB就與TestService解除了綁定。當沒有任何client與Service處於綁定連接狀態的時候，TestService才會執行onUnbind方法、onDestroy方法。但是由於此時還有ActivityA這個client與TestService處於綁定連接中，所以不會執行Service的onBind及onDestroy回調方法。

點擊ActivityB中的”Finish”按鈕
執行了ActivityB的finish方法後，ActivityB銷毀了，界面返回到ActivityA

點擊ActivityA中的”unbindService”按鈕
ActivityA執行unbindService之後，ActivityA與TestService就解除綁定了，這樣就沒有客戶端client與TestService相連，這時候Android會銷毀TestService，在銷毀前會先執行TestService的onUnbind方法，然後才會執行其onDestroy方法，這樣TestService就銷毀了。

bindService生命周期流程圖

這裡特別要說明的是，本文所提到的client指的是組件Component，比如某個Activity。如果在某一個Activity中，多次調用bindService方法連接Service，那麼對於Service來說，這個Activity也只是一個client，而不是多個client。

最後我們將bindService啟動的Service的生命周期總結為如下的流程圖:

希望本文對大家了解bindService的使用有所幫助。