Android源码第五章:PackageManager 与 Resources——沿着一个 APK 走通安装与资源读取

34 阅读44分钟

用同一把密钥签出的 v2 更新应用后,日志里的英文资源值变了,SharedPreferences 里仍留着 v1 写下的标记。接着用另一把密钥签出的 v3 尝试更新,系统拒绝了它。一个 APK 从文件变成可启动的应用,究竟要通过哪些检查?应用启动后,一行 getString(R.string.message) 又从哪里拿到那段文字?

开发者面对一个尚未安装的应用包

本章跟着同一个示例 APK 走三段路。先用 AAPT2 把资源编进 APK,再看 Android 怎样安装这个包、登记它的路径,最后进入应用进程,跟着一个资源 ID 找到那行英文。读到文件映射时,再用历史实验的 Emulator 追到 ext4 和 VirtIO block。

5.1 准备设备并认识 APK 与核心角色

先确认沿用的实验环境

需要第一章的 Linux x86_64 Host、已构建的 AOSP Host 工具与可连接的 Android 设备。示例使用公共 SDK,不需要修改 Framework 或完整编译系统。底层 sysfs、strace 与部分 Overlay 排查使用 userdebug Emulator 的 adb root;普通安装、应用日志与限定符实验不要求 root。

在 Host 的 Bash 终端定义路径和设备,后面的命令复用这些变量。把这个窗口称为终端 A;需要并行追踪时再打开终端 B,B 复用 A 的路径与临时目录,不能重新创建另一份 chapter5_run:

chapter5_top="$HOME/aosp"
chapter5_notes="$chapter5_top/Android源码学习笔记/章节学习/第五章-PackageManager与Resources"
chapter5_run=$(mktemp -d "$HOME/aosp-chapter5.XXXXXX")
chapter5_adb="$chapter5_top/out/host/linux-x86/bin/adb"
chapter5_aapt2="$chapter5_top/out/host/linux-x86/bin/aapt2"
"$chapter5_adb" devices -l
read -r -p '输入本次设备 serial:' chapter5_serial
"$chapter5_adb" -s "$chapter5_serial" shell getprop sys.boot_completed
"$chapter5_adb" -s "$chapter5_serial" shell getprop ro.build.fingerprint
"$chapter5_adb" -s "$chapter5_serial" shell uname -a
chapter5_user=$("$chapter5_adb" -s "$chapter5_serial" shell am get-current-user | tr -d '\r')
printf 'current user=%s\n' "$chapter5_user"
test "$chapter5_user" = 0

预期 boot_completed 为 1,能够取得 fingerprint 与 Kernel 版本,并且 current user 为 0。本章安装、Overlay 和 Activity 采集统一以用户 0 为前提;若最后一条检查失败,停止本章步骤,先选择已解锁的用户 0 实验设备,不要混用不同用户的安装与运行结果。应成功的步骤若失败,先停止并排查再继续;5.11 故意构造的失败安装另按其判据判断。设备不可用时回到第一章运行步骤。本章操作限定在示例包 com.example.pmresdemo 与它的 Overlay,不要把实验包名替换成日常使用的应用。

APK 里面有哪些不同性质的数据

APK 是有特定结构和签名规则的 ZIP 容器。安装不会简单地把所有内容解压到一个目录,再让每次 API 调用逐文件寻找。

内容它是什么谁使用
AndroidManifest.xml构建后通常是二进制 XML,声明包、组件、SDK 与权限等安装解析器、组件管理与相关服务
classes.dexDEX 字节码,可能有多个文件ART 类加载、解释、JIT/AOT 等执行机制
resources.arsc本示例的二进制资源表,保存资源标识、配置、值与文件路径等libandroidfw 资源选择与解析
res/ 下的文件编译后的 XML、图片、raw 文件等Resources、AssetManager 与相应解码器
assets/按路径访问的应用素材,不生成每项 R 标识符AssetManager.open 等
lib/ABI/可选 Native 库安装策略与动态链接器;不是每个 APK 都有
签名相关数据用于验证 APK 内容及签名身份,具体位置取决于签名方案包校验与更新兼容检查

R.string.message 是资源标识,不是字符串本身,也不是文件偏移。 常见资源 ID 可按 0xPPTTEEEE 理解:package、type、entry。具体数值由构建与加载规则决定;示例中看到的 0x7f... 不能当作所有 APK 的永恒固定值,更不要跨独立构建持久化这些数值。

名字相近的组件分别做什么

名称所在位置与职责容易混淆的地方
PackageManager应用侧的 Java API,查询包、组件与相关信息它不是负责所有安装步骤的单一对象
PackageInstaller安装会话 API,创建 Session、写入、提交并接收结果一个 Session 不等于一个已安装包
PackageManagerServicesystem_server 中的包管理服务,协调包状态、安装校验和查询当前实现还分散在多个 Helper、Session 与 Computer 类中
Installersystem_server 中通往 installd 的 Java 包装不是安装器界面,也不是 PackageInstaller
installd独立 Native 进程,完成受控的数据目录、权限和相关文件操作不能把整个 APK 安装都归为“installd 拷贝文件”
ART Service / artdART Service 在 system_server 中管理 dexopt,artd 是独立 Native 服务不应照搬旧版本“所有 dexopt 都由 installd 做”的结论
Resources / ResourcesImpl应用进程中的资源 API 与实现状态读取本应用字符串通常不需要向 PackageManagerService 请求字符串
AssetManager / ApkAssets管理资源来源、配置和 APK 资源载入,连接 Native libandroidfw与名称相似的 ActivityManager 没有从属关系
AAPT2Host 构建工具,编译、链接与打包资源不在设备上替应用执行 getString

5.2 从整体架构看 APK 怎样连接构建、安装与运行

Android 的哪些模块共同处理一个 APK

Host 上的 AAPT2 负责资源构建,设备上的包管理服务负责安装和包状态,应用进程里的 Resources 负责读值。它们共享的关键产物是 APK。安装完成后,包管理服务登记代码路径,随后启动应用时,应用拿着资源路径建立自己的查询环境。

Android 包与资源整体架构

图中的设备部分沿用 AOSP 架构概览 的软件栈。横向层级表示模块在 Android 中的位置,框内标明进程归属。软件层级和进程归属分开看。 Resources 和 AssetManager 属于 Android Framework,在应用进程运行。PackageManagerService 与 OverlayManagerService 属于系统服务,运行于 system_server。installd、artd 和 idmap2d 则是独立的 Native 服务进程。Host 工具与 Emulator 后端均画在设备软件栈外。

读图时区分三条通道。Binder 连接需要跨进程的包管理和 Native 服务。资源查询经 JNI 进入同一应用进程里的 libandroidfw。安装写入与按需读取通过文件接口进入 Kernel。HAL 仍是 Android 软件栈的一层,这里所选的普通安装和读取路径没有专属 HAL 调用。

一张时序图串起构建、安装和读值

顺着图往下读,注意每段交付了什么。Host 交出签名 APK,Session 提交后由 Handler 等执行者推进安装,最终状态通过回调交还。实验随后单独启动应用,ApplicationInfo 带着路径跨进程传给应用。包查询可能跨 Binder,已加载资源上的 getString 在应用进程内完成。

从 AAPT2 构建、Session 安装到应用读取资源的全章时序

如果目标页已经就绪,这次读值无需为它等待新的设备读取。需要补齐数据时,内核可能等待已有 I/O,也可能发起新的读取。图中的 ext4 和块设备路径对应本次 Emulator。Overlay 是后续可选实验,图中单列它如何更新资源来源,再由应用重新取值。

用目录把职责落到源码上

目录本章关键入口
frameworks/base/tools/aapt2cmd/Compile.cpp、cmd/Link.cpp,资源编译和链接
frameworks/base/core/java/android/content/pmPackageInstaller、PackageManager,应用 API
frameworks/base/services/core/java/com/android/server/pmPackageInstallerSession、InstallingSession、InstallPackageHelper、ComputerEngine
frameworks/native/cmds/installdInstalldNativeService.cpp,数据目录等 Native 操作
art/libartserviceArtManagerLocal、Dexopter 与 artd 的衔接
frameworks/base/core/java/android/appLoadedApk、ResourcesManager,资源路径与缓存
frameworks/base/core/java/android/content/resResources、ResourcesImpl、AssetManager、ApkAssets
frameworks/base/core/jni 与 libs/androidfwJava/Native 桥接、AssetManager2、资源表和 ZIP 内文件读取
system/incremental_delivery、system/libbase本基线资源文件映射使用的 IncFsFileMap 与 MappedFile
匹配 Kernel 的 mm、fs、drivers/block文件映射、页缓存、ext4 与 VirtIO block

本基线使用 IncFsFileMap 包装常规 APK 的映射,不代表当前安装一定采用 Incremental FS。具体文件系统仍以挂载点和设备证据为准。

5.3 用 AAPT2 构建一个可观察的示例

先拿到完整工程

基础示例与源码包包含一个 Activity、四组字符串、raw 文件、两种压缩策略的 assets,以及允许实验 Overlay 的声明。Overlay 工程与源码包另外维护。

跟做时,从第五章完整学习笔记的 示例/ 目录取得基础工程 Chapter5PackageResourcesDemo、Chapter5MessageOverlay、构建示例APK.py、运行并采集.py 和 追踪配置/。下文用独立构建脚本生成 APK,再通过同一个示例核对安装状态与资源值。

基础 Manifest:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.pmresdemo" android:versionCode="1" android:versionName="1">
    <uses-sdk android:minSdkVersion="28" />
    <application android:label="@string/app_name" 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>
    </application>
</manifest>

四组字符串分别位于 res/values、res/values-en、res/values-zh、res/values-night。基础目录至少提供默认值,其他目录只覆写需要变化的资源:

<!-- res/values/strings.xml -->
<resources>
    <string name="app_name">Package Resources Demo</string>
    <string name="message">Base resource</string>
    <string name="message_alias">@string/message</string>
</resources>
<!-- res/values-en/strings.xml -->
<resources><string name="message">English resource</string></resources>
<!-- res/values-zh/strings.xml -->
<resources><string name="message">中文资源</string></resources>
<!-- res/values-night/strings.xml -->
<resources><string name="message">Night resource</string></resources>

默认资源中的 message_alias 引用 message,让后面能直接观察 TYPE_REFERENCE 与最终字符串的区别。

res/raw/payload.txt 由 R.raw.payload 访问;assets/compressed.txt 与 assets/mapped.bin 则按路径访问。构建时对 bin 使用 -0 bin,让该扩展名的 ZIP 条目保持未压缩。不要把扩展名本身当成是否压缩的证明,稍后检查最终 APK。

示例先观察四件事

配套工程里的 MainActivity.java 把文件读取放在 chapter5-reader 工作线程。构建前先看这四个观察点,运行后可按日志标签核对。

方法观察内容日志判据
inspectPackage版本、UID、代码与数据路径;首次保存数据标记PACKAGE、STATE
inspectResources英文、中文、夜间候选与引用资源RESOURCE、REFERENCE
inspectFilesraw、压缩与未压缩 assets;openFd 的边界RAW、ASSET、OPEN_FD
inspectMappings当前进程的 APK 映射MAP

createConfigurationContext 只创建本实验的配置上下文,不改变整台设备的语言。每次运行的日志带 run=本轮标识;最后的 DONE 表示整组完成,ERROR 表示本次未完成。5.4 的采集脚本为每轮生成新标识,避免旧日志干扰判断。

AAPT2 的 compile 与 link 为什么分开

AAPT2 官方用法可与下列固定实现对照;官方文档随平台维护,本章调用与产物以已列基线和实物为准。

AAPT2 compile、link 与 DEX 签名构建流程

compile 主要处理单个输入,不具备整个应用最终资源集合的全部上下文;link 才能把资源表、依赖、Manifest 和引用关系放在一起解决。XML 中的 @string/message 因此能变成运行时可定位的标识;R.java 也在这个阶段生成。

Host 的基础操作形态如下,输出只写入本轮临时目录:

"$chapter5_aapt2" compile \
  --dir "$chapter5_notes/示例/Chapter5PackageResourcesDemo/res" \
  -o "$chapter5_run/compiled.zip"
"$chapter5_aapt2" link \
  -I "$chapter5_top/prebuilts/sdk/current/public/android.jar" \
  --manifest "$chapter5_notes/示例/Chapter5PackageResourcesDemo/AndroidManifest.xml" \
  --java "$chapter5_run/generated" --min-sdk-version 28 --target-sdk-version 36 \
  -A "$chapter5_notes/示例/Chapter5PackageResourcesDemo/assets" -0 bin \
  -o "$chapter5_run/resources-only.apk" "$chapter5_run/compiled.zip"

预期得到 compiled.zip、资源 APK 和 generated 目录中的 R.java。此时还没有把 Activity 的 DEX 和签名组合进去,不能把 resources-only.apk 当作可运行成品。完整脚本按相同顺序继续 javac、D8、添加 DEX 和签名。

源码上,Compile.cpp 根据资源目录和扩展名选择编译器:

