Android源码第六章:AMS、ATMS 与四大组件——跟着一次启动读通组件交接

17 阅读21分钟

在示例应用里点“打开 remote Activity”,调用方会记下一条 after startActivity returned。目标进程里另有一条 DetailActivity.onCreate。为什么要看两条日志?前一条只说明启动调用已返回,后一条才说明宿主主线程已经开始执行这个 Activity 的生命周期。

先顺着这次点击走一遍。系统怎样决定沿用哪个任务、要不要创建宿主,宿主又怎样把 Binder 收到的工作交给主线程?理清这几次交接后,再看另外三类组件。绑定 Service 要等连接回调,本例的有序广播会交回结果,首次获取尚未发布的 Provider 要等接口就绪。

开发者点过手机后,在书桌前等待另一端的回应

6.1 先建立四大组件的整体模型

组件、进程、线程和任务,分别是什么

Activity、Service、BroadcastReceiver、ContentProvider 是 Android 定义的应用组件。它们的声明、可见性、权限和目标进程一般来自 AndroidManifest.xml;系统为启动、绑定、分发、查询维护相应状态。类的 Java 实例最终由宿主应用进程创建。

一个进程可以承载多个组件,一项任务也可以包含不同进程中的 Activity。 进程由 PID 标识,线程由 TID 标识;Activity 的 Java 实例有自己的对象身份,系统中的 ActivityRecord 又是另一份对象。taskId、PID 和 Binder token 不是同一套编号。

概念保存在哪里解决什么问题本章中的例子
Intent 与组件信息请求端和系统端的参数/元数据要启动谁、携带什么、目标进程和权限是什么显式打开 DetailActivity
ActivityRecord / Tasksystem_server 的窗口与任务管理结构管理任务关系、目标状态与 token同一任务中的两个 Activity
ProcessRecord / WindowProcessControllersystem_server 的进程记录及窗口侧关联记录宿主、ApplicationThread 和进程状态查找 :components 是否已运行
ActivityClientRecord / Activity 实例应用进程 Java 堆把系统 token 与本地 Activity、窗口和状态关联先创建记录,再实例化 Activity
ApplicationThread应用中的 IApplicationThread Binder 实体接收系统对应用的调度生命周期事务、创建 Service、交付广播
ActivityThread 与主线程 Looper应用进程执行组件生命周期和消息分派主线程调用 onCreate

ActivityTaskManagerService(下文简称 ATMS)主要管理 Activity、任务和状态推进,ActivityManagerService(AMS)管理应用进程,并组织 Service、广播和 Provider 等能力;两者协作完成组件调度。

ActivityThread 是类名,不是额外的工作线程。正常应用入口在主线程建立它和主 Looper;内部 ApplicationThread 是 Binder 入口。远程调度到达时,往往先在 Binder 接收线程执行入口,再由 Handler 交给主线程。

用整体架构图定位执行空间

先找到上方的应用入口和宿主组件,再向下辨认 Framework、system_server 和 Linux 内核。蓝线走管理请求,紫线走调度,绿色通道在取得业务接口之后使用。

四大组件整体架构。按 Android 标准分层展示请求端、system_server、组件宿主、Zygote 和 Binder 驱动

图的横带按 Android 平台分层,带进程名的框用来区分执行归属。同一个应用进程既有应用代码,也运行 Framework 代码。Service 或 Provider 的业务接口就绪后,后续业务调用直达宿主的 Binder 端点。图把这些跨进程线所共有的 JNI、libbinder 和 Binder 驱动折叠起来,内核带单独标出事务入队和唤醒。

冷建进程走琥珀色通道。ProcessList 通过 Unix socket 请求 Zygote,Zygote 的原生实现经 Bionic 进入 Linux 任务创建路径。本章调度不经过专属 HAL。显示首帧和真实文件 I/O 分别留到 Graphics 与 Storage 章节。

用一张总时序对照四种交接

先看第一段。ATMS 接受请求后,宿主还要完成进程创建、报到和主线程接单。后面三段沿用同一套生命线,分别画一次 Service 绑定、一次有序广播和一次 Provider 冷获取。它们是独立操作,宿主和接口已就绪时可以跳过各自的创建或等待步骤。

四大组件全章时序。沿同一套生命线对照 Activity 冷启动、Service 绑定、有序广播和 Provider 冷获取,各自有独立的起点与收尾

可以先在图上找每段的完成信号。Activity 看生命周期回报,Service 看连接回调和解绑,广播看 finish 与最终结果,Provider 看发布通知和 Cursor.close()。手机上可用系统缩放阅读接口名。

6.2 准备一个能同时观察四类组件的示例

明确设备与代码各自的身份

需要已有的 ADB 与 AOSP Host 工具,并理解 Binder、Handler 和进程启动的基本模型。下面的操作结果是依据源码与契约给出的预期,不是本章设备实测。

下面命令在 Host Bash 终端 A 执行,后续构建、安装和只读查询继续使用这个终端。Host 是工作站,设备 shell 是 Android 内部;先把源码路径改成自己的位置:

chapter6_top=/absolute/path/to/aosp
chapter6_adb="$chapter6_top/out/host/linux-x86/bin/adb"
chapter6_run=$(mktemp -d "$HOME/aosp-chapter6.XXXXXX")
chapter6_notes="$chapter6_run"
"$chapter6_adb" devices -l
read -r -p '选择本轮设备 serial:' chapter6_serial
"$chapter6_adb" -s "$chapter6_serial" shell getprop sys.boot_completed
"$chapter6_adb" -s "$chapter6_serial" shell getprop ro.build.fingerprint
"$chapter6_adb" -s "$chapter6_serial" shell uname -a

把 chapter6_top 改成自己的 AOSP 根目录。先按附录 A 保存所有文件到 $chapter6_notes/示例/ 下,再继续构建;不要求读者拥有作者的知识库目录。预期设备在线、boot_completed 为 1。记录 fingerprint、Kernel、时间与 serial。未连接时先回到第一章;源码提交不能代替设备镜像身份,历史 PID 和 Trace 也不是本章实验结果。

一个 APK 如何观察两个进程

工程为 Chapter6ComponentsDemo.zip,展开文件也在 示例目录。它只用公共 SDK、程序化布局与一个 AIDL 接口,不修改 Framework,不需要系统权限。

Chapter6ComponentsDemo/
├── Android.bp
├── AndroidManifest.xml
└── src/com/example/componentsdemo/
    ├── IComponentService.aidl
    ├── Events.java
    ├── DemoApplication.java
    ├── MainActivity.java
    ├── DetailActivity.java
    ├── DemoService.java
    ├── DemoReceiver.java
    └── DemoProvider.java

知识库展开目录用 Android.bp.example,避免被 Soong 扫描成同名模块;ZIP 内是真正的 Android.bp。手写 src 不放 AIDL 生成的 Java 文件,生成结果只用于构建与对照。

Manifest 的关键是把四个目标组件放进同一私有进程。以下为完整工程中组件声明的节选:

<activity android:name=".DetailActivity" android:process=":components"
    android:exported="false" />
<service android:name=".DemoService" android:process=":components"
    android:exported="false" />
<receiver android:name=".DemoReceiver" android:process=":components"
    android:exported="false" />
<provider android:name=".DemoProvider" android:process=":components"
    android:authorities="com.example.componentsdemo.state"
    android:exported="false" />

MainActivity 在默认进程,四个目标组件在另一 PID,通常仍是同一 UID,因此可在未导出时相互访问。任意组件启动过 :components,后续组件就可能复用宿主。第一次打开 DetailActivity 时,也可能先看到同进程 Provider 初始化。 这用于观察进程初始化与组件请求不是一对一关系。

Events.mark 统一记录 uptime、PID、TID、线程名;DemoApplication 的 ActivityLifecycleCallbacks 再记 Activity 实例标识与 taskId。DetailActivity 提供 singleTop、recreate、finish 三个按钮,MainActivity 分开触发 started Service、绑定、解绑、广播与查询。

启动按钮的示例代码先后记录:

Events.mark("before startActivity");
startActivity(new Intent(this, DetailActivity.class));
Events.mark("after startActivity returned");

这两条标记只圈出调用方的请求。 远端生命周期和首帧要用各自的日志或 Trace 观察。两个进程可并发执行,日志不要求固定交错顺序。

构建、安装与第一次运行

需要 Linux x86_64 Host、Python 3、已有 AOSP Host 工具和 API 至少 28 的设备;本例 target SDK 为 36。独立 APK 与 Soong 路线任选一种,下面先讲独立路径;只用 Soong 的读者直接看稍后的同名段落。下列命令生成 AIDL、编译、打包和签名,只改变新输出目录;缺材料时脚本会列出,不会自动完整编译系统:

python3 "$chapter6_notes/示例/构建示例APK.py" \
  --aosp-top "$chapter6_top" \
  --module "$chapter6_notes/示例/Chapter6ComponentsDemo" \
  --name Chapter6ComponentsDemo \
  --target-sdk 36 \
  --out "$chapter6_run/apk"

输入包括公共 android.jar、aidl、JDK 21、D8、aapt2 和测试签名材料;输出包括 generated、classes、DEX、APK 与 build-commands.json。成功以退出码 0 和本轮产物为准,旧 APK 文件不能证明本次成功。2026-10-22 的历史静态检查只做过 AIDL 生成与 javac 编译;本轮未重跑这些命令,也没有验证完整打包。

独立脚本退出码为 0 后,在终端 A 指定它刚生成的产物:

chapter6_apk="$chapter6_run/apk/Chapter6ComponentsDemo.apk"
test -f "$chapter6_apk"

若选择 Soong 路线,则跳过上面的独立构建及赋值。 将 ZIP 解压到 packages/apps/Chapter6ComponentsDemo;从附录重建时把 Android.bp.example 改名为 Android.bp,避免两份同名模块。终端 A 应已加载第一章的 envsetup 并完成目标产品的 lunch,再在 AOSP 根目录执行:

cd "$chapter6_top" && m Chapter6ComponentsDemo

构建成功后,根据本轮输出确认当前产品安装的 APK 路径。若要查找候选文件,可在终端 A 执行下面的命令。输出可能同时包含安装件和中间产物,选产品分区下的安装件。

chapter6_product_out=$(get_build_var PRODUCT_OUT)
test -d "$chapter6_product_out" &&
  find "$chapter6_product_out" -type f -name Chapter6ComponentsDemo.apk -print
read -r -p '输入本轮产品安装件的路径:' chapter6_apk
test -f "$chapter6_apk"

构建或定位失败就停在这里。两条路线最后都得到 chapter6_apk,先打印路径并确认它来自本轮构建。

printf '%s\n' "$chapter6_apk"

下一组命令会安装/更新本示例并打开入口:

test -f "$chapter6_apk" &&
  "$chapter6_adb" -s "$chapter6_serial" install -r "$chapter6_apk" &&
  "$chapter6_adb" -s "$chapter6_serial" shell am start -W \
    -n com.example.componentsdemo/.MainActivity

安装返回 Success 后才打开入口。预期看到按钮列表,默认进程输出 Application 和 MainActivity 的生命周期日志。按 6.11 打开终端 B 并保持 logcat 监听,再点“打开 remote Activity”,记录新 PID、Provider 初始化、Detail 实例与 taskId。

6.3 从 startActivity 进入系统的启动决策

调用方交出的是什么

以下用户空间源码取自本工程 android17-release,各节源码链接指向对应项目的固定提交和行号。

启动请求不是把已 new 出的 Activity 送给系统。应用交出 Intent、调用者 ApplicationThread、当前 Activity token、选项和身份;系统先确认目标、用户、权限和启动条件,才决定创建、复用或拒绝。

普通 Activity 的 startActivity 经 startActivityForResult 的相关重载进入 Instrumentation。先看应用主线程中的交接:

来源:Activity.java · startActivityForResult。

mInstrumentation.execStartActivity(
    this, mMainThread.getApplicationThread(), mToken, this,
    intent, requestCode, options);

execStartActivity 收到调用方 ApplicationThread 和 Activity token。 前者让系统识别调用进程,后者关联来源 Activity;两者不是即将创建的目标 Activity 实例。

Instrumentation 随后取得 ActivityTaskManager 接口并发起事务:

来源:Instrumentation.java · execStartActivity。

