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 = 1;
private final Messenger mMessenger = new Messenger(new Handler() {
private int remoteInt = 1;//返回到进程A的值
@Override
public void handleMessage(Message msg) {
if (msg.what == GET_RESULT) {
try {
msg.replyTo.send(Message.obtain(null, GET_RESULT, remoteInt++, 0));
} 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(1);
msg.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
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(0);
}
boolean r = onTransact(code, data, reply, flags);
if (reply != null) {
reply.setDataPosition(0);
}
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 ((0!=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处理。