【Android源码】Binder机制和AIDL分析
一般状况下，若是两个对象可以直接相互访问，那么这两个对象存在于同一个内存空间中。 若是两个对象分别存在于两个不一样的进程的时候，那么这两个对象是不能相互访问的，这个时候就须要使用跨进程通讯的技术了。 而Android是基于Linux系统的，Linux传统的跨进程技术主要是Socket，信号量，管道，消息队列等，可是这些技术都有不一样的缺点，如Socket开销大效率不高，管道和消息队列拷贝次数多，而对于Android系统来说，更重要的是安全性要高，而这些技术安全性都不是很高，大部分状况下接收方并不能获得发送发进程的PID/UID，很难识别身份。 因此Android系统就设计出了Binder跨进程通讯机制，来保证传输性能和安全性。java
Binder
Binder主要模块
-
BinderDriverandroid
存在于内核空间中，以字符设备的misc类型注册，用户能够从/dev/binder设备文件节点上，经过open和ioctl文件操做函数与BinderDriver进行通讯，主要是负责Binder通讯的创建，进程间的传递、Binder引用计数管理/数据包的管理。git
-
BinderClientgithub
存在于用户空间中，它和BinderServer的跨进程通讯都是经过BinderDriver来处理转发的。 对于BinderClient只须要知道本身须要使用的Binder的名字和该Binder在ServerManager中的0号引用就能够了。经过0号引用去访问ServerManager获取Binder的引用，获得引用后就能够直接调用Binder的方法了。安全
-
ServerManagerbash
存在于用户空间中，用来管理BinderServer，BinderClient能够经过它来查询BinderServer接口，查询到以后就能够获取到Binder的映射。服务器
-
BinderServer并发
BinderServer会生成一个Binder实体，并会给Binder绑定一个名字，最终封装成一个数据包传递给BinderDriver，BinderDriver在获取到这个数据包以后，若是发现这个数据包是新传递过来的，就会给其在内核空间中建立相应的Binder实体节点和对应的实体节点的引用。 BinderDriver会将Binder的引用传递给ServerManager，ServerManager收到后就会取出Binder的名字和引用插入一张数据表中，这个就和DNS存储域名到IP的映射原理同样。ide
系统如何使用Binder
在客户端中ServerManager的接口定义主要是在IServiceManager中：函数
public interface IServiceManager extends IInterface
{
/**
* Retrieve an existing service called @a name from the
* service manager. Blocks for a few seconds waiting for it to be
* published if it does not already exist.
*/
public IBinder getService(String name) throws RemoteException;
/**
* Retrieve an existing service called @a name from the
* service manager. Non-blocking.
*/
public IBinder checkService(String name) throws RemoteException;
/**
* Place a new @a service called @a name into the service
* manager.
*/
public void addService(String name, IBinder service, boolean allowIsolated)
throws RemoteException;
/**
* Return a list of all currently running services.
*/
public String[] listServices() throws RemoteException;
/**
* Assign a permission controller to the service manager. After set, this
* interface is checked before any services are added.
*/
public void setPermissionController(IPermissionController controller)
throws RemoteException;
static final String descriptor = "android.os.IServiceManager";
int GET_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION;
int CHECK_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+1;
int ADD_SERVICE_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+2;
int LIST_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+3;
int CHECK_SERVICES_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+4;
int SET_PERMISSION_CONTROLLER_TRANSACTION = IBinder.FIRST_CALL_TRANSACTION+5;
}
复制代码
能够看到IServiceManager定义的方法主要是添加，获取，检查等关于各类服务。主要做用其实就是像上面所说的简单的将Binder以字符表示的名字转换成引用。而对于BinderClient的实现其实就是ServiceManagerNative和ServiceManagerProxy，这两个类实现了该接口，咱们在AIDL的时候在分析。
AIDL
咱们以具体的例子来分析，首先咱们建立相关aidl文件：
// Book.java
public class Book implements Parcelable {
public int bookId;
public String bookName;
protected Book(Parcel in) {
bookId = in.readInt();
bookName = in.readString();
}
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(bookId);
dest.writeString(bookName);
}
@Override
public int describeContents() {
return 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];
}
};
}
// Book.aidl
package com.fastaoe.proficient;
parcelable Book;
// IBookManager.aidl
package com.fastaoe.proficient;
import com.fastaoe.proficient.Book;
interface IBookManager {
List<Book> getBookList();
void addBook(in Book book);
}
复制代码
上面3个文件，Book.java表示图书信息，实现了Parcelable接口。 Book.aidl是Book.java在AIDL中的声明。 IBookManager是定义了用来操做Book的方法，getBookList从服务器中获取图书列表，addBook向服务器图书列表中插入一本新书。 当咱们声明好了AIDL以后，IDE编译好以后，就生成了IBookManager.java这个类。
public interface IBookManager extends android.os.IInterface {
// 代码省略，下面在分析
}
复制代码
能够看到这个系统为咱们生成的类，实现了IInterface这个接口，本身自己也是一个接口，咱们能够实现这个接口来实现相关的方法。咱们来具体分析下这个生成的接口：
private static final java.lang.String DESCRIPTOR = "com.fastaoe.proficient.IBookManager";
复制代码
Binder的惟一标识，通常状况下使用当前的类来表示。
public static com.fastaoe.proficient.IBookManager asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.fastaoe.proficient.IBookManager))) {
return ((com.fastaoe.proficient.IBookManager) iin);
}
return new com.fastaoe.proficient.IBookManager.Stub.Proxy(obj);
}
复制代码
用来将服务器中的Binder对象转换成客户端中所须要的AIDL接口类型的对象。能够看到当客户端和服务端在同一个进程的时候，返回的就是服务端的Stub自己，若是不在同一个进程，返回的是系统封装好的Stub.proxy对象，这表示当不在同一个进程的时候，客户端拿到的其实不是服务端Binder自己，而是一个副本。
public android.os.IBinder asBinder() {
return this;
}
复制代码
返回Binder对象自己。
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_getBookList: {
data.enforceInterface(DESCRIPTOR);
java.util.List<com.fastaoe.proficient.Book> _result = this.getBookList();
reply.writeNoException();
reply.writeTypedList(_result);
return true;
}
case TRANSACTION_addBook: {
data.enforceInterface(DESCRIPTOR);
com.fastaoe.proficient.Book _arg0;
if ((0 != data.readInt())) {
_arg0 = com.fastaoe.proficient.Book.CREATOR.createFromParcel(data);
} else {
_arg0 = null;
}
this.addBook(_arg0);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
复制代码
这个方法运行在服务器端的Binder线程池中，当客户端发起跨进程的请求的时候，请求会经过底层封装以后交给此方法执行。服务器端经过code来判断客户端请求的方法是什么，接着从data中获取目标方法所须要的数据，并执行目标方法。当方法执行完以后经过reply写入返回值，最后返回是否成功，若是成功返回true，不然则是false失败。
private static class Proxy implements com.fastaoe.proficient.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 java.util.List<com.fastaoe.proficient.Book> getBookList() throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
java.util.List<com.fastaoe.proficient.Book> _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
mRemote.transact(Stub.TRANSACTION_getBookList, _data, _reply, 0);
_reply.readException();
_result = _reply.createTypedArrayList(com.fastaoe.proficient.Book.CREATOR);
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void addBook(com.fastaoe.proficient.Book book) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
if ((book != null)) {
_data.writeInt(1);
book.writeToParcel(_data, 0);
} else {
_data.writeInt(0);
}
mRemote.transact(Stub.TRANSACTION_addBook, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
复制代码
这个类运行在客户端中，当客户端调用此方法以后，首先会建立parcel的类型的输入对象_data，输出对象_reply，返回值对象_result（若是有的话），接着经过_data将参数存储起来，在经过transact方法来发送RPC请求，同时线程会被挂起。接着服务端的onTransact方法会调用，最终RPC过程返回后，当前线程继续执行，从_reply获取到返回的结果。
经过AIDL实现跨进程通讯（参考《Android开发艺术探索第二章例子》）
咱们把AIDL生成的类分析完以后，就来实现一个服务器和客户端通讯的例子吧。
首先定义AIDL文件，就是上面图书的例子
其中须要注意的是：
AIDL支持的数据类型：
- 基本数据类型
- String和CharSequence
- ArrayList和HashMap
- Parcelable
- AIDL自己
当咱们自定义了Parcelable的时候，必须新建一个同名的.aidl文件，并将其声明为parcelable类型。 AIDL中全部的实现了Parcelabe接口的类都须要声明相对应的aidl文件，而且须要标识in(输入)、out(输出)、inout(输入输出)。
服务端的实现
public class ServerService extends Service {
private CopyOnWriteArrayList<Book> list = new CopyOnWriteArrayList<>();
private RemoteCallbackList<IAddBookListener> listeners = new RemoteCallbackList<>();
@Override
public void onCreate() {
super.onCreate();
list.add(new Book(1, "岛上书店"));
list.add(new Book(2, "白夜行"));
}
@Nullable
@Override
public IBinder onBind(Intent intent) {
return binder;
}
private IBinder binder = new IBookManager.Stub(){
@Override
public List<Book> getListBook() throws RemoteException {
return list;
}
@Override
public void addBook(Book book) throws RemoteException {
onNewBookAdd(book);
}
@Override
public void registerListener(IAddBookListener listener) throws RemoteException {
listeners.register(listener);
}
@Override
public void unregisterListener(IAddBookListener listener) throws RemoteException {
listeners.unregister(listener);
}
};
private void onNewBookAdd(Book book) throws RemoteException {
list.add(book);
int N = listeners.beginBroadcast();
for (int i = 0; i < N; i++) {
IAddBookListener broadcastItem = listeners.getBroadcastItem(i);
broadcastItem.OnNewBookAddListener(book);
}
listeners.finishBroadcast();
}
}
复制代码
在服务端中咱们首先初始化了图书列表，并建立了Binder对象并在onBind中返回。
-
使用了CopyOnWriteArrayList，这个List是支持并发读写的，由于当多个客户端同时链接的时候，会出现多个线程同时访问的问题，因此须要在AIDL中处理线程问题。
-
使用RemoteCallbackList来管理跨进程的listener接口，由于若是使用List的话，并不能在unregister的时候删除掉当前listener接口，虽然咱们使用的看上去是同一个listener，可是其实并非同一个对象。
客户端和服务端在多进程的环境中，而对象是不可能在多进程下传递的，因此Binder会将客户端传递过来的对象从新转化成新的对象，并非原来的对象，这实际上是反序列化的过程，因此AIDL中的自定义对象必须实现Parcelable接口。
那么怎么解除注册呢？
能够经过RemoteCallbackList，RemoteCallbackList是系统专门提供用来删除跨进程listener的接口，在它的内部有一个Map用来保存全部的AIDL回调，key是IBinder，value是callback。虽然在跨进程的环境中，生成的对象不是同一个对象，可是它们底层的Binder确定是同一个，因此能够利用这个来实现解除注册。当客户端要解除注册的时候，服务端经过RemoteCallbackList找到具备相同Binder对象的服务端listener并将其删除。
客户端实现
public class MainActivity extends AppCompatActivity {
private List<Book> list = new ArrayList<>();
private int index = 3;
Handler handler = new Handler(){
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case 1:
list.add((Book) msg.obj);
tv_book.setText(list.toString());
break;
}
}
};
private ServiceConnection conn = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
iBookManager = IBookManager.Stub.asInterface(service);
try {
iBookManager.registerListener(listener);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
iBookManager = null;
}
};
private IBookManager iBookManager;
private IAddBookListener listener = new IAddBookListener.Stub() {
@Override
public void OnNewBookAddListener(Book book) throws RemoteException {
handler.obtainMessage(1, book).sendToTarget();
}
};
private Button btn_search;
private Button btn_add;
private TextView tv_book;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
btn_search = (Button) findViewById(R.id.btn_search);
btn_add = (Button) findViewById(R.id.btn_add);
tv_book = (TextView) findViewById(R.id.tv_book);
btn_search.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (iBookManager != null) {
try {
// TODO: 2017/7/9 放在子线程中
list = iBookManager.getListBook();
} catch (RemoteException e) {
e.printStackTrace();
}
tv_book.setText(list.toString());
}
}
});
btn_add.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
if (iBookManager != null) {
Book book = new Book(index, "图书"+ index);
index += 1;
try {
// TODO: 2017/7/9 放在子线程中
iBookManager.addBook(book);
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
});
Intent intent = new Intent();
intent.setAction("com.fastaoe.server.ServerService");
intent.setComponent(new ComponentName("com.fastaoe.server", "com.fastaoe.server.ServerService"));
bindService(intent, conn, Context.BIND_AUTO_CREATE);
}
@Override
protected void onDestroy() {
try {
iBookManager.unregisterListener(listener);
} catch (RemoteException e) {
e.printStackTrace();
}
unbindService(conn);
super.onDestroy();
}
}
复制代码
首先绑定远程服务，接着将远程服务返回的Binder对象转换成AIDL接口，接着就能够调用服务端中的方法了。
-
须要注意的是若是aidl中的方法在服务端是耗时的操做的时候，须要处理，否则会致使ANR的产生，一样的当服务端调用客户端的耗时操做的时候，也须要保证在服务端的方法运行在非UI线程，由于Service自己是运行在UI线程中的。
-
OnNewBookAddListener运行在Binder线程池中，因此不能在其中访问UI相关的内容，若是须要访问的话，则须要经过Handler切换线程。
-
Binder在链接过程当中是可能意外死亡的，主要是由于服务端的进程被终止了，因此咱们须要从新链接服务。
- 能够经过在onServiceDisconnected中重连。
- 也能够经过DeathRecipient来监听是否被断开。
具体的Demo能够查看AIDL的简单实现