目录
- Service 介绍
- Service两种启动方式
- 使用
- 测试
- IntentService
- Activity与Service之间的通信
- 继承Binder类
- Messenger
- AIDL
Service 介绍
A Service is an application component that can perform long-running operations in the background and does not provide a user interface. Another application component can start a service and it will continue to run in the background even if the user switches to another application. Additionally, a component can bind to a service to interact with it and even perform interprocess communication (IPC). For example, a service might handle network transactions, play music, perform file I/O, or interact with a content provider, all from the background.
Service是一个没有用户界面的应用程序组件，可以在后台长时间运行。另外一个应用程序组件可以启动一个Service，它可以在用户切换到其他应用的时候依旧保持在后台运行。另外，一个组件可以绑定到Service上，与它进行通信，甚至是IPC（进程间通信）。
Service两种启动方式
- startService
-
bindService
其生命周期官方API介绍：
Paste_Image.png
需要注意的点：
1.通过startService启动的Service，只有调用了stopService（外部组件调用）或stopSelf（Service内部自己调用），才会停止。
2.通过startService启动的Service，在Service运行中无法与Service进行交互，即外部组件只能控制其开关，无法进行交互。
3.通过startService启动的Service，与外部组件之间没有关系，外部组件的生死跟它没有联系。
3.通过startService启动的Service，启动之后重复启动的话不会触发onCreate方法，但是会重复触发onStartCommand，其实貌似也算是数据交流了吧，不过是单向的。
4.bindService启动的Service表示将一个Service绑定到一个组件上，其生命周期与该组件的生命周期绑定在一起，比如绑到一个Activity，Activity在Destroy后Service跟着就Destroy了。
4.注意是不能绑定广播的，因为广播发完了其生命就到头了，常用的是绑Activity，还可以是Service。
5.bindService启动的Service在使用完之后可以解除绑定，当一个Service上的所有绑定的组件都解绑之后，它就会被销毁。
6.可以同时使用两种启动方式，此时的生命周期就变的有些复杂了，两种关联到一起，总结来说的话，先startService与先bindService两种方式达到的效果是一样的，即此时unbindService的话，Service并不会结束，而是要等到stopService才会结束（onDestroy）；若是此时stopService，也不会结束，而是要等到unbindService时才会结束（由于已经调用过stopService，此时会直接onDestroy）。
7.onRebind调用时机：
Paste_Image.png
当旧client与service之间的关联在onUnbind中都结束之后，新client绑定时，
必须是onUnbind返回true，且服务在解绑之后没有销毁
使用
-
startService
创建类继承Service，在启动组件中调用：Intent intent1 = new Intent(ServiceActivity1.this, MyService1.class); startService(intent1);
停止方法同上
-
bindService
1.创建类继承Service，其中默认会有一个onBind方法，返回是一个IBinder类型对象，这个返回值就是与组件之间通信的关键。可以通过自定义内部类继承Binder，在这个类中返回Service，然后在组件中通过返回的IBinder类型对象获取到Service对象从而进行操作；
2.在组件中新建一个ServiceConnection对象，必须重写两个方法，onServiceConnected（建立连接（bind_service）时调用）、onServiceDisconnected（一般都不调用，除非是意外情况，unbind_service并不调用这个），在onServiceConnected中获取到Service对象进行操作。
MyService：public class MyService1 extends Service { @Override public void onCreate() { super.onCreate(); Log.i("test_out","----->onCreate"); } @Override public int onStartCommand(Intent intent, int flags, int startId) { Log.i("test_out","----->onStartCommand"); return super.onStartCommand(intent, flags, startId); } @Override public void onDestroy() { super.onDestroy(); Log.i("test_out","----->onDestroy"); } public class MyBinder extends Binder { public MyService1 getService(){ return MyService1.this; } } private MyBinder mBinder = new MyBinder(); @Override public IBinder onBind(Intent intent) { Log.i("test_out","----->onBind"); return mBinder; } @Override public boolean onUnbind(Intent intent) { Log.i("test_out","----->onUnbind"); return true; } @Override public void onRebind(Intent intent) { super.onRebind(intent); Log.i("test_out","----->onRebind"); } public int getCount(){ return (int) (Math.random() * 10); } }
在Activity中建立连接：
ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = ((MyService1.MyBinder)service).getService();
textView.setText("" + mService.getCount());
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.i("test_out","----->onServiceDisconnected");
}
};
启动与停止：
bindService(intent3, serviceConnection, Service.BIND_AUTO_CREATE);
第一个参数是intent，第二个是上面的serviceConnection，第三个表示绑定方式，Service.BIND_AUTO_CREATE表示绑定时不存在的话就自动创建。
解绑：unbindService(serviceConnection);
测试
startService -> stopService
startService -> startService -> startService -> stopService
果然重复start会调用onStartCommand，那么就相当于可以发指令。
bindService -> unbindService
bindService -> 按下返回键
startService -> bindService -> unbindService
startService -> bindService -> unbindService -> bindService -> unbindService
startService -> bindService -> stopService
此时unbindService ：
IntentService
Android封装好的Service，在其中的onHandleIntent(Intent intent)中处理需要在子线程中处理的逻辑，在处理完毕后，会自动onDestroy。
Activity与Service之间的通信
一般来讲，我们将绑定到Service上的组件称为客户端，Service称为服务端，他们之间的通信可以在同一个进程，也可以在不同的进程。
要进行通信，那个前面已经提到，就要在客户端获取到一个IBinder对象，而获取这个对象的方式有三种：
继承Binder类，使用Messenger类，使用AIDL
第一种上面已经用过了，不过这种方式是适用于同进程内通信，因为不同的进程使用的是不同的内存区域。
Messenger
其实现是通过Message以及Handler来进行通信，Handler应该都有所了解，一般使用最多的都是用来解决非UI线程更新UI的问题，Handler机制有待仔细研究一下，后面写一篇。
其实其底层实现也是通过AIDL。
服务端（Service）：
基本流程跟上面的继承Binder类的方式差不多，如下：
首先创建一个Service，在其中实现一个Handler，用于接受消息。
然后通过Handler创建一个Messenger实例，在onBind中返回Messager实例的Binder。
public class MyService2 extends Service {
class ServiceHandler extends Handler{
@Override
public void handleMessage(Message msg) {
if(msg.what == 1){
Log.i("test_out","------>receive data from client!");
}
}
}
final Messenger messager = new Messenger(new ServiceHandler());
@Override
public IBinder onBind(Intent intent) {
Log.i("test_out","----->onBind");
return messager.getBinder();
}
@Override
public boolean onUnbind(Intent intent) {
Log.i("test_out","----->onUnbind");
return true;
}
}
客户端：
通过serviceConnection中的onServiceConnected获取到服务端传来的Binder对象，实例化Client端的Messenger。
创建Message，通过Messager发送消息。
ServiceConnection serviceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mMessager = new Messenger(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.i("test_out","----->onServiceDisconnected");
}
};
public void sendToMyService(){
Message msg = new Message();
msg.what = 1;
try {
mMessager.send(msg);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
protected void onStart() {
super.onStart();
Intent intent = new Intent();
intent.setAction("com.gsq.service2");
intent.setClassName("com.example.gsq.servicetest", "com.example.gsq.servicetest.service.MyService2");
bindService(intent, serviceConnection, BIND_AUTO_CREATE);
}
@Override
protected void onStop() {
super.onStop();
unbindService(serviceConnection);
}
对了，这里我的客户端是另外一个APK，验证进程间通信，那么就要在Service注册的时候指定其action，在Intent跳转的时候设置完整包名和action，这个在前面学习Intent中有介绍的。
<service android:name=".service.MyService2"
android:exported="true"
android:permission="com.gsq.permission.service2">
<intent-filter>
<action android:name="com.gsq.service2" />
<category android:name="android.intent.category.DEFAULT" />
</intent-filter>
</service>
注意，这里写了android:exported之后，AS会提示你：
Exported services (services which either set exported=true or contain an intent-filter and do not specify exported=false) should define a permission that an entity must have in order to launch the service or bind to it. Without this, any application can use this service.
大意就是，最好是加一个权限，android:permission。
自定义权限过程：在被调用的应用中先定义
<permission
android:name="com.gsq.permission.service2"
android:protectionLevel="normal">
</permission>
然后使用，android:permission="com.gsq.permission.service2
然后在调用者（客户端）声明：
<uses-permission android:name="com.gsq.permission.service2" />
坑：自定义权限名称一定要是 *.permission.*
好了，这样子Messenger的使用流程就说完了，下面就可以看一下结果了。
启动第二个应用：
点击button：
OK ! 大功告成！
再点一下：
关闭：
上面就实现了客户端向服务端发送消息。
下面就来实现一下服务端在受到消息之后给一个response。
流程跟上面类似，要想发送消息就要有一个Messenger，可是我们前面不是分别在服务端创建了一个Messenger了么，然后将这个Messenger返回给客户端，这样客户端就可以通过这个Messenger向服务器端发送消息，那么既然已经通道已经存在了，我们能不能在服务端使用这个Messenger来想客户端发送消息呢？
答案是否定的。因为这个Messenger是在服务端的，而且是通过服务端的handler实例化的，然后通过binder传到客户端，也就是说告诉客户端你就用这个给我发消息就行了，我就能收到，但是服务端并不知道客户端是谁，谁拿到了这个Messenger，只知道处理通过这个Messenger传递来的消息。
那么按照这个分析的话，要想服务端向客户端发送消息方式就显而易见了，就是在客户端实例化一个Messenger，然后传递给服务端，告诉它用这个Messenger给我发消息就行了，那么客户端可以通过binder获取到服务端的Messenger实例，那么服务端怎么获取到客户端的实例呢？这个就很简单了，因为前面通道已经创建了，只需要在客户端向服务端发送消息的时候将客户端自己的Messenger传递过去就行了。而Message类刚好有一个参数replyTo，这个参数就是Messenger类型的，那么我们只需要在客户端建一个handler，然后实例化一个Messenger传递过去就ok了。
分析完毕，下面是实现：
首先是客户端代码：
//创建一个处理服务端发来的消息的handler
private class MyHandler extends Handler{
@Override
public void handleMessage(Message msg) {
switch(msg.what){
case 2:
Log.i("test_out", "------>receive response from server!");
break;
default:
super.handleMessage(msg);
}
}
}
然后在向服务端发送数据的时候给msg指定replyTo：
//在client向服务端发送消息的时候告诉服务端通过这个messenger进行回复
msg.replyTo = new Messenger(new MyHandler());
接下来是服务端代码，收到消息后获取到messenger并发送消息即可：
class ServiceHandler extends Handler{
@Override
public void handleMessage(Message msg) {
if(msg.what == 1){
Log.i("test_out","------>receive data from client!");
Messenger messengerFromClient = msg.replyTo;
Message replyMessage = new Message();
replyMessage.what = 2;
try {
messengerFromClient.send(replyMessage);
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
}
接下来就是测试了：
先启动服务端，按下home，再启动客户端：
此时服务端：
然后在客户端点击发送消息按钮：
再看一下客户端：
这样就完成了双向通信。
小结：要实现双向通信需要首先在服务端创建一个handler，通过这个handler实例化一个Messenger，通过binder将这个Messenger返回给客户端，客户端收到Messenger之后即可向服务端发消息，此时在客户端创建一个handler，并实例化一个Messenger，在向服务端发消息时将这个Messenger传递过去，服务端收到消息的同时也得到了客户端的Messenger，就可以发消息给客户端。
Messenger是使用串行的方式来进行通信，数据量比较大时显然就有点吃力了，而且主要是用来传递消息，但是我们还会出现在客户端调用服务端的方法的情况，这种情况下Messenger就无能为力了，这时候就需要AIDL了，而且Messenger底层实现的本质上也是AIDL。
AIDL
由于水平很菜，感觉AIDL太高深了，后面单独写一个。
参考：
http://www.jianshu.com/p/a8e43ad5d7d2
http://blog.csdn.net/luoyanglizi/article/details/51586437
http://blog.csdn.net/luoyanglizi/article/details/51594016
非常感谢这位大神。
