直观地说，Binder是Android的一个类，实现IBinder接口，可以重点关注transact方法和onTransact方法。事故Android提供跨进程通信的一种方式，是各种Manager(比如ActivityManager)和ManagerService通信的桥梁。从我们工程角度来看，是客户端和服务端通信的媒介，bindService时服务端返回一个Binder实例，通过这个实例客户端就可以调用服务端的方法或者数据。可以参考下面图示1。
public class Binder implements IBinder {
public static final native long clearCallingIdentity();
public static final native void restoreCallingIdentity(long var0);
public static final native void flushPendingCommands();
public static final native void joinThreadPool();
protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
throw new RuntimeException("Stub!");
}
public final boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
throw new RuntimeException("Stub!");
}
……
}
注：后面分析的过程都是基于鸿神博客中的代码，有需要可以到链接中查看源代码。例子是在客户端中去调用服务端中的两个方法，实现加法和减法。
1.不依赖AIDL的通信
假如不依赖于AIDL的通信，那么服务端的代码可以这样子,其中省略掉一些代码，只摘略一些紧要代码。
public class CalcPlusService extends Service
{
private static final String DESCRIPTOR = "CalcPlusService";
private static final String TAG = "CalcPlusService";
public IBinder onBind(Intent t)
{
Log.e(TAG, "onBind");
return mBinder;
}
private MyBinder mBinder = new MyBinder();
private class MyBinder extends Binder
{
@Override
protected boolean onTransact(int code, Parcel data, Parcel reply,int flags) throws RemoteException
{
switch (code)
{
case 0x110:
{
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
int _arg1;
_arg1 = data.readInt();
int _result = _arg0 * _arg1;
reply.writeNoException();
reply.writeInt(_result);
return true;
}
case 0x111:
{
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
int _arg1;
_arg1 = data.readInt();
int _result = _arg0 / _arg1;
reply.writeNoException();
reply.writeInt(_result);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
};
}
服务端在客户端bindService时返回内部类MyBinder的实例。MyBinder中实现onTransact方法，其中code是方法的编号，0x110/0x111分别代表客户端需要调用的两个方法；data中可以拿到方法调用需要的入参；reply用于存储方法调用的结果，客户端可以从中拿到结果；flags代表有无返回值，0代表有，1代表没有。
客户端的代码，摘略如下：
public class MainActivity extends Activity
{
private IBinder mPlusBinder;
private ServiceConnection mServiceConnPlus = new ServiceConnection()
{
@Override
public void onServiceConnected(ComponentName name, IBinder service)
{
Log.e("client", " mServiceConnPlus onServiceConnected");
mPlusBinder = service;
}
};
public void bindService(View view)
{
Intent intentPlus = new Intent();
intentPlus.setAction("com.zhy.aidl.calcplus");
boolean plus = bindService(intentPlus, mServiceConnPlus,
Context.BIND_AUTO_CREATE);
Log.e("plus", plus + "");
}
public void mulInvoked(View view)
{
if (mPlusBinder == null)
{
Toast.makeText(this, "未连接服务端或服务端被异常杀死", Toast.LENGTH_SHORT).show();
} else
{
android.os.Parcel _data = android.os.Parcel.obtain();
android.os.Parcel _reply = android.os.Parcel.obtain();
int _result;
try
{
_data.writeInterfaceToken("CalcPlusService");
_data.writeInt(50);
_data.writeInt(12);
mPlusBinder.transact(0x110, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
Toast.makeText(this, _result + "", Toast.LENGTH_SHORT).show();
} catch (RemoteException e)
{
e.printStackTrace();
} finally
{
_reply.recycle();
_data.recycle();
}
}
}
}
客户端在绑定服务成功时可以拿到与服务端通信的Binder，然后通过mPlusBinder.transact调用，服务端的onTransact就会得到调用。
上面就是不通过AIDL调用的过程，可以看到需要写的代码不少，但是大部分是可以抽取出来进行重构。
客户端中做的工作无非就是：向data中写入调用参数，调用transact方法，再从reply方法中读取服务端返回的结果；
服务端做的工作，在onTransact中可以总结：从data中读取调用参数，调用客户端需要的方法，将方法执行结果写入reply中。因此完全可以通过代码设计，比如模版模式和代理模式进行优化。幸运的是Android提供了AIDL的机制，帮我们省略了上面重构的过程。
2.AIDL简易流程
面向接口编程，客户端和服务端需要共同定义好接口，这个接口的名字比较特殊，是.aidl结尾，不是.java结尾。比如：
package com.zhy.calc.aidl;
interface ICalcAIDL
{
int add(int x , int y);
int min(int x , int y );
}
注：这个例子中参数都是基本类型，如果参数中有自定义类型，需要导入这个类型，尽管和该接口在同一个包中也需要
然后进行编译，会在工程generated目录下生成一个ICalcAIDL.java的类
public interface ICalcAIDL extends android.os.IInterface
ICalcAIDL.java的结构如下，也是一个接口，接口中有两个在aidl接口中声明的方法，接着声明了一个内部类Stub，是Binder类, 注意Stub是个抽象类。
public static abstract class Stub extends android.os.Binder implements com.zhy.calc.aidl.ICalcAIDL
Stub中有个内部代理类Proxy
private static class Proxy implements com.zhy.calc.aidl.ICalcAIDL
先不具体看代码，先看下怎么使用。
服务端：
实例化Binder需要我们手动实现预先定义aidl文件中的接口方法。在后面供客户端调用。
public class CalcService extends Service
{
public IBinder onBind(Intent t)
{
Log.e(TAG, "onBind");
return mBinder;
}
private final ICalcAIDL.Stub mBinder = new ICalcAIDL.Stub()
{
@Override
public int add(int x, int y) throws RemoteException
{
return x + y;
}
@Override
public int min(int x, int y) throws RemoteException
{
return x - y;
}
};
}
客户端：
在onServiceConnected中会拿到Binder对象，通过Binder对象就可以调用服务端的方法。
public class MainActivity extends Activity
{
private ICalcAIDL mCalcAidl;
private ServiceConnection mServiceConn = new ServiceConnection()
{
@Override
public void onServiceConnected(ComponentName name, IBinder service)
{
Log.e("client", "onServiceConnected");
mCalcAidl = ICalcAIDL.Stub.asInterface(service);
}
};
public void bindService(View view)
{
Intent intent = new Intent();
intent.setAction("com.zhy.aidl.calc");
bindService(intent, mServiceConn, Context.BIND_AUTO_CREATE);
}
public void addInvoked(View view) throws Exception
{
if (mCalcAidl != null)
{
int addRes = mCalcAidl.add(12, 12);
Toast.makeText(this, addRes + "", Toast.LENGTH_SHORT).show();
} else
{
Toast.makeText(this, "服务器被异常杀死，请重新绑定服务端", Toast.LENGTH_SHORT)
.show();
}
}
}
看过了使用过程，我们看看Android为我们生成的java文件。
ICalcAIDL.java文件分析
onServiceConnected中是调用ICalcAIDL.Stub.asInterface方法得到Binder对象，我们看看生成的代码：
/**
* Cast an IBinder object into an com.zhy.calc.aidl.ICalcAIDL interface,
* generating a proxy if needed.
*/
public static com.zhy.calc.aidl.ICalcAIDL asInterface(android.os.IBinder obj) {
if ((obj == null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin != null) && (iin instanceof com.zhy.calc.aidl.ICalcAIDL))) {
return ((com.zhy.calc.aidl.ICalcAIDL) iin);
}
return new com.zhy.calc.aidl.ICalcAIDL.Stub.Proxy(obj);
}
从上面可以看到，通过obj.queryLocalInterface查询如果客户端和服务端位于同一进程，那么就返回服务端的Stub对象本身，也就是private final ICalcAIDL.Stub mBinder实例。如果不在同一进程，就返回封装后的com.zhy.calc.aidl.ICalcAIDL.Stub.Proxy对象。
客户端如果需要跨进程调用服务端的方法，需要调用proxy中的transact方法。使用的是代理模式，在初始化的时候将服务端的Binder对象mRemote传了进来。然后在客户端调用add方法时，为我们将客户端的方法流程都进行了封装，先做一些准备工作，比如写入调用参数，然后再调用方法mRemote.transact，最后得到结果。那么真正做工作的是mRemote，也就是服务端中的Binder对象。
private static class Proxy implements com.zhy.calc.aidl.ICalcAIDL {
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 x, int y) 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(x);
_data.writeInt(y);
mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
} finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
……
}
我们看到Stub中的代码，在TRANSACTION_add中会调用this.add也就是我们在服务端Service手动实现的方法。有木有恍然大悟的感觉？？？？
@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_min: {
data.enforceInterface(DESCRIPTOR);
int _arg0;
_arg0 = data.readInt();
int _arg1;
_arg1 = data.readInt();
int _result = this.min(_arg0, _arg1);
reply.writeNoException();
reply.writeInt(_result);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
有木有感觉到AIDL框架的神奇？？？再简单总结下，当在客户端通过proxy调用接口.aidl文件中定义的方法时，proxy实现的对应方法中会先替我们做些处理工作，比如创建输入型对象data和输出型对象reply，然后把调用方法需要的参数放入data中，接着通过服务端Binder(在初始化Proxy时传入)调用transact方法发起RPC请求，当前线程会挂起（看到这要习惯反应，不能再主线程执行耗时操作，所以如果远程调用方法很耗时就不能再UI线程发起请求）。然后服务端的onTransact方法会被调用，将方法调用结果存入reply中，RPC返回，proxy线程继续执行。
谢谢！
欢迎关注公众号：JueCode