Service是在一段不定的時間運行在后臺，不和用戶交互應用組件。每個Service必須在manifest中 通過來聲明。可以通過contect.startservice和contect.bindserverice來啟動。

Service和其他的應用組件一樣，運行在進程的主線程中。這就是說如果service需要很多耗時或者阻塞的操作，需要在其子線程中實現。

service的兩種模式（startService()/bindService()不是完全分離的）：

• 本地服務 Local Service 用于應用程序內部。

  它可以啟動并運行，直至有人停止了它或它自己停止。在這種方式下，它以調用Context.startService()啟動，而以調用 Context.stopService()結束。它可以調用Service.stopSelf() 或 Service.stopSelfResult()來自己停止。不論調用了多少次startService()方法，你只需要調用一次 stopService()來停止服務。

  用于實現應用程序自己的一些耗時任務，比如查詢升級信息，并不占用應用程序比如Activity所屬線程，而是單開線程后臺執行，這樣用戶體驗比較好。

• 遠程服務 Remote Service 用于android系統內部的應用程序之間。

  它可以通過自己定義并暴露出來的接口進行程序操作。客戶端建立一個到服務對象的連接，并通過那個連接來調用服務。連接以調用 Context.bindService()方法建立，以調用 Context.unbindService()關閉。多個客戶端可以綁定至同一個服務。如果服務此時還沒有加載，bindService()會先加載 它。

  可被其他應用程序復用，比如天氣預報服務，其他應用程序不需要再寫這樣的服務，調用已有的即可。

生命周期

Service的生命周期并不像Activity那么復雜，它只繼承了onCreate(),onStart(),onDestroy()三個方法，當我 們第一次啟動Service時，先后調用了onCreate(),onStart()這兩個方法，當停止Service時，則執行onDestroy() 方法，這里需要注意的是，如果Service已經啟動了，當我們再次啟動Service時，不會在執行onCreate()方法，而是直接執行 onStart()方法。

而啟動service，根據onStartCommand的返回值不同，有兩個附加的模式：

1. START_STICKY 用于顯示啟動和停止service。

2. START_NOT_STICKY或START_REDELIVER_INTENT用于有命令需要處理時才運行的模式。

服務不能自己運行，需要通過調用Context.startService()或Context.bindService()方法啟動服務。這兩個方法都可以啟動Service，但是它們的使用場合有所不同。

1. 使用startService()方法啟用服務，調用者與服務之間沒有關連，即使調用者退出了，服務仍然運行。

如果打算采用Context.startService()方法啟動服務，在服務未被創建時，系統會先調用服務的onCreate()方法，接著調用onStart()方法。

如果調用startService()方法前服務已經被創建，多次調用startService()方法并不會導致多次創建服務，但會導致多次調用onStart()方法。

采用startService()方法啟動的服務，只能調用Context.stopService()方法結束服務，服務結束時會調用onDestroy()方法。

2. 使用bindService()方法啟用服務，調用者與服務綁定在了一起，調用者一旦退出，服務也就終止，大有“不求同時生，必須同時死”的特點。

onBind()只有采用Context.bindService()方法啟動服務時才會回調該方法。該方法在調用者與服務綁定時被調用，當調用者與服務已經綁定，多次調用Context.bindService()方法并不會導致該方法被多次調用。

采用Context.bindService()方法啟動服務時只能調用onUnbind()方法解除調用者與服務解除，服務結束時會調用onDestroy()方法。

看看官方給出的比較流程示意圖：

官方文檔告訴我們，一個service可以同時start并且bind，在這樣的情況，系統會一直保持service的運行狀態如果service已經 start了或者BIND_AUTO_CREATE標志被設置。如果沒有一個條件滿足，那么系統將會調用onDestory方法來終止service.所 有的清理工作（終止線程，反注冊接收器）都在onDestory中完成。

擁有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

1.不需和Activity交互的本地服務

public  class LocalService  extends Service {  
 
         private  static  final String TAG =  "LocalService";  
 
        @Override  
         public IBinder onBind(Intent intent) {  
                Log.i(TAG,  "onBind");  
                 return  null;  
        }  
 
        @Override  
         public  void onCreate() {  
                Log.i(TAG,  "onCreate");  
                 super.onCreate();  
        }  
 
        @Override  
         public  void onDestroy() {  
                Log.i(TAG,  "onDestroy");  
                 super.onDestroy();  
        }  
 
        @Override  
         public  void onStart(Intent intent,  int startId) {  
                Log.i(TAG,  "onStart");  
                 super.onStart(intent, startId);  
        }  
} 
  
Activity: 
public  class ServiceActivity  extends Activity {  
 
