同一个 APK 里的两个进程,能否像调用普通 Java 方法一样完成一次加法?可以,但方法调用背后需要传递参数、定位对象、安排线程,再把结果或失败送回。Binder 与 AIDL 正是理解这条路径的入口。
2.1 准备实验设备并认识源码目录
第一章解决了取得源码、编译和运行的问题。现在先确认设备可用,并找到 Binder 相关目录,不需要重新完整编译 Android。
本文基于 android17-release 的用户空间源码与文末列出的 Kernel 阅读基线;源码摘录、生成代码和教学片段分别标明。
本文使用普通应用的 Java AIDL 与 Kernel Binder IPC。AIDL 也有 C++、NDK、Rust 等后端;后端决定生成代码的语言与库依赖,不表示所有 Java 调用都会经过某个 HAL。AIDL 后端说明
准备 Host 终端与实验设备
沿用第一章的 Linux x86_64 工作站和 SDK Emulator。源码放在其他位置时修改第一行;serial 必须从实际设备列表中选择。
chapter2_top="$HOME/aosp"
chapter2_run=$(mktemp -d "$HOME/aosp-chapter2.XXXXXX")
chapter2_adb="$chapter2_top/out/host/linux-x86/bin/adb"
cd "$chapter2_top"
"$chapter2_adb" devices -l
read -r -p '输入本次设备 serial:' chapter2_serial
"$chapter2_adb" -s "$chapter2_serial" shell getprop sys.boot_completed
"$chapter2_adb" -s "$chapter2_serial" shell getprop ro.build.fingerprint
"$chapter2_adb" -s "$chapter2_serial" shell uname -a
预期设备可连接,boot_completed 为 1。记录 fingerprint、Kernel 版本与 serial,后面用同一个设备安装示例。未启动时先完成第一章运行步骤,不把空设备列表当作 AIDL 问题。
认识本章的源码分布
| 位置 | 本章会读什么 | 它解决的问题 |
|---|---|---|
| system/tools/aidl | Java 代码生成器 | 把接口声明生成 Proxy、Stub 和编解码代码 |
| frameworks/base/core/java/android/os | Binder、BinderProxy、Parcel、ServiceManager | Java 对象与 IPC 接口 |
| frameworks/base/core/jni/android_util_Binder.cpp | Binder JNI 与 JavaBBinderExt | Java 与 Native 对象之间的桥梁 |
| frameworks/native/libs/binder | BpBinder、IPCThreadState、ProcessState、Parcel | 用户空间协议、线程状态与 Driver 交互 |
| frameworks/native/cmds/servicemanager | Native ServiceManager | 按名称登记和查询系统 Binder 服务 |
| 匹配的 Kernel 源码 drivers/android | C Binder 或 Rust Binder | 事务、引用、缓冲区、排队与唤醒 |
在 Host 中先定位几个入口:
rg --files frameworks/base/core/java/android/os -g 'Binder.java' -g 'BinderProxy.java'
rg --files frameworks/native/libs/binder -g 'IPCThreadState.cpp' -g 'ProcessState.cpp'
rg -n 'BINDER_WRITE_READ' frameworks/native/libs/binder/IPCThreadState.cpp
这只是位置导航,还不要求立刻理解 ioctl。先从进程与接口概念进入,写出一个能观察行为的小程序,再回到这些文件。
2.2 理解进程 Binder 与 AIDL 的关系
为什么普通 Java 对象引用不能跨进程使用
一个 Java 引用只在所属进程和运行时中有意义。客户端进程持有的对象地址,不能直接当作另一个进程中的对象地址调用;两个进程有各自的地址空间和对象生命周期。
IPC 是进程间通信。对一次 add(7, 8),跨进程需要解决至少四个问题:找到服务端对象、传递参数、在服务端执行、把结果或失败送回来。Binder 提供 Android 上常用的一套 IPC 机制;AIDL 则描述双方约定的接口并生成大量样板代码。官方 AIDL 概念
AIDL 不是网络协议,也不会把任意 Java 对象自动变成远程对象。参数类型、序列化方式、对象引用与生命周期仍需要遵守接口规则。
用一次加法认识六个角色
| 名称 | 含义 | 在示例中的位置 |
|---|---|---|
| 客户端 | 发起请求的一方 | MainActivity 所在进程的工作线程 |
| 服务端 | 执行业务的一方 | DemoService 所在的 remote 进程 |
| ICalculator | 双方同意的方法集合 | AIDL 声明的接口 |
| Proxy | 客户端的接口实现,把方法调用转成事务 | 生成的 ICalculator.Stub.Proxy |
| Stub | 服务端入口,按事务编号读取参数并调用实现 | 服务端继承 ICalculator.Stub |
| Binder Driver | 在 Kernel 中管理对象、传输与调度的实现 | /dev/binder 等接口背后的实际 Driver |
Parcel 是参数与结果的承载格式和工具,transaction code 区分接口中的不同方法。Proxy 将参数写进 Parcel;Stub 按双方约定的顺序读出,调用业务,再写入返回内容。
这里的 Android Service 是应用组件,负责服务生命周期和绑定;Binder 是它交给客户端的通信对象。两者经常一起出现,但不是同一个概念,一个 Service 也不天然等于一个系统 ServiceManager 注册项。
先看整体架构 各层分别负责什么
上面的 Proxy、Stub 和 Driver 分别位于哪里?先把一次远程 add(7, 8) 放回 Android 的分层架构:客户端在自己的进程里打包请求,内核负责把事务交给目标进程,服务端再在自己的进程里还原方法调用。
下面按本章的 Java AIDL + Kernel Binder 场景画出整体架构。它展示组件位置和主要交接关系,省略逐函数细节;JavaBBinderExt 是本文源码版本中的服务端 JNI 桥接类。蓝色实线箭头表示业务请求,棕色虚线箭头表示同步回复;ServiceManager 的灰色无箭头连线仅表示它也通过 Driver 通信。
查看架构图 SVG · 下载 PNG 用于发布
图中的 BC_TRANSACTION / BC_REPLY 是进程提交给 Driver 的请求 / 回复命令,BR_TRANSACTION / BR_REPLY 是 Driver 向进程交付事务 / 回复时使用的命令。用户空间通过 ioctl 的 BINDER_WRITE_READ 接口交换这些协议命令;具体封装与处理在 2.5~2.7 展开。
先顺着实线读请求,再沿虚线看回复。 客户端先调用本地 Proxy,Proxy 借助 Parcel 把参数编码成约定格式;BinderProxy 经 JNI 找到 Native 代理,libbinder 再通过 ioctl 把事务提交给 Driver。Driver 定位目标 Binder,把请求数据交付给服务端,并安排接收线程处理。服务端由 libbinder 经 JNI 回到 Java,Stub 解包后调用真正的 add 实现。
结果返回仍然需要一次 Binder 回复。 服务端把结果写入 reply Parcel,经 Native 层提交 BC_REPLY;Driver 将它交给等待的客户端线程,客户端代理读出 15,原来的 Java 调用才返回。图中只画出回复跨越内核的部分,服务端 Java 到 Native、客户端 Native 到 Java 的返回过程在 2.7 展开。
按层理解职责 不必一开始记住所有类
| 层次 | 主要职责 | 用加法示例理解 |
|---|---|---|
| Java 业务与 AIDL 生成代码 | 定义并实现业务接口,按统一约定编码、解码和分派方法 | 客户端 Proxy 写入 7 和 8;服务端 Stub 读出后调用 add |
| Java Binder 与 JNI | 把 Java 的 Binder、Parcel 与 Native 对象关联起来,连接 Java 和 C++ 调用入口 | BinderProxy 把请求送入 Native;JavaBBinderExt 把收到的调用带回服务端 Java |
| Native libbinder | 管理代理、本地 Binder、事务协议和接收循环;ProcessState 保存进程级状态,IPCThreadState 保存线程级通信状态 | BpBinder 持有访问远端对象的 handle,IPCThreadState 负责发送、等待或处理收到的命令 |
| Kernel Binder Driver | 管理跨进程对象引用、事务缓冲区和工作队列,完成目标定位、数据交付与线程唤醒 | 根据客户端的 handle 找到目标 node 和所属进程,把请求交给可处理它的线程 |
Parcel 横跨这些层:Java 有供生成代码使用的 Parcel API,Native 有对应的数据容器;Driver 按事务携带的普通数据和对象元数据处理传输。Driver 处理的是事务编号、字节数据和 Binder 引用等信息,计算 7 + 8 的 Java 业务逻辑仍在服务端执行。
ServiceManager 与 bindService 在架构中的位置
先取得 Binder 引用,再通过它调用业务,是两件不同的事。 图中的 ServiceManager 是一种服务发现入口:系统服务可按名称登记自己的 Binder,使用方再按名称查询。登记和查询本身也通过 Binder 通信;取得目标引用后,普通业务事务直接面向目标 Binder,由 Driver 交付。
本章 Demo 使用另一条入口:客户端的 bindService 请求由 system_server 中的 ActivityManagerService / ActiveServices 协调;服务端执行 onBind 后交出业务 Binder,再经系统管理链路交给客户端。因此,system_server 和 ServiceManager 都不是每次 add 调用都要经过的业务中转站。图聚焦取得引用后的调用,组件绑定的完整过程见 2.8。
用架构图判断线程与对象的位置
Java、JNI、Native 是代码层次,客户端、服务端则是进程角色。客户端向下经过 JNI 和 libbinder,通常仍由原调用线程执行;服务端接收循环收到事务后,才在服务端接收线程中进入 Java Stub。同步调用的客户端线程会等待回复,两边没有共享同一个 Java 对象或同一个线程。
同一个进程也可以同时拥有远端代理和本地 Binder。注册业务 callback 后,服务端通过代理调用客户端,客户端就成为这次反向事务的接收方;回调实体有自己的 Binder node,详见 2.9。由此可见,客户端和服务端是某次调用中的角色,不是进程永久不变的身份。
AIDL 编译器在构建时生成 Proxy 和 Stub,没有参与运行时的消息转发;图中的 Java、JNI、libbinder 也不表示调用必须经过 HAL。本图对应的公开说明见 官方 Binder 概览;本章选定版本的类名与实现分别在 2.4、2.5、2.6、2.7 对照源码展开。
对象 引用和 handle 怎样对应
服务端的本地 Binder 对象由 Driver 中的节点等结构表示;另一个进程拿到的是对该对象的引用,其用户空间代理使用本进程中的 handle。handle 是进程内有意义的描述值,不能把一个进程打印出的数字直接当作另一个进程的同一对象。
Binder 对象参数和文件描述符也不能靠复制整数完成跨进程传递,Driver 需要转换对应引用或为接收方安装有效描述符。因此普通数据与对象元数据需要分别处理。
先在整条使用过程里定位自己
一个应用先获取业务引用,再发起调用;需要主动通知时,客户端再把独立的 callback 引用交给服务端。下面画业务关系,跨进程箭头都经过 Binder Driver,详细协议在 2.4~2.7 展开。
这是一条学习顺序示意,省略启动失败与各异步阶段的并发。业务 callback 是后面的扩展;基础加法 Demo 没有注册它。
| 进程与线程 | 本章负责的动作 | 线程交接怎样发生 |
|---|---|---|
| 客户端主线程 | 发起绑定、接收连接回调、更新界面 | 普通绑定的 ServiceDispatcher 通过 Handler 分发连接通知 |
| 客户端工作线程 | add、sleep 等同步调用,callback 注册请求 | 应用显式 worker.execute;同步回复返回原调用线程 |
| 客户端 Binder 接收线程 | 接收业务 callback、连接通知的 Binder 事务 | Driver 交付后由 libbinder/JNI 分发;界面更新另用 Handler |
| system_server 的 Binder 处理线程 | 管理组件绑定、转交接口引用 | 系统接口事务的接收者 |
| 服务端主线程 | 创建 Service、onBind、组件销毁 | ActivityThread 的消息分发 |
| 服务端 Binder 接收线程 | 执行远程业务 Stub 方法 | 应用运行时准备的 Binder 接收循环 |
| callback 扩展的服务端工作线程 | 排队计算、通过代理调用客户端 callback | 示例自己的 Executor;不是 Driver 自动创建的 Java 业务线程 |
后面的图继续使用这些角色名称。Java 到 JNI 不代表切线程;进入 ioctl 不代表切到服务端;线程交接要找到队列、等待与唤醒的位置。
阅读底层代码需要的最少术语
Parcel 同时提供写入、读取及相应数据容器,双方遵守同一参数顺序。JNI 连接 Java 与 Native 方法;C++ 的 sp 保持强引用,wp 是可尝试提升的弱引用。ioctl 向设备提交控制请求,mmap 建立内存映射。首次阅读只需理解用途,具体对象地址与字段关联在 2.10 集中解释。
先运行基础加法,再沿它的结果阅读源码。初次学习可在读完 2.9 后先做 2.12 的对照实验,2.10~2.11 用于深入与复习。
2.3 写一个双进程 AIDL 示例并运行
这个示例使用一个 APK、两个进程。Activity 在默认进程,Service 通过 android:process=":remote" 放入另一个进程。两者通常拥有相同应用 UID,但 PID 不同;因此不需要两个 APK 也能观察真实跨进程调用。
创建独立示例模块
在 AOSP 根目录执行:
chapter2_demo="$chapter2_top/packages/apps/Chapter2BinderDemo"
mkdir -p "$chapter2_demo/src/com/example/binderdemo"
确认该目录用于本示例,按下列相对路径保存五个文件;已有同名项目时先换目录和模块名,避免覆盖其他内容。示例不修改 Framework,也不需要系统签名权限。
Android.bp
android_app {
name: "Chapter2BinderDemo",
manifest: "AndroidManifest.xml",
srcs: ["src/**/*.java", "src/**/*.aidl"],
aidl: { local_include_dirs: ["src"] },
sdk_version: "current",
min_sdk_version: "28",
certificate: "testkey",
optimize: { enabled: false },
}
这是普通 android_app 模块,srcs 同时收集 Java 与 AIDL。sdk_version 使用公共 SDK,testkey 用于示例签名,关闭优化便于对照代码;后续通过 adb install 安装,不需要把它加入 PRODUCT_PACKAGES 或重打包整个系统。
AndroidManifest.xml
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.binderdemo">
<uses-sdk android:minSdkVersion="28" />
<application android:label="Binder Demo"
android:debuggable="true"
android:theme="@android:style/Theme.Material.Light.NoActionBar">
<activity android:name=".MainActivity" android:exported="true">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<service android:name=".DemoService"
android:process=":remote" android:exported="false" />
</application>
</manifest>
process 的冒号前缀表示应用私有进程名。Service 没有对其他应用导出,但同一应用的 Activity 可以显式绑定。debuggable 用于后面的 run-as 实验,不用于生产应用配置。
src/com/example/binderdemo/ICalculator.aidl
package com.example.binderdemo;
interface ICalculator {
int add(int a, int b);
int getServerPid();
void sleepSync(int millis);
oneway void sleepOneway(int millis);
}
前三个方法是同步调用;最后一个用 oneway 声明单向调用。它返回 void,也不提供本次业务的返回 Parcel。oneway 的线程行为要在跨进程条件下观察,同进程时不自动变成异步。
src/com/example/binderdemo/DemoService.java
package com.example.binderdemo;
import android.app.Service;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.os.Process;
import android.os.SystemClock;
import android.os.Trace;
import android.util.Log;
public final class DemoService extends Service {
private static final String TAG = "BinderDemoServer";
private void record(String event) {
Log.i(TAG, event + " pid=" + Process.myPid()
+ " tid=" + Process.myTid()
+ " thread=" + Thread.currentThread().getName()
+ " callingUid=" + Binder.getCallingUid());
}
private void pause(String kind, int millis) {
Trace.beginSection("BinderDemo." + kind);
try {
record(kind + " begin");
SystemClock.sleep(Math.max(0, Math.min(millis, 2000)));
record(kind + " end");
} finally {
Trace.endSection();
}
}
private final ICalculator.Stub binder = new ICalculator.Stub() {
@Override public int add(int a, int b) {
Trace.beginSection("BinderDemo.add");
try {
record("add(" + a + "," + b + ")");
return a + b;
} finally {
Trace.endSection();
}
}
@Override public int getServerPid() { return Process.myPid(); }
@Override public void sleepSync(int millis) { pause("sync", millis); }
@Override public void sleepOneway(int millis) { pause("oneway", millis); }
};
@Override public IBinder onBind(Intent intent) {
record("onBind");
return binder;
}
}
onBind 返回实际的 Stub 实例。add 等接口方法记录当前进程与线程;pause 用有上限的休眠模拟耗时业务,不代表实际服务应该主动阻塞。onBind 是组件生命周期回调,远程接口方法则由 Binder 分发,两者的线程不能混为一谈。
src/com/example/binderdemo/MainActivity.java
package com.example.binderdemo;
import android.app.Activity;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.ServiceConnection;
import android.os.Bundle;
import android.os.IBinder;
import android.os.Process;
import android.os.RemoteException;
import android.os.SystemClock;
import android.os.Trace;
import android.util.Log;
import android.widget.TextView;
import java.util.NoSuchElementException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
public final class MainActivity extends Activity {
private static final String TAG = "BinderDemoClient";
private final ExecutorService worker = Executors.newSingleThreadExecutor();
private IBinder remoteBinder;
private boolean needsUnbind;
private final IBinder.DeathRecipient death = () -> record("binderDied");
private void record(String event) {
Log.i(TAG, event + " pid=" + Process.myPid()
+ " tid=" + Process.myTid()
+ " thread=" + Thread.currentThread().getName());
}
private void runCalls(ICalculator calculator) {
Trace.beginSection("BinderDemo.runCalls");
try {
record("serverPid=" + calculator.getServerPid());
record("add result=" + calculator.add(7, 8));
long begin = SystemClock.elapsedRealtime();
calculator.sleepSync(1200);
record("sync returned elapsedMs=" + (SystemClock.elapsedRealtime() - begin));
begin = SystemClock.elapsedRealtime();
calculator.sleepOneway(1200);
record("oneway returned elapsedMs=" + (SystemClock.elapsedRealtime() - begin));
} catch (RemoteException e) {
Log.e(TAG, "RPC failed", e);
} finally {
Trace.endSection();
}
}
private final ServiceConnection connection = new ServiceConnection() {
@Override public void onServiceConnected(ComponentName name, IBinder binder) {
record("connected binderClass=" + binder.getClass().getName());
remoteBinder = binder;
ICalculator calculator = ICalculator.Stub.asInterface(binder);
try {
binder.linkToDeath(death, 0);
} catch (RemoteException e) {
Log.e(TAG, "server died before linkToDeath", e);
return;
}
worker.execute(() -> runCalls(calculator));
}
@Override public void onServiceDisconnected(ComponentName name) {
record("onServiceDisconnected");
remoteBinder = null;
}
};
@Override public void onCreate(Bundle state) {
super.onCreate(state);
TextView text = new TextView(this);
text.setText("Binder Demo:通过 logcat 查看双进程与线程日志。");
setContentView(text);
final boolean accepted;
try {
accepted = bindService(new Intent(this, DemoService.class),
connection, Context.BIND_AUTO_CREATE);
} catch (SecurityException e) {
unbindService(connection);
Log.e(TAG, "bindService denied", e);
return;
}
needsUnbind = true;
record("bindService accepted=" + accepted);
if (!accepted) {
unbindService(connection);
needsUnbind = false;
}
}
@Override public void onDestroy() {
if (remoteBinder != null) {
try { remoteBinder.unlinkToDeath(death, 0); }
catch (NoSuchElementException ignored) { }
}
if (needsUnbind) unbindService(connection);
worker.shutdown();
super.onDestroy();
}
}
本例区分请求是否被接受与连接是否需要清理。 固定版本的 Context 契约要求 bindService 返回 true、false 或抛出 SecurityException 后都配对 unbindService;ContextImpl 在向系统请求前已登记本地连接。这里返回 false 或抛出 SecurityException 时立即解绑;成功接受请求后在 onDestroy 解绑。此处承接已审公众号第四稿的必要修复,配套基础版、callback 与生命周期三套完整示例及其 ZIP 均同步修正这项清理契约;历史日志与 Trace 保留原版本证据,本次清理修订尚未重新构建实测。绑定与解绑契约
bindService 的布尔结果只说明绑定请求是否被接受,拿到 Binder 要等 onServiceConnected。该回调中取得接口并注册死亡通知,然后把同步调用放到 Executor 的工作线程;主线程不会因此等待那段模拟耗时业务。
先用半页看懂绑定和调用的关系
本例有两个阶段:先用 bindService 建立组件连接,从 onServiceConnected 得到远端 IBinder;再用 asInterface 包装业务接口并发起 add。连接建立只交付引用,后续 add 直接指向服务端业务 Binder。 系统管理接口负责协调绑定,Driver 负责实际跨进程传输。
onBind 在服务端主线程运行,onServiceConnected 默认回到客户端主线程;示例随后用 worker.execute 主动安排业务调用。服务端 add 则由 Binder 接收线程执行。现在先带着这几个位置运行,具体绑定链路在 2.8,全部线程位置见 整体模型。示例中的 Trace.beginSection/endSection 只给实验增加可定位区间,分析方法在 2.12。
使用已有 Host 工具构建 APK
本章基础示例与 callback 扩展都没有自定义资源。已经完成第一章构建、具有 Host AIDL、aapt2、D8 和 signapk 时,可以用配套脚本独立生成 APK;本章设备实测使用这条路径。脚本源码为 构建示例APK.py,依次执行 AIDL → javac → D8 → aapt2 → 测试密钥签名,并把每条命令写入输出目录。
chapter2_notes="$chapter2_top/Android源码学习笔记/章节学习/第二章-Binder与AIDL"
python3 "$chapter2_notes/示例/构建示例APK.py" \
--aosp-top "$chapter2_top" --module "$chapter2_demo" \
--name Chapter2BinderDemo --out "$chapter2_run/basic-apk"
chapter2_apk="$chapter2_run/basic-apk/Chapter2BinderDemo.apk"
输出目录必须为空,避免把历史 dex 混进新包;失败时脚本在对应步骤停止,并说明缺少的 Host 工具。此路径使用 min SDK 28、target SDK 36 和公共 current android.jar,适用于本章 Android 17 实验设备;不能据此代替 Soong 产品构建检查。
可选 使用 Soong 模块构建
如果要练习 AOSP 模块构建,可以选择这一分支;已有上面 APK 时直接继续安装。仍在 AOSP 根目录与同一 Host Bash 终端中执行:
source build/envsetup.sh
lunch sdk_phone64_x86_64 aosp_current userdebug
set -o pipefail
m Chapter2BinderDemo -j2 2>&1 | tee "$chapter2_run/build.log"
chapter2_build_status=("${PIPESTATUS[@]}")
printf 'build=%s tee=%s\n' "${chapter2_build_status[0]}" \
"${chapter2_build_status[1]}" | tee "$chapter2_run/build-exit.txt"
两项均为 0 后,查找实际产品输出,并设置 APK 路径;若没有该文件,按构建输出核实路径,不继续安装旧文件:
rg --files --no-ignore "$ANDROID_PRODUCT_OUT" -g 'Chapter2BinderDemo.apk'
chapter2_apk="$ANDROID_PRODUCT_OUT/system/app/Chapter2BinderDemo/Chapter2BinderDemo.apk"
test -f "$chapter2_apk"
安装并启动本轮 APK
无论采用哪种构建路径,先确认 chapter2_apk 指向本轮生成文件,再在所选设备运行:
"$chapter2_adb" -s "$chapter2_serial" install -r "$chapter2_apk"
"$chapter2_adb" -s "$chapter2_serial" shell am force-stop com.example.binderdemo
"$chapter2_adb" -s "$chapter2_serial" shell am start -W \
-n com.example.binderdemo/.MainActivity
安装应返回 Success,启动应成功。这一步只更新实验应用,不重建系统镜像;使用同一测试密钥方便后续覆盖安装。
观察第一次调用
Activity 连接后自动执行一次测试,不需要点击界面。用有限时间窗口查看并保存日志:
timeout 8 "$chapter2_adb" -s "$chapter2_serial" logcat -v threadtime \
-s BinderDemoClient:I BinderDemoServer:I '*:S' \
| tee "$chapter2_run/first-run.log"
"$chapter2_adb" -s "$chapter2_serial" shell pidof com.example.binderdemo
"$chapter2_adb" -s "$chapter2_serial" shell pidof com.example.binderdemo:remote
timeout 到期返回 124 表示观察窗口结束,不表示应用失败。logcat 会包含缓冲区旧日志,重复实验时按本轮 PID 和时间区分。预期观察如下,PID、TID 与耗时不要照抄:
connected binderClass=android.os.BinderProxy
serverPid=<与客户端不同的 PID>
add result=15
sync returned elapsedMs=<包含约 1200 ms 业务等待>
oneway returned elapsedMs=<通常明显短于同步耗时>
服务端还应出现 sync、oneway 的 begin/end。oneway 客户端返回不代表服务端已经 end,具体日志先后受调度影响。耗时只是辅助观察,不能用一个固定毫秒阈值证明实现正确。
现在有了真实对象:客户端使用哪个接口,服务端执行什么方法,双方在哪个进程与线程。下面再拆开生成代码和源码中的每一层。
2.4 从生成代码理解 Proxy 与 Stub
先暂时放下类名,带着上一节的 calculator.add(7, 8) 为什么能得到 15 来看整个过程。本节认识 Java 两端;2.5 看发送,2.6 看 Driver 交付,2.7 再回到服务端和返回值。
先看一次调用 再读代码
下图展示一次成功的跨进程同步调用。纵向表示每个参与者内部的阅读顺序,横向箭头表示交接;中间省略了协议确认、错误和资源释放,不是每个内部函数的逐条 Trace。
先抓住三个动作:Proxy 写参数,Stub 读参数并调用实现,Proxy 读返回值。 Driver 帮双方找到对象、传递数据与安排执行,不认识 Java 方法名 add。
后面的正文按客户端发送、Driver 交付、服务端执行、结果返回展开。先读通这一条请求与回复,再深入对象创建、引用传递和回收。
生成自己的接口代码
示例模块构建会自动调用 AIDL 编译器。也可以在上一节已准备好的 Host 终端执行下列命令,单独查看生成结果。生成文件单独保存,不复制回手写 src 与同名 AIDL 一起参与编译,避免重复定义。
"$chapter2_top/out/host/linux-x86/bin/aidl" --lang=java --min_sdk_version=28 \
-I "$chapter2_demo/src" -o "$chapter2_run/generated" \
"$chapter2_demo/src/com/example/binderdemo/ICalculator.aidl"
rg -n 'asInterface|TRANSACTION_add|transact|FLAG_ONEWAY|onTransact' \
"$chapter2_run/generated/com/example/binderdemo/ICalculator.java"
执行后,可以在记录目录的 generated/com/example/binderdemo/ICalculator.java 中找到生成结果。我们在 AIDL 中只声明了四个方法,生成器却补出了接口实现、参数读写和事务分发代码。下面先把这个文件完整展开,看看这些代码怎样组织在一起,再沿一次 add 调用逐段阅读。
ICalculator.java 完整生成源码
首次阅读可先扫下面的结构表,再直接跳到 asInterface 与 add 的分段讲解;复习时可以停在完整文件里对照。
这个文件延续了前面的通信模型:Proxy 负责把方法调用写成请求,Stub 负责从请求中读出参数并调用业务实现,接口标识与事务编号让双方按同一套规则配合。 它们都由 AIDL 生成,不需要我们逐个手写。
第一次阅读完整文件时,可以先根据下面的分工找到对应位置。Default 是一个返回默认值或不执行动作的生成实现;上一节 DemoService 中覆写 add 的对象继承自 Stub,实际加法会进入我们自己的实现。
| 文件中的部分 | 与前面示例的关系 |
|---|---|
| 接口方法、DESCRIPTOR、TRANSACTION 常量 | 描述双方约定的方法、接口标识与事务编号 |
| Stub 构造与 asInterface | 关联本地接口,把拿到的 IBinder 转成 ICalculator |
| Proxy 的四个方法 | 接住客户端的方法调用,写参数、提交事务并处理响应 |
| Stub.onTransact | 接住交付的事务,读参数、调用服务端实现并写响应 |
| Default | 提供默认实现,便于与本例实际使用的 Stub 实现区分 |
建议先找到 asInterface,再把 Proxy.add 与 Stub.onTransact 的 add 分支对照起来看。 sleepSync 与 sleepOneway 可以留到后面的对照实验中比较。下面保留本章示例的完整生成结果,也可打开单独的 Java 文件查阅;不同生成器版本或 SDK 选项可能带来写法差异,以自己的生成结果为准。生成规则的源码入口是 generate_java_binder.cpp。
/*
* This file is auto-generated. DO NOT MODIFY.
* Using: aidl --lang=java --min_sdk_version=28 -I src -o ../AIDL生成源码 src/com/example/binderdemo/ICalculator.aidl
*
* DO NOT CHECK THIS FILE INTO A CODE TREE (e.g. git, etc..).
* ALWAYS GENERATE THIS FILE FROM UPDATED AIDL COMPILER
* AS A BUILD INTERMEDIATE ONLY. THIS IS NOT SOURCE CODE.
*/
package com.example.binderdemo;
public interface ICalculator extends android.os.IInterface
{
/** Default implementation for ICalculator. */
public static class Default implements com.example.binderdemo.ICalculator
{
@Override public int add(int a, int b) throws android.os.RemoteException
{
return 0;
}
@Override public int getServerPid() throws android.os.RemoteException
{
return 0;
}
@Override public void sleepSync(int millis) throws android.os.RemoteException
{
}
@Override public void sleepOneway(int millis) throws android.os.RemoteException
{
}
@Override
public android.os.IBinder asBinder() {
return null;
}
}
/** Local-side IPC implementation stub class. */
public static abstract class Stub extends android.os.Binder implements com.example.binderdemo.ICalculator
{
/** Construct the stub and attach it to the interface. */
@SuppressWarnings("this-escape")
public Stub()
{
this.attachInterface(this, DESCRIPTOR);
}
/**
* Cast an IBinder object into an com.example.binderdemo.ICalculator interface,
* generating a proxy if needed.
*/
public static com.example.binderdemo.ICalculator asInterface(android.os.IBinder obj)
{
if ((obj==null)) {
return null;
}
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.example.binderdemo.ICalculator))) {
return ((com.example.binderdemo.ICalculator)iin);
}
return new com.example.binderdemo.ICalculator.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
{
if (code >= android.os.IBinder.FIRST_CALL_TRANSACTION && code <= android.os.IBinder.LAST_CALL_TRANSACTION) {
data.enforceInterface(DESCRIPTOR);
}
switch (code)
{
case TRANSACTION_add:
{
int _arg0;
_arg0 = data.readInt();
int _arg1;
_arg1 = data.readInt();
int _result = this.add(_arg0, _arg1);
reply.writeNoException();
reply.writeInt(_result);
break;
}
case TRANSACTION_getServerPid:
{
int _result = this.getServerPid();
reply.writeNoException();
reply.writeInt(_result);
break;
}
case TRANSACTION_sleepSync:
{
int _arg0;
_arg0 = data.readInt();
this.sleepSync(_arg0);
reply.writeNoException();
break;
}
case TRANSACTION_sleepOneway:
{
int _arg0;
_arg0 = data.readInt();
this.sleepOneway(_arg0);
break;
}
default:
{
return super.onTransact(code, data, reply, flags);
}
}
return true;
}
private static final class Proxy implements com.example.binderdemo.ICalculator
{
private android.os.IBinder mRemote;
Proxy(android.os.IBinder remote)
{
mRemote = remote;
}
@Override public android.os.IBinder asBinder()
{
return mRemote;
}
public final 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);
boolean _status = mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override public int getServerPid() 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);
boolean _status = mRemote.transact(Stub.TRANSACTION_getServerPid, _data, _reply, 0);
_reply.readException();
_result = _reply.readInt();
}
finally {
_reply.recycle();
_data.recycle();
}
return _result;
}
@Override public void sleepSync(int millis) 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(millis);
boolean _status = mRemote.transact(Stub.TRANSACTION_sleepSync, _data, _reply, 0);
_reply.readException();
}
finally {
_reply.recycle();
_data.recycle();
}
}
@Override public void sleepOneway(int millis) throws android.os.RemoteException
{
android.os.Parcel _data = android.os.Parcel.obtain();
try {
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(millis);
boolean _status = mRemote.transact(Stub.TRANSACTION_sleepOneway, _data, null, android.os.IBinder.FLAG_ONEWAY);
}
finally {
_data.recycle();
}
}
}
static final int TRANSACTION_add = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
static final int TRANSACTION_getServerPid = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
static final int TRANSACTION_sleepSync = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
static final int TRANSACTION_sleepOneway = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
}
/** @hide */
public static final java.lang.String DESCRIPTOR = "com.example.binderdemo.ICalculator";
public int add(int a, int b) throws android.os.RemoteException;
public int getServerPid() throws android.os.RemoteException;
public void sleepSync(int millis) throws android.os.RemoteException;
public void sleepOneway(int millis) throws android.os.RemoteException;
}
完整文件中,请求的写入与读取分散在不同方法里。接下来把它们沿调用顺序接起来:客户端先通过 asInterface 取得 ICalculator,再调用 Proxy.add;服务端通过 Stub.onTransact 执行 add,最后把结果交回 Proxy。
先从示例中已经执行过的 asInterface 看起。下面沿一次调用选择连续源码片段;省略的分支与校验可通过相邻的固定提交链接核对。
入口选择 asInterface 为什么可能绕过 IPC
上一节的客户端在 onServiceConnected 回调中拿到 IBinder,随后执行 ICalculator.Stub.asInterface(binder),得到可调用的 ICalculator。这个转换究竟返回本地实现,还是创建远端代理,决定了后续方法会怎样执行。
生成文件 ICalculator.java,符号 Stub.asInterface,非空分支:
android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
if (((iin!=null)&&(iin instanceof com.example.binderdemo.ICalculator))) {
return ((com.example.binderdemo.ICalculator)iin);
}
return new com.example.binderdemo.ICalculator.Stub.Proxy(obj);
关键判断:obj.queryLocalInterface(DESCRIPTOR) 能否取回本地接口。 同进程的 Binder 可以返回 attachInterface 保存的实现;远端 BinderProxy 的这个查询返回 null,于是创建 AIDL Proxy。本地 Binder 实现 · BinderProxy 实现
本例显式使用 :remote 进程,因此沿图中 Proxy 分支阅读。这里有两层代理:ICalculator.Stub.Proxy 认识 add 的参数协议;它持有的 mRemote,即本例的 BinderProxy,负责通用 Binder 传输。 两者职责不同。
Proxy.add 把参数按顺序写入 Parcel
执行位置:客户端工作线程。文件为生成的 ICalculator.java,符号 Stub.Proxy.add。方法先取得 _data 与 _reply 两个 Parcel,再写入请求:
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(a);
_data.writeInt(b);
重点是写入顺序:接口标识 → a → b。 传入 7、8 时,接收方也必须按相同顺序读取。interface token 用于核对接口协议,不能代替调用者权限检查。
这里把请求理解成 [接口标识, 7, 8] 即可。这是业务字段的阅读示意,不是 Parcel 全部字节布局;Parcel 还有内部协议信息。
Proxy.add 提交事务 然后等待结果
仍在同一个客户端工作线程、同一个 Proxy.add 方法里:
boolean _status = mRemote.transact(Stub.TRANSACTION_add, _data, _reply, 0);
关键语句:mRemote.transact(...)。 从这里进入下一节的 BinderProxy。四个参数分别回答四个问题:
| 参数 | 在本例中表示什么 |
|---|---|
Stub.TRANSACTION_add | 调用哪个接口方法;由生成器分配,结合接口理解 |
_data | 刚才写入的请求参数 |
_reply | 接收返回数据的 Parcel |
0 | 此处未设置单向标志,本次按同步事务处理 |
这行调用返回后,Proxy 才读 _reply,读法放到 2.7 的“Proxy 读出结果并回收 Parcel”,和服务端写入结果对照。目前只走到提交入口,加法还没有在服务端执行。
2.5 从 Java 进入 JNI 与 libbinder
这一节只回答:Proxy 中的 mRemote.transact 怎样变成一次系统调用?进入 Kernel 前的用户空间代码始终由客户端工作线程执行;ioctl 也由这条线程进入内核。JNI 和 C++ 的语言边界不会自动切换执行线程。
BinderProxy.transact 从 Java 进入 JNI
文件:BinderProxy.java,符号 transact。先只看它把工作交出的这一行:
final boolean result = transactNative(code, data, reply, flags);
关键语句:transactNative(...)。 code、data、reply、flags 沿原方向继续传递。完整方法还做事务监听、阻塞提示等处理;本节先抓住 Java 与 Native 的边界。下一站是 android_os_BinderProxy_transact。
JNI 分别取得 Native Parcel 与 Native Binder
这里要同时找齐两样东西:本次事务传什么,以及向哪个 Binder 发。 它们来自不同的 Java 对象。parcelForJavaObject 不会调用 getBPNativeData;JNI 入口分别调用两个辅助函数,再把两路结果合到一次 Native transact 中。
先对上 JNI 参数 obj 与 dataObj 不是同一个对象
文件:android_util_Binder.cpp,符号 android_os_BinderProxy_transact,先看函数头:
static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj,
jint code, jobject dataObj, jobject replyObj, jint flags) // throws RemoteException
obj 是发起 native 方法调用的 BinderProxy;dataObj 与 replyObj 才是两个 Java Parcel。 env 与 obj 是 JNI 为这个实例方法提供的参数;code、dataObj、replyObj、flags 对应 Java 显式传入的四项。
BinderProxy 的 transactNative 怎样找到这个 C++ 函数?同文件的 gBinderProxyMethods 注册表中有以下一项,注册函数将该表绑定到 android/os/BinderProxy:
{"transactNative", "(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z", (void*)android_os_BinderProxy_transact},
注册表将 Java 的 transactNative 绑定到 JNI 的 android_os_BinderProxy_transact。 签名中的 I 是 int,Landroid/os/Parcel; 是 Parcel 引用,Z 是 boolean 返回值。
| JNI 输入 | 对应 Java 对象 | 从中取出的 Native 内容 | 本轮作用 |
|---|---|---|---|
dataObj | Proxy 写过参数的 _data | mNativePtr 指向的 Native Parcel | 请求数据 |
replyObj | Proxy 创建的 _reply | mNativePtr 指向的另一份 Native Parcel | 承接响应 |
obj | AIDL Proxy 的 mRemote,本例是 BinderProxy | mNativeData 指向包装结构,其中 mObject 保存 Native IBinder | 目标代理 |
下面是对象关系图。箭头上的文字说明字段读取或使用关系,不表示一个辅助函数顺序调用另一个;图中对象都位于客户端进程。
parcelForJavaObject 从 Java 字段取回 Native Parcel
先回到 JNI 入口。它分别处理两份 Parcel,下面仍是 android_os_BinderProxy_transact 内的片段:
Parcel* data = parcelForJavaObject(env, dataObj);
if (data == NULL) {
return JNI_FALSE;
}
Parcel* reply = parcelForJavaObject(env, replyObj);
dataObj 传入辅助函数以后,成为那个函数自己的形参 obj。 不要把两个函数中碰巧同名的 obj 当成同一个对象。下面才是辅助函数本体,文件切到 android_os_Parcel.cpp,符号 parcelForJavaObject:
Parcel* parcelForJavaObject(JNIEnv* env, jobject obj)
{
if (obj) {
Parcel* p = (Parcel*)env->GetLongField(obj, gParcelOffsets.mNativePtr);
if (p != NULL) {
return p;
}
jniThrowException(env, "java/lang/IllegalStateException", "Parcel has been finalized!");
}
return NULL;
}
关键语句:env->GetLongField(obj, gParcelOffsets.mNativePtr)。 它读取传入 Java Parcel 的 long 字段 mNativePtr,再把保存的地址恢复成 C++ 的 Parcel*。gParcelOffsets.mNativePtr 是初始化时缓存的 JNI 字段标识 jfieldID,不是某个 Parcel 实例的指针;该字段名与 long 类型在同文件 register_android_os_Parcel 中绑定。
对应的注册语句是:
gParcelOffsets.mNativePtr = GetFieldIDOrDie(env, clazz, "mNativePtr", "J");
这里的 J 表示 Java long 类型;字段标识告诉 JNI 去哪个字段读取,字段里保存的数值才是这份 Parcel 的 Native 地址。
如果 Java 对象为空,函数返回 null;如果对象存在但 Native 指针已为空,则抛 IllegalStateException。回到 JNI 入口后仍会检查转换结果。同步 add 有响应 Parcel;远程 oneway 的 replyObj 可以为 null,不能把两种调用的条件混在一起。
当前使用的是先前已经建立的对象关联
Parcel.obtain 已建立或复用 Java Parcel 与 Native Parcel 的关联;客户端收到业务引用时,libbinder 已建立或复用 BpBinder,JNI 已为 Java BinderProxy 准备 BinderProxyNativeData。其中 mObject 是 sp<IBinder>,本例持有 BpBinder。
本次发送读取已有对象,不重新创建整套代理。 如果想追问这些字段由谁分配、何时赋值,完整创建路径保存在 2.10 对象关联。现在继续把当前的 BinderProxy 还原成 Native 目标,保持 add 的调用栈连续。
getBPNativeData 取回包装结构 再从中得到 target
回到正在执行的 android_os_BinderProxy_transact。这里的 obj 是 BinderProxy 本身,与 dataObj 对应的 Parcel 分别查找:
IBinder* target = getBPNativeData(env, obj)->mObject.get();
把这一行拆开看,先进入同文件的 getBPNativeData:
BinderProxyNativeData* getBPNativeData(JNIEnv* env, jobject obj) {
return (BinderProxyNativeData *) env->GetLongField(obj, gBinderProxyOffsets.mNativeData);
}
它读取 BinderProxy 的 long 字段 mNativeData,恢复 BinderProxyNativeData 指针。 gBinderProxyOffsets.mNativeData 同样是字段标识,绑定位置在 int_register_android_os_BinderProxy;它与 Parcel 的 gParcelOffsets.mNativePtr 指向不同类的不同字段。
为避免把名字相似的两层内容混在一起,对照如下:
| 名称 | 实际是什么 | 如何取得或创建 |
|---|---|---|
gBinderProxyOffsets.mNativeData | JNI 的 jfieldID,标识 Java 字段 | 注册时由 GetFieldIDOrDie 取得并缓存 |
Java BinderProxy.mNativeData 的值 | BinderProxyNativeData 地址,以 long 保存 | 包装时在客户端执行 new BinderProxyNativeData,再交给 Java 构造函数保存 |
mObject.get() 的值 | 指向本例客户端 BpBinder 的 IBinder 指针 | BpBinder 工厂创建或代理缓存复用,随后由 mObject 持有 |
对应的注册语句来自 android_util_Binder.cpp:
gBinderProxyOffsets.mNativeData = GetFieldIDOrDie(env, clazz, "mNativeData", "J");
返回包装结构后,原调用表达式继续取 mObject.get():mObject 是刚才保存的 sp<IBinder>,get 取出其中的裸指针供当前调用使用,不会再创建一个 BpBinder,也不会将强引用所有权转交出去。这个指针就是变量 target 的值;完整入口紧接着检查 target 是否为空。
两路结果在 target.transact 汇合
此时 JNI 入口已经准备好 target、data、reply,才执行:
status_t err = target->transact(code, *data, reply, flags);
连起来读:用 BinderProxy 中保存的目标代理,发送 Parcel 中已经写好的请求,并用另一份 Parcel 承接响应。 *data 是请求 Parcel 引用,reply 是响应 Parcel 指针,code 与 flags 继续说明方法与事务方式。该调用仍在客户端线程内,下一站才是 BpBinder 的事务处理;跨入 Kernel 还要经过后面的 ioctl。
现在再看最初的两个辅助函数:一条沿 Parcel.mNativePtr 找数据,一条沿 BinderProxy.mNativeData 找目标;它们共同服务于这次 transact,没有相互转换关系。 JNI 根据 Native 返回的传输状态处理返回值或异常,业务结果则由同步响应 Parcel 承接。
BpBinder 把事务交给当前线程的 IPCThreadState
文件:BpBinder.cpp,符号 BpBinder::transact,下面只摘本例使用的 Kernel IPC 分支:
status = IPCThreadState::self()->transact(binderHandle(), code, data, reply, flags);
binderHandle() 标识目标引用,self() 取得当前线程的通信状态。 handle 在本进程的 Binder 引用表中有意义,不能把一个进程里的数值直接当成另一个进程里的同一对象。
完整函数另有 Binder RPC 分支;本例不沿该分支阅读。ProcessState 管理进程级 Driver 连接和映射,IPCThreadState 管理当前线程的收发缓冲区、调用身份与等待状态,职责粒度不同。
接着进入 IPCThreadState.cpp 的 IPCThreadState::transact:
err = writeTransactionData(BC_TRANSACTION, flags, handle, code, data, nullptr);
关键命令:BC_TRANSACTION,意思是“用户线程向 Driver 提交一笔请求”。 此处调用 writeTransactionData 组织命令,尚不能把它当成已经完成了 ioctl。
IPCThreadState 怎样打包参数 描述结构和命令流
同一文件的 writeTransactionData,先把目标与方法写入事务描述:
tr.target.handle = handle;
tr.code = code;
tr.flags = binderFlags;
tr.target.handle 回答“找谁”,tr.code 回答“做什么”。 随后在数据有效分支中,记录 Parcel 的数据位置和对象偏移信息:
tr.data_size = data.ipcDataSize();
tr.data.ptr.buffer = data.ipcData();
tr.offsets_size = data.ipcObjectsCount()*sizeof(binder_size_t);
tr.data.ptr.offsets = data.ipcObjects();
tr.data.ptr.buffer 是发送方参数区的位置。 offsets 描述需特别处理的 Binder 对象等内容的位置,本例 int 加法不代表所有事务都只是简单复制字节。
最后仍在这个函数内,把命令和描述结构写入发送缓冲区 mOut:
mOut.writeInt32(cmd);
mOut.write(&tr, sizeof(tr));
用图把三种“容器”区分开。箭头在这里表示指向或描述关系,不表示函数调用:
命令流不等于全部业务载荷。 read_buffer 也不是接收方最终保存全部参数的区域:回送的事务描述还会指向接收方 Binder 映射区中的载荷,2.6 会画出这条路径。UAPI 结构定义
transact 进入等待循环 由循环完成收发
执行位置仍是客户端工作线程。前面的 writeTransactionData 只把命令加入 mOut;同一个 IPCThreadState::transact 在同步、有 reply 的分支中继续执行:
if (reply) {
err = waitForResponse(reply);
waitForResponse 是 talkWithDriver 的外层循环。 正确调用关系是 transact → waitForResponse → talkWithDriver → ioctl。不能把它读成“先独立发送完 ioctl,再进入另一套等待机制”。同文件 waitForResponse 的循环开头为:
while (1) {
if ((err=talkWithDriver()) < NO_ERROR) break;
err = mIn.errorCheck();
if (err < NO_ERROR) break;
if (mIn.dataAvail() == 0) continue;
cmd = (uint32_t)mIn.readInt32();
talkWithDriver 必要时把 mOut 交给 Driver,并将返回命令放进 mIn。循环读取一条命令后分发:BR_REPLY 关联业务响应并结束本次同步等待;BR_DEAD_REPLY 等使它以失败结束。BR_TRANSACTION_COMPLETE 分支则是:
case BR_TRANSACTION_COMPLETE:
if (!reply && !acquireResult) goto finish;
break;
同步 add 有 reply,因此仅收到这个协议通知不会结束等待。default 分支还会调用 executeCommand,必要时分发嵌套事务;“等待同步响应”不等于线程永远不能执行其他 Binder 工作。接下来进入这个循环内部的系统调用。
talkWithDriver 通过 ioctl 跨入 Kernel
文件仍为 IPCThreadState.cpp,符号 talkWithDriver,Kernel IPC 编译分支:
先对照收发说明的字段;下列片段来自 talkWithDriver,是否读取由当前缓冲区状态决定:
bwr.write_size = outAvail;
bwr.write_buffer = (uintptr_t)mOut.data();
// This is what we'll read.
if (doReceive && needRead) {
bwr.read_size = mIn.dataCapacity();
bwr.read_buffer = (uintptr_t)mIn.data();
write_buffer 指向 mOut 命令流,read_buffer 指向 mIn 命令接收区。两者与 Parcel 载荷区的关系见前面的数据关系图。真正发起系统调用的片段是:
if (ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0)
err = NO_ERROR;
else
err = -errno;
真正跨入 Kernel 的语句是 ioctl(..., BINDER_WRITE_READ, &bwr)。 bwr 是上图的收发说明;mDriverFD 来自 ProcessState 打开的 Binder 设备,普通应用场景通常为 /dev/binder,具体路径按产品与 binderfs 布局核实。ProcessState.cpp
这里容易混淆两个名字:BINDER_WRITE_READ 是 ioctl 请求号;BC_TRANSACTION 是该请求承载的命令流中的命令。 可以把前者理解为提交一组收发工作,后者是其中“发送事务”的一项工作。
ioctl 返回后仍回到同一个 waitForResponse 循环,按 mIn 中的命令继续处理。下面放大这次系统调用:Driver 怎样找到对象、安排接收者,接收者又怎样用自己的读取路径取得请求。
2.6 进入 Binder Driver 并找到接收线程
先确定 Kernel 阅读基线
本文 Goldfish 预编译文件的内嵌版本线索为 6.12.58-android16-6-gccafb60de224-ab14828483,短提交解析到 kernel/common 的 ccafb60de224d35a8bc14de33e1cd47caaaa786b。以下引用固定在该公开提交;AOSP 用户空间与 Kernel 的版本数字不要求相同。
在已准备好的 Host 终端执行;后四项向目标设备查询:
file "$chapter2_top/prebuilts/qemu-kernel/x86_64/6.12/kernel-6.12"
"$chapter2_adb" -s "$chapter2_serial" shell uname -a
"$chapter2_adb" -s "$chapter2_serial" shell cat /proc/cmdline
"$chapter2_adb" -s "$chapter2_serial" shell cat /proc/bootconfig
"$chapter2_adb" -s "$chapter2_serial" shell \
'for f in /sys/module/*binder*/parameters/impl; do if [ -r "$f" ]; then echo "$f"; cat "$f"; fi; done'
部分文件可能不存在或不可读,保留结果再核实。内嵌提交是来源线索,不单独证明运行镜像与源码完全匹配。 2026-10-16 的记录核对了 uname 与镜像来源,当时尚未判定 C/Rust 运行选择。2026-10-19 的独立设备核对进一步保存完整配置,并读取到 impl=c、C Binder 内建、Rust 模块未加载,确认该轮当前镜像使用 C Binder;其他启动配置仍需分别判断。
先用图认识 Driver 的四项工作
下面沿 C 语言实现理解协议。命令解析、目标查找和排队通常在提交请求的线程进入内核后执行;事务交付是接收线程读工作时的路径,二者可以并发推进。Kernel 不会亲自执行 Java 加法。
图上虚线表示工作交接,不是客户端内核调用栈直接调用了服务端 Java。以下四个节点均来自 drivers/android/binder.c。
解释请求 取出命令流中的事务
符号 binder_ioctl_write_read。它先从用户空间取得 binder_write_read,再按写入长度处理命令:
if (bwr.write_size > 0) {
ret = binder_thread_write(proc, thread,
bwr.write_buffer,
bwr.write_size,
&bwr.write_consumed);
关键交接:binder_thread_write(...) 解释用户提交的命令流。 同一 ioctl 也可以请求读工作,对应 binder_thread_read;没有可用工作时是否等待取决于调用条件。
下一段来自 binder_thread_write 的普通事务分支,单独阅读:
case BC_TRANSACTION:
case BC_REPLY: {
struct binder_transaction_data tr;
if (copy_from_user(&tr, ptr, sizeof(tr)))
return -EFAULT;
ptr += sizeof(tr);
binder_transaction(proc, thread, &tr,
cmd == BC_REPLY, 0);
cmd == BC_REPLY 区分请求与回复。 两者进入共同的事务处理函数,但目标查找和事务关系处理不同;本轮是 BC_TRANSACTION,所以沿新请求方向往下读。复制到 tr 的是事务描述,不是已经完成全部业务载荷传输。
用 handle 找目标 不是按 add 名称搜索
符号 binder_transaction,非零目标 handle 的成功查找分支:
ref = binder_get_ref_olocked(proc, tr->target.handle,
true);
if (ref) {
target_node = binder_get_node_refs_for_txn(
ref->node, &target_proc,
&return_error);
核心对应关系:发送进程的 handle → binder_ref → binder_node → 目标进程。 binder_node 表示 Driver 跟踪的 Binder 实体,binder_ref 表示其他进程对它的引用;它们与客户端 Java 的 Proxy 不是同一种对象。
binder_transaction 还检查权限、安全策略、对象与数据,并准备目标缓冲区;以上六行只说明目标查找。Driver 使用 code 传递方法编号,不解释 add 的 Java 含义。 读方法编号并分发到 add 是后面 Stub 的工作。
数据路径 参数怎样进入接收方映射区
先把控制流暂停,用图看载荷去向。下图表示成功传输的主要数据关系,不包含所有分配、对象翻译和失败处理。
文件:binder_alloc.c,符号 binder_alloc_copy_user_to_buffer,以下片段在它的循环内:
page = binder_alloc_get_page(alloc, buffer,
buffer_offset, &pgoff);
size = min_t(size_t, bytes, PAGE_SIZE - pgoff);
kptr = kmap_local_page(page) + pgoff;
ret = copy_from_user(kptr, from, size);
kunmap_local(kptr);
重点只看 copy_from_user(kptr, from, size):从发送方用户数据复制到目标缓冲区页面。 kmap_local_page 临时映射页面供内核访问,kunmap_local 解除这次临时映射;接收方的用户空间映射由先前的 Binder mmap 路径建立,两种映射不要混为一谈;打开设备与建立映射的代码见 2.10。
因此这条载荷路径避免了“内核中转缓冲区再整体复制一份到接收方普通缓冲区”的步骤。它仍然有复制,不能把整个 Binder 流程称为零拷贝。 Java 序列化、Binder 对象处理、Reply 和业务自己的复制还要分别计算;mmap 也不意味着两个应用可以任意访问彼此地址空间。
将事务排队 唤醒接收线程
回到控制流,符号 binder_proc_transaction。先看条件允许时如何选择线程:
if (!thread && !pending_async)
thread = binder_select_thread_ilocked(proc);
binder_select_thread_ilocked 查找可用接收线程,不是每来一次调用就创建新线程。 例如选到线程后,会把工作加入该线程队列:
if (thread) {
binder_transaction_priority(thread, t, node);
binder_enqueue_thread_work_ilocked(thread, &t->work);
这段只摘了“已有目标线程”分支的开头;没有合适线程时,还可能进入进程工作队列,待处理的单向事务还涉及对象异步队列。随后在相应条件下唤醒等待者:
if (!pending_async)
binder_wakeup_thread_ilocked(proc, thread, !oneway /* sync */);
排队与唤醒是两个动作:工作先变成可接收状态,接收线程才有机会继续运行。 服务端何时真正执行还受线程可用性和调度影响,不能把 ioctl 提交成功当成加法已经执行。
普通 Java 应用的 Binder 线程池由运行时启动路径准备,本版本可在 app_main.cpp 的 onZygoteInit 找到 ProcessState::startThreadPool;不需要每个 Android Service 自己调用 Native 线程池启动方法。
接收线程取得 BR_TRANSACTION
执行位置变为服务端线程进入 Kernel 读取工作。符号 binder_thread_read,已有目标对象的请求交付分支:
trd->target.ptr = target_node->ptr;
trd->cookie = target_node->cookie;
binder_transaction_priority(thread, t, target_node);
cmd = BR_TRANSACTION;
BR_TRANSACTION 表示“Driver 向接收线程交付请求”。 目标 ptr 与 cookie 来自该接收进程注册的对象信息,不是把客户端的对象指针原样当成服务端指针使用。部分配置使用携带安全上下文的事务变体。
至此,服务端 libbinder 能从自己的读取结果获得事务描述和参数位置。下一步回到用户空间,由 libbinder 开始分发。
Rust 实现作为另一条路径对照
这个 Kernel 提交也包含 Rust Binder。它与 C 语言实现遵循相同 UAPI,是两条可选实现路径,不是先经过 C 语言实现再经过 Rust 实现。读通上面的协议后,再按下面入口对照即可。
| 刚才的问题 | C 实现 | Rust 实现与固定源码 |
|---|---|---|
| 谁接收 ioctl | binder_ioctl_write_read | process.rs:ioctl_write_read 把 BINDER_WRITE_READ 交给当前线程的 write_read |
| 谁拆解 BC_TRANSACTION / BC_REPLY | binder_thread_write | thread.rs:write 及请求、回复处理方法 |
| 谁组织目标与事务 | binder_transaction / binder_proc_transaction | process.rs、thread.rs、transaction.rs |
| 谁向用户线程交付结果 | binder_thread_read | thread.rs 的 read 与 transaction.rs 的交付实现 |
| 设备与映射入口在哪 | binder_ioctl / binder_mmap | rust_binder_main.rs 的文件与映射操作 |
本文主场景没有独立 HAL,也没有专属物理外设。Binder Driver 的事务、缓冲区、队列与等待机制就是本例应读通的底层边界。
2.7 服务端执行与结果返回
现在 Driver 已把请求交给服务端。先看下图:上半段是接收和执行,下半段是业务结果回到调用者;下面分别追踪两端各自的调用栈。
接收分发、业务执行和写入响应发生在服务端接收线程,读取结果回到发起请求的客户端工作线程。 进入 Java 不会自动切到主线程。响应传输跨过服务端、Kernel 和客户端,下面拆开看。
Binder 线程池怎样创建 扩容并接收事务
一次调用进入服务端后,是谁创建接收线程,忙时谁增加线程,空闲时又在哪里等待?先区分三个角色:ProcessState 管当前进程的 Binder 连接与线程池,IPCThreadState 管当前线程的收发状态,Driver 管哪些工作可以交给哪个线程。 Binder 线程是用户空间线程,也由 Linux 调度;Driver 不会直接替应用执行 Java 方法。
先启动一个接收线程 再按需增加
普通 Java 应用的启动路径经过 app_main.cpp 的 AppRuntime::onZygoteInit:
sp<ProcessState> proc = ProcessState::self();
ALOGV("App process: starting thread pool.\n");
proc->startThreadPool();
应用启动时准备线程池,不需要每个 Service 各建一套。 同一进程中的多个 Java Stub 通常共用这套 Kernel Binder 接收线程;客户端进程也需要它接收业务 callback、连接通知和死亡通知。不同 Binder 设备、Binder RPC 等模式另有连接与线程配置,本节沿本文的普通 Java Kernel Binder 路径阅读。
ProcessState.cpp 的 startThreadPool 在锁内检查 mThreadPoolStarted,首次才执行下面两行:
mThreadPoolStarted = true;
spawnPooledThread(true);
同文件 spawnPooledThread 的创建片段如下,外层条件是线程池已经启动:
sp<Thread> t = sp<PoolThread>::make(isMain);
t->run(name.c_str());
mKernelStartedThreads++;
真正创建线程的是 libbinder 的 Thread/PoolThread。 PoolThread::threadLoop 再进入接收循环:
IPCThreadState::self()->joinThreadPool(mIsMain);
return false;
这里 isMain=true 表示池中的初始常驻角色,不是 Activity 主线程。Activity 主线程继续执行自己的 Looper;这条新线程运行 Binder 接收循环。joinThreadPool 也可以由 Native 程序的一条已有线程直接调用,此时是让该线程加入接收循环,不会因为方法名带 ThreadPool 就再生成一个线程。
下面是创建与扩容的机制时序图,省略普通事务交付,只保留管理协议:
BR_SPAWN_LOOPER 是扩容请求 不是内核创建线程
IPCThreadState.cpp 的 joinThreadPool 开头按角色写入不同命令:
mProcess->mCurrentThreads++;
mOut.writeInt32(isMain ? BC_ENTER_LOOPER : BC_REGISTER_LOOPER);
BC_ENTER_LOOPER 表示主动进入,BC_REGISTER_LOOPER 对应 Driver 请求后补充的线程。 两者都让该线程成为可接收工作的 looper,但 Driver 的计数口径不同。匹配 Kernel 的 binder_thread_write 在有效 BC_REGISTER_LOOPER 分支中才执行:
proc->requested_threads--;
proc->requested_threads_started++;
Driver 什么时候请求增加?固定提交的 binder.c 中,binder_thread_read 的普通分支检查:没有尚待响应的增线程请求、没有正在等待进程工作的空闲线程、按请求启动的线程数未到上限,而且当前是已进入/注册的 looper。对应连续条件摘录如下:
if (force_spawn || (proc->requested_threads == 0 &&
list_empty(&thread->proc->waiting_threads) &&
proc->requested_threads_started < proc->max_threads &&
(thread->looper & (BINDER_LOOPER_STATE_REGISTERED |
BINDER_LOOPER_STATE_ENTERED)))/* the user-space code fails to */
/*spawn a new thread if we leave this out */) {
proc->requested_threads++;
同一分支随后写出 BR_SPAWN_LOOPER;force_spawn 还允许源码中的 vendor hook 影响决策,分析具体产品时需要核对。扩容判断发生在读取路径,不能概括为“每来一笔请求就新建线程”。 用户空间 executeCommand 收到该协议命令后才调用:
case BR_SPAWN_LOOPER:
mProcess->spawnPooledThread(false);
break;
创建、Driver 请求、新线程登记构成一个闭环。没有运行用户空间接收循环,即使内核发出了请求,也不会凭空多出一个 Java 可用的 Binder 接收线程。
默认参数 15 应按哪种口径理解
本版本 ProcessState.cpp 定义 DEFAULT_MAX_BINDER_THREADS 15,打开 Driver 时通过 BINDER_SET_MAX_THREADS 提交该配置。这不是启动时预创建 15 条线程,也不是每个 Service 独占 15 条。 ProcessState::getThreadPoolMaxTotalThreadCount 的容量计算中有以下连续片段:
// calling startThreadPool starts a thread
size_t threads = 1;
// the kernel is configured to start up to mMaxThreads more threads
threads += max;
因此在“默认配置、只调用一次 startThreadPool、没有其他线程手工 join”的模型中,容量口径是初始 1 条 + 按 Driver 请求最多增加 15 条,并非应用主线程加 15 条。实际进程可修改配置,也可能额外手工加入线程;不要将这个推导写成所有 Android 进程固定有 16 条。SystemServer 等系统进程另有自己的设置入口。
修改池大小的 Native API 是 ProcessState::setThreadPoolMaxThreadCount;它通过 ioctl 更新 Driver 配置,本版本还禁止启动后把 max 调小。普通应用不应靠隐藏 API 猜测修改,更不应把“增线程”当作绕过业务锁或死锁的解决方案。
空闲等待 取事务与重入分别发生在哪里
joinThreadPool 反复执行 getAndExecuteCommand;该方法通过 talkWithDriver 读取命令,再交给 executeCommand。没有工作时,接收线程阻塞在自己的 ioctl 读取路径,不是不断轮询 Java 队列。 固定 Kernel 的 binder_wait_for_work 在锁内登记等待状态,必要时将线程放入 proc->waiting_threads,解锁后 schedule;被唤醒后重新检查工作。
binder_thread_read 在可读取工作时,优先看当前线程的 todo;若符合 wait_for_proc_work 条件,再取进程级 todo。其连续选择片段为:
if (!binder_worklist_empty_ilocked(&thread->todo))
list = &thread->todo;
else if (!binder_worklist_empty_ilocked(&proc->todo) &&
wait_for_proc_work)
list = &proc->todo;
线程级工作与进程级工作不是随便互换的两条队列。 同步嵌套调用涉及 transaction_stack 与指定线程;普通同步等待者的 waitForResponse 也可以通过 executeCommand 分发收到的嵌套事务。因此“Java callback 一律换到一个全新的池线程”不成立。远程 oneway 对同一节点有异步串行规则,但执行它们的 TID 可以变化;本章的非嵌套单向业务 callback 是其中一个具体场景。官方线程模型
Driver 选定接收者后还会按事务、节点与策略处理线程优先级,相关入口为 binder_proc_transaction 中的 binder_transaction_priority;接收者回到等待进程工作时可恢复进程默认优先级。选接收线程与 Linux 决定何时让它运行是两件事。 即使池有空位,CPU 竞争、线程锁、服务端自己投递的 Executor 都可能继续造成延迟。
空闲是否会自动回收线程
IPCThreadState::joinThreadPool 确实保留了下面的退出分支:
if(result == TIMED_OUT && !isMain) {
break;
}
但存在分支不等于当前 Driver 会定时返回超时。本章固定 C Binder 的阻塞等待使用 schedule,并没有给空闲池线程设置 Java Executor 式的 keepAliveTime;executeCommand 中的 BR_FINISHED 才会被转换为 TIMED_OUT。正常场景下已创建的池线程通常保持到进程结束,不能期待闲一会儿就缩回初始数量。读取返回 -ECONNREFUSED、-EBADF 等退出条件时,循环还会走 BC_EXIT_LOOPER;宿主进程终止则由系统回收线程资源。
用已有 Trace 和自己的设备观察管理协议
2026-10-20 的在途死亡实验保存了服务重建阶段的 Trace。新服务端 PID 5085 中,现可提取以下真实协议序列;时间均为该轮设备启动后秒,不是今天重新运行的结果:
| 时间 | 线程 | 事件 | 对应机制 |
|---|---|---|---|
| 828.306959 | TID 5096,binder:5085_1 | BC_ENTER_LOOPER | 初始池线程进入 |
| 828.306959 | TID 5096 | BR_SPAWN_LOOPER | Driver 请求增加线程 |
| 828.307902 | TID 5097,binder:5085_2 | BC_REGISTER_LOOPER | 新线程登记 |
| 828.314915 | TID 5096 | BR_SPAWN_LOOPER | 后续再次请求 |
| 828.315087 | TID 5098,binder:5085_3 | BC_REGISTER_LOOPER | 另一条新线程登记 |
这组事件支持“先有接收者,再按请求补充线程”的实际过程;它不证明池已增长到上限,也不说明每次扩容都是某一个业务方法引发的。提取行及关联方式见管理协议复核记录。
自己观察时,先运行 2.3 的 remote 示例,在 Host 沿用本章变量执行以下只读查询。Driver 快照要求专用 userdebug 实验实例具有 root 和相应调试接口:
chapter2_server_pid=$("$chapter2_adb" -s "$chapter2_serial" shell \
pidof com.example.binderdemo:remote | tr -d '\r')
: "${chapter2_server_pid:?请先启动双进程示例并确认服务已连接}"
"$chapter2_adb" -s "$chapter2_serial" shell ps -T -p "$chapter2_server_pid"
"$chapter2_adb" -s "$chapter2_serial" shell cat \
"/dev/binderfs/binder_logs/proc/$chapter2_server_pid"
比较空闲与调用期间的 TID、线程名、transaction_stack、线程/进程 todo 及 waiting 状态;线程数以实际快照为准。若要触发多个同步调用,必须让客户端有多个真正并发的工作线程;单个 Executor 连点仍会在客户端先串行。完整容量与并发实验在2.15 容量与并发实验继续,不通过终止池内单个线程来模拟正常缩容。
回到 libbinder,getAndExecuteCommand 从本线程的读取结果中取协议编号,其开头的连续摘录为:
result = talkWithDriver();
if (result >= NO_ERROR) {
size_t IN = mIn.dataAvail();
if (IN < sizeof(int32_t)) return result;
cmd = mIn.readInt32();
同函数完成相应线程计数处理后执行:
result = executeCommand(cmd);
这套分发既处理 BR_TRANSACTION,也处理 BR_SPAWN_LOOPER、BR_DEAD_BINDER 等管理命令。 接下来只取这套接收循环的一次迭代:线程已经读到 BR_TRANSACTION,libbinder 怎样找到本地实体并进入 Java Stub?
libbinder 找到服务端本地 Binder
文件:IPCThreadState.cpp,符号 executeCommand,收到 BR_TRANSACTION 后的目标对象分支:
BBinder* binder = reinterpret_cast<BBinder*>(tr.cookie);
error = doTransactBinder(binder, tr.code, buffer, &reply, tr.flags);
cookie 定位服务端本地 Binder,buffer 携带收到的请求,reply 承接响应。 doTransactBinder 从这里进入本地分发。上文未摘出的强引用检查保障对象生命周期,不能把两行代码单独搬到业务中使用。
同一文件的 doTransactBinder 再调用本地 Binder 的 transact:
status_t error = binder->transact(code, data, reply, flags);
接着 Binder.cpp 的 BBinder::transact 在普通业务分支调用:
err = onTransact(code, data, reply, flags);
这次是服务端本地对象上的虚函数分发。 本例对象最终进入 Java 桥接实现,下一步不是再次发送跨进程请求。
JNI 回到服务端 Java Binder
文件:android_util_Binder.cpp,符号 JavaBBinderExt::onTransact:
jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact,
code, reinterpret_cast<jlong>(&data), reinterpret_cast<jlong>(reply), flags);
CallBooleanMethod 调用服务端 Java Binder 的 execTransact 入口。 本版本桥接类名是 JavaBBinderExt;阅读旧文章时不要只按旧类名搜索。
Java 的 execTransact 进入 Binder.java 的 execTransactInternal,其中执行:
res = onTransact(code, data, reply, flags);
onTransact 会动态分发到本例生成的 Stub。 Native 到 Java 是语言边界,执行者仍是当前服务端线程。
execTransact 接收的 dataObj、replyObj 是当前 Native Parcel 的地址;Java 入口先建立包装:
Parcel data = Parcel.obtain(dataObj);
Parcel reply = Parcel.obtain(replyObj);
服务端包装的 Parcel 指向当前接收数据,不是把客户端 Java Parcel 对象复制过来。 它们的 mOwnsNativeParcelObject 为 false,业务分发后回收 Java 包装;Native 接收 Parcel 的作用域与回收另见 2.11。这条关联把 Driver 的参数位置接到了下一段 Java Stub 的 readInt。
生成 Stub 按协议解包 再调用业务实现
文件为生成的 ICalculator.java,符号 Stub.onTransact。对普通接口事务,先校验接口描述符:
data.enforceInterface(DESCRIPTOR);
enforceInterface 核对协议,不等于授予业务权限。 随后 switch 按 code 进入 TRANSACTION_add;只看该分支的解包与调用部分:
int _arg0;
_arg0 = data.readInt();
int _arg1;
_arg1 = data.readInt();
int _result = this.add(_arg0, _arg1);
真正执行加法的交接是 this.add(_arg0, _arg1)。 对照前面的参数写入过程:Proxy 先写 a 再写 b;Stub 先读 _arg0 再读 _arg1。this 是 DemoService 创建的 Stub 实例,调用其覆写的 add,结果为 15。
至此你应该能在图上指出:参数经过了跨进程传输,业务方法仍是服务端进程内的一次 Java 调用。 下面只追这一个 int 如何回去。
Stub 把结果写入 reply
仍在同一个 Stub.onTransact 的 add 分支中,紧接业务调用:
reply.writeNoException();
reply.writeInt(_result);
写回顺序:无异常标记 → 返回值 15。 writeNoException 写的是客户端可读取的响应协议信息,不表示在 Driver 中再次执行权限检查。到这里结果只写进了服务端响应 Parcel,客户端还不能直接读取它。
经 BC_REPLY 与 BR_REPLY 把结果交回原调用线程
文件:IPCThreadState.cpp,符号 sendReply。服务端 executeCommand 对同步事务完成分发后调用它:
err = writeTransactionData(BC_REPLY, flags, -1, 0, reply, &statusBuffer);
if (err < NO_ERROR) return err;
return waitForResponse(nullptr, nullptr);
关键变化:命令变成 BC_REPLY。 Driver 根据同步事务关系把响应送回等待的发起线程;不需要向 ServiceManager 再查找一次客户端。
Driver 怎样把 reply 找回原调用线程
执行位置是服务端线程处理 BC_REPLY 的内核路径。来源:binder.c,binder_transaction;下面分别摘取原请求与回复分支,二者不是相邻代码。
原同步请求建立时,事务记录发起线程:
if (!reply && !(tr->flags & TF_ONE_WAY))
t->from = thread;
服务端发送 reply 时,从当前处理线程的事务栈取出正在回复的请求:
in_reply_to = thread->transaction_stack;
经过栈关系和线程校验后,沿原事务找到发起线程:
target_thread = binder_get_txn_from_and_acq_inner(in_reply_to);
reply 的目标来自原同步事务关系,不靠业务 code 再查服务,也不要求客户端额外注册 callback。 随后 Driver 将响应排给原调用线程,客户端 waitForResponse 处理 BR_REPLY。本例是一次直接同步调用;嵌套调用、死亡和错误也由这些关系及其校验分支管理。
用时序图区分“写了结果”和“调用者拿到结果”:
客户端同文件的 waitForResponse 在 BR_REPLY、非状态码错误分支中关联响应数据:
reply->ipcSetDataReference(reinterpret_cast<const uint8_t*>(tr.data.ptr.buffer),
tr.data_size,
reinterpret_cast<const binder_size_t*>(
tr.data.ptr.offsets),
tr.offsets_size / sizeof(binder_size_t), freeBuffer);
ipcSetDataReference 让 reply Parcel 引用收到的响应数据。 回调 freeBuffer 参与后续缓冲区释放,这不是把服务端 Java int 变量的地址直接传给客户端。
Driver 还会交付 BR_TRANSACTION_COMPLETE 等协议通知,它不等于业务结果。同步等待不能把它当作“已经拿到 15”;图中省略这些通知,以免误读为跨线程固定发生顺序。错误、目标死亡等情况也可能提前结束本次等待。
Proxy 读出结果 并回收 Parcel
回到生成的 ICalculator.java,符号 Stub.Proxy.add。Proxy 中的 transact 返回后执行:
_reply.readException();
_result = _reply.readInt();
对照服务端的响应写入顺序:先写无异常标记,再写 int;客户端先读异常状态,再读 int。 业务代码最后得到 _result,也就是 15。
同一个方法使用 finally 确保回收两份 Parcel:
finally {
_reply.recycle();
_data.recycle();
}
Java Parcel 回收与 Driver 接收缓冲区回收属于相关但不同层次的生命周期;libbinder 通过 freeBuffer 等路径发送 BC_FREE_BUFFER,Driver 才能回收相应接收缓冲区。不能只看分配和传输而忽略释放。
服务端部分异常会编码进 reply,再由 readException 还原;不是任意 Java 异常对象都可原样跨进程传递。传输失败还可能表现为 RemoteException、DeadObjectException。oneway 没有业务 reply,服务端业务异常不能靠这次返回值送回客户端。
读完这节,再回看 2.4 的总时序图:请求从客户端经 Driver 到服务端;业务结果在服务端写入响应,经 Driver 回到客户端,再由 Proxy 读出。请求与返回至此形成一个闭环。
2.8 通过 bindService 取得业务 Binder
前面从已经取得的 calculator 开始。现在回到它的来源:客户端调用 bindService 后,服务端创建的 Binder 怎样到达 onServiceConnected?这条路径同时涉及组件生命周期、Binder 引用传递和线程交接,不能只把 onBind 与 onServiceConnected 用一根箭头连起来。
本节沿本章 remote 配置的首次成功绑定展开,onBind 返回非空 Binder。先追踪直接转交服务 Binder 的基本路径;当前源码还允许按配置插入额外代理,后文在转交位置说明。已有绑定、重绑定与空 Binder 返回作为分支理解,不假设每次 bindService 都重新创建全部对象。
先分清连接回调 Binder 与业务 Binder
| 对象 | 实体所属进程 | 作用 |
|---|---|---|
| 应用自己的 ServiceConnection | 客户端 | 接收连接状态的 Java 回调对象,本身不是 Binder |
| IServiceConnection.Stub,即 InnerConnection | 客户端 | Framework 创建的 Binder 回调入口,供系统跨进程通知客户端 |
| ICalculator.Stub 实例 | 服务端 | DemoService 提供的业务 Binder,实现 add 等方法 |
| IActivityManager、IApplicationThread 等已有接口 | 各自的宿主进程 | 提供系统管理与应用调度通道,本节按用到的位置追踪 |
连接回调 Binder 从客户端交给系统,业务 Binder 从服务端经系统交给客户端。 两条引用方向不同,指向的实体也不同。bindService 返回的是绑定请求的受理结果,业务接口要在连接回调中取得。
下面是成功绑定的控制关系示意,省略每次跨进程调用内部重复的 Driver 收发过程,也不把受理返回与各进程的执行画成固定的全局先后。
客户端先建立连接回调 再提交绑定请求
执行位置:本例客户端主线程。入口是 ContextImpl.java 的 bindServiceCommon。普通绑定分支将应用的 ServiceConnection 包装为 IServiceConnection:
sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), handler, flags);
继续看 LoadedApk.java 的 ServiceDispatcher 构造函数:
mIServiceConnection = new InnerConnection(this);
mConnection = conn;
new InnerConnection(this) 创建了客户端自己的连接回调 Binder。 InnerConnection 继承 IServiceConnection.Stub;mConnection 则保存应用提供的普通 Java 回调。首次包装会创建这些对象,已有 ServiceDispatcher 可按连接和上下文等条件复用。
回到 ContextImpl.bindServiceCommon,把这个可跨进程访问的连接 sd 随请求交给系统:
int res = ActivityManager.getService().bindServiceInstance(
mMainThread.getApplicationThread(), getActivityToken(), service,
service.resolveTypeIfNeeded(getContentResolver()),
sd, flags, instanceName, getOpPackageName(), user.getIdentifier());
这里传的是连接回调的 Binder 引用,业务 ICalculator 还没有交到客户端。 Intent 用于描述要绑定的组件;已有的 IActivityManager 通道负责把请求送进 system_server。系统侧拿到 sd 对应的远端接口,稍后才能反向通知客户端。
system_server 安排 Service 创建 并请求执行 onBind
执行位置:system_server 处理该请求的线程。文件:ActivityManagerService.java,符号 bindServiceInstance,其内部转交给 ActiveServices:
return mServices.bindServiceLocked(caller, token, service, resolvedType, connection,
flags, instanceName, isSdkSandboxService, sdkSandboxClientAppUid,
sdkSandboxClientAppPackage, sdkSandboxClientApplicationThread,
callingPackage, userId);
ActiveServices.java 的 bindServiceLocked 会解析和校验目标,建立连接记录。本例使用 BIND_AUTO_CREATE;需要启动时沿 bringUpServiceLocked、realStartServiceLocked 等路径准备宿主进程与 Service。进程创建细节在启动章节展开,这里要分清:找到目标组件、创建 Service、取得它返回的 Binder,是三个不同动作。
具备宿主进程和应用调度接口后,requestServiceBindingLocked 发出绑定调度:
r.getHostProcess().getThread().scheduleBindService(r, b, b.intent.getIntent(),
rebind, r.getHostProcess().getReportedProcState(),
mBindServiceSeqCounter++);
scheduleBindService 通过 IApplicationThread 进入服务端应用。文件:ActivityThread.java,符号 ApplicationThread.scheduleBindService;它将收到的参数装入 BindServiceData,再发送消息:
sendMessage(H.BIND_SERVICE, s);
这行 sendMessage 把绑定工作交给服务端主线程。 主线程的 H 处理 BIND_SERVICE,进入 handleBindService,因此本例的 Service.onBind 在主线程执行;这与后面远程 add 在 Binder 接收线程执行不同。
handleBindService 中,真正取得业务 Binder 并发布的片段是:
IBinder binder = s.onBind(data.intent);
ActivityManager.getService().publishService(
data.token, data.bindToken, binder);
先暂停在第一句。s 是已经创建的 DemoService,onBind 返回它保存的 Stub 字段。这个 Java 引用先在服务端进程内交给 ActivityThread,跨进程发布发生在下一句 publishService 中。
这里的三个参数也要分开:data.token 对应 system_server 的 ServiceRecord,data.bindToken 对应 IntentBindRecord,用于让系统识别组件和本轮绑定;binder 才是要交付的业务接口。前两个 token 返回它们的宿主进程时,能够还原为系统原有的本地对象,不能把它们当作 ICalculator。
publishService 传的是对象描述 Driver 怎样换成引用
本例的 Java Stub 在服务端有相应 Native 桥接对象 JavaBBinderExt,Native Parcel 写 Binder 参数时先取得这个实体。Holder 与桥接对象的完整创建过程放在 2.10,这里继续跟随绑定过程观察它怎样被导出。
现在继续看 publishService 跨进程参数。以下针对普通 Kernel Binder IPC;底层协议沿用 2.6 的 C 语言 Driver 阅读基线。
Native Parcel.cpp 的 writeStrongBinder 进入 flattenBinder。对于本地实体,关键描述是:
obj.hdr.type = BINDER_TYPE_BINDER;
obj.binder = reinterpret_cast<uintptr_t>(local->getWeakRefs());
obj.cookie = reinterpret_cast<uintptr_t>(local);
发送 Parcel 中确实包含本地对象相关指针,但 Driver 会识别并改写 Binder 描述。 obj.binder 记录 Native 弱引用控制信息,cookie 记录本地 Native Binder 地址;这些信息帮助 Driver 识别和定位宿主进程中的实体,接收方不能拿它们直接访问服务端 Java 对象。Parcel 还记录对象描述的偏移位置,供 Driver 与普通参数区别处理。
文件:binder.c,符号 binder_translate_binder。先按发送进程与对象信息查找实体节点,没有时创建:
node = binder_get_node(proc, fp->binder);
if (!node) {
node = binder_new_node(proc, fp);
if (!node)
return -ENOMEM;
}
binder_node 表示内核记录的实体,它不是 Java 对象,也不把 Java 堆内容保存一份。 随后为本次接收进程,也就是 system_server,取得相应引用:
ret = binder_inc_ref_for_node(target_proc, node,
fp->hdr.type == BINDER_TYPE_BINDER,
&thread->todo, &rdata);
binder_inc_ref_for_node 创建或复用目标进程的 binder_ref,并维护相应引用计数。函数随后将本地实体类型改为 BINDER_TYPE_HANDLE,清除发送方指针字段,填入接收方可用的 handle:
fp->binder = 0;
fp->handle = rdata.desc;
fp->cookie = 0;
传输结果是 system_server 引用表中的 handle,不是一份能在 system_server 解引用的服务端指针。 事务本身还使用接收缓冲区保存参数与描述,相关数据映射见 2.6;接收缓冲区和长期存在的 binder_ref 是不同对象。
system_server 的 libbinder 解包 BINDER_TYPE_HANDLE 时,进入 Parcel::unflattenBinder:
ProcessState::self()->getStrongProxyForHandle(flat->handle);
它在 system_server 自己的 Native 堆创建或复用 BpBinder。随后 javaObjectForIBinder 为这个 Native IBinder 准备 BinderProxyNativeData 与 Java BinderProxy,创建与缓存规则见 Java 与 Native 对象对应关系。此时 system_server 持有的是指向服务端实体的本地代理。
system_server 保存业务引用 再通过连接回调转交客户端
ActivityManagerService.publishService 检查 token 与 bindToken 后,转入 ActiveServices.publishServiceLocked。文件:ActiveServices.java,先缓存业务引用与绑定状态:
b.binder = service;
b.requested = true;
b.received = true;
b.binder = service 保存的是 system_server 收到的 IBinder 引用。 b 是本轮绑定对应的 IntentBindRecord,不是客户端或服务端的业务 Stub。接着找到匹配的连接记录,向客户端发送通知:
IBinder serviceBinder = createPccProxyIfNeeded(c, service);
c.conn.connected(clientSideComponentName, serviceBinder, session,
false);
c.conn 是前面传入系统的 IServiceConnection 接口,指向客户端的 InnerConnection;serviceBinder 则是这次通知携带的业务 Binder。通知的目标 Binder 与通知参数中的业务 Binder 是两个对象。
当前 createPccProxyIfNeeded 允许按配置增加框架代理。图中追踪的是直接转交原业务引用的路径;若此分支返回额外代理,还要追踪它的实体、引用和转发行为,不能把所有产品的路径都认定为直接指向 DemoService。
直接转交时,system_server 写出的是远端 Binder 描述 BINDER_TYPE_HANDLE。Driver 的 binder_translate_handle 先从发送方的引用表找回实体:
node = binder_get_node_from_ref(proc, fp->handle,
fp->hdr.type == BINDER_TYPE_HANDLE, &src_rdata);
此时接收方是客户端,不是实体宿主进程,Driver 为客户端创建或复用指向同一节点的引用:
ret = binder_inc_ref_for_node(target_proc, node,
fp->hdr.type == BINDER_TYPE_HANDLE,
NULL, &dest_rdata);
然后写入客户端自己的 handle:
fp->binder = 0;
fp->handle = dest_rdata.desc;
fp->cookie = 0;
system_server 与客户端可以用不同的 handle 引用同一个 binder_node。 例如 system_server 使用 42、客户端使用 7,两者都可以指向同一服务端实体;数字仅作示意。跨进程传递的是受 Driver 管理的对象引用关系,不是要求两个进程使用同一个整数或内存地址。
连接回调的事务目标与业务 Binder 参数分别是谁
客户端传入 sd 时,InnerConnection 的本地实体描述经 Driver 转换为 system_server 的引用。system_server 随后通过 IServiceConnection.Stub.asInterface 得到连接接口代理;ActiveServices.bindServiceLocked 将 connection 保存进 ConnectionRecord,后续的 c.conn 就从这里取得。对应 ActiveServices.java 中的连续片段:
ConnectionRecord c = new ConnectionRecord(b, activity,
connection, flags, clientLabel, clientIntent,
callerApp.uid, callerApp.processName, callingPackage, res.aliasComponent);
这里导出的是客户端 InnerConnection 对应的 binder_node。拿到服务端发布的业务 Binder 后,系统执行 c.conn.connected,不是直接调用 DemoService 来通知客户端。完整的通知路径是:
system_server 的 IServiceConnection 接口代理 → Java BinderProxy → JNI/libbinder → Driver 根据连接回调的 handle 找到客户端节点 → 客户端 libbinder/JNI → IServiceConnection.Stub.onTransact → InnerConnection.connected → ServiceDispatcher → 主线程 ServiceConnection.onServiceConnected。
下面只画两个相关实体的定位关系。实线是事务目标与定位关系,虚线是业务引用作为参数交付;其余管理接口和 token 不在图中。
connected 事务发给客户端的连接回调节点,Parcel 里携带的是另一个节点的业务引用。 Driver 在同一次事务中既要定位接收者,又要转换参数中的 Binder 对象,不能把这两件事混为“都走业务节点”。客户端收到参数后才可以通过业务节点发起 add。
本例中,InnerConnection 属于客户端,ICalculator.Stub 属于服务端,两者对应两个不同的 binder_node;整个绑定过程还有 IActivityManager、IApplicationThread 和管理 token 等对象,不能据此说全过程只有两个节点。bindService 的连接回调由 system_server 调用,DemoService 并没有因此得到应用自己的业务 callback。 后面若希望 DemoService 主动通知客户端,需要显式注册另一份业务回调引用。
客户端还原业务代理 再把通知交给主线程
接收连接通知时,客户端先按自己的 handle 还原 Native BpBinder 与 Java BinderProxy;机制与上面 system_server 收到引用时相同,代理对象属于客户端自己的地址空间。这一步发生在解包通知参数时,早于应用的 onServiceConnected。
随后执行 LoadedApk.java 的 InnerConnection.connected。本例跨进程通知由客户端 Binder 接收线程处理,先找到对应的 ServiceDispatcher:
LoadedApk.ServiceDispatcher sd = mDispatcher.get();
if (sd != null) {
sd.connected(name, service, binderSession, dead);
}
IServiceConnection 在 AIDL 声明中是 oneway 接口。它负责通知连接,并不直接在当前 Binder 线程调用应用的普通 ServiceConnection 回调。ServiceDispatcher.connected 根据分发方式安排工作;本例普通绑定走 Handler 分支:
} else if (mActivityThread != null) {
mActivityThread.post(new RunConnection(name, service, session, 0, dead));
这次 post 才把回调工作交给客户端主线程。 主线程执行 RunConnection、doConnected,保存活动连接、设置死亡监听,最后调用应用回调:
mConnection.onServiceConnected(name, service, session);
本章 MainActivity.java 的回调里,先把通用 IBinder 转成业务接口:
ICalculator calculator = ICalculator.Stub.asInterface(binder);
跨进程时,asInterface 创建认识计算器协议的 ICalculator.Stub.Proxy,持有刚才已经得到的 Java BinderProxy。 它没有在客户端新建一个服务端 Stub,也不是此时才第一次还原底层 BpBinder。若引用返回自己的宿主进程,解包与 asInterface 可走本地对象路径,不能套用本例远端分支。
应用接着主动切到自己的工作线程:
worker.execute(() -> runCalls(calculator));
到这里才接上 2.4 的 Proxy.add。普通绑定回调默认主线程、远程业务方法在服务端 Binder 线程,是不同分发机制;若改用带 Executor 的绑定重载,连接回调的执行位置还要按传入 Executor 判断。
从对象分配位置重新看完整引用关系
下图只画直接转交路径中的业务 Binder,连接回调 Binder 是另一套方向相反的引用。箭头表示引用与定位关系,不表示函数执行顺序。
| 阶段 | 本例中新增或复用的主要对象 | 执行位置 |
|---|---|---|
| 准备连接 | 客户端 ServiceDispatcher、InnerConnection 与相应 Binder 关联 | 客户端主线程 |
| 创建服务 | DemoService、Stub 与 Native Holder | 服务端主线程 |
| 发布业务引用 | 服务端 Native 桥接、Kernel 实体与接收方引用、system_server 代理 | 服务端发布线程、Driver 与 system_server 接收线程 |
| 转交业务引用 | 客户端引用与代理,继续对应原服务实体 | system_server、Driver 与客户端 Binder 接收线程 |
| 通知应用并创建接口代理 | 活动连接记录、ICalculator.Stub.Proxy | 本例客户端主线程 |
| 调用 add | 请求与响应 Parcel、事务及接收缓冲区;已有代理继续使用 | 客户端工作线程与服务端 Binder 接收线程 |
这里的“创建或复用”很重要。 服务已运行且绑定记录已有 Binder 时,bindServiceLocked 可直接回送缓存引用,不一定再次调用 onBind;重绑定可进入 onRebind;onBind 返回 null 时客户端走 onNullBinding。这些分支改变控制流程,但不改变“对象留在所属进程、引用由 Driver 管理”的原则。
用本章日志核对绑定与线程交接
沿用 2.3 的安装和启动步骤,在 Host 保存日志与当前组件状态:
"$chapter2_adb" -s "$chapter2_serial" logcat -d -v threadtime \
-s BinderDemoClient:I BinderDemoServer:I '*:S' \
> "$chapter2_run/binding-thread.log"
"$chapter2_adb" -s "$chapter2_serial" shell dumpsys activity services com.example.binderdemo \
> "$chapter2_run/binding-state.txt"
结合本轮 PID 和时间窗口,按下面的对应关系阅读;不要把历史进程的同名日志混入本轮。这里给出预期判据,实际结果写入自己的实验记录。
| 日志位置 | 本例预期看到什么 | 能确认什么 |
|---|---|---|
| 服务端 onBind | 服务端 PID、主线程信息 | 创建的 Service 已进入绑定回调 |
| 客户端 connected | 客户端 PID、主线程、远端 BinderProxy 类名 | 业务引用已通过连接通知到达应用 |
| 服务端 add | 服务端 PID、Binder 接收线程 | 业务调用进入实体所属进程,不在客户端直接执行 |
| 客户端 add result | 客户端工作线程、结果 15 | 同步响应回到原来的业务调用线程 |
日志可以验证进程、线程与方法执行,不能直接证明内核引用计数或所有内存已回收;需要研究这部分时,再结合匹配 Kernel 的 Binder 调试信息追踪。至此,bindService 负责建立连接并交付目标引用,后续 add 使用该引用访问实体,两段过程已经接起来。
ServiceManager 是另一种获取入口
系统 Binder 服务常见“按名称注册、按名称查询”。对比图能看到,它与应用组件绑定解决了不同的获取场景;下图是概念时序,注册和获取 API 因服务而异。
拿到引用后,普通业务事务面向目标 Binder,不需要 ServiceManager 每次转发参数。 服务死亡、服务更新和再次获取另行处理。本例 DemoService 由应用绑定获取,并没有调用 ServiceManager.getService("Calculator")。
两条获取路径可以在不同层次相遇:bindService 使用的 ActivityManager 系统接口,本身可通过系统服务获取机制取得;但这不等于 DemoService 的业务 Binder 也按名称注册到了 ServiceManager。先取得系统管理接口,再由它协调应用组件绑定,才是这里的关系。
阅读入口:Java ServiceManager 的 getIServiceManager、ServiceManagerNative 的代理包装,以及 Native ServiceManager.cpp 的 addService、tryGetService、mNameToService 和访问控制。当前包装方式与旧版本可能不同,按固定基线阅读。
在 Host 终端做只读对照:
"$chapter2_adb" -s "$chapter2_serial" shell service list \
> "$chapter2_run/system-services.txt"
"$chapter2_adb" -s "$chapter2_serial" shell dumpsys activity services com.example.binderdemo \
> "$chapter2_run/app-service-binding.txt"
前者观察系统服务注册,后者观察本应用 Service 绑定。service list 没有 DemoService,不表示示例 Binder 调用失败。 两份输出回答的不是同一个获取问题。
绑定结束时,客户端已经有了调用目标。接下来 2.9 让服务端也取得客户端的回调目标;2.11 再分别追踪组件解绑、事务缓冲区与对象引用的释放。
2.9 注册业务 callback 并追踪反向调用
先把结论落到具体对象:如果服务端创建一个业务 Stub,客户端再创建一个独立的 callback Stub,它们对应两个不同的 binder_node。 正向业务事务定位服务端节点,反向 callback 事务定位客户端节点。Binder 不固定谁只能发送、谁只能接收;“客户端”和“服务端”是相对于某个接口的角色。
下面使用完整工程 Chapter2CallbackDemo 演示“注册回调、计算通知、注销、再次注册”。它与基础 Demo 使用不同包名,可同时安装;2.4 的 ICalculator.java 仍对应基础四方法接口。
先运行完整 callback 示例
下载 完整源码包。源码包含六个文件,已接好绑定、工作线程、回调分发、界面更新和退出清理;展开文件也保存在本章示例目录。Android.bp.example 在源码包内已命名为 Android.bp。
| 文件 | 职责 |
|---|---|
| Android.bp 与 AndroidManifest.xml | 模块声明、Activity 入口、独立 remote Service |
| ICallbackCalculator.aidl | 注册、注销与请求计算 |
| ICalculatorCallback.aidl | 客户端接收结果的 oneway 接口 |
| CallbackService.java | 实现业务 Stub,保存注册者,在单一工作线程中计算和广播 |
| MainActivity.java | 创建 callback Stub,注册和发起请求,处理按钮及清理 |
沿用 2.1 的 Host 环境与本轮记录目录。可直接使用知识库内展开的完整工程构建,不需要把下文片段手动拼成新类:
chapter2_notes="$chapter2_top/Android源码学习笔记/章节学习/第二章-Binder与AIDL"
chapter2_callback_source="$chapter2_notes/示例/Chapter2CallbackDemo"
python3 "$chapter2_notes/示例/构建示例APK.py" \
--aosp-top "$chapter2_top" --module "$chapter2_callback_source" \
--name Chapter2CallbackDemo --out "$chapter2_run/callback-apk"
chapter2_callback_apk="$chapter2_run/callback-apk/Chapter2CallbackDemo.apk"
"$chapter2_adb" -s "$chapter2_serial" install -r "$chapter2_callback_apk"
"$chapter2_adb" -s "$chapter2_serial" shell am force-stop com.example.bindercallback
"$chapter2_adb" -s "$chapter2_serial" shell am start -W \
-n com.example.bindercallback/.MainActivity
"$chapter2_adb" -s "$chapter2_serial" logcat -v threadtime -s CallbackDemo:I '*:S'
启动后自动注册并计算 7+8,界面应显示 result=15。按一次“注销回调”,再按“仅计算 7+8”:服务端仍计算,但客户端不应新增结果通知;再按“注册并计算 7+8”,通知应恢复。按“结束绑定并退出”可触发 Activity 退出与解绑。注销不撤回已经在途的通知,因此等首轮结果出现后再对照。抓日志时用 Ctrl+C 结束观察。
若要走 Soong,将源码包解压到独立的 packages/apps/Chapter2CallbackDemo,确认 Android.bp 存在,再按 2.3 的构建分支执行 m Chapter2CallbackDemo。不要同时把生成 Java 放回 src。两种构建方式使用相同手写源码,具体已验证范围见文末。
先认识两份 AIDL 再读注册过程
以下业务代码是突出通信关系的精简教学片段;完整工程负责日志、Trace、并发与生命周期处理。AIDL 生成代码摘要保持实际生成语句。
先定义客户端接收结果的接口。 文件 ICalculatorCallback.aidl:
package com.example.bindercallback;
oneway interface ICalculatorCallback {
void onResult(int value);
}
再让服务端业务接口接收这个回调对象。 文件 ICallbackCalculator.aidl:
package com.example.bindercallback;
import com.example.bindercallback.ICalculatorCallback;
interface ICallbackCalculator {
void registerCallback(ICalculatorCallback callback);
void unregisterCallback(ICalculatorCallback callback);
void addAndNotify(int a, int b);
}
这里 onResult 是 oneway;注册和 addAndNotify 仍是普通同步事务。完整工程中的 addAndNotify 只排队,结果通过独立回调发送,所以它的同步返回并不代表 onResult 已执行。
源码包已经包含这两份 AIDL。上面的构建脚本会把生成结果保存到本轮输出目录,可直接定位注册和回调的四个生成代码节点:
rg -n 'registerCallback|writeStrongInterface|readStrongBinder|TRANSACTION_onResult' \
"$chapter2_run/callback-apk/generated/com/example/bindercallback/ICallbackCalculator.java" \
"$chapter2_run/callback-apk/generated/com/example/bindercallback/ICalculatorCallback.java"
依次对照 registerCallback 的 Proxy、Stub,以及 onResult 的 Proxy、Stub。后面的四处生成代码摘要来自这两份接口的实际 Host AIDL 输出。
客户端创建 callback 实体 通过业务接口注册
先看客户端的教学代码,省略 Activity 的其他部分。Handler 明确指向主线程,callback 保留为字段,以便后续用同一个对象注销:
private final Handler mainHandler = new Handler(Looper.getMainLooper());
private final ICalculatorCallback callback = new ICalculatorCallback.Stub() {
@Override public void onResult(int value) {
Log.i("CallbackDemo", "onResult tid=" + Process.myTid());
mainHandler.post(() -> Log.i("CallbackDemo", "main result=" + value));
}
};
这次 new Stub 创建的是客户端实体,Native Holder 和桥接对象的建立机制与前面服务端 Stub 相同,只是宿主进程换了。 本工程 CallbackService.onBind 返回 ICallbackCalculator.Stub,在连接回调中取得业务接口后,由工作线程提交:
ICallbackCalculator calculator = ICallbackCalculator.Stub.asInterface(binder);
worker.execute(() -> {
try {
calculator.registerCallback(callback);
calculator.addAndNotify(7, 8);
} catch (RemoteException exception) {
Log.e("CallbackDemo", "request failed", exception);
}
});
看 ICallbackCalculator.java 的 Proxy.registerCallback 中的连续原文:
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeStrongInterface(callback);
boolean _status = mRemote.transact(Stub.TRANSACTION_registerCallback, _data, _reply, 0);
_reply.readException();
mRemote 是业务 Binder,决定本次事务送到服务端;callback 是 Parcel 参数,描述客户端创建的另一份 Binder 实体。 writeStrongInterface 最终写入 callback.asBinder(),不会把整个匿名 Java 对象序列化到服务端。这里同步 _reply 只是注册事务的响应,也不是以后通知结果的 callback。
Driver 处理该参数时,按前面的 binder_translate_binder 路径,为客户端 callback 创建或复用 binder_node,并为服务端建立 binder_ref。服务端解包得到自己进程的 BpBinder、Java BinderProxy;业务接口 Stub 随后执行:
com.example.bindercallback.ICalculatorCallback _arg0;
_arg0 = com.example.bindercallback.ICalculatorCallback.Stub.asInterface(data.readStrongBinder());
this.registerCallback(_arg0);
服务端收到的 _arg0 是 ICalculatorCallback.Stub.Proxy,内部持有指向客户端的 BinderProxy。 registerCallback 在服务端执行的是“保存这份代理”,不是在服务端 new 一个客户端 callback 实现。
服务端保存回调代理 再发起独立的反向事务
保存方式可以使用 RemoteCallbackList.java。它按 callback.asBinder() 管理注册,关联死亡通知;客户端进程死亡时可以移除相应回调。下面是服务端教学代码的字段:
private final RemoteCallbackList<ICalculatorCallback> callbacks =
new RemoteCallbackList<>();
private final ExecutorService callbackWorker = Executors.newSingleThreadExecutor();
业务 Stub 内的注册与注销方法:
@Override public void registerCallback(ICalculatorCallback callback) {
if (callback != null) callbacks.register(callback);
}
@Override public void unregisterCallback(ICalculatorCallback callback) {
if (callback != null) callbacks.unregister(callback);
}
同一个 Stub 的 addAndNotify 把计算和通知安排到单一工作线程,避免多个广播同时交叉执行:
@Override public void addAndNotify(int a, int b) {
callbackWorker.execute(() -> broadcastResult(a + b));
}
broadcastResult 是服务端自己的普通 Java 方法,重点是循环中的 onResult(value):
private void broadcastResult(int value) {
int count = callbacks.beginBroadcast();
try {
for (int index = 0; index < count; index++) {
try { callbacks.getBroadcastItem(index).onResult(value); }
catch (RemoteException exception) {
Log.w("CallbackDemo", "callback failed", exception);
}
}
} finally {
callbacks.finishBroadcast();
}
}
这组代码演示的是对当前注册者广播,若业务只向某次请求的发起者返回,需要增加请求与回调的对应关系。这里使用默认 RemoteCallbackList 的广播方式。完整工程在 Activity 退出时先停止新的界面处理,将注销请求放进客户端工作队列,并在主线程立即 unbindService;注销是尽力完成的独立请求,不要求它阻塞主线程。服务端组件销毁时结束工作任务并调用 callbacks.kill()。因此既要有业务注销协议,也要处理组件或进程已不可用的分支。
继续展开服务端实际调用的 ICalculatorCallback.java 的 Proxy.onResult:
_data.writeInterfaceToken(DESCRIPTOR);
_data.writeInt(value);
boolean _status = mRemote.transact(Stub.TRANSACTION_onResult, _data, null, android.os.IBinder.FLAG_ONEWAY);
这是另一份接口代理:它的 mRemote 持有 callback 的 BinderProxy,事务的目标 handle 指向客户端节点。 原业务代理的目标没有改变。回调沿 Java BinderProxy → JNI → 服务端 BpBinder → IPCThreadState → ioctl 进入 Driver;Driver 根据服务端的 callback handle 找到客户端 callback 的 binder_node,把事务交给客户端进程。
客户端 libbinder 接收后,经 JavaBBinderExt 回到原来的 ICalculatorCallback.Stub.onTransact,生成代码读取参数并调用客户端实现:
int _arg0;
_arg0 = data.readInt();
this.onResult(_arg0);
最终执行的是最初在客户端 new 出来的 callback.onResult。 本例远程 oneway 回调由客户端 Binder 接收线程分发,回调中的 Handler.post 才将日志后的处理交给主线程。业务回调没有 ServiceDispatcher 帮忙切线程;如果换成同步嵌套回调,还可能涉及等待线程上的重入分发,不能将所有 callback 都认定为固定的一条线程。
下面画的是机制时序,Driver 的箭头分别标出两次事务所定位的节点;同步响应仅作简写,完整返回协议见 2.7。
图中回调发生在同步响应之后是便于阅读的一种可能执行顺序。工作线程与回复路径可以并发,应用不能假定一定先收到 addAndNotify 的返回,再收到结果通知。
怎样数节点 怎样观察回调
| 对象或动作 | 是否对应另一份 binder_node |
|---|---|
| 服务端创建的业务 Stub 实例 | 对应服务端业务节点 |
| 客户端独立创建的 callback Stub 实例 | 对应另一个客户端回调节点 |
| 同一个 callback 多次注册或多次调用 | 本例引用持续存活时复用同一实体节点,不因每次调用新建节点 |
| 同一实体在其他进程的 BpBinder、BinderProxy、AIDL Proxy | 是代理包装,不各自再产生一份实体节点 |
| 一次同步调用的 reply Parcel | 沿原事务回复,不因为有返回值而自动创建回调节点 |
| bindService 的 InnerConnection | 还有独立的连接回调节点,与业务 callback 不同 |
节点数量取决于实际导出的 Binder 实例,不按方法数、事务方向或线程数计算。这里的复用以 Native 实体和相应引用仍存活为条件;注销后再注册,不保证沿用之前的节点编号。JavaBBinderHolder 的弱引用与按需重建见 2.10。多个客户端分别 new callback Stub,通常对应多个回调节点;一个客户端创建两份不同的 callback Stub,也不是因为接口类型相同就合并成一份。
运行扩展示例时,可以在客户端 callback、服务端 addAndNotify、broadcastResult 与主线程处理处记录 PID/TID,并在 Host 观察:
"$chapter2_adb" -s "$chapter2_serial" logcat -v threadtime -s CallbackDemo:I '*:S'
预期结果是客户端收到数值 15,服务端调用代理的位置与客户端 callback 的执行位置属于不同进程。日志用于验证执行方向与线程;节点和 handle 的真实编号要另结合匹配 Kernel 的 Binder 调试信息,不能从 Proxy 类名推导出来。完整工程的两端日志和线程位置,可以与 2.12 的实际记录和 Trace 对照。
Java 与 Native 对象的关联、资源生命周期、死亡通知及后续对照实验,继续见下篇 2.10~2.18。本文的源码基线、自测与参考资料也保留在下篇。