1.Binder简介
我们知道，在Android操作系统中，每个进程都拥有属于自己的独立虚拟地址空间（用户空间+内核空间）。一般情况下，进程的用户空间是各自独立的，无法进行数据共享；而内核空间却是所有进程都可以共同访问的。
对于Android系统来说，其特有的IPC机制是Binder。正如其名字所喻（粘粘剂），通过Binder作为桥梁，将系统各个进程组件进行连接。
2.Binder优点
1.Binder更加简洁和快速，消耗的内存资源更小。
2.传统的进程间通信可能会增加进程的开销，而且有进程过载和安全漏洞等方面的风险，Binder正好能解决和避免这些问题。
3.用驱动程序来推进进程间的通信。
4.通过共享内存来提高性能。
5.为进程请求分配每个进程的线程池。
6.针对系统中的对象引入了引用计数和跨进程的对象引用映射。
7.进程间同步调用。
3.Binder实现IPC通讯原理
3.1 Binder IPC基础组件
Binder通讯采用C/S架构，其进行IPC涉及到的组件主要包含Client,Server,ServerManager和binder驱动。
Client：客户端
Server：服务端
ServerManager：用于管理系统中的各种服务。提供服务注册功能和查询服务功能。（此处的ServerManager是Native层的ServiceManager(c++),不是framework层的ServerManager(java)）。
binder驱动：位于内核空间，提供Client，Server，ServerManager跨进程通讯功能。
3.2实例讲解
我们知道，Android提供的AIDL通讯底层采用的就是Binder机制。现在我们采用AIDL方式创建2个应用进行进程间通讯。
(1)首先定义aidl接口：
// IMath.aidl
package com.yn.bindertest.aidl;
// Declare any non-default types here with import statements
interface IMath {
int add(in int a,in int b);
void result(in int justTestWithoutReturnValue);
}
(2)服务端代码编写：
public class Server extends Service {
private static final String TAG = "ynServer";
@Nullable
@Override
public IBinder onBind(Intent intent) {
return new IMath.Stub(){
@Override
public int add(int a, int b) throws RemoteException {
Log.d(TAG, "add: "+Thread.currentThread().getName());
return a+b;
}
@Override
public void result(int justTestWithoutReturnValue) throws RemoteException {
Log.d(TAG, "result: "+Thread.currentThread().getName());
}
};
}
}
(3)客户端代码编写：
public class MainActivity extends AppCompatActivity {
private static final String TAG = "ynClient";
private TextView tvShow;
private IMath mServer;
private ServiceConnection mServiceConnection = new ServiceConnection() {
@Override
public void onServiceConnected(ComponentName name, IBinder service) {
Log.d(TAG, "onServiceConnected: "+Thread.currentThread().getName());
mServer = IMath.Stub.asInterface(service);
try {
mServer.asBinder().linkToDeath(mDeathRecipient,0);
} catch (RemoteException e) {
e.printStackTrace();
}
}
@Override
public void onServiceDisconnected(ComponentName name) {
Log.d(TAG, "onServiceDisconnected: "+Thread.currentThread().getName());
}
};
private IBinder.DeathRecipient mDeathRecipient = new IBinder.DeathRecipient(){
@Override
public void binderDied() {
Log.d(TAG, "binderDied: "+Thread.currentThread().getName());
bindService(new Intent(MainActivity.this, Server.class),mServiceConnection , Context.BIND_AUTO_CREATE);
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
tvShow = (TextView)findViewById(R.id.tvShow);
bindService(new Intent(this, Server.class),mServiceConnection , Context.BIND_AUTO_CREATE);
}
public void onClick(View view)
{
try {
int sum = mServer.add(10,30);
Log.d(TAG, "onClick: sum="+sum);
tvShow.setText(sum+"");
} catch (RemoteException e) {
e.printStackTrace();
}
}
}
(4)记得在AndroidManifest.xml中将Service设置到另一个进程中。
<service
android:name=".Server"
android:process="com.yn.bindertest.server" />
通过以上步骤，我们就实现了使用AIDL进行跨进程通讯功能，结果如下：
当程序启动时，bindService()成功时就会回调onServiceConnected，然后手动调用add可以看到add过程是运行在Server端的binder线程池中的；由于为Server设置了死亡代理，当服务端异常被kill时，会回调死亡代理IBinder.DeathRecipient.binderDied和ServiceConnection.onServiceDisconnected，两者的区别就是binderDied是运行在客户端的binder线程池中的，而onServiceDisconnected是运行在主线程中的。
更关键的一点是：当客户端调用远程函数时，客户端进程会被挂起，等待远程服务端执行完成后才重新运行客户端进程，因此，这是一个同步调用，应小心因为服务端的耗时方法导致客户端发生ANR。
3.3 aidl的binder机制讲解
当我们创建完成IMath.aidl文件后，rebuild一下，可以看到IDE为我们生成了一个.java文件，路径为：app\build\generated\source\aidl\debug\com\yn\bindertest\aidl\IMath.java
该IMath.java的具体内容如下：
可以看到，IDE为我们自动生成的其实就是一个继承了IInterface的接口，生成的接口类名和方法与我们aidl中声明的完全一致，只是另外增加了一个Stub内部抽象静态类，而这个Stub类继承了Binder并且实现了我们这个IMath(由于IMath继承了IInterface,而IInterface只有一个接口方法asBinder),所以这个Stub类就是一个Binder，并且必须实现我们自己定义的IMath中的接口方法，并提供asBinder方法给到系统调用。
所以这个Stub类才是我们要着重进行研究的，那么这个Stub类的具体如下所示：
/**
* Local-side IPC implementation stub class.
*/
public static abstract class Stub extends android.os.Binder implements com.yn.bindertest.aidl.IMath {
private static final java.lang.String DESCRIPTOR = "com.yn.bindertest.aidl.IMath";
/**
* Construct the stub at attach it to the interface.
*/
public Stub() {
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.yn.bindertest.aidl.IMath interface,
* generating a proxy if needed.
*/
public static com.yn.bindertest.aidl.IMath asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.yn.bindertest.aidl.IMath))) {
return ((com.yn.bindertest.aidl.IMath) iin);
}
return new com.yn.bindertest.aidl.IMath.Stub.Proxy(obj);
}
@Override
public android.os.IBinder asBinder() {
return this;
}
@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_add: {
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
int _arg1;
_arg1 = data.readInt();
int _result = this.add(_arg0, _arg1);
reply.writeNoException();
reply.writeInt(_result);
return true;
}
case TRANSACTION_result: {
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
this.result(_arg0);
reply.writeNoException();
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
private static class Proxy implements com.yn.bindertest.aidl.IMath {
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 int add(int a, int b) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(a);
_data.writeInt(b);
mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void result(int justTestWithoutReturnValue) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(justTestWithoutReturnValue);
mRemote.transact(Stub.TRANSACTION_result, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_result = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
}
看一下asInterface()内容：
可以看出，通过DESCRIPTOR（即包名+类名："com.yn.bindertest.aidl.IMath"）先进行本地查找，如果找到，那么返回本地binder类对象（即onBind返回的那个binder对象），如果找不到，那么返回一个binder代理类，这个代理类具体内容如下：
private static class Proxy implements com.yn.bindertest.aidl.IMath {
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 int add(int a, int b) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
int _result;
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(a);
_data.writeInt(b);
mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override
public void result(int justTestWithoutReturnValue) throws android.os.RemoteException {
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(justTestWithoutReturnValue);
mRemote.transact(Stub.TRANSACTION_result, _data, _reply, 0);
_reply.readException();
} finally {
_reply.recycle();
_data.recycle();
}
}
}
可以看到，这个Proxy也实现了IMath接口，并且持有一个远程服务的IBinder对象（其实这个IBinder是一个BinderProxy对象，是bindservice时，向ServiceManager获取得到的）。所以，当处于不同的进程时，客户端得到的是一个Proxy代理类，然后由于该代理类实现了aidl定义的接口，并且持有一个远程IBinder接口，所以在调用aidl接口方法时，可以看到，它通过将函数参数放入到一个Parcel(_data)中，提供一个Parcel（_reply)存储返回结果(如果有返回的话)，然后通过持有的远程IBinder对象的transact将函数标识，参数Parcel和返回结果Parcel发送给远程服务，客户端调用transact时，客户端进程被挂起，然后通过binder驱动调用到远程服务的onTransact函数，通过传递过来的函数标识，就可以知道要执行哪个函数，然后取出对应的函数参数，运行完成后，将返回结果存储到_reply中，通过binder驱动返回给客户端，客户端只要读取_reply就可以获取到结果。这样，就完成了一次IPC通讯。
综上所述，通过aidl实现IPC的原理如下：
1.IDE根据我们定义的aidl生成一个同名接口，并继承IInterface,目的是为了客户端可以通过asBinder获取到binder对象（同个进程则获取的是同一个binder，不同进程获取到的是一个BinderProxy代理对象）。
2.当Server（Service）启动时，它会通过binder驱动向ServiceManager进行注册（binder标识+binder引用）；当Client要获取远程服务（bindservice）时，它首先要通过binder驱动向ServiceManger获取特定远程服务的binder引用，获取成功后，就可以对远程服务进行IPC通讯（也是通过binder驱动）。
总结
应用间通过Binder实现IPC的整体过程如下图所示：
1.当Server启动时，它会通过进程内的0号binder引用，将服务名和binder传递给内核0号binder引用，再依次传给ServiceManager内核binder实体，最后传入ServiceManager的进程binder中。经过这个过程后，ServiceManager内部就记录了Server相应的信息，该过程即是Server向ServiceManager的注册过程。
2.当Client要进行远程服务通讯时，它首先会经由进程内0号binder引用通知到内核0号binder引用，然后经由ServiceManager内核binder实体，最后将所需的服务信息传入到ServiceManager进程的binder实体中，那么ServiceManager通过查询相关服务信息，如果存在对应服务，就会通过binder驱动传递一个拥有访问远程服务能力的BinderProxy给到Client（即bindservice时，onServiceConnection中的onConnected中的IBinder参数）。这个过程就是Client的获取远程服务过程。
3.Client获取远程服务成功后，就可以通过ServiceManager传递过来的BinderProxy对象创建出一个远程服务Binder的代理类对象（asInterface），通过这个代理类对象，Client就可以执行远程服务相关方法了，从而实现跨进程IPC通讯。
4.当Client调用远程方法时，本地远程binder的代理类对象会调用其持有的BinderProxy对象的transact方法，这个方法会将要调用的函数标识，参数和返回值（如果有的话）放入到Client的共享内存中，然后经由内核binder驱动运输到相应远程服务的共享内存中，然后远程服务的进程binder实体的onTransact函数会被调用，这个函数的功能就是从共享内存中获取传递过来的相关信息，通过函数标识就知道要运行哪个函数，然后再将相关的参数提取出来（如果有的话），执行完毕后，就将返回结果存入之前传递过来的容器（Parcel）内，最后经由内核binder驱动传递回给到Client中。这样，一次完整的binder IPC通讯就完成了。