        @Override  
         protected  void onCreate(Bundle savedInstanceState) {  
                 super.onCreate(savedInstanceState);  
                setContentView(R.layout.servicedemo);  
 
                ((Button) findViewById(R.id.startLocalService)).setOnClickListener(  
                                 new View.OnClickListener(){  
 
                                        @Override  
                                         public  void onClick(View view) {  
                                                 // TODO Auto-generated method stub  
                                                startService(new Intent("com.demo.SERVICE_DEMO"));  
                                        }   
                                });  
 
                ((Button) findViewById(R.id.stopLocalService)).setOnClickListener(  
                                 new View.OnClickListener(){  
 
                                        @Override  
                                         public  void onClick(View view) {  
                                                 // TODO Auto-generated method stub  
                                                 stopService(new Intent("com.demo.SERVICE_DEMO"));  
                                        }  
                                });  
        }  
 
} 

在AndroidManifest.xml添加：

< service  android:name =".LocalService" >  
         < intent-filter >  
                 < action  android:name ="com.demo.SERVICE_DEMO"  />  
                 < category  android:name ="android.intent.category.default"  />  
          intent-filter >  
 service > 

否則啟動服務時會提示new Intent找不到"com.demo.SERVICE_DEMO"。

對于這類不需和Activity交互的本地服務，是使用startService/stopService的最好例子。

運行時可以發現第一次startService時，會調用onCreate和onStart，在沒有stopService前，無論點擊多少次 startService，都只會調用onStart。而stopService時調用onDestroy。再次點擊stopService，會發現不會 進入service的生命周期的，即不會再調用onCreate，onStart和onDestroy。

而onBind在startService/stopService中沒有調用。

2.本地服務和Activity交互

對于這種case，官方的sample(APIDemo\app.LocalService)是最好的例子:

/**  
* This is an example of implementing an application service that runs locally  
* in the same process as the application.    The {@link LocalServiceController}  
* and {@link LocalServiceBinding} classes show how to interact with the  
* service.  
*  
* 
Notice the use of the {@link NotificationManager} when interesting things  
* happen in the service.    This is generally how background services should  
* interact with the user, rather than doing something more disruptive such as  
* calling startActivity().  
*/  
public  class LocalService  extends Service {  
         private NotificationManager mNM;  
 
         /**  
         * Class for clients to access.    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 LocalService.this;  
                }  
        }  
          
        @Override  
         public  void onCreate() {  
                mNM = (NotificationManager)getSystemService(NOTIFICATION_SERVICE);  
 
                 // Display a notification about us starting.    We put an icon in the status bar.  
                showNotification();  
        }  
 
        @Override  
         public  int onStartCommand(Intent intent,  int flags,  int startId) {  
                Log.i( "LocalService",  "Received start id " + startId +  ": " + intent);  
                 // We want this service to continue running until it is explicitly  
                 // stopped, so return sticky.  
                 return START_STICKY;  
        }  
 
        @Override  
         public  void onDestroy() {  
                 // Cancel the persistent notification.  
                mNM.cancel(R.string.local_service_started);  
 
                 // Tell the user we stopped.  
                Toast.makeText( this, R.string.local_service_stopped, Toast.LENGTH_SHORT).show();  
        }  
 
        @Override  
        public IBinder onBind(Intent intent) {  
             return mBinder; 
        }  
 
         // This is the object that receives interactions from clients.    See  
         // RemoteService for a more complete example.  
        private final IBinder mBinder = new LocalBinder();  
 
         /**  
         * Show a notification while this service is running.  
         */  
         private  void showNotification() {  
                 // In this sample, we'll use the same text for the ticker and the expanded notification  
                CharSequence text = getText(R.string.local_service_started);  
 
                 // Set the icon, scrolling text and timestamp  
                Notification notification =  new Notification(R.drawable.stat_sample, text,  
                                System.currentTimeMillis());  
 
                 // The PendingIntent to launch our activity if the user selects this notification  
                PendingIntent contentIntent = PendingIntent.getActivity( this, 0,  
                                 new Intent( this, LocalServiceController. class), 0);  
 
                 // Set the info for the views that show in the notification panel.  
                notification.setLatestEventInfo( this, getText(R.string.local_service_label),  
                                             text, contentIntent);  
 
                 // Send the notification.  
                 // We use a layout id because it is a unique number.    We use it later to cancel.  
                mNM.notify(R.string.local_service_started, notification);  
        }  
} 

這里可以發現onBind需要返回一個IBinder對象。也就是說和上一例子LocalService不同的是，

1. 添加了一個public內部類繼承Binder，并添加getService方法來返回當前的Service對象；

2. 新建一個IBinder對象——new那個Binder內部類；

