編輯：關於Android編程
Service 是一個可以在後台執行長時間運行操作而不使用用戶界面的應用組件。 例如，服務可以處理網絡事務、播放音樂，執行文件 I/O 或與內容提供程序交互，而所有這一切均可在後台進行。
服務基本上分為兩種形式：
啟動服務
當應用組件（如 Activity）通過調用 startService() 啟動服務時，服務即處於“啟動”狀態。 一旦啟動，服務即可在後台無限期運行，即使啟動服務的組件已被銷毀也不受影響。 已啟動的服務通常是執行單一操作，而且不會將結果返回給調用方。例如，它可能通過網絡下載或上傳文件。 操作完成後，服務會自行停止運行。
綁定服務
當應用組件通過調用 bindService() 綁定到服務時，服務即處於“綁定”狀態。 綁定服務提供了一個客戶端-服務器接口，允許組件與服務進行交互、發送請求、獲取結果，甚至是利用進程間通信 (IPC) 跨進程執行這些操作。 僅當與另一個應用組件綁定時，綁定服務才會運行。 多個組件可以同時綁定到該服務，但全部取消綁定後，該服務即會被銷毀。
無論應用是處於啟動狀態還是綁定狀態，抑或處於啟動並且綁定狀態，任何應用組件均可像使用活動那樣通過調用 Intent 來使用服務（即使此服務來自另一應用）。 不過，您可以通過清單文件將服務聲明為私有服務，並阻止其他應用訪問。 使用清單文件聲明服務部分將對此做更詳盡的闡述。
注意：服務在其托管進程的主線程中運行，它既不創建自己的線程，也不在單獨的進程中運行（除非另行指定）。 這意味著，如果服務將執行任何 CPU 密集型工作或阻止性操作（例如 MP3 播放或聯網），則應在服務內創建新線程來完成這項工作。 通過使用單獨的線程，可以降低發生“應用無響應”(ANR) 錯誤的風險，而應用的主線程仍可繼續專注於運行用戶與 Activity 之間的交互。
如同 Activity（以及其他組件）一樣，也必須在應用的清單文件中聲明所有服務。
添加 < service >元素作為< application > 元素的子元素。例如：
... ...
< service >元素有以下屬性：
. . .
android:enabled
服務是否能被系統實例化 —“true”可以，“false”不允許。 默認值是“true”。 < application > 元素擁有自己的 enabled 屬性，適用於應用程序所有的內部組件，包括服務。 服務要能被啟用， < application> 和 < service> 的此屬性都必須設置為“true”（均為默認值即可）。
android:exported
其它應用程序的組件能否調用服務或與服務交互 — “true”可以，“false”不可以。 如果設為“false”，則只有本應用程序或用戶 ID 相同程序的組件才能啟動或綁定該服務。 默認值取決於服務是否包含 Intent 過濾器。 如果不含任何過濾器，該服務僅供應用程序內部使用（因為其他應用程序通常不知道確切的類名稱）。這時的默認值是“false”。 如果存在一個以上的過濾器，則表示服務願意被外部使用，因此默認值是“true”。 本屬性並不是限制服務對其他應用程序的公開程度的唯一途徑。 還可以利用權限機制對可與服務進行交互的外部對象進行限制（請參閱permission屬性）。 為了確保應用的安全性，請始終使用顯式 Intent 啟動或綁定 Service，且不要為服務聲明 Intent 過濾器。 啟動哪個服務存在一定的不確定性，而如果對這種不確定性的考量非常有必要，則可為服務提供 Intent 過濾器並從 Intent 中排除相應的組件名稱， 但隨後必須使用 setPackage() 方法設置 Intent 的軟件包，這樣可以充分消除目標服務的不確定性。 或者添加 android:exported 屬性並將其設置為 "false"，確保服務僅適用於您的應用。這可以有效阻止其他應用啟動您的服務，即便在使用顯式 Intent 時也如此。
android:icon
代表服務的圖標。 本屬性必須設為對 drawable 資源的引用，該資源包含了圖片的定義。 如果未設置本屬性值，則會用全局性的應用程序圖標來代替。 服務的圖標不管是在此處還是在< application> 元素中設置的，同時也是本服務中所有 Intent 過濾器的默認圖標
android:isolatedProcess
如果設為 true ，則本服務將會運行於一個特殊的進程中。 該進程與系統其他部分隔離，且沒有自己的權限。 與其通訊的唯一手段就是通過 Service API （綁定和啟動）。
android:label
供用戶查看的服務名稱。 如果未設置本屬性，則用全局性的應用程序文本標簽代替。 服務的文本標簽 — 不管是在在此處還是在 < application> 元素中設置的， 同時也是本服務中所有 Intent 過濾器的默認文本標簽。
android:name
實現服務的 Service 子類的名稱。 這應該是一個完全限定格式的類名（比如“com.example.project.RoomService”）。 不過作為簡稱，如果首字符為句點（比如“.RoomService”），則會在前面自動加上 < manifest> 元素定義的包名稱。 應用程序一經發布，就 不應再更改名稱 （除非設置了 android:exported="false"）。 沒有默認值。本名稱必須指定。
android:permission
要啟動或綁定服務的對象所必須擁有的權限名稱。 如果 startService()、 bindService()或 stopService() 的調用者未獲得本屬性設定的權限，這些方法將會失效，Intent 對象也不會分發給本服務。 如果本屬性未被設置，則會把 < application> 元素的 permission 屬性所定義的權限應用於本服務。 如果兩個地方的屬性都沒有設置，則本服務將不受權限機制的保護。
android:process
運行服務的進程名稱。 通常，應用程序的所有組件都運行在創建時的默認進程中。 該進程的名稱與程序包名相同。 < application> 元素的 process 屬性可以為每個組件設置不同的默認進程。 但每個組件也可以用各自的 process 屬性覆蓋默認設置，使得程序可以跨越多個進程運行。 如果本屬性設置的名稱以冒號（':'）開頭，則必要時會新建一個屬於該程序私有的進程，服務將在該新進程中運行。 如果進程名稱以小寫字母開頭，則服務將運行於一個以此名字命名的全局進程中，並賦予應有的訪問權限。 這就允許分屬於不同應用程序的多個組件共享同一個進程，以減少資源的占用。
從傳統上講，您可以擴展兩個類來創建啟動服務：
Service
這是適用於所有服務的基類。 擴展此類時，必須創建一個用於執行所有服務工作的新線程，因為默認情況下，服務將使用應用的主線程，這會降低應用正在運行的所有 Activity 的性能。
IntentService
這是 Service 的子類，它使用工作線程逐一處理所有啟動請求。如果您不要求服務同時處理多個請求，這是最好的選擇。 只需實現 onHandleIntent() 方法即可，該方法會接收每個啟動請求的 Intent，使您能夠執行後台工作。
由於大多數啟動服務都不必同時處理多個請求（實際上，這種多線程情況可能很危險），因此使用 IntentService 類實現服務也許是最好的選擇。
IntentService 執行以下操作：
創建默認的工作線程，用於在應用的主線程外執行傳遞給 onStartCommand() 的所有 Intent。 創建工作隊列，用於將一個 Intent 逐一傳遞給 onHandleIntent() 實現，這樣您就永遠不必擔心多線程問題。 在處理完所有啟動請求後停止服務，因此您永遠不必調用 stopSelf()。 提供 onBind() 的默認實現（返回 null）。 提供 onStartCommand() 的默認實現，可將 Intent 依次發送到工作隊列和 onHandleIntent() 實現。
綜上所述，只需實現 onHandleIntent() 來完成客戶端提供的工作即可。（另外，還需要為服務提供一個構造函數。）
以下是 IntentService 的實現示例：
public class HelloIntentService extends IntentService {
//您只需要一個構造函數和一個 onHandleIntent() 實現即可。
/**
* A constructor is required, and must call the super IntentService(String)
* constructor with a name for the worker thread.
*/
public HelloIntentService() {
super("HelloIntentService");
}
/**
* The IntentService calls this method from the default worker thread with
* the intent that started the service. When this method returns, IntentService
* stops the service, as appropriate.
*/
@Override
protected void onHandleIntent(Intent intent) {
// Normally we would do some work here, like download a file.
// For our sample, we just sleep for 5 seconds.
long endTime = System.currentTimeMillis() + 5*1000;
while (System.currentTimeMillis() < endTime) {
synchronized (this) {
try {
wait(endTime - System.currentTimeMillis());
} catch (Exception e) {
}
}
}
}
}
//如果您決定還重寫其他回調方法（如 onCreate()、onStartCommand() 或 onDestroy()），
//請確保調用超類實現，以便 IntentService 能夠妥善處理工作線程的生命周期。
//除 onHandleIntent() 之外，您無需從中調用超類的唯一方法就是 onBind()（僅當服務允許綁定時，才需要實現該方法）。
//例如，onStartCommand() 必須返回默認實現（即，如何將 Intent 傳遞給 onHandleIntent()）：
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
return super.onStartCommand(intent,flags,startId);
}
使用 IntentService 顯著簡化了啟動服務的實現，但是，若要求服務執行多線程（而不是通過工作隊列處理啟動請求），則可擴展 Service 類來處理每個 Intent。
為了便於比較，以下提供了 Service 類實現的代碼示例，該類執行的工作與上述使用 IntentService 的示例完全相同。也就是說，對於每個啟動請求，它均使用工作線程執行作業，且每次僅處理一個請求。：
public class HelloService extends Service {
private Looper mServiceLooper;
private ServiceHandler mServiceHandler;
// 服務實現一個 Handler
private final class ServiceHandler extends Handler {
public ServiceHandler(Looper looper) {
super(looper);
}
@Override
public void handleMessage(Message msg) {
// 執行任務, 比如下載文件.
// For our sample, we just sleep for 5 seconds.
long endTime = System.currentTimeMillis() + 5*1000;
while (System.currentTimeMillis() < endTime) {
synchronized (this) {
try {
wait(endTime - System.currentTimeMillis());
} catch (Exception e) {
}
}
}
// 完成後自動停止。Stop the service using the startId, so that we don't stop
// the service in the middle of handling another job
stopSelf(msg.arg1);
}
}
@Override
public void onCreate() {
// 因為服務運行在主線程中，又不希望主線程阻塞，所以新建一個線程運行服務 We also make it
// 我們還讓他優先在後台運行，這樣CPU密集型任務不會阻塞UI
HandlerThread thread = new HandlerThread("ServiceStartArguments",
Process.THREAD_PRIORITY_BACKGROUND);
thread.start();
// Get the HandlerThread's Looper and use it for our Handler
mServiceLooper = thread.getLooper();
mServiceHandler = new ServiceHandler(mServiceLooper);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show();
// For each start request, send a message to start a job and deliver the
// start ID so we know which request we're stopping when we finish the job
Message msg = mServiceHandler.obtainMessage();
msg.arg1 = startId;
mServiceHandler.sendMessage(msg);
//如果任務中斷，從這裡重啟任務
return START_STICKY;
}
@Override
public IBinder onBind(Intent intent) {
// 因為不提供綁定服務，所以返回null
return null;
}
@Override
public void onDestroy() {
Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show();
}
}
與使用 IntentService 相比，這需要執行更多工作。
但是，因為是由您自己處理對 onStartCommand() 的每個調用，因此可以同時執行多個請求。此示例並未這樣做，但如果您希望如此，則可為每個請求創建一個新線程，然後立即運行這些線程（而不是等待上一個請求完成）。
請注意，onStartCommand() 方法必須返回整型數。整型數是一個值，用於描述系統應該如何在服務終止的情況下繼續運行服務（如上所述，IntentService 的默認實現將為您處理這種情況，不過您可以對其進行修改）。從 onStartCommand() 返回的值必須是以下常量之一：
START_NOT_STICKY：
如果系統在 onStartCommand() 返回後終止服務，則除非有掛起 Intent 要傳遞，否則系統不會重建服務。 這是最安全的選項，可以避免在不必要時以及應用能夠輕松重啟所有未完成的作業時運行服務。
START_STICKY：
如果系統在 onStartCommand() 返回後終止服務，則會重建服務並調用 onStartCommand()，但絕對不會重新傳遞最後一個 Intent。 相反，除非有掛起 Intent 要啟動服務（在這種情況下，將傳遞這些 Intent ），否則系統會通過空 Intent 調用 onStartCommand()。 這適用於不執行命令、但無限期運行並等待作業的媒體播放器（或類似服務）。
START_REDELIVER_INTENT：
如果系統在 onStartCommand() 返回後終止服務，則會重建服務，並通過傳遞給服務的最後一個 Intent 調用 onStartCommand()。 任何掛起 Intent 均依次傳遞。 這適用於主動執行應該立即恢復的作業（例如下載文件）的服務。
您可以通過將 Intent（指定要啟動的服務）傳遞給 startService()，從 Activity 或其他應用組件啟動服務。Android 系統調用服務的 onStartCommand() 方法，並向其傳遞 Intent。
例如，Activity 可以結合使用顯式 Intent 與 startService()，啟動上文中的示例服務 (HelloSevice)：
Intent intent = new Intent(this, HelloService.class); startService(intent);
startService() 方法將立即返回，且 Android 系統調用服務的 onStartCommand() 方法。如果服務尚未運行，則系統會先調用 onCreate()，然後再調用 onStartCommand()。
如果服務亦未提供綁定，則使用 startService() 傳遞的 Intent 是應用組件與服務之間唯一的通信模式。 但是，如果您希望服務返回結果，則啟動服務的客戶端可以為廣播創建一個 PendingIntent （使用 getBroadcast()），並通過啟動服務的 Intent 傳遞給服務。 然後，服務就可以使用廣播傳遞結果。
多個服務啟動請求會導致多次對服務的 onStartCommand() 進行相應的調用。但是，要停止服務，只需一個服務停止請求（使用 stopSelf() 或 stopService()）即可。
啟動服務必須管理自己的生命周期。也就是說，除非系統必須回收內存資源，否則系統不會停止或銷毀服務，而且服務在 onStartCommand() 返回後會繼續運行。因此，服務必須通過調用 stopSelf() 自行停止運行，或者由另一個組件通過調用 stopService() 來停止它。
一旦請求使用 stopSelf() 或 stopService() 停止服務，系統就會盡快銷毀服務。
但是，如果服務同時處理多個 onStartCommand() 請求，則您不應在處理完一個啟動請求之後停止服務，因為您可能已經收到了新的啟動請求（在第一個請求結束時停止服務會終止第二個請求）。為了避免這一問題，您可以使用 stopSelf(int) 確保服務停止請求始終基於最近的啟動請求。也就說，在調用 stopSelf(int) 時，傳遞與停止請求的 ID 對應的啟動請求的 ID（傳遞給 onStartCommand() 的 startId） 。然後，如果在您能夠調用 stopSelf(int) 之前服務收到了新的啟動請求， ID 就不匹配，服務也就不會停止。
注意：為了避免浪費系統資源和消耗電池電量，應用必須在工作完成之後停止其服務。 如有必要，其他組件可以通過調用 stopService() 來停止服務。即使為服務啟用了綁定，一旦服務收到對 onStartCommand() 的調用，您始終仍須親自停止服務。
創建提供綁定的服務時，您必須提供 IBinder，用以提供客戶端用來與服務進行交互的編程接口。 您可以通過三種方法定義接口：
使用Binder
如果服務是供您的自有應用專用，並且在與客戶端相同的進程中運行（常見情況），則應通過擴展 Binder 類並從 onBind() 返回它的一個實例來創建接口。 客戶端收到 Binder 後，可利用它直接訪問 Binder 實現中乃至 Service 中可用的公共方法。 如果服務只是您的自有應用的後台工作線程，則優先采用這種方法。 不以這種方式創建接口的唯一原因是，您的服務被其他應用或不同的進程占用。
使用 Messenger
如需讓接口跨不同的進程工作，則可使用 Messenger 為服務創建接口。 服務可以這種方式定義對應於不同類型 Message 對象的 Handler。 此 Handler 是 Messenger 的基礎，後者隨後可與客戶端分享一個 IBinder，從而讓客戶端能利用 Message 對象向服務發送命令。 此外，客戶端還可定義自有 Messenger，以便服務回傳消息。 這是執行進程間通信 (IPC) 的最簡單方法，因為 Messenger 會在單一線程中創建包含所有請求的隊列，這樣您就不必對服務進行線程安全設計。
使用 AIDL
AIDL（Android 接口定義語言）執行所有將對象分解成原語的工作，操作系統可以識別這些原語並將它們編組到各進程中，以執行 IPC。 之前采用 Messenger 的方法實際上是以 AIDL 作為其底層結構。如上所述，Messenger 會在單一線程中創建包含所有客戶端請求的隊列，以便服務一次接收一個請求。 不過，如果您想讓服務同時處理多個請求，則可直接使用 AIDL。 在此情況下，您的服務必須具備多線程處理能力，並采用線程安全式設計。 如需直接使用 AIDL，您必須創建一個定義編程接口的 .aidl 文件。Android SDK 工具利用該文件生成一個實現接口並處理 IPC 的抽象類，您隨後可在服務內對其進行擴展。
注：大多數應用“都不會”使用 AIDL 來創建綁定服務，因為它可能要求具備多線程處理能力，並可能導致實現的復雜性增加。因此，AIDL 並不適合大多數應用，本文也不會闡述如何將其用於您的服務。如果您確定自己需要直接使用 AIDL，請參閱 AIDL 文檔。
如果您的服務僅供本地應用使用，不需要跨進程工作，則可以實現Binder 類，讓客戶端通過該類直接訪問服務中的公共方法。
注：此方法只有在客戶端和服務位於同一應用和進程內這一最常見的情況下方才有效。 例如，對於需要將 Activity 綁定到在後台播放音樂的自有服務的音樂應用，此方法非常有效。
以下是具體的設置方法：
1>在您的服務中，創建一個可滿足下列任一要求的 Binder 實例：
包含客戶端可調用的公共方法
返回當前 Service 實例，其中包含客戶端可調用的公共方法
或返回由服務承載的其他類的實例，其中包含客戶端可調用的公共方法
2>從 onBind() 回調方法返回此 Binder 實例。
3>在客戶端中，從 onServiceConnected() 回調方法接收 Binder，並使用提供的方法調用綁定服務。
注：之所以要求服務和客戶端必須在同一應用內，是為了便於客戶端轉換返回的對象和正確調用其 API。服務和客戶端還必須在同一進程內，因為此方法不執行任何跨進程編組。
例如，以下這個服務可讓客戶端通過 Binder 實現訪問服務中的方法：
public class LocalService extends Service {
// 2> Binder，讓客戶端通過該對象直接訪問服務中的公共方法
private final IBinder mBinder = new LocalBinder();
// Random number generator
private final Random mGenerator = new Random();
/** 1> 實現Binder 類，返回當前 Service 實例
* Class used for the client Binder. Because we know this service always
* runs in the same process as its clients, we don't need to deal with IPC.
*/
public class LocalBinder extends Binder {
LocalService getService() {
// Return this instance of LocalService so clients can call public methods
return LocalService.this;
}
}
// 3> 從 onBind() 回調方法返回此 Binder 實例。
@Override
public IBinder onBind(Intent intent) {
return mBinder;
}
/**4> 客戶端可調用的公共方法 */
public int getRandomNumber() {
return mGenerator.nextInt(100);
}
}
LocalBinder 為客戶端提供 getService() 方法，以檢索 LocalService 的當前實例。這樣，客戶端便可調用服務中的公共方法。 例如，客戶端可調用服務中的 getRandomNumber()。
點擊按鈕時，以下這個 Activity 會綁定到 LocalService 並調用 getRandomNumber()：
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();
// 7> 綁定LocalService
Intent intent = new Intent(this, LocalService.class);
bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
}
@Override
protected void onStop() {
super.onStop();
// 8> 解綁服務
if (mBound) {
unbindService(mConnection);
mBound = false;
}
}
/** Called when a button is clicked (the button in the layout file attaches to
* this method with the android:onClick attribute) */
public void onButtonClick(View v) {
if (mBound) {
// 6> 使用提供的方法調用綁定服務
// However, if this call were something that might hang, then this request should
// occur in a separate thread to avoid slowing down the activity performance.
int num = mService.getRandomNumber();
Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show();
}
}
// 5> 在客戶端中，從 onServiceConnected() 回調方法接收 Binder。
/** Defines callbacks for service binding, passed to bindService() */
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName className,
IBinder service) {
// We've bound to LocalService, cast the IBinder and get LocalService instance
LocalBinder binder = (LocalBinder) service;
mService = binder.getService();
mBound = true;
}
@Override
public void onServiceDisconnected(ComponentName arg0) {
mBound = false;
}
};
}
上例說明了客戶端如何使用 ServiceConnection 的實現和 onServiceConnected() 回調綁定到服務。
注：上例並未顯式取消與服務的綁定，但所有客戶端都應在適當的時間（例如當 Activity 暫停時）取消綁定。
如需查看更多示例代碼，請參閱 ApiDemos 中的 LocalService.java 類和 LocalServiceActivities.java 類。
如需讓服務與遠程進程通信，則可使用 Messenger 為您的服務提供接口。利用此方法，您無需使用 AIDL 便可執行進程間通信 (IPC)。
以下是 Messenger 的使用方法摘要：
1>服務實現一個 Handler，由其接收來自客戶端的每個調用的回調 2>用於創建 Messenger 對象（對 Handler 的引用） 3>Messenger 創建一個 IBinder，服務通過 onBind() 使其返回客戶端 4>客戶端使用 IBinder 將 Messenger（引用服務的 Handler）實例化，然後使用後者將 Message 對象發送給服務 5>服務在其 Handler 中（具體地講，是在 handleMessage() 方法中）接收每個 Message
這樣，客戶端並沒有調用服務的“方法”。而客戶端傳遞的“消息”（Message 對象）是服務在其 Handler 中接收的。
以下是一個使用 Messenger 接口的簡單服務示例：
public class MessengerService extends Service {
/** Command to the service to display a message */
static final int MSG_SAY_HELLO = 1;
/**
* 1>服務實現一個 Handler，由其接收來自客戶端的每個調用的回調
*/
class IncomingHandler extends Handler {
@Override
public void handleMessage(Message msg) {
//6>服務在 handleMessage() 方法中接收每個 Message
switch (msg.what) {
case MSG_SAY_HELLO:
Toast.makeText(getApplicationContext(), "hello!", Toast.LENGTH_SHORT).show();
break;
default:
super.handleMessage(msg);
}
}
}
/**
* 2>用於創建 Messenger 對象（對 Handler 的引用）
*/
final Messenger mMessenger = new Messenger(new IncomingHandler());
/**3>Messenger 創建一個 IBinder，服務通過 onBind() 使其返回客戶端
* When binding to the service, we return an interface to our messenger
* for sending messages to the service.
*/
@Override
public IBinder onBind(Intent intent) {
Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
return mMessenger.getBinder();
}
}
請注意，服務就是在 Handler 的 handleMessage() 方法中接收傳入的 Message，並根據 what 成員決定下一步操作。
客戶端只需根據服務返回的 IBinder 創建一個 Messenger，然後利用 send() 發送一條消息。例如，以下就是一個綁定到服務並向服務傳遞 MSG_SAY_HELLO 消息的簡單 Activity：
public class ActivityMessenger extends Activity {
/** Messenger for communicating with the service. */
Messenger mService = null;
/** Flag indicating whether we have called bind on the service. */
boolean mBound;
/** 4>客戶端使用 IBinder 將 Messenger（引用服務的 Handler）實例化
* Class for interacting with the main interface of the service.
*/
private ServiceConnection mConnection = new ServiceConnection() {
public void onServiceConnected(ComponentName className, IBinder service) {
// This is called when the connection with the service has been
// established, giving us the object we can use to
// interact with the service. We are communicating with the
// service using a Messenger, so here we get a client-side
// representation of that from the raw IBinder object.
mService = new Messenger(service);
mBound = true;
}
public void onServiceDisconnected(ComponentName className) {
// This is called when the connection with the service has been
// unexpectedly disconnected -- that is, its process crashed.
mService = null;
mBound = false;
}
};
public void sayHello(View v) {
if (!mBound) return;
// Create and send a message to the service, using a supported 'what' value
Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0);
try {
// 5> 將 Message 對象發送給服務
mService.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
@Override
protected void onStart() {
super.onStart();
// 7> 綁定服務
bindService(new Intent(this, MessengerService.class), mConnection,
Context.BIND_AUTO_CREATE);
}
@Override
protected void onStop() {
super.onStop();
// 8> 解綁服務
if (mBound) {
unbindService(mConnection);
mBound = false;
}
}
}
請注意，此示例並未說明服務如何對客戶端作出響應。如果您想讓服務作出響應，則還需要在客戶端中創建一個 Messenger。然後，當客戶端收到 onServiceConnected() 回調時，會向服務發送一條 Message，並在其 send() 方法的 replyTo 參數中包含客戶端的 Messenger。
如需查看如何提供雙向消息傳遞的示例，請參閱 MessengerService.java（服務）和 MessengerServiceActivities.java（客戶端）示例。
AIDL（Android Interface Definition Language）接口定義語言。它定義一個編程接口，這個接口是客戶端與服務端都約定一致的用來跨進程通信。
注意：只有當允許讓來自不同應用的客戶端跨進程通信（IPC）訪問你的服務並且在你的服務中有多個線程需要處理，才有必要使用AIDL。 如果沒有必要處理並發跨進程(IPC)訪問不同的應用，應該通過實現Binder接口，或者如果你想執行跨進程通信，但又沒有必要處理多線程， 使用Messager 來實現接口。
AIDL接口的調用采用的是直接的函數調用方式，但你無法預知哪個進程（或線程）將調用該接口。同進程的線程調用和其他進程調用該接口之間是有所區別的：
在同進程中調用AIDL接口，AIDL接口代碼的執行將在調用該AIDL接口的線程中完成， 如果在主UI線程中調用AIDL接口，那麼AIDL接口代碼的執行將會在這個主UI線程中完成。 如果是其他線程，AIDL接口代碼的執行將在service中完成。 因此，如果僅僅是本進程中的線程訪問該服務，你完全可以控制哪些線程將訪問這個服務（但是如果是這樣，那就完全沒必要使用AIDL了,采取Binder接口的方式更為合適）。 遠程進程（其他線程）調用AIDL接口時，將會在AIDL所屬的進程的線程池中分派一個線程來執行該AIDL代碼， 所以編寫AIDL時，你必須准備好可能有未知線程訪問、同一時間可能有多個調用發生（多個線程的訪問）， 所以ADIL接口的實現必須是線程安全的。 可以用關鍵字oneway來標明遠程調用的行為屬性，如果使用了該關鍵字，那麼遠程調用將僅僅是調用所需的數據傳輸過來並立即返回，而不會等待結果的返回，也即是說不會阻塞遠程線程的運行。 AIDL接口將最終將獲得一個從Binder線程池中產生的調用（和普通的遠程調用類似）。 如果關鍵字oneway在本地調用中被使用，將不會對函數調用有任何影響。
AIDL接口使用後綴名位.aidl的文件來定義，.aidl文件使用java語法編寫，並且將該.aidl文件保存在 src/目錄下（無論是服務端還是客戶端都得保存同樣的一份拷貝，也就是說只要是需要使用到該AIDL接口的應用程序都得在其src目錄下擁有一份.aidl文件的拷貝）。
要創建一個通過AIDL綁定的服務，采用下面的步驟。
1>創建.aidl文件。這個文件定義了帶有方法簽名的接口 2>實現該接口。Android SDK工具會根據你的.aidl文件以Java編程語言生成一個接口。 該接口有一個叫做Stub的內部抽象類， 它繼承自Binder並且實現了你在AIDL接口中定義的方法。你必須繼承Stub類然後實現它的方法。 3>暴露接口給客戶端。實現一個 Service並且覆蓋 onBind() 方法，返回你針對Stub類的實現.
1、創建.aidl文件
每一個.aidl文件只能定義一個接口，只需要申明該接口的方法（不需要實現）。
AIDL默認支持下面幾種數據類型：
![這裡寫圖片描述](https://www.android5.online/Android/UploadFiles_5356/201702/2017022217100218.png "\")
