Android Binder机制详解:手写IPC通信

想要掌握一样东西,最好的方式就是阅读理解它的源码。想要掌握Android Binder,最好的方式就是写一个AIDL文件,然后查看其生成的代码。本文的思路也是来自于此。

简介

Binder是Android常用的一种进程间通信方式。当然,不使用Binder,你还可以使用Socket甚至文件来进行通信。

通常Android上的进程间通信,指的就是远程Service的调用。

开始

新建测试工程

打开Android Studio新建IPCClient和IPCServer两个app工程。

假设我们要做这样一件事情:

  1. Client向Server发起一个请求:请告诉我1+2等于多少

  2. Server将答案返回给Client

创建远程Service

IPCServer新建ManualCalculatorService作为远程Service。

远程Server需要重写onBind。

public class ManualCalculatorService extends Service
{
@Nullable
@Override
public IBinder onBind(Intent intent)
{
return new Binder()
{
@Override
protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException
{
return super.onTransact(code, data, reply, flags);
}
};
}
}

然后在AndroidManifest中注册这个Service。

<service android:name=".ManualCalculatorService"
android:exported="true"
android:process=":manualremote"/>

android:exported="true"表示这个Service对外是暴露的。

android:process=":manualremote"表示这个Service的运行进程的名称

一个Service要作为远程Service被其他Client调用,上面两个缺一不可。

创建Client

Client调用bindService即可和远程Service建立联系。

Intent intent = new Intent();
intent.setComponent(new ComponentName("cn.zmy.ipcserver", "cn.zmy.ipcserver.ManualCalculatorService"));
bindService(intent, new ServiceConnection()
{
@Override
public void onServiceConnected(ComponentName name, IBinder service)
{ } @Override
public void onServiceDisconnected(ComponentName name)
{ }
}, Context.BIND_AUTO_CREATE);

至此,两个项目大体代码结构已经完成。

Client调用Server

Client可以通过onServiceConnected中的IBinder类型的service参数来调用远程Service。

Parcel data = Parcel.obtain();
Parcel reply = Parcel.obtain(); data.writeInt(1);
data.writeInt(2);
try
{
service.transact(1000, data, reply, 0);
}
catch (RemoteException e)
{
e.printStackTrace();
} int result = reply.readInt();
data.recycle();
reply.recycle();
Toast.makeText(MainActivity.this, "" + result, Toast.LENGTH_SHORT).show();

代码很简单,最关键的是这一句:

service.transact(1000, data, reply, 0);

第一个参数,1000。这是我随便写的个数字,你可以写2000,3000都没得问题。(实际项目中通常使用常量定义,这里主要为了方便演示)

第二个参数,data。表示我想要传递给Server的数据。

第三个参数,reply。Server会把结果写入这个参数。

第四个参数,0。这个参数只有两个可选值:0和IBinder.FLAG_ONEWAY

0表示这是一个双向的IPC调用,也就是Client向Server发起请求后,Server也会答复Client。

IBinder.FLAG_ONEWA表示这是一个单向IPC调用,也就是Client向Server发起请求后,会直接返回,不接受Server的答复。

Server处理Client请求

Client通过transact请求Server之后,Server可以在onTransact接收到Client的请求。

@Nullable
@Override
public IBinder onBind(Intent intent)
{
return new Binder()
{
@Override
protected boolean onTransact(int code, Parcel data, Parcel reply, int flags) throws RemoteException
{
switch (code)
{
case 1000:
{
int num1 = data.readInt();
int num2 = data.readInt();
reply.writeInt(num1 + num2);
return true;
}
}
return super.onTransact(code, data, reply, flags);
}
};
}

data中读出数据,然后将结果写入reply中。整个过程就这样。

运行

先后安装Server和Client程序,Client中就可以看到结果。

Demo

项目代码:

https://github.com/a3349384/IPCDemo

原理分析

所谓原理分析就是追本溯源,接下来我们看一下Client的请求是如何一步步到达Server的

IBinder

回到Client调用Server的代码:

bindService(intent, new ServiceConnection(){
@Override
public void onServiceConnected(ComponentName name, IBinder service)
{
...
} @Override
public void onServiceDisconnected(ComponentName name)
{ }
}, Context.BIND_AUTO_CREATE);

关键在于这个IBinder,Client是通过IBinder.transact()将请求发给Server的。

这里的IBinder实际上是个BinderProxy对象。(我怎么知道的?打断点,打日志啊。。。)

BinderProxy处于{framework}/core/java/android/os/Binder.java中。

final class BinderProxy implements IBinder {
private long mObject; public boolean transact(int code, Parcel data, Parcel reply, int flags) throws RemoteException {
...
return transactNative(code, data, reply, flags);
} public native boolean transactNative(int code, Parcel data, Parcel reply,
int flags) throws RemoteException;
...
}

Client调用BindProxy类的transact方法,实际逻辑还是交给transactNative方法处理的。

接下来找到transactNative的代码。

代码在{framework}/core/jni/android_util_Binder.cpp中

static const JNINativeMethod gBinderProxyMethods[] = {
...
{"transactNative", "(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z", (void*)android_os_BinderProxy_transact}
...
};

可以看的transactNative是动态注册的。找到android_os_BinderProxy_transact方法,看看它的代码。

JNI方法注册分为静态注册和动态注册,感兴趣的朋友可以自行搜索了解。

static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj,
jint code, jobject dataObj, jobject replyObj, jint flags)
{
IBinder* target = (IBinder*)
env->GetLongField(obj, gBinderProxyOffsets.mObject); status_t err = target->transact(code, *data, reply, flags); if (err == NO_ERROR) {
return JNI_TRUE;
} else if (err == UNKNOWN_TRANSACTION) {
return JNI_FALSE;
}
}

可以看到,里面又调用了target的transact方法,将请求发送出去。

target是通过反射获取BinderProxy类的mObject对象得到的。

final class BinderProxy implements IBinder {
private long mObject;
}

long是怎么被强转为IBinder的?

实际上这里的long mObject保存的是IBinder的指针。指针的大小和long的大小都是一样的,都是4个字节。

而名为target的这个IBinder实际上就是Server中onBind返回的这个Binder:

public class ManualCalculatorService extends Service
{
@Nullable
@Override
public IBinder onBind(Intent intent)
{
return new Binder()
{
...
};
}
}

到这里,我们就差不多明白了。BinderProxy之所以叫BinderProxy,它代理的就是Server中onBind返回的Binder。

而Client经过一层层的调用,最终调用了Server中返回的Binder对象的transact方法。

我们看一下这个方法:

public final boolean transact(int code, Parcel data, Parcel reply,
int flags) throws RemoteException {
...
boolean r = onTransact(code, data, reply, flags);
...
return r;
}

这个方法实际上调用了onTransact方法进行具体的逻辑处理。这也是为什么我们可以在onTransact中处理Client请求的原因。

结尾

关于target是怎么来的?

target是通过反射获取BinderProxy类的mObject对象得到的。

mObject保存了server中IBinder的指针。

那么这个指针又是哪里来的?

这里不得不提到另外一个类:ServiceManager

该类在{framework}/core/java/android/os/ServiceManager.java中

感兴趣的朋友可以阅读它的代码。

这里简单说一下:ServiceManager通过map保存了Service和IBinder的关系。也就是通过Service的名称就可以获取到这个Service的IBinder。

参考链接:https://www.zhoumingyao.cn/Android笔记/Android-Binder机制详解:手写IPC通信/

上一篇:Linux 内存机制详解宝典


下一篇:《深入理解mybatis原理》 MyBatis缓存机制的设计与实现