从Activity的启动理解Binder通信

大学四年毕业以后就开始从事Android 软件开发，说好的我要一个人的毕业旅行也不得不因为很多的原因被搁置，正式进入公司从事了”挨踢”男的工作。不管怎样，毕竟兴趣就这个，开始好好工作吧。

随着对android的深入，很多疑惑也越来越多，比如framework怎么和android系统服务（system service）进行通信的，这就牵扯到android的通信机制了，即Binder（IPC）通信机制。

1.Binder的通信模型



Binder框架定义了四个角色：Server，Client，ServiceManager（以后简称SMgr）以及Binder驱动。其中Server，Client，SMgr运行于用户空间，驱动运行于内核空间。这四个角色的关系和互联网类似：Server是服务器，Client是客户终端，SMgr是域名服务器（DNS），驱动是路由器。

由于android初级开发者从Framework 层理解Binder通信原理会感觉十分困难，我也是慢慢从初级向中级前进，于是我做了一个简化的图这样便于大家的理解。



上图是从一个android Application启动activity来引出Binder的通信机制，下面我们随着源码一步一步的分析。

2.源码分析

首先给一个关于Application是怎么启动Activity的整体时序图，跟着时序图这样有助于源码步骤的理解。



当一个应用程序启动一个界面展示的时候依托的就是Activity,我们跟着时序图进入Activity中查看关键代码

public void startActivityForResult(Intent intent, int requestCode, @Nullable Bundle options) {
if (mParent == null) {
Instrumentation.ActivityResult ar =
mInstrumentation.execStartActivity(
this, mMainThread.getApplicationThread(), mToken, this,
intent, requestCode, options);
if (ar != null) {
mMainThread.sendActivityResult(
mToken, mEmbeddedID, requestCode, ar.getResultCode(),
ar.getResultData());
}
//省略下面代码......
}

当调用startActivity时候，实际上调用的是Instrumentation里面的execStartActivity（）方法，于是我们继续跟踪代码；

public ActivityResult execStartActivity(
Context who, IBinder contextThread, IBinder token, Fragment target,
Intent intent, int requestCode, Bundle options) {
IApplicationThread whoThread = (IApplicationThread) contextThread;
if (mActivityMonitors != null) {
synchronized (mSync) {
final int N = mActivityMonitors.size();
for (int i=0; i<N; i++) {
final ActivityMonitor am = mActivityMonitors.get(i);
if (am.match(who, null, intent)) {
am.mHits++;
if (am.isBlocking()) {
return requestCode >= 0 ? am.getResult() : null;
}
break;
}
}
}
}
try {
intent.migrateExtraStreamToClipData();
intent.prepareToLeaveProcess();
int result = ActivityManagerNative.getDefault()
.startActivity(whoThread, who.getBasePackageName(), intent,
intent.resolveTypeIfNeeded(who.getContentResolver()),
token, target != null ? target.mWho : null,
requestCode, 0, null, options);
checkStartActivityResult(result, intent);
} catch (RemoteException e) {
}
return null;
}

紧接着调用ActivityManagerNative.getDefault().startActivity()；那ActivityManagerNative.getDefault()这个对象到底是什么呢？我们继续跟踪源码可以知道原来是通过ServiceManager得到一个activity的服务，最后通过asInterface（b）返回一个IActivityManager 接口。

private static final Singleton<IActivityManager> gDefault = new Singleton<IActivityManager>() {
protected IActivityManager create() {
IBinder b = ServiceManager.getService("activity");
if (false) {
Log.v("ActivityManager", "default service binder = " + b);
}
IActivityManager am = asInterface(b);
if (false) {
Log.v("ActivityManager", "default service = " + am);
}
return am;
}
};

那我们接下来看看asInterface（）方法里面做了什么

/**
* Cast a Binder object into an activity manager interface, generating
* a proxy if needed.
*/
static public IActivityManager asInterface(IBinder obj) {
if (obj == null) {
return null;
}
IActivityManager in =
(IActivityManager)obj.queryLocalInterface(descriptor);
if (in != null) {
return in;
}

return new ActivityManagerProxy(obj);
}

通过源码我们可以知道，原来返回的是一个ActivityManagerProxy类，这个类的作用就是实现Client 和Service之间通信的代理。那接下来继续跟踪ActivityManagerProxy发现他是IActivityManager 的实现类。

class ActivityManagerProxy implements IActivityManager
{
public ActivityManagerProxy(IBinder remote)
{
mRemote = remote;
}

public IBinder asBinder()
{
return mRemote;
}

public int startActivity(IApplicationThread caller, String callingPackage, Intent intent,
String resolvedType, IBinder resultTo, String resultWho, int requestCode,
int startFlags, ProfilerInfo profilerInfo, Bundle options) throws RemoteException {
Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
data.writeStrongBinder(caller != null ? caller.asBinder() : null);
data.writeString(callingPackage);
intent.writeToParcel(data, 0);
data.writeString(resolvedType);
data.writeStrongBinder(resultTo);
data.writeString(resultWho);
data.writeInt(requestCode);
data.writeInt(startFlags);
if (profilerInfo != null) {
data.writeInt(1);
profilerInfo.writeToParcel(data, Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
} else {
data.writeInt(0);
}
if (options != null) {
data.writeInt(1);
options.writeToParcel(data, 0);
} else {
data.writeInt(0);
}
mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);//重点代码
reply.readException();
int result = reply.readInt();
reply.recycle();
data.recycle();
return result;
}
......
}

这里很关键的一句代码 mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0);这个mRemote就是Binder对象了，就是通信的关键，在这重载transact（）；具体实现如下：