来源:Compile.cpp · int Compile(IAaptContext* context, io::IFileCollection* inputs, IArchiveWriter* output_writer,,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

auto compile_func = &CompileFile;
if (path_data.resource_dir == "values" && path_data.extension == "xml") {
  compile_func = &CompileTable;
  // We use a different extension (not necessary anymore, but avoids altering the existing
  // build system logic).
  path_data.extension = "arsc";

values XML 进入 CompileTable,普通文件、XML 与图片另有分支。 编译结果并非简单复制原 XML。Link.cpp 的 Run 再调用引用链接器:

来源:Link.cpp · int Run(const std::vector<std::string>& input_files) {,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

ReferenceLinker linker;
if (!options_.merge_only && !linker.Consume(context_, &final_table_)) {
  context_->GetDiagnostics()->Error(android::DiagMessage() << "failed linking references");
  return 1;
}

ReferenceLinker 在合并后的资源表上解析引用,未能解析会使链接失败。 WriteJavaFile 对应 Java 标识产物:

来源:Link.cpp · bool WriteJavaFile(ResourceTable* table, StringPiece package_name_to_generate,,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

file::AppendPath(&out_path, "R.java");

fout = util::make_unique<android::FileOutputStream>(out_path);

这里创建 R.java 输出;类内容由后续的 JavaClassGenerator 生成。对读者更直接的产物是生成的字段;2026-10-19 示例构建的 R.java 中,string 类的连续片段如下:

public static final class string {
  public static final int app_name=0x7f020000;
  public static final int message=0x7f020001;
  public static final int message_alias=0x7f020002;
}

这是示例的构建产物节选,不是 AOSP 实现源码。message_alias 有自己的 ID,其条目值引用 message;两者不是同一个 R 字段。5.7 会把这些 ID 放回资源表解释。

AAPT2 内部还涉及 ID 分配、资源裁剪、二进制序列化与可选 split,先以“编译局部输入 → 链接完整资源集合 → 生成运行时表与代码入口”恢复主线即可。

构建两版 APK 和错误签名对照包

在 Host 运行:

python3 "$chapter5_notes/示例/构建示例APK.py" \
  --aosp-top "$chapter5_top" \
  --module "$chapter5_notes/示例/Chapter5PackageResourcesDemo" \
  --version-code 1 --out "$chapter5_run/v1"
python3 "$chapter5_notes/示例/构建示例APK.py" \
  --aosp-top "$chapter5_top" \
  --module "$chapter5_notes/示例/Chapter5PackageResourcesDemo" \
  --version-code 2 --out "$chapter5_run/v2"
python3 "$chapter5_notes/示例/构建示例APK.py" \
  --aosp-top "$chapter5_top" \
  --module "$chapter5_notes/示例/Chapter5PackageResourcesDemo" \
  --version-code 3 --key-name media --out "$chapter5_run/wrong-key"
chapter5_apk1="$chapter5_run/v1/Chapter5PackageResourcesDemo.apk"
chapter5_apk2="$chapter5_run/v2/Chapter5PackageResourcesDemo.apk"

脚本只修改输出目录中的资源与 Manifest 副本:将 message 的值加上 v1 / v2 等后缀,并设置 versionCode。源工程保持可重复构建。testkey 与 media 都是 AOSP 公开实验密钥,这里只用不同证书构造更新失败;它们不用于生产签名。

预期三个输出目录各有 APK、generated、compiled.zip 与 build-commands.json。输出目录需为空,避免旧 R.java 或 DEX 混入。可以检查资源标识与实际 ZIP 条目:

"$chapter5_aapt2" dump badging "$chapter5_apk1"
"$chapter5_aapt2" dump resources "$chapter5_apk1" > "$chapter5_run/resources.txt"
python3 - "$chapter5_apk1" <<'PY'
import sys, zipfile
with zipfile.ZipFile(sys.argv[1]) as archive:
    for name in ['resources.arsc', 'assets/mapped.bin', 'assets/compressed.txt']:
        entry = archive.getinfo(name)
        print(name, 'method=', entry.compress_type,
              'size=', entry.file_size, 'compressed=', entry.compress_size)
PY

预期 mapped.bin 与 resources.arsc 为 ZIP_STORED,compressed.txt 为 ZIP_DEFLATED。历史构建的具体大小见 5.11;大小会随输入变化,不是协议常量。

5.4 用安装会话观察写入、提交与结果

写入文件并不等于安装完成

本次用显式 Session 展开普通、非 staged 安装。这里 staged 指等待后续激活流程的会话类型;普通安装也有临时文件准备区,不能因为有临时目录就称为 staged install。 APEX、增量安装、归档恢复和多包原子安装是其他分支。

先在终端 A 单独执行 "$chapter5_adb" -s "$chapter5_serial" shell pm path --user 0 com.example.pmresdemo。设备应正常响应且没有 package: 路径。如果仍有旧版本,按 5.11 的重置步骤清理示例,确认包已不存在后再回来。重做全章时,按 5.1 新建本轮目录,再按 5.3 重新生成三个 APK 并设置路径变量,然后回到本节。

下面先推送 v1,再创建会话并写入 APK。最后一条命令用于对照提交前的状态。

chapter5_size=$(stat -c %s "$chapter5_apk1")
"$chapter5_adb" -s "$chapter5_serial" push "$chapter5_apk1" /data/local/tmp/chapter5-v1.apk
chapter5_create=$("$chapter5_adb" -s "$chapter5_serial" shell pm install-create \
  -r --user 0 -S "$chapter5_size")
printf '%s\n' "$chapter5_create"
chapter5_session=$(printf '%s\n' "$chapter5_create" | sed -n 's/.*\[\([0-9][0-9]*\)\].*/\1/p')
test -n "$chapter5_session"
"$chapter5_adb" -s "$chapter5_serial" shell pm install-write \
  -S "$chapter5_size" "$chapter5_session" base.apk /data/local/tmp/chapter5-v1.apk
"$chapter5_adb" -s "$chapter5_serial" shell pm path com.example.pmresdemo

写入完成后,最后一步预期仍没有已安装路径。创建时,PackageInstallerService 用 Session ID 登记会话。后续 install-write 和 install-commit 用这个 ID 找回同一个对象,并校验调用方的会话访问权限。命令执行结束后关闭的是 Session 包装,只有显式放弃或走到相应收尾才结束服务端会话。写入失败先检查大小、设备文件路径与会话是否仍可写。参见 创建时登记 Session和按 ID 打开会话。

随后提交并查询:

"$chapter5_adb" -s "$chapter5_serial" shell pm install-commit "$chapter5_session"
"$chapter5_adb" -s "$chapter5_serial" shell pm path com.example.pmresdemo
"$chapter5_adb" -s "$chapter5_serial" shell dumpsys package com.example.pmresdemo \
  > "$chapter5_run/package-v1.txt"
python3 "$chapter5_notes/示例/运行并采集.py" \
  --adb "$chapter5_adb" --serial "$chapter5_serial" --out "$chapter5_run/run-v1" \
  --expect-version 1 --expect-marker created-by-version-1 --expect-en 'English resource v1'

预期 commit 返回 Success,pm path 给出实际 base.apk 路径,采集脚本退出码为 0。run-v1/logcat.txt 仅包含本轮日志,result.json 保存本轮标识、命令、退出码和通过状态;日志应包含 version=1、配置资源值与 DONE。

运行并采集脚本通过 am start -S 停止本实验应用,并用 NEW_TASK 与 CLEAR_TASK 清除本示例任务、重新创建 Activity;这不会清除应用私有数据。它用 --es experiment_id 传入随机标识,等待带同一标识的 DONE;发现 ERROR、超时或预期不符会返回非零。默认等待启动完成后 30 秒,需长延迟时可调 --timeout。am start -W 只等待相应启动阶段,不等待自建工作线程完成;单独读取历史 logcat 也不能证明本轮成功。 脚本不清空全局日志。

上面的 marker 判据针对全新安装。若之前保留过示例数据,先确认旧状态,或使用 5.11 的重置步骤后从 v1 重做。/data/app 下目录名带随机部分,使用查询结果,不要手写上一次的路径。

安装完成为什么需要回调

回看 5.2 总时序里的安装阶段,注意两个时间点。会话封存后,后台 Handler 可以推进安装。处理命令的线程还会等待最终状态。设备端 cmd 通过 Binder shellCommand 进入 system_server 后,由 PackageManagerShellCommand 调用同进程的 Session 对象。普通安装器则从自己的应用进程通过 Binder 调用 PackageInstaller。

普通应用的 commit Binder 应答与最终状态回调是两个事件。 后台处理可以与调用端并行,安装结果由状态接收者取得。普通应用还可能收到 STATUS_PENDING_USER_ACTION,需要用户继续操作。参见 PackageInstaller.Session API。

shell 为什么看起来一直等到结束?doCommitSession 自己等待接收器结果:

来源:PackageManagerShellCommand.java · private int doCommitSession(int sessionId, boolean logSuccess),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

final LocalIntentReceiver receiver = new LocalIntentReceiver();
session.commit(receiver.getIntentSender());
if (!session.isStaged()) {
    final Intent result = receiver.getResult();
    int status = result.getIntExtra(
            PackageInstaller.EXTRA_STATUS, PackageInstaller.STATUS_FAILURE);

session.commit(...) 交接安装工作,receiver.getResult() 等待最终状态;异步执行工作不等于没有线程阻塞等待。 在这条 shellCommand 路径中,system_server 处理 shell 命令的 Binder 线程会等待;安装 Session 的消息处理与 PackageManager Handler 等执行者继续推进安装。不要把等待线程误画成执行所有文件操作的线程。

接收器为什么会阻塞?它的 getResult 调用阻塞队列 take:

来源:PackageManagerShellCommand.java · public Intent getResult(),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

return mResult.take();

普通安装任务完成后,InstallingSession 的观察者把结果写入 CompletableFuture<InstallResult>,Session 在完成回调中处理成功与失败。随后 dispatchSessionFinished 进入状态通知路径,把结果投递给 MSG_ON_PACKAGE_INSTALLED。参见 普通安装结果处理。处理消息时,sendOnPackageInstalled 把 EXTRA_SESSION_ID 和 EXTRA_STATUS 等字段放进 Intent,经提交时登记的 IntentSender 送回。shell 使用的 LocalIntentReceiver 实现在 system_server 内,把收到的 Intent 放入队列,前面等待的 take() 才能返回。shell 命令随后检查状态。该基线中,即使安装状态是成功,若返回了警告,命令也会报告失败,所以遇到这类输出还要检查包的实际状态。普通应用由自己提供接收端,是否等待、在哪个线程等待由调用方决定。

源码定位:Session 结束与通知、构造最终状态 Intent、LocalIntentReceiver。

APK 字节怎样写进会话目录

pm install-write 并不把 APK 全部塞进一次 Binder 参数。PackageManagerShellCommand.doWriteSplit 打开输入文件,向会话传递 fd 与长度:

来源:PackageManagerShellCommand.java · private int doWriteSplit(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

session.write(splitName, 0, sizeBytes, fd);

源 fd 从哪里来?设备端的 cmd 客户端把 ShellCallback 随 shellCommand 请求交给 system_server。ShellCommand.openFileForSystem 通过它反向请求客户端打开路径。cmd.cpp · MyShellCallback::openFile 在设备端打开文件,检查 system_server 所需的 SELinux 访问权限,再把 fd 经 Binder 交回。这里用的是事先推到设备上的 APK,读取路径由客户端打开。

在同一个 system_server 进程里,Session.write 把源 fd 交给 PackageInstallerSession.doWriteInternal。后者在 stageDir 下创建目标文件并取得目标 fd:

来源:PackageInstallerSession.java · private ParcelFileDescriptor doWriteInternal(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

ParcelFileDescriptor targetPfd = openTargetInternal(target.getAbsolutePath(),
        O_CREAT | O_WRONLY, mode);

存在 incomingFd 时,该函数通过 FileUtils.copy 把源 fd 的字节复制到目标 fd,并在 finally 中关闭两端 fd、移除保持会话活跃的写入记录。Binder 传回的是文件描述符,APK 内容由 FileUtils.copy 通过文件 I/O 复制到会话目录。 因此打开源文件、写入会话和完成安装是三个可单独排查的步骤。

普通应用调用 Session.openWrite 时拿到可写的输出流。此基线有 RevocableFileDescriptor 与 FileBridge 两条备选分支。它们与这里的 incomingFd 复制分支不能拼成一条必经链。写入流需要结束,提交时封存输入,后续才开始安装验证。

5.5 从 Session 追踪校验、落盘与数据目录

封存输入后,Handler 接手安装

在 system_server 中,PackageInstallerSession.commit 首先尝试封存会话:

来源:PackageInstallerSession.java · public void commit(@NonNull IntentSender statusReceiver, boolean forTransfer),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

if (!markAsSealed(statusReceiver, forTransfer)) {
    return;
}

封存使提交的输入集合固定下来,避免一边校验一边继续任意修改 APK。 函数还处理父子会话等状态,随后调用 dispatchSessionSealed:

来源:PackageInstallerSession.java · private void dispatchSessionSealed(),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

private void dispatchSessionSealed() {
    mHandler.obtainMessage(MSG_ON_SESSION_SEALED).sendToTarget();
}

这个 sendToTarget 是明确的消息边界;handleSessionSealed 继续发送验证消息。验证准备好后进入安装消息:

来源:PackageInstallerSession.java · private void handleStreamValidateAndCommit(),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

if (allSessionsReady && streamValidateAndCommit()) {
    mHandler.obtainMessage(MSG_INSTALL).sendToTarget();
}

接下来,handleInstall 检查是否需要用户操作。继续安装时,普通会话经 verifyNonStaged 验证,验证通过后由 Session Handler 处理完成消息,再创建 InstallingSession。其 installStage 把任务交给 PackageManager 的 Handler:

来源:InstallingSession.java · public void installStage(),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

public void installStage() {
    setTraceMethod("installStage").setTraceCookie(System.identityHashCode(this));
    Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "installStage",
            System.identityHashCode(this));
    Trace.asyncTraceBegin(TRACE_TAG_PACKAGE_MANAGER, "queueInstall",
            System.identityHashCode(this));
    mPm.mHandler.post(this::start);
}

这两段 Handler 交接把“提交会话”和“执行安装”分开。 InstallingSession.start 完成前置拷贝/来源处理,经 processInstallRequests 的普通 APK 分支进入 InstallPackageHelper。阅读源码时按具体消息与分支前进,不要把所有带 install 的函数直接连起来。

安装请求经过哪些判断

先沿图追踪同一个请求。文件写入 Session 后还有解析和身份校验。进入普通 APK 分支后,代码路径和数据目录分别处理,ART 优化由策略决定。最后看包状态是否提交,以及等待结果的一方收到的是成功还是失败。

普通 APK 安装的决策流程:校验、落盘、提交与失败出口

InstallPackageHelper 的入口清楚地表达了前三个阶段:

来源:InstallPackageHelper.java · void installPackagesTraced(List<InstallRequest> requests, MoveInfo moveInfo),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

if (prepareInstallPackages(requests)
        && scanInstallPackages(requests, createdAppId, versionInfos)) {
    List<ReconciledPackage> reconciledPackages =
            reconcileInstallPackages(requests, versionInfos);
阶段要回答的问题输出
prepare这是什么包,输入是否基本有效,更新与签名条件是否成立解析后的包与准备状态
scan放进当前系统后,组件、ABI、权限声明和包设置怎样处理本次扫描结果
reconcile新旧包、签名、共享库等能否在整体状态中共存协调后的安装请求
commit怎样把已检查的结果变成可查询的包状态包设置、组件索引和后续通知所需状态

prepare、scan、reconcile 和 commit 是沿源码读安装的四个观察点。部分条件会在 Session 和安装任务中重复检查,APK 文件也可以在包状态提交前写入。看失败时要先确定请求走到了哪一步,再判断系统是否已经接纳新版本。

prepare 中的解析入口是 PackageParser2:

来源:InstallPackageHelper.java · private void preparePackage(InstallRequest request) throws PrepareFailure,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

parsedPackage = pp.parsePackage(tmpPackageFile, parseFlags, false);

解析得到包结构和声明,不代表签名已经满足更新条件。 当前实现随后还会做升级签名兼容检查,preparePackage 的一处入口如下:

来源:InstallPackageHelper.java · private void preparePackage(InstallRequest request) throws PrepareFailure,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

final boolean compatMatch =
        PackageManagerServiceUtils.verifySignatures(signatureCheckPs,
                signatureCheckSus, null,
        parsedPackage.getSigningDetails(), compareCompat, compareRecover,
        isRollback);

这考虑签名兼容、恢复与 rollback 条件,不是只比较两张证书的文本。签名轮换有自己的能力与继承规则;本章不同实验密钥没有合法继承关系,因此构造出的更新应失败。

内容完整性与更新身份是两道检查

签名至少回答两个不同问题:这份 APK 的受保护内容是否与签名一致,以及它是否有资格替换已安装包。 前者防止签名后篡改,后者检查更新身份和合法继承关系;一份自身签名有效、却由另一把密钥签出的 APK,仍可被拒绝更新。

FrameworkParsingPackageUtils.getSigningDetails 按场景选择证书提取或完整验证;普通需要验证的路径会调用 ApkSignatureVerifier.verify:

来源:FrameworkParsingPackageUtils.java · public static ParseResult<SigningDetails> getSigningDetails(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

verified = ApkSignatureVerifier.verify(input, baseCodePath, minSignatureScheme);

其相邻 skipVerify 分支用于已有信任条件的场景,不能把 unsafeGetCertsWithoutVerification 当成所有安装的完整校验。验签后的 SigningDetails 再参与新旧包身份检查;v1、v2/v3 等签名方案的受保护范围和验证实现不同,本章不展开密码学格式。

5.11 分别使用“另一把密钥签出的有效 APK”与“签名后修改内容的 APK”对照验证,两者的失败不能互相代替。

APK 最终路径与数据目录不是同一条落盘分支

普通非 Incremental 的代码路径重命名发生在 system_server 的 doRenameLI 中:

来源:InstallPackageHelper.java · private void doRenameLI(InstallRequest request,,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

if (onIncremental) {
    // Just link files here. The stage dir will be removed when the installation
    // session is completed.
    mPm.mIncrementalManager.linkCodePath(beforeCodeFile, afterCodeFile);
} else {
    Os.rename(beforeCodeFile.getAbsolutePath(), afterCodeFile.getAbsolutePath());
}

本分支直接使用 Os.rename;Incremental 则走另一条路径。 因此“APK 所有落盘都由 installd 做”并不准确。前面的会话写入已经产生临时文件,这里处理最终代码路径;包状态登记与旧版本清理还在后续步骤。

应用私有数据目录受 UID、GID、存储域、SELinux 标签和配额约束。本基线的这条普通 APK 路径先重命名代码目录,再进入 prepPerformDexoptIfNeeded,其中会准备应用数据,之后才提交包状态。即使数据准备方法叫 prepareAppDataPostCommitLIF,也要以这个调用点的顺序为准。InstallPackageHelper · 数据准备与 dexopt 调度

AppDataHelper 构造目录准备参数。Java Installer 将这些参数经 Binder 批量交给 installd:

来源:Installer.java · public @NonNull CreateAppDataResult[] createAppDataBatched(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

return mInstalld.createAppDataBatched(args);

installd 的 createAppDataBatched 对每项调用 createAppData,再进入带锁的数据目录处理;createAppDataDirs 调用具体目录准备函数:

来源:InstalldNativeService.cpp · static binder::Status createAppDataDirs(,固定提交 ae266dcb706d。以下为该函数内的连续原文摘录。

if (prepare_app_dir(path, targetMode, uid, gid, projectIdApp) ||
    prepare_app_cache_dir(path, "cache", 02771, uid, cacheGid, projectIdCache) ||
    prepare_app_cache_dir(path, "code_cache", 02771, uid, cacheGid, projectIdCache)) {
    return error("Failed to prepare " + path);
}

prepare_app_dir 进入 libcutils 的 fs_prepare_dir_strict,内部创建路径的分支最终调用:

来源:fs.cpp · static int fs_prepare_path_impl(,固定提交 545d2487e381。以下为该函数内的连续原文摘录。

create_result = prepare_as_dir
    ? TEMP_FAILURE_RETRY(mkdir(path, mode))
    : TEMP_FAILURE_RETRY(open(path, O_CREAT | O_CLOEXEC | O_NOFOLLOW | O_RDONLY, 0644));

mkdir/open 是进入 Kernel 文件接口的边界,目录权限与 SELinux 标签决定应用能否在之后访问数据。 路径大致包括 /data/user/0/包名 的凭据加密数据与 /data/user_de/0/包名 的设备加密数据;创建和可访问时机还取决于用户解锁状态。

更新通常替换代码路径而保留同一用户的应用数据;卸载、清除数据、安装到另一个用户与回滚策略可能改变这一点。本章使用 SharedPreferences 标记验证普通更新,不能拿它代表所有多用户或加密状态。

dexopt 由策略决定

当前 DexOptHelper 使用 ART Service:

来源:DexOptHelper.java · private DexoptResult dexoptPackageUsingArtService(InstallRequest installRequest),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

return getArtManagerLocal().dexoptPackage(snapshot, ps.getPackageName(), params);

ART Service 通过 ArtManagerLocal、Dexopter 等协调 artd,决定编译过滤器、可复用产物和是否需要工作。这个普通安装分支会等 dexopt 任务结束,再检查安装请求状态。dexopt 结果与安装结果分别判断,普通编译失败本身不会自动改成安装失败。可以从 Dexopter.java 的 dexoptFile 继续追踪 Native 边界:

来源:Dexopter.java · private ArtdDexoptResult dexoptFile(,固定提交 b753cf97923c。以下为该函数内的连续原文摘录。

ArtdDexoptResult result = mInjector.getArtd().dexopt(outputArtifacts,
        target.dexInfo().dexPath(), target.isa(), target.dexInfo().classLoaderContext(),
        target.compilerFilter(), profile, inputVdex, target.dmPath(), priorityClass,
        dexoptOptions, artdCancellationSignal, mParams.getLoggingFd());

getArtd().dexopt 是与独立 artd 服务的 Binder 边界。 artd 的 Artd::dexopt 组织实际 dex2oat 工作与输出文件处理;是否需要这些工作由前面的策略与可复用状态决定。

安装包有效、DEX 能被运行时加载、安装期间发生哪些优化,是相关但不同的问题。 profile、编译原因、资源限制和当前策略都会影响结果,不能凭安装很快就断言“没有经过 ART”,也不能因安装成功就断言“全部方法已编成机器码”。ART Service 配置

commit 怎样让一个包真正成为系统状态

前面 APK 已有最终路径,为什么还需要 commit?因为文件存在只证明代码在磁盘上,系统还需要登记包设置、用户状态和组件索引。普通安装在 commitPackagesLocked 中把协调结果提交并更新设置:

来源:InstallPackageHelper.java · private void commitPackagesLocked(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

AndroidPackage pkg = commitReconciledScanResultLocked(reconciledPkg, allUsers);
updateSettingsLI(pkg, allUsers, installRequest);

其中 commitPackageSettings 将包设置与解析结果放入系统管理结构:

来源:InstallPackageHelper.java · private void commitPackageSettings(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

mPm.mSettings.insertPackageSettingLPw(pkgSetting, pkg);
// Add the new setting to mPackages
mPm.mPackages.put(pkg.getPackageName(), pkg);

同一函数还通过 ComponentResolver.addAllComponents 注册 Activity、Service 等组件,更新包可见性等关联状态。getPackageInfo 查询与 Intent 解析读取的结构有区别,不能理解成所有查询都只查一个 Map。

随后 updateSettingsLI 转到 updateSettingsInternalLI,在相关分支请求写设置:

来源:InstallPackageHelper.java · private void updateSettingsInternalLI(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

Trace.traceBegin(TRACE_TAG_PACKAGE_MANAGER, "writeSettings");
mPm.writeSettingsLPrTEMP();
Trace.traceEnd(TRACE_TAG_PACKAGE_MANAGER);

包状态登记、持久化与重启恢复

该图是状态关系图,不表示持久化与所有通知只有一个不可分割的函数调用。需要分清以下对象:

对象或位置保存什么不代表什么
/data/app/.../base.apk 与 split当前安装的代码和资源文件文件存在不等于用户已安装且组件可解析
PackageManagerService 内存包设置、包对象、ComponentResolver包元数据、扫描结果、组件索引不全是每次查询重新解析 APK 得到
/data/system/packages.xmlSettings 的全局包设置,如代码路径、appId、签名等不保存应用的完整运行内存或资源表
/data/system/users/用户编号/package-restrictions.xml每用户的安装、启停等包限制状态同一个包对所有用户都自动具有相同状态
/data/user/用户编号/包名、/data/user_de/...应用 CE/DE 私有数据不等于 PackageManagerService 全局包设置

appId 标识应用身份的一部分,UID 还包含用户维度。packages.xml 与用户状态文件的路径由 Settings 定义,具体序列化和写入策略以该版本实现为准;调试优先用 dumpsys,不直接修改这些文件。重启时 PackageManagerService 读取 Settings,InitAppsHelper 再结合系统分区和数据目录中的 APK 扫描恢复运行结构;不是简单把一个 XML 原样反序列化成全部 PackageManagerService 对象。 这也解释了为什么“已经复制 APK”“查询可见”“重启后仍有效”是不同的观察点。

源码定位:Settings 文件与读写、PackageManagerService 读取设置、InitAppsHelper 扫描数据目录。启动扫描与 Permission 的完整机制分别接第四章和后续安全章节。

更新时旧进程与旧代码何时处理

替换路径并保留数据,还要协调正在使用旧代码与资源的进程。普通更新会使用 PackageFreezer 暂时阻止受影响包启动,并按策略停止旧进程;这是包管理的“冻结”,不等于把每个旧线程挂起后继续原地执行。此基线存在同步冻结与启用 enableAppRestartAfterUpdate 后的异步冻结分支:后者在专用执行器等待 stop/kill,再回到 PackageManagerService Handler 提交,不能把所有耗时都归到同一个线程。

成功后的 handlePackagePostInstall 根据移除信息清理旧代码路径。若请求允许不杀进程,旧路径仍可能被使用,清理会延后;不要在重命名之后立即删除所有旧 APK。新代码路径、PackageManagerService 状态和旧进程生命周期需要配合,应用数据保留是另一项策略。

源码定位:commitInstallPackages / commitInstallPackagesAsync、旧代码延后清理分支。

5.6 PackageManager 怎样查询安装后的包

查询读包状态 不会为每次调用重新扫描 APK

应用调用 Context.getPackageManager 得到应用侧实现,getPackageInfo 经 ApplicationPackageManager 进入带失效机制的查询缓存:

来源:PackageManager.java · public static PackageInfo getPackageInfoAsUserCached(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

public static PackageInfo getPackageInfoAsUserCached(
        String packageName, @PackageInfoFlagsBits long flags, int userId) {
    return sPackageInfoCache.query(new PackageInfoQuery(packageName, flags, userId));
}

缓存需要重算时,走到系统接口:

来源:PackageManager.java · private static PackageInfo getPackageInfoAsUserUncached(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

return ActivityThread.getPackageManager().getPackageInfo(packageName, flags, userId);

一次 Java API 调用可能命中进程内缓存;真正的远端查询通过 IPackageManager 进入 system_server。 服务端查询由当前 Computer 快照与 ComputerEngine 等实现处理,结合包状态、调用 UID、用户、flags 和可见性规则生成 PackageInfo,而不是对每次请求解压 APK。

在示例里 PackageInfo.getLongVersionCode 来自查询结果,ApplicationInfo.sourceDir 则告诉应用代码 APK 的实际路径。更新后启动新进程,我们可以同时观察版本变化与 sourceDir 变化;不能把两个时间点取得的不同版本状态随意拼成一个全局快照。

为什么 shell 看得到,应用却查不到

从 Android 的应用身份看,“已安装”不意味着“对所有调用者都可查询”。包可见性、用户范围、安装状态和 flags 都影响结果;Manifest 的 <queries> 声明也属于可见性契约。查询权限与启动导出组件的权限是另外的问题。

本章只查询自身包,避免把包可见性问题混进安装主实验。排查其他包时,先记录调用 UID、userId 和 flags,再比较 pm 与应用的结果;不要直接以 shell 的 dumpsys 结果认定应用 API 有 bug。

查询结果中的版本号和路径能帮我们确认更新是否生效。应用在启动时也会收到资源路径,但这走的是应用绑定流程。下面沿启动传入的路径找到 Resources,再跟着一个 ID 查值。

5.7 一次 getString 怎样找到资源值

先分清加载资源来源与查询资源值

应用路径怎样到达 Resources?system_server 在应用绑定时通过 IApplicationThread.bindApplication 传入 ApplicationInfo。应用进程的 Binder 入口把它放进 AppBindData.appInfo,投递 H.BIND_APPLICATION。主线程在 handleBindApplication 中取得或创建 LoadedApk。对本例读取自身包资源的情形,LoadedApk 将 sourceDir 记为 mResDir,之后同 split、共享库和 Overlay 等路径一起交给 ResourcesManager。这里的初始化由应用启动驱动。5.6 的 getPackageInfo 查询用于观察包状态。

源码定位:ActivityManagerService · bindApplication 调用点、ActivityThread · 保存 appInfo 并投递主线程消息、ActivityThread · 取得 LoadedApk、LoadedApk · 记录 APK 路径。

Context、LoadedApk 和 ResourcesManager 组织资源来源的时序

这是应用 Context 的机制示意,不是每次查询都发生的调用。ContextImpl.createAppContext 明确安装 LoadedApk 提供的 Resources:

来源:ContextImpl.java · static ContextImpl createAppContext(ActivityThread mainThread, LoadedApk packageInfo, ,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

context.setResources(packageInfo.getResources());

LoadedApk.getResourcesInner 将路径交给 ResourcesManager:

来源:LoadedApk.java · private Resources getResourcesInner(),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

return ResourcesManager.getInstance().getResources(null, mResDir,
        splitPaths, mLegacyOverlayDirs, mOverlayPaths,
        mApplicationInfo.sharedLibraryFiles, null, null, getCompatibilityInfo(),
        getClassLoader(), null);

LoadedApk 持有路径和应用信息;ResourcesManager 按路径集合、显示与配置等组成的 ResourcesKey 管理复用。 base、split、共享库和 Overlay 作为不同资源来源加入集合。创建新 ResourcesImpl 时,createAssetManager 使用 Builder.addApkAssets 加入各来源;Builder.build 会把 Java 中的来源数组交给 Native:

来源:AssetManager.java · public AssetManager build(),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

assetManager.mApkAssets = apkAssets;
AssetManager.nativeSetApkAssets(assetManager.mObject, apkAssets,
        false /*invalidateCaches*/, mNoInit /*preset*/);

这里先把一个容易漏掉的对象来源接上:assetManager.mObject 保存的是当前应用进程里的 Native 包装对象地址,不是 system_server 的地址,也不是 APK 文件地址。 Builder 先调用 new AssetManager(false);这个私有构造函数把 nativeCreate 的返回值存入 mObject。

来源:AssetManager.java · private AssetManager(boolean sentinel),以下为连续原文摘录。

        mObject = nativeCreate();

JNI 的 NativeCreate 则在同一进程分配 GuardedAssetManager;包装内包含锁保护的 AssetManager2。

来源:android_util_AssetManager.cpp · NativeCreate,以下为连续原文摘录。

static jlong NativeCreate(JNIEnv* /*env*/, jclass /*clazz*/) {
  // AssetManager2 needs to be protected by a lock. To avoid cache misses, we allocate the lock and
  // AssetManager2 in a contiguous block (GuardedAssetManager).
  return reinterpret_cast<jlong>(new GuardedAssetManager());
}

Java long 在这里承载 Native 地址这一数值,JNI 用它找回原对象;进入 JNI 不会把对象搬到另一进程,也不会自行切换线程。 ApkAssets 的来源包装由另一个 mNativePtr 字段保存,5.8 接着解释其创建和安装到 AssetManager2 的过程。

nativeSetApkAssets 取出这些 ApkAssets 的 Native 对象;preset 为 true 时先由 AssetManager2.PresetApkAssets 准备来源,另一分支调用 SetApkAssets。随后配置初始化使来源与配置共同形成可查询环境。ResourcesImpl 组合这个 AssetManager、DisplayMetrics 与 Configuration。由此,后面的 nativeGetResourceValue 才有可查询的 Native 环境,而不是凭资源 ID 临时找到任意 APK。

Activity 的 Context 使用 ContextImpl.createActivityContext → ResourcesManager.createBaseTokenResources,还包含 Activity token、显示和覆盖配置;它不保证与 Application 的 Context 返回同一个 Resources 对象。createConfigurationContext 同样按覆盖配置取得相应 Resources,底层资源来源可以复用。Resources 是 Java API 包装,ResourcesImpl 持有实现状态,AssetManager 连接来源与 Native 查询环境,ApkAssets 表示具体加载来源。

源码定位:创建 ResourcesImpl、JNI 安装来源集合、Activity 资源上下文。

本基线 loadApkAssetsRaw 区分普通 APK 与 Overlay:

来源:ResourcesManager.java · protected ApkAssets loadApkAssetsRaw(@NonNull ApkKey key, int flags),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

protected ApkAssets loadApkAssetsRaw(@NonNull ApkKey key, int flags) throws IOException {
    if (key.overlay) {
        return ApkAssets.loadOverlayFromPath(overlayPathToIdmapPath(key.path), flags);
    }
    return ApkAssets.loadFromPath(key.path, flags);
}

普通来源按 APK 路径加载,Overlay 来源按 idmap 路径加载。 ResourcesManager.loadApkAssets 还先检查可复用的 ApkAssets,因此看到一个新 Resources 对象,不等于系统一定重新 mmap 整个 APK。资源来源的底层加载细节放在 5.8;本节先沿已准备好的资源集合查询一个 ID。

从 Java API 走到 Native 选择

先跟着资源 ID 找条目,再看返回值怎样带着来源回到 Java。 可以把资源表看成按编号编排的目录:ID 决定查哪一项,Configuration 决定选哪个候选,cookie 与池索引决定从哪里取出文本。这只是查表关系的比喻,ID 不是文件偏移,cookie 也不是内存地址;引用资源还要沿目标 ID 继续查。

同一应用进程中从 getString 到资源字符串池的时序

沿图先看资源 ID 进入 AssetManager2,再看 JNI 填入 TypedValue、返回 cookie,最后由 Java 取出字符串。整段同步调用留在发起 getString 的应用线程。

Resources.getString 本身很短:

来源:Resources.java · public String getString(@StringRes int id),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

public String getString(@StringRes int id) throws NotFoundException {
    return getText(id).toString();
}

getText 才把工作交给 ResourcesImpl 持有的 AssetManager:

来源:Resources.java · @NonNull public CharSequence getText(@StringRes int id),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

@NonNull public CharSequence getText(@StringRes int id) throws NotFoundException {
    CharSequence res = mResourcesImpl.getAssets().getResourceText(id);
    if (res != null) {
        return res;
    }
    throw new NotFoundException("String resource ID #0x"
            + Integer.toHexString(id));
}

本基线的字符串路径是 Resources → ResourcesImpl.getAssets → AssetManager.getResourceText,并非先调用 ResourcesImpl.getValue。 后者也存在,服务于其他取值路径;阅读时应跟着实际方法走。

来源:AssetManager.java · @Nullable CharSequence getResourceText(@StringRes int resId),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

@Nullable CharSequence getResourceText(@StringRes int resId) {
    synchronized (this) {
        final TypedValue outValue = mValue;
        if (getResourceValue(resId, 0, outValue, true)) {
            return outValue.coerceToString();
        }
        return null;
    }
}

AssetManager.getResourceText 使用同一个 getResourceValue 入口;它提交 Native 对象与资源 ID:

来源:AssetManager.java · boolean getResourceValue(@AnyRes int resId, int densityDpi, @NonNull TypedValue outValue,,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

final int cookie = nativeGetResourceValue(
        mObject, resId, (short) densityDpi, outValue, resolveRefs);
if (cookie <= 0) {
    return false;
}

JNI 取得 Native AssetManager2,在本线程内执行查找:

来源:android_util_AssetManager.cpp · static jint NativeGetResourceValue(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

auto value = assetmanager->GetResource(static_cast<uint32_t>(resid), false /*may_be_bag*/,
                                       static_cast<uint16_t>(density));

Native GetResource 进入 FindEntry:

来源:AssetManager2.cpp · base::expected<AssetManager2::SelectedValue, NullOrIOError> AssetManager2::GetResource(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

auto result = FindEntry(resid, density_override, false /* stop_at_first_match */,
                        false /* ignore_configuration */);

FindEntry 根据资源标识定位包、类型和条目,并在当前配置与来源集合中选择合适值。 引用类型还需要 ResolveReference,不能把 @string/another 当成最终字符串内容直接返回。数组、style 等复杂 bag 类型另有取值入口。

把一个真实资源 ID 放进资源表看

先用 aapt2 dump resources "$chapter5_apk1" 找 message。此前基线示例的值是 0x7f020001;本次构建应以自己的 dump 和 generated/R.java 为准。拆开后是:

部分示例值本次查找含义
package0x7f应用资源包的编号,映射到 PackageGroup;不是 UID 或 Java 包名
type0x02本 APK 的 string 类型;Native 常转为从零开始的 type_idx=1
entry0x0001string 类型下的 message 条目索引

resources.arsc 包含表头、资源包、类型说明、带配置的类型数据以及字符串池等结构。同一个条目可以在默认、英文、中文、night 配置中有不同值;资源 ID 指向逻辑条目,不指向某一份固定文本。

资源 ID、配置候选和字符串池的查找关系

FindEntry 先拆 ID,再查 package_ids_ 映射;资源包 ID 并非直接等于数组下标:

来源:AssetManager2.cpp · AssetManager2::FindEntry(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

const uint32_t package_id = get_package_id(resid);
const uint8_t type_idx = get_type_id(resid) - 1;
const uint16_t entry_idx = get_entry_id(resid);
uint8_t package_idx = package_ids_[package_id];

FindEntryInternal 在该 PackageGroup 的来源中取得 TypeSpec,然后查看配置候选;符合配置且优于已有候选时,用条目索引取得资源表偏移:

来源:AssetManager2.cpp · AssetManager2::FindEntryInternal(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

const auto& type = type_entry->type;
const auto offset = LoadedPackage::GetEntryOffset(type, entry_idx);

偏移用于读取条目和值,不是把 entry_idx 直接当字符串池索引。TypeSpec 描述类型与条目相关信息,带配置的类型数据存放具体条目,值字符串池保存文本;类型名称和资源名称也有各自的字符串池,不能与值字符串池混用。源码还处理稀疏条目、动态包映射等情况,这张图表达查询层次,不规定资源表只有一种紧凑布局。

引用资源为什么要再查一次

示例的 message_alias 值为 @string/message。link 后,它的 Res_value 是 TYPE_REFERENCE,data 表示 message 的资源 ID;它还不是字符串池索引。JNI 在 resolve_references 为 true 时调用 ResolveReference:

来源:android_util_AssetManager.cpp · static jint NativeGetResourceValue(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

if (resolve_references) {
  auto result = assetmanager->ResolveReference(value.value());
  if (!result.has_value()) {
    return ApkAssetsCookieToJavaCookie(kInvalidCookie);
  }
}

AssetManager2.ResolveReference 沿引用继续 GetResource,直到得到终值或遇到终止条件;最终 cookie 也应来自终值所在来源。示例用 getValue(message_alias, value, false) 保留未解析引用,日志应显示 type=1(TYPE_REFERENCE)以及指向 message 的 data;getString(message_alias) 则返回选定配置中的最终文本。5.4 的日志中,alias-en 应与 en 一致。

资源 ID、引用值中的目标 ID、TYPE_STRING 中的池索引,都是整数,但属于不同阶段。 数组、style、Theme/TypedArray 的 bag 解析不等同于本节单值字符串路径,后续学习应在此模型上继续展开。

cookie 与池索引怎样定位字符串

找到值之后,Java 一侧会处理 TYPE_STRING:

来源:AssetManager.java · boolean getResourceValue(@AnyRes int resId, int densityDpi, @NonNull TypedValue outValue,,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

if (outValue.type == TypedValue.TYPE_STRING) {
    if ((outValue.string = getPooledStringForCookie(cookie, outValue.data)) == null) {
        return false;
    }
}
return true;

这里的 outValue.data 对字符串类型表示字符串池索引,而不是另一个资源 ID。cookie 指向当前 AssetManager 中的资源来源;本基线 Java cookie 从 1 开始计数:

来源:AssetManager.java · CharSequence getPooledStringForCookie(int cookie, int id),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

CharSequence getPooledStringForCookie(int cookie, int id) {
    // Cookies map to ApkAssets starting at 1.
    return getApkAssets()[cookie - 1].getStringFromPool(id);
}

cookie - 1 选择 ApkAssets,id 参数选择该来源的字符串池条目。 这里形参 id 指字符串池索引,与前面的 R.string.message 不同;同名的整数形参不能按同一种含义理解。ApkAssets.getStringFromPool 继续调用 StringBlock.getSequence。池的 Java 包装由 ApkAssets 构造函数通过 nativeGetStringBlock 取得,对应已加载资源表的值字符串池。命中 StringBlock 缓存时直接返回 CharSequence,未命中时才从 Native 池取值。最终 Resources.getString 将 CharSequence 转成 String。

源码定位:StringBlock.getSequence、JNI 获取 ApkAssets 的字符串池。

名称本步骤表示什么不要误认为什么
资源 ID哪个包、类型和资源条目原始文本、Native 地址
TypedValue.type / data值的类型与对应数据;字符串类型时 data 是池索引所有类型都能直接按字符串解释
assetCookie从哪个已加载的资源来源取值Linux fd、UID、固定 package ID
字符串池同一资源来源中的文本与样式数据所有 APK 共用的 Java String 池

根据配置解析资源引用,再按来源 cookie 和池索引返回字符串

资源 ID 指向逻辑条目。配置和引用解析确定最终值,cookie 和池索引再把这个值还原成 Java 文本。下一节打开它依赖的 APK,看资源表和 ZIP 条目怎样成为进程能读的文件数据。

沿着目录找到文字,再打开承载它的文件

5.8 APK 怎样变成可读取的 Native 资源

JNI 加载 APK 并取得资源表

ApkAssets.loadFromPath 在 Java 侧创建或初始化对象,经 nativeLoad 进入 android_content_res_ApkAssets.cpp。普通 APK 分支如下:

来源:android_content_res_ApkAssets.cpp · static jlong NativeLoad(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

case FORMAT_APK: {
    auto assets = AssetsProvider::CreateWithOverride(ZipAssetsProvider::Create(path.c_str(),
                                                                               property_flags),
                                                     std::move(loader_assets));
    apk_assets = ApkAssets::Load(std::move(assets), std::move(flag_func), property_flags);
    break;
}

加载完成后,NativeLoad 并不把裸的 APK 字节地址直接交给 Java,而是调用 CreateGuardedApkAssets(std::move(apk_assets)),创建一个持有 ApkAssetsPtr 的包装。

来源:android_content_res_ApkAssets.cpp · CreateGuardedApkAssets,以下为连续原文摘录。

static jlong CreateGuardedApkAssets(AssetManager2::ApkAssetsPtr assets) {
  auto guarded_assets = new Guarded<AssetManager2::ApkAssetsPtr>(std::move(assets));
  return reinterpret_cast<jlong>(guarded_assets);
}

Java ApkAssets 的构造函数把返回的包装地址存入 mNativePtr,再用它取得值字符串池的 StringBlock 包装:

来源:ApkAssets.java · 按路径创建 ApkAssets,以下为连续原文摘录。

        mNativePtr = nativeLoad(format, path, flags, assets);
        mStringBlock = new StringBlock(nativeGetStringBlock(mNativePtr), true /*useSparse*/);

回到 5.7 的 nativeSetApkAssets:JNI 对数组中每个 Java ApkAssets 读取 mNativePtr,ApkAssetsFromLong 把地址还原为上述 Guarded 包装,再在锁内取出 ApkAssetsPtr,加入本次 Native 来源集合:

来源:android_util_AssetManager.cpp · NativeSetApkAssets,以下为连续原文摘录。

    auto scoped_assets = ScopedLock(ApkAssetsFromLong(apk_assets_native_ptr));
    apk_assets.emplace_back(*scoped_assets);

随后用 mObject 找到 AssetManager2,调用 SetApkAssets 或 PresetApkAssets。mObject 关联查询环境,mNativePtr 关联某个加载来源,两者都是当前进程中的地址数值;后面返回的 cookie 则是当前来源集合中的编号,三者不能互换。 Native 集合持有来源的引用,关闭一个 Java 包装不等于所有共享来源和映射立刻销毁;读取流、fd、映射和资源管理器的生命周期分别见本节收尾。

ZipAssetsProvider 管理 ZIP 内条目的访问,ApkAssets::Load 组织该来源的资源表。 这里没有把整个 APK 每项都解压到文件系统。进入 ApkAssets::LoadImpl 时,资源表被当作 resources.arsc 条目打开:

来源:ApkAssets.cpp · ApkAssetsPtr ApkAssets::LoadImpl(std::unique_ptr<AssetsProvider>&& assets,,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

bool resources_asset_exists = false;
auto resources_asset = assets->Open(kResourcesArsc, Asset::AccessMode::ACCESS_BUFFER,
                                    &resources_asset_exists);

取得 Asset 后,后续 LoadImpl 调用 getIncFsBuffer 和 LoadedArsc::Load,建立可用于查找的 Native 资源表结构。LoadedArsc 对二进制格式、边界和内容有检查;一个文件叫 resources.arsc,并不能证明它是可安全读取的有效资源表。

怎样读取压缩和未压缩条目

ZIP 压缩和未压缩条目的读取分支

源码 OpenInternal 先 FindEntry,并校验条目偏移与长度没有越过 APK。随后根据 ZIP 方法选择 Asset 类型。压缩分支的一处关键动作是:

来源:AssetsProvider.cpp · std::unique_ptr<Asset> ZipAssetsProvider::OpenInternal(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

std::unique_ptr<Asset> asset =
    Asset::createFromCompressedMap(std::move(asset_map), entry.uncompressed_length, mode);

压缩条目也可能先 mmap 它的压缩字节,之后才解压。 因此在 strace 中看到 mmap,并不能证明这个条目没有压缩,也不能证明消费者在零拷贝地使用原始内容。

对于未压缩条目,映射范围是 APK 文件中可直接定位的内容区间。AssetManager.openFd 能返回 AssetFileDescriptor,它描述的是 fd、起始偏移、长度;把这个 fd 当成“一个从偏移零开始的独立小文件”读取,可能读到 APK 的其他内容。

从 IncFsFileMap 走到真正的 mmap

看映射过程时,区分 APK 文件区间、进程映射和真正就绪的文件页。 映射建立后,已有页表映射或就绪页缓存可以避免本次设备读取;压缩条目的映射里仍是压缩字节,需要解压才能交给消费者。这里以未压缩条目串起映射、按需取页、读取与收尾,压缩分支以本节前图和源码为准;缓存与 I/O 分支是条件示意,不是本次逐页实测。

当前 ZipAssetsProvider 使用 incfs::IncFsFileMap;在 Android 分支,它最终调用:

来源:map_ptr.cpp · bool IncFsFileMap::CreateForceVerification(int fd, off64_t offset, size_t length,,固定提交 6b853f9e5703。以下为该函数内的连续原文摘录。

map_ = base::MappedFile::Create(fd, offset, length, PROT_READ);
if (!map_) {
    return false;
}

IncFs 的校验包装会结合文件类型与数据是否完整决定验证策略。对本章普通 ext4 上的 APK,仍可沿它进入 libbase 的 MappedFile;不要只凭类名推断文件位于 Incremental FS。

APK 条目偏移通常不是页边界,MappedFile 先计算对齐:

来源:mapped_file.cpp · std::optional<MappedFile> MappedFile::Create(os_handle h, off64_t offset, size_t length,,固定提交 fef4173e19d9。以下为该函数内的连续原文摘录。

size_t slop = offset % page_size;
off64_t file_offset = offset - slop;
off64_t file_length = length + slop;

file_offset 向下按页对齐,file_length 覆盖条目长度与页内偏移 slop。 返回给上层的有效数据指针会跳过 slop,因此映射地址与条目逻辑起点不一定相同。

Linux 分支真正进入 Kernel 的语句是:

来源:mapped_file.cpp · std::optional<MappedFile> MappedFile::Create(os_handle h, off64_t offset, size_t length,,固定提交 fef4173e19d9。以下为该函数内的连续原文摘录。

void* base = mmap(nullptr, file_length, prot, MAP_SHARED, h, file_offset);
if (base == MAP_FAILED) {

这是 Linux 分支片段,后续还有失败与空文件等处理。x86_64 Bionic 的 mmap/mmap64 系统调用入口由 SYSCALLS.TXT 的 lp64 规则生成;不要把旧 32 位 mmap2 包装硬套到本设备。

close 与 unmap 分别释放什么

文件描述符是访问文件的入口;映射是进程地址空间的一段区域。成功建立映射后关闭用于创建它的 fd,并不自动撤销那段映射。MappedFile 的 Linux 清理分支是:

来源:mapped_file.cpp · void MappedFile::close() noexcept {,固定提交 fef4173e19d9。以下为该函数内的连续原文摘录。

if (base_ != nullptr && size_ != 0) munmap(base_, size_ + offset_);

munmap 释放该映射,不表示对应文件数据立刻从全局页缓存消失。 同一 APK 的其他映射或其他进程仍可使用相同底层文件页。Java close、Native 对象引用与映射释放也受所有权关系约束;不要为了“释放缓存”随意关闭仍由 Resources 使用的 AssetManager。

5.9 限定符与 Overlay 怎样改变选择结果

限定符不是按目录扫描顺序覆盖

限定符描述资源适用的配置,例如语言、屏幕尺寸、方向、密度、夜间模式与 API 版本。运行时根据 Configuration 筛选并比较候选,不能用“目录名更长”或“放在后面的目录”解释结果。官方资源配置说明

本章只改变局部 Context 的 locale 与 uiMode。示例中的 configured("en", true) 先复制当前配置,再显式设置英文 locale 和 night 模式,由 createConfigurationContext 得到局部 Resources;因此表中的“en,夜间”是这组明确输入,不是只看设备当前主题。配置会影响资源选择,但字符串 ID 不变;getString 根据相应 Resources 的配置返回值。

AssetManager2.FindEntryInternal 在候选中使用 match 与 isBetterThan:

来源:AssetManager2.cpp · base::expected<FindEntryResult, NullOrIOError> AssetManager2::FindEntryInternal(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

const ResTable_config& this_config = type_entry->config;
if (!((use_filtered && (configurations_.size() == 1))
    || ignore_configuration || this_config.match(desired_config))) {
  continue;
}

Resolution::Step::Type resolution_type;
if (best_config == nullptr) {
  resolution_type = Resolution::Step::Type::INITIAL;
} else if (this_config.isBetterThan(*best_config, &desired_config)) {
  resolution_type = Resolution::Step::Type::BETTER_MATCH;

先判断是否适用于期望配置,再比较是否比当前最佳候选更合适。 源码还有预过滤、多个配置、加载器等分支,片段只解释本节的核心判断。

在示例配置中,预期与实测如下:

查询配置选中值(v1)为什么
en,非夜间English resource v1有 values-en 的语言候选
zh,非夜间中文资源 v1有 values-zh 的语言候选
en,夜间English resource v1本例的 locale 优先比较使 en 候选保留下来
fr,夜间Night resource v1没有法语专用项,夜间候选优于默认值

这个实验刻意没有提供 values-en-night。需要英文夜间专用内容时,应补组合限定目录,而不是假设 values-night 无条件覆盖 values-en。限定符有规定的优先级和目录排列规则,不要将本表推广成所有资源类型的简化排序。

拿到一个旧 String 后更改配置,不会自动修改这个已返回的字符串。应用需要重新取值并更新界面;ResourcesManager、ResourcesImpl 与配置更新还涉及缓存失效及 Activity 重建等机制,本章通过独立配置 Context 把选择行为单独观察出来。

Overlay 增加一份资源来源

Runtime Resource Overlay 可以在允许的范围内替换目标资源。系统需要确认目标、overlayable 名称、策略和启用状态,并建立 idmap 关联;Overlay 不是任意应用都能随意替换系统资源的通行证。

基础工程允许本章 message 资源参与实验:

<!-- res/values/overlayable.xml,完整文件 -->
<resources>
    <overlayable name="Chapter5Theme">
        <policy type="public">
            <item type="string" name="message" />
        </policy>
    </overlayable>
</resources>

public 策略让该示例资源可被符合条件的 Overlay 使用;这是实验目标的显式设计。不要将该策略无差别复制到敏感生产资源。Overlay Manifest 为:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.pmresdemo.overlay" android:versionCode="1" android:versionName="1">
    <uses-sdk android:minSdkVersion="28" />
    <overlay android:targetPackage="com.example.pmresdemo"
        android:targetName="Chapter5Theme" android:isStatic="false" />
    <application android:hasCode="false" android:label="Chapter5 Message Overlay" />
</manifest>

Overlay 的默认与英文资源各声明同名 message,值均为 Overlay resource;这个 APK 不需要 Activity 和 DEX。它通过 targetPackage 与 targetName 对应目标,idmap 关联目标资源与覆盖值。

目标资源与 Overlay 的配置候选比较

相同目标 ID 仍需在配置和 Overlay 规则下选值,Overlay 的默认项不保证压过目标 APK 的所有更优配置项。 2026-10-19 的历史实测在基础包 v2 上进行:开启后英文变成 Overlay resource,中文仍为中文资源 v2;源码中 FindEntry 的 Overlay 分支也会比较覆盖项的配置是否等于或优于目标候选。

从启用 Overlay 到应用刷新资源

idmap 是目标资源与 Overlay 资源的映射产物,启用状态则按用户维护。两者都需要:磁盘上存在 idmap,不表示这个用户当前一定启用了 Overlay;切换 enable 也不保证每次重新生成文件,已有映射可验证后复用。

Overlay 启用、idmap 准备、路径更新和应用刷新

设备端 cmd overlay enable 经 Binder 进入 Overlay 服务的 shell 命令入口。OverlayManagerShellCommand 构造启用事务,同进程交给服务的 commit。事务执行到 setEnabled 后更新用户设置,再调用 updateState。安装或扫描更新时也可能准备 idmap。参见 OverlayManagerShellCommand · runEnableDisable。

来源:OverlayManagerServiceImpl.java · Set<UserPackage> setEnabled(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

boolean modified = mSettings.setEnabled(overlay, userId, enable);
modified |= updateState(oi, userId, 0, constraints);

updateState 根据目标、Overlay 与策略决定是否准备 idmap。IdmapManager.createIdmap 先验证已有映射,不可复用时才经 IdmapDaemon 调独立服务;真正的 Binder 边界是 IIdmap2:

来源:IdmapDaemon.java · String createIdmap(,固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

return idmap2.createIdmap(targetPath, overlayPath, TextUtils.emptyIfNull(overlayName),
        policies, enforce, userId, constraints);

idmap2d 的 Idmap2Service.createIdmap 读取目标和 Overlay 容器,通过 Idmap::FromContainers 构造映射并写入缓存文件。它不修改目标 APK 本身。回到 system_server,updateTargetPackagesLocked 持久化 Overlay 设置并更新 PackageManager 里的 OverlayPaths,再投递通知任务:

来源:OverlayManagerService.java · private void updateTargetPackagesLocked(@Nullable Set<UserPackage> updatedTargets),固定提交 94b4c163b7df。以下为该函数内的连续原文摘录。

updateActivityManager(affectedPackages, userId);

如果实际受影响的包集合非空,通知任务由 FgThread 分发。应用侧可经过 ActivityThread.handleApplicationInfoChanged、LoadedApk.updateApplicationInfo 和 ResourcesManager 更新资源路径与实现。配置更新还可能引发 Activity 重建或由应用处理配置变化,不能保证每个旧 View 都自动重新赋值。旧 String 不会自己变成新内容,必须重新取值并更新显示。

源码定位:IdmapManager 验证或创建、idmap2d 生成映射、更新 PackageManagerService 路径与调度通知、应用处理 ApplicationInfo 变化。

在 Host 构建并安装,以下命令只启用本实验的 Overlay:

python3 "$chapter5_notes/示例/构建示例APK.py" \
  --aosp-top "$chapter5_top" --module "$chapter5_notes/示例/Chapter5MessageOverlay" \
  --name Chapter5MessageOverlay --out "$chapter5_run/overlay"
"$chapter5_adb" -s "$chapter5_serial" install "$chapter5_run/overlay/Chapter5MessageOverlay.apk"
"$chapter5_adb" -s "$chapter5_serial" shell cmd overlay enable --user 0 com.example.pmresdemo.overlay
"$chapter5_adb" -s "$chapter5_serial" shell cmd overlay list --user 0 com.example.pmresdemo
"$chapter5_adb" -s "$chapter5_serial" shell cmd overlay dump com.example.pmresdemo.overlay
python3 "$chapter5_notes/示例/运行并采集.py" \
  --adb "$chapter5_adb" --serial "$chapter5_serial" --out "$chapter5_run/run-overlay-on" \
  --expect-version 1 --expect-marker created-by-version-1 --expect-en 'Overlay resource'

按文章顺序此时基础包仍为 v1,预期 Overlay 状态启用、本轮英文值改变。若已经进行过 v2 更新,应将版本判据相应改为 2;如为用户 build、shell 无权修改或目标策略不满足,先核对 cmd overlay help、用户和 dump 状态,不要关闭全局安全策略。

恢复只针对本实验包:

"$chapter5_adb" -s "$chapter5_serial" shell cmd overlay disable --user 0 com.example.pmresdemo.overlay
python3 "$chapter5_notes/示例/运行并采集.py" \
  --adb "$chapter5_adb" --serial "$chapter5_serial" --out "$chapter5_run/run-overlay-off" \
  --expect-version 1 --expect-marker created-by-version-1 --expect-en 'English resource v1'

预期资源回到当前基础版本的值。重新启动让本实验绕开旧进程中已持有对象的影响;这不表示所有真实应用都必须强停才能处理配置变化。

split 与共享资源怎样放进同一模型

split APK 可以承载代码、语言、密度或功能资源,安装集合和依赖必须一致;pm path 可能返回 base 与多条 split 路径。ResourcesManager 按资源路径和依赖组织 ApkAssets,资源 ID 的 package 关系和动态引用映射再参与查找。

本章示例为单 APK,因此 pm path 只有基础路径。分析真实 split 应用时,先用 pm path 取得全部路径,再核对 split 名称、签名、版本与依赖。不要只拉一个语言 split 就推断资源表损坏;多 APK Session 与多包原子安装也不是同一个概念。

5.10 从文件映射走到页缓存、ext4 与 VirtIO block

先用设备证据选底层分支

本章普通安装最终位于 /data。底层实现必须取自目标设备,不能只因第一章使用 Emulator 就猜文件系统或块设备名称。

以下只读查询在有权限的实验设备上执行;需要时先使用 adb root 并等待重连。它重启 adbd,不会替应用授予任意 API 权限。先查自己的 /data 挂载来源,再填入设备名;下面的 dm-6、vdc 仅是 2026-10-19 的历史结果,不是可通用复制的设备名。

"$chapter5_adb" -s "$chapter5_serial" root
"$chapter5_adb" -s "$chapter5_serial" wait-for-device
"$chapter5_adb" -s "$chapter5_serial" shell cat /proc/mounts > "$chapter5_run/mounts.txt"
cat "$chapter5_run/mounts.txt"
read -r -p '填写 /data 对应块设备的 basename(如历史 dm-6):' chapter5_data_block
"$chapter5_adb" -s "$chapter5_serial" shell ls -l "/sys/class/block/$chapter5_data_block/slaves"
read -r -p '填写实际底层块设备的 basename(如历史 vdc):' chapter5_leaf_block
"$chapter5_adb" -s "$chapter5_serial" shell ls -l "/sys/class/block/$chapter5_leaf_block/device/driver"

预期能把 /data 挂载来源与实际 Driver 连起来;某层没有 slaves 或不是普通块设备时,在该边界重新定位,不能硬套 Device Mapper。历史结果是 /dev/block/dm-6 /data ext4,dm-6 的底层为 vdc,vdc 绑定 virtio_blk,保存在设备证据。

Device Mapper 是块设备映射层,具体映射目标与加密策略还需结合目标表和系统配置确认。这里的 sysfs 证据支持“经过 dm-6 到 vdc”,不单凭 dm 名字认定某一种加密目标。真实设备可能使用 F2FS、UFS 或 eMMC,按相同方法重新定位。

open 与 mmap 先建立文件和地址空间关系

VFS 是 Linux 向应用提供统一文件接口、向下衔接 ext4 等具体文件系统的一层,可对照Kernel 官方 VFS 说明。用户空间 openat 等入口经内核参数检查进入这里。do_sys_openat2 中的一个交接点是:

来源:open.c · static long do_sys_openat2(,固定提交 ccafb60de224。以下为该函数内的连续原文摘录。

struct file *f = do_filp_open(dfd, tmp, &op);

do_filp_open 进入路径查找与文件打开处理,随后有效 file 被安装到进程的 fd 表。 路径权限、挂载点、SELinux 与文件系统操作都会影响结果;不是“有 APK 路径就能忽略权限直接读取”。

安装目录创建也会进入 VFS。vfs_mkdir 在调用具体文件系统方法前检查安全钩子:

来源:namei.c · int vfs_mkdir(struct mnt_idmap *idmap, struct inode *dir,,固定提交 ccafb60de224。以下为该函数内的连续原文摘录。

error = security_inode_mkdir(dir, dentry, mode);
if (error)
	return error;

上面只保留安全检查节点,后面才通过 inode 操作调用实际文件系统的 mkdir。安装写入涉及 write/rename、元数据更新、日志和回写;API 返回、文件内容可见、块设备完成、断电后持久性是不同保证层次。不要把成功的 Os.rename 简化成“所有数据此刻都已同步到介质”。

mmap 经过地址空间检查建立 VMA;ext4_file_mmap 为普通文件设置 ext4_file_vm_ops,后者使用 filemap_fault 等实现。建立映射不要求立刻把文件全部读入物理内存。

访问映射页时怎样判断是否需要 I/O

映射缺页时按页缓存状态选择内存或存储后端

这是普通文件映射的概念路径,省略 DAX、Direct I/O、回写和竞争重试等分支;不同缺页状态可能触发预读或等待已有 I/O,不能把每次读取强制写成相同栈。

filemap_fault 先查询文件页:

来源:filemap.c · vm_fault_t filemap_fault(struct vm_fault *vmf),固定提交 ccafb60de224。以下为该函数内的连续原文摘录。

folio = filemap_get_folio(mapping, index);
if (likely(!IS_ERR(folio))) {

这里的 folio 是内核管理内存页的单位;在这条文件缓存路径中,它承载文件数据,可以包含一个或多个基础页。filemap_get_folio(mapping, index) 按文件对应的 address_space 和页索引查找它;找到之后还要判断数据是否就绪。Kernel 内存管理 API可供概念对照,本文函数分支仍以已列固定 ACK 源码为准。

页缓存以文件的 address_space 与页索引组织,不是某个 Java Resources 私有的一份缓存。 页缓存命中仍可能需要建立页表,所以“有缺页事件”不等于“发生了磁盘读取”。

其中数据尚未就绪的分支会走到读取入口:

来源:filemap.c · vm_fault_t filemap_fault(struct vm_fault *vmf),固定提交 ccafb60de224。以下为该函数内的连续原文摘录。

error = filemap_read_folio(file, mapping->a_ops->read_folio, folio);

mapping 的 read_folio 对本场景可对应 ext4_read_folio;在非内联数据的相关分支中:

来源:inode.c · static int ext4_read_folio(struct file *file, struct folio *folio),固定提交 ccafb60de224。以下为该函数内的连续原文摘录。

if (ret == -EAGAIN)
	return ext4_mpage_readpages(inode, NULL, folio);

ext4 还有 readahead 等入口,进一步组织文件块读取,进入映射与块层。这里对照的是固定 Kernel 的实现,不把某条 block 事件直接认作这一行 getString 发出的请求。

VirtIO block 怎样提交并完成请求

2026-10-19 的历史实验中,vdc 使用 virtio_blk。块层通过该 Driver 的队列操作提交请求;单请求入口 virtio_queue_rq 中:

来源:virtio_blk.c · static blk_status_t virtio_queue_rq(,固定提交 ccafb60de224。以下为该函数内的连续原文摘录。

err = virtblk_add_req(vblk->vqs[qid].vq, vbr);

virtblk_add_req 把协议头、数据与状态缓冲组织为 scatter-gather 项,再交给 virtqueue:

来源:virtio_blk.c · static int virtblk_add_req(,固定提交 ccafb60de224。以下为该函数内的连续原文摘录。

return virtqueue_add_sgs(vq, sgs, num_out, num_in, vbr, GFP_ATOMIC);

请求进入 virtqueue 后,Emulator 的设备后端处理虚拟块设备 I/O;完成会再回到 Driver。 这里是虚拟设备边界,不能替它凭空附加一个手机 UFS 控制器调用。

完成入口 virtblk_done 取回已使用的缓冲并通知块层:

来源:virtio_blk.c · static void virtblk_done(struct virtqueue *vq),固定提交 ccafb60de224。以下为该函数内的连续原文摘录。

while ((vbr = virtqueue_get_buf(vblk->vqs[qid].vq, &len)) != NULL) {
	struct request *req = blk_mq_rq_from_pdu(vbr);

	if (likely(!blk_should_fake_timeout(req->q)))
		blk_mq_complete_request(req);

块请求完成后,文件系统更新页状态,等待数据的读取路径才能继续。映射页就绪后,Native 代码可以读取数据,Java 获得相应资源内容。若文件页此前已在缓存中并就绪,这次访问可以在到达设备前返回。

5.11 用更新、失败保留与 Trace 验证调用链

先明确每轮的初始状态

下表列出按本文顺序跟做的预期判据;每轮都用独立输出目录采集,不用历史 DONE 判定本轮完成。2026-10-19、20 的实测结果分别列在本节后面的日期小节;文中的历史 PID、偏移和耗时只属于当次运行。

步骤基础包Overlay预期 marker / 英文资源
5.4 首次提交并运行v1未安装或停用created-by-version-1 / English resource v1
5.9 启用 Overlayv1启用原 marker / Overlay resource
5.9 停用 Overlayv1停用原 marker / English resource v1
5.11 普通更新v2停用原 marker / English resource v2
错密钥、内容篡改、普通降级失败保留 v2停用原 marker / English resource v2
新会话写入后 abandon保留 v2停用原 marker / English resource v2
strace 与 Perfetto沿用 v2停用不重置数据,记录当次版本

若已有旧数据,marker 不一定从 v1 创建;需要完整重做时,执行本节末尾的重置操作,再回到 5.4。下面所有 --out 目录均需为空,重复实验请换目录名。

更新 v2 并检查原数据是否仍在

先确认 v1 的本轮日志已打印 STATE marker=created-by-version-1 与 DONE。若示例 Overlay 仍启用,按 5.9 停用,使后续读到的英文文案来自基础包。然后在 Host 执行:

"$chapter5_adb" -s "$chapter5_serial" install -r "$chapter5_apk2"
python3 "$chapter5_notes/示例/运行并采集.py" \
  --adb "$chapter5_adb" --serial "$chapter5_serial" --out "$chapter5_run/run-v2" \
  --expect-version 2 --expect-marker created-by-version-1 --expect-en 'English resource v2'

预期新进程查询 version=2,英文值为 English resource v2,而 marker 仍由 v1 创建。更新后某些实现会自动恢复应用任务;历史复测曾观察到单独 force-stop 后立即 start 仍把 Intent 交给已有实例,未重新执行 onCreate。采集脚本因此在启动时使用 -S -f 0x10008000,要求清除本示例任务并创建 Activity,再按新 run 标识等待结果。

替换新版本时保留原来的数据书签

失败后验证保留的是哪个版本

这两次安装故意构造失败,后面必须重新查询和启动验证,不能只看命令中的 Failure:

"$chapter5_adb" -s "$chapter5_serial" install -r \
  "$chapter5_run/wrong-key/Chapter5PackageResourcesDemo.apk"
"$chapter5_adb" -s "$chapter5_serial" install -r "$chapter5_apk1"
"$chapter5_adb" -s "$chapter5_serial" shell dumpsys package com.example.pmresdemo \
  > "$chapter5_run/package-after-failures.txt"
python3 "$chapter5_notes/示例/运行并采集.py" \
  --adb "$chapter5_adb" --serial "$chapter5_serial" --out "$chapter5_run/run-after-failures" \
  --expect-version 2 --expect-marker created-by-version-1 --expect-en 'English resource v2'

预期错误签名返回 INSTALL_FAILED_UPDATE_INCOMPATIBLE,普通降级返回 INSTALL_FAILED_VERSION_DOWNGRADE;应用仍为 v2,marker 未被清除。本实验没有添加允许降级的标志;debuggable 等条件可能使显式降级分支不同。

另做一份“签名后篡改内容”的对照包:在 Host 复制 v2,只改未压缩 asset 的一个字节,保留其余结构,不重新签名。下面操作只写临时副本:

python3 - "$chapter5_apk2" "$chapter5_run/tampered.apk" <<'PYCODE'
import pathlib, struct, sys, zipfile
source, target = map(pathlib.Path, sys.argv[1:])
with zipfile.ZipFile(source) as archive:
    entry = archive.getinfo('assets/mapped.bin')
    assert entry.compress_type == zipfile.ZIP_STORED and entry.file_size > 0
    offset = entry.header_offset
content = bytearray(source.read_bytes())
assert content[offset:offset + 4] == b'PK\x03\x04'
name_len, extra_len = struct.unpack_from('<HH', content, offset + 26)
data_offset = offset + 30 + name_len + extra_len
content[data_offset] ^= 1
target.write_bytes(content)
PYCODE
"$chapter5_adb" -s "$chapter5_serial" install -r "$chapter5_run/tampered.apk"
python3 "$chapter5_notes/示例/运行并采集.py" \
  --adb "$chapter5_adb" --serial "$chapter5_serial" --out "$chapter5_run/run-after-tamper" \
  --expect-version 2 --expect-marker created-by-version-1 --expect-en 'English resource v2'

预期篡改包被拒绝,具体错误文字取决于签名方案和最早失败的检查;应同时保留安装错误和安装后仍为 v2 的本轮日志。不要把错误密钥包的 UPDATE_INCOMPATIBLE 固定套在内容篡改上。本文命令块故意包含失败安装,逐项检查输出;不要仅以整块最后一条命令的退出码判断全部行为。

主动放弃新会话,再确认 v2

最后观察主动放弃会话。仍在 Host 的终端 A 操作:重新创建会话、写入 APK,然后直接 abandon,不执行 commit,也不复用前面已提交的 Session ID。 已安装包仍为 v2,下面写入的 v1 只是新会话中的临时输入:

chapter5_abandon_size=$(stat -c %s "$chapter5_apk1")
"$chapter5_adb" -s "$chapter5_serial" push "$chapter5_apk1" /data/local/tmp/chapter5-abandon-v1.apk
chapter5_abandon_create=$("$chapter5_adb" -s "$chapter5_serial" shell pm install-create \
  -r --user 0 -S "$chapter5_abandon_size")
printf '%s\n' "$chapter5_abandon_create"
chapter5_abandon_session=$(printf '%s\n' "$chapter5_abandon_create" | sed -n 's/.*\[\([0-9][0-9]*\)\].*/\1/p')
test -n "$chapter5_abandon_session"
"$chapter5_adb" -s "$chapter5_serial" shell pm install-write \
  -S "$chapter5_abandon_size" "$chapter5_abandon_session" base.apk /data/local/tmp/chapter5-abandon-v1.apk
"$chapter5_adb" -s "$chapter5_serial" shell pm install-abandon "$chapter5_abandon_session"
"$chapter5_adb" -s "$chapter5_serial" shell pm path com.example.pmresdemo
python3 "$chapter5_notes/示例/运行并采集.py" \
  --adb "$chapter5_adb" --serial "$chapter5_serial" --out "$chapter5_run/run-after-abandon" \
  --expect-version 2 --expect-marker created-by-version-1 --expect-en 'English resource v2'

预期创建、写入与 abandon 均成功,随后仍能查到已安装路径;采集脚本退出码为 0,确认版本仍为 2、marker 仍由 v1 创建,英文值为 English resource v2。此处的 --out 也必须为空目录,重复实验时换一个新名称。放弃会话、失败事务清理、恢复到一份旧 APK,以及系统 RollbackManager 的回滚,是不同机制。 上述历史记录验证前两种,未验证系统自动回滚。

用 strace 看一次资源读取的系统调用

仅在允许 ptrace 的 userdebug 实验设备执行。示例支持 delay_ms,先留出附加时间,再让工作线程读取资源。不要对其他应用附加跟踪。

先准备好 Host 终端 B,再开始倒计时。在终端 A 打印本章现有变量的 Bash 赋值,把输出原样复制到 B 执行;后面的 Perfetto 也复用这一组值,不在 B 重新运行 mktemp:

declare -p chapter5_top chapter5_notes chapter5_run chapter5_adb \
  chapter5_serial chapter5_apk1 chapter5_apk2

终端 A 启动应用采集,终端 B 附加 strace。 先在 B 记录启动前的进程 PID,并为这轮跟踪生成独立文件名。尚无旧进程时,旧 PID 留空即可。

chapter5_old_pid=$("$chapter5_adb" -s "$chapter5_serial" shell pidof com.example.pmresdemo | tr -d '\r')
chapter5_trace_name="chapter5-assets-$(date +%s%N).strace"
chapter5_trace_device="/data/local/tmp/$chapter5_trace_name"

B 准备好后,在 A 执行下列命令。示例给工作线程的文件读取留出 15 秒附加时间,脚本按本轮标识等待 DONE:

python3 "$chapter5_notes/示例/运行并采集.py" \
  --adb "$chapter5_adb" --serial "$chapter5_serial" --out "$chapter5_run/run-strace" \
  --delay-ms 15000 --timeout 60 \
  --expect-version 2 --expect-marker created-by-version-1 --expect-en 'English resource v2'

在延迟结束前,终端 B 确认已经换成新的示例进程,再附加。若旧进程还在,等 A 启动完成后重查;窗口已过就换一轮:

chapter5_pid=$("$chapter5_adb" -s "$chapter5_serial" shell pidof com.example.pmresdemo | tr -d '\r')
if [[ "$chapter5_pid" =~ ^[0-9]+$ && "$chapter5_pid" != "$chapter5_old_pid" ]]; then
  "$chapter5_adb" -s "$chapter5_serial" shell strace -f -tt -T \
    -e trace=openat,mmap,munmap,read,pread64,close \
    -p "$chapter5_pid" -o "$chapter5_trace_device"
else
  printf '%s\n' '尚未取得这轮的新进程 PID'
fi

终端 A 的采集脚本通过,表示本轮 DONE 与预期均满足。此时在终端 B 按 Ctrl+C 结束 strace,再由 B 拉取:

"$chapter5_adb" -s "$chapter5_serial" pull \
  "$chapter5_trace_device" "$chapter5_run/$chapter5_trace_name"
test -s "$chapter5_run/$chapter5_trace_name"

以 strace 的附加提示、本轮新文件以及 A 端同一 run 的 PID、文件读取线程 TID 交叉核对。只有进程实例与读取区间都对得上,才把这些系统调用用于解释本轮操作。附加过晚、PID 不符或找不到相关读取时,记录本轮跟踪无效。重试使用新的采集目录与文件名,适当增加 delay-ms、timeout。缺少记录本身无法判断是否命中缓存。

2026-10-19 的历史实验已附加到示例进程并取得 mmap、pread64、openat、munmap 等记录。若系统没有 strace 或权限拒绝,保留应用日志与 self maps 证据,并按实验环境解决跟踪工具问题;不通过放宽全局 SELinux 代替分析。

用 Perfetto 对应系统安装与应用区间

配套 追踪配置/第五章PackageResources.pbtxt 采集 20 秒,包含 pm、am、dalvik、disk、应用 Trace 与调度事件。这次终端 A 运行 Perfetto,终端 B 执行安装与应用采集,与上一组 strace 分工不同;B 需按原值复用 A 的全部路径、serial 与临时目录变量。在终端 A 启动采集:

"$chapter5_adb" -s "$chapter5_serial" shell perfetto --txt -c - \
  -o /data/misc/perfetto-traces/chapter5-install.perfetto-trace \
  < "$chapter5_notes/示例/追踪配置/第五章PackageResources.pbtxt"

在终端 B,于这 20 秒内执行同版本重装并启动应用;当前沿用 v2,不重新安装 v1:

"$chapter5_adb" -s "$chapter5_serial" install -r "$chapter5_apk2"
python3 "$chapter5_notes/示例/运行并采集.py" \
  --adb "$chapter5_adb" --serial "$chapter5_serial" --out "$chapter5_run/run-perfetto" \
  --expect-version 2 --expect-marker created-by-version-1 --expect-en 'English resource v2'

终端 A 的 Perfetto 退出后,在 A 拉取 Trace:

"$chapter5_adb" -s "$chapter5_serial" pull \
  /data/misc/perfetto-traces/chapter5-install.perfetto-trace \
  "$chapter5_run/chapter5-install.perfetto-trace"

在 Perfetto 中先看 system_server 的 installPackages、preparePackage、scanPackage、commitPackages,再看应用进程的 Chapter5/resources 与 Chapter5/assets。它们处在不同进程和阶段;嵌套区间不能直接相加得到总安装时间。完整配置和查询 SQL 均在第五章的配套 追踪配置/ 目录。

历史实测:2026-10-19

以下原始实测使用当时可连接的 SDK Emulator 与本章独立示例包,serial 为 emulator-5564,fingerprint 为 Android/sdk_phone64_x86_64/emu64x:17/CP2A.260605.016/eng.ajie:userdebug/test-keys。APK 使用本文独立 Host 构建脚本生成,没有把这次结果写成 Soong 模块构建成功。

场景真实观察
初次 SessionSession ID=426433312;写入 25187 字节;提交前查不到包,提交后 Success
v1应用 PID=2705,工作线程 TID=2722;version=1,marker 由 v1 创建
v2 更新version=2,字符串后缀变 v2;marker 仍为 created-by-version-1
错误签名INSTALL_FAILED_UPDATE_INCOMPATIBLE;随后仍可启动 v2
普通降级INSTALL_FAILED_VERSION_DOWNGRADE;marker 与 v2 保留
放弃会话写入后 abandon,已安装版本仍为 v2
OverlaySTATE_ENABLED 后英文为 Overlay resource;中文仍为中文资源 v2;停用后英文恢复
raw 与 assetsraw=78 字节,compressed.txt 解压后 11776 字节,mapped.bin=9728 字节
openFdmapped.bin 的 offset=60、length=9728;compressed.txt 被拒绝
映射与跟踪v1 日志观察到两个 APK 映射;另一次 PID=3005 的运行成功采集 strace
存储后端/data 为 ext4,dm-6 的底层 vdc 使用 virtio_blk

该轮 APK 中 compressed.txt 的 ZIP 方法为 8,压缩大小 74 字节;mapped.bin 与 resources.arsc 的 ZIP 方法为 0,资源表大小 2264 字节。压缩状态来自 ZIP 条目检查,不能仅凭文件扩展名推断。

下面从真实 strace 选取四个相关节点,中间省略其他调用。读取 ZIP 条目的名称字段之后出现相应 mmap;所选条目分别为压缩与未压缩条目:

3023  14:51:18.234481 pread64(81, "assets/compressed.txt", 21, 12898) = 21 <0.000019>
3023  14:51:18.234522 mmap(NULL, 705, PROT_READ, MAP_SHARED, 81, 0x3000) = 0x734935cf3000 <0.000044>
3023  14:51:18.234885 pread64(81, "assets/mapped.bin", 17, 30) = 17 <0.000019>
3023  14:51:18.234926 mmap(NULL, 9788, PROT_READ, MAP_SHARED, 81, 0) = 0x734931c02000 <0.000019>

705 与 9788 是传给 mmap 的请求长度 条目长度 + slop,不是已向上取整的整页长度,也不是解压后内容长度。 本轮压缩条目是 74 + 631 = 705,未压缩条目是 9728 + 60 = 9788;文件起始偏移向下对齐,内核按页管理实际映射范围。映射起点也不一定是条目的逻辑起点,正好对应 5.8 的 slop 计算。此处可以支持用户空间确实采用了这些文件读取与映射操作,不能据此证明每次 mmap 都触发了 vdc 设备读取。

真实 Trace 的区间如下,数值只描述本轮小示例:

区间PID / TID持续时间
installPackages646 / 71016.613 ms
preparePackage646 / 7101.066 ms
scanPackage646 / 7100.276 ms
commitPackages646 / 71010.199 ms
Chapter5/resources2705 / 27222.477 ms
Chapter5/assets2705 / 27220.572 ms

prepare、scan、commit 与 installPackages 有包含关系;这张表不用于把阶段耗时直接求和,也不代表从 Host 发起安装到命令退出的端到端延迟。Kernel 的具体函数栈与某个资源页对应的块请求没有在本轮逐一追踪,底层机制依据固定源码与后端证据说明。

完整命令、关键日志、实际 ZIP 条目、CSV、SHA256 与原始 Trace 位置见第五章设备与 Trace 实测。

历史复测:2026-10-20

修订示例在 SDK Emulator emulator-5576 上完成了 14 项判据,使用同一 android17-release 用户空间基线。本次没有清空全局日志,也没有声明使用全新 userdata;先确认本章包不存在,再从 v1 安装开始。

对照实际结果
引用资源alias=0x7f020002,未解析时 type=1、data=0x7f020001;alias-en 与 en 相同
历史 DONE 干扰保留上一轮成功日志,给新一轮设置 3 秒延迟、0.6 秒超时,脚本正确失败
更新与数据v2 生效,marker 仍为 created-by-version-1
错误密钥与普通降级分别为 UPDATE_INCOMPATIBLE 与 VERSION_DOWNGRADE,随后仍可运行 v2
签名后篡改INSTALL_PARSE_FAILED_NO_CERTIFICATES,错误详情为 APK Signature Scheme v3 的 SHA-256 内容摘要验证失败
Overlay本轮英文开启后为 Overlay resource,停用后为 English resource v2
判据不符本轮已 DONE,但故意填写错误英文预期,脚本仍返回失败

这里的 14 项是 2026-10-20 修订的设备判据,与前一日的 15 项记录分别保存;本次没有重新采集 strace、Perfetto 或逐页块 I/O。

采集脚本版本边界。 配套脚本在上述设备复测后又收紧了 ERROR/DONE 的正则匹配。这次修改用保存的日志做了回放核对,历史 14 项对应的是修改前的设备复测。

修订验证、启动竞争与完整本轮日志。

实验结束后重置

要重新观察提交前后的变化,如果本章 Overlay 仍启用,先只执行 5.9 的停用命令。然后卸载 Overlay 和示例应用。卸载会删除示例应用的数据,需保留的记录应先导出。

"$chapter5_adb" -s "$chapter5_serial" uninstall com.example.pmresdemo.overlay
"$chapter5_adb" -s "$chapter5_serial" uninstall com.example.pmresdemo
"$chapter5_adb" -s "$chapter5_serial" shell pm path --user 0 com.example.pmresdemo

设备正常响应且查不到示例路径后,按 5.1 新建本轮目录,按 5.3 准备三个 APK,再回到 5.4 创建新 Session。先完成 v1 的首次提交和运行,再做 v2 更新对照。

5.12 排查、自测与源码速查

先按失败边界定位

现象先核对什么对应机制
AAPT2 找不到资源或引用默认资源、资源名称、依赖 android.jar、compile 与 link 输入构建契约,尚未进入安装
找不到 R 或 Activity 编译失败是否先 link 生成 R.java,Java 包名是否一致资源代码生成与 Java 消费者衔接
INSTALL_FAILED_UPDATE_INCOMPATIBLE新旧签名与签名轮换关系更新身份校验;-r 不会绕过
INSTALL_FAILED_VERSION_DOWNGRADE已装版本、请求版本与显式降级策略更新版本校验
Session 提交后没有最终成功statusReceiver、pending user action、会话错误与用户异步安装状态
pm path 成功但应用查不到另一个包调用 UID、用户、flags、包可见性查询过滤与身份差异
Resources.NotFoundExceptionID 的来源、类型、base/split 集合与实际资源表资源定位,不能只查 Java 包名
夜间资源不符合预期locale 与 night 的组合限定、Configuration、配置上下文候选匹配与优先级
Overlay 没生效targetPackage、targetName、overlayable 策略、用户、状态、配置映射与候选选择
openFd 失败但 open 成功最终 ZIP 压缩方法是否能用原始文件区间描述内容
mmap 存在但没有对应磁盘事件页表、页缓存、既有 I/O 与采集范围映射与实际块 I/O 的条件边界
文件操作权限拒绝UID/GID、目录权限、SELinux、用户解锁与 CE/DE文件与安全模型

不要为调查单个资源性能在日常设备上全局 drop_caches。需要冷态对照时使用隔离 Emulator、记录快照/重启方式,并把“进程冷启动”和“全局页缓存冷态”分别定义。

把 APK、包状态和资源值接起来

  1. 构建:AAPT2 compile/link 生成资源表、二进制资源与 R.java。Java 代码引用这些 ID,再与资源一起打包成签名 APK。
  2. 安装:PackageInstaller Session 接收并封存输入,系统解析与校验,按策略处理代码路径、数据目录和 dexopt,提交包状态,再通过接收者通知结果。
  3. 查询与初始化:PackageManager 返回当前调用者可见的包状态。应用启动时另通过 ApplicationInfo 接收路径,ResourcesManager 据此建立资源查询环境。
  4. 资源值:Resources 经 AssetManager、JNI 和 AssetManager2 按配置选择条目;字符串的来源 cookie 与池索引最终得到 Java 文本。
  5. 数据来源:ApkAssets 与 ZIP Provider 载入资源表和文件,未压缩与压缩条目采用适合的访问方式;文件映射缺页且数据未就绪时,才可能继续到文件系统与存储 Driver。
  6. 返回与恢复:读取完成后由应用消费结果,流、fd 与映射各按生命周期释放。失败更新和放弃新会话后可以重新启动并验证原版本,停用 Overlay 后重新查询基础资源。

同一次更新可以留下两个不同的结果。包管理服务登记了新 APK,应用重新取到 v2 的英文资源值。用户数据按普通更新规则保留,所以 SharedPreferences 仍能读到 v1 写下的 marker。

自测与参考答案

问题参考答案或定位
APK 写完 Session 后,为什么还不能当作已安装包启动?还没完成校验与包状态提交,见 5.4~5.5
commit 返回是否代表安装成功?不代表;检查 statusReceiver 的最终状态,普通应用还可能等待用户操作
是否所有 APK 文件操作都在 installd?不是;本基线普通代码路径可由 system_server 的 Os.rename 处理,数据目录另经 installd
安装成功是否代表全部 DEX 已 AOT 编译?不代表;ART Service 根据策略选择、跳过或复用编译产物
getPackageInfo 是否每次都跨 Binder 扫描 APK?不会;有进程缓存,远端也主要查询包状态并过滤
一次 getString 是否由 PackageManagerService 返回文本?本章本应用查询在应用进程的资源栈中完成,见 5.7
shell 等待与安装异步是否矛盾?不矛盾;处理 shell 命令的线程可阻塞等待,Handler 等执行者推进工作,见 5.4
重启后为什么还能查到包?Settings 持久化包和用户状态,启动读取并结合 APK 扫描重建,见 5.5
Resources 查询环境在哪里建立?应用/Activity 的 Context 经 LoadedApk、ResourcesManager 组织来源和实现,见 5.7
引用资源的 data 一定是字符串池索引吗?不是;TYPE_REFERENCE 时是目标资源 ID,解析到 TYPE_STRING 后才是池索引
APK 自身签名有效就能替换旧包吗?不能;还要满足新旧签名身份、版本等更新条件
cookie 与 R.string.message、fd 有什么区别?分别是来源编号、资源 ID 与文件描述符,不能互换
为什么 en-night 在本例返回英文普通值?语言候选优先影响匹配;需要英文夜间专用资源时补 values-en-night
为什么压缩文件也出现 mmap?可先映射压缩字节再解压,见 5.8 与实际 strace
openFd 返回的 fd 是否从偏移零开始就是目标文件?不一定;必须考虑 startOffset 和 length
mmap 是否会把 APK 全部立即读入?不会;按地址空间、页表、页缓存和缺页状态进一步决定
为什么缺页也不一定访问磁盘?所需文件页可能已在全局页缓存中,只需建立映射或等待已有工作
怎样证明本轮最后使用了 VirtIO block?/data 挂载点、dm-6 slaves 与 vdc driver 形成设备关系证据;没有逐页请求栈证明
更新失败后怎样确认旧包还可用?重新查询、启动并核对版本和持久数据;不能只看 Failure 字样
普通放弃会话等于系统回滚吗?不等于;RollbackManager 的授权、版本和数据策略需要另行验证

固定源码与后续阅读

本文用户空间摘录使用 android17-release 的下列固定提交;底层对照使用与历史 SDK Emulator 设备版本线索对应的 ACK 提交。每个代码块还链接到对应文件与范围。原始范围校验见2026-10-19 记录,新增源码、图示与实验脚本的校验见2026-10-20 修订记录。

项目固定提交
frameworks/base94b4c163b7dfe5ce3607f7bb8456f9573f7de57d
frameworks/nativeae266dcb706d083868578cfedce381ef44488a07
system/core545d2487e38192a2ce25040897ced877cf6b4f53
system/incremental_delivery6b853f9e5703a8c90648f82850a3a01d9763e619
system/libbasefef4173e19d97cd4b4fc09a06bccbf800d0d3937
kernelccafb60de224d35a8bc14de33e1cd47caaaa786b
artb753cf97923c3695338d21466fa14c57b480a59a
bionic06356e41c5ed7b12220b24c05ba4fdb873b126a7
目的关键文件与符号
看会话入口与回调等待PackageManagerShellCommand.doCommitSession、PackageInstallerSession.commit
看异步安装阶段InstallingSession.installStage、InstallPackageHelper.installPackagesTraced
看数据目录AppDataHelper、Installer、InstalldNativeService.createAppData、createAppDataDirs
看 ART 服务边界DexOptHelper、ArtManagerLocal、Dexopter.dexoptFile、artd Artd::dexopt
看包登记与重启恢复InstallPackageHelper.commitPackagesLocked / updateSettingsLI、Settings、InitAppsHelper
看包查询ApplicationPackageManager、PackageManager 查询缓存、ComputerEngine
看应用资源来源LoadedApk、ResourcesManager、ApkAssets.loadFromPath
看字符串查找Resources.getText、AssetManager.getResourceValue、AssetManager2.GetResource / FindEntry
看字符串池AssetManager.getPooledStringForCookie、ApkAssets.getStringFromPool
看 Overlay 管理与通知OverlayManagerService、OverlayManagerServiceImpl、IdmapManager、IdmapDaemon、Idmap2Service
看签名验证与更新身份ApkSignatureVerifier、FrameworkParsingPackageUtils、PackageManagerServiceUtils.verifySignatures
看资源映射ZipAssetsProvider.OpenInternal、IncFsFileMap、MappedFile.Create
看 Kernel 文件与缓存do_sys_openat2、filemap_fault、ext4_read_folio / readahead
看本轮设备后端virtio_queue_rq、virtblk_add_req、virtblk_done

本章代表场景覆盖普通单 APK 安装/更新、资源配置、可变 Overlay 与常规文件读取。APEX/staged、Incremental FS、完整 split 安装组合、签名轮换、系统自动回滚、CE 锁定状态与真实手机存储后端属于单独扩展场景,不能用本轮实验宣称全部已经验收。更广的 Storage、Permission、ART 与 OTA 机制分别衔接后续章节。