简介
Service 是Android四大组件之一。与Activity比较相似，它们都代表可执行的程序。Service与Activity的区别在于：Service一直在后台运行，它没有用户界面，具有自己的生命周期。在开发中，如果某个程序组件需要在运行时向用户呈现某种界面，或者该程序需要与用户交互，就需要使用Activity,否则就应该考虑Service。
Service分类
按照启动方式的不同Service可以分为两类:
1>Started Service ：在后台，作为一个独立的可执行单元不能与调用者进行交互，适合在后台做一些独立的耗时任务，比如：下载、上传。
2>Bound Service ：类似client-server模式，此类Service可被多个client端绑定，client与Service可实现双向通信。
下面就按照此分类介绍其创建、启动、销毁、生命周期等一系列知识
1>Started Service
A.创建Service步骤：
类似Activity的开发步骤：1.开发一个Activity子类 2.在配置文件中配置Activity，开发Service也需要两个步骤。
1》定义一个派生自Service或ServiceIntent的子类。
2》在AndroidManifest.xml中配置之
配置示例代码：
<manifest ... >
...
<application ... >
<service android:name=".ExampleService" />
...
</application>
</manifest>
Note:Service 的配置与Activity基本相同，如果开发的Service只供本应用调用则不需要为其配置intent-filter 标签。Service标签下可以配置许多属性，了解更多请参考这里
示例1：继承自Service
View Code
1 package com.example.services;
2
3 import android.app.Service;
4 import android.content.Intent;
5 import android.os.IBinder;
6
7 public class Myservice extends Service {
8
9 @Override
10 public IBinder onBind(Intent intent) {
11 System.out.println("onBind");
12 return null;
13 }
14
15 @Override
16 public void onCreate() {
17 System.out.println("onCreate");
18 super.onCreate();
19 }
20
21 @Override
22 public int onStartCommand(Intent intent, int flags, int startId) {
23 System.out.println("onStartCommand");
24 return super.onStartCommand(intent, flags, startId);
25
26 }
27
28 @Override
29 public void onDestroy() {
30 System.out.println("onDestroy");
31 super.onDestroy();
32 }
33 }
示例2：继承自ServiceIntent
View Code
1 package com.example.services;
2
3 import android.content.Intent;
4
5 public class ExtendIntentService extends android.app.IntentService {
6
7 public ExtendIntentService() {
8 super("ExtendIntentService");
9 }
10
11 @Override
12 protected void onHandleIntent(Intent intent) {
13 System.out
14 .println("onHandleIntent:" + Thread.currentThread().getName());
15 }
16
17 @Override
18 public void onCreate() {
19 super.onCreate();
20 System.out.println("onCreate:" + Thread.currentThread().getName());
21 }
22
23 @Override
24 public int onStartCommand(Intent intent, int flags, int startId) {
25 System.out
26 .println("onStartCommand:" + Thread.currentThread().getName());
27 return super.onStartCommand(intent, flags, startId);
28 }
29
30 @Override
31 public void onDestroy() {
32 super.onDestroy();
33 System.out.println("onDestroy");
34 }
35
36 }
分析：
示例1
继承自Service类，需要我们根据需要实现特定的几个回调方法主要有以下几个：
onBind(Intent intent):该方法是子类必须要实现的方法。该方法返回一个IBinder对象，应用程序可通过此对象与Service通信。
onCreate():当Service第一次被创建时将回调此方法。
onDestroy():当该Service被销毁时将回调此方法。
onStart(Intent intent, int startId)：已被标注Deprecated,被onStartCommand方法取代，其实onStartCommand在内部也是调用onStart，只是多了个int返回值。
int onStartCommand(Intent intent, int flags, int startId):该方法的早期版本是onStart(Intent intent, int startId),每当客户端调用startService(Intent)时系统将 回调此方法。其有一个int返回值，系统根据此值决定当系统由于某种原因(比如：内存紧张)销毁此service后，是否重启它及对intent的处理细节。
onUnbind(Intent intent):当service上绑定的所有方法都断开链接时，将回调此方法。
通过这种方式，我们操作的灵活性较高，但请注意对于某些耗时性的操作我们应该为其开一个单独的线程，以防阻塞UI主线程，因为Service也是运行在主线程中的，对于某些实时性要求较高的请求，我们也可以为其开单独的线程处理。
示例2
ServiceIntent也是Service的一个子类，里面默认实现好了一套消息处理机制(一个单独的线程，Handler,Looper)，在onHandleIntent中是按照FIFO的方式处理所有Client发送过来的intent请求。
B.启动Service
这里只讲通过startService(intent)方式，另一种方式将在下面介绍。我们一般会在Activity中开启一个Service，示例代码：
1 final Intent intent_Service = new Intent(this,
2 ExtendIntentService.class);
3
4 findViewById(R.id.start).setOnClickListener(new OnClickListener() {
5
6 @Override
7 public void onClick(View v) {
8 System.out.println("startService");
9 startService(intent);
10 }
11 });View Code
C.关闭Service
通过start方式启动service，此service并不会自己销毁，即使启动它的组件(比如:Activity)已销毁。所以当我们通过这种方式启动service后一定要记得在合适的时机主动关闭它。我们可以通过stopService(intent)方法在某个组件中关闭，也可以通过stopSelf()方法，在service中关闭。stopService方法还有另一种形式：void stopSelf(int startId)，startId用于区分不同的intent的请求。此方法的作用是：我们可以在Service中每处理完一个请求，就调用一次stopSelf(int startId)方法，但此方法并不会真正关闭service,只有当service中所有的请求都处理完后才会关闭service.此方法可防止出现任务未处理完就关闭Service的情况。
D.生命周期
图1
说明：上面我们所讲的对应此图的左半幅，即通过start方式。
2>Bound Service
A.创建步骤
1>写一个继承自Service的子类
2>在1>中定义的Service中实现一个IBinder类型的接口，以供onBind方法返回到client端，client与service也是通过此接口实现通信的
IBinder类型的接口，有三种实现方式：
1>继承Binder类：如果你开发的Service只供当前应用使用，采用这种方式是最佳的。在此Binder类中要实现一些公共的方法以供client端调用，或者返回当前service实例。
示例：
1 public class LocalService extends Service {
2 // Binder given to clients
3 private final IBinder mBinder = new LocalBinder();
4 // Random number generator
5 private final Random mGenerator = new Random();
6
7 /**
8 * Class used for the client Binder. Because we know this service always
9 * runs in the same process as its clients, we don't need to deal with IPC.
10 */
11 public class LocalBinder extends Binder {
12 LocalService getService() {
13 // Return this instance of LocalService so clients can call public methods
14 return LocalService.this;
15 }
16 }
17
18 @Override
19 public IBinder onBind(Intent intent) {
20 return mBinder;
21 }
22
23 /** method for clients */
24 public int getRandomNumber() {
25 return mGenerator.nextInt(100);
26 }
27 }View Code
1 public class BindingActivity extends Activity {
2 LocalService mService;
3 boolean mBound = false;
4
5 @Override
6 protected void onCreate(Bundle savedInstanceState) {
7 super.onCreate(savedInstanceState);
8 setContentView(R.layout.main);
9 }
10
11 @Override
12 protected void onStart() {
13 super.onStart();
14 // Bind to LocalService
15 Intent intent = new Intent(this, LocalService.class);
16 bindService(intent, mConnection, Context.BIND_AUTO_CREATE);
17 }
18
19 @Override
20 protected void onStop() {
21 super.onStop();
22 // Unbind from the service
23 if (mBound) {
24 unbindService(mConnection);
25 mBound = false;
26 }
27 }
28
29 /** Called when a button is clicked (the button in the layout file attaches to
30 * this method with the android:onClick attribute) */
31 public void onButtonClick(View v) {
32 if (mBound) {
33 // Call a method from the LocalService.
34 // However, if this call were something that might hang, then this request should
35 // occur in a separate thread to avoid slowing down the activity performance.
36 int num = mService.getRandomNumber();
37 Toast.makeText(this, "number: " + num, Toast.LENGTH_SHORT).show();
38 }
39 }
40
41 /** Defines callbacks for service binding, passed to bindService() */
42 private ServiceConnection mConnection = new ServiceConnection() {
43
44 @Override
45 public void onServiceConnected(ComponentName className,
46 IBinder service) {
47 // We've bound to LocalService, cast the IBinder and get LocalService instance
48 LocalBinder binder = (LocalBinder) service;
49 mService = binder.getService();
50 mBound = true;
51 }
52
53 @Override
54 public void onServiceDisconnected(ComponentName arg0) {
55 mBound = false;
56 }
57 };
58 }View Code
2>利用Messenger：如果你的service要提供被别的应用访问的功能(进程间访问)就要利用此方式
示例：
1 public class MessengerService extends Service {
2 /** Command to the service to display a message */
3 static final int MSG_SAY_HELLO = 1;
4
5 /**
6 * Handler of incoming messages from clients.
7 */
8 class IncomingHandler extends Handler {
9 @Override
10 public void handleMessage(Message msg) {
11 switch (msg.what) {
12 case MSG_SAY_HELLO:
13 Toast.makeText(getApplicationContext(), "hello!", Toast.LENGTH_SHORT).show();
14 break;
15 default:
16 super.handleMessage(msg);
17 }
18 }
19 }
20
21 /**
22 * Target we publish for clients to send messages to IncomingHandler.
23 */
24 final Messenger mMessenger = new Messenger(new IncomingHandler());
25
26 /**
27 * When binding to the service, we return an interface to our messenger
28 * for sending messages to the service.
29 */
30 @Override
31 public IBinder onBind(Intent intent) {
32 Toast.makeText(getApplicationContext(), "binding", Toast.LENGTH_SHORT).show();
33 return mMessenger.getBinder();
34 }
35 }View Code
1 public class ActivityMessenger extends Activity {
2 /** Messenger for communicating with the service. */
3 Messenger mService = null;
4
5 /** Flag indicating whether we have called bind on the service. */
6 boolean mBound;
7
8 /**
9 * Class for interacting with the main interface of the service.
10 */
11 private ServiceConnection mConnection = new ServiceConnection() {
12 public void onServiceConnected(ComponentName className, IBinder service) {
13 // This is called when the connection with the service has been
14 // established, giving us the object we can use to
15 // interact with the service. We are communicating with the
16 // service using a Messenger, so here we get a client-side
17 // representation of that from the raw IBinder object.
18 mService = new Messenger(service);
19 mBound = true;
20 }
21
22 public void onServiceDisconnected(ComponentName className) {
23 // This is called when the connection with the service has been
24 // unexpectedly disconnected -- that is, its process crashed.
25 mService = null;
26 mBound = false;
27 }
28 };
29
30 public void sayHello(View v) {
31 if (!mBound) return;
32 // Create and send a message to the service, using a supported 'what' value
33 Message msg = Message.obtain(null, MessengerService.MSG_SAY_HELLO, 0, 0);
34 try {
35 mService.send(msg);
36 } catch (RemoteException e) {
37 e.printStackTrace();
38 }
39 }
40
41 @Override
42 protected void onCreate(Bundle savedInstanceState) {
43 super.onCreate(savedInstanceState);
44 setContentView(R.layout.main);
45 }
46
47 @Override
48 protected void onStart() {
49 super.onStart();
50 // Bind to the service
51 bindService(new Intent(this, MessengerService.class), mConnection,
52 Context.BIND_AUTO_CREATE);
53 }
54
55 @Override
56 protected void onStop() {
57 super.onStop();
58 // Unbind from the service
59 if (mBound) {
60 unbindService(mConnection);
61 mBound = false;
62 }
63 }
64 }View Code
3>利用AIDL
待续...
B.绑定到Service
通过bindService (Intent service, ServiceConnection conn, int flags)方法。第一个参数就是一个普通的Intent包含了所要绑定的Service名。第二个参数ServiceConnection需要我们自己在Client端定义。里面有两个方法要我们实现。一个是onServiceConnected(ComponentName name, IBinder service)，此方法会在绑定成功时被回调，其中的第二个参数service就是那个我们在Service中定义的接口，通过它我们可以访问Service，以实现某些功能。void onServiceDisconnected (ComponentName name)，当client与service断开连接时将回调此方法。
C.生命周期
总结：
1>service可以分为两种:1.started service; 2.Bound service。
2>started service:与启动方无关联，被启动后在后台作为一个独立的执行单元运行，此类service一定要记得关闭，否则会一直在后台运行。有两种关闭方式a.在某个组件类中调用stopService方法 b.在service内部合适的地方与时机(任务完成时)调用stopSelf方法。此类service适合在后台做一些较独立的任务，比如：下载、上传...
3>Bound service:此类service类似client-server模式中的server端，一个server可以被不同的组件绑定。绑定成功后，可以调用service内容提供的公共方法。此类service还可以提供进程间的通信。当所有的客户端都与其断开连接后，系统将回调其onDestroy方法，因此针对此类型的service不需要我们显式去关闭。
4>一个通过startService方法启动后的service，还可以被别的组件通过bindService方法绑定。
5>service作为android的四大组件之一，它也是运行在主线程中的。因此，如果要在service中作耗时性的操作最好要开新的线程。
6>由于系统资源紧张问题，导致service被系统杀死，在以后某个时刻资源不再紧张，则系统会自动重启它。具体规则可以看onStartCommand方法的返回值 。 7>对于bound型service,若开启它的组件(比如activity)销毁后，此service也会被销毁，不管是否在那个activity的onDestory中调用unBindService方法。
ps:有点懒了，示例代码直接copy的官方文档中的。还有很多细节并没有介绍到。官方文档中介绍的真是太全了，英语还行的朋友，建议直接看文档。
