Android 跨进程通信之：AIDL

写这篇文章之前，首先要感谢一下任玉刚大哥写了《Android开发艺术探索》这本书。这篇文章其实就是对书中讲解AIDL的那个小节的一个简单的总结。

Android进程间通信方式

Android实现进程间通信的方式有很多种，比如通过Intent来传递数据，共享文件，SharedPreferences，基于Binder的Messager和AIDL，以及socket等。Binder是Android中最有特色的进程间通信方式。

Binder

Binder主要用于进程间通信，是Android中的一个类，实现了IBinder接口。从Android应用层来说，Binder是服务端与客户端通信的媒介，当bindService一个服务的时候，服务端会返回一个包含了服务端业务调用的Binder对象，通过这个对象客户端就可以获取服务端数据或向服务端传递数据，这里的服务包括普通服务和包含了AIDL的服务。

在Android开发中，Binder主要用在Service中，包括AIDL、Messager。普通Service中的Binder不涉及到进程间通信，所以较为简单。Messager底层其实就是AIDL，这里选择AIDL来学习Binder的工作机制。

AIDL在Service中的使用方法

[b]服务端[/b]

定义AIDL接口，将暴露给客户端的接口在这个AIDL文件中声明

// IBookManager.aidl
package com.example.android.aidl;

interface IBookManager{

void setName(String name);
String getName();
}

系统会自动根据AIDL文件生成用于通信的java类。建议将AIDL文件及所有AIDL用到的类和文件放在同一个包中，这样做的好处是，当客户端在另一个工程时，我们可以直接整个包复制到客户端工程。

编写Service，在Service实现AIDL接口

//MyService.java
package com.example.android.service;

public class MyService extends Service {

private String name;
@Override
public void onCreate() {
super.onCreate();

}
@Override
public IBinder onBind(Intent arg0) {

return mBinder;
}

private final IBookManager.Stub mBinder = new IBookManager.Stub() {
void setName(String name){
this.name = name;
}
String getName(){
return name;
}
};

}

然后在清单文件中注册Service，这里假设action为：

com.example.android.action.bookmanager

[b]客户端[/b]

拷贝AIDL文件

将AIDL文件及所有AIDL用到的类和文件拷贝到客户端工程中（如果服务端跟客户端没在一个工程的话），注意客户端AIDL的包结构必须和服务端保持一致。

绑定远程服务。绑定成功后将服务端返回的Binder对象转化成AIDL接口所属类型，接着就可以调用AIDL中的方法。

//MainActivity.java
package com.example.android.activiy;

public class MainActivity extends Activity {

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

String action = "com.example.android.action.bookmanager";
Intent intent = new Intent(action);
//Android 5.0后不能使用隐式Intent启动服务，所以这里需要指定包名
intent.setPackage("com.example.android");
bindService(intent, conn, Context.BIND_AUTO_CREATE);
}

ServiceConnection conn = new ServiceConnection() {

@Override
public void onServiceDisconnected(ComponentName name) {
}

@Override
public void onServiceConnected(ComponentName name, IBinder service) {
//将服务端返回的Binder对象转化成AIDL接口所属类型
IBookManager mBookManager = IBookManager.Stub.asInterface(service);
try {
String name = mBookManager.getName();
mBookManager.setName("Android开发艺术探索");
} catch (RemoteException e) {
e.printStackTrace();
}
}
};

@Override
protected void onDestroy() {
super.onDestroy();
unbindService(conn);
}
}

AIDL 源码解析

上面简单介绍了一下AIDL在Service中的使用，接着就通过AIDL接口对应的java源码来分析一下AIDL是如何通过Binder实现进程间通信的。

//IBookManager.java
package com.example.android.aidl;

/**
* 系统根据aidl文件自动生成的java文件
*/
public interface IBookManager extends android.os.IInterface {

// 用于标识setName()、getName()方法的id
static final int TRANSACTION_setName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_getName = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);

// aidl文件接口中声明的方法
public void setName(java.lang.String name)
throws android.os.RemoteException;
public java.lang.String getName() throws android.os.RemoteException;

/** Stub 是IPC通信实现类，Stub即是Binder对象，也是IBookManager对象 */
public static abstract class Stub extends android.os.Binder implements
com.example.xutils3demo.aidl.IBookManager {

// Binder唯一标识，一般用当前Binder的类名表示
private static final java.lang.String DESCRIPTOR = "com.example.xutils3demo.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.xutils3demo.aidl.IBookManager interface, generating a
* proxy if needed.
* 客户端应调用此方法将服务端返回的Binder对象转换成AIDL接口所属的类型，接着就可以调用AIDL中的方法了。
* 如果不跨进程通信直接返回IBookManager对象本身，否则返回IBookManager对象的代理
*/
public static com.example.xutils3demo.aidl.IBookManager asInterface(
android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.example.xutils3demo.aidl.IBookManager))) {
// 不跨进程，返回IBookManager对象本身
return ((com.example.xutils3demo.aidl.IBookManager) iin);
}
// 跨进程，返回IBookManager对象的代理Proxy对象
return new com.example.xutils3demo.aidl.IBookManager.Stub.Proxy(obj);
}

