IPC机制：Inter-Process Communication，进程间通信
RPC: Remote Procedure Call—远程过程调用，它是一种通过协议从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。
android.os.IInterface接口，一个方法： public IBinder asBinder();
IBinder接口，方法queryLocalInterface
Binder类实现IBinder接口，stub继承Binder类，
interface IMyService extends IInterface{}
//关系
abstract class Stub extends Binder implements IMyService
1.生成aidl文件后
2.抽象类stub，服务端用的继承并写真正的处理逻辑
2.proxy 构造函数要传入IBinder对象作为remote
3.asinterface静态方法，如果客户端和服务端位于同一进程,那么此方法返回的就是服务端的Stub对象本身，否则返回的是系统封装后的Stub.proxy对象。
服务端：
public class MyService extends Service {
//这里实现了aidl中的抽象函数
private final IMyService.Stub mBinder = new IMyService.Stub() {
@Override
public List<Student> getStudent() throws RemoteException {
。。。
}
@Override
public void addStudent(Student student) throws RemoteException {
。。。
}
public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
//在这里可以做权限认证，return false意味着客户端的调用就会失败，比如下面，只允许包名为com.example.test的客户端通过，
//其他apk将无法完成调用过程
return super.onTransact(code, data, reply, flags);
}
};
@Override
public IBinder onBind(Intent intent) {
Log.d(TAG, String.format("on bind,intent = %s", intent.toString()));
displayNotificationMessage("服务已启动");
return mBinder;
}
}
客户端想拿服务端的binder通过service。
ServiceConnection mServiceConnection =...
public void onServiceConnected(ComponentName name, IBinder service) {
//通过服务端onBind方法返回的binder对象得到IMyService的实例，得到实例就可以调用它的方法了
mIMyService = IMyService.Stub.asInterface(service);
}
附录：
直观来说， Binder是Android中的一一个类，它实现了IBinder接口。从IPC角度来说，Binder是Android中的一-种跨进程通信方式，Binder 还可以理解为一~种虚拟的物理设备，它的设备驱动是/dev/binder,该通信方式在Linux中没有:从Android Framework角度来说，Binder是ServiceManager连接各种Manager ( ActivityManager、WindowManager, 等等)和相应ManagerService的桥梁;从Android应用层来说，Binder 是客户端和服务端进行通信的媒介，当bindService的时候，服务端会返回一个包含了服务端业务调用的Binder对象，通过这个Binder对象，客户端就可以获取服务端提供的服务或者数据，这里的服务包括普通服务和基于AIDL的服务。
Android开发中，Binder主要用在Service中,包括AIDL和Messenger,其中普通Service中的Binder不涉及进程间通信，所以较为简单，无法触及Binder的核心，而Messenger的底层其实是AIDL，所以这里选择用AIDL来分析Binder的工作机制。为了分析Binder的工作机制，我们需要新建一一个AIDL示例，SDK会自动为我们生产AIDL所对应的Binder类，然后我们就可以分析Binder的工作过程。
asInterface方法：
用于将服务端的Binder对象转换成客户端所需的AIDL接口类型的对象，这种转换过程是区分进程的，如果客户端和服务端位于同一进程,那么此方法返回的就是服务端的Stub对象本身，否则返回的是系统封装后的Stub.proxy对象。
as Binder方法：
此方法用于返回当前Binder对象。
onTransact方法：
这个方法运行在服务端中的Binder线程池中，当客户端发起跨进程请求时，远程请求会通过系统底层封装后交由此方法来处理。该方法的原型为public Boolean onTransact (intcode, android.os. Parcel data, android.os.Parcel reply, int flags)。服务端通过code可以确定客户端所请求的目标方法是什么，接着从data中取出目标方法所需的参数(如果目标方法有参数的话)，然后执行目标方法。当目标方法执行完毕后，就向reply中写入返回值(如果目标方法有返回值的话)，onTransact 方法的执行过程就是这样的。需要注意的是， 如果此方法返回false, 那么客户端的请求会失败，因此我们可以利用这个特性来做权限验证，毕竟我们也不希望随便一一个进程都能远程调用我们的服务。
客户端Proxy#getBookList
这个方法运行在客户端，当客户端远程调用此方法时，它的内部实现是这样的:首先创建该方法所需要的输入型Parcel对象_ data、 输出型Parcel对象reply 和返回值对象List;然后把该方法的参数信息写入_ data 中(如果有参数的话);接着调用transact 方法来发起RPC (远程过程调用)请求，同时当前线程挂起;然后服务端的onTransact方法会被调用，直到RPC过程返回后，当前线程继续执行，并从_ reply 中取出RPC过程的返回结果;最后返回_ reply 中的数据。
客户端Proxy#addBook
这个方法运行在客户端，它的执行过程和getBookList是一样的， addBook没有返回值，所以它不需要从_reply 中取出返回值。
备注：
通过上面的分析，读者应该已经了解了Binder的工作机制， 但是有两点还是需要额外说明一下:首先，当客户端发起远程请求时， 由于当前线程会被挂起直至服务端进程返回数据，所以如果一个 远程方法是很耗时的，那么不能在∪I线程中发起此远程请求; 其次,由于服务端的Binder方法运行在Binder的线程池中，所以Binder 方法不管是否耗时都应该采用同步的方式去实现，因为它已经运行在一一个线程中了。
死亡代理：
接下来，我们介绍Binder的两个很重要的方法linkToDeath和unlinkToDeath。我们知道，Binder 运行在服务端进程，如果服务端进程由于某种原因异常终止，这个时候我们到服务端的Binder连接断裂(称之为Binder死亡)，会导致我们的远程调用失败。 更为关键的是， 如果我们不知道Binder连接已经断裂，那么客户端的功能就会受到影响。为了解决这个问题，Binder中提供了两个配对的方法linkToDeath和unlinkToDeath,通过linkToDeath我们可以给Binder设置-一个死亡代理，当Binder死亡时，我们就会收到通知，这个时候我们就可以重新发起连接请求从而恢复连接。
Messenger 注意不是message
Messenger可以翻译为信使，顾名思义，通过它可以在不同进程中传递Message对象，在Message中放入我们需要传递的数据,就可以轻松地实现数据的进程间传递了.Messenger是一种轻量级的IPC方案，它的底层实现是AIDL, 为什么这么说呢，我们大致看一下Messenger这个类的构造方法就明白了。下面是Messenger的两个构造方法，从构造方法的实现.上我们可以明显看出AIDL的痕迹，不管是IMessenger还是Stub.asInterface, 这种使用方法都表明它的底层是AIDL。
public Messenger (Handler target)
mTarget = target.getIMessenger () ;
public Messenger (IBinder target){
mTarget = IMessenger. Stub.asInterface (target) ;
//Handler源码，handler.getIMessenger ()返回的对象
private final class MessengerImpl extends IMessenger.Stub {
public void send(Message msg) {
msg.sendingUid = Binder.getCallingUid();
Handler.this.sendMessage(msg);
}
}
Messenger的使用方法很简单，它对AIDL做了封装，使得我们可以更简便地进行进程间通信。同时，由于它一次处理一个请求，因此在服务端我们不用考虑线程同步的问题，这是因为服务端中不存在并发执行的情形。实现-一个Messenger有如下几个步骤，分为服务端和客户端。
1.服务端进程
首先，我们需要在服务端创建-一个Service来处理客户端的连接请求，同时创建-一个Handler并通过它来创建-一个Messenger 对象，然后在Service 的onBind 中返回这个Messenger对象底层的Binder即可。
2.客户端进程
客户端进程中，首先要绑定服务端的Service, 绑定成功后用服务端返回的IBinder对象创建一个Messenger, 通过这个Messenger 就可以向服务端发送消息了，发消息类型为Message对象。如果需要服务端能够回应客户端，就和服务端一样，我们还需要创建-一个Handler并创建-一个 新的Messenger,并把这个Messenger对象通过Message的replyTo参数传递给服务端，服务端通过这个replyTo参数就可以回应客户端。这听起来可能还是有点抽象，不过看了下面的两个例子，读者肯定就都明白了。首先，我们来看一个简单点的例子，在这个例子中服务端无法回应客户端。
public class MessengerService extends Service{
//自定义handler
private static class MessengerHandler extends Handler{
@Override
public void handleMessage (Message msg)
switch (msg.what) {
case MyConstants.MSG_ FROM_ CLIENT :
...
break;
}
super .handleMessage (msg) ;
}
//创建Messager对象
private fina1 Messenger mMessenger = new Messenger (new MessengerHandler());
@Override
public IBinder onBind (Intent intent ){
return mMessenger.getBinder( ）;
}
}
客户端：
回调相关：
1.回调必须是aidl接口。定义在aidl目录里。客户端创建时也用的是响应的stub，如下图：
2.服务端存放回调必须用RemoteCallbackList：
RemoteCallbackList是系统专门提供的用于删除跨进程listener
的接口。RemoteCallbackList是一个泛型，支持管理任意的AIDL接口，这点从它的声明就可以看出，因为所有的AIDL接口都继承自IInterface 接口，读者还有印象吗?
通知：
线程相关
到这里，AIDL的基本使用方法已经介绍完了，但是有几点还需要再次说明一下。我们知道， 客户端调用远程服务的方法，被调用的方法运行在服务端的Binder线程池中，同时客户端线程会被挂起，这个时候如果服务端方法执行比较耗时，就会导致客户端线程长时间地阻塞在这里， 而如果这个客户端线程是UI线程的话，就会导致客户端ANR, 这当然不是我们想要看到的。因此，如果我们明确知道某个远程方法是耗时的，那么就要避免在客户端的UI线程中去访问远程方法。 由于客户端的onServiceConnected 和onServiceDisconnected方法都运行在UI线程中，所以也不可以在它们里面直接调用服务端的耗时方法，这点要尤其注意。另外，由于服务端的方法本身就运行在服务端的Binder线程池中，所以服务端方法本身就可以执行大量耗时操作，这个时候切记不要在服务端方法中开线程去进行异步任务，除非你明确知道自己在千什么，否则不建议这么做。
附录aidl文件：
public interface IMyService extends android.os.IInterface {
//接口方法1
public java.util.List<Student> getStudent() throws android.os.RemoteException;
public void addStudent(Student student) throws android.os.RemoteException;
//服务类
public static abstract class Stub extends android.os.Binder implements IMyService {
private static final String DESCRIPTOR = "com.example.hans.testlauncha.IMyService";
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
@Override
public android.os.IBinder asBinder() {
return this;
}
@Override
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException {
//生路拆包、装包
return super.onTransact(code, data, reply, flags);
}
//静态方法
public static IMyService asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof IMyService))) {
return ((IMyService) iin);
}
return new Proxy(obj);
}
//客户端用的代理类
private static class Proxy implements IMyService {
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote) {
mRemote = remote;
}
@Override
public android.os.IBinder asBinder() {
return mRemote;
}
public String getInterfaceDescriptor() {
return DESCRIPTOR;
}
@Override
public java.util.List<Student> getStudent() throws android.os.RemoteException {
//省略装包
return null;
}
@Override
public void addStudent(Student student) throws android.os.RemoteException {
//省略装包
}
}
}
}