3. onBind方法返還那個IBinder對象。

/**  
* 
Example of binding and unbinding to the {@link LocalService}.  
* This demonstrates the implementation of a service which the client will  
* bind to, receiving an object through which it can communicate with the service.
  
*/  
public  class LocalServiceBinding  extends Activity {  
         private  boolean mIsBound;  
         private LocalService mBoundService;  
 
        @Override  
         protected  void onCreate(Bundle savedInstanceState) {  
                 super.onCreate(savedInstanceState);  
 
                setContentView(R.layout.local_service_binding);  
 
                 // Watch for button clicks.  
                Button button = (Button)findViewById(R.id.bind);  
                button.setOnClickListener(mBindListener);  
                button = (Button)findViewById(R.id.unbind);  
                button.setOnClickListener(mUnbindListener);  
        }  
 
        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 service object we can use to  
                         // interact with the service.    Because we have bound to a explicit  
                         // service that we know is running in our own process, we can  
                         // cast its IBinder to a concrete class and directly access it.  
                        mBoundService = ((LocalService.LocalBinder)service).getService();   
                          
                         // Tell the user about this for our demo.  
                        Toast.makeText(LocalServiceBinding. this, R.string.local_service_connected,  
                                        Toast.LENGTH_SHORT).show();  
                }  
 
                public void onServiceDisconnected(ComponentName className) {  
                         // This is called when the connection with the service has been  
                         // unexpectedly disconnected -- that is, its process crashed.  
                         // Because it is running in our same process, we should never  
                         // see this happen.  
                        mBoundService =  null;  
                        Toast.makeText(LocalServiceBinding. this, R.string.local_service_disconnected,  
                                        Toast.LENGTH_SHORT).show();  
                }  
        };  
 
         private OnClickListener mBindListener =  new OnClickListener() {  
                 public  void onClick(View v) {  
                         // Establish a connection with the service.    We use an explicit  
                         // class name because we want a specific service implementation that  
                         // we know will be running in our own process (and thus won't be  
                         // supporting component replacement by other applications).  
                         bindService( new Intent(LocalServiceBinding. this,     
                                        LocalService. class),  mConnection, Context.BIND_AUTO_CREATE);  
                        mIsBound =  true;  
                }  
        };  
 
         private OnClickListener mUnbindListener =  new OnClickListener() {  
                 public  void onClick(View v) {  
                         if (mIsBound) {  
                                 // Detach our existing connection.  
                                 unbindService( mConnection);  
                                mIsBound =  false;  
                        }  
                }  
        };  
} 

明顯看出這里面添加了一個名為ServiceConnection類，并實現了onServiceConnected(從IBinder獲取Service對象)和onServiceDisconnected(set Service to null)。

而bindService和unbindService方法都是操作這個ServiceConnection對象的。

AndroidManifest.xml里添加:

< service  android:name =".app.LocalService"  />  
 
< activity  android:name =".app.LocalServiceBinding"  android:label ="@string/activity_local_service_binding" >  
      < intent-filter >  
           < action  android:name ="android.intent.action.MAIN"  />  
           < category  android:name ="android.intent.category.SAMPLE_CODE"  />  
       intent-filter >  
 activity > 

這里沒什么特別的，因為service沒有需要什么特別的action，所以只是聲明service而已，而activity和普通的沒差別。

運行時，發現調用次序是這樣的：

bindService:

1.LocalService : onCreate

2.LocalService : onBind

3.Activity: onServiceConnected

unbindService: 只是調用onDestroy

可見，onStart是不會被調用的，而onServiceDisconnected沒有調用的原因在上面代碼的注釋有說明。

介紹onStartCommand()需要用到的幾個常量 (引自官方文檔)

START_NOT_STICKY

If the system kills the service after onStartCommand() returns, do not recreate the service, unless there are pending intents to deliver. This is the safest option to avoid running your service when not necessary and when your application can simply restart any unfinished jobs.

START_STICKY

If the system kills the service after onStartCommand() returns, recreate the service and call onStartCommand(), but do not redeliver the last intent. Instead, the system calls onStartCommand() with a null intent, unless there were pending intents to start the service, in which case, those intents are delivered. This is suitable for media players (or similar services) that are not executing commands, but running indefinitely and waiting for a job.

START_REDELIVER_INTENT

If the system kills the service after onStartCommand() returns, recreate the service and call onStartCommand() with the last intent that was delivered to the service. Any pending intents are delivered in turn. This is suitable for services that are actively performing a job that should be immediately resumed, such as do wnloading a file.

Running a Service in the Foreground

具體內容查看官方文檔，主要是使用 startForeground() 和 stopForeground()方法。