// Binder唯一标识，一般用当前Binder的类名表示
@Override
public android.os.IBinder asBinder() {
return this;
}

/**
* 方法执行在服务端，由客户端通过RPC(远程过程调用)进行调用， 通过这个方法，最终使得服务端Binder对象中对应的方法被调用。
*
* 服务端可以根据code值，确定客户端请求的目标方法是什么。 接着从data中取出目标方法所需的参数，然后执行目标方法。
* 目标方法执行完后，就向reply中写入返回值，返回给客户端。
*
* 注意：如果此方法返回false的话，那么客户端的请求会失败， 因此可以利用这个特性来做权限验证。使得符合权限的客户端才能 调用服务端方法。
*/
@Override
public boolean onTransact(int code, android.os.Parcel data,
android.os.Parcel reply, int flags)
throws android.os.RemoteException {
switch (code) {
case INTERFACE_TRANSACTION: {
reply.writeString(DESCRIPTOR);
return true;
}
case TRANSACTION_setName: {
data.enforceInterface(DESCRIPTOR);
java.lang.String _arg0;
// 从data中取出目标方法所需参数
_arg0 = data.readString();
// 这里使得服务端Binder中的方法执行
this.setName(_arg0);
reply.writeNoException();
return true;
}
case TRANSACTION_getName: {
data.enforceInterface(DESCRIPTOR);
// 这里使得服务端Binder中的方法执行
java.lang.String _result = this.getName();
reply.writeNoException();
reply.writeString(_result);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}

/**
* Binder代理，类中方法执行在客户端，这个类才是真正的RPC。
*
* RPC过程：当客户端调用Proxy对象的setName()方法时，会通 过transact()发起RPC请求，并将当前线程挂起。接着服务端
* 的onTransact()会被调用，从而使得服务端的Binder中的对应的setName()方法被调用，直到RPC过程返回后，当前线程才
* 继续执行，并从_reply 中取出RPC过程的返回结果，然后返 给setName()方法(如果有返回值的话)。getName()方法同理。
*
*/
private static class Proxy implements
com.example.xutils3demo.aidl.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;
}

@Override
public void setName(java.lang.String name)
throws android.os.RemoteException {
// _data 输入型Parcel对象，用于携带客户端传递给服务端的参数
android.os.Parcel _data = android.os.Parcel.obtain();
// _reply 输出型Parcel对象，用于携带从服务端返回给客户端的返回结果
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
//将要传递给服务端的参数写入_data中
_data.writeString(name);
// 调用Binder对象的transact()方法发送RPC请求，并将当前挂起
mRemote.transact(Stub.TRANSACTION_setName, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}

@Override
public java.lang.String getName() throws android.os.RemoteException {

android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.lang.String _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getName, _data, _reply, 0);
_reply.readException();
// 从_reply中读取服务端返回给客户端的返回结果
_result = _reply.readString();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
}
}

}

AIDL支持的参数类型

在AIDL文件中，并不是支持所有的数据类型，只有某些数据类型才能使用。AIDL支持的数据类型有：

基本数据类型（int、long、char、boolean、double等）

String 和 CharSequence

List：只支持ArrayList，里面的元素都必须能够被AIDL支持

Map：只支持HashMap，里面的每个元素都必须能够被AIDL支持，包括key和value

Parcelable：所有实现了Parcelable 的对象

AIDL：所有AIDL接口本身也可以在AIDL文件中使用

AIDL文件定义注意事项

Parcelable对象在AIDL中使用前必须新建一个和它同名的AIDL文件，并在其中声明该类为Parcelable类型。

在AIDL中，使用自定义的Parcelable对象和AIDL接口必须显示import进来，不管他们是否和当前AIDL位于同一个包中。这是AIDL的规范。

AIDL接口中只支持方法，不支持静态常量，这一点区别于传统接口。

AIDL中除基本数据类型外，其他类型的参数必须标上方向：in、out和inout。in表示输入型参数，out表示输出型参数，inout表示输入输出型参数。

以下是书中提到的更多关于AIDL使用的内容，这里就不一一讲解了。

使用AIDL在服务端注册与解注册监听器

远程服务断开重连

使用AIDL做权限验证