AIDL全称Android Interface Define Language，鸿洋大神已经讲得很清楚了，传送门在此：aidl Binder框架浅析
我们应该知道Android IPC(Inter Process Communication)的几种方式：
1、使用Bundle：Bundle实现了Parcelable接口，Activity、Service和Receiver都支持在Intent中传递Bundle数据。
2、使用文件共享：这种方式简单，适合在对数据同步要求不高的进程之间进行通信，并且要妥善处理并发读写的问题。
SharedPreferences是一个特例，虽然它也是文件的一种，但是由于系统对它的读写有一定的缓存策略，即在内存中会有一份SharedPreferences文件的缓存，因此在多进程模式下，系统对它的读写就变得不可靠，当面对高并发读写访问的时候，有很大几率会丢失数据，因此，不建议在进程间通信中使用SharedPreferences。
3、使用Messenger：Messenger是一种轻量级的IPC方案，它的底层实现就是AIDL。Messenger是以串行的方式处理请求的，即服务端只能一个个处理，不存在并发执行的情形，详细的示例见原书。
4、使用AIDL
大致流程：首先建一个Service和一个AIDL接口，接着创建一个类继承自AIDL接口中的Stub类并实现Stub类中的抽象方法，在Service的onBind方法中返回这个类的对象，然后客户端就可以绑定服务端Service，建立连接后就可以访问远程服务端的方法了。
(1)、AIDL支持的数据类型：基本数据类型、String和CharSequence、ArrayList、HashMap、Parcelable以及AIDL；
(2)、某些类即使和AIDL文件在同一个包中也要显式import进来；
(3)、AIDL中除了基本数据类，其他类型的参数都要标上方向：in、out或者inout；
(4)、AIDL接口中支持方法，不支持声明静态变量；
(5)、为了方便AIDL的开发，建议把所有和AIDL相关的类和文件全部放入同一个包中，这样做的好处是，当客户端是另一个应用的时候，可以直接把整个包复制到客户端工程中。
(6)、RemoteCallbackList是系统专门提供的用于删除跨进程Listener的接口。RemoteCallbackList是一个泛型，支持管理任意的AIDL接口，因为所有的AIDL接口都继承自IInterface接口。
5、使用ContentProvider
(1)、ContentProvider主要以表格的形式来组织数据，并且可以包含多个表；
(2)、ContentProvider还支持文件数据，比如图片、视频等，系统提供的MediaStore就是文件类型的ContentProvider；
(3)、ContentProvider对底层的数据存储方式没有任何要求，可以是SQLite、文件，甚至是内存中的一个对象都行；
(4)、要观察ContentProvider中的数据变化情况，可以通过ContentResolver的registerContentObserver方法来注册观察者；
6、使用Socket
Socket是网络通信中“套接字”的概念，分为流式套接字和用户数据包套接字两种，分别对应网络的传输控制层的TCP和UDP协议。
这里主要谈一下Messenger，Messager实现IPC通信，底层也是使用了AIDL方式。和AIDL方式不同的是，Messager方式是利用Handler形式处理，因此，它是线程安全的，这也表示它不支持并发处理；而AIDL方式是非线程安全的，支持并发处理，因此，我们使用AIDL方式时需要保证代码的线程安全。
大部分情况下，我们应用中不需要并发处理。因此，我们通常只需要使用Messager方式。
思想：在进程A中创建一个Message，将这个Message对象通过IMessenger.send(message)方法传递到进程B（当然，Message对象本身是无法被传递到进程B的，send(message)方法会使用一个Parcel对象对Message对象编集，再将Parcel对象传递到进程B中，然后解编集，得到一个和进程A中Message对象内容一样的对象），再把Message对象加入到进程B的消息队列里，Handler会去处理它。
先看下面这个例子，进程B中代码：
public class RemoteService extends Service {
public static final int GET_RESULT = ;
private final Messenger mMessenger = new Messenger(new Handler() {
private int remoteInt = ;//返回到进程A的值
@Override
public void handleMessage(Message msg) {
if (msg.what == GET_RESULT) {
try {
msg.replyTo.send(Message.obtain(null, GET_RESULT, remoteInt++, ));
} catch (RemoteException e) {
e.printStackTrace();
}
} else {
super.handleMessage(msg);
}
}
});
@Override
public IBinder onBind(Intent intent) {
return mMessenger.getBinder();
}
}
进程A中代码：
private Messenger mService;
private boolean isBinding = false;
private ServiceConnection mConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
mService = new Messenger(service);
isBinding = true;
}
@Override public void onServiceDisconnected(ComponentName name) {
mService = null;
isBinding = false;
} };
//绑定进程B的服务
bindService(new Intent(this, RemoteService.class), mConnection, BIND_AUTO_CREATE);
//处理来自进程B回复的消息
private Messenger mMessenger = new Messenger(new Handler() {
@Override
public void handleMessage(Message msg) {
if (msg.what == RemoteServiceProxy.GET_RESULT) {
Log.i("TAG", "Int form process B is "+msg.arg1);//msg.arg1就是remoteInt
} else {
super.handleMessage(msg);
}
}
});
//向进程B发一条消息，并接收来自进程B回复过来的消息
Message message = Message.obtain(null, RemoteServiceProxy.GET_RESULT);
message.replyTo = mMessenger;
try {
mService.send(message);
} catch (RemoteException e) {
e.printStackTrace();
}
上面这个例子很简单，目的就是从进程A向进程B的RemoteService发一个消息，进程B再把处理结果发给进程A。
下面来深入分析一下Messenger的实现过程。Messenger类的方法：
public Messenger(Handler target) {
mTarget = target.getIMessenger();
}
public IBinder getBinder() {
return mTarget.asBinder();
}
public void send(Message message) throws RemoteException {
mTarget.send(message);
}
Handler类的方法：
final IMessenger getIMessenger() {
synchronized (mQueue) {
if (mMessenger != null) {
return mMessenger;
}
mMessenger = new MessengerImpl();
return mMessenger;
}
}
private final class MessengerImpl extends IMessenger.Stub {
public void send(Message msg) {
Handler.this.sendMessage(msg);
}
}
从上面代码可知，当进程A的Activity绑定进程B的RemoteService时，onBind方法返回一个MessengerImpl对象，它是IBinder类的子类。这个对象会被传递到进程A中，在进程A与进程B建立链接时，传到ServiceConnection.onServiceConnected(ComponentName name, IBinder service)方法中，IBinder service就是进程B返回的MessengerImpl对象。然后用service构建一个Messager对象。
mService = new Messenger(service);
public Messenger(IBinder target) {
mTarget = IMessenger.Stub.asInterface(target);
}
IMessenger.Stub.asInterface(target)方法会在进程A中创建一个IMessenger的代理类Proxy，看过AIDL的朋友会对这个很熟悉。
当使用mService发送一条消息时，实际调用的是代理类Proxy的send(Message msg)方法。
public void send(android.os.Message msg) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((msg != null)) {
_data.writeInt();
msg.writeToParcel(_data, );
} else {
_data.writeInt();
}
mRemote.transact(Stub.TRANSACTION_send, _data, null, android.os.IBinder.FLAG_ONEWAY);
} finally {
_data.recycle();
}
}
上面方法是将Message msg的内容写到Parcel _data对象中，然后调用进程B返回的MessengerImpl对象的transact方法。这个方法把_data对象传递到进程B中，看下这个方法：
public final boolean transact(int code, Parcel data, Parcel reply,
int flags) throws RemoteException {
if (Config.LOGV) Log.v("Binder", "Transact: " + code + " to " + this);
if (data != null) {
data.setDataPosition();
}
boolean r = onTransact(code, data, reply, flags);
if (reply != null) {
reply.setDataPosition();
}
return r;
}
在进程B中调用onTransact方法：
public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
{
switch (code)
{
........
case TRANSACTION_send:
{
data.enforceInterface(DESCRIPTOR);
android.os.Message _arg0;
if ((!=data.readInt())) {
_arg0 = android.os.Message.CREATOR.createFromParcel(data);
}
else {
_arg0 = null;
}
this.send(_arg0);
return true;
}
.......
}
}
这个方法在进程B中恢复进程A传递过来的消息，然后调用this.send(_arg0);。再来看看send(_arg0)这个方法：
private final class MessengerImpl extends IMessenger.Stub {
public void send(Message msg) {
Handler.this.sendMessage(msg);
}
}
把它加到进程B的消息队列中了，由Handler处理。