int result = ActivityTaskManager.getService().startActivity(whoThread,
        who.getOpPackageName(), who.getAttributionTag(), intent,
        intent.resolveTypeIfNeeded(who.getContentResolver()), token,
        target != null ? target.mEmbeddedID : null, requestCode, 0, null, options);
notifyStartActivityResult(result, options);
checkStartActivityResult(result, intent);

checkStartActivityResult 检查系统对启动请求的返回状态。 无法解析、权限不允许等可以变成调用方异常;这不证明目标 onCreate 已完成,更不证明窗口呈现。目标 Activity 的业务返回要另用 Activity Result 契约,本例没有请求它。

系统把请求组织成启动操作

执行者变成 system_server 的 Binder 处理线程。ActivityTaskManagerService.startActivityAsUser 校验用户等条件后配置 ActivityStarter:

来源:ActivityTaskManagerService.java · startActivityAsUser。

return getActivityStartController().obtainStarter(intent, "startActivityAsUser")
        .setCaller(caller)
        .setCallingPackage(callingPackage)
        .setCallingFeatureId(callingFeatureId)
        .setResolvedType(resolvedType)
        .setResultTo(resultTo)
        .setResultWho(resultWho)
        .setRequestCode(requestCode)
        .setStartFlags(startFlags)
        .setProfilerInfo(profilerInfo)
        .setActivityOptions(opts)
        .setUserId(userId)
        .execute();

obtainStarter 取得用于组织本次启动的对象,execute 推进流程。 Intent 解析、身份与权限、后台启动限制、任务选择发生在应用回调之前。ActivityStarter 不是 Activity Java 实例的工厂。

ActivityStarter 的 startActivityUnchecked / startActivityInner 等函数选择目标 Task,处理 flags、launchMode 与复用,再推动目标生命周期。本版 Activity/Task 管理的主要代码在 com.android.server.wm,不是都位于 AMS 的 am 包。

检查宿主是否已经就绪

ActivityTaskSupervisor.startSpecificActivity 根据目标记录 r 查找宿主。这里的 r 是 system_server 维护的 ActivityRecord,保存目标信息与 token;它不是应用进程中的 Activity 实例:

来源:ActivityTaskSupervisor.java · startSpecificActivity。

final WindowProcessController wpc =
        mService.getProcessController(r.processName, r.getUid());

