安卓中跨进程通讯时常常需要AIDL，因此总结一下AIDL的用法和简要分析AIDL的工作流程。
在Android Studio中可以直接创建AIDL文件，创建的AIDL文件会生成在新创建的aidl文件夹下。
建议在aidl下建立实体类，这样可以将整个aidl直接拷贝，建立的文件列表如下： 
Book是实现了Parcelable的实体类：
public class Book implements Parcelable{
public String usrName;
public int usrId;
public boolean isMale;
public Book(String usrName, boolean isMale, int usrId) {
this.usrName = usrName;
this.isMale = isMale;
this.usrId = usrId;
}
protected Book(Parcel in) {
usrName = in.readString();
usrId = in.readInt();
isMale = in.readByte() != 0;
}
public static final Creator<Book> CREATOR = new Creator<Book>() {
@Override
public Book createFromParcel(Parcel in) {
return new Book(in);
}
@Override
public Book[] newArray(int size) {
return new Book[size];
}
};
@Override
public int describeContents() {
return 0;
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeString(usrName);
dest.writeInt(usrId);
dest.writeByte((byte) (isMale ? 1 : 0));
}
}定义Book.aidl使得IBookManager.aidl可以找到实体类：
// Book.aidl
package com.example.aidl;
parcelable Book;记得在IBookManager.aidl 中import com.example.aidl.Book
// IBookManager.aidl
package com.example.aidl;
// Declare any non-default types here with import statements
//需要导入实体类
import com.example.aidl.Book;
interface IBookManager {
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/
void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat,
double aDouble, String aString);
//定义两个需要实现的方法
List<Book> getBookList();
void addBook(in Book book);
}为了能够编译aidl文件夹下的Book.java,需要在应用的build.gradle中做如下配置：
sourceSets{
main{
java.srcDirs = ['src/main/java', 'src/main/aidl']
}
}接下来就可以进行进程间通信了，我们可以给Service指定android:process=":remote"来模拟进程间通信。
在Activity中绑定Service:
Intent intent = new Intent(this, MainService.class);
mConn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service)
{
mIBookManager = IBookManager.Stub.asInterface(service);
}
@Override
public void onServiceDisconnected(ComponentName name) {
}
};
bindService(intent, mConn, Context.BIND_AUTO_CREATE);在Service的onBind方法中返回Binder对象：
public class MainService extends Service {
ArrayList<Book> mBookList;
@Nullable
@Override
public IBinder onBind(Intent intent) {
return new MyBookManager();
}
@Override
public void onCreate() {
super.onCreate();
mBookList=new ArrayList<Book>();
}
class MyBookManager extends IBookManager.Stub{
@Override
public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString) throws RemoteException {}
@Override
//实现定义的接口方法，用于被跨进程调用
public List<com.example.aidl.Book> getBookList() throws RemoteException
{
return mBookList;
}
@Override
//实现定义的接口方法，用于被跨进程调用
public void addBook(com.example.aidl.Book book) throws RemoteException
{
mBookList.add(book);
}
}
}根据IBookManager.Stub.asInterface(service)获取IBookManager对象，这样就可以在Activity中利用mIBookManager对象跨进程调用Service的方法了，例如在Activity中：
public void addBook(View view) {
if (mIBookManager != null) {
try {
//将会调用Service中MyBookManager实例的addBook方法。
mIBookManager.addBook(new Book("momo", false, 0));
} catch (RemoteException e) {
e.printStackTrace();
}
}
}接着分析一下根据IBookManager.aidl自动生成的IBookManager.java文件。
package com.example.aidl;
public interface IBookManager extends android.os.IInterface {
/**
* Local-side IPC implementation stub class.
*/
public static abstract class Stub extends android.os.Binder implements com.example.aidl.IBookManager {...}
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/
public void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, java.lang.String aString) throws android.os.RemoteException;
public java.util.List<com.example.aidl.Book> getBookList() throws android.os.RemoteException;
public void addBook(com.example.aidl.Book book) throws android.os.RemoteException;
}可以看出IBookManager接口extends android.os.IInterface，包含两个我们定义在IBookManager.aidl的待实现的方法，同时内部包含了一个静态内部抽象类Stub，Stub既继承自Binder又实现了IBookManager，IBookManager.Stub就是我们需要创建的进行通信的Binder对象。
接着看一下Stub的简要结构：
public static abstract class Stub extends Binder implements IBookManager {
private static final java.lang.String DESCRIPTOR = "com.example.aidl.IBookManager";
/**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.example.aidl.IBookManager interface,
* generating a proxy if needed.
*/
public static IBookManager asInterface(IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.example.aidl.IBookManager))) {
return ((com.example.aidl.IBookManager) iin);
}
return new com.example.aidl.IBookManager.Stub.Proxy(obj);
}
@Override
public android.os.IBinder asBinder() {
return this;
}
@Override
public boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_basicTypes: {
...
return true;
}
case TRANSACTION_getBookList: {
...
return true;
}
case TRANSACTION_addBook: {
...
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements IBookManager {
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote) {
mRemote = remote;
}
@Override
public android.os.IBinder asBinder() {
return mRemote;
}
public java.lang.String getInterfaceDescriptor() {
return DESCRIPTOR;
}
/**
* Demonstrates some basic types that you can use as parameters
* and return values in AIDL.
*/
@Override
public void basicTypes(...) throws RemoteException {
...
try {
...
mRemote.transact(Stub.TRANSACTION_basicTypes, _data, _reply, 0);
_reply.readException();
} finally {
...
}
}
@Override
public java.util.List<Book> getBookList() throws RemoteException {
...
try {
...
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
...
} finally {
...
}
return _result;
}
@Override
public void addBook(Book book) throws RemoteException {
...
try {
...
mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
} finally {
...
}
}
}
static final int TRANSACTION_basicTypes = (FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_getBookList= (FIRST_CALL_TRANSACTION + 1);
static final int TRANSACTION_addBook = (FIRST_CALL_TRANSACTION + 2);
}可以看到Stub内部包含了一个实现了IBookManager的静态内部代理类Proxy ，Stub.asInterface(Ibinder binder)返回的就是Proxy实例，代理类在实现方法内最终都是调用了mRemote.transact()方法。transact()方法第一个参数code是int类型值，代表的是具体调用的方法序号，服务端根据onTransact()根据code值来判断调用的方法。
客户端执行transact方法后，当前线程会被挂起，直到服务端onTransact执行并返回数据后，当前线程继续执行
//FIRST_CALL_TRANSACTION 的值为1
static final int TRANSACTION_basicTypes = (FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_getBookList= (FIRST_CALL_TRANSACTION + 1);
static final int TRANSACTION_addBook = (FIRST_CALL_TRANSACTION + 2);
@Override
public boolean onTransact(int code, ...) throws RemoteException {
switch (code) {
...
case TRANSACTION_basicTypes: {
...
return true;
}
case TRANSACTION_getBookList: {
...
return true;
}
case TRANSACTION_addBook: {
...
return true;
}
}
return super.onTransact(code, data, reply, flags);
}可以看出Stub内部把方法从1开始排号，服务端根据该code的值来判断调用的方法，并没有传递真正的函数名。
参考自《Android开发艺术探索》