1.向服务端线程以消息机制发送调用信息；

2.挂起当前线程，等待服务端执行完毕发送通知（notify）；

3.接到通知，继续客户端线程，并返回执行结果。

值得注意的是，客户端视乎直接调用服务端的Binder，而事实上是通过Binder驱动进行了中转，就存在两个Binder对象，一个是服务端的Binder对象，另一个是Binder驱动中的Binder对象，不同之处在于Binder驱动中的对象不会产生额外的线程。

同时要进行Binder的远程服务调用时，服务函数的参数要么是一个原子类，要么必须继承Parcel类，否则不会传递。而且传递的数据添加到包裹中和包裹返回的数据必须是有序的，这个顺序是服务端和客户端事先约定好的。

传递数据的插入过程：

Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain();
data.writeInterfaceToken(IActivityManager.descriptor);
data.writeStrongBinder(caller != null ? caller.asBinder() : null);
data.writeString(callingPackage);
intent.writeToParcel(data, 0);
data.writeString(resolvedType);
data.writeStrongBinder(resultTo);
data.writeString(resultWho);
data.writeInt(requestCode);
data.writeInt(startFlags);

从mRemote.transact(START_ACTIVITY_TRANSACTION, data, reply, 0)发送的消息START_ACTIVITY_TRANSACTION跟踪我可以知道服务端对数据的处理是在ActivityManagerNative类中

public boolean onTransact(int code, Parcel data, Parcel reply, int flags)
throws RemoteException {
switch (code) {
case START_ACTIVITY_TRANSACTION:
{
data.enforceInterface(IActivityManager.descriptor);
IBinder b = data.readStrongBinder();
IApplicationThread app = ApplicationThreadNative.asInterface(b);
String callingPackage = data.readString();
Intent intent = Intent.CREATOR.createFromParcel(data);
String resolvedType = data.readString();
IBinder resultTo = data.readStrongBinder();
String resultWho = data.readString();
int requestCode = data.readInt();
int startFlags = data.readInt();
ProfilerInfo profilerInfo = data.readInt() != 0
? ProfilerInfo.CREATOR.createFromParcel(data) : null;
Bundle options = data.readInt() != 0
? Bundle.CREATOR.createFromParcel(data) : null;
int result = startActivity(app, callingPackage, intent, resolvedType,
resultTo, resultWho, requestCode, startFlags, profilerInfo, options);
reply.writeNoException();
reply.writeInt(result);
return true;
}
......
}

Binder的解析数据的方法是enforceInterface（）；而插入数据使用的writeInterfaceToken（）；最后通过消息机制调用startActivity（）方法进入到ActivityManagerService，即system service;

@Override
public int startActivity(IBinder whoThread, String callingPackage,
Intent intent, String resolvedType, Bundle options) {
checkCaller();

int callingUser = UserHandle.getCallingUserId();
TaskRecord tr;
IApplicationThread appThread;
synchronized (ActivityManagerService.this) {
tr = recentTaskForIdLocked(mTaskId);
if (tr == null) {
throw new IllegalArgumentException("Unable to find task ID " + mTaskId);
}
appThread = ApplicationThreadNative.asInterface(whoThread);
if (appThread == null) {
throw new IllegalArgumentException("Bad app thread " + appThread);
}
}
return mStackSupervisor.startActivityMayWait(appThread, -1, callingPackage, intent,
resolvedType, null, null, null, null, 0, 0, null, null,
null, options, callingUser, null, tr);
}

这就是囫囵吞枣的Binder的分析，由于能力有限，后续会更加深入的去学习Binder（IPC）通信机制，个人觉得以Activity的启动流程来掌握Binder通信，这样更容易上手和接受，由于Binder通信在android初级开发者理解起来是最困难的，以此博客，记录自己的学习心得。后续会写对Binder更深入的文章。

*逆风的方向，更适合飞翔。*