我们都知道，在Android中，系统会为每个进程分配对应的内存空间，这部分内存是彼此间相互独立，不可直接交互的，这样的设计是处于安全性以及系统稳定性方面考虑的，比如当我们的App奔溃时，不至于导致其他App无法运行，甚至死机等情况。那么，Android中是否就无法实现进程间通信呢？答案当然是否定的。Android中进程通信的方式有很多，比如AIDL就可以实现这样子的需求。
1.AIDL
AIDL(Android Interface Define Language)是一种IPC通信方式，我们可以利用它来定义两个进程相互通信的接口。他是基于Service实现的一种线程间通信机制。它的本质是C/S架构的，需要一个服务器端，一个客户端。
2.AIDL的使用
2.1创建aidl
首先我们在AndroidStudio中创建一个Andorid工程，
随后添加一个module，作为aidl的服务端
在aidlserver中创建aild目录， 同时创建一个aidl文件
// IMyAidlInterface.aidl
package com.yunzhou.aidlserver;
// Declare any non-default types here with import statements
interface IMyAidlInterface {
/**
* 自己添加的方法
*/
int add(int value1, int value2);
}
这边可以看到aidl的语法跟JAVA是一样的，声明了一个接口，里面定义了aidl服务器端暴露给客户端调用的方法。
完成这部分操作之后还没有结束，我们需要手动编译程序，生成aidl对应的Java代码
2.2实现接口，并向客户端放开接口
public class MyAidlService extends Service {
public MyAidlService() {
}
@Override
public IBinder onBind(Intent intent) {
return iBinder;
}
private IBinder iBinder = new IMyAidlInterface.Stub(){
@Override
public int add(int value1, int value2) throws RemoteException {
return value1 + value2;
}
};
}
我们创建了一个service，并在service内部声明了一个IBinder对象，它是一个匿名实现的IMyAidlInterface.Stub的实例(这部分我们后面讲)，同时我们在发现IMyAidlInterface.Stub实例实现了add方法，这个方法正是我们在aidl中声明的供客户端调用的方法。
2.3客户端调用aidl
首先在客户端跟服务器一样，新建aidl目录，将服务器端的aidl拷贝到客户端，这边特别要注意，拷贝后的客户端的aidl文件包目录必须与服务器端保持一致，拷贝完后同样时编译工程，让客户端也生成对应的java文件
其次就是在Activity的onCreate中绑定服务
private ServiceConnection connection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//绑定服务成功回调
aidl = IMyAidlInterface.Stub.asInterface(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
//服务断开时回调
aidl = null;
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//do something
bindService();
}
private void bindService(){
Intent intent = new Intent();
//Android 5.0开始，启动服务必须使用显示的，不能用隐式的
intent.setComponent(new ComponentName("com.yunzhou.aidlserver", "com.yunzhou.aidlserver.MyAidlService"));
bindService(intent, connection, Context.BIND_AUTO_CREATE);
}
绑定完服务，就是进行调用了，具体的页面细节这边不做展示，就是在Activity中放了一个按钮，点击按钮进行远程调用
int result = aidl.add(12, 12);
Log.e(TAG, "远程回调结果:" + result);
可以看到，logcat打印出来结果，说明远程调用成功了，至此aidl的整个流程就走完了。
3.AIDL可使用的参数类型
3.1基本数据类型
我们都知道Java有8中基本数据类型，分别为byte,char,short,int,long,float,double,boolean,那这8中数据类型是否都能作为aidl的参数进行传递呢？我们可以在aild中尝试下，并编译，看看有没有错
void basicTypes(byte aByte, char aChar, short aShort, int anInt, long aLong, float aFloat,
double aDouble, boolean aBoolean);
发现这样子定义，无法成功编译，经过筛查发现aidl并不能支持short基本数据类型，至于为什么呢，可以看一看Android中的Parcel，Parcel是不支持short的，这应该是考虑到兼容性问题吧。
所以基本数据类型支持：byte,char,int,long,float,double,boolean
3.2引用数据类型
引用数据类型根据官方介绍，可以使用String,CharSequence,List,Map，当然，我们也可以使用自定义数据类型。
3.3自定义数据类型
自定义数据类型，用于进程间通信的话，必须实现Parcelable接口，Parcelable是类似于Java中的Serializable，Android中定义了Parcelable，用于进程间数据传递，对传输数据进行分解，编组的工作，相对于Serializable，他对于进程间通信更加高效。
我们来看下下面的例子
public class User implements Parcelable {
private int id;
private String name;
public User() {
}
public User(int id, String name) {
this.id = id;
this.name = name;
}
public User(Parcel in){
//注意顺序！！！注意顺序！！！注意顺序！！！
this.id = in.readInt();
this.name = in.readString();
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
//注意顺序！！！注意顺序！！！注意顺序！！！
dest.writeInt(id);
dest.writeString(name);
}
public static final Parcelable.Creator<User> CREATOR = new Parcelable.Creator<User>(){
@Override
public User createFromParcel(Parcel source) {
return new User(source);
}
@Override
public User[] newArray(int size) {
return new User[size];
}
};
@Override
public String toString() {
return "User{" +
"id=" + id +
", name='" + name + '\'' +
'}';
}
}
这边我们定义了一个User类，实现了Parcelable接口，大致的类结构就是这个样子的，需要注意的一点是，Parcelable对数据进行分解/编组的时候必须使用相同的顺序，字段以什么顺序分解的，编组时就以什么顺序读取数据，不然会有问题！
创建完实体后，我们需要创建一个aidl文件，来定义一下我们的User，否则User在aidl中无法识别
// IMyAidlInterface.aidl
package com.yunzhou.aidlserver;
parcelable User;
并在之前的服务器端aidl中新增方法
interface IMyAidlInterface {
int add(int value1, int value2);
List<User> addUser(in User user);
}
在service中实现新增的addUser方法
private ArrayList users;
@Override
public IBinder onBind(Intent intent) {
users = new ArrayList<User>();
return iBinder;
}
private IBinder iBinder = new IMyAidlInterface.Stub(){
@Override
public int add(int value1, int value2) throws RemoteException {
return value1 + value2;
}
@Override
public List<User> addUser(User user) throws RemoteException {
users.add(user);
return users;
}
};
此时，server端的目录就够如下
服务器端一切准备就绪后，我们对客户端进行操作，首先，我们将服务端的两个aidl文件复制到客户端，包结构必须一致，aidl文件发生变化不要忘记重新编译代码。
然后，将User实体也复制到客户端，并且包结构一致。
最后，在客户端进行addUser的操作(这边只是添加了一个按钮，每点击一次就调用一次addUser)
try {
ArrayList<User> users = (ArrayList<User>) aidl.addUser(new User(12, "demaxiya"));
Log.e(TAG, "远程回调结果:" + users.toString());
} catch (RemoteException e) {
e.printStackTrace();
}
此时客户端的目录结构如下：
运行服务端与客户端App，点击addUser，输出日下日志，说明调用成功
4.AIDL原理
要了解aidl原理，我们需要看一下根据aidl生成的对应的java代码了，
public interface IMyAidlInterface extends android.os.IInterface{
public static abstract class Stub extends android.os.Binder implements com.yunzhou.aidlserver.IMyAidlInterface{...}
public int add(int value1, int value2) throws android.os.RemoteException;
public java.util.List<com.yunzhou.aidlserver.User> addUser(com.yunzhou.aidlserver.User user) throws android.os.RemoteException;
}
我们可以看到，生成的代码结构很简单，一个静态抽象类Stub，以及aidl中定义的方法，其中Stub肯定时核心，我们深入阅读
Stub的目录结构也不复杂，一个构造函数，一个asInterface方法，一个asBinder方法，一个onTransact方法，一个Proxy代理类，这边Proxy与Stub同时实现了我们定义的aidl，且Proxy中实现了我们在aidl中定义的add/addUser方法。下面两个int为告诉系统的方法Id
在客户端，我们绑定服务的时候通过Stub.asInterface()回去aidl对象，查看asInterface源码，我们不难发现，客户端获取到的其实时Stub.Proxy,一个远程服务的代理。
//客户端获取aidl
aidl = IMyAidlInterface.Stub.asInterface(service);
//Stub的asInterface
public static com.yunzhou.aidlserver.IMyAidlInterface asInterface(android.os.IBinder obj) {
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.yunzhou.aidlserver.IMyAidlInterface))) {
return ((com.yunzhou.aidlserver.IMyAidlInterface)iin);
}
return new com.yunzhou.aidlserver.IMyAidlInterface.Stub.Proxy(obj);
}
所以客户端调用add/addUser方法其实调用的时Stub.Proxy中实现的add/addUser,在Stub.Proxy中我们可以看到一句核心代码
//add
mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
//addUser
mRemote.transact(Stub.TRANSACTION_addUser, _data, _reply, 0);
追溯源头，mRemote其实就是IMyAidlInterface.Stub，随意mRemote.transact传递到了IMyAidlInterface.Stub.OnTransact, onTransact中执行了add/addUser,回调到了我们在服务端定义Service中声明IBidner时重写的add/addUser,这就是AIDL的整个流程。
private IBinder iBinder = new IMyAidlInterface.Stub(){
@Override
public int add(int value1, int value2) throws RemoteException {
return value1 + value2;
}
@Override
public List<User> addUser(User user) throws RemoteException {
users.add(user);
return users;
}
};
下面用一张图来总结aidl原理，这边特别感谢imooc