boolean knownToBeDead = false;
if (wpc != null && wpc.hasThread()) {
    try {
        realStartActivityLocked(r, wpc, andResume, checkConfig);
        return;

已有 ApplicationThread 时,系统尝试向现有宿主派发。 没有可用宿主时,系统转向进程创建:

来源:ActivityTaskSupervisor.java · startSpecificActivity。

mService.startProcessAsync(r, knownToBeDead, isTop,
        isTop ? HostingRecord.HOSTING_TYPE_TOP_ACTIVITY
                : HostingRecord.HOSTING_TYPE_ACTIVITY);

startProcessAsync 把冷启动交给 AMS/ProcessList。即使已有可用宿主,realStartActivityLocked 也会先检查之前的暂停是否完成。派发第一次遇到 RemoteException 时会标记 launchFailed 并尝试重建,标记尚在且再次派发失败时会结束 Activity。内部中止也不一定在客户端表现为异常,START_ABORTED 在对外返回时可以映射为 START_SUCCESS。 派发和重试 · 对外结果映射

Activity 启动分支流程。区分启动受阻、实例复用、可用宿主与冷启动,包含等待和派发失败

Activity 复用和进程复用是不同判断。没有 fork 不说明复用了原 Activity;启动快也不能证明走 onNewIntent。

6.4 目标进程不存在时,怎样到达 Zygote 与 Kernel

系统先登记进程,再等待应用接口

ProcessRecord 是 system_server 的宿主记录,可能先于实际进程可用而存在;它保存进程名、UID、启动序列及后续接口。创建后再把真实 PID、启动身份与 ApplicationThread 关联,窗口侧通过 WindowProcessController 感知宿主。

这里读取普通 Zygote 分支。app Zygote、WebView Zygote、USAP 池和隔离进程是其他分支,不把本节的 fork 时机扩写成每次启动唯一情况。ProcessList.startProcess 普通分支调用:

来源:ProcessList.java · startProcess。

startResult = Process.start(entryPoint,
        app.processName, uid, uid, gids, runtimeFlags, mountExternal,
        app.info.targetSdkVersion, seInfo, requiredAbi, instructionSet,
        app.info.dataDir, invokeWith, app.info.packageName, zygotePolicyFlags,
        isTopApp, app.getDisabledCompatChanges(), app.getEnabledCompatChanges(),
        useDeliQueue, pkgDataInfoMap,
        allowlistedAppDataInfoMap, bindMountAppsData, bindMountAppStorageDirs,
        bindOverrideSysprops, app.getStartSeq(),
        new String[]{PROC_START_SEQ_IDENT + app.getStartSeq()});

entryPoint、进程名、UID、挂载与运行时配置参与宿主建立。 Process.start 进入 ZygoteProcess,连接第四章进程创建与本章组件请求。

创建请求通过 socket 交给 Zygote

attemptZygoteSendArgsAndGetResult 写参数并读结果:

来源:ZygoteProcess.java · attemptZygoteSendArgsAndGetResult。

zygoteWriter.write(msgStr);
zygoteWriter.flush();

// Always read the entire result from the input stream to avoid leaving
// bytes in the stream for future process starts to accidentally stumble
// upon.
Process.ProcessStartResult result = new Process.ProcessStartResult();
result.pid = zygoteInputStream.readInt();
result.usingWrapper = zygoteInputStream.readBoolean();

读到 PID 只说明取得进程创建结果,不说明应用初始化完成。 ZygoteConnection 解析普通 socket 命令后,仍有两种内部创建路径。ZygoteServer 的 multipleForksOK 受 USAP 开关和运行时线程挂起安全条件影响,再作为 multipleOK 传给 processCommand;排除 USAP 还不能断言一定调用 forkAndSpecialize。

来源:ZygoteConnection.java · processCommand。条件分支连续原文:

if (parsedArgs.mInvokeWith != null || parsedArgs.mStartChildZygote
        || !multipleOK || peer.getUid() != Process.SYSTEM_UID) {

满足其中任一条件时走 Zygote.forkAndSpecialize,经其 JNI 路径进入 ForkCommon。 否则走普通的快速处理分支:

来源:ZygoteConnection.java · processCommand。

Runnable result = Zygote.forkSimpleApps(argBuffer,
        zygoteServer.getZygoteSocketFileDescriptor(),
        peer.getUid(), Zygote.minChildUid(peer), parsedArgs.mNiceName,
        parsedArgs.mIsTopApp);

forkSimpleApps 委托同一命令缓冲的 forkRepeatedly;ZygoteCommandBuffer 的对应方法继续交给 JNI:

来源:ZygoteCommandBuffer.java · forkRepeatedly。

return nativeForkRepeatedly(mNativeBuffer, zygoteSocket.getInt$(),
        expectedUid, minUid, firstNiceName, isTopApp, useFifoUi);

Native 的 com_android_internal_os_ZygoteCommandBuffer_nativeForkRepeatedly 解析命令后调用 zygote::forkApp,后者汇入同一个 ForkCommon。两条入口是条件分支,不是一次创建连续执行两遍。 Native 还协调 fd、身份与 fork 前后资源,再交应用入口;有 PID 不表示消息队列和组件已准备好。本节接下来解释它们汇合后的 fork/Bionic/Kernel 创建机制,不声明本轮设备实际选中了哪一条入口。

JNI 到 Bionic 再到 Kernel 任务创建

Zygote Native 的 ForkCommon 中核心创建动作如下,其完整上下文还包括 fd、信号和 fork 协调,不应在普通多线程应用中照抄:

来源:com_android_internal_os_Zygote.cpp · zygote::ForkCommon。

pid_t pid = fork();

if (pid == 0) {

本 Bionic 基线的 fork / _Fork 进入 __clone_for_fork:

来源:fork.cpp · __clone_for_fork。

int result = clone(nullptr, nullptr, (CLONE_CHILD_SETTID | CLONE_CHILD_CLEARTID | SIGCHLD),
                   nullptr, nullptr, nullptr, &(self->tid));

两块分别属于 Zygote Native 和 Bionic,不是同一函数相邻代码。架构相关系统调用封装再进入 Kernel;ACK 的 kernel_clone 创建任务:

来源:fork.c · kernel_clone。

p = copy_process(NULL, trace, NUMA_NO_NODE, args);
add_latent_entropy();

准备完成后使新任务可被调度:

来源:fork.c · kernel_clone。

wake_up_new_task(p);

copy_process 建立任务及资源,wake_up_new_task 使其可运行;可运行不等于已获得 CPU。 fork 通常使用写时复制语义,不是立即复制全部物理页。COW 与映射继续对照第四章;本节把组件冷启动连到任务创建和调度入口。

应用报到后才能继续交付组件

子进程经 RuntimeInit / ActivityThread.main 准备主 Looper、ActivityThread 与 ApplicationThread。ActivityThread.attach 非 system 分支向 AMS 报到:

来源:ActivityThread.java · attach。

mgr.attachApplication(mAppThread, startSeq);

mAppThread 是应用交给 AMS 的 Binder 实体,startSeq 关联本次进程启动。 AMS 校验报到身份、注册死亡监听,再向应用发送单向的 bindApplication。应用收到后把 H.BIND_APPLICATION 投递给主线程,主线程再做进程级初始化。Service 的绑定是稍后另行处理的组件操作。

报到和初始化完成是两次交接。 等待初始化的开关启用时,应用主线程执行完 Application.onCreate 后回报 finishAttachApplication,系统再从 finishAttachApplicationInner 续办待处理工作。关闭等待开关时,AMS 在初次报到里直接续办,并忽略客户端稍后的完成回执。Activity 冷启动加速启用时,ATMS 的续办可提到发出 bindApplication 之后、等待初始化之前,生命周期仍要由宿主主线程执行。 AMS 报到与加速分支 · 续办待处理工作 · 应用回报

冷建应用宿主时的进程创建和报到

这张图突出创建与报到。父端通过 socket 取到 PID、子进程被调度执行和应用报到是不同事件,图上的距离不代表间隔。创建请求失败、报到身份不符或应用初始化异常,都会让后续交接受阻。

6.5 从生命周期事务到 Activity 的 onCreate 和 onResume

系统创建的是可序列化的执行要求

宿主可用后,realStartActivityLocked 及其 tryRealStartActivityInner 分支组织初始化数据。本版直接构造 LaunchActivityItem:

来源:ActivityTaskSupervisor.java · tryRealStartActivityInner。

final LaunchActivityItem launchActivityItem = new LaunchActivityItem(r.token,
        r.intent, System.identityHashCode(r), r.info,
        procConfig, overrideConfig, deviceId,
        r.getFilteredReferrer(r.launchedFromPackage), task.voiceInteractor,
        proc.getReportedProcState(), r.getSavedState(), persistentState,
        results, newIntents, r.takeSceneTransitionInfo(), isTransitionForward,
        proc.createProfilerInfoIfNeeded(), r.assistToken, activityClientController,
        r.shareableActivityToken, r.getLaunchedFromBubble(), fragmentToken,
        r.initialCallerInfoAccessToken, activityWindowInfo, r.getDisplayId());

LaunchActivityItem 携带 token、Intent、ActivityInfo、配置和待恢复状态。 token 关联系统 ActivityRecord;传的是参数与 Binder 引用,不是把 system_server 的记录对象搬进应用 Java 堆。

目标状态还可能是 Resume、Pause 或 Stop。这里看继续到前台的分支,系统把 launch item 与生命周期 item 交给 ClientLifecycleManager:

来源:ActivityTaskSupervisor.java · tryRealStartActivityInner。

final boolean isSuccessful = mService.getLifecycleManager().scheduleTransactionItems(
        proc.getThread(),
        // Immediately dispatch the transaction, so that if it fails, the server can
        // restart the process and retry now.
        true /* shouldDispatchImmediately */,
        launchActivityItem, lifecycleItem);

本版还有事务独立派发/批量管理的兼容分支。不要将旧文 obtain/addCallback 的写法当成本工程逐字实现,应核对 scheduleTransactionItems 与目标状态选择。

ClientLifecycleManager.scheduleTransaction 经 ClientTransaction.schedule 调用:

来源:ClientTransaction.java · schedule。

mClient.scheduleTransaction(this);

这里的 ClientTransaction 是 Framework 生命周期协议对象,底层仍由 Binder 传输;它不是 Kernel 的 binder_transaction,也不是数据库事务。

Binder 接收后怎样交给主线程

远程调度先进入 ApplicationThread.scheduleTransaction:

来源:ActivityThread.java · ApplicationThread.scheduleTransaction。

ActivityThread.this.scheduleTransaction(transaction);

ActivityThread 继承的 ClientTransactionHandler 预处理后交给 Handler:

来源:ClientTransactionHandler.java · scheduleTransaction。

transaction.preExecute(this);
sendMessage(ActivityThread.H.EXECUTE_TRANSACTION, transaction);

sendMessage 是从 Binder 接收线程交到主线程队列的明确动作。 preExecute 的预处理不代表生命周期已完成。主线程 H.handleMessage 收到 EXECUTE_TRANSACTION 后:

来源:ActivityThread.java · H.handleMessage。

mTransactionExecutor.execute(transaction);

TransactionExecutor 按 items、当前/目标状态和需补齐的生命周期路径组织执行。下面的 LaunchActivityItem.execute 已在主线程:

来源:LaunchActivityItem.java · execute。

final ActivityClientRecord r = new ActivityClientRecord(mActivityToken, mIntent, mIdent,
        mInfo, mOverrideConfig, mReferrer, mVoiceInteractor, mState, mPersistentState,
        mPendingResults, mPendingNewIntents, mSceneTransitionInfo, mIsForward,
        mProfilerInfo, client, mAssistToken, mShareableActivityToken, mLaunchedFromBubble,
        mTaskFragmentToken, mInitialCallerInfoAccessToken, mActivityWindowInfo, mDisplayId);
client.handleLaunchActivity(r, pendingActions, mDeviceId, null /* customIntent */);
Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER);

ActivityClientRecord 在应用进程创建,以 token 对应系统目标和本地实例。 它保存 LoadedApk 等运行信息,再交给 handleLaunchActivity / performLaunchActivity。

对象由谁创建 谁保存 谁调用 onCreate

ActivityThread 先从 LoadedApk/Context 取得 ClassLoader,由 Instrumentation 和 AppComponentFactory 实例化:

来源:ActivityThread.java · performLaunchActivity。

activity = mInstrumentation.newActivity(
        cl, component.getClassName(), r.intent);

这里用 LoadedApk 提供的类加载器实例化 Activity。默认 AppComponentFactory 调用 cl.loadClass(className).newInstance()。需要由应用 DEX 查找新类时,查找会经 BaseDexClassLoader、DexPathList 和 DexFile.defineClassNative 接到 ART。已经加载的类可以复用。后面的 attach 接上 Context、Resources 与窗口关联。 AppComponentFactory 默认实现

接着 attach 建立 Context、Application、token、Intent、配置和 Window 等关联:

来源:ActivityThread.java · performLaunchActivity。

activity.attach(activityBaseContext, this, getInstrumentation(), r.token,
        r.ident, app, r.intent, r.activityInfo, title, r.parent,
        r.embeddedID, r.lastNonConfigurationInstances, config,
        r.referrer, r.voiceInteractor, window, r.activityConfigCallback,
        r.assistToken, r.shareableActivityToken, r.initialCallerInfoAccessToken);

构造与 attach 是不同动作。 只找到 newActivity,却没有解释 Context、token 和身份怎样关联,仍不能读通启动。

ActivityThread 把对象写入本地记录,再调用生命周期:

来源:ActivityThread.java · performLaunchActivity。

r.activity = activity;
if (r.isPersistable()) {
    mInstrumentation.callActivityOnCreate(activity, r.state, r.persistentState);
} else {
    mInstrumentation.callActivityOnCreate(activity, r.state);
}

Instrumentation.callActivityOnCreate 进入 Activity.performCreate 与应用覆盖的 onCreate。Framework 会检查是否调用 super;实例化、attach 或业务回调异常,走 Instrumentation 异常处理或 RuntimeException 失败路径。

分别观察 onResume 反馈与首帧显示

后续路径补齐 Start、Resume。ResumeActivityItem.execute 进入 handleResumeActivity,后者推进 performResumeActivity 并按状态处理窗口挂接;postExecute 还通知系统:

来源:ResumeActivityItem.java · postExecute。

ActivityClient.getInstance().activityResumed(getActivityToken(),
        client.isHandleSplashScreenExit(getActivityToken()));

activityResumed 是生命周期推进反馈,不是“画面已显示”的证明。 onResume 返回、窗口加入、首帧绘制、SurfaceFlinger 合成和显示有不同时间点。生命周期契约描述上层状态;下一章继续 ViewRootImpl、RenderThread 和 SurfaceFlinger。

图里有两条应用侧生命线。Binder 接收线程先入队 EXECUTE_TRANSACTION,主线程稍后取出消息,才会创建实例并推进生命周期。

Activity 生命周期事务从 ATMS 经 Binder 接收线程到宿主主线程

6.6 分清任务栈复用、实例重建与进程退出

再次打开页面,先分清几种情况

观察进程可能怎样Activity 可能怎样确认方式
再创建 Activity复用宿主新实例,执行 onCreatePID 相同,实例标识改变
栈顶 singleTop 接收新 Intent原进程继续存在原实例进入 onNewIntent同时比较 PID、实例、taskId
recreate 或配置重建通常复用宿主原实例销毁,新实例恢复新 onCreate 与 saved state
宿主被杀后重新进入新进程依系统保存信息重建PID 改变,原 Java 对象已不存在

“冷”“温”“热”会涉及不同保留状态。实验先精确写“进程不存在”“进程存在但新实例”“已有实例接收 Intent”,再比较时间;不只凭 am start 的 TotalTime 贴标签。

singleTop 的关键是满足复用条件

DetailActivity 从栈顶再次启动自身并带 FLAG_ACTIVITY_SINGLE_TOP。满足相应条件时,ActivityStarter.deliverNewIntent 交给已有记录:

来源:ActivityStarter.java · deliverNewIntent。

activity.deliverNewIntentLocked(mCallingUid, mStartActivity.intent, intentGrants,
        mStartActivity.launchedFromPackage, mStartActivity.mShareIdentity,

ActivityRecord 后续通过 NewIntentItem 等交付,在主线程调用已有实例的 onNewIntent。singleTop 不是同类 Activity 在系统中永久只有一个实例。 目标不在合适栈顶、Task 不同或 flags 组合变化,都可能创建新实例。任务与返回堆栈需要结合 Manifest launchMode 阅读。

本例 MainActivity 与 DetailActivity 跨进程却保持普通任务关系:ActivityTaskManager 管任务,AMS 管宿主,它们协作但不是同一组编号。

保存状态与正常销毁

示例把 onNewIntent 次数写入 Bundle,在重建时读回。Bundle 是少量可恢复 UI 状态,不是把整个 View 树、业务对象物理内存持久化。持续数据应使用合适的存储,状态 Bundle 也受 IPC 容量等约束。

正常 finish 或系统要求销毁时,销毁生命周期项、ActivityThread.handleDestroyActivity 与窗口清理协作释放实例。主线程移除本地记录、清理窗口/Context,反馈系统完成状态变更;是否保留任务、记录和待恢复信息取决于 finishing 等条件。

进程死亡走另一条清理路径

AMS 在 attach 时建立的死亡监听可收到 ApplicationThread Binder 死亡。AppDeathRecipient.binderDied 的入口:

来源:ActivityManagerService.java · AppDeathRecipient.binderDied。

synchronized (mGlobalLock) {
    appDiedLocked(mApp, mPid, mAppThread, true, null);
}

appDiedLocked 及后续处理会清理进程状态、任务侧关联、Service 连接、广播队列和 Provider 宿主关系。Kernel 回收线程、内存与文件资源,Binder Driver 随进程资源关闭清理引用并发送死亡通知;AMS 不会在另一个进程替旧 Activity 执行 Java onDestroy。

不要把 onDestroy 当作进程退出必执行的回调。 SIGKILL、崩溃或回收可能来不及运行它。重要数据与资源安全需要相应持久化、IPC 协议和系统生命周期保证,不能只依赖最后一条日志。

沿着一次打开走到这里,请求、宿主和实例已经各有位置。先把几次交接分清,再看 Service 多出来的连接。

开发者在桌面上整理信封与索引卡,追踪不同交接

6.7 Service 的启动、绑定、回调与销毁

绑定要交接两个对象。客户端先把连接回调交给系统,Service 随后发布业务接口,系统再通过回调把这个接口转交客户端。先记住这两条通道,再读 ServiceDispatcher 和 onBind 的源码。

Service 默认没有自己的工作线程

Service 是系统管理的组件,不是 Thread 的别名。onCreate、onStartCommand、onBind、onUnbind、onDestroy 默认在宿主主线程;本例远程 AIDL describe 在服务端 Binder 接收线程。耗时计算的执行器、取消和完成协议需要应用安排。

startService 建立 started 需求,bindService 建立连接,并在相应 flags 下要求存活。它们可以作用同一个 Service;不是每次请求都新建实例,也不是“绑定过就永不销毁”。

创建与 started 请求 怎样到达主线程

ContextImpl 请求经 IActivityManager 到 AMS,ActiveServices.startServiceLocked 解析检查,bringUpServiceLocked 选择宿主,realStartServiceLocked 调度。ApplicationThread.scheduleCreateService 的交接是:

来源:ActivityThread.java · ApplicationThread.scheduleCreateService。

sendMessage(H.CREATE_SERVICE, s);

主线程 handleCreateService 使用 ClassLoader 和 AppComponentFactory 创建:

来源:ActivityThread.java · handleCreateService。

service = packageInfo.getAppFactory()
        .instantiateService(cl, data.info.name, data.intent);
ContextImpl context = ContextImpl.getImpl(service
        .createServiceBaseContext(this, packageInfo));

attach 建立 Context、token、Application 与系统接口等关联;随后执行并保存:

来源:ActivityThread.java · handleCreateService。

service.onCreate();
mServicesData.put(data.token, data);
mServices.put(data.token, service);
try {
    ActivityManager.getService().serviceDoneExecuting(
            data.token, SERVICE_DONE_EXECUTING_ANON, 0, 0);
} catch (RemoteException e) {

ServiceRecord token 由系统管理,Java Service 由应用创建,mServices 用 token 保存本地实例。 serviceDoneExecuting 是阶段完成反馈,参与执行计数/超时,不表示 Service 已无存活需求。

started 请求经 scheduleServiceArgs / H.SERVICE_ARGS 到 handleServiceArgs,在同 token 找到实例后:

来源:ActivityThread.java · handleServiceArgs。

res = s.onStartCommand(data.args, data.flags, data.startId);

返回 START_NOT_STICKY、START_STICKY 等影响后续重启策略,不是远程业务返回。本例 START_NOT_STICKY 缩小自动重启干扰,但其他绑定理由仍可能使服务被需要。

ServiceConnection 先包装登记 再提交绑定

示例传入的 connection 是普通 Java ServiceConnection,不能直接成为其他进程调用的 Binder 接口。Activity 的 Context 委托最终到 ContextImpl;本例不带 Executor 的 bindService 重载选择应用主线程 Handler:

来源:ContextImpl.java · bindService。

return bindServiceCommon(service, conn, Integer.toUnsignedLong(flags), null,
        mMainThread.getHandler(), null, getUser());

bindServiceCommon 先通过当前包的 LoadedApk 包装连接。下面摘取的是 Handler 分支,其他重载可以选择 Executor:

来源:ContextImpl.java · bindServiceCommon。

sd = mPackageInfo.getServiceDispatcher(conn, getOuterContext(), handler, flags);

LoadedApk.getServiceDispatcherCommon 按 Context → ServiceConnection → ServiceDispatcher 查找登记。没有既有 dispatcher 时,Handler 分支创建:

来源:LoadedApk.java · getServiceDispatcherCommon。

sd = new ServiceDispatcher(c, context, handler, flags);

构造器把应用回调、Context 和 Handler 保存在客户端,同时创建另一个真正的 Binder 实体:

来源:LoadedApk.java · ServiceDispatcher。

mIServiceConnection = new InnerConnection(this);
mConnection = conn;
mContext = context;
mActivityThread = activityThread;

InnerConnection 继承 IServiceConnection.Stub,是客户端导出的连接通知入口;mConnection 保存的才是应用写的 ServiceConnection。 InnerConnection 内用弱引用找到 ServiceDispatcher,LoadedApk 则通过上述登记表保持 dispatcher。它们属于客户端进程,和服务端稍后 onBind 返回的业务 Stub 分开创建。

dispatcher 接着保存进登记表,并返回用于 IPC 的接口:

来源:LoadedApk.java · getServiceDispatcherCommon。

    map.put(c, sd);
} else {
    sd.validate(context, handler, executor);
}
return sd.getIServiceConnection();

getIServiceConnection 返回构造时创建的字段:

来源:LoadedApk.java · ServiceDispatcher.getIServiceConnection。

return mIServiceConnection;

这里的 sd 要区分两处变量:LoadedApk 中它是 ServiceDispatcher,ContextImpl 中接到的 sd 已是 IServiceConnection。bindServiceCommon 随后才把这个接口提交给 AMS:

来源:ContextImpl.java · bindServiceCommon。

int res = ActivityManager.getService().bindServiceInstance(
        mMainThread.getApplicationThread(), getActivityToken(), service,
        service.resolveTypeIfNeeded(getContentResolver()),
        sd, flags, instanceName, getOpPackageName(), user.getIdentifier());

本地登记发生在读取远端绑定结果之前。 所以不能只在 onServiceConnected 已发生、或 bind 返回 true 时才认为有清理责任;false、异常等路径仍需按本版契约处理已申请连接,详见本节后面的清理代码。

AMS.bindServiceInstance 经过身份、Intent 和实例名等检查,在全局锁下委托 ActiveServices:

来源:ActivityManagerService.java · bindServiceInstance。

return mServices.bindServiceLocked(caller, token, service, resolvedType, connection,
        flags, instanceName, isSdkSandboxService, sdkSandboxClientAppUid,
        sdkSandboxClientAppPackage, sdkSandboxClientApplicationThread,
        callingPackage, userId);

ActiveServices 为连接建立 ConnectionRecord,并按回调 Binder 关联到目标 Service 的连接集合:

来源:ActiveServices.java · bindServiceLocked。

ConnectionRecord c = new ConnectionRecord(b, activity,
        connection, flags, clientLabel, clientIntent,
        callerApp.uid, callerApp.processName, callingPackage, res.aliasComponent);

IBinder binder = connection.asBinder();
s.addConnection(binder, c);
b.connections.add(c);

ConnectionRecord 构造器保存收到的回调接口:

来源:ConnectionRecord.java · ConnectionRecord。

conn = _conn;

因此后面看到 c.conn.connected(...) 时,c.conn 就是这条登记链交给系统的 IServiceConnection 引用;它没有把客户端普通 Java connection 对象复制进 system_server。

绑定时交付一个业务 Binder

ActiveServices.requestServiceBindingLocked 要求宿主执行绑定:

来源:ActiveServices.java · requestServiceBindingLocked。

r.getHostProcess().getThread().scheduleBindService(r, b, b.intent.getIntent(),
        rebind, r.getHostProcess().getReportedProcState(),
        mBindServiceSeqCounter++);

应用入口再投递 BIND_SERVICE;主线程 handleBindService 调用:

来源:ActivityThread.java · handleBindService。

IBinder binder = s.onBind(data.intent);
ActivityManager.getService().publishService(
        data.token, data.bindToken, binder);

onBind 返回 Service 持有的业务 Binder,本例是 IComponentService.Stub。 系统保存引用,再向客户端原先提供的连接回调通知:

来源:ActiveServices.java · publishServiceLocked。

c.conn.connected(clientSideComponentName, serviceBinder, session,
        false);

回程先进入客户端导出的 InnerConnection.connected,由弱引用找到最初的 ServiceDispatcher:

来源:LoadedApk.java · InnerConnection.connected。

LoadedApk.ServiceDispatcher sd = mDispatcher.get();
if (sd != null) {
    sd.connected(name, service, binderSession, dead);
}

它把 name、service、session 和 dead 交给 dispatcher;这里的 service 是刚由系统转交的业务 Binder。ServiceDispatcher 普通 Handler 分发路径继续:

来源:LoadedApk.java · ServiceDispatcher.connected。

mActivityThread.post(new RunConnection(name, service, session, 0, dead));

随后主线程 onServiceConnected 得到 IBinder,经 Stub.asInterface 取得接口,示例再投递 worker 调用 describe。连接回调 Binder 与业务 Binder 是两个对象。 前者通知连接状态,后者提供业务方法,不把同步 reply 混进这两种回调。

顺着图中的回程找两次交接。AMS 通知的是客户端的连接回调,describe 调用的则是宿主的业务 Binder。解绑移除连接,started 状态仍单独管理。

Service 连接回调 Binder 与业务 Binder 的两条通路

宿主和接口已就绪时,绑定可以沿用已有实例或业务 Binder。连接通知先到客户端 Binder 线程,再由原 Handler 投递给主线程。

stop 与 unbind 为什么不能替代

ServiceRecord 按理由保存是否仍需要服务。本版判断包括:

来源:ServiceRecord.java · getNeededReasonsLocked。

if (isStartRequested()) {
    result |= NEEDED_BY_START;
}

// Is someone still bound to us keeping us running?
if (!knowConn) {
    hasConn = hasAutoCreateConnections();
}
if (hasConn) {
    result |= NEEDED_BY_AUTO_CREATE;
}

isNeededLocked 使用这些需求:

来源:ServiceRecord.java · isNeededLocked。

return getNeededReasonsLocked(knowConn, hasConn) != NEEDED_NONE;

先 start 再 bind,只 unbind 通常还剩 started 理由;先 stop 但有有效 auto-create 连接,也不意味着销毁。ActiveServices.bringDownServiceIfNeededLocked 还要判断是否正在启动等状态。

没有存活需求且进入正常停止调度后,主线程 handleStopService 包括:

来源:ActivityThread.java · handleStopService。

s.onDestroy();
s.detachAndCleanUp();
Context context = s.getBaseContext();
if (context instanceof ContextImpl) {
    final String who = s.getClassName();

它还清理 Context、等待相关 QueuedWork、上报完成。宿主直接死亡不保证运行这段 Java 代码。

失败与死亡后的清理责任

本固定版本 Context.bindService 明确要求:返回 true/false 都应释放连接,抛 SecurityException 时也应 unbind。示例调用前记录 bindAttempted,false 或异常立即 releaseBinding,正常连接则由用户解绑或 Activity.onDestroy 收尾;不以“收到 onServiceConnected”作为唯一标记。

bindAttempted = true;
try {
    if (!bindService(intent, connection, BIND_AUTO_CREATE)) {
        releaseBinding();
    }
} catch (RuntimeException error) {
    releaseBinding();
    // 教学摘要:完整示例同时记录错误,不在这里自动重试。
}

这是工程的教学摘要,intent、connection 是已有变量;完整输入与幂等释放在 MainActivity。releaseBinding 先清本地标记再 unbind,若失败发生在 dispatcher 建立前,捕获无登记的 IllegalArgumentException 并记录,不将它视作成功绑定。

onServiceDisconnected 通常表示意外断连,原登记可能仍存在并允许系统重连;onBindingDied 需要先清理旧绑定再重新绑定;onNullBinding 也要归还连接。RemoteException 只说明调用失败,不能证明远端没有副作用。本例 describe 只读,有副作用接口需要幂等与请求身份。

固定 Context 契约用于核对当前清理责任,绑定服务说明解释概念与整体生命周期。

6.8 BroadcastReceiver 的排队、分发与完成

发送有序广播时,发送方把 Intent 和最终结果接收者一起交给系统。目标接收者完成本轮处理后,队列才能按结果继续推进,最后通过原来的回调交还结果。

广播是通知队列 不是直接方法调用

sendBroadcast 发出 Intent,系统结合声明/动态注册、权限、用户、包和调度状态决定交付。方法返回不表示所有 onReceive 已结束,普通广播也不向发送方同步汇总业务结果。

当前源码使用 BroadcastController、BroadcastQueueImpl 和按进程组织的 BroadcastProcessQueue,计算何时可运行、冷启动和继续待投递项。源码旁的 BroadcastQueue.md说明当前模型;不以旧实现名 BroadcastQueueModernImpl 定位本工程。

接收方式实例来源冷启动与登记默认执行线程与收尾
Manifest 接收者ActivityThread 用 AppComponentFactory 在应用实例化满足系统条件时可启动宿主主线程 onReceive,返回后结束同步处理
动态接收者应用 new 并注册,ReceiverDispatcher 保存关联依活进程登记,死亡后消失默认主线程或指定 Handler,需 unregister

动态注册不是每次根据 Manifest 重新创建实例。导出 flags、隐式广播限制、缓存进程延迟、跨进程优先级规则会影响交付;示例用同应用显式目标和非导出动态注册缩小变量。官方广播说明

有序广播的结果接收者 怎样先交给系统

示例的 sendOrderedBroadcast 还传入一个最终 resultReceiver、main Handler 和初值 100。这个结果接收者在发送应用内创建,不是远端 DemoReceiver;发送前也需要先把普通 Java 对象包装成 IPC 接口。

ContextImpl.sendOrderedBroadcast 对应用包分支选择 scheduler;没有指定时用主线程 Handler,本例传入的 main 已经非空:

来源:ContextImpl.java · sendOrderedBroadcast。

if (scheduler == null) {
    scheduler = mMainThread.getHandler();
}
rd = mPackageInfo.getReceiverDispatcher(
    resultReceiver, getOuterContext(), scheduler,
    mMainThread.getInstrumentation(), false);

LoadedApk.getReceiverDispatcher 在需要创建时构造 ReceiverDispatcher:

来源:LoadedApk.java · getReceiverDispatcher。

rd = new ReceiverDispatcher(mActivityThread.getApplicationThread(), r, context,
        handler, instrumentation, registered);

构造器把结果接收对象与 Handler 保存下来,并创建 InnerReceiver:

来源:LoadedApk.java · ReceiverDispatcher。

mIIntentReceiver = new InnerReceiver(mAppThread, this, !registered);
mReceiver = receiver;
mContext = context;
mActivityThread = activityThread;

InnerReceiver 继承 IIntentReceiver.Stub,mReceiver 是原 resultReceiver,mActivityThread 是最终执行它的 Handler。 注意该调用的 registered=false:这不是一次 registerReceiver,不按动态订阅登记到 mReceivers 表,也不需要为最终结果额外调用 unregisterReceiver。InnerReceiver 在这个分支保留 dispatcher 的强引用:

来源:LoadedApk.java · InnerReceiver。

mDispatcher = new WeakReference<LoadedApk.ReceiverDispatcher>(rd);
mStrongRef = strong ? rd : null;

getReceiverDispatcher 返回对应接口:

来源:LoadedApk.java · getReceiverDispatcher。

rd.mForgotten = false;
return rd.getIIntentReceiver();

其 getter 返回前面创建的字段:

来源:LoadedApk.java · ReceiverDispatcher.getIIntentReceiver。

return mIIntentReceiver;

回到 ContextImpl,变量 rd 此时是 IIntentReceiver,不是 ReceiverDispatcher。它与初始结果和 ordered 标志一起提交:

来源:ContextImpl.java · sendOrderedBroadcast。

ActivityManager.getService().broadcastIntentWithFeature(
        mMainThread.getApplicationThread(), getAttributionTag(), intent, resolvedType,
        rd, initialCode, initialData, initialExtras, receiverPermissions,
        null /*excludedPermissions=*/, null, appOp, options, true, false, getUserId());

这里末尾的 true 是 ordered 参数;包装时的 false 则是 registered 参数,二者描述不同事情。AMS.broadcastIntentWithFeature 委托 BroadcastController,后者创建 BroadcastRecord 时保存 resultTo、resultCode、resultData 等:

来源:BroadcastController.java · broadcastIntentLockedTraced。

BroadcastRecord r = new BroadcastRecord(queue, intent, callerApp, callerPackage,
        callerFeatureId, callingPid, callingUid, callerInstantApp, resolvedType,
        requiredPermissions, excludedPermissions, excludedPackages, appOp, brOptions,
        receivers, resultToApp, resultTo, resultCode, resultData, resultExtras, ordered,
        sticky, false, userId, -1 /* originalStickyCallingUid */, realCallingUid,
        backgroundStartPrivileges, timeoutExempt, filterExtrasForReceiver,
        callerAppProcessState, mService.mPlatformCompat);

客户端的 resultReceiver → ReceiverDispatcher/InnerReceiver → IIntentReceiver rd → 系统 BroadcastRecord.resultTo,就是最终回调能够找到发起方的注册与保存桥梁。下面先沿 Manifest 接收者的正常处理往下读,完成后再回到同一份记录中的结果接口。

Manifest 广播从队列交给应用

scheduleReceiverColdLocked 在需要时请求宿主,之后走可派发的 warm 路径;这里的 warm 不是 Activity 性能分类中的“热启动”。dispatchReceivers 对 Manifest 接收者调用:

来源:BroadcastQueueImpl.java · dispatchReceivers。

thread.scheduleReceiver(receiverIntent, ((ResolveInfo) receiver).activityInfo,
        null, r.resultCode, r.resultData, r.resultExtras, r.ordered,
        assumeDelivered, r.userId,
        app.getReportedProcState(),
        r.shareIdentity ? r.callingUid : Process.INVALID_UID,
        r.shareIdentity ? r.callerPackage : null);

应用 ApplicationThread.scheduleReceiver 创建本次 ReceiverData,再投递主线程:

来源:ActivityThread.java · ApplicationThread.scheduleReceiver。

    ReceiverData r = new ReceiverData(intent, resultCode, data, extras,
            ordered, false, assumeDelivered, mAppThread.asBinder(), sendingUser,
            sendingUid, sendingPackage);
    r.info = info;
    if (DEBUG_STORE_ENABLED) {
        DebugStore.recordScheduleBroadcastReceive(System.identityHashCode(r), intent);
    }
    sendMessage(H.RECEIVER, r);
}

ReceiverData 保存本次 Intent、结果和身份,Receiver 实例稍后才创建。 主线程 handleReceiver 根据目标类名实例化:

来源:ActivityThread.java · handleReceiver。

receiver = packageInfo.getAppFactory()
        .instantiateReceiver(cl, data.info.name, data.intent);

随后关联本次 PendingResult 并执行:

来源:ActivityThread.java · handleReceiver。

receiver.setPendingResult(data);
receiver.onReceive(context.getReceiverRestrictedContext(),
        data.intent);

这是应用主线程中的本地 Java 调用。onReceive 做长时间 I/O 或等待网络会占用响应预算,不会因为名字叫 Receiver 就自动进入后台线程。

动态接收者走已有 ReceiverDispatcher

同一 dispatchReceivers 的动态分支:

来源:BroadcastQueueImpl.java · dispatchReceivers。

thread.scheduleRegisteredReceiver(
        ((BroadcastFilter) receiver).receiverList.receiver,
        receiverIntent, r.resultCode, r.resultData, r.resultExtras,
        r.ordered, r.initialSticky, assumeDelivered, r.userId,
        app.getReportedProcState(),
        r.shareIdentity ? r.callingUid : Process.INVALID_UID,

ApplicationThread 再调用对应 IIntentReceiver,LoadedApk.ReceiverDispatcher.performReceive 把 Args runnable 投递到注册的 Handler;Args 执行原 receiver.onReceive。它与 Manifest 的查类、实例化、H.RECEIVER 路径不同。

配套 MainActivity 在 onStart 注册、onStop 解除,API 33 及以上显式使用 RECEIVER_NOT_EXPORTED。页面停止后不保留无用订阅;进程死亡后内存中的动态注册也不再有效。重新进入页面需要重新建立登记。

finish 是异步接收的收尾

同步 onReceive 返回后,handleReceiver 检查 PendingResult:

来源:ActivityThread.java · handleReceiver。

if (receiver.getPendingResult() != null) {
    data.finish();
}

goAsync 会将 PendingResult 从 receiver 交给调用方;不再满足上述“receiver 仍持有结果”的条件时,框架不会替异步任务自动完成。应用需要在成功、失败、取消和提交被拒绝时处理它。下面是独立教学片段,不属于本章正在运行的设备代码:

final PendingResult pending = goAsync();
try {
    boundedExecutor.execute(() -> {
        try {
            // 教学注释:只执行有上界的短任务。
            handleSmallEvent();
        } finally {
            pending.finish();
        }
    });
} catch (java.util.concurrent.RejectedExecutionException error) {
    pending.finish();
}

boundedExecutor 是应用管理的有界执行器,handleSmallEvent 表示短任务。这个片段覆盖任务实际开始执行和提交抛拒绝异常两种情形。若任务可能静默丢弃,或在开始前被取消,还需由调用方接管 finish()。goAsync() 仍受广播执行时限约束,可靠的长任务应使用作业机制。

PendingResult 在需要报告的路径通过 IActivityManager.finishReceiver 回到系统;部分非阻塞广播采用 assume-delivered 策略,不能说任何广播都等待应用显式完成。本版队列对有序结果的处理:

来源:BroadcastQueueImpl.java · finishReceiverLocked。

if (r.ordered) {
    r.resultCode = resultCode;
    r.resultData = resultData;
    r.resultExtras = resultExtras;
    if (!r.isNoAbort()) {
        r.resultAbort = resultAbort;
    }
}

之后按结果、abort 和队列状态继续或跳过后续项。有序结果推进,不等于所有进程中的普通广播被全局串行化。 本例只有一个显式 Manifest 接收者和最终结果接收者,预期结果 100→101,用于理解完成反馈,不证明多个包之间的优先级排序。

有序结果回到最初的结果接收者

队列需要交付最终结果时,scheduleResultTo 取出前面登记的 r.resultTo,并通过发送方的 ApplicationThread 安排通知:

来源:BroadcastQueueImpl.java · scheduleResultTo。

thread.scheduleRegisteredReceiver(
        r.resultTo, r.intent,
        r.resultCode, r.resultData, r.resultExtras, false, r.initialSticky,
        assumeDelivered, r.userId,
        app.getReportedProcState(),
        r.shareIdentity ? r.callingUid : Process.INVALID_UID,

此处携带的是同一 IIntentReceiver 引用和队列累积的结果。 scheduleRegisteredReceiver 这个方法名不表示发送方调用过 registerReceiver;本例结果包装时仍是 registered=false。片段中结果接收调用的 ordered 实参也是 false,与最初发出有序广播时的 true 分属不同交付阶段。

发送应用收到通知后,沿 InnerReceiver → ReceiverDispatcher.performReceive → Args runnable → 原 scheduler Handler,最后执行最初 resultReceiver.onReceive。对象没有重新从 Manifest 创建;本例 main Handler 使最终结果日志在客户端主线程输出,读取 resultCode 101。这个接收路径与本节动态 ReceiverDispatcher 共用基础设施,但不建立动态订阅。

系统安排结果交付后清除自己的结果目标引用:

来源:BroadcastQueueImpl.java · scheduleResultTo。

r.resultTo = null;

这让系统不再为该记录保留结果接口;客户端已经投递的 runnable 仍按自己的持有关系执行,不能把清引用解释成最终回调已运行完。生命周期或进程故障导致未交付等分支,仍需按当前状态处理。

沿着 resultTo 看一去一回。发送时系统保存结果目标,目标接收者结束后队列才安排结果交付。使用 goAsync() 时,这份完成责任随 PendingResult 交给接手的代码。

有序广播从队列调度到 PendingResult 完成和最终结果通知

图聚焦需要完成反馈的路径,普通广播非阻塞策略与超时还有不同分支。完成是队列可继续的条件之一,不是所有广播固定毫秒内交付的承诺。

6.9 ContentProvider 从首次获取到查询和释放

第一次查一个尚未发布的 Provider,工作线程要先等到接口,才能发出真正的 query。结果回来后还有一份稳定引用随 Cursor 保留到关闭时。用“先等接口,再交查询,最后归还引用”跟下面的源码。

authority 定位服务 查询再走业务接口

content://com.example.componentsdemo.state/state 包含 authority 与路径。ContentResolver 获取 IContentProvider 后请求 query;权限、用户、同/跨进程影响拿到本地接口或远端代理。URI 不是 Java 内存地址,authority 也不等价于 ServiceManager 的服务名。

示例从 worker 查询 :components,用 try-with-resources 关闭 Cursor。若宿主未运行,获取会先创建它;若打开过 DetailActivity,Provider 可能早已安装。比较冷获取前先检查进程状态。

从公共 query 找到真正的 Resolver 接收者

示例的 getContentResolver().query(...) 并不是直接调用 ActivityThread。Activity 的 Context 委托最终到 ContextImpl;它在构造时创建具体 Resolver:

来源:ContextImpl.java · ContextImpl。

mContentResolver = new ApplicationContentResolver(this, mainThread);

ContextImpl.getContentResolver 返回保存的实例:

来源:ContextImpl.java · getContentResolver。

return mContentResolver;

这个实例的具体类型是 ContextImpl.ApplicationContentResolver,它继承 ContentResolver,并持有该进程的 ActivityThread。 因而同一次调用可以先执行基类公共 API,再动态分派到子类的获取方法;这里不是创建两个互不相关的 Resolver。

本例使用五参数 SQL 形式的 query,它先委托带 CancellationSignal 的重载;该重载把 selection、selectionArgs、sortOrder 组织成 Bundle,交给统一版本:

来源:ContentResolver.java · query。

Bundle queryArgs = createSqlQueryBundle(selection, selectionArgs, sortOrder);
return query(uri, projection, queryArgs, cancellationSignal);

统一 query 入口先获取临时 unstable Provider:

来源:ContentResolver.java · query。

IContentProvider unstableProvider = acquireUnstableProvider(uri);

这里调用的是基类 acquireUnstableProvider(Uri),它先检查 scheme,再取 authority,并委托接收 Context 和字符串的重载:

来源:ContentResolver.java · acquireUnstableProvider。

if (!SCHEME_CONTENT.equals(uri.getScheme())) {
    return null;
}
String auth = uri.getAuthority();
if (auth != null) {
    return acquireUnstableProvider(mContext, uri.getAuthority());
}
return null;

因为接收者实际是 ApplicationContentResolver,动态分派到它的实现,再进入 ActivityThread:

来源:ContextImpl.java · ApplicationContentResolver.acquireUnstableProvider。

return mMainThread.acquireProvider(c,
        ContentProvider.getAuthorityWithoutUserId(auth),
        resolveUserIdFromAuthority(auth), false);

此处最后一个形参名是 stable,传 false 表示本次获取 unstable 引用,写法是 stable=false。 该布尔量描述申请的引用类型,不描述服务端进程的运行稳定性。

userId 的解析入口是同一子类的 resolveUserIdFromAuthority:

来源:ContextImpl.java · ApplicationContentResolver.resolveUserIdFromAuthority。

return ContentProvider.getUserIdFromAuthority(auth, getUserId());
传给 ActivityThread 的参数从哪里得到本例含义
c / contextContentResolver 保存的 Context,经基类传入子类用于包身份等上下文,不是 URI 指向的 Provider 对象
authURI 的 authority,交接时由 getAuthorityWithoutUserId 去掉可能的用户前缀com.example.componentsdemo.state,不含 /state 路径
userIdgetUserIdFromAuthority(auth, getUserId())本例没有显式用户前缀,因此使用 Resolver 所属 Context 的用户
stableApplicationContentResolver 的对应获取方法显式传入首次 acquireUnstableProvider 为 false,后续稳定获取为 true

mMainThread 在这里保存的是 ActivityThread 对象引用,调用它的 acquireProvider 并没有投递到主线程;示例仍由原 worker 执行。现在才能把 URI、实际接收者和参数接到下一段的缓存/发布等待代码。

缓存未命中时,客户端在哪里等待

ActivityThread.acquireProvider 先 acquireExistingProvider。未找到可用记录后,取得按 authority/user 组织的 ProviderKey,再向 AMS 请求:

来源:ActivityThread.java · acquireProvider。

holder = ActivityManager.getService().getContentProvider(
        getApplicationThread(), c.getOpPackageName(), auth, userId, stable);
// If the returned holder is non-null but its provider is null and it's not

ContentProviderHelper 解析 ProviderInfo,检查权限,查找/建立 ContentProviderRecord 与连接,必要时启动宿主。本版应用调用方可能先收到 provider 为空的 holder,再在客户端等发布通知。 外部 shell 等 caller 为空的分支则可能在系统端等待,不能把 content query 当成与应用逐行一致的等待实现。

客户端需要等待时执行:

来源:ActivityThread.java · acquireProvider。

key.mLock.wait(ContentResolver.CONTENT_PROVIDER_READY_TIMEOUT_MILLIS);

这是请求线程对 ProviderKey 的等待,不是把 query 移到主线程。示例把获取/查询放到 worker,避免首次初始化阻塞 UI;缓存命中、已发布和超时都有各自分支。

Provider 为什么可能先于 Application.onCreate

宿主 handleBindApplication 先创建/准备 Application 对象,再在允许安装的分支调用:

来源:ActivityThread.java · handleBindApplication。

if (!data.restrictedBackupMode) {
    if (!ArrayUtils.isEmpty(data.providers)) {
        installContentProviders(app, data.providers);
    }
}

installContentProviders 进入本地 installProvider,通过 ClassLoader 与 AppComponentFactory 创建并取得接口:

来源:ActivityThread.java · installProvider。

localProvider = packageInfo.getAppFactory()
        .instantiateProvider(cl, info.name);
provider = localProvider.getIContentProvider();

之后建立 Context、权限与 authority 关联:

来源:ActivityThread.java · installProvider。

localProvider.attachInfo(c, info);

ContentProvider.attachInfo 的首次初始化分支最后调用:

来源:ContentProvider.java · attachInfo。

ContentProvider.this.onCreate();

Provider Java 实例与其 Transport 接口在宿主形成,getIContentProvider 交出通信入口;onCreate 在初始化主线程。 本地记录再按类名、authority、Binder 等保存;客户端拿到的是接口引用,不是整个对象堆的拷贝。

普通初始化路径中,Application 的业务回调在 Providers 安装之后:

来源:ActivityThread.java · handleBindApplication。

mInstrumentation.callApplicationOnCreate(app);

所以 Provider.onCreate 不应假设 Application.onCreate 已初始化全局单例。这里存在 restricted backup 等条件,不能扩大成所有特殊模式的无条件顺序。

发布通知怎样叫醒请求线程

ActivityThread 安装本地 Provider 后,经 AMS 发布列表:

来源:ActivityThread.java · installContentProviders。

ActivityManager.getService().publishContentProviders(
    getApplicationThread(), results);

系统把接口与宿主记录关联,并通知等待者:

来源:ContentProviderHelper.java · publishContentProviders。

dst.mProvider = src.provider;
dst.setProcess(r);
dst.notifyAll();
dst.onProviderPublishStatusLocked(true);

onProviderPublishStatusLocked 再经等待客户端的 ApplicationThread.notifyContentProviderPublishStatus 回传 holder。客户端 Binder 线程在 ProviderKey 锁内:

来源:ActivityThread.java · ApplicationThread.notifyContentProviderPublishStatus。

key.mHolder = holder;
key.mLock.notifyAll();

通知唤醒等待该 authority/user 的请求线程,不经 Handler 在主线程重做 query。 等待者取得 holder 后,installProvider 为远端引用建立本地记录与计数,acquireProvider 返回可用 IContentProvider。通知可能早于真正 wait,代码通过共享 key、锁和已发布检查处理这类竞态。

query 线程与 Cursor 所有权

ContentResolver.query 先取得 unstable Provider,再执行:

来源:ContentResolver.java · query。

qCursor = unstableProvider.query(mContext.getAttributionSource(), uri, projection,
        queryArgs, remoteCancellationSignal);

远端 Transport 检查权限、参数和身份后进入业务 query,通常在宿主 Binder 接收线程。相同进程的本地调用可直接在原请求线程执行,因此不能把所有 Provider 方法当成单线程串行。

跨进程 Cursor 也不是把任意 Java 实例直接复制到客户端;适配涉及 BulkCursor 接口、窗口与远端访问。本例 MatrixCursor 由内存数据生成,没有真实磁盘 I/O。成功路径还取得稳定引用并包装结果:

来源:ContentResolver.java · query。

final CursorWrapperInner wrapper = new CursorWrapperInner(qCursor, provider);
stableProvider = null;
qCursor = null;
return wrapper;

这里成功路径的 acquireProvider(uri) 再走同一个 ApplicationContentResolver,但这次调用稳定获取方法:

来源:ContextImpl.java · ApplicationContentResolver.acquireProvider。

return mMainThread.acquireProvider(context,
        ContentProvider.getAuthorityWithoutUserId(auth),
        resolveUserIdFromAuthority(auth), true);

接收者和 authority/userId 解析保持一致,最后一个 stable 参数变成 true。 它与前面临时 unstable 获取的 false 对应两种引用计数,不能理解成在跨进程途中把一个布尔字段自动翻转。

临时 unstable 引用在 finally 归还,稳定引用交由 CursorWrapperInner 管理。客户端关闭包装时:

来源:ContentResolver.java · CursorWrapperInner.close。

if (mProviderReleased.compareAndSet(false, true)) {
    ContentResolver.this.releaseProvider(mContentProvider);
}

关闭 Cursor 既释放结果资源,也是 Provider 引用归还的入口。 不关可能延长资源关联;归还也不保证宿主立即退出,引用可延迟清理,进程还可能有其他组件。

图里先看 ProviderKey 上的条件等待,再看成功查询后的两份引用。临时引用在 finally 归还,稳定引用由 Cursor 包装持有到关闭。

ContentProvider 冷获取、发布、远程查询与 Cursor 引用归还

缓存命中时可以直接取得接口。未发布分支允许通知先到,工作线程会复查条件,超时则按当前分支返回。

unstable 查询遇到远端死亡时,可报告死亡并重新获取稳定接口重试 query;稳定依赖的宿主死亡还可能使系统处理依赖客户端。ContentProviderClient 的 stable/unstable 选择、取消和写入副作用需要按契约设计,不能把 query 重试推广成所有写入均可安全重试。真实数据库、文件、FUSE 和块设备链在第十章继续。

6.10 把 Binder 唤醒和主线程执行连到一起

前面多次出现“经 Binder”“投递主线程”。现在把它们接成真实边界,避免把 Java → JNI → Native 误读成每层都换线程。

请求进入 Kernel 时 线程没有自动变成接收者

以 IActivityTaskManager 为例,生成代理和 BinderProxy 编码参数,经 JNI、BpBinder 到 IPCThreadState,Native 最终提交:

来源:IPCThreadState.cpp · talkWithDriver。

if (ioctl(mProcess->mDriverFD, BINDER_WRITE_READ, &bwr) >= 0)
    err = NO_ERROR;

ioctl 是当前线程向 Kernel 设备接口提交控制请求的系统调用,BINDER_WRITE_READ 交换协议命令。 它没有把当前 Java 栈搬到 system_server;系统服务由另一条接收并分派事务的线程执行,原同步调用线程可能在 Driver 中等回复。

驱动入队并唤醒接收线程

ACK 的 binder_proc_transaction 结合目标进程、oneway、冻结与线程状态处理事务。选到接收线程的分支,将工作项放进线程队列:

来源:binder.c · binder_proc_transaction。

binder_enqueue_thread_work_ilocked(thread, &t->work);

该函数在可唤醒分支调用:

来源:binder.c · binder_proc_transaction。

binder_wakeup_thread_ilocked(proc, thread, !oneway /* sync */);

没有具体可用线程时还可能进入进程 todo;同一 node 的单向事务也有独立串行条件。排队、唤醒、runnable、实际运行是不同阶段。 sched_wakeup 不能证明 onCreate 已执行。Kernel 摘录来自固定 C Binder,不据静态阅读宣称本轮运行设备已走过该分支。

接收循环回到 Java 再决定是否投递

libbinder 接收 BR_TRANSACTION,在 IPCThreadState.executeCommand 定位本地 Binder 并分派:

来源:IPCThreadState.cpp · executeCommand。

error = doTransactBinder(binder, tr.code, buffer, &reply, tr.flags);

Java Binder 对应的 JavaBBinderExt.onTransact 调用 Java 入口:

来源:android_util_Binder.cpp · JavaBBinderExt.onTransact。

jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact,
    code, reinterpret_cast<jlong>(&data), reinterpret_cast<jlong>(reply), flags);

Java Binder / 生成 Stub 再进入 ApplicationThread。JNI 桥接仍在当前接收线程;换到主线程由入口的 Handler/Executor 决定。 EXECUTE_TRANSACTION、CREATE_SERVICE、RECEIVER 是前面找到的交接点,Provider 远程 query 不自动套用同一路径。

主线程取到消息后才执行生命周期

主线程 Looper 从 MessageQueue 取得就绪消息,loopOnce 调用:

来源:Looper.java · loopOnce。

msg.target.dispatchMessage(msg);

Handler 分派到 ActivityThread.H,对应 case 再进 TransactionExecutor 或 handleCreateService。无就绪工作时可经 Native Looper、epoll/eventfd 等休眠和唤醒;Legacy/DeliQueue 是配置分支,不能画成连续经过两个队列。

Binder 接收线程把事务交给主线程消息队列,Looper 随后消费

图只描述需要投递主线程的调度。同步 Binder reply 依事务关系回到原线程;生命周期到达后还有主线程工作和状态上报。不能合成“Binder 回复就表示页面完成”。

6.11 用日志、dumpsys 与 Trace 对照四条链路

以下是可执行观察方案,本轮没有安装/运行示例,没有生成本章设备日志或 Trace。预期只说明要核对什么,执行后应另记设备、命令、退出码与实际证据。

先持续观察,再触发动作

打开 Host 终端 B。新终端不继承 A 的变量,独立选择同一 serial 并建日志目录,然后保持运行:

chapter6_top=/absolute/path/to/aosp
chapter6_adb="$chapter6_top/out/host/linux-x86/bin/adb"
"$chapter6_adb" devices -l
read -r -p '输入与终端 A 相同的 serial:' chapter6_serial
chapter6_logs=$(mktemp -d "$HOME/chapter6-logs.XXXXXX")
"$chapter6_adb" -s "$chapter6_serial" logcat -v threadtime \
  Chapter6:I ActivityTaskManager:I ActivityManager:I AndroidRuntime:E '*:S' \
  | tee "$chapter6_logs/components.log"

threadtime 与应用标记对照 PID/TID;日志级别和构建配置会影响输出,缺一条系统日志不证明函数没运行。设备或 adbd 重启后应重新打开监听,不以 wait-for-device 代替观察会话恢复。

终端 A 常用的只读查询:

"$chapter6_adb" -s "$chapter6_serial" shell pidof com.example.componentsdemo
"$chapter6_adb" -s "$chapter6_serial" shell pidof com.example.componentsdemo:components
"$chapter6_adb" -s "$chapter6_serial" shell dumpsys activity activities
"$chapter6_adb" -s "$chapter6_serial" shell dumpsys activity services com.example.componentsdemo
"$chapter6_adb" -s "$chapter6_serial" shell dumpsys activity providers
"$chapter6_adb" -s "$chapter6_serial" shell dumpsys activity broadcasts

pidof 无结果可能只是进程不存在。各 dumpsys 分别对应任务/Activity、Service 需求与连接、Provider 引用、广播队列,不用一份快照代替全部组件。先用普通设备权限观察,本章不要求改 adbd 状态。

Activity 做三组对照

操作顺序比较内容预期解释
只运行 Main,确认 remote 未存在,再开 DetailPID、Provider/App 初始化、Detail 实例与 taskId目标宿主冷创建,同进程 Provider 可先初始化
Detail finish 回 Main,再次打开remote PID 是否仍在、实例标识是否变化同进程可新建实例,finish 不等于杀进程
Detail 栈顶点 singleTop,再点 recreateonNewIntent、onCreate、saved state 与实例复用实例和原进程内重建不同

需要重置时,下面命令终止本示例所有进程/组件/连接并置 stopped 状态,只对专用实验包使用;重新打开 Main 后再触发下一轮。强制重置不能代替自然内存回收:

"$chapter6_adb" -s "$chapter6_serial" shell am force-stop com.example.componentsdemo
"$chapter6_adb" -s "$chapter6_serial" shell am start -W \
  -n com.example.componentsdemo/.MainActivity

Home 后从最近任务恢复可观察已有实例,但受任务保留、回收和 flags 影响。am start -W 的 Status、LaunchState、TotalTime/WaitTime 等按当前输出解释,不把等待时间当成 CPU Running 时间。

Service 按需求组合观察

在前台 Main 点击“绑定并请求 Service”,对照 onCreate/onBind、onServiceConnected 与 describe 的线程。解绑后用日志和 dumpsys 看正常收尾。

下一轮先 start,再 bind,随后只 unbind,预期 started 理由仍可保留;再 stop 才具备销毁条件。反过来先 stop 后 unbind 也分别记录。不要混淆客户端连接回调主线程、服务端生命周期主线程、服务端业务 Binder 线程。

启动来自可见 Activity,减少后台限制干扰,不表示可长期无限后台运行。前台服务类型、后台启动与 target SDK 约束另查。Service 概念

广播和 Provider 分开触发

普通 Manifest 广播看 remote PID、主线程 onReceive 与异步交付;有序广播看最终 resultCode=101;动态广播仅在 Main 的注册区间有效。不要从 shell 向未导出接收者发请求,再把权限失败写成队列丢失。

Provider 按钮看客户端 worker、Provider.onCreate 主线程、远程 query Binder 线程。开过 Detail 再查询属于已有宿主;看冷获取则重置后只开 Main,直接查询。Provider 未导出,外部 content query 与同 UID 应用内访问权限不同。MatrixCursor 没有磁盘数据链,不能据此声称存储驱动已验证。

按界面按钮找日志

点哪个按钮先找哪些 Chapter6 标记看哪一端
打开 remote Activityafter startActivity returned、DetailActivity.onCreate前者是调用端,后者是宿主主线程
绑定并请求 ServiceService.onBind、onServiceConnected、Service.describe依次辨认宿主主线程、客户端主线程(本例用默认 Handler)和宿主业务 Binder 线程
有序广播:记录完成结果ManifestReceiver.onReceive ordered=true、Ordered final code=101接收者主线程与发送方结果回调
工作线程查询 ProviderProvider.onCreate、Provider.query、Provider result pid=… tid=…result 消息体里的 PID/TID 来自 Cursor,logcat 行首仍是客户端工作线程

用 Trace 连接排队和执行

配置 第六章组件调度.pbtxt采集应用、am/wm、Binder 和调度。终端 A 按下面命令采 15 秒,期间在设备点一两个按钮;配置同时包含两个应用进程名:

chapter6_trace_id=$(mktemp -d "$chapter6_run/trace.XXXXXXXX") &&
chapter6_trace_tag=${chapter6_trace_id##*/} &&
chapter6_trace_config="/data/local/tmp/chapter6-$chapter6_trace_tag.pbtxt" &&
chapter6_trace_remote="/data/misc/perfetto-traces/chapter6-$chapter6_trace_tag.perfetto-trace" &&
chapter6_trace_local="$chapter6_trace_id/chapter6.perfetto-trace" &&
"$chapter6_adb" -s "$chapter6_serial" push \
  "$chapter6_notes/示例/追踪配置/第六章组件调度.pbtxt" "$chapter6_trace_config" &&
  "$chapter6_adb" -s "$chapter6_serial" shell perfetto --txt \
    -c "$chapter6_trace_config" -o "$chapter6_trace_remote" &&
  "$chapter6_adb" -s "$chapter6_serial" pull "$chapter6_trace_remote" "$chapter6_trace_local" &&
  test -s "$chapter6_trace_local"

Perfetto 在前台采集时操作设备。每轮用独立路径,推配置或采集失败就停止拉取。拉取后先确认本轮文件非空,再打开检查预期事件。权限或事件不支持时,从本轮错误入手。

在 Perfetto 按进程/线程找 Chapter6 标记,再看 Binder、主线程消息、sched_wakeup、sched_switch。先确认事件,再用 区间查询 SQL;字段和事件取决于采集及工具版本。

Events.mark slice 只包住短日志动作,不是整个生命周期或跨进程请求。 两标记的墙钟间隔、线程 Running、等待时间应分别计量,不把其 dur 当成完整 onCreate 成本。

结束时先从界面 stop/unbind 观察正常收尾。需移除示例时,"$chapter6_adb" -s "$chapter6_serial" uninstall com.example.componentsdemo 会删除此包及数据;不卸载别章示例或替换系统包。

6.12 遇到失败时怎样缩小范围

现象先区分的边界检查入口
ActivityNotFoundException 或启动拒绝解析、导出/权限、用户与后台策略Manifest、ComponentName、checkStartActivityResult、ActivityStarter 与系统日志
有 PID 却没 onCreateattach、应用初始化、事务与主线程ApplicationThread 状态、handleBindApplication 异常、EXECUTE_TRANSACTION、主线程阻塞
已 onResume 却没有画面生命周期与窗口/首帧Activity/Task、窗口可见性,再接 Graphics
bind true 却无回调请求接受与接口发布onCreate/onBind、publishService、连接投递、null binding、死亡
unbind 后仍有 Servicestarted 或其他 auto-create 连接ServiceRecord 需求、dumpsys services,组件销毁与 PID 退出分开
广播未立即到匹配、权限、注册区间与队列策略BroadcastController/Queue、stopped/缓存进程、receiver flags
goAsync 后后续项不进展PendingResult 是否完成执行器拒绝、失败、取消均要处理,不只看 onReceive 返回
首次 Provider 查询卡住宿主初始化、发布与等待ProviderKey、onCreate、发布通知/超时、应用初始化异常
查询成功但资源不归还Cursor / ContentProviderClient显式关闭、客户端计数与延迟移除,不以 UI 消失代替 close

这些排查入口来自源码。自己遇到问题时,记下复现步骤、证据、原因、修复和验证结果。

最后回到开头的两条日志。调用端的 after startActivity returned 记录请求返回,目标 PID 中的 DetailActivity.onCreate 记录宿主开始执行。要知道两者之间停在哪一步,再按进程报到、Binder 调度和主线程队列的顺序找证据。

回调异常、事务派发失败、广播超时、Provider 发布超时是不同路径。ANR 不等于 CPU 一定占满,应看哪条线程等什么、是否持锁或依赖其他进程,以及哪项状态触发超时。

从按钮下的一行调用走到这里,接下来可以拿着同一组 PID、TID、实例与接口去对照设备。等你把日志和系统状态逐项对上,最初那次点击的来路与去向,也就清楚了。

开发者把笔记中的观察点与手机上的回应逐一对照

附录 A|保存完整输入,再回到实验

对应 6.2 的构建与 6.11 的观察。将下面标题所示路径保存到 $chapter6_notes/示例/ 下;已有知识库文件时可以直接复制同名输入。Java/AIDL 都属于 src 树,生成的 Java 只进入 generated;独立脚本只读 AndroidManifest.xml 等输入,不需要 Soong 模板改名,走 Soong 时才把 Android.bp.example 改成 Android.bp。正文中的短源码用于理解每次交接;这里给出完整可复制文件,便于保存后回到实验。

Chapter6ComponentsDemo/Android.bp.example

android_app {
    name: "Chapter6ComponentsDemo",
    manifest: "AndroidManifest.xml",
    srcs: ["src/**/*.java", "src/**/*.aidl"],
    aidl: { local_include_dirs: ["src"] },
    sdk_version: "current",
    min_sdk_version: "28",
    target_sdk_version: "36",
    certificate: "testkey",
    optimize: { enabled: false },
}

Chapter6ComponentsDemo/AndroidManifest.xml

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.componentsdemo">
    <uses-sdk android:minSdkVersion="28" android:targetSdkVersion="36" />
    <application android:name=".DemoApplication" android:label="Components 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>
        <activity android:name=".DetailActivity" android:process=":components"
            android:exported="false" />
        <service android:name=".DemoService" android:process=":components"
            android:exported="false" />
        <receiver android:name=".DemoReceiver" android:process=":components"
            android:exported="false" />
        <provider android:name=".DemoProvider" android:process=":components"
            android:authorities="com.example.componentsdemo.state"
            android:exported="false" />
    </application>
</manifest>

Chapter6ComponentsDemo/src/com/example/componentsdemo/DemoApplication.java

package com.example.componentsdemo;

import android.app.Activity;
import android.app.Application;
import android.os.Bundle;

public final class DemoApplication extends Application {
    @Override public void onCreate() {
        super.onCreate();
        Events.mark("Application.onCreate process=" + getProcessName());
        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
            private void event(Activity a, String state) {
                Events.mark(a.getClass().getSimpleName() + "." + state
                        + " instance=" + System.identityHashCode(a) + " task=" + a.getTaskId());
            }
            public void onActivityCreated(Activity a, Bundle b) { event(a, "onCreate"); }
            public void onActivityStarted(Activity a) { event(a, "onStart"); }
            public void onActivityResumed(Activity a) { event(a, "onResume"); }
            public void onActivityPaused(Activity a) { event(a, "onPause"); }
            public void onActivityStopped(Activity a) { event(a, "onStop"); }
            public void onActivitySaveInstanceState(Activity a, Bundle b) {
                event(a, "onSaveInstanceState");
            }
            public void onActivityDestroyed(Activity a) { event(a, "onDestroy"); }
        });
    }
}

Chapter6ComponentsDemo/src/com/example/componentsdemo/DemoProvider.java

package com.example.componentsdemo;

import android.content.ContentProvider;
import android.content.ContentValues;
import android.database.Cursor;
import android.database.MatrixCursor;
import android.net.Uri;
import android.os.Process;

public final class DemoProvider extends ContentProvider {
    @Override public boolean onCreate() {
        Events.mark("Provider.onCreate");
        return true;
    }
    @Override public Cursor query(Uri uri, String[] projection, String selection,
            String[] selectionArgs, String sortOrder) {
        if (!"/state".equals(uri.getPath())) throw new IllegalArgumentException("Unknown URI");
        Events.mark("Provider.query");
        MatrixCursor rows = new MatrixCursor(new String[]{"_id", "pid", "tid", "value"});
        rows.addRow(new Object[]{1, Process.myPid(), Process.myTid(), "components-ready"});
        return rows;
    }
    @Override public String getType(Uri uri) { return "vnd.android.cursor.item/vnd.components.state"; }
    @Override public Uri insert(Uri u, ContentValues v) { throw new UnsupportedOperationException(); }
    @Override public int update(Uri u, ContentValues v, String s, String[] a) {
        throw new UnsupportedOperationException();
    }
    @Override public int delete(Uri u, String s, String[] a) {
        throw new UnsupportedOperationException();
    }
}

Chapter6ComponentsDemo/src/com/example/componentsdemo/DemoReceiver.java

package com.example.componentsdemo;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;

public final class DemoReceiver extends BroadcastReceiver {
    @Override public void onReceive(Context context, Intent intent) {
        Events.mark("ManifestReceiver.onReceive ordered=" + isOrderedBroadcast());
        if (isOrderedBroadcast()) {
            setResultCode(getResultCode() + 1);
            setResultData("manifest receiver completed");
        }
    }
}

Chapter6ComponentsDemo/src/com/example/componentsdemo/DemoService.java

package com.example.componentsdemo;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.os.Process;

public final class DemoService extends Service {
    private final IComponentService.Stub binder = new IComponentService.Stub() {
        @Override public String describe() {
            Events.mark("Service.describe");
            return "service pid=" + Process.myPid() + " tid=" + Process.myTid();
        }
    };
    @Override public void onCreate() {
        super.onCreate();
        Events.mark("Service.onCreate");
    }
    @Override public int onStartCommand(Intent intent, int flags, int startId) {
        Events.mark("Service.onStartCommand startId=" + startId);
        return START_NOT_STICKY;
    }
    @Override public IBinder onBind(Intent intent) {
        Events.mark("Service.onBind");
        return binder;
    }
    @Override public boolean onUnbind(Intent intent) {
        Events.mark("Service.onUnbind");
        return false;
    }
    @Override public void onDestroy() {
        Events.mark("Service.onDestroy");
        super.onDestroy();
    }
}

Chapter6ComponentsDemo/src/com/example/componentsdemo/DetailActivity.java

package com.example.componentsdemo;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;

public final class DetailActivity extends Activity {
    private int deliveries;
    private TextView status;
    @Override public void onCreate(Bundle state) {
        super.onCreate(state);
        deliveries = state == null ? 0 : state.getInt("deliveries");
        LinearLayout panel = new LinearLayout(this);
        panel.setOrientation(LinearLayout.VERTICAL);
        status = new TextView(this);
        panel.addView(status);
        Button again = new Button(this);
        again.setText("再次打开自身:singleTop");
        again.setOnClickListener(v -> startActivity(new Intent(this, DetailActivity.class)
                .addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)));
        panel.addView(again);
        Button recreate = new Button(this);
        recreate.setText("重建 Activity(进程继续存在)");
        recreate.setOnClickListener(v -> recreate());
        panel.addView(recreate);
        Button close = new Button(this);
        close.setText("finish 返回上个 Activity");
        close.setOnClickListener(v -> finish());
        panel.addView(close);
        setContentView(panel);
        update();
    }
    @Override protected void onNewIntent(Intent intent) {
        super.onNewIntent(intent);
        setIntent(intent);
        deliveries++;
        Events.mark("DetailActivity.onNewIntent instance=" + System.identityHashCode(this));
        update();
    }
    @Override protected void onSaveInstanceState(Bundle state) {
        state.putInt("deliveries", deliveries);
        super.onSaveInstanceState(state);
    }
    private void update() {
        status.setText("instance=" + System.identityHashCode(this) + " task=" + getTaskId()
                + " onNewIntent=" + deliveries);
    }
}

Chapter6ComponentsDemo/src/com/example/componentsdemo/Events.java

package com.example.componentsdemo;

import android.os.Process;
import android.os.SystemClock;
import android.os.Trace;
import android.util.Log;

final class Events {
    static final String TAG = "Chapter6";
    static void mark(String event) {
        String section = "Chapter6/" + event;
        Trace.beginSection(section.length() > 120 ? section.substring(0, 120) : section);
        try {
            Log.i(TAG, "uptime=" + SystemClock.uptimeMillis() + " pid=" + Process.myPid()
                    + " tid=" + Process.myTid() + " thread=" + Thread.currentThread().getName()
                    + " " + event);
        } finally {
            Trace.endSection();
        }
    }
    private Events() {}
}

Chapter6ComponentsDemo/src/com/example/componentsdemo/IComponentService.aidl

package com.example.componentsdemo;

interface IComponentService {
    String describe();
}

Chapter6ComponentsDemo/src/com/example/componentsdemo/MainActivity.java

package com.example.componentsdemo;

import android.app.Activity;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.ServiceConnection;
import android.database.Cursor;
import android.net.Uri;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.IBinder;
import android.os.Looper;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.ScrollView;
import android.widget.TextView;

public final class MainActivity extends Activity {
    private static final String ACTION = "com.example.componentsdemo.DYNAMIC";
    private final Handler main = new Handler(Looper.getMainLooper());
    private final ExecutorService worker = Executors.newSingleThreadExecutor();
    private volatile boolean closing;
    private boolean bindAttempted;
    private boolean receiverRegistered;
    private TextView status;
    private final BroadcastReceiver dynamicReceiver = new BroadcastReceiver() {
        @Override public void onReceive(Context c, Intent i) { show("DynamicReceiver.onReceive"); }
    };
    private final ServiceConnection connection = new ServiceConnection() {
        @Override public void onServiceConnected(ComponentName name, IBinder binder) {
            if (closing || !bindAttempted) return;
            show("onServiceConnected");
            IComponentService service = IComponentService.Stub.asInterface(binder);
            worker.execute(() -> {
                try { show(service.describe()); }
                catch (android.os.RemoteException e) { show("service request failed: " + e); }
            });
        }
        @Override public void onServiceDisconnected(ComponentName name) {
            show("onServiceDisconnected:连接仍登记,等待系统重连或手动解绑");
        }
        @Override public void onBindingDied(ComponentName name) {
            show("onBindingDied:先清理旧连接,再手动绑定");
            releaseBinding();
        }
        @Override public void onNullBinding(ComponentName name) {
            show("onNullBinding");
            releaseBinding();
        }
    };
    @Override public void onCreate(Bundle state) {
        super.onCreate(state);
        LinearLayout panel = new LinearLayout(this);
        panel.setOrientation(LinearLayout.VERTICAL);
        status = new TextView(this);
        panel.addView(status);
        add(panel, "打开 remote Activity", () -> {
            Events.mark("before startActivity");
            startActivity(new Intent(this, DetailActivity.class));
            Events.mark("after startActivity returned");
        });
        add(panel, "启动 Service(started 状态)", () -> {
            startService(new Intent(this, DemoService.class));
            show("startService submitted");
        });
        add(panel, "绑定并请求 Service", this::bind);
        add(panel, "解除绑定", this::releaseBinding);
        add(panel, "停止 Service 的 started 状态", () -> {
            boolean stopped = stopService(new Intent(this, DemoService.class));
            show("stopService result=" + stopped);
        });
        add(panel, "普通广播:manifest receiver", () -> sendBroadcast(
                new Intent(this, DemoReceiver.class).setAction("com.example.componentsdemo.EVENT")));
        add(panel, "有序广播:记录完成结果", () -> sendOrderedBroadcast(
                new Intent(this, DemoReceiver.class).setAction("com.example.componentsdemo.ORDERED"),
                null, new BroadcastReceiver() {
                    @Override public void onReceive(Context c, Intent i) {
                        show("Ordered final code=" + getResultCode() + " data=" + getResultData());
                    }
                }, main, 100, null, null));
        add(panel, "普通广播:dynamic receiver", () -> sendBroadcast(
                new Intent(ACTION).setPackage(getPackageName())));
        add(panel, "工作线程查询 Provider", () -> worker.execute(() -> {
            Uri uri = Uri.parse("content://com.example.componentsdemo.state/state");
            try (Cursor cursor = getContentResolver().query(uri, null, null, null, null)) {
                if (cursor != null && cursor.moveToFirst()) {
                    show("Provider result pid=" + cursor.getInt(1) + " tid=" + cursor.getInt(2));
                } else { show("Provider returned no rows"); }
            } catch (RuntimeException e) { show("Provider query failed: " + e); }
        }));
        ScrollView scroll = new ScrollView(this);
        scroll.addView(panel);
        setContentView(scroll);
    }
    @Override protected void onStart() {
        super.onStart();
        if (!receiverRegistered) {
            IntentFilter filter = new IntentFilter(ACTION);
            if (Build.VERSION.SDK_INT >= 33) {
                registerReceiver(dynamicReceiver, filter, Context.RECEIVER_NOT_EXPORTED);
            } else { registerReceiver(dynamicReceiver, filter); }
            receiverRegistered = true;
        }
    }
    @Override protected void onStop() {
        if (receiverRegistered) {
            unregisterReceiver(dynamicReceiver);
            receiverRegistered = false;
        }
        super.onStop();
    }
    private void bind() {
        if (closing || bindAttempted) return;
        bindAttempted = true;
        try {
            if (!bindService(new Intent(this, DemoService.class), connection, BIND_AUTO_CREATE)) {
                show("bindService returned false");
                releaseBinding();
            }
        } catch (RuntimeException e) {
            show("bindService failed: " + e);
            releaseBinding();
        }
    }
    private void releaseBinding() {
        if (!bindAttempted) return;
        bindAttempted = false;
        try { unbindService(connection); show("unbindService completed"); }
        catch (IllegalArgumentException e) { show("No dispatcher remained: " + e); }
    }
    private void add(LinearLayout panel, String title, Runnable action) {
        Button button = new Button(this);
        button.setText(title);
        button.setOnClickListener(v -> action.run());
        panel.addView(button);
    }
    private void show(String message) {
        Events.mark(message);
        main.post(() -> { if (!closing) status.setText(message); });
    }
    @Override protected void onDestroy() {
        closing = true;
        releaseBinding();
        worker.shutdown();
        super.onDestroy();
    }
}

构建示例APK.py

#!/usr/bin/env python3
"""用已构建的 AOSP Host 工具打包第六章无资源组件示例,不修改系统镜像。"""
import argparse
import json
from pathlib import Path
import subprocess
import zipfile


def main():
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--aosp-top", type=Path, required=True)
    parser.add_argument("--module", type=Path, required=True)
    parser.add_argument("--name", required=True)
    parser.add_argument("--out", type=Path, required=True)
    parser.add_argument("--target-sdk", default="36")
    args = parser.parse_args()
    top = args.aosp_top.resolve()
    module = args.module.resolve()
    output = args.out.resolve()
    if not (module / "AndroidManifest.xml").is_file():
        parser.error("module 需要指向包含 AndroidManifest.xml 的示例目录")
    if output.exists() and any(output.iterdir()):
        parser.error("out 目录需为空;请为本轮构建使用新目录")
    output.mkdir(parents=True, exist_ok=True)
    host = top / "out/host/linux-x86"
    sdk = top / "prebuilts/sdk/current/public/android.jar"
    java = top / "prebuilts/jdk/jdk21/linux-x86/bin/java"
    javac = java.with_name("javac")
    jar = java.with_name("jar")
    required = [host / "bin/aidl", host / "bin/aapt2", host / "framework/d8.jar",
                host / "framework/signapk.jar", sdk, java, javac, jar,
                host / "lib64/libconscrypt_openjdk_jni.so",
                top / "build/make/target/product/security/testkey.x509.pem",
                top / "build/make/target/product/security/testkey.pk8"]
    missing = [str(path) for path in required if not path.is_file()]
    if missing:
        parser.error("缺少已构建的 Host 工具或材料:\n" + "\n".join(missing))

    commands = []

    def run(command):
        command = [str(value) for value in command]
        subprocess.run(command, check=True, cwd=top)
        commands.append(command)

    generated, classes, dex = [output / name for name in ("generated", "classes", "dex")]
    for directory in (generated, classes, dex):
        directory.mkdir()
    for aidl in sorted((module / "src").rglob("*.aidl")):
        run([host / "bin/aidl", "--lang=java", "--min_sdk_version=28",
             "-I", module / "src", "-o", generated, aidl])
    sources = sorted((module / "src").rglob("*.java")) + sorted(generated.rglob("*.java"))
    run([javac, "--release", "17", "-cp", sdk, "-d", classes, *sources])
    run([jar, "cf", output / "classes.jar", "-C", classes, "."])
    run([java, "-cp", host / "framework/d8.jar", "com.android.tools.r8.D8",
         "--lib", sdk, "--min-api", "28", "--output", dex, output / "classes.jar"])
    run([host / "bin/aapt2", "link", "-I", sdk, "--manifest", module / "AndroidManifest.xml",
         "--min-sdk-version", "28", "--target-sdk-version", args.target_sdk,
         "-o", output / "unsigned.apk"])
    with zipfile.ZipFile(output / "unsigned.apk", "a", zipfile.ZIP_DEFLATED) as archive:
        for path in sorted(dex.glob("*.dex")):
            archive.write(path, path.name)
    apk = output / (args.name + ".apk")
    run([java, "-Djava.library.path=" + str(host / "lib64"), "-jar",
         host / "framework/signapk.jar",
         top / "build/make/target/product/security/testkey.x509.pem",
         top / "build/make/target/product/security/testkey.pk8", output / "unsigned.apk", apk])
    (output / "build-commands.json").write_text(json.dumps(commands, ensure_ascii=False, indent=2))
    print(apk)


if __name__ == "__main__":
    main()

追踪配置/第六章组件调度.pbtxt

buffers { size_kb: 32768 fill_policy: RING_BUFFER }
duration_ms: 15000
data_sources {
  config {
    name: "linux.ftrace"
    ftrace_config {
      ftrace_events: "sched/sched_switch"
      ftrace_events: "sched/sched_wakeup"
      ftrace_events: "sched/sched_waking"
      ftrace_events: "sched/sched_process_fork"
      ftrace_events: "sched/sched_process_exit"
      ftrace_events: "binder/binder_transaction"
      ftrace_events: "binder/binder_transaction_received"
      atrace_categories: "am"
      atrace_categories: "wm"
      atrace_categories: "view"
      atrace_apps: "com.example.componentsdemo"
      atrace_apps: "com.example.componentsdemo:components"
    }
  }
}
data_sources {
  config {
    name: "linux.process_stats"
    process_stats_config { scan_all_processes_on_start: true }
  }
}

追踪配置/查询组件区间.sql

-- 在已加载本章 Trace 的 Trace Processor 中运行。
-- dur 只覆盖 Events.mark 的短日志动作,不是整个组件回调的成本。
SELECT p.name AS process_name, p.pid, t.name AS thread_name, t.tid,
       s.name, s.ts / 1e6 AS start_ms, s.dur / 1e6 AS marker_duration_ms
FROM slice s
JOIN thread_track tt ON tt.id = s.track_id
JOIN thread t ON t.utid = tt.utid
LEFT JOIN process p ON p.upid = t.upid
WHERE s.name GLOB 'Chapter6/*'
ORDER BY s.ts;

参考资料

AOSP 软件栈与平台分层

ZygoteServer.java · multipleForksOK

Zygote.java · forkSimpleApps

ZygoteCommandBuffer Native