点一下“下一帧”,onDraw() 已经执行,屏幕上的圆却可能还在原处。在本章的普通硬件加速 View 中,onDraw() 记录绘制操作。RenderThread 随后生成窗口 buffer,SurfaceFlinger 再组织合成与呈现。 这几个时间点可以相隔不止一帧。
读卡顿 Trace 时,可以先找应用主线程的 Ch7.update 与 Ch7.onDraw_record,再找对应的 RenderThread 与 SurfaceFlinger 帧。前两条区间能回答应用何时更新、何时记录,屏幕何时呈现则需要后续时间线或后端证据。示例和预期判据在 7.2 与 7.13。
7.1 从整体架构认识窗口与一帧
先分清窗口控制与像素数据
WindowManager 是应用可接触的窗口管理接口;WindowManagerService(WMS)在 system_server 中管理窗口身份、位置、可见性、层级与输入相关策略。SurfaceFlinger 是独立 Native 系统服务,依据 Layer 状态和 buffer 组织屏幕合成。WMS 决定窗口如何摆放;应用负责生成内容;SurfaceFlinger 负责把各个内容组织为显示输出。 WMS 不在每次 Canvas.drawCircle() 时替应用画圆。
先沿蓝线看窗口控制。应用以 IWindowSession 进入 system_server,WMS 再用窗口事务把位置、层级与可见性等状态交给 SurfaceFlinger。沿绿线看内容,应用侧 BLAST 把 buffer 引用与同步依赖交给 SurfaceFlinger,后者经 Composer AIDL 协商合成并提交显示。紫色虚线标出同步和释放反馈。
图按应用层、Java API Framework 与系统服务、Android Runtime 与 Native C/C++ 库及服务、HAL、Linux Kernel 排列。卡片标题另标运行归属。应用、system_server、SurfaceFlinger 和 Composer HAL 服务各有自己的边界。应用内 JNI 只跨语言接口,RenderThread 的任务入队才涉及线程交接。
沿最下方继续读,Composer 的 Goldfish 图形命令和同步分别经过 Guest 驱动,最后接到 Android 之外的 Emulator Host。Binder 驱动承载窗口和图形事务的跨进程通信,Goldfish pipe 负责 Guest 与 Host 的图形协议,二者用途不同。图中的 Host 后端来自第一章的历史配置与运行证据,选用这个分支的条件见 7.10。
给几个容易混淆的对象找位置
| 名称 | 是什么 | 本章中的关系 |
|---|---|---|
| View / DecorView | 应用进程中的界面对象树;DecorView 是窗口顶层容器 | 测量、布局、记录绘制操作 |
| ViewRootImpl | View 树连接窗口系统、绘制调度、输入接收的客户端协调者 | 一个顶层根通常对应一个实例,Activity 可有多个窗口 |
| SurfaceControl | 可向合成系统提交 Layer 状态的句柄/客户端控制对象 | 管位置、crop、层级、buffer 等事务状态,不等于像素数组 |
| Surface / ANativeWindow | 供生产者提交图形 buffer 的 Java/Native 接口 | EGL/HWUI 或软件 Canvas 通过它向队列取还 buffer |
| GraphicBuffer / HardwareBuffer | 图形缓冲区(buffer)内存的描述与包装,带尺寸、格式、usage、handle | 多方可导入同一底层分配的引用,不搬运整块 Java 对象 |
| BufferQueue / BLAST | 前者管理生产消费与 slot;后者衔接队列和 SurfaceControl 事务 | 现代普通窗口中,BLAST 的消费者位于应用侧 |
| Layer | SurfaceFlinger 组织合成的节点及状态 | 层级、变换、可见区域、buffer/颜色等一起决定输出 |
| fence | 表达异步工作完成条件的同步对象,常以 fd 传递 | buffer 已交付不代表它已写完、已显示或可重写 |
SurfaceView 为内容建立独立 Surface/Layer,适合视频、相机或独立渲染;TextureView 的 SurfaceTexture 消费内容并作为纹理参与 View/HWUI 绘制。普通 View 树的 DisplayList 和 SurfaceView 独立生产的内容不是同一个对象。后面的示例使用普通硬件加速 View,避免同时引入第二个生产者。
窗口就绪后,一帧怎样交接
先沿流程图往下走。发现圆未更新时,先问 RenderThread 有没有拿到目标 buffer,再问 SurfaceFlinger 本轮能否应用这笔事务,最后看 Composer 的提交结果。CLIENT 和 DEVICE 是逐层分工,同一显示输出可以混合使用。后端提交、实际呈现和资源可复用也各有判据。
再沿同一组生命线看交接。第一段是首次添加窗口并准备 Surface,第二段开始才是窗口就绪后的按钮更新。重点找三次交接。应用主线程把绘制任务交给 RenderThread,应用侧 BLAST 把 buffer 事务提交给 SurfaceFlinger,Composer 把显示工作交给 Guest 驱动与 Host。旧 buffer 的释放和窗口退出分别收尾。
BLAST 一列表示应用里的 Native 对象和回调职责。普通路径的 queueBuffer 可沿本地同步 listener 调到 BLAST,返回侧释放通知另有通道。图里 HAL 返回 fence fd 和 Host 完成后的信号分开画,帧与帧之间仍可流水重叠。60 Hz 的周期约 16.67 ms,120 Hz 约 8.33 ms,应用与合成的实际预算还受预测、偏移和刷新率影响。
参考 AOSP 系统架构 和 Android Graphics 架构。本章的具体实现以 7.14 的固定阅读基线 为准。
7.2 准备基线并创建最小绘制示例
先记录设备身份与后端
沿用第一章 Linux Host、已可连接的 SDK Emulator。Host 是 Linux 工作站,Guest 是 Emulator 内运行的 Android。下面是读者操作,先替换第一行工程路径;本轮不启动设备或改变既有设备状态。示例构建、安装和 Trace 采集供读者跟做,本章未实际执行。
ch7_top=/absolute/path/to/aosp
ch7_run=$(mktemp -d "$HOME/aosp-ch7.XXXXXX")
ch7_chapter="$ch7_run/材料"
mkdir -p "$ch7_chapter/示例/Chapter7GraphicsDemo/src/com/example/graphicsdemo"
mkdir -p "$ch7_chapter/示例/追踪配置"
ch7_adb="$ch7_top/out/host/linux-x86/bin/adb"
cd "$ch7_top"
"$ch7_adb" devices -l
read -r -p '输入本次设备 serial:' ch7_serial
"$ch7_adb" -s "$ch7_serial" shell getprop ro.build.fingerprint
"$ch7_adb" -s "$ch7_serial" shell uname -a
"$ch7_adb" -s "$ch7_serial" shell getprop ro.boot.hardware.gltransport
"$ch7_adb" -s "$ch7_serial" shell getprop ro.hardware.gralloc
"$ch7_adb" -s "$ch7_serial" shell getprop debug.hwui.renderer
"$ch7_adb" -s "$ch7_serial" shell getprop viewroot.ipc_rendering_packages
"$ch7_adb" -s "$ch7_serial" shell dumpsys SurfaceFlinger > "$ch7_run/surfaceflinger-before.txt"
serial 来自实际列表,不能沿用历史 emulator 编号;空列表时先完成第一章连接。属性为空只说明未显式设置,不能推断无 Vulkan 或无 HWUI。viewroot.ipc_rendering_packages 用于核对本章选用的普通应用侧渲染分支,若包含本例包名,应先按该配置重新定位 IPC rendering,不能把 BLAST 分支的结论强套过去。保存 SurfaceFlinger 输出可查显示、渲染器与 Layer;单凭 ro.hardware.vulkan=ranchu 无法证明应用本帧使用 Vulkan。
用最小示例分清更新与显示
把下面三个完整文件保存到 $ch7_chapter/示例/Chapter7GraphicsDemo/,其中 Android.bp 保存为 Android.bp.example。再到附录取打包脚本和两个追踪文件,分别保存到 $ch7_chapter/示例/ 和它下面的 追踪配置/。本轮材料目录由前一段命令新建,可直接从本文补齐。
示例按钮可以让圆单步移动、连续移动或停止。Intent 参数 main_delay_ms 在主线程更新回调中加一段可控的等待,用于与正常帧对照。
Android.bp
知识库中保存为 Android.bp.example,复制到 packages/apps 构建时改名为 Android.bp,避免知识库被 Soong 重复扫描。
android_app {
name: "Chapter7GraphicsDemo",
manifest: "AndroidManifest.xml",
srcs: ["src/**/*.java"],
sdk_version: "current",
min_sdk_version: "28",
certificate: "testkey",
optimize: { enabled: false },
}
AndroidManifest.xml
开启硬件加速与 debuggable;本例没有跨应用服务或特殊权限。
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.graphicsdemo">
<uses-sdk android:minSdkVersion="28" />
<application android:label="Graphics Demo" android:debuggable="true"
android:hardwareAccelerated="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>
src/com/example/graphicsdemo/MainActivity.java
postFrame() 防止重复登记同一个帧回调;onPause() 停止连续生产并移除回调,onDestroy() 再作幂等清理。View 里的整数是业务帧序号,不等于 SurfaceFlinger 的 frame number 或 VSYNC ID,后面的跨进程关联要另看 Trace。多语言文字使用 TextView,圆和英文计数使用自定义 Canvas 绘制。阿拉伯文使用 Java Unicode 转义,编译后仍是同一串字符。
package com.example.graphicsdemo;
import android.app.Activity;
import android.content.Context;
import android.graphics.Canvas;
import android.graphics.Color;
import android.graphics.Paint;
import android.os.Bundle;
import android.os.Process;
import android.os.SystemClock;
import android.os.Trace;
import android.util.Log;
import android.util.TypedValue;
import android.view.Choreographer;
import android.view.View;
import android.widget.Button;
import android.widget.LinearLayout;
import android.widget.TextView;
import java.text.DateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.TimeZone;
public final class MainActivity extends Activity implements Choreographer.FrameCallback {
private static final String TAG = "Ch7Graphics";
private Choreographer choreographer;
private FrameView frameView;
private boolean resumed;
private boolean continuous;
private boolean callbackPosted;
private int mainDelayMs;
private int frameNumber;
@Override public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
mainDelayMs = Math.max(0, Math.min(100, getIntent().getIntExtra("main_delay_ms", 0)));
choreographer = Choreographer.getInstance();
LinearLayout root = new LinearLayout(this);
root.setOrientation(LinearLayout.VERTICAL);
TextView title = new TextView(this);
title.setTextSize(20);
title.setText("一帧实验 / Android 图形\n中文、English、\u0627\u0644\u0639\u0631\u0628\u064a\u0629 123、🙂\n"
+ "Locale=" + Locale.getDefault().toLanguageTag()
+ " TimeZone=" + TimeZone.getDefault().getID() + "\n"
+ DateFormat.getDateTimeInstance().format(new Date())
+ "\nmain_delay_ms=" + mainDelayMs);
root.addView(title);
addButton(root, "下一帧", () -> { continuous = false; postFrame(); });
addButton(root, "连续更新", () -> { continuous = true; postFrame(); });
addButton(root, "停止更新", () -> { continuous = false; cancelFrame(); });
frameView = new FrameView(this);
root.addView(frameView, new LinearLayout.LayoutParams(
LinearLayout.LayoutParams.MATCH_PARENT, 0, 1));
setContentView(root);
Log.i(TAG, "create pid=" + Process.myPid() + " tid=" + Process.myTid());
}
private void addButton(LinearLayout root, String text, Runnable action) {
Button button = new Button(this);
button.setText(text);
button.setOnClickListener(v -> action.run());
root.addView(button);
}
private void postFrame() {
if (resumed && !callbackPosted) {
callbackPosted = true;
choreographer.postFrameCallback(this);
}
}
private void cancelFrame() {
choreographer.removeFrameCallback(this);
callbackPosted = false;
}
@Override public void doFrame(long frameTimeNanos) {
callbackPosted = false;
if (!resumed) return;
Trace.beginSection("Ch7.update");
try {
if (mainDelayMs > 0) SystemClock.sleep(mainDelayMs);
frameNumber++;
frameView.frameNumber = frameNumber;
frameView.invalidate();
if (frameNumber <= 3 || frameNumber % 60 == 0) {
Log.i(TAG, "update frame=" + frameNumber + " tid=" + Process.myTid()
+ " frameTimeNanos=" + frameTimeNanos);
}
} finally {
Trace.endSection();
}
if (continuous) postFrame();
}
@Override protected void onResume() {
super.onResume();
resumed = true;
}
@Override protected void onPause() {
resumed = false;
continuous = false;
cancelFrame();
super.onPause();
}
@Override protected void onDestroy() {
cancelFrame();
Log.i(TAG, "destroy pid=" + Process.myPid());
super.onDestroy();
}
private static final class FrameView extends View {
private final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
private int frameNumber;
FrameView(Context context) { super(context); }
@Override protected void onDraw(Canvas canvas) {
Trace.beginSection("Ch7.onDraw_record");
try {
canvas.drawColor(Color.rgb(235, 242, 250));
paint.setColor(Color.rgb(38, 105, 174));
float radius = Math.max(1, Math.min(getWidth(), getHeight()) / 10f);
float available = Math.max(0, getWidth() - 2 * radius);
float x = radius + available * (frameNumber % 120) / 119f;
canvas.drawCircle(x, getHeight() / 2f, radius, paint);
paint.setTextSize(TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
32, getResources().getDisplayMetrics()));
canvas.drawText("Frame " + frameNumber, 20, 60, paint);
if (frameNumber <= 3) {
Log.i(TAG, "onDraw frame=" + frameNumber + " hardware="
+ canvas.isHardwareAccelerated() + " tid=" + Process.myTid());
}
} finally {
Trace.endSection();
}
}
}
}
构建、安装并观察
主路径使用本章附带的独立 Host 构建脚本,调用现有 AOSP JDK、公共 android.jar、D8、aapt2 和 signapk,将这个不含额外资源的应用打成 APK。它复用了第二章已采用的构建流程;本章未实际打包 APK。缺少某个 Host 工具时脚本会列出路径,不会悄悄触发全系统编译。
在上一段同一个 Host 终端运行:
if ch7_build=$(mktemp -d "$HOME/aosp-ch7-apk.XXXXXX") &&
python3 "$ch7_chapter/示例/构建示例APK.py" \
--aosp-top "$ch7_top" \
--module "$ch7_chapter/示例/Chapter7GraphicsDemo" \
--name Chapter7GraphicsDemo --out "$ch7_build" &&
test -s "$ch7_build/Chapter7GraphicsDemo.apk" &&
"$ch7_adb" -s "$ch7_serial" install -r "$ch7_build/Chapter7GraphicsDemo.apk"; then
"$ch7_adb" -s "$ch7_serial" shell am start -S -W \
-n com.example.graphicsdemo/.MainActivity --ei main_delay_ms 0
else
printf '%s\n' '构建或安装未成功。检查错误后重试,先别启动设备上的旧包。' >&2
fi
预期脚本生成 APK 与 build-commands.json,安装输出 Success,启动后界面出现圆与三个按钮。-S 先停止本例进程,让新 Activity 读取参数 0。点击“下一帧”应移动圆并增加计数,连续模式会持续请求更新。安装失败先保留错误,如版本/签名不一致不要直接卸载其他人的应用;本例专用包名仍应先确认可覆盖。
另开 Host 终端 B,把第一行替换为与终端 A 相同的工程根路径,再单独初始化变量。日志命令持续占用终端 B,结束时按 Ctrl+C:
ch7_top=/absolute/path/to/aosp
ch7_adb="$ch7_top/out/host/linux-x86/bin/adb"
"$ch7_adb" devices -l
read -r -p '输入与终端 A 相同的 serial:' ch7_serial
"$ch7_adb" -s "$ch7_serial" logcat -v threadtime 'Ch7Graphics:I' '*:S'
依据代码,update 和 onDraw 的日志来自主线程;hardware=true 表示 Canvas 使用硬件加速绘制路径。日志不是 RenderThread/GPU 的逐函数证据,Frame 1 也不保证屏幕已呈现第一个 buffer。
需要走 Soong 时,可将示例复制到新建且无同名模块的 packages/apps/Chapter7GraphicsDemo,改名构建模板后加载第一章已确认的 lunch 配置,再执行 m Chapter7GraphicsDemo。这是独立的备选路径,本轮未执行。不要将“公共 SDK 类型校验成功”写成 Soong 或安装成功。
观察结束可在界面点“停止更新”,再退出 Activity。示例没有常驻 Service。是否卸载本例由读者决定;读者操作涉及安装/启动,本轮仅提供步骤。
7.3 窗口怎样获得 Surface 与 Layer
下文的 AOSP 源码块都是固定提交中的连续摘录。每块上方保留函数和行号,完整条件与其余分支可回到对应源码查看。
从 Activity 的内容 View 到 ViewRootImpl
Activity 的 setContentView() 设置的是窗口内部内容,真正把顶层 DecorView 接入窗口系统时会进入 WindowManagerGlobal.addView。Activity 启动/恢复与 WindowManager 的交接见第六章,本节从顶层 View 已准备好开始。应用主线程创建根对象:
来源:WindowManagerGlobal.java · public void addView(View view, ViewGroup.LayoutParams params,(本地源码)。
if (windowlessSession == null) {
root = new ViewRootImpl(view.getContext(), display);
} else {
root = new ViewRootImpl(view.getContext(), display,
windowlessSession, new WindowlessWindowLayout());
}
new ViewRootImpl 发生在应用进程,WMS 持有的对应对象是 WindowState,不是这个 Java 实例。 addView 随后登记本地 View、根与布局参数,并调用 root.setView(...)。
setView 使用的 mWindowSession 从哪里来?普通构造路径先调用 WindowManagerGlobal.getWindowSession,它缓存进程级会话;首次取得 IWindowManager(系统 window 服务)后请求 openSession:
来源:WindowManagerGlobal.java · public static IWindowSession getWindowSession()(本地源码)。
IWindowManager windowManager = getWindowManagerService();
sWindowSession = windowManager.openSession(
new IWindowSessionCallback.Stub() {
服务端 WindowManagerService 明确分配 Session 并返回 Binder 接口:
来源:WindowManagerService.java · public IWindowSession openSession(IWindowSessionCallback callback)(本地源码)。
return new Session(this, callback);
应用接收的是 IWindowSession 代理,ViewRootImpl 将它保存在 mWindowSession;另一个参数 mWindow 则是应用创建的 IWindow 本地 Stub,用于系统通知客户端窗口:
mWindow = new W(this);
会话代理指向 system_server 的 Session,IWindow 回调实体属于应用;二者不是同一 Binder node。 会话可以复用,也不等于一个 Activity 的全部生命周期。setView 把 IWindow、窗口类型与可见性等送到系统:
res = mWindowSession.addToDisplayAsUser(mWindow, mWindowAttributes,
getHostVisibility(), mDisplay.getDisplayId(), userId,
mInsetsController.getRequestedVisibleTypes(), inputChannel, addResult);
IWindowSession 是应用取得的会话 Binder 接口。请求跨 Binder 进入 system_server 的 Session,再交给 WMS:
来源:Session.java · public int addToDisplayAsUser(IWindow window,(本地源码)。
return mService.addWindow(this, window, attrs, viewVisibility, displayId, userId,
requestedVisibleTypes, outInputChannel, result);
来源:WindowManagerService.java · public int addWindow(Session session,(本地源码)。
final WindowState win = new WindowState(this, session, client, token, parentWindow,
appOp[0], attrs, viewVisibility, session.mUid, userId,
session.mCanAddInternalSystemWindow);
final DisplayPolicy displayPolicy = displayContent.getDisplayPolicy();
WindowState 把调用方 Session、IWindow、token、父窗口和属性联系起来。 WMS 在它前后做显示、token、类型、权限与策略检查。应用窗口的 token 与 Activity/容器管理有关,不能把 TYPE_APPLICATION 当作“任意进程可以新建的窗口”。添加窗口返回后,也还没有生成一帧像素。
窗口焦点是另一组状态:可见、可获得焦点、可触摸不是同一条件。WMS 的焦点和 InputWindow 信息最终供 InputDispatcher 选择目标;它不会使失去焦点的窗口立即释放所有图形资源。第八章继续解释输入通道与事件完成确认。
当前版本要区分两种 SurfaceControl 创建路径
布局协商经过 ViewRootImpl.relayoutWindow,带上请求尺寸、可见性、Insets 与序列信息。本版本受 WindowManager.useClientSurface() 控制:启用时客户端创建/复用 SurfaceControl,并通过 relayout2/relayoutAsync2 交给 WMS;关闭时沿旧分支由系统准备后回传。先看客户端创建函数:
来源:ViewRootImpl.java · private SurfaceControl createSurfaceControl()(本地源码)。
final SurfaceControl.Builder builder = new SurfaceControl.Builder()
.setCallsite("ViewRootImpl.createSurfaceControl")
.setName("VRI-" + getTitle())
.setFlags(surfaceFlags)
.setFormat((mWindowAttributes.flags
& WindowManager.LayoutParams.FLAG_HARDWARE_ACCELERATED) != 0
? PixelFormat.TRANSLUCENT : mWindowAttributes.format)
.setMetadata(SurfaceControl.METADATA_WINDOW_TYPE, mWindowAttributes.type)
.setBLASTLayer();
try {
Builder 创建的是 SurfaceFlinger Layer 的客户端控制对象,setBLASTLayer() 不是分配一块已填好像素的 framebuffer。 build 最终经 Java SurfaceControl 的 Native 实现与 SurfaceComposerClient 建立服务端 Layer。客户端的 mSurfaceControl 保存该控制关系,WMS 仍负责窗口策略与父子挂接。更新中还可能复用缓存,不能画成每次 relayout 都新建 Layer。
旧路径的 WindowStateAnimator.createSurfaceLocked 则明确排除客户端创建已开启的情况:
来源:WindowStateAnimator.java · SurfaceControl createSurfaceLocked()(本地源码)。
if (WindowManager.useClientSurface()) {
Slog.e(TAG, "No longer create client surfaces on the server side", new Throwable());
return null;
}
在同步 relayout 的客户端 Surface 分支中,客户端把有效控制对象放到参数里,返回结果继续用于窗口帧与配置更新:
relayoutResult |= mWindowSession.relayout2(mWindow, params,
requestedWidth, requestedHeight, viewVisibility,
insetsPending ? WindowManagerGlobal.RELAYOUT_INSETS_PENDING : 0,
mRelayoutSeq, seqId, surfaceControl, mRelayoutResult);
两条创建分支是备选实现,不可串成“应用先创建,再必定由 WMS 创建同一个 Surface”。本章未读取本轮设备的 feature flag 值,保留两条来源;两条路径完成后都需要一个有效的绘制目标。
把 Layer 控制关系接成可绘制 Surface
普通非 IPC-rendering 分支中,ViewRootImpl.updateBlastSurfaceIfNeeded 创建 BLAST,再把 BLAST 生产者端包装成 Java Surface:
来源:ViewRootImpl.java · void updateBlastSurfaceIfNeeded()(本地源码)。
mBlastBufferQueue = new BLASTBufferQueue(mTag, true /* updateDestinationFrame */);
// If we create and destroy BBQ without recreating the SurfaceControl, we can end up
// queuing buffers on multiple apply tokens causing out of order buffer submissions. We
// fix this by setting the same apply token on all BBQs created by this VRI.
mBlastBufferQueue.setApplyToken(mBbqApplyToken);
mBlastBufferQueue.update(mSurfaceControl, mSurfaceSize.x, mSurfaceSize.y,
mWindowAttributes.format);
mBlastBufferQueue.setTransactionHangCallback(sTransactionHangCallback);
来源:ViewRootImpl.java · void updateBlastSurfaceIfNeeded()(本地源码)。
blastSurface = mBlastBufferQueue.createSurfaceWithHandle();
// Only call transferFrom if the surface has changed to prevent inc the generation ID and
// causing EGL resources to be recreated.
mSurface.transferFrom(blastSurface);
mSurface 接到的是应用可生产 buffer 的接口;mSurfaceControl 是它要提交到的 Layer 控制关系。 二者在 BLAST 中关联。Java BLASTBufferQueue 构造函数把 nativeCreate 的返回值存到 mNativeObject;Native 分配位置是:
来源:android_graphics_BLASTBufferQueue.cpp · static jlong nativeCreate((本地源码)。
sp<BLASTBufferQueue> queue = sp<BLASTBufferQueue>::make(name.c_str(), updateDestinationFrame);
queue->incStrong((void*)nativeCreate);
return reinterpret_cast<jlong>(queue.get());
}
这里的长整数代表应用进程中的 Native BLASTBufferQueue 地址。引用计数在 nativeCreate/nativeDestroy 间配对;createSurfaceWithHandle 经 JNI 从它取得 Native Surface,再做 Java 包装。这不是 SurfaceFlinger 内部 Layer 的内存地址,也不能在别的进程解引用。
这张图只画持有与关联,不表示同步方法调用次序。先认清这些创建和绑定关系,后面读到 queueBuffer,就能把已经建立的队列与目标 Layer 接上。
7.4 Choreographer 怎样安排测量布局与绘制
invalidate 为什么不会立刻调用 onDraw
invalidate() 标记绘制内容需要更新,requestLayout() 表达布局需要重新计算。二者可以合并到同一次遍历;不是每次颜色变化都必须重新完整 measure/layout。先沿本例 frameView.invalidate() 追到根,再看根怎样安排 traversal。
此时执行者仍是示例的应用主线程。 View.invalidate() 调用 invalidate(true),后者把 View 范围传给 invalidateInternal:
来源:View.java · public void invalidate(boolean invalidateCache)(本地源码)。
invalidateInternal(0, 0, mRight - mLeft, mBottom - mTop, invalidateCache, true);
invalidateInternal 在可处理本次失效的条件下标记内容/缓存脏状态,并把损伤传到父对象;脱离窗口、无有效范围或 skipInvalidate 等条件会改变这条路径:
来源:View.java · void invalidateInternal(int l, int t, int r, int b,(本地源码)。
mPrivateFlags |= PFLAG_DIRTY;
if (invalidateCache) {
mPrivateFlags |= PFLAG_INVALIDATED;
mPrivateFlags &= ~PFLAG_DRAWING_CACHE_VALID;
}
来源:View.java · void invalidateInternal(int l, int t, int r, int b,(本地源码)。
final ViewParent p = mParent;
if (p != null && ai != null && l < r && t < b) {
final Rect damage = ai.mTmpInvalRect;
damage.set(l, t, r, b);
p.invalidateChild(this, damage);
}
本例处于硬件加速的已挂接 View 树。父 ViewGroup 的 invalidateChild 选择硬件快速路径:
来源:ViewGroup.java · public final void invalidateChild(View child, final Rect dirty)(本地源码)。
final AttachInfo attachInfo = mAttachInfo;
if (attachInfo != null && attachInfo.mHardwareAccelerated) {
// HW accelerated fast path
onDescendantInvalidated(child, child);
return;
}
ViewGroup.onDescendantInvalidated 汇总后代脏状态,再向自己的父对象继续传播:
来源:ViewGroup.java · public void onDescendantInvalidated(@NonNull View child, @NonNull View target)(本地源码)。
if (mParent != null) {
mParent.onDescendantInvalidated(this, target);
}
到根时,接收者已经是 ViewRootImpl。它的 onDescendantInvalidated 调用本类 invalidate,后者再按条件安排 traversal:
invalidate();
来源:ViewRootImpl.java · void invalidate()(本地源码)。
mDirty.set(0, 0, mWidth, mHeight);
if (!mWillDrawSoon) {
scheduleTraversals();
}
View.invalidate 和 ViewRootImpl.invalidate 是不同对象的方法;前者经父树传播到后者,并没有直接调用 onDraw。 传播过程中可以合并更新,软件层与非硬件分支也有不同处理。本例接下来的共同入口是 scheduleTraversals。
根怎样把一次失效合并到 traversal
ViewRootImpl.scheduleTraversals 用 mTraversalScheduled 合并重复安排,在关键路径上登记 traversal 的 VSYNC 回调:
来源:ViewRootImpl.java · void scheduleTraversals()(本地源码)。
postTraversalBarrier();
mChoreographer.postVsyncCallback(
Choreographer.CALLBACK_TRAVERSAL, mTraversalCallback);
notifyRendererOfFramePending();
pokeDrawLockIfNeeded();
当前代码是 postVsyncCallback(CALLBACK_TRAVERSAL),不能把旧版本的 postCallback 名称直接抄进来。 同步屏障帮助异步的帧工作越过相应普通消息,完整机制复用第三章;屏障不使执行中的长任务被抢占。应用主线程如果一直占用,VSYNC 已到也不能马上跑 traversal。
Choreographer 向 DisplayEventReceiver 请求后续节拍:
来源:Choreographer.java · private void scheduleVsyncLocked()(本地源码)。
mDisplayEventReceiver.scheduleVsync();
来源:DisplayEventDispatcher.cpp · status_t DisplayEventDispatcher::scheduleVsync()(本地源码)。
status_t status = mReceiver.requestNextVsync();
if (status) {
ALOGW("Failed to request next vsync, status=%d", status);
return status;
}
DisplayEventReceiver 的连接由 SurfaceFlinger 的 EventThread 等调度组件提供。请求路径可通过 Binder,事件数据经事件通道/文件描述符到 Native Looper;到达后由 NativeDisplayEventReceiver 回调 Java。事件通道可读使 Looper 被唤醒,与“主线程已经获得 CPU 并开始 doFrame”之间仍有调度距离。 不把 VSYNC 事件的每次交付都描述成一笔 Java Binder 业务回调。
VSYNC 回到主线程后怎样分阶段运行
FrameDisplayEventReceiver.onVsync 把时间和帧时间线数据保存,再投递异步 Message:
来源:Choreographer.java · public void onVsync(long timestampNanos, long physicalDisplayId, int frame,(本地源码)。
Message msg = Message.obtain(mHandler, this);
msg.setAsynchronous(true);
mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);
它的 run 再调用 Choreographer.doFrame。一次 doFrame 按阶段运行回调:
来源:Choreographer.java · void doFrame(long frameTimeNanos, int frame,(本地源码)。
mFrameInfo.markInputHandlingStart();
doCallbacks(Choreographer.CALLBACK_INPUT);
mFrameInfo.markAnimationsStart();
doCallbacks(Choreographer.CALLBACK_ANIMATION);
doCallbacks(Choreographer.CALLBACK_INSETS_ANIMATION);
mFrameInfo.markPerformTraversalsStart();
doCallbacks(Choreographer.CALLBACK_TRAVERSAL);
doCallbacks(Choreographer.CALLBACK_COMMIT);
示例 postFrameCallback 在动画阶段更新圆。如果本帧还未取走 traversal 回调,这次 invalidate 可以赶上同一轮 doFrame。 Choreographer 做时间校正、过期/跳帧判断与回调组织;不是简单每 16 ms 的 Handler 定时器。SurfaceFlinger 的 Scheduler 使用显示节拍估计与预测安排工作,HWC 节拍用于反馈/校准,应用节拍和合成节拍可能有不同偏移。
ViewRootImpl.doTraversal 清掉“已安排”状态,移除屏障,再进入 performTraversals:
来源:ViewRootImpl.java · void doTraversal(long frameTimeNanos)(本地源码)。
if (mTraversalScheduled) {
mTraversalScheduled = false;
removeTraversalBarrier();
performTraversals(frameTimeNanos);
}
}
performTraversals 依据首次布局、尺寸、可见性和脏区等条件执行 measure、layout、relayout 与 draw。measure 计算尺寸约束下的结果,layout 确定子 View 的几何位置,draw 记录/绘制内容。它们不是“一个 View 对应一次 GPU 命令”的一一关系,DisplayList 可缓存复用。
两条入口最后都回到应用主线程。帧外请求等合适的节拍,动画阶段的请求则可能被同一轮 traversal 取走。判断是否重新测量或布局时,再回到源码里的尺寸、首次布局和窗口状态等具体条件。
7.5 从 DisplayList 走到 RenderThread
硬件加速时,主线程记录什么
示例的 Canvas 为硬件加速路径时,主线程先把 drawCircle 等操作记成绘制记录:RenderNode 保存节点内容与属性,DisplayList 承载绘制操作;RenderThread 再处理这棵树并提交渲染。onDraw 里的 Java 方法耗时包含内容准备和记录工作,不能直接当成 GPU 执行时长。
ViewRootImpl 先选中硬件绘制分支
7.4 的 performTraversals 在满足绘制条件时进入 performDraw;后者调用 ViewRootImpl.draw:
来源:ViewRootImpl.java · private boolean performDraw(@Nullable SurfaceSyncGroup surfaceSyncGroup)(本地源码)。
usingAsyncReport = draw(fullRedrawNeeded, surfaceSyncGroup, mSyncBuffer);
draw 还会检查窗口/Surface、脏区、动画与无障碍绘制等条件。进入硬件启用分支后,接收者是 AttachInfo 中为这个根准备的 ThreadedRenderer:
if (!dirty.isEmpty() || mIsAnimating || accessibilityFocusDirty) {
if (isHardwareEnabled()) {
mAttachInfo.mThreadedRenderer.draw(mView, mAttachInfo, this);
mView 是本根所接的顶层 View,mAttachInfo 带根和渲染器信息,this 提供根绘制前后回调。 此调用仍在主线程;软件绘制或跳过绘制的路径不能当作这次硬件 draw。ThreadedRenderer.draw 先更新根 DisplayList,再触发同步绘制:
来源:ThreadedRenderer.java · void draw(View view, AttachInfo attachInfo, DrawCallbacks callbacks)(本地源码)。
updateRootDisplayList(view, callbacks);
沿 View 树找到需要重录的 onDraw
上面的 updateRootDisplayList 先调用 updateViewTreeDisplayList。后者把顶层 View 的失效标记转换为本次重建记录的条件,再调用该 View 的 updateDisplayListIfDirty:
来源:ThreadedRenderer.java · private void updateViewTreeDisplayList(View view)(本地源码)。
view.mPrivateFlags |= View.PFLAG_DRAWN;
view.mRecreateDisplayList = (view.mPrivateFlags & View.PFLAG_INVALIDATED)
== View.PFLAG_INVALIDATED;
view.mPrivateFlags &= ~View.PFLAG_INVALIDATED;
view.updateDisplayListIfDirty();
view.mRecreateDisplayList = false;
这里处理的是树根;ViewGroup 绘制/获取子节点时继续把相应工作传到子 View。每个 View 的 mRenderNode 记录自己的绘制内容与属性,ThreadedRenderer 的 mRootNode 是额外的渲染根容器。 缓存仍有效时 updateDisplayListIfDirty 可以复用已有记录或仅推进子节点;不能把每帧等同于重录每个 View。
当需要重建当前 View 的记录时,View.updateDisplayListIfDirty 取得本 View 的 mRenderNode,并在相应条件分支用它生成 RecordingCanvas:
来源:View.java · public RenderNode updateDisplayListIfDirty()(本地源码)。
final RenderNode renderNode = mRenderNode;
来源:View.java · public RenderNode updateDisplayListIfDirty()(本地源码)。
final RecordingCanvas canvas = renderNode.beginRecording(width, height);
这个 canvas 是当前 RenderNode 的录制目标,和 dequeue 取得的 GraphicBuffer 不是同一个对象。 软件图层、PFLAG_SKIP_DRAW 等分支另作处理;本例 FrameView 没有设置软件层或跳过自身绘制,普通分支调用当前 View 的 draw:
来源:View.java · public RenderNode updateDisplayListIfDirty()(本地源码)。
draw(canvas);
View.draw 在内容阶段调用可覆写的 onDraw,再分派子 View;下面选无 fading edges 的快速分支:
来源:View.java · public void draw(@NonNull Canvas canvas)(本地源码)。
onDraw(canvas);
// Step 4, draw the children
dispatchDraw(canvas);
这就回到示例 FrameView.onDraw:Ch7.onDraw_record 包住的 drawColor、drawCircle 和 drawText 此时把操作录到传入的 RecordingCanvas。根 ViewGroup 会递归处理需要更新的孩子,所以示例是树中的一份记录,不是直接替换整个窗口的渲染根。
本 View 完成后,finally 中结束本次录制并更新节点属性:
来源:View.java · public RenderNode updateDisplayListIfDirty()(本地源码)。
renderNode.endRecording();
setDisplayListProperties(renderNode);
ThreadedRenderer 还在自己的根 RecordingCanvas 中引用 View 树返回的 RenderNode:
来源:ThreadedRenderer.java · private void updateRootDisplayList(View view, DrawCallbacks callbacks)(本地源码)。
canvas.drawRenderNode(view.updateDisplayListIfDirty());
onDraw 返回 → 当前 View 的 endRecording → 根容器引用节点 → 后续同步到 RenderThread,才把“Java 方法执行”和“图形记录归属”接在一起。 根容器本身也按 mRootNodeNeedsUpdate/已有 DisplayList 决定是否重录;停止示例的帧回调不等于把这些缓存全部销毁。
把绘制记录交给 RenderThread
updateRootDisplayList 完成后,ThreadedRenderer.draw 取 FrameInfo,调用同步绘制入口:
来源:ThreadedRenderer.java · void draw(View view, AttachInfo attachInfo, DrawCallbacks callbacks)(本地源码)。
final FrameInfo frameInfo = attachInfo.mViewRootImpl.getUpdatedFrameInfo();
int syncResult = syncAndDrawFrame(frameInfo);
同步入口来自 HardwareRenderer;mNativeProxy 的来源在构造时建立,而不是每帧从别的进程取得:
来源:HardwareRenderer.java · public HardwareRenderer(boolean useIpcCanvas)(本地源码)。
mNativeProxy = nCreateProxy(!mOpaque, mRootNode.mNativeRenderNode, useIpcCanvas);
if (mNativeProxy == 0) {
throw new OutOfMemoryError("Unable to create hardware renderer");
}
Cleaner.create(this, new DestroyContextRunnable(mNativeProxy));
JNI 的 nCreateProxy 对应函数在本进程创建 C++ RenderProxy,并把地址返回给 Java 字段:
来源:android_graphics_HardwareRenderer.cpp · static jlong android_view_ThreadedRenderer_createProxy((本地源码)。
RenderProxy* proxy = new RenderProxy(translucent, rootRenderNode, &factory, useIpcCanvas);
return (jlong) proxy;
来源:HardwareRenderer.java · public int syncAndDrawFrame(@NonNull FrameInfo frameInfo)(本地源码)。
return nSyncAndDrawFrame(mNativeProxy, frameInfo.frameInfo, frameInfo.frameInfo.length);
来源:android_graphics_HardwareRenderer.cpp · static int android_view_ThreadedRenderer_syncAndDrawFrame((本地源码)。
RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
env->GetLongArrayRegion(frameInfo, 0, frameInfoSize, proxy->frameInfo());
return proxy->syncAndDrawFrame();
回看 7.1 的全章时序。主线程先用 RecordingCanvas 录制,再把 DrawFrameTask 放进队列。RenderThread 获得调度后才执行任务。主线程等待在哪一步解除,取决于下面的同步分支。
proxyPtr 指向应用 Native 堆的 RenderProxy,JNI 复制 FrameInfo 后仍在调用它的主线程执行。 RenderProxy 把工作交给 DrawFrameTask,真正的线程交接在任务队列:
来源:DrawFrameTask.cpp · void DrawFrameTask::postAndWait()(本地源码)。
AutoMutex _lock(mLock);
mRenderThread->queue().post([this]() { run(); });
mSignal.wait(mLock);
post 将 run 安排到 RenderThread;mSignal.wait 等待同步点。这个等待主要约束两线程共享渲染状态的安全交接,并不意味着主线程要一直等屏幕显示完成。在 RenderThread 上执行的 DrawFrameTask.run 有条件提前解除 UI 等待:
来源:DrawFrameTask.cpp · void DrawFrameTask::run()(本地源码)。
if (canUnblockUiThread) {
unblockUiThread();
}
本版本的 canUnblockUiThread 取自 syncFrameState 返回的 info.prepareTextures;该值为 false 表示纹理缓存空间不足。这个条件只决定 UI 等待的解除位置,不等于 GPU 已完成,也不保证一定能生产新 buffer。未提前解除时,run 会在后段调用 unblockUiThread,二者是互斥分支。
来源:DrawFrameTask.cpp · void DrawFrameTask::run()(本地源码)。
if (CC_LIKELY(canDrawThisFrame)) {
context->draw(solelyTextureViewUpdates);
后一个片段中的 context 是此前从 mContext 取得的 CanvasContext。存在跳过绘制、Surface 丢失等分支,因此一次 DrawFrameTask 不保证必定生产新 buffer。ThreadedRenderer 检查 syncResult,对丢 Surface 等情况请求后续 relayout/重绘。
Skia 如何落到 EGL 或 Vulkan
CanvasContext 持有当前 RenderPipeline;渲染管线选择来自 Properties:
来源:Properties.cpp · RenderPipelineType Properties::peekRenderPipelineType()(本地源码)。
bool useVulkan = use_vulkan().value_or(false);
std::string rendererProperty = base::GetProperty(PROPERTY_RENDERER, useVulkan ? "skiavk" : "skiagl");
if (rendererProperty == "skiavk") {
return RenderPipelineType::SkiaVulkan;
}
return RenderPipelineType::SkiaGL;
SkiaGL 与 SkiaVulkan 是备选后端。 常见的 debug.hwui.renderer 与 use_vulkan 配置、已锁定的进程管线状态共同决定结果。只改属性但不重建相关进程,不能保证现有上下文随即切换;本章不主动修改这些属性。
CanvasContext.draw 将准备好的节点树交给 RenderPipeline 绘制,再调用 swapBuffers。先看共同的绘制入口:
来源:CanvasContext.cpp · void CanvasContext::draw(bool solelyTextureViewUpdates)(本地源码)。
drawResult = mRenderPipeline->draw(
frame, windowDirty, dirty, mLightGeometry, &mLayerUpdateQueue, mContentDrawBounds,
mOpaque, mLightInfo, mRenderNodes, &(profiler()), mBufferParams, profilerLock());
SkiaGL 经 EglManager 的 EGL 呈现接口交出窗口内容:
来源:EglManager.cpp · bool EglManager::swapBuffers(const Frame& frame,(本地源码)。
EGLint rects[4];
frame.map(screenDirty, rects);
eglSwapBuffersWithDamageKHR(mEglDisplay, frame.mSurface, rects, screenDirty.isEmpty() ? 0 : 1);
SkiaVulkan 则通过 VulkanManager 的呈现路径。对于 Guest EGL 的窗口实现,swapBuffers 最终把本次 buffer 连同完成 fence 交给 ANativeWindow helper:
来源:egl.cpp · EGLBoolean egl_window_surface_t::swapBuffers()(本地源码)。
anwHelper->queueBuffer(nativeWindow, buffer, presentFenceFd);
appTimeMetric.onQueueBufferReturn();
这段只解释 GL/Guest EGL 分支;Vulkan 使用自己的提交与窗口系统集成,不会先调用上述 EGL 函数。它们接到 ANativeWindow 的 buffer 获取/提交接口,本章下一节沿该共同边界阅读。GPU 完成通常晚于 CPU 提交,不能把 EGL/Vulkan API 返回或 RenderThread slice 结束当作 fence 已 signal。
软件 Canvas 是另外一条分支,可能在 CPU 上直接填充图形 buffer。硬件加速关闭不意味着跳过 Surface/队列/SF/HAL 的所有后续步骤,也不意味着系统合成从此不再使用 GPU。
7.6 Surface、BufferQueue 与 BLAST 怎样交付一帧
生产者取到的是 slot 与 buffer 引用
上一节的 RenderNode 留在应用内部;接下来交付给 SurfaceFlinger 的是渲染所得 buffer 的引用与同步依赖。
Native Surface 实现 ANativeWindow 接口,渲染管线通过它 dequeue。Surface 向 IGraphicBufferProducer 索取可用 slot 与复用所需的 fence:
来源:Surface.cpp · int Surface::dequeueBuffer(sp<GraphicBuffer>* buffer, int* fenceFd)(本地源码)。
status_t result = mGraphicBufferProducer->dequeueBuffer(&buf, &fence, dqInput.width,
dqInput.height, dqInput.format,
dqInput.usage, &mBufferAge,
dqInput.getTimestamps ?
首次使用某个 slot、尺寸/格式变化或需要重分配时,requestBuffer 取得对应 GraphicBuffer;普通复用不保证每帧重新分配内存。dequeue 返回的 fence 约束上次消费者访问何时结束,生产者必须尊重它。
slot 是队列管理 buffer 引用和状态的槽位。BufferQueue 的典型 slot 状态可先记为 FREE → DEQUEUED → QUEUED → ACQUIRED → FREE;源码还包含共享 buffer、丢帧、缓存与额外 acquire 等状态变化。这里每个箭头表示队列状态转移,不是内存拷贝:
回到 FREE 表示协议上可再分配给生产者,不自动表示旧硬件访问已经结束;安全访问还受 fence 约束。 为何多缓冲:生产、合成、显示可能同时进行;代价是图形内存与排队延迟。不能把每个窗口固定成“永远三个 buffer”。
现代普通窗口中的消费者在应用侧
BLASTBufferQueue.initialize 在应用 Native 侧创建 producer、consumer 和 BufferItemConsumer:
来源:BLASTBufferQueue.cpp · void BLASTBufferQueue::initialize()(本地源码)。
createBufferQueue(&mProducer, &mConsumer);
mBufferItemConsumer =
sp<BLASTBufferItemConsumer>::make(mProducer, mConsumer,
GraphicBuffer::USAGE_HW_COMPOSER |
GraphicBuffer::USAGE_HW_TEXTURE,
1, false, wp<BLASTBufferQueue>::fromExisting(this));
Surface.queueBufferImpl 把 slot、输入的 buffer/fence 元数据和输出信息交给生产者接口:
来源:Surface.cpp · status_t Surface::queueBufferImpl((本地源码)。
status_t err = mGraphicBufferProducer->queueBuffer(slot, igbpInput, &igbpOutput);
BufferQueueProducer 完成入队状态与事件组织后,在相应 listener 上触发帧可用通知:
来源:BufferQueueProducer.cpp · status_t BufferQueueProducer::queueBuffer(int slot,(本地源码)。
if (frameAvailableListener != nullptr) {
frameAvailableListener->onFrameAvailable(item);
} else if (frameReplacedListener != nullptr) {
frameReplacedListener->onFrameReplaced(item);
}
BLAST 在 initialize 中登记了这个 listener,再由 onFrameAvailable/acquireNextBufferLocked 消费队列项目。它取得 GraphicBuffer、acquire fence 与 frame number,组装目标 SurfaceControl 的事务:
来源:BLASTBufferQueue.cpp · status_t BLASTBufferQueue::acquireNextBufferLocked((本地源码)。
t->setBuffer(mSurfaceControl, buffer, fence, bufferItem.mFrameNumber, mProducerId,
releaseBufferCallback, dequeueTime);
t->setDataspace(mSurfaceControl, static_cast<ui::Dataspace>(bufferItem.mDataSpace));
t->setHdrMetadata(mSurfaceControl, bufferItem.mHdrMetadata);
t->setSurfaceDamageRegion(mSurfaceControl, bufferItem.mSurfaceDamage);
BLAST 把 buffer 和 Layer 状态交给 SurfaceFlinger,SurfaceFlinger 不需要再把这条应用侧队列当作旧版直接消费队列。 视频、SurfaceTexture、屏幕录制等其他 producer/consumer 组合仍可能采用不同连接,不能把本例的拓扑扩展为所有图形对象。
Transaction.setBuffer 的数据对象是明确创建出来的:
std::shared_ptr<BufferData> bufferData = std::make_shared<BufferData>();
bufferData->buffer = buffer;
if (buffer) {
uint64_t frameNumber = sc->resolveFrameNumber(optFrameNumber);
bufferData->frameNumber = frameNumber;
bufferData->producerId = producerId;
bufferData->flags |= BufferData::BufferDataChange::frameNumberChanged;
bufferData->dequeueTime = dequeueTime;
if (fence) {
bufferData->acquireFence = *fence;
bufferData 保存 GraphicBuffer 强引用、帧标识、producerId 和可选 acquire fence,并登记释放端点/回调。这个 C++ 对象不是被远程直接解引用的指针。跨 Binder 编解码会传递描述、handle/fd 和缓存引用等信息,接收进程建立自己的包装与导入关系;不会用 Binder Parcel 把整张图像像素重复复制过去。
在本例普通应用侧 BufferQueue 中,生产者通知 listener,沿本地代理调用消费者,再进入 BLAST 的 onFrameAvailable。这条 BufferQueueProducer 回调路径 可在生产者调用线程同步执行。释放反馈另走后面的通道。
无等待合并事务等特殊条件时,BLAST 直接 apply:
来源:BLASTBufferQueue.cpp · status_t BLASTBufferQueue::acquireNextBufferLocked((本地源码)。
status_t status = t->setApplyToken(mApplyToken).apply(false, true);
if (status != OK) {
BQA_LOGE("Transaction Failure Details: Status: %d (%s), Pending Transactions Merged: "
"%zu, Transaction ID: %" PRIu64 ", Frame Number: %" PRIu64
", Buffer Size: %dx%d",
status, statusToString(status).c_str(), mPendingTransactions.size(),
t->getId(), bufferItem.mFrameNumber, bufferItem.mGraphicBuffer->getWidth(),
bufferItem.mGraphicBuffer->getHeight());
}
LOG_ALWAYS_FATAL_IF(status != OK,
"[%s] acquireNextBufferLocked failed to apply transaction. status=%d",
mName.c_str(), status);
此处自行 apply 的返回值非 OK 时,先记录错误详情,随后 LOG_ALWAYS_FATAL_IF 触发当前应用进程的 Native fatal。 这条分支不会仅丢帧后继续等下一次 relayout;后续清理应按宿主异常退出理解。这个结论只针对本版本 BLAST.acquireNextBufferLocked 的自行提交分支,不推广为所有 Transaction.apply、队列错误或 HAL 返回错误都会终止进程。
来源:SurfaceComposerClient.cpp · status_t SurfaceComposerClient::Transaction::apply((本地源码)。
sp<ISurfaceComposer> sf(ComposerService::getComposerService());
TransactionState state = std::move(mState);
status_t binderStatus = sf->setTransactionState(std::move(state), applyToken);
应用图形事务在这里跨进程进入 SurfaceFlinger。 applyToken 用于相关事务的顺序/归组,BLAST 使用 one-way 模式,并在上述自行提交分支对非 OK 状态作 fatal 检查;需要同步到下一帧/合并窗口状态时,事务也可以交给外部合并,不能把所有帧画成立即独立 apply。one-way 更不表示图像已呈现。
对照旧架构阅读时,先问“producer 和 consumer 在哪个进程”“最终是 queueBuffer 还是 setBuffer 事务跨向 SF”。只有这两个问题明确,后续锁、回调、延迟与内存归属才不会混乱。
7.7 buffer 分配与 fence 怎样保证可安全复用
像素内存的来源不是 Parcel
BufferQueueProducer.dequeueBuffer 在需要分配时创建 GraphicBuffer;GraphicBuffer 经 GraphicBufferAllocator 进入对应 gralloc 实现。当前 allocator 入口包含参数检查、版本回退和导入,不是所有设备都固定同一个 gralloc 版本:
来源:GraphicBufferAllocator.cpp · auto GraphicBufferAllocator::allocate(const AllocationRequest& request)(本地源码)。
auto result = mAllocator->allocate(request);
if (result.status == UNKNOWN_TRANSACTION) {
if (!request.extras.empty()) {
ALOGE("Failed to allocate with additional options, allocator version mis-match? "
"gralloc version = %d",
(int)mMapper.getMapperVersion());
return result;
}
Allocator 负责根据 width/height/format/usage 分配合适的图形资源,Mapper 负责本进程导入、查询、CPU lock/unlock 等操作。usage 同时约束 CPU、GPU、显示等消费者,不能只用“宽×高×4”推断全部实际占用:stride、格式、压缩、元数据、多个 slot 与后端映射都会影响它。
本场景产品有 ranchu allocator/mapper 源码;第一章历史属性记录 ro.hardware.gralloc=ranchu。在 ranchu Mapper 的 importBuffer 中,先复制 native_handle,再按需建立本进程映射:
来源:mapper.cpp · AIMapper_Error importBuffer(const native_handle_t* const handle,(本地源码)。
native_handle_t* const imported = native_handle_clone(handle);
if (!imported) {
return FAILURE(AIMAPPER_ERROR_BAD_BUFFER);
}
cb_handle_t* const cb = cb_handle_t::from(imported);
if (!cb) {
native_handle_close(imported);
native_handle_delete(imported);
return FAILURE(AIMAPPER_ERROR_BAD_BUFFER);
复制 handle 是建立本地 fd/整数元数据包装;它没有把一整张图像做 Java 序列化。 后面的 GoldfishAddressSpaceBlock::memoryMap 也说明不同进程可得到不同虚拟地址。导入失败要关闭已复制 fd 并销毁 handle;成功后的导入资源由对应 Mapper/free 路径回收。设备使用 DMA-BUF 时同样要区分共享分配、每进程 fd、每进程映射;不能仅因看见 GraphicBuffer 就断定它一定是普通 malloc 或某一种 DMA heap。
三种 fence 约束不同的完成点
| 使用位置 | 它回答的问题 | 下一方的责任 |
|---|---|---|
| queueBuffer / setBuffer 的 acquire fence | 生产者写入何时可安全被后续消费者读取 | 合成/设备对它建立等待依赖,可异步等待,不必让调用 CPU 原地忙等 |
| 释放旧 buffer 的 release fence | 上次合成/显示读取何时结束 | 队列交回生产者后,下一次写入仍须尊重该依赖 |
| display present fence | 后端这次呈现对应的完成时点 | 供调度、统计和后续同步使用;语义依接口/后端,不能等同于 Java 方法返回 |
fence 通常以 fd 跨进程传递,fd 数字在每个进程内有效;dup 建立新的 fd 所有权,关闭一个副本不会替所有持有者关闭。Fence::NO_FENCE/无效 fd 在相应契约下表示无额外等待,不表示传输失败或 GPU 没工作。
先用静态时序对照 acquire、present、release 各在哪一步出现。
动图只跟一个复用中的 slot。图形内存留在原位,变化的是持有状态和访问依赖。观察 slot 回到 FREE 时,上一轮 release fence 仍可能未 signal。生产者取得这个 slot 后,要到依赖满足才可安全写入。
fence 怎样连接到 Kernel 等待与唤醒
Native Fence::wait 最终使用 sync_wait;在本章匹配的 Kernel 源码中,sync_file 的 poll 方法把等待队列和 dma_fence 完成条件连接起来:
来源:sync_file.c · static __poll_t sync_file_poll((本地源码)。
poll_wait(file, &sync_file->wq, wait);
if (list_empty(&sync_file->cb.node) &&
!test_and_set_bit(POLL_ENABLED, &sync_file->flags)) {
if (dma_fence_add_callback(sync_file->fence, &sync_file->cb,
fence_check_cb_func) < 0)
wake_up_all(&sync_file->wq);
}
return dma_fence_is_signaled(sync_file->fence) ? EPOLLIN : 0;
未 signal 时,poll 注册等待并返回未就绪;fence callback 能唤醒等待者。 dma_fence 表达设备/驱动工作完成条件,sync_file 提供 fd 接口。这是解释异步依赖的通用 Kernel 层;实际 GPU/显示 Driver 如何产生、合并和 signal fence 要回到目标后端,不能凭这个函数宣称已跟踪某一帧的全部硬件 fence。
释放通知怎样回到队列
BLAST 收到释放反馈后,先按 callbackId 找已提交项目,再将 release fence 交给 BufferItemConsumer:
来源:BLASTBufferQueue.cpp · void BLASTBufferQueue::releaseBuffer(const ReleaseCallbackId& callbackId,(本地源码)。
auto it = mSubmitted.find(callbackId);
if (it == mSubmitted.end()) {
return;
}
mNumAcquired--;
BBQ_TRACE("frame=%" PRIu64, callbackId.framenumber);
BQA_LOGV("released %s", callbackId.to_string().c_str());
mBufferItemConsumer->releaseBuffer(it->second, releaseFence);
mSubmitted.erase(it);
// Remove the frame number from mSyncedFrameNumbers since we can get a release callback
mSlots[slot].mFence = releaseFence;
mSlots[slot].mBufferState.release();
本版本还支持 BufferReleaseChannel/异步 listener 等反馈路径;释放反馈的传输形式与图中的职责应分开。BufferQueue 保存 fence 并更新协议状态,才让生产者有机会安全复用。 若消费者迟迟不释放,dequeue 可能受反压而阻塞,应用主线程“没有做复杂计算”仍可能被 RenderThread 同步间接影响。增加 buffer 数有时掩盖短期阻塞,却同时增加内存和排队延迟。
7.8 SurfaceFlinger 怎样接收事务并选择合成内容
Binder 接收不等于立即在主线程合成
应用 Transaction.apply 进入 SurfaceFlinger.setTransactionState。Binder 调用线程处理调用者身份、状态权限和描述数据;解析后的事务进入 TransactionHandler 队列,并请求后续 commit:
mTransactionHandler.queueTransaction(std::move(state));
}
源码随后设置 eTransactionFlushNeeded 等标记,经 scheduleCommit 与 Scheduler 触发处理。不能在 setTransactionState 的返回处就画上“屏幕显示完成”。 独立 applyToken、期望呈现时间、acquire fence、buffer barrier 和反压等会影响事务何时可应用。队列允许跨 Binder 线程提交,不等于主合成状态可以不受同步约束地任意改。
commit 与 composite 各自解决什么
可以先将 commit 理解为推进事务、Layer 快照与本轮可合成状态,将 composite 理解为准备显示输出并提交实际合成工作;实际受调度/优化条件影响,二者不必每次都产生新像素。本版 SurfaceFlinger 的 commit 会更新 Layer 快照,相关 latch 路径把选定 buffer 变成本轮内容:
来源:SurfaceFlinger.cpp · bool SurfaceFlinger::updateLayerSnapshots((本地源码)。
it->second->latchBufferImpl(unused, latchTime, expectedPresentTimeNs, bgColorOnly);
newDataLatched = true;
latch 是接收/锁定本轮内容的阶段,不等同于屏幕扫描完成;未满足条件、隐藏/遮挡或可丢弃的帧也不会因应用已生产就必定显示。SurfaceFlinger.composite 把刷新参数交给 CompositionEngine:
来源:SurfaceFlinger.cpp · CompositeResultsPerDisplay SurfaceFlinger::composite((本地源码)。
mCompositionEngine->present(refreshArgs);
CompositionEngine 把显示、输出层、可见区域、颜色转换和输出目标等联系起来。WMS 布局位置只是其中一种输入;buffer 的 transform/crop、Layer 的变换、显示旋转与颜色空间也会影响最终像素。
合成策略决定谁去混合 Layer
这张图用等待条件概括多个分支;某些条件存在优化、允许 latch 未 signal buffer 等特定配置,不能把它理解成“SF 主线程总是先阻塞 wait 每个 acquire fence”。后端可以把依赖继续传下去。
客户端合成里的“客户端”是 Composer HAL 的调用方 SurfaceFlinger。 SurfaceFlinger RenderEngine 合成若干层生成 client target,是系统合成的一种工作;应用 RenderThread 渲染本窗口则是前一个独立阶段。即使两个阶段都调用 GPU,也要区分执行者、输入与输出。
7.9 Composer HAL 怎样提交合成与呈现
四种工作不能混为一次 GPU draw
| 工作 | 执行者与输入 | 产出 |
|---|---|---|
| 应用渲染 | 应用 RenderThread / GPU(或软件 CPU),处理自己的 RenderNode 内容 | 本窗口 buffer |
| 客户端合成 | SurfaceFlinger RenderEngine,处理被判为 CLIENT 的 Layer | client target buffer 与完成 fence |
| 设备合成 | Composer 实现及设备/虚拟后端,处理 DEVICE 层和必要的 client target | 显示输出安排 |
| scanout / Host 呈现 | 真实显示控制器或 Emulator Host 显示后端 | 目标显示上的更新与同步反馈 |
CLIENT/DEVICE 是接口分工,不保证 DEVICE 就是某个物理 DPU,也不保证 Emulator 的“硬件加速”真的调用了 Host 物理 GPU。SwiftShader 可以在 Host CPU 上实现图形 API。
需要客户端合成时,Output.composeSurfaces 调用 RenderEngine:
来源:Output.cpp · std::optional<base::unique_fd> Output::composeSurfaces((本地源码)。
auto fenceResult = renderEngine
.drawLayers(clientCompositionDisplay, clientRenderEngineLayers, tex,
std::move(fd))
.get();
这里的输入是为本输出准备的 LayerSettings 与纹理,返回的 fence 表达 client target 何时完成,后续要继续交给 HWC。普通客户端合成不改变原应用 View 树;它拿到的是各 Layer 的图形资源与几何/混合状态。
从 CompositionEngine 走到 Composer AIDL
不要停在 Output 基类的 presentFrame:实际显示输出使用 Display 的覆盖方法,再交给 HWComposer:
来源:Display.cpp · compositionengine::Output::FrameFences Display::presentFrame()(本地源码)。
hwc.presentAndGetReleaseFences(*halDisplayIdOpt, getState().earliestPresentTime);
if (isPowerHintSessionEnabled()) {
mPowerAdvisor->setHwcPresentTiming(*halDisplayIdOpt, startTime, TimePoint::now());
}
来源:HWComposer.cpp · status_t HWComposer::presentAndGetReleaseFences((本地源码)。
auto error = hwcDisplay->present(&displayData.lastPresentFence);
RETURN_IF_HWC_ERROR_FOR("present", error, displayId, UNKNOWN_ERROR);
std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
error = hwcDisplay->getReleaseFences(&releaseFences);
RETURN_IF_HWC_ERROR_FOR("getReleaseFences", error, displayId, UNKNOWN_ERROR);
HWComposer 的 validate/present 接口是框架侧封装;在 AIDL Composer 实现中,层状态、validate、present 等会装进命令批次,executeCommands 通过 ComposerClient Binder 接口送到独立 HAL 服务。调用名中保留 HWC2 并不意味着该设备必须运行 HIDL 2.x 服务。
本场景 HAL 服务是 ranchu 的 Composer3,其 ComposerClient.executeDisplayCommand 解开命令:
来源:ComposerClient.cpp · void ComposerClient::executeDisplayCommand((本地源码)。
DISPATCH_DISPLAY_BOOL_COMMAND_AND_DATA(displayCommand, commandResults, *display,
validateDisplay, expectedPresentTime, ValidateDisplay);
DISPATCH_DISPLAY_BOOL_COMMAND(displayCommand, commandResults, *display, acceptDisplayChanges,
AcceptDisplayChanges);
DISPATCH_DISPLAY_BOOL_COMMAND(displayCommand, commandResults, *display, presentDisplay,
PresentDisplay);
DISPATCH_DISPLAY_BOOL_COMMAND_AND_DATA(displayCommand, commandResults, *display,
presentOrValidateDisplay, expectedPresentTime,
命令分派到 Display.validate / present,再交给选中的 FrameComposer。HostFrameComposer.validateDisplay 会根据 Host composition 能力和各层条件决定是否回退 CLIENT。校验策略和真正 present 是两个动作;validate 返回“可合成”不等于本帧已呈现。 当前实现还支持 presentOrValidate/跳过验证等优化,应以本轮命令与 Trace 观察为准。
present 后怎样归还 buffer
Composer 返回 present fence 和各层 release fence。Display::presentFrame 把它们放入 FrameFences,Output::presentFrameAndReleaseLayers 再按层把释放依赖反馈给 Layer 前端/事务回调,最终接到 7.7 的 BLAST releaseBuffer。该轮输出可能释放的是上一帧使用的 buffer,而不是刚提交的新 buffer;不要把“第 N 次 present”与“第 N 个 buffer 立刻归还”机械配对。
如果 HAL 返回 BAD_DISPLAY、NO_RESOURCES 等错误,SurfaceFlinger/HWComposer 会走相应错误处理而不是自动证明屏幕更新;旧图像可继续显示,应用也可能在后续重建 Surface。排查要保留原始错误码、显示 ID 和前后生命周期,不只看应用日志。
7.10 沿 Goldfish Driver 追到 Host 显示后端
用设备证据选择阅读哪条后端
第一章 2026-10-19 的底层来源记录确认过:设备为 sdk_phone64_x86_64/emu64x,Composer 服务名为 android.hardware.graphics.composer3.IComposer/default,可执行文件为 android.hardware.graphics.composer3-service.ranchu;图形 transport 为 pipe,Composer 打开 goldfish pipe/address_space 节点;Host 启动参数为 -gpu swiftshader_indirect,日志出现 gfxstream、SwiftShader Device 和 Google SwiftShader。
这里复用的是这些历史身份与文件证据,不复用旧 PID 作为现在的进程,也不等于本轮逐帧实测。当前学习主线因此选择 ranchu/Goldfish,与 Cuttlefish 的 virtio-gpu/DRM 路径区分。HAL 源码中的 Device::getComposer 还支持其他实现:
来源:Device.cpp · HWC3::Error Device::getComposer(FrameComposer** outComposer)(本地源码)。
if (IsInNoOpCompositionMode()) {
DEBUG_LOG("%s: using NoOpFrameComposer", __FUNCTION__);
mComposer = std::make_unique<NoOpFrameComposer>();
} else if (IsInClientCompositionMode()) {
DEBUG_LOG("%s: using ClientFrameComposer", __FUNCTION__);
mComposer = std::make_unique<ClientFrameComposer>();
} else if (shouldUseGuestComposer()) {
DEBUG_LOG("%s: using GuestFrameComposer", __FUNCTION__);
mComposer = std::make_unique<GuestFrameComposer>();
} else {
DEBUG_LOG("%s: using HostFrameComposer", __FUNCTION__);
mComposer = std::make_unique<HostFrameComposer>();
}
第一章依据当时属性与此工厂对应 HostFrameComposer,没有对工厂函数逐调用插桩。本章不把该推断升级成“每帧已跟踪到指定分支”。
HostFrameComposer 怎样提交显示工作
HostFrameComposer.presentDisplay 依据 Host composition 能力与 minigbm 等条件选择提交方式。支持 Host composition 时,会编码 Layer/target 信息并发送 rcCompose 系列命令;以下展示其中一个连续分支:
来源:HostFrameComposer.cpp · HWC3::Error HostFrameComposer::presentDisplay((本地源码)。
if (rcEnc->hasAsyncFrameCommands()) {
if (mIsMinigbm) {
ATRACE_FORMAT("rcComposeAsyncWithoutPost()");
rcEnc->rcComposeAsyncWithoutPost(rcEnc, bufferSize, buffer);
} else {
ATRACE_FORMAT("rcComposeAsync()");
rcEnc->rcComposeAsync(rcEnc, bufferSize, buffer);
}
} else {
rcEnc 是 HostConnection 提供的 renderControl 编码器;它传的是后端可理解的资源标识、Layer 参数和图形命令,和 SF→HAL 的 AIDL 协议不是同一层。CLIENT 回退时可 post client target;若 mIsMinigbm 成立,还存在 DrmClient/flushToDisplay 分支。本章不把所有源码备选分支都写成当前 Emulator 同时执行的链路。
支持 Host composition 的分支对带有效 acquire fd 的 DEVICE 层还会执行一次 HAL 侧 sync_wait。这处超时会记日志。具体由谁等待、是阻塞还是把依赖继续传给后端,要看合成分支。
在非 minigbm 的同步反馈分支中,HAL 通过 goldfish_sync_queue_work 取得可返回的 fence fd;后面复制给显示与各层释放结果:
来源:HostFrameComposer.cpp · HWC3::Error HostFrameComposer::presentDisplay((本地源码)。
goldfish_sync_queue_work(mSyncDeviceFd, sync_handle, thread_handle, &fd);
retire_fd = ::android::base::unique_fd(fd);
}
使用 rc command 同步、virtio GPU 分支与 minigbm 分支有不同条件。上面片段用于解释 goldfish fence 的形成,不宣称每一帧都走它;本轮需要另外采集实际分支和 fd 才能升级为实测结论。
从用户空间 pipe 写入走到 Kernel
在 pipe 配置下,HostConnection 建立 QemuPipeStream。流连接到 opengles 通道,再把 renderControl 编码器交来的数据交给 qemu_pipe_write_fully。
Guest gfxstream 的 qemu_pipe_open_ns 打开虚拟设备,并发送 pipe:... 服务名握手。写入函数最终使用普通 write 系统调用:
来源:qemu_pipe_guest.cpp · int qemu_pipe_write(int pipe, const void* buffer, int size)(本地源码)。
const ssize_t r = write(pipe, buffer, size);
return (r >= 0) ? r : -checkErr(errno, EIO);
对应预编译模块来源的 goldfish_pipe_write 将请求转入 goldfish_pipe_read_write;后者分页处理用户数据。transfer_max_buffers 先 pin 用户页、设置命令描述,再向虚拟设备提交读写命令:
来源:goldfish_pipe.c · static int transfer_max_buffers((本地源码)。
*status = goldfish_pipe_cmd_locked(pipe,
is_write ? PIPE_CMD_WRITE : PIPE_CMD_READ);
*consumed_size = pipe->command_buffer->rw_params.consumed_size;
unpin_user_pages_dirty_lock(pipe->pages, pages_count,
!is_write && (*consumed_size > 0));
这条 Goldfish Driver 在 Guest 和 Host 之间传输图形协议与数据,适用范围是本节的虚拟设备。 它维护 pipe 状态、用户页与设备命令,等待 Host 可读写信号时可休眠,再由通知唤醒;系统调用返回仍需结合协议成功状态和上层同步判断。
Goldfish address space 用于图形共享内存映射等工作,与 pipe 的命令通道相互配合。不能把每个图形 buffer 说成每帧通过 pipe 完整复制一次,也不能仅凭共享映射就承诺端到端零拷贝。
同步反馈怎样从 Host 回到 fence
goldfish_sync_ioctl_locked 接收 GOLDFISH_SYNC_IOC_QUEUE_WORK,为时间线创建同步点,并把 fence fd 返回给用户空间。创建过程通过 Kernel sync_file 安装 fd:
来源:goldfish_sync.c · goldfish_sync_fence_create(struct goldfish_sync_timeline *tl, u32 val,(本地源码)。
sync_file_obj = sync_file_create(&pt->base);
if (!sync_file_obj)
goto err_cleanup_fd_pt;
fd_install(fd, sync_file_obj->file);
dma_fence_put(&pt->base); /* sync_file_obj now owns the fence */
fence->pt = pt;
ioctl 还会发 CMD_TRIGGER_HOST_WAIT;Host 的后续完成命令经设备中断/工作队列回到 goldfish_sync 时间线,从而使对应 fence 完成。Kernel 的 poll callback 再唤醒等待者,接回 7.7。进程中的 fd、Kernel sync_file 与 dma_fence/同步点、Host 同步对象属于不同层,不能把它们的地址或编号混为一个对象。
这张图以已确认的 Emulator 后端为蓝本,箭头表示接口方向,不宣称本轮逐帧时序。Host 预编译 Emulator 的精确构建源码/补丁映射尚未补齐,不能将当前 gfxstream checkout 的某个 Host 函数强认成运行器中的实现;这里止于可定位的 Guest Driver、协议职责与已有 Host 渲染器身份。
采用 DRM/KMS 的设备怎样呈现
采用 DRM/KMS 的设备一般涉及图形资源导入、framebuffer/plane/CRTC 状态和 atomic commit,GPU 渲染与显示控制器 scanout 是不同引擎,fence 把它们的访问顺序联系起来。DMA-BUF 是可共享分配/附件映射机制,不会自动决定该由 GPU 还是显示控制器合成。其他厂商设备也可能使用不同的显示接口。
这条是换后端时的阅读方法,不能用本例的 pipe 证据证明手机上的 plane、IRQ 或物理面板已验证。应追加实际 HAL 实现、/dev/dri 或厂商节点、Kernel 配置/Driver 绑定、buffer/fence/commit 证据,再沿对应源码读到显示终点。
7.11 字体与国际化怎样进入图形链路
沿源码读到显示后端以后,再回到同一个窗口:圆的位置和颜色之外,文字还要先选出字形、安排位置。下面补的是图形内容形成的另一条入口,不是说文本布局发生在呈现之后。
一个字符为什么不一定对应一个字形
字符编码表达文本,glyph(字形)是字体中可绘制的形状;多个字符可能连成一个字形,一个字符也可能组合、选用不同字体或变体。双向文本、脚本、语言、字体覆盖与字体回退一起影响排列。把中文、英文、阿拉伯文和 emoji 直接按 UTF-16 下标逐个画,不能替代完整文本布局。
本例把混合文本交给 TextView。TextView/Layout/TextLine 的测量与排版准备文本运行,Native 文本绘制再连接 HWUI/Minikin;下面沿 Canvas 的 Native 文本路径看相同基础机制,不把它声称为 TextView 每次都完全相同的调用栈。
图展示职责与数据,不是声称所有文本每次重新执行全部 shaping。Minikin/Skia 的缓存可以避开部分工作,字体首次加载和命中缓存的成本不同。
Minikin 怎样接到当前 Canvas 绘制
HWUI Canvas::drawText 先调用 MinikinUtils 布局,再按字体运行生成字形绘制:
来源:Canvas.cpp · void Canvas::drawText(const uint16_t* text,(本地源码)。
minikin::Layout layout = MinikinUtils::doLayout(&paint, bidiFlags, typeface, text, textSize,
start, count, contextStart, contextCount, mt);
x += MinikinUtils::xOffsetForTextAlign(&paint, layout);
来源:Canvas.cpp · void Canvas::drawText(const uint16_t* text,(本地源码)。
DrawTextFunctor f(layout, this, paint, x, y, layout.getAdvance());
MinikinUtils::forFontRun(layout, &paint, f);
MinikinUtils 把 Paint/Typeface 转成 MinikinPaint,保留文本上下文、范围、方向与连字符等信息。普通未提供 MeasuredText 的路径构造 Layout;已有测量结果则尝试 buildLayout 复用:
来源:MinikinUtils.cpp · minikin::Layout MinikinUtils::doLayout((本地源码)。
if (mt == nullptr) {
return minikin::Layout(textBuf.substr(contextRange), range - contextStart, bidiFlags,
minikinPaint, startHyphen, endHyphen, minikinRunFlag);
} else {
return mt->buildLayout(textBuf, range, contextRange, minikinPaint, startHyphen, endHyphen);
}
字体回退通过 FontCollection 的字符/变体/locale 匹配工作。itemize 为相应字符挑选候选字体族,再决定与前后文本是否属于同一个运行:
来源:FontCollection.cpp · std::vector<FontCollection::Run> FontCollection::itemize((本地源码)。
FamilyMatchResult familyIndices = getFamilyForChar(
ch, isVariationSelector(nextCh) ? nextCh : 0, localeListId, familyVariant);
bool breakRun;
脚本、方向和选中的字体信息进入 shaping,复杂布局中 LayoutPiece 调用 HarfBuzz 并读取 glyph 信息和位置:
来源:LayoutCore.cpp · LayoutPiece::LayoutPiece(const U16StringPiece& textBuf,(本地源码)。
hb_shape(hbFont.get(), buffer.get(), features.empty() ? NULL : &features[0],
features.size());
unsigned int numGlyphs;
hb_glyph_info_t* info = hb_buffer_get_glyph_infos(buffer.get(), &numGlyphs);
hb_glyph_position_t* positions = hb_buffer_get_glyph_positions(buffer.get(), NULL);
glyph ID 只在所选字体中有意义,不能把 Unicode 码点直接当成 glyph ID。 字形布局完成后回到 Skia/HWUI 的绘制管线,后续仍要生产 buffer、同步、合成与显示,不存在独立“字体 HAL”替代这条主链。
Locale、时区、字体与方向分别改变什么
| 条件 | 主要影响 | 不应误解为 |
|---|---|---|
| Locale / Resources 配置 | 资源选择、数字日期格式、语言相关文本行为 | 自动为任意自定义字符串完成翻译 |
| 时区与 ICU/tzdata | 同一时间戳怎样显示为当地日期时间 | 改了时区就改变系统时钟的真实时间戳 |
| Bidi / layoutDirection | 文本运行方向、段落与界面方向 | 只把所有字符顺序反转 |
| 字体覆盖与回退 | 为字符/变体挑选可用字体并度量 | 一个 Typeface 文件必然覆盖所有 emoji 和脚本 |
RuntimeI18n/ICU 提供相关国际化数据与算法,字体配置与 Minikin 则决定具体字形选择;二者协作但不是同一个库。字体文件加载会走资源/文件映射,存储页缓存和首次访问影响耗时;得到的映射或字体对象也需要在进程生命周期内正确管理,不能把每次 drawText 等同于重新读取字体文件。
动手时先观察示例中的 Locale/TimeZone、混排效果和 emoji。再在专用测试环境用系统设置更改语言/字体缩放/时区,每次只改一个条件并记原值,完成后恢复。比较布局宽高、RTL、首帧与稳定帧;这些操作本轮未执行。第五章继续解释配置/Resources 重建与资源选择,这里补的是文本形成可绘制字形的连接。
7.12 窗口退出、失败与资源收尾
暂停停帧与移除窗口分别处理
本例 MainActivity.onPause 将 resumed/continuous 清为 false,并移除自己的 Choreographer 回调;这是示例停止主动更新的条件,不是“框架必然销毁窗口”的条件。短暂 pause 或被透明 Activity 覆盖时,原窗口/Layer 可以仍存在,不能据此认定存在资源泄漏。
固定版本 ActivityThread.performPauseActivityIfNeeded 调用生命周期回调:
mInstrumentation.callActivityOnPause(r.activity);
这条 pause 路径最后置 ON_PAUSE,没有在这里无条件移除 DecorView。窗口实际移除在另一条路径决定:例如 ActivityThread.handleDestroyActivity 的已加窗口、非 mPreserveWindow 分支会执行:
来源:ActivityThread.java · public void handleDestroyActivity(ActivityClientRecord r, boolean finishing,(本地源码)。
wm.removeViewImmediate(v);
preserve-window 分支会把移除留待后续处理,不能把所有 destroy 也改写成立即拆掉同一窗口。窗口隐藏、进入 stopped 或 Surface 重建还可能改变渲染目标,须按具体可见性与停止路径判断;这里同样不主张 pause 时 Surface 永远不变。
只有走到根 View 的实际 detach/移除收尾时,才接下面这组拆资源动作。 ViewRootImpl.dispatchDetachedFromWindow 清理 View 关联、渲染器、Surface、输入资源并通知系统移除窗口:
来源:ViewRootImpl.java · void dispatchDetachedFromWindow()(本地源码)。
destroyHardwareRenderer();
setAccessibilityFocus(null, null);
mInsetsController.cancelExistingAnimations();
mView.assignParent(null);
mView = null;
mAttachInfo.mRootView = null;
来源:ViewRootImpl.java · void dispatchDetachedFromWindow()(本地源码)。
mWindowSession.remove(mWindow.asBinder());
} catch (RemoteException e) {
}
destroySurface 中将本地 Surface、SurfaceControl 和 BLAST 关联解开:
来源:ViewRootImpl.java · private void destroySurface()(本地源码)。
mRenderTargetIsValid = false;
mSurface.release();
mSurfaceControl.release();
if (mBlastBufferQueue != null) {
mBlastBufferQueue.destroy();
mBlastBufferQueue = null;
}
release 本地包装、撤销服务端 Layer 关系、关闭/导入释放 buffer、等待异步访问结束,是相关但不同的动作。 渲染器需要先与 RenderThread 同步,避免队列销毁后还继续使用旧目标;队列 disconnect/abandon 后生产者收到错误,不应继续把旧 slot 当作有效资源。
观察三种收尾入口: 先看本例 pause 只停止主动帧回调,再分别看窗口实际 detach 与宿主异常退出。图把三个收尾入口并列,按当前场景选一条读。本地包装消失后,仍有共享持有者或在途访问的分配继续受各自的生命周期约束。
图的两个正常入口有不同条件:pause 只连到本例停帧,实际 detach 才连到框架拆资源;二者没有无条件的后继连线。其余箭头展示收尾职责,不把各条并行清理画成一个固定全局调用顺序。宿主崩溃时 onPause/onDestroy 可能不执行;服务端通过 Binder death、连接消失等移除残留窗口/Layer,内核关闭 fd、撤销映射并归还最终无人使用的资源。共享分配若仍由另一方持有,不会仅因原生产者进程消失就无条件立刻释放。
几类失败应沿不同边界检查
| 现象 | 首要检查与原因范围 | 对应阅读 |
|---|---|---|
| 添加窗口报 BadToken / InvalidDisplay | Activity/window token、display ID、窗口类型、调用时机与权限 | 7.3 的添加与回滚;WindowManagerGlobal 会清理已登记的本地根 |
| relayout 后不出图或 Surface lost | SurfaceControl 有效性、窗口可见性、尺寸变化、syncResult 与重新布局 | 7.3、7.5;旧目标不能继续盲用 |
| onDraw 很快但后续延迟 | RenderThread 同步/队列、dequeue 反压、acquire fence、SF 排队与后端 | 7.6~7.10 与 Trace |
| BufferQueue abandoned / dequeue 错误 | 先看宿主/消费者是否已断开、窗口是否重建 | 7.6、7.12;不是加重试次数就能恢复旧连接 |
| BLAST 自行 apply 返回非 OK | 本版本该分支记录详情后 Native fatal,按宿主死亡清理;不能类推成所有事务错误 | 7.6、7.12 |
| HAL BAD_DISPLAY / NO_RESOURCES | 显示热插拔/断开、格式与资源条件、命令批次与 fence | 7.9;记录原错误与目标显示 |
| 文本缺字/方向异常 | 字体覆盖、fallback、脚本上下文、Bidi 与 locale,而不是先怀疑显示驱动 | 7.11 |
本章没有新增设备故障实录,这些是源码支持的诊断入口。读者遇到实际问题再保存“现象、复现条件、证据、原因、修复、验证与边界”,不要把预期故障写成已发生的踩坑。
7.13 用日志和 Trace 定位一帧的延迟
先做正常帧与慢主线程的对照
按下一小节采两份样本。正常组启动参数为 main_delay_ms=0,慢回调组改为 40。每组先在界面核对当前参数,启动采集后都点“连续更新”。两组分别打开命令打印的 Trace 路径,日志也分开保存。
正常样本保存完毕后,在终端 A 用以下命令切到慢模式;-S 会强制停止本例包名的现有实例,确保新的 Intent 参数由 onCreate 读取,不要改成其他正在使用的包名。
"$ch7_adb" -s "$ch7_serial" shell am start -S -W \
-n com.example.graphicsdemo/.MainActivity --ei main_delay_ms 40
它预期使 Ch7.update 的墙钟区间增加约 40 ms 并延迟后续 traversal;具体调度与帧结果仍要实测。SystemClock.sleep 的区间多为线程等待,不能称作 40 ms CPU 运算。返回正常模式时再用同一命令把参数改回 0,避免将旧 Activity 未重建误当参数失效。
预期判据分开记录:圆确实更新、日志计数推进、UI 回调是否在主线程、RenderThread 的对应提交、SF 的实际帧轨迹。am start -W 是启动时序观察,不是每次按钮更新的端到端帧时间。
采集应用、系统与调度证据
终端 A 沿用 7.2 定义的 ch7_adb、ch7_serial、ch7_chapter 和本轮独立目录 ch7_run。先成功查询数据源,再决定本次实际输入路径 ch7_trace_config;查询失败时清空该变量并先解决连接/权限问题,不按“查不到”擅自推断未注册。
ch7_trace_config=
if "$ch7_adb" -s "$ch7_serial" shell perfetto --query > "$ch7_run/perfetto-sources.txt"; then
ch7_default="$ch7_chapter/示例/追踪配置/一帧绘制.pbtxt"
grep -Fq 'android.surfaceflinger.frametimeline' "$ch7_run/perfetto-sources.txt"
case $? in
0) ch7_trace_config="$ch7_default" ;;
1)
ch7_fallback="$ch7_run/ch7-no-frametimeline.pbtxt"
if sed '/name: "android.surfaceflinger.frametimeline"/d' \
"$ch7_default" > "$ch7_fallback" && test -s "$ch7_fallback"; then
ch7_trace_config="$ch7_fallback"
else
printf '%s\n' '生成备用配置失败。先检查输入文件和目录权限。' >&2
fi
;;
*) printf '%s\n' '读取数据源列表失败,暂不选择采集配置。' >&2 ;;
esac
else
printf '%s\n' '数据源查询失败。先检查设备和 Perfetto 权限,再重做本段。' >&2
fi
if [ -n "$ch7_trace_config" ]; then
printf '%s\n' "$ch7_trace_config" > "$ch7_run/selected-trace-config.txt"
fi
配套默认文件中该 FrameTimeline data_source 的整条声明独占一行,所以未注册分支删除的是整条声明,并把新路径保存到同一个变量。若将来改成多行配置,应删除整个相应 data_sources 块,不能只删 name 行。副本写在 ch7_run,不修改知识库原配置;本分支缺少呈现时间线证据,仍可采其他可用源,不能据普通 slice 补造屏幕呈现时间。
每组先用对应的启动参数重建 Activity,再执行下面的采集命令。正常组输入 normal,慢回调组输入 slow。命令给每次采集建独立目录和远端文件,先检查采集和拉取结果,再把本轮文件交给 Perfetto UI。
read -r -p '本组标签(normal 或 slow):' ch7_case
case "$ch7_case" in
normal|slow)
if [ -n "$ch7_trace_config" ] && [ -s "$ch7_trace_config" ] &&
ch7_pid=$("$ch7_adb" -s "$ch7_serial" shell pidof -s com.example.graphicsdemo) &&
[[ "$ch7_pid" =~ ^[0-9]+$ ]] &&
ch7_capture=$(mktemp -d "$ch7_run/$ch7_case.XXXXXX"); then
ch7_remote="/data/misc/perfetto-traces/ch7-${ch7_capture##*/}.perfetto-trace"
ch7_local="$ch7_capture/frame.perfetto-trace"
if "$ch7_adb" -s "$ch7_serial" shell perfetto --txt -c - \
-o "$ch7_remote" < "$ch7_trace_config" &&
"$ch7_adb" -s "$ch7_serial" pull "$ch7_remote" "$ch7_local" &&
test -s "$ch7_local"; then
printf '本组 Trace:%s\n' "$ch7_local"
if "$ch7_adb" -s "$ch7_serial" logcat -d --pid="$ch7_pid" \
-v threadtime 'Ch7Graphics:I' '*:S' > "$ch7_capture/logcat.txt"; then
printf '本组日志:%s\n' "$ch7_capture/logcat.txt"
else
printf '%s\n' '日志读取失败。保留 Trace,并标记本组日志缺失。' >&2
fi
else
printf '%s\n' '采集或拉取失败,当前文件不作本轮证据。' >&2
fi
else
printf '%s\n' '确认采集配置已选定、示例进程已启动、本轮目录可写。' >&2
fi
;;
*) printf '%s\n' '请输入 normal 或 slow,再重新运行本段。' >&2 ;;
esac
采集持续 12 秒。终端 A 等待时,在设备界面点“连续更新”。如果终端 B 仍在显示 logcat,可以继续用它观察。命令会按采集前取得的本例 PID 导出这一组日志,确认其中有这轮按钮触发的记录。如果采集中进程重启,或日志缺少本轮记录,记为证据不完整,重新采这一组。配置采集 gfx/view/wm、应用 Trace、Binder 与 sched 事件;受权限、内核事件可用性和 Trace buffer 容量影响,必须查看 Perfetto 退出状态和采集诊断。若设备/adbd 重启,重新开启终端 B 的 logcat,不把 wait-for-device 当作观察器自动恢复。
使用 Perfetto UI 打开命令打印的文件路径。SQL 编辑器可运行应用绘制区间查询,完整 SQL 也在附录。查询只找线程轨上的区间,呈现要另看帧时间线。
按因果顺序读 Trace
- 找
com.example.graphicsdemo的主线程,在Ch7.update与Ch7.onDraw_record对照日志;确认慢回调是在运行、等待还是就绪未被调度。 - 找应用 RenderThread,观察 DrawFrame/DrawFrames、dequeue/queue 等可见区间;寻找 UI 与 RenderThread 的交接,不能只以两个 slice 时间接近断言同一帧。
- 有 FrameTimeline 时,先在应用 Actual Timeline 选中目标 surface frame,再沿 Flow 跳到 SurfaceFlinger 的 Actual Timeline,核对 Layer、关联的 display frame 和相邻的 commit/composite。底层线索是 CanvasContext 记录的
frameNumber与vsyncId,BLAST 按匹配的frameNumber携带时间线信息。Layer ID、事务 ID 和帧 token 各有自己的含义。 - 数据源有实际 GPU/fence/后端事件时再继续解释完成与呈现;缺少时明确最后观察点。普通 Emulator Trace 不会自动包含 Host SwiftShader 内部的全部工作。
每次对照都填写下面这行记录,保留当前 Trace 中真正能关联的字段;空缺处写“关联未完成”,不要用相邻 slice 的时间或相同数字补出一条链。它是待填写的观察表,不是本章的实测结果。
| 本轮进程与 Layer | surface frame token / VSYNC 标识 | 关联的 display frame | 最后可观察端点 |
|---|---|---|---|
| 待填写 | 待填写;缺 FrameTimeline 则写“关联未完成” | 待填写 | 待填写,并注明缺少的证据 |
这是按最后可观察的边界分类,不是说四种延迟之间没有相互影响。上游生产快、下游消费慢会对上游形成反压;单看某条线程不足以定位根因。
用系统快照核对窗口与 Layer
在终端 A 同一环境保存以下只读快照:
"$ch7_adb" -s "$ch7_serial" shell dumpsys window windows > "$ch7_run/windows.txt"
"$ch7_adb" -s "$ch7_serial" shell dumpsys SurfaceFlinger --list > "$ch7_run/layers.txt"
"$ch7_adb" -s "$ch7_serial" shell dumpsys gfxinfo com.example.graphicsdemo framestats \
> "$ch7_run/gfxinfo.txt"
rg -n 'graphicsdemo|MainActivity|VRI-' "$ch7_run/windows.txt" "$ch7_run/layers.txt"
输出用于对照窗口身份、Layer 名称与应用帧统计;快照并非同一原子时刻,退出后保留的层也可能是过渡/动画对象,应比较前后和持有关系。framestats 字段与刷新模式有关,不把某一列直接当 Host 物理显示延迟。
可追加三种单条件对照:窗口旋转/尺寸变化看目标重建与 buffer 尺寸;切后台/返回看生产停止与生命周期;多语言/字体缩放看文本测量及首次加载。操作前保存原配置并恢复。当前笔记与示例经过静态核对,没有将这些对照登记为设备已通过。
回到开头那个还没移动的圆。如果慢组的额外等待落在 Ch7.update,应用侧已经出现可定位的延迟。如果更新和录制都按时,接着查 RenderThread 的对应提交,再沿 FrameTimeline 的 Flow 对照 SurfaceFlinger 的显示帧。证据能跟到哪一步,就把结论写到哪一步。
7.14 回顾、自测与源码速查
用六句话重连完整链路
- 窗口加入时,应用创建 ViewRootImpl,经 IWindowSession 让 WMS 管理 WindowState;SurfaceControl 的来源要按客户端创建开关区分。
- 内容变化先安排 Choreographer 的 traversal,主线程按条件测量、布局并记录绘制;JNI 入口不是自动换线程点。
- RenderProxy/DrawFrameTask 经任务队列把状态交给 RenderThread,SkiaGL 或 SkiaVulkan 向窗口生产图形 buffer。
- 应用侧 BLAST 消费本地队列,把 buffer、acquire fence 与 Layer 状态装入事务,交给 SurfaceFlinger 的事务队列。
- SurfaceFlinger 在调度时机应用状态、latch 内容,通过 CompositionEngine、RenderEngine 与 Composer 共同决定合成并提交后端。
- 后端呈现和 buffer 复用靠 fence、释放反馈与引用生命周期协作;窗口退出、进程死亡和失败路径分别终止生产、撤销连接并释放最终无人使用的资源。
自测与参考答案
| 问题 | 参考答案与定位 |
|---|---|
| onDraw 已结束,为什么屏幕可以还没更新? | 硬件加速时主要完成内容记录;RenderThread、队列交付、SF 调度/合成、后端呈现还有独立阶段。见 7.5~7.10 |
| ViewRootImpl 和 WindowState 是同一对象吗? | 前者在应用,后者在 system_server;IWindowSession/IWindow/token 等把双方联系起来。见 7.3 |
| SurfaceControl 与 Surface 分别交出什么能力? | 前者控制 Layer 状态,后者是生产图形 buffer 的接口;BLAST 将二者关联。见 7.1、7.3 |
| 普通窗口 BLAST 的 consumer 在哪里? | 本章非 IPC-rendering 主分支在应用侧,随后 setBuffer 事务进入 SF。其他图形消费者另看拓扑。见 7.6 |
| mNativeProxy 指向 SurfaceFlinger 吗? | 指向应用进程中的 RenderProxy;跨线程工作经 DrawFrameTask 队列交接。见 7.5 |
| 同步屏障能打断已经运行的主线程方法吗? | 不能,它影响后续消息选择。正在运行的慢回调仍会推迟后面的帧工作。见 7.4 |
| queueBuffer 后为什么还不能任意读写 buffer? | acquire/release fence 约束异步访问;协议状态与硬件完成需要同时考虑。见 7.7 |
| “客户端合成”是 Activity 合成整个屏幕吗? | 不是,指作为 HWC 客户端的 SurfaceFlinger 使用 RenderEngine 合成 CLIENT 层。见 7.8~7.9 |
| DEVICE composition 是否证明真实手机 DPU 已工作? | 否,是接口分工;Emulator 可交 Host composition,真实设备要核对实际 HAL/Driver。见 7.9~7.10 |
| 帧 slice 持续 40 ms 是否说明 CPU 忙算 40 ms? | 否,需结合 sched 判断 Running、Sleeping 和 Runnable。示例 sleep 主要制造等待。见 7.13 |
| 进程崩溃没调用 onDestroy,会永远保留所有 buffer 吗? | 不会如此推断;Binder/fd/映射关闭与服务端清理会推进回收,仍由别人持有的共享资源可继续存在。见 7.12 |
| Unicode 码点能否直接当 glyph ID? | 不能,需字体选择、脚本/方向 shaping 与 glyph 定位,布局结果再进入图形链。见 7.11 |
| ro.hardware.vulkan=ranchu 能证明本例本帧跑 SkiaVulkan 吗? | 不能,需渲染管线配置、进程状态和运行证据。见 7.2、7.5 |
| 如何验证真正从 Guest 到 Host 的一帧? | 先记录后端身份,再关联 Guest 事务/buffer/fence 与 Host 事件;现有历史身份记录不能代替逐帧关联。见 7.10、7.13 |
按问题找源码
| 要查什么 | 文件与关键符号 |
|---|---|
| 加窗口、建立本地根与失败回滚 | WindowManagerGlobal.addView,ViewRootImpl.setView,Session.addToDisplayAsUser,WMS.addWindow |
| SurfaceControl 来源与客户端创建开关 | ViewRootImpl.createSurfaceControl/updateSurfaceControl/relayoutWindow,WindowStateAnimator.createSurfaceLocked |
| 主线程绘制安排 | ViewRootImpl.scheduleTraversals/doTraversal/performTraversals,Choreographer.doFrame |
| 显示事件回到 Looper/Java | DisplayEventDispatcher,NativeDisplayEventReceiver,FrameDisplayEventReceiver |
| Java 与 RenderThread 交接 | HardwareRenderer,RenderProxy,DrawFrameTask.postAndWait/run,CanvasContext |
| 生产消费和 BLAST 事务 | Surface,BufferQueueProducer/Consumer,BLASTBufferQueue.acquireNextBufferLocked/releaseBuffer |
| buffer 分配/导入 | GraphicBufferAllocator,Gralloc4/5,ranchu allocator.cpp/mapper.cpp |
| SF 接收与合成 | SurfaceFlinger.setTransactionState/commit/composite/updateLayerSnapshots,CompositionEngine 的 Output/Display |
| HAL 与显示反馈 | HWComposer,AidlComposerHal,ranchu ComposerClient/Display/HostFrameComposer |
| Guest/Host 传输与同步 | qemu_pipe_guest.cpp,goldfish_pipe.c,goldfish_sync.c,sync_file.c |
| 文本布局与字形形成 | HWUI Canvas/MinikinUtils,Minikin Layout/FontCollection/LayoutCore,HarfBuzz |
| 退出收尾 | ViewRootImpl.dispatchDetachedFromWindow/destroySurface,RenderProxy.destroy,队列 disconnect/release |
本章固定阅读基线
本章用户空间采用本工程 android17-release 的固定项目提交,下表为读取时的项目 HEAD;摘录另保存文件摘要与函数范围,不以源码 HEAD 代替运行镜像身份。第一章的历史设备/Host 证据与本轮源码核对分开。官方概览中的旧接口、旧术语只用于机制对照,本文接口选择以固定版本源码和已记录的后端证据为准。
| 项目 | 提交 |
|---|---|
| frameworks/base | 94b4c163b7dfe5ce3607f7bb8456f9573f7de57d |
| frameworks/native | ae266dcb706d083868578cfedce381ef44488a07 |
| device/generic/goldfish | 296e55aa0244e8929e393e00e34471fef2a5d662 |
| hardware/google/gfxstream | b46f0d4b4545def09bdf30651d4bf848b2ba0c34 |
| frameworks/minikin | 915f1232cff2f38be1ed2273769c5ffd00928dff |
| external/skia | 508606366e71a3daa933a4e08bc49b84e387ec18 |
| external/harfbuzz_ng | 31e11a7283dce4ffc573fc8d249b3483988f8bde |
| external/icu | 00c713278f65a4db343c388f0c4f8501f70387b9 |
| hardware/interfaces | 0162af698935100a590b7359581ac8b1b80693e5 |
| Kernel common | ccafb60de224d35a8bc14de33e1cd47caaaa786b |
| Kernel virtual-device 模块 | 544e91ec0222069e5477857d16614b453e137340 |
Kernel 与模块完整工作树未放在当前工程,本章从官方 Gitiles 固定提交取得必要文件,保留于固定源码快照。快照是阅读/核对材料,不表示本轮重新构建或加载过对应模块。
本章待验证边界:APK 完整构建/安装、实际窗口和绘制 Trace、当前设备渲染管线/feature flag、逐帧 buffer/fence 配对与 Host 内部呈现;真实设备 GPU/DPU/DRM/KMS、字体配置切换与压力竞态也未实测。
附录:独立打包与 Trace 输入
这里补全 7.2 的独立打包输入和 7.13 的采集输入,第一次跟做时先保存这些文件。脚本只调用已有 Host 工具,不触发完整系统编译;缺工具、构建或安装步骤失败时先停下并保留错误,再解决前置问题。以下完整文件仍未在本次编写中打包、安装或采集。
$ch7_chapter/示例/构建示例APK.py
#!/usr/bin/env python3
"""用已构建的 AOSP Host 工具打包本章无资源示例(复用第二章 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()
$ch7_chapter/示例/追踪配置/一帧绘制.pbtxt
buffers { size_kb: 32768 fill_policy: RING_BUFFER }
duration_ms: 12000
data_sources {
config {
name: "linux.ftrace"
ftrace_config {
ftrace_events: "sched/sched_switch"
ftrace_events: "sched/sched_waking"
ftrace_events: "binder/binder_transaction"
ftrace_events: "binder/binder_transaction_received"
atrace_categories: "gfx"
atrace_categories: "view"
atrace_categories: "wm"
atrace_apps: "com.example.graphicsdemo"
}
}
}
data_sources { config { name: "linux.process_stats" process_stats_config { scan_all_processes_on_start: true } } }
data_sources { config { name: "android.surfaceflinger.frametimeline" } }
$ch7_chapter/示例/追踪配置/应用绘制区间.sql
SELECT p.name AS process_name, t.name AS thread_name,
s.name, s.ts / 1000000.0 AS start_ms, s.dur / 1000000.0 AS duration_ms
FROM slice s
JOIN thread_track tt ON s.track_id = tt.id
JOIN thread t ON tt.utid = t.utid
LEFT JOIN process p ON t.upid = p.upid
WHERE p.name = 'com.example.graphicsdemo'
AND (s.name GLOB 'Ch7.*' OR s.name GLOB '*DrawFrame*' OR s.name GLOB '*doFrame*')
ORDER BY s.ts;