第二章(上):Binder 与 AIDL——从 AIDL 到内核的完整调用链

35 阅读19分钟

同一个 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/aidlJava 代码生成器把接口声明生成 Proxy、Stub 和编解码代码
frameworks/base/core/java/android/osBinder、BinderProxy、Parcel、ServiceManagerJava 对象与 IPC 接口
frameworks/base/core/jni/android_util_Binder.cppBinder JNI 与 JavaBBinderExtJava 与 Native 对象之间的桥梁
frameworks/native/libs/binderBpBinder、IPCThreadState、ProcessState、Parcel用户空间协议、线程状态与 Driver 交互
frameworks/native/cmds/servicemanagerNative ServiceManager按名称登记和查询系统 Binder 服务
匹配的 Kernel 源码 drivers/androidC 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。先从进程与接口概念进入,写出一个能观察行为的小程序,再回到这些文件。

Java、Native、Driver 的整体位置

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 通信。

Binder 整体架构:客户端与服务端的 Java、JNI、libbinder 层,以及内核 Driver 和 ServiceManager 的位置

查看架构图 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。这个转换究竟返回本地实现,还是创建远端代理,决定了后续方法会怎样执行。

入口选择 asInterface 为什么可能绕过 IPC(过程或对象关系)

生成文件 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++ 的语言边界不会自动切换执行线程。

2.5 从 Java 进入 JNI 与 libbinder(过程或对象关系)

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取得数据与目标两条关联

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 内容本轮作用
dataObjProxy 写过参数的 _datamNativePtr 指向的 Native Parcel请求数据
replyObjProxy 创建的 _replymNativePtr 指向的另一份 Native Parcel承接响应
objAIDL Proxy 的 mRemote,本例是 BinderProxymNativeData 指向包装结构,其中 mObject 保存 Native IBinder目标代理

下面是对象关系图。箭头上的文字说明字段读取或使用关系,不表示一个辅助函数顺序调用另一个;图中对象都位于客户端进程。

先对上 JNI 参数 obj 与 dataObj 不是同一个对象(过程或对象关系)

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.mNativeDataJNI 的 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));

用图把三种“容器”区分开。箭头在这里表示指向或描述关系,不表示函数调用:

IPCThreadState 怎样打包参数 描述结构和命令流(过程或对象关系)

命令流不等于全部业务载荷。 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 加法。

先用图认识 Driver 的四项工作(过程或对象关系)

图上虚线表示工作交接,不是客户端内核调用栈直接调用了服务端 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 实现与固定源码
谁接收 ioctlbinder_ioctl_write_readprocess.rs:ioctl_write_read 把 BINDER_WRITE_READ 交给当前线程的 write_read
谁拆解 BC_TRANSACTION / BC_REPLYbinder_thread_writethread.rs:write 及请求、回复处理方法
谁组织目标与事务binder_transaction / binder_proc_transactionprocess.rs、thread.rs、transaction.rs
谁向用户线程交付结果binder_thread_readthread.rs 的 read 与 transaction.rs 的交付实现
设备与映射入口在哪binder_ioctl / binder_mmaprust_binder_main.rs 的文件与映射操作

本文主场景没有独立 HAL,也没有专属物理外设。Binder Driver 的事务、缓冲区、队列与等待机制就是本例应读通的底层边界。

请求与回复的时序

2.7 服务端执行与结果返回

现在 Driver 已把请求交给服务端。先看下图:上半段是接收和执行,下半段是业务结果回到调用者;下面分别追踪两端各自的调用栈。

2.7 服务端执行与结果返回(过程或对象关系)

接收分发、业务执行和写入响应发生在服务端接收线程,读取结果回到发起请求的客户端工作线程。 进入 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.306959TID 5096,binder:5085_1BC_ENTER_LOOPER初始池线程进入
828.306959TID 5096BR_SPAWN_LOOPERDriver 请求增加线程
828.307902TID 5097,binder:5085_2BC_REGISTER_LOOPER新线程登记
828.314915TID 5096BR_SPAWN_LOOPER后续再次请求
828.315087TID 5098,binder:5085_3BC_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。本例是一次直接同步调用;嵌套调用、死亡和错误也由这些关系及其校验分支管理。

用时序图区分“写了结果”和“调用者拿到结果”:

Driver 怎样把 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 收发过程,也不把受理返回与各进程的执行画成固定的全局先后。

先分清连接回调 Binder 与业务 Binder(过程或对象关系)

客户端先建立连接回调 再提交绑定请求

执行位置:本例客户端主线程。入口是 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 不在图中。

连接回调的事务目标与业务 Binder 参数分别是谁(过程或对象关系)

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 因服务而异。

ServiceManager 是另一种获取入口(过程或对象关系)

拿到引用后,普通业务事务面向目标 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 再分别追踪组件解绑、事务缓冲区与对象引用的释放。

callback的注册与反向调用

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。本文的源码基线、自测与参考资料也保留在下篇。