在示例应用里点“打开 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 / Task | system_server 的窗口与任务管理结构 | 管理任务关系、目标状态与 token | 同一任务中的两个 Activity |
| ProcessRecord / WindowProcessController | system_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 平台分层,带进程名的框用来区分执行归属。同一个应用进程既有应用代码,也运行 Framework 代码。Service 或 Provider 的业务接口就绪后,后续业务调用直达宿主的 Binder 端点。图把这些跨进程线所共有的 JNI、libbinder 和 Binder 驱动折叠起来,内核带单独标出事务入队和唤醒。
冷建进程走琥珀色通道。ProcessList 通过 Unix socket 请求 Zygote,Zygote 的原生实现经 Bionic 进入 Linux 任务创建路径。本章调度不经过专属 HAL。显示首帧和真实文件 I/O 分别留到 Graphics 与 Storage 章节。
用一张总时序对照四种交接
先看第一段。ATMS 接受请求后,宿主还要完成进程创建、报到和主线程接单。后面三段沿用同一套生命线,分别画一次 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 复用和进程复用是不同判断。没有 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 创建任务:
p = copy_process(NULL, trace, NUMA_NO_NODE, args);
add_latent_entropy();
准备完成后使新任务可被调度:
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,主线程稍后取出消息,才会创建实例并推进生命周期。
6.6 分清任务栈复用、实例重建与进程退出
再次打开页面,先分清几种情况
| 观察 | 进程可能怎样 | Activity 可能怎样 | 确认方式 |
|---|---|---|---|
| 再创建 Activity | 复用宿主 | 新实例,执行 onCreate | PID 相同,实例标识改变 |
| 栈顶 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 状态仍单独管理。
宿主和接口已就绪时,绑定可以沿用已有实例或业务 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 交给接手的代码。
图聚焦需要完成反馈的路径,普通广播非阻塞策略与超时还有不同分支。完成是队列可继续的条件之一,不是所有广播固定毫秒内交付的承诺。
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 / context | ContentResolver 保存的 Context,经基类传入子类 | 用于包身份等上下文,不是 URI 指向的 Provider 对象 |
| auth | URI 的 authority,交接时由 getAuthorityWithoutUserId 去掉可能的用户前缀 | com.example.componentsdemo.state,不含 /state 路径 |
| userId | getUserIdFromAuthority(auth, getUserId()) | 本例没有显式用户前缀,因此使用 Resolver 所属 Context 的用户 |
| stable | ApplicationContentResolver 的对应获取方法显式传入 | 首次 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 包装持有到关闭。
缓存命中时可以直接取得接口。未发布分支允许通知先到,工作线程会复查条件,超时则按当前分支返回。
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 调用:
msg.target.dispatchMessage(msg);
Handler 分派到 ActivityThread.H,对应 case 再进 TransactionExecutor 或 handleCreateService。无就绪工作时可经 Native Looper、epoll/eventfd 等休眠和唤醒;Legacy/DeliQueue 是配置分支,不能画成连续经过两个队列。
图只描述需要投递主线程的调度。同步 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 未存在,再开 Detail | PID、Provider/App 初始化、Detail 实例与 taskId | 目标宿主冷创建,同进程 Provider 可先初始化 |
| Detail finish 回 Main,再次打开 | remote PID 是否仍在、实例标识是否变化 | 同进程可新建实例,finish 不等于杀进程 |
| Detail 栈顶点 singleTop,再点 recreate | onNewIntent、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 Activity | after startActivity returned、DetailActivity.onCreate | 前者是调用端,后者是宿主主线程 |
| 绑定并请求 Service | Service.onBind、onServiceConnected、Service.describe | 依次辨认宿主主线程、客户端主线程(本例用默认 Handler)和宿主业务 Binder 线程 |
| 有序广播:记录完成结果 | ManifestReceiver.onReceive ordered=true、Ordered final code=101 | 接收者主线程与发送方结果回调 |
| 工作线程查询 Provider | Provider.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 却没 onCreate | attach、应用初始化、事务与主线程 | ApplicationThread 状态、handleBindApplication 异常、EXECUTE_TRANSACTION、主线程阻塞 |
| 已 onResume 却没有画面 | 生命周期与窗口/首帧 | Activity/Task、窗口可见性,再接 Graphics |
| bind true 却无回调 | 请求接受与接口发布 | onCreate/onBind、publishService、连接投递、null binding、死亡 |
| unbind 后仍有 Service | started 或其他 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;