Android Service詳解
1、Service的種類
一、本地服務， Local Service 用於應用程序內部。在Service能夠調用Context.startService()啓動，調用Context.stopService()結束。在內部能夠調用Service.stopSelf() 或 Service.stopSelfResult()來本身中止。不管調用了多少次startService()，都只需調用一次stopService()來中止。java
二、遠程服務， Remote Service 用於android系統內部的應用程序之間。能夠定義接口並把接口暴露出來，以便其餘應用進行操做。客戶端創建到服務對象的鏈接，並經過那個鏈接來調用服務。調用Context.bindService()方法創建鏈接，並啓動，以調用 Context.unbindService()關閉鏈接。多個客戶端能夠綁定至同一個服務。若是服務此時尚未加載，bindService()會先加載它。android
提供給可被其餘應用複用，好比定義一個天氣預報服務，提供與其餘應用調用便可。windows
2、生命週期
1). 被啓動的服務的生命週期：若是一個Service被某個Activity 調用 Context.startService方法啓動，那麼無論是否有Activity使用bindService綁定或unbindService解除綁定到該Service，該Service都在後臺運行。若是一個Service被startService 方法屢次啓動，那麼onCreate方法只會調用一次，onStart將會被調用屢次（對應調用startService的次數），而且系統只會建立Service的一個實例（所以你應該知道只須要一次stopService調用）。該Service將會一直在後臺運行，而無論對應程序的Activity是否在運行，直到被調用stopService，或自身的stopSelf方法。固然若是系統資源不足，android系統也可能結束服務。服務器
2). 被綁定的服務的生命週期：若是一個Service被某個Activity 調用 Context.bindService 方法綁定啓動，無論調用 bindService調用幾回，onCreate方法都只會調用一次，同時onStart方法始終不會被調用。當鏈接創建以後，Service將會一直運行，除非調用Context.unbindService 斷開鏈接或者以前調用bindService 的 Context 不存在了（如Activity被finish的時候），系統將會自動中止Service，對應onDestroy將被調用。架構
3).被啓動又被綁定的服務的生命週期：若是一個Service又被啓動又被綁定，則該Service將會一直在後臺運行。而且無論如何調用，onCreate始終只會調用一次，對應startService調用多少次，Service的onStart便會調用多少次。調用unbindService將不會中止Service，而必須調用 stopService 或 Service的 stopSelf 來中止服務。app
4).當服務被中止時清除服務：當一個Service被終止（一、調用stopService；二、調用stopSelf；三、再也不有綁定的鏈接（沒有被啓動））時，onDestroy方法將會被調用，在這裏你應當作一些清除工做，如中止在Service中建立並運行的線程。異步
特別注意：ide
一、你應當知道在調用 bindService 綁定到Service的時候，你就應當保證在某處調用 unbindService 解除綁定（儘管Activity被finish的時候綁定會自動解除，而且Service會自動中止）。函數
二、你應當注意 使用 startService 啓動服務以後，必定要使用 stopService中止服務，無論你是否使用bindService。工具
三、同時使用 startService 與 bindService 要注意到，Service 的終止，須要unbindService與stopService同時調用，才能終止 Service，無論 startService 與 bindService 的調用順序，若是先調用 unbindService 此時服務不會自動終止，再調用 stopService 以後服務纔會中止，若是先調用 stopService 此時服務也不會終止，而再調用 unbindService 或者 以前調用 bindService 的 Context 不存在了（如Activity 被 finish 的時候）以後服務纔會自動中止。
四、當在旋轉手機屏幕的時候，當手機屏幕在「橫」「豎」變換時，此時若是你的 Activity 若是會自動旋轉的話，旋轉實際上是 Activity 的從新建立，所以旋轉以前的使用 bindService 創建的鏈接便會斷開（Context 不存在了），對應服務的生命週期與上述相同。
五、在 sdk 2.0 及其之後的版本中，對應的 onStart 已經被否決變爲了 onStartCommand，不過以前的 onStart 任然有效。這意味着，若是你開發的應用程序用的 sdk 爲 2.0 及其之後的版本，那麼你應當使用 onStartCommand 而不是 onStart。
例子：
public class ServiceDemo extends Service {
public static final String TAG = "ServiceDemo" ;
public static final String ACTION = "com.demo.SERVICE_DEMO";
/**
* onBind 是 Service 的虛方法，所以咱們不得不實現它。
* 返回 null，表示客服端不能創建到此服務的鏈接，因此不會調用onServiceConnected。
*/
@Override
public IBinder onBind(Intent intent) {
Log.i(TAG, this.toString() + " ServiceDemo onBind");
return null;
}
@Override
public void onCreate() {
Log.i(TAG, this.toString() + " ServiceDemo onCreate");
super.onCreate();
}
@Override
public void onStart(Intent intent, int startId) {
Log.i(TAG, this.toString() + " ServiceDemo onStart");
super.onStart(intent, startId);
}
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
Log.i(TAG, this.toString() + " ServiceDemo onStartCommand");
return super.onStartCommand(intent, flags, startId);
}
@Override
public boolean onUnbind(Intent intent) {
Log.i(TAG, this.toString() + " ServiceDemo onUnbind");
return super.onUnbind(intent);
}
@Override
public void onDestroy() {
Log.i(TAG, this.toString() + " ServiceDemo onDestroy");
super.onDestroy();
}
}
<!-- android:exported 這個屬性用於指示該服務是否可以被其餘應用程序組件調用或跟它交互。 若是設置爲true，則可以被調用或交互，不然不能。設置爲false時， 只有同一個應用程序的組件或帶有相同用戶ID的應用程序才能啓動或綁定該服務。--> <service android:name=".ServiceDemo" android:exported="false"> <intent-filter> <action android:name="com.demo.SERVICE_DEMO" /> <category android:name="android.intent.category.default" /> </intent-filter> </service>
經過Context.startService(Intent)方法啓動service或者Context.bindService方法來綁定service。
public class MainActivity extends ActionBarActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
findViewById(R.id.btn_bindService).setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
bindService(new Intent(ServiceDemo.ACTION), conn, BIND_AUTO_CREATE);
}
});
findViewById(R.id.btn_unbindService).setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
unbindService(conn);
}
});
findViewById(R.id.btn_startService).setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
startService(new Intent(ServiceDemo.ACTION));
}
});
findViewById(R.id.btn_stopService).setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
stopService(new Intent(ServiceDemo.ACTION));
}
});
}
ServiceConnection conn = new ServiceConnection() {
public void onServiceConnected(ComponentName name, IBinder service) {
Log.i(ServiceDemo.TAG, service.toString() + " onServiceConnected");
}
public void onServiceDisconnected(ComponentName name) {
Log.i(ServiceDemo.TAG, "onServiceDisconnected");
}
};
@Override
protected void onDestroy() {
super.onDestroy();
}
}
日誌輸出：
上面的截圖是點擊綁定服務時輸出的。能夠看出，只調用了onCreate方法和onBind方法，當重複點擊綁定服務時，沒有再輸出任何日誌，而且不報錯。onCreate方法是在第一次建立Service時調用的，並且只調用一次。另外，在綁定服務時，給定了參數BIND_AUTO_CREATE，即當服務不存在時，自動建立，若是服務已經啓動了或者建立了，那麼只會掉調用onBind方法。
當解除綁定的時，能夠看出，Service調用onUnbind和onDestroy銷燬了服務。
上面的截圖是在屢次點擊啓動服務時輸出的。能夠看出，在第一次點擊時，由於Service還未建立，因此調用了onCreate方法，緊接着調用了onStartCommand和onStart方法。當再次點擊啓動服務時，仍然調用了onStartCommand和onStart方法，因此，在Service中作任務處理時須要注意這點，由於一個Service能夠被重複啓動。
當點中止服務的時，Service只是執行onDestroy方法，跟綁定仍是有點小區別。
這裏說一下，日常使用多的是startService方法，能夠把一些耗時的任務放到後臺去處理，當處理完成後，能夠經過廣播來通知前臺。
而onBind方法更多的是結合AIDL來使用，這樣一個應用能夠經過綁定服務得到的IBinder來拿到後臺的接口，進而調用AIDL中定義的方法，進行數據交換等。
3、Local 與 Remote 服務綁定
1) Local 服務綁定：Local 服務的綁定較簡單，首先在 Service 中咱們須要實現 Service 的抽象方法 onBind，並返回一個實現 IBinder 接口的對象。
Service 中的代碼：
public class LocalService extends Service{
public static final String TAG = "LocalService" ;
public static final String ACTION = "com.demo.LOCAL_SERVICE";
public SimpleBinder sBinder;
public class SimpleBinder extends Binder{
public LocalService getService(){
return LocalService.this;
}
public int add(int a, int b){
return a + b;
}
}
@Override
public void onCreate() {
super.onCreate();
// 建立 SimpleBinder
sBinder = new SimpleBinder();
}
@Override
public IBinder onBind(Intent intent) {
// 返回 SimpleBinder 對象
Log.i(TAG, "LocalService onBind");
return sBinder;
}
@Override
public boolean onUnbind(Intent intent) {
Log.i(TAG, "LocalService onUnbind");
return super.onUnbind(intent);
}
}
<service android:name=".LocalService" android:exported="false"> <intent-filter> <action android:name="com.demo.LOCAL_SERVICE" /> <category android:name="android.intent.category.default" /> </intent-filter> </service>
public class LocalActivity extends ActionBarActivity {
private ServiceConnection sc;
private boolean isBind;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_local);
sc = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.i(LocalService.TAG, "onServiceConnected");
LocalService.SimpleBinder sBinder = (LocalService.SimpleBinder)service;
Log.i(LocalService.TAG, "3 + 5 = " + sBinder.add(3, 5));
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.i(LocalService.TAG, " onServiceDisconnected");
}
};
findViewById(R.id.btn_bindService).setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
bindService(new Intent(LocalService.ACTION), sc, Context.BIND_AUTO_CREATE);
isBind = true;
}
});
findViewById(R.id.btn_unbindService).setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
if(isBind){
unbindService(sc);
isBind = false;
}
}
});
}
}
在 Activity 中，咱們經過 ServiceConnection 接口來取得創建鏈接 與 鏈接意外丟失的回調。bindService有三個參數，第一個是用於區分 Service 的Intent 與 startService 中的 Intent 一致，第二個是實現了 ServiceConnection 接口的對象，最後一個是 flag 標誌位。有兩個flag，BIND_DEBUG_UNBIND 與 BIND_AUTO_CREATE，前者用於調試（詳細內容能夠查看javadoc 上面描述的很清楚），後者默認使用。unbindService 解除綁定，參數則爲以前建立的 ServiceConnection 接口對象。另外，屢次調用 unbindService 來釋放相同的鏈接會拋出異常，所以我建立了一個 boolean 變量來判斷是否 unbindService 已經被調用過。
運行結果：
在綁定服務的時候，須要一個服務鏈接對象，ServiceConnection，服務一旦鏈接，就會調用onServiceConnected方法，咱們能夠在這個方法裏面返回咱們的本地服務對象，具體看代碼；而在服務斷開時候會調用onServiceDisconnected方法，咱們能夠清理一些服務資源。
2) Remote 服務綁定：以前所談的Service屬於Local Service，即Service和Client在同一進程內（即同一application內），Service的生命週期服從進程的生命週期。在實際應用上，有時但願Service做爲後臺服務，不只被同一進程內的activity使用，也可被其餘進程所使用。
一般每一個應用程序都在它本身的進程內運行，但有時須要在進程之間傳遞對象（IPC通訊），你能夠經過應用程序UI的方式寫個運行在一個不一樣的進程中的service。在android平臺中，一個進程一般不能訪問其它進程中的內存區域。因此，他們須要把對象拆分紅操做系統能理解的簡單形式，以便假裝成對象跨越邊界訪問。編寫這種假裝代碼至關的枯燥乏味，好在android爲咱們提供了AIDL工具能夠來作這件事。
AIDL(android接口描述語言)是一個IDL語言，它能夠生成一段代碼，可使在一個android設備上運行的兩個進程使用內部通訊進程進行交互。若是你須要在一個進程中(例如在一個Activity中)訪問另外一個進程中(例如一個Service)某個對象的方法，你就可使用AIDL來生成這樣的代碼來假裝傳遞各類參數。
Android提供AIDL（Android Interface Definition Language）工具幫助IPC之間接口的創建，大大地簡化了開發者視圖。經過下面的步驟實現client和service之間的通訊：
1）定義AIDL接口 ，Eclipse將自動爲Service創建接口IService
2）Client鏈接Service，鏈接到IService暴露給Client的Stub，得到stub對象；換句話，Service經過接口中的Stub向client提供服務，在IService中對抽象IService.Stub具體實現。
3）Client和Service鏈接後，Client可向使用本地方法那樣，簡單地直接調用IService.Stub裏面的方法。
下面的例子給出client從提供定時計數的Remote Service，稱爲TestRemoteService，中得到服務的例子。
步驟1：經過AIDL文件定義Service向client提供的接口，ITestRemoteService.aidl文件以下
interface ITestRemoteService {
int getCounter();
}
咱們在src的目錄下添加一個ITestRemoteService.aidl文件，語法和java的相同。在這個例子中Service很簡單，只提供計數器的值，故在接口中咱們定義了int getCounter( )。
AIDL文件很簡單，Eclipse會根據文件自動生成相關的一個java interface文件，不過沒有顯示出來，若是直接使用命令行工具會幫助生成java文件。
步驟2：Remote Service的編寫，經過onBind()，在client鏈接時，傳遞stub對象。 TestRemoteService.java文件以下：
//Service提供一個定時計數器，採用Runnable的方式實現。
public class TestRemoteService extends Service{
private Handler serviceHandler = null;
private int counter = 0;
private TestCounterTask myTask = new TestCounterTask();
public void onCreate() {
super.onCreate();
showInfo("remote service onCreate()");
}
public void onDestroy() {
super.onDestroy();
serviceHandler.removeCallbacks(myTask); //中止計數器
serviceHandler = null;
showInfo("remote service onDestroy()");
}
public void onStart(Intent intent, int startId) {
// 開啓計數器
super.onStart(intent, startId);
serviceHandler=new Handler();
serviceHandler.postDelayed(myTask, 1000);
showInfo("remote service onStart()");
}
//步驟2.1：具體實現接口中暴露給client的Stub，提供一個stub inner class來具體實現。
private ITestRemoteService.Stub stub= new ITestRemoteService.Stub() {
//步驟2.1：具體實現AIDL文件中接口的定義的各個方法。
public int getCounter() throws RemoteException {
showInfo("getCounter()");
return counter;
}
};
//步驟2.2：當client鏈接時，將觸發onBind()，Service向client返回一個stub對象，
//由此client能夠經過stub對象來訪問Service，本例中經過stub.getCounter()就能夠得到計時器的當前計數。
//在這個例子中，咱們向全部的client傳遞同一stub對象。
public IBinder onBind(Intent arg0) {
//咱們特別跟蹤了stub對象的地址，能夠在client鏈接service中看看經過ServiceConnection傳遞給client
showInfo("onBind() " + stub);
return stub;
}
//用Runnable使用定時計數器，每10秒計數器加1。
private class TestCounterTask implements Runnable{
public void run() {
++ counter;
serviceHandler.postDelayed(myTask,10000);
showInfo("running " + counter);
}
}
//showInfo() 幫助咱們進行信息跟蹤，更好了解Service的運行狀況
private void showInfo(String s){
System.out.println("[" +getClass().getSimpleName()+"@" + Thread.currentThread().getName()+ "] " + s);
}
}
步驟3：Client和Service創建鏈接，得到stub，ServiceTest4.java代碼以下
public class ServiceTest4 extends Activity{
//步驟3.1 定義接口變量
private ITestRemoteService remoteService = null;
private boolean isStarted = false;
//步驟3.1 定義鏈接變量，實現ServiceConnection接口
private CounterServiceConnection conn = null;
protected void onCreate(Bundle savedInstanceState) {
//5個button分別觸發startService( )，stopService( ) ,
//bindService( ), releaseService( )和invokeService( )，
//下面兩行，一行是顯示從Service中得到的計數值，一行顯示狀態。
}
private void startService(){
Intent i = new Intent();
//個人這個包裏面還有層次，如*.part一、*.part2,etc
i.setClassName("com.wei.android.learning", "com.wei.android.learning.part5.TestRemoteService");
//和以前的local service同樣，經過intent開啓Service，觸發onCreate()[if Service沒有開啓]->onStart()
startService(i);
isStarted = true;
updateServiceStatus();
}
private void stopService(){
Intent i = new Intent();
i.setClassName("com.wei.android.learning","com.wei.android.learning.part5.TestRemoteService");
stopService(i); //觸發Service的 onDestroy()[if Service存在]
isStarted = false;
updateServiceStatus();
}
//步驟3.3：bindService( )經過一個實現ServiceConnection接口的類於Service之間創建鏈接，
//注意到裏面的參數Context.BIND_AUTO_CREATE，觸發onCreate()[if Service不存在] –> onBind().
private void bindService(){
if(conn == null){
conn = new CounterServiceConnection();
Intent i = new Intent();
i.setClassName("com.wei.android.learning","com.wei.android.learning.part5.TestRemoteService");
bindService(i, conn,Context.BIND_AUTO_CREATE);
updateServiceStatus();
}
}
private void releaseService(){
if(conn !=null){
unbindService(conn); //斷開鏈接，解除綁定
conn = null;
updateServiceStatus();
}
}
private void invokeService(){
if(conn != null){
try{
//一旦client成功綁定到Service，就能夠直接使用stub中的方法。
Integer counter =remoteService.getCounter();
TextView t = (TextView)findViewById(R.id.st4_notApplicable);
t.setText("Counter value : " + Integer.toString(counter));
}catch(RemoteException e){
Log.e(getClass().getSimpleName(),e.toString());
}
}
}
//步驟3.2 class CounterServiceConnection實現ServiceConnection接口，
//須要具體實現裏面兩個觸發onServiceConnected()和onServiceDisconnected()
private class CounterServiceConnection implements ServiceConnection{
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
// 從鏈接中得到stub對象，根據咱們的跟蹤，remoteService就是service中的stub對象
remoteService = ITestRemoteService.Stub.asInterface(service);
showInfo("onServiceConnected()" + remoteService);
}
@Override
public void onServiceDisconnected(ComponentName name) {
remoteService = null;
updateServiceStatus();
showInfo("onServiceDisconnected");
}
}
private void updateServiceStatus() {
TextView t = (TextView)findViewById( R.id.st4_serviceStatus);
t.setText( "Service status: "+(conn == null ? "unbound" : "bound")+ ","+ (isStarted ? "started" : "not started"; ));
}
private void showInfo(String s){
System.out.println("[" +getClass().getSimpleName()+"@" + Thread.currentThread().getName()+ "] " + s);
}
}
注意：
Service.onBind若是返回null，則調用 bindService 會啓動 Service，但不會鏈接上 Service，所以 ServiceConnection.onServiceConnected 不會被調用，但你任然須要使用 unbindService 函數斷開它，這樣 Service 纔會中止。
其它：
一、在什麼狀況下使用 startService 或 bindService 或 同時使用startService 和 bindService
若是你只是想要啓動一個後臺服務長期進行某項任務那麼使用 startService 即可以了。若是你想要與正在運行的 Service 取得聯繫，那麼有兩種方法，一種是使用 broadcast ，另外是使用 bindService ，前者的缺點是若是交流較爲頻繁，容易形成性能上的問題，而且 BroadcastReceiver 自己執行代碼的時間是很短的（也許執行到一半，後面的代碼便不會執行），然後者則沒有這些問題，所以咱們確定選擇使用 bindService（這個時候你便同時在使用 startService 和 bindService 了，這在 Activity 中更新 Service 的某些運行狀態是至關有用的）。另外若是你的服務只是公開一個遠程接口，供鏈接上的客服端（android 的 Service 是C/S架構）遠程調用執行方法。這個時候你能夠不讓服務一開始就運行，而只用 bindService ，這樣在第一次 bindService 的時候纔會建立服務的實例運行它，這會節約不少系統資源，特別是若是你的服務是Remote Service，那麼該效果會越明顯（固然在 Service 建立的時候會花去必定時間，你應當注意到這點）。
二、在 AndroidManifest.xml 裏 Service 元素的常見選項
android:name，服務類名
android:label，服務的名字，若是此項不設置，那麼默認顯示的服務名則爲類名
android:icon，服務的圖標
android:permission，申明此服務的權限，這意味着只有提供了該權限的應用才能控制或鏈接此服務
android:process，表示該服務是否運行在另一個進程，若是設置了此項，那麼將會在包名後面加上這段字符串表示另外一進程的名字
android:enabled，若是此項設置爲 true，那麼 Service 將會默認被系統啓動，不設置默認此項爲 false
android:exported，表示該服務是否可以被其餘應用程序所控制或鏈接，不設置默認此項爲 false
三、Service 與 Thread 的區別
不少時候，你可能會問，爲何要用 Service，而不用 Thread 呢，由於用 Thread 是很方便的，比起 Service 也方便多了，下面我詳細的來解釋一下。
1). Thread：Thread 是程序執行的最小單元，它是分配CPU的基本單位。能夠用 Thread 來執行一些異步的操做。
2). Service：Service 是android的一種機制，當它運行的時候若是是Local Service，那麼對應的 Service 是運行在主進程的 main 線程上的。如：onCreate，onStart 這些函數在被系統調用的時候都是在主進程的 main 線程上運行的。若是是Remote Service，那麼對應的 Service 則是運行在獨立進程的 main 線程上。所以請不要把 Service 理解成線程，它跟線程半毛錢的關係都沒有！
既然這樣，那麼咱們爲何要用 Service 呢？其實這跟 android 的系統機制有關，咱們先拿 Thread 來講。Thread 的運行是獨立於 Activity 的，也就是說當一個 Activity 被 finish 以後，若是你沒有主動中止 Thread 或者 Thread 裏的 run 方法沒有執行完畢的話，Thread 也會一直執行。所以這裏會出現一個問題：當 Activity 被 finish 以後，你再也不持有該 Thread 的引用。另外一方面，你沒有辦法在不一樣的 Activity 中對同一 Thread 進行控制。
舉個例子：若是你的 Thread 須要不停地隔一段時間就要鏈接服務器作某種同步的話，該 Thread 須要在 Activity 沒有start的時候也在運行。這個時候當你 start 一個 Activity 就沒有辦法在該 Activity 裏面控制以前建立的 Thread。所以你便須要建立並啓動一個 Service ，在 Service 裏面建立、運行並控制該 Thread，這樣便解決了該問題（由於任何 Activity 均可以控制同一 Service，而系統也只會建立一個對應 Service 的實例）。
所以你能夠把 Service 想象成一種消息服務，而你能夠在任何有 Context 的地方調用 Context.startService、Context.stopService、Context.bindService，Context.unbindService，來控制它，你也能夠在 Service 裏註冊 BroadcastReceiver，在其餘地方經過發送 broadcast 來控制它，固然這些都是 Thread 作不到的。
四、擁有service的進程具備較高的優先級
官方文檔告訴咱們，Android系統會盡可能保持擁有service的進程運行，只要在該service已經被啓動(start)或者客戶端鏈接(bindService)到它。當內存不足時，須要保持，擁有service的進程具備較高的優先級。
1). 若是service正在調用onCreate,onStartCommand或者onDestory方法，那麼用於當前service的進程則變爲前臺進程以免被killed。
2). 若是當前service已經被啓動(start)，擁有它的進程則比那些用戶可見的進程優先級低一些，可是比那些不可見的進程更重要，這就意味着service通常不會被killed.
3). 若是客戶端已經鏈接到service (bindService),那麼擁有Service的進程則擁有最高的優先級，能夠認爲service是可見的。
4). 若是service可使用startForeground(int, Notification)方法來將service設置爲前臺狀態，那麼系統就認爲是對用戶可見的，並不會在內存不足時killed。
若是有其餘的應用組件做爲Service,Activity等運行在相同的進程中，那麼將會增長該進程的重要性。
五、注意事項
Service的onCreate的方法只會被調用一次，就是你不管多少次的startService又 bindService，Service只被建立一次。若是先是bind了，那麼start的時候就直接運行Service的onStart方法，若是先是start，那麼bind的時候就直接運行onBind方法。若是你先bind上了，就stop不掉了，只能先UnbindService, 再StopService,因此是先start仍是先bind行爲是有區別的。
Android中的服務和windows中的服務是相似的東西，服務通常沒有用戶操做界面，它運行於系統中不容易被用戶發覺，可使用它開發如監控之類的 程序。
服務不能本身運行，須要經過調用Context.startService()或Context.bindService()方法啓動服務。
這兩個方法均可以啓動Service，可是它們的使用場合有所不一樣。使用startService()方法啓用服務，調用者與服務之間沒有關連，即便調用者退出了，服務仍然運行。使用bindService()方法啓用服務，調用者與服務綁定在了一塊兒，調用者一旦退出，服務也就終止，大有「不求同 時生，必須同時死」的特色。
若是打算採用Context.startService()方法啓動服務，在服務未被建立時，系統會先調用服務的onCreate()方法，接着調用onStart()方法。若是調用startService()方法前服務已經被建立，屢次調用startService()方法並不會致使屢次 建立服務，但會致使屢次調用onStart()方法。採用startService()方法啓動的服務，只能調用Context.stopService()方法結 束服務，服務結束時會調用onDestroy()方法。
若是打算採用Context.bindService()方法啓動服務，在服務未被建立時，系統會先調用服務的onCreate()方法，接着調用onBind()方法。這個時候調用者和服務綁定在一塊兒，調用者退出了，系統就會先調用服務的onUnbind()方法，接着調用onDestroy()方法。若是調用bindService()方法前服務已經被綁定，屢次調用bindService()方法並不會致使屢次建立服務及綁定(也就是說onCreate()和onBind()方法並不會被屢次調用)。
若是調用者但願與正在綁定的服務解除綁定，能夠調用unbindService()方法，調用該方法也會致使系統調用服務的 onUnbind()-->onDestroy()方法.
- 1. 【Android】詳解Android Service
- 2. Android Service -詳解
- 3. android service詳解
- 4. Android Service詳解
- 5. Android Service 詳解
- 6. Android之Service詳解
- 7. Android Service詳解(一)
- 8. Android Service 詳解（上）
- 9. Android Service詳解(二)
- 10. Android Service學習篇一：Service詳解
- 更多相關文章...
- • 免費ARP詳解 - TCP/IP教程
- • *.hbm.xml映射文件詳解 - Hibernate教程
- • Flink 數據傳輸及反壓詳解
- • 爲了進字節跳動，我精選了29道Java經典算法題，帶詳細講解
-
每一个你不满意的现在，都有一个你没有努力的曾经。