Android 15 显示子系统深度解析(一)：显示框架总览与SurfaceFlinger核心机制

引言

"在Android系统中，显示子系统就像一个精密的交响乐团，应用层是作曲家，SurfaceFlinger是指挥家，各个Layer是演奏家，而屏幕则是舞台。只有各个角色完美配合，才能呈现流畅丝滑的视觉体验。"

作为Android系统中最复杂、最核心的子系统之一，显示子系统承担着将应用绘制的内容高效呈现到屏幕上的重任。无论是滑动列表的丝滑流畅，还是视频播放的画面稳定，背后都离不开显示子系统的精密调度。

Android 15在显示系统方面进行了重大优化，包括Canvas现代化改造、CanvasKit集成、HWC 3.0支持等，使得渲染性能和功耗都有了显著提升。作为《Android 15核心子系统深度解析》系列的第一篇，本文将带你深入理解Android显示框架的整体架构，并重点剖析SurfaceFlinger这一核心服务的工作机制。

你将学到什么

Android显示栈的完整分层架构
SurfaceFlinger服务的启动与初始化流程
Surface的本质及其创建管理机制
SurfaceFlinger的合成循环核心流程
实用的调试技巧和问题排查方法
Android 15的显示系统新特性

前置知识

Android应用开发基础（四大组件、View绘制流程）
基本的Linux进程间通信概念
图形学基础概念（帧缓冲、双缓冲等）

Android显示系统架构总览

Android的显示系统采用经典的分层设计，从应用层到硬件驱动层共分为四层，每一层都有明确的职责边界。

显示栈的分层架构

图1: Android显示系统的四层架构

让我们从上到下逐层解析：

1. 应用层 (Application Layer)

应用层是开发者最熟悉的部分，提供了多种绘制API：

kotlin 复制代码

// View/Canvas - 最常用的绘制方式
class CustomView(context: Context) : View(context) {
    override fun onDraw(canvas: Canvas) {
        canvas.drawCircle(100f, 100f, 50f, paint)
    }
}

// SurfaceView - 独立Surface，支持子线程绘制
class GameView(context: Context) : SurfaceView(context), SurfaceHolder.Callback {
    override fun surfaceCreated(holder: SurfaceHolder) {
        // 在独立线程中绘制
        thread {
            val canvas = holder.lockCanvas()
            // 绘制游戏画面
            holder.unlockCanvasAndPost(canvas)
        }
    }
}

// TextureView - 可以像普通View一样变换
val textureView = TextureView(context)
textureView.surfaceTextureListener = object : SurfaceTextureListener {
    override fun onSurfaceTextureAvailable(surface: SurfaceTexture, width: Int, height: Int) {
        // 绘制逻辑
    }
}

三种绘制方式的区别：

View/Canvas: 最简单，但只能在UI线程绘制，适合静态内容
SurfaceView: 拥有独立Surface，可子线程绘制，适合游戏和视频
TextureView: 基于SurfaceTexture，支持View变换（旋转、缩放），但性能略低

2. Framework层 (Framework Layer)

Framework层负责管理窗口和协调绘制：

WindowManager: 窗口管理器，负责Window的添加、删除和布局

每个Activity、Dialog、PopupWindow都对应一个Window
管理Window的Z-order（层级顺序）
与WindowManagerService通信

ViewRootImpl: 连接View和WindowManager的桥梁

每个Window都有一个ViewRootImpl
负责View树的measure、layout、draw
管理Surface的创建和更新
处理输入事件分发

Surface (Java层): 跨进程绘制的"画布"

java 复制代码

// frameworks/base/core/java/android/view/Surface.java
public class Surface implements Parcelable {
    // Native层Surface的引用
    private long mNativeObject;

    // 锁定画布进行绘制
    public Canvas lockCanvas(Rect inOutDirty) {
        // 从BufferQueue获取GraphicBuffer
        // 返回Canvas供应用绘制
    }

    // 提交绘制结果
    public void unlockCanvasAndPost(Canvas canvas) {
        // 将GraphicBuffer提交到BufferQueue
    }
}

3. Native层 (Native Layer)

Native层是显示系统的核心，主要包含：

SurfaceFlinger: 系统合成服务，本文重点讲解对象

运行在独立进程（PID通常较小）
负责所有Layer的合成
驱动整个渲染管线

BufferQueue: 生产者-消费者队列

应用（Producer）负责生产GraphicBuffer
SurfaceFlinger（Consumer）负责消费GraphicBuffer
典型配置：2-3个Buffer（双缓冲/三重缓冲）

GraphicBuffer: 跨进程共享的图形缓冲区

基于匿名共享内存(ashmem)或ION
通过Gralloc HAL分配
可同时被CPU和GPU访问

HWC (Hardware Composer): 硬件合成器

由硬件厂商实现的HAL层
可以利用硬件加速合成Layer
Android 15使用HWC 3.0版本

4. 驱动层 (Driver Layer)

Display Driver: 显示驱动

控制屏幕显示时序
产生硬件Vsync信号
管理显示模式（分辨率、刷新率）

GPU Driver: 图形处理器驱动

执行OpenGL ES / Vulkan指令
进行图形渲染
与Display Driver协同工作

从应用绘制到屏幕显示的完整流程

让我们通过一个简单的例子，理解数据是如何从应用流向屏幕的：

kotlin 复制代码

// 1. 应用层：开发者调用View.invalidate()
customView.invalidate()

// 2. Framework层：ViewRootImpl调度绘制
// ViewRootImpl.scheduleTraversals()
//   → Choreographer.postCallback(CALLBACK_TRAVERSAL)
//   → 等待Vsync信号

// 3. Vsync信号到达
//   → ViewRootImpl.doTraversal()
//   → performDraw()
//   → drawSoftware() 或 drawHardware()

// 4. 绘制到Surface
//   → Canvas canvas = surface.lockCanvas()
//   → view.draw(canvas)  // 执行onDraw()
//   → surface.unlockCanvasAndPost(canvas)

// 5. Native层：Buffer提交到BufferQueue
//   → BufferQueue.queueBuffer()
//   → 通知SurfaceFlinger有新内容

// 6. SurfaceFlinger合成
//   → 从BufferQueue获取Buffer
//   → 决定GPU合成还是HWC合成
//   → 将所有Layer合成到FrameBuffer

// 7. 驱动层：输出到屏幕
//   → Display Driver显示FrameBuffer内容

**小知识**: 在Android系统中，几乎所有的渲染都会走SurfaceFlinger进行合成，包括SystemUI（状态栏、导航栏）、Wallpaper（壁纸）、以及所有应用窗口。这也是为什么SurfaceFlinger性能如此关键的原因。

Android 15显示系统的新特性

Android 15在显示系统方面进行了多项重要优化：

1. Canvas现代化改造

引入CanvasKit（基于Skia的Web渲染引擎）
改进Canvas API性能
更好的文本渲染效果

2. HWC 3.0支持

更灵活的Layer合成策略
改进的色彩管理
更低的功耗

3. 动态刷新率优化

更智能的刷新率切换
减少不必要的高刷新率
改善电池续航

4. HDR支持增强

更完善的HDR10+支持
改进的色彩空间转换
更好的HDR内容显示效果

SurfaceFlinger服务启动与初始化

SurfaceFlinger作为Android显示系统的核心服务，其启动和初始化过程奠定了整个显示系统的基础。

SurfaceFlinger的启动时机

SurfaceFlinger由init进程在系统启动早期拉起，其启动配置定义在surfaceflinger.rc中：

bash 复制代码

# frameworks/native/services/surfaceflinger/surfaceflinger.rc
service surfaceflinger /system/bin/surfaceflinger
    class core animation
    user system
    group graphics drmrpc readproc
    capabilities SYS_NICE
    onrestart restart --only-if-running zygote
    task_profiles HighPerformance
    socket pdx/system/vr/display/client     stream 0666 system graphics u:object_r:pdx_display_client_endpoint_socket:s0
    socket pdx/system/vr/display/manager    stream 0666 system graphics u:object_r:pdx_display_manager_endpoint_socket:s0
    socket pdx/system/vr/display/vsync      stream 0666 system graphics u:object_r:pdx_display_vsync_endpoint_socket:s0

关键配置说明：

class core animation: 属于核心服务，在animation类启动
user system: 以system用户身份运行
group graphics: 拥有graphics组权限，可访问GPU设备
task_profiles HighPerformance: 高性能调度策略
onrestart restart --only-if-running zygote: 如果崩溃，重启Zygote（因为所有应用都依赖它）

服务启动流程

SurfaceFlinger的启动从main.cpp开始：

cpp 复制代码

// frameworks/native/services/surfaceflinger/main_surfaceflinger.cpp
int main(int, char**) {
    // 设置线程优先级
    signal(SIGPIPE, SIG_IGN);

    // 创建ProcessState（Binder通信基础）
    sp<ProcessState> ps(ProcessState::self());
    ps->setThreadPoolMaxThreadCount(4);
    ps->startThreadPool();

    // 创建SurfaceFlinger实例
    sp<SurfaceFlinger> flinger = surfaceflinger::createSurfaceFlinger();

    // 设置为系统服务
    flinger->init();

    // 注册到ServiceManager
    sp<IServiceManager> sm(defaultServiceManager());
    sm->addService(String16(SurfaceFlinger::getServiceName()), flinger,
                   false, IServiceManager::DUMP_FLAG_PRIORITY_CRITICAL |
                          IServiceManager::DUMP_FLAG_PROTO);

    // 启动线程池
    startDisplayService(); // dependency on SF getting registered above

    // 运行主循环
    flinger->run();

    return 0;
}

核心数据结构初始化

在SurfaceFlinger::init()中，会初始化大量核心组件：

cpp 复制代码

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp (简化)
void SurfaceFlinger::init() {
    ALOGI("SurfaceFlinger is starting");

    // 1. 创建HWComposer（硬件合成器）
    mCompositionEngine->setHwComposer(getFactory().createHWComposer(mHwcServiceName));

    // 2. 创建RenderEngine（GPU渲染引擎）
    mCompositionEngine->setRenderEngine(
        renderengine::RenderEngine::create(
            renderengine::RenderEngineCreationArgs::Builder()
                .setPixelFormat(defaultCompositionPixelFormat)
                .setImageCacheSize(maxFrameBufferAcquiredBuffers)
                .setUseColorManagerment(useColorManagement)
                .setEnableProtectedContext(enable_protected_contents(false))
                .setPrecacheToneMapperShaderOnly(false)
                .setSupportsBackgroundBlur(mSupportsBlur)
                .setContextPriority(useContextPriority
                    ? renderengine::RenderEngine::ContextPriority::REALTIME
                    : renderengine::RenderEngine::ContextPriority::MEDIUM)
                .build()));

    // 3. 创建Scheduler（调度器，管理Vsync）
    mScheduler = getFactory().createScheduler(...)

    // 4. 初始化DisplayDevice
    initializeDisplays();

    // 5. 创建EventThread（事件线程）
    mEventThreads.push_back(
        mScheduler->makeEventThread("app", ...));  // app-vsync
    mEventThreads.push_back(
        mScheduler->makeEventThread("appSf", ...)); // sf-vsync

    // 6. 启动合成循环
    mScheduler->startThin();

    ALOGI("SurfaceFlinger init completed");
}

核心组件说明：

HWComposer (Hardware Composer)

与硬件合成器HAL交互
管理Display设备
决定Layer的合成策略（GPU vs 硬件）

RenderEngine

封装GPU渲染能力
通常基于OpenGL ES或Skia
负责GPU合成路径

Scheduler

管理Vsync信号
调度合成时机
控制刷新率

EventThread

分发Vsync事件
app-vsync: 通知应用层（Choreographer）
sf-vsync: 通知SurfaceFlinger自己

与系统服务的交互

SurfaceFlinger需要与多个系统服务协作：

1. 向ServiceManager注册

cpp 复制代码

// 注册为ISurfaceComposer服务
sm->addService(String16("SurfaceFlinger"), flinger, ...)

其他进程可通过以下方式获取SurfaceFlinger服务：

cpp 复制代码

sp<ISurfaceComposer> sf = interface_cast<ISurfaceComposer>(
    defaultServiceManager()->getService(String16("SurfaceFlinger")));

2. 与WindowManagerService协作

WMS负责窗口管理和策略决策
SurfaceFlinger负责实际的图形合成
通过Binder IPC进行通信

3. 接收硬件Vsync

从Display Driver接收硬件Vsync中断
通过HWC HAL传递给SurfaceFlinger
驱动整个渲染管线

Surface创建与管理机制

Surface是Android显示系统中最核心的概念之一，理解Surface的本质和管理机制是掌握显示系统的关键。

Surface的本质：跨进程共享的画布

Surface本质上是一个跨进程共享的绘制缓冲区的封装。它连接了两个角色：

生产者（Producer）: 应用进程，负责绘制内容
消费者（Consumer）: SurfaceFlinger进程，负责合成显示

cpp 复制代码

// Surface的核心结构（简化）
class Surface {
    // 指向Native层Surface对象
    sp<IGraphicBufferProducer> mGraphicBufferProducer;

    // 当前正在使用的GraphicBuffer
    sp<GraphicBuffer> mLockedBuffer;

    // BufferQueue的配置
    uint32_t mReqWidth;
    uint32_t mReqHeight;
    PixelFormat mReqFormat;
};

Surface创建流程详解

让我们跟踪一个Activity窗口的Surface创建全过程：

1. 应用侧：Activity启动

kotlin 复制代码

// Activity.onCreate()被调用后
class MainActivity : Activity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 此时还没有Surface
    }

    override fun onResume() {
        super.onResume()
        // ViewRootImpl已创建，Surface即将创建
    }
}

2. Framework侧：ViewRootImpl创建Surface

java 复制代码

// frameworks/base/core/java/android/view/ViewRootImpl.java (简化)
public final class ViewRootImpl {
    final Surface mSurface = new Surface(); // 创建Surface对象

    private void performTraversals() {
        // 第一次布局时，请求创建Surface
        if (mSurfaceHolder == null) {
            relayoutWindow(params, viewVisibility, insetsPending);
        }
    }

    private int relayoutWindow(WindowManager.LayoutParams params, ...) {
        // 通过WMS请求SurfaceFlinger创建Surface
        int relayoutResult = mWindowSession.relayout(
            mWindow, params, ..., mSurface); // mSurface作为输出参数

        return relayoutResult;
    }
}

3. Native侧：SurfaceFlinger创建Layer和BufferQueue

cpp 复制代码

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp (简化)
status_t SurfaceFlinger::createLayer(const String8& name,
                                     const sp<Client>& client,
                                     uint32_t w, uint32_t h,
                                     PixelFormat format,
                                     uint32_t flags,
                                     sp<IBinder>* handle,
                                     sp<IGraphicBufferProducer>* gbp) {
    // 1. 创建Layer对象
    sp<Layer> layer;
    switch (flags & ISurfaceComposerClient::eFXSurfaceMask) {
        case ISurfaceComposerClient::eFXSurfaceBufferQueue:
            // 普通的Buffer Layer
            layer = new BufferQueueLayer(this, client, name, w, h, flags);
            break;
        case ISurfaceComposerClient::eFXSurfaceEffect:
            // 特效Layer（如模糊、颜色）
            layer = new EffectLayer(this, client, name, w, h, flags);
            break;
    }

    // 2. 创建BufferQueue
    sp<IGraphicBufferProducer> producer;
    sp<IGraphicBufferConsumer> consumer;
    BufferQueue::createBufferQueue(&producer, &consumer);

    // 3. Layer与BufferQueue关联
    layer->setBufferConsumer(consumer);

    // 4. 返回给应用
    *handle = layer->getHandle();
    *gbp = producer; // 返回Producer接口

    // 5. 将Layer加入Layer树
    mCurrentState.layersSortedByZ.add(layer);

    return NO_ERROR;
}

创建流程总结：

Activity启动 → ViewRootImpl创建
ViewRootImpl通过WMS请求创建Surface
SurfaceFlinger创建对应的Layer和BufferQueue
IGraphicBufferProducer返回给应用
应用通过Producer接口进行绘制

Layer的类型与管理

在SurfaceFlinger内部，每个Surface对应一个Layer。Android定义了多种Layer类型：

BufferQueueLayer（最常见）

cpp 复制代码

class BufferQueueLayer : public BufferLayer {
    // 持有BufferQueue的Consumer端
    sp<BufferQueueConsumer> mConsumer;

    // Layer的属性
    Rect mBounds;          // 位置和大小
    float mAlpha;          // 透明度
    int32_t mZOrder;       // Z轴顺序
    mat4 mTransform;       // 变换矩阵
};

EffectLayer（特效Layer）

用于颜色填充、模糊效果等
不需要BufferQueue
直接由GPU渲染特效

ContainerLayer（容器Layer）

不包含实际内容
用于组织Layer层级
例如：ActivityRecord的根Layer

Layer树的组织结构

所有Layer组织成一棵树，根据Z-order进行排序：

复制代码

RootLayer
  ├── WallpaperLayer (Z=-1)
  ├── AppLayer1 (Z=0)
  │     ├── SurfaceView1 (Z=0)
  │     └── SurfaceView2 (Z=1)
  ├── AppLayer2 (Z=1)
  ├── SystemUI (Z=100000)
  │     ├── StatusBar
  │     └── NavigationBar
  └── BootAnimation (Z=200000)

Z-order排序规则：

数值越大，越靠近用户（显示在上层）
SystemUI层级最高，始终显示在最上面
普通应用的Z-order通常在0附近
同一父Layer下的子Layer，也有相对Z-order

Layer的关键属性

cpp 复制代码

// Layer的核心属性（简化）
struct LayerState {
    // 几何属性
    Rect crop;              // 裁剪区域
    Rect frame;             // 显示区域
    float cornerRadius;     // 圆角半径
    mat4 matrix;            // 变换矩阵（旋转、缩放、平移）

    // 视觉属性
    half4 color;            // 颜色（RGBA）
    float alpha;            // 不透明度
    uint32_t flags;         // 标志位（隐藏、安全等）

    // 合成属性
    int32_t z;              // Z轴顺序
    uint32_t layerStack;    // 所属Display

    // 内容属性
    sp<GraphicBuffer> buffer;         // 当前Buffer
    sp<Fence> acquireFence;           // 同步Fence
    Rect transparentRegion;           // 透明区域
    Region opaqueRegion;              // 不透明区域
};

SurfaceFlinger的合成流程

SurfaceFlinger的合成流程是显示系统的核心，理解这个流程是掌握Android显示机制的关键。

合成循环的触发机制

SurfaceFlinger的合成循环由两种方式触发：

1. Vsync信号触发（主要方式）

cpp 复制代码

// Vsync到达 → Scheduler调度 → SurfaceFlinger::composite()
void SurfaceFlinger::onVsync(nsecs_t expectedVsyncTime) {
    // 收到Vsync信号，开始新的一帧
    composite();
}

2. Transaction触发（属性变更）

cpp 复制代码

// 应用修改Layer属性 → 提交Transaction → 触发合成
surface.setPosition(100, 200);  // Java层
surface.setAlpha(0.5f);
// → Native层提交Transaction
// → SurfaceFlinger处理Transaction
// → 触发重新合成

合成流程核心步骤

图2: SurfaceFlinger的合成流程

让我们深入分析合成流程的每个阶段：

阶段1：Transaction处理 (`commitTransactions`)

cpp 复制代码

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp (简化)
void SurfaceFlinger::commitTransactions() {
    ATRACE_CALL();

    // 1. 处理等待中的Transactions
    bool transactionFlushNeeded = transactionFlushNeeded();
    if (transactionFlushNeeded) {
        commitTransactionsLocked(eDisplayTransactionNeeded);
    }
}

void SurfaceFlinger::commitTransactionsLocked(uint32_t transactionFlags) {
    // 遍历所有Transactions
    for (const auto& [handle, compositorState] : mCompositorStates) {
        sp<Layer> layer = fromHandleLocked(handle).promote();
        if (layer) {
            // 应用属性变更到Layer
            layer->setPosition(compositorState.x, compositorState.y);
            layer->setAlpha(compositorState.alpha);
            layer->setMatrix(compositorState.matrix);
            // ... 其他属性
        }
    }

    // 标记需要重新计算可见区域
    mVisibleRegionsDirty = true;
}

Transaction处理的关键任务：

应用Layer属性变更（位置、大小、透明度等）
更新Layer树结构（添加、删除Layer）
标记需要重新计算的区域

阶段2：Layer遍历与准备 (`latchBuffers`)

cpp 复制代码

void SurfaceFlinger::latchBuffers() {
    ATRACE_CALL();

    // 遍历所有Layer
    for (const auto& layer : mDrawingState.layersSortedByZ) {
        // 1. 从BufferQueue获取最新的Buffer
        bool bufferUpdated = layer->latchBuffer();

        // 2. 更新Layer的内容区域
        if (bufferUpdated) {
            Region dirtyRegion = layer->getDirtyRegion();
            mDirtyRegion.orSelf(dirtyRegion);
        }
    }

    // 计算可见区域
    computeVisibleRegions();
}

关键操作：

latchBuffer(): 从BufferQueue获取最新的GraphicBuffer
getDirtyRegion(): 计算需要重绘的区域
computeVisibleRegions(): 计算每个Layer的可见部分（考虑遮挡关系）

阶段3：合成策略决策

SurfaceFlinger需要决定使用GPU合成还是HWC硬件合成：

cpp 复制代码

// 简化的决策逻辑
void SurfaceFlinger::computeCompositionType() {
    // 1. 先假设所有Layer都用GPU合成
    for (auto& layer : layers) {
        layer->setCompositionType(CompositionType::CLIENT);
    }

    // 2. 询问HWC是否能硬件合成
    hwc->validateDisplay(displayId, &numTypes, &numRequests);

    // 3. HWC会修改Layer的合成类型
    // CompositionType::DEVICE - HWC可以硬件合成
    // CompositionType::CLIENT - 需要GPU合成
    // CompositionType::SOLID_COLOR - 纯色填充
    // CompositionType::CURSOR - 硬件光标
}

合成类型说明：

合成类型	说明	性能
`DEVICE`	HWC硬件合成	最高（低功耗）
`CLIENT`	GPU合成（OpenGL/Vulkan）	中等
`SOLID_COLOR`	纯色填充（无Buffer）	最高
`CURSOR`	硬件光标叠加	最高

**优化技巧**: HWC硬件合成的功耗远低于GPU合成。应用开发时，尽量避免使用HWC不支持的特性（如复杂的Shader、旋转等），让更多Layer走硬件合成路径。

阶段4：执行合成

根据合成策略，分别执行GPU合成和HWC合成：

GPU合成路径：

cpp 复制代码

void SurfaceFlinger::doComposeSurfaces(const DisplayDevice& display) {
    auto& engine = getRenderEngine();

    // 1. 准备渲染目标（FrameBuffer或离屏Buffer）
    const auto& outputState = display.getState();
    auto framebuffer = outputState.framebuffer;

    // 2. 设置渲染参数
    engine->setViewportAndProjection(width, height, viewport, projection);
    engine->setOutputDataSpace(outputDataSpace);
    engine->setDisplayMaxLuminance(maxLuminance);

    // 3. 遍历需要GPU合成的Layer
    for (auto& layer : clientCompositionLayers) {
        // 构建Layer渲染设置
        auto settings = layer->prepareClientCompositionSettings(
            clip, needsFiltering, isSecure, ...);

        // 添加到渲染列表
        clientCompositionList.push_back(settings);
    }

    // 4. 执行渲染
    engine->drawLayers(clientCompositionList, framebuffer, ...);
}

HWC合成路径：

cpp 复制代码

void SurfaceFlinger::presentDisplay(const DisplayDevice& display) {
    auto& hwc = getHwComposer();

    // 1. 设置Layer信息到HWC
    for (auto& layer : layers) {
        if (layer->getCompositionType() == CompositionType::DEVICE) {
            hwc->setLayerBuffer(displayId, layerId,
                               layer->getBuffer(),
                               layer->getAcquireFence());
            hwc->setLayerDisplayFrame(displayId, layerId, layer->getFrame());
            hwc->setLayerSourceCrop(displayId, layerId, layer->getCrop());
            // ... 其他属性
        }
    }

    // 2. 执行硬件合成
    hwc->presentDisplay(displayId, &presentFence);

    // 3. 等待合成完成
    presentFence->waitForever();
}

阶段5：输出到Display

cpp 复制代码

void SurfaceFlinger::postComposition() {
    // 1. 获取Present Fence
    auto fence = display->getCompositionDisplay()->getReleaseFence();

    // 2. 发送到Display Driver
    display->present();

    // 3. 释放旧的Buffer
    for (auto& layer : layers) {
        layer->onPostComposition(fence);
    }

    // 4. 通知应用Buffer可以释放
    mTransactionCallbackInvoker.sendCallbacks();
}

Frame buffer管理与Fence同步

Frame buffer：

存储最终合成结果的Buffer
通常有2-3个（双缓冲/三重缓冲）
一个正在显示，一个正在合成，一个空闲

Fence同步机制：

cpp 复制代码

// Fence用于同步GPU/HWC的异步操作
class Fence {
    int mFenceFd;  // 内核fence文件描述符

    // 等待fence信号（阻塞）
    status_t wait(int timeout) {
        return sync_wait(mFenceFd, timeout);
    }

    // 检查fence是否已经信号
    bool isValid() { return mFenceFd != -1; }
};

// 使用示例
sp<Fence> acquireFence = layer->getAcquireFence();
acquireFence->waitForever("Waiting for buffer");
// Buffer现在可以安全读取了

Fence的作用：

acquireFence: 应用写完Buffer后设置，SurfaceFlinger等待此Fence才能读取Buffer
releaseFence: SurfaceFlinger读完Buffer后设置，应用等待此Fence才能重用Buffer
presentFence: 显示完成后设置，用于统计真实的显示时间

调试技巧与常见问题

掌握调试技巧是理解和解决显示问题的关键。

dumpsys SurfaceFlinger详解

dumpsys SurfaceFlinger是最常用的调试命令：

bash 复制代码

# 查看SurfaceFlinger完整状态
adb shell dumpsys SurfaceFlinger

# 查看Layer列表
adb shell dumpsys SurfaceFlinger --list

# 查看Vsync信息
adb shell dumpsys SurfaceFlinger --vsync-info

# 查看Display信息
adb shell dumpsys SurfaceFlinger --display-id

# 查看渲染统计
adb shell dumpsys SurfaceFlinger --frame-stats

输出示例：

复制代码

SurfaceFlinger (platform 35, AOSP-Android 15)
Build: Android 15 / xxxxx

Displays:
  Display 0 (primary)
    size: 1080x2400
    refresh: 90 Hz
    power: ON

Visible Layers:
  Layer 1234 (com.example.app/MainActivity)
    z=0, alpha=1.0, pos=(0, 0), size=(1080, 2400)
    compositionType=DEVICE
    buffer=0x7f8a9c0000 (1080x2400 RGBA_8888)

  Layer 5678 (StatusBar)
    z=100000, alpha=1.0, pos=(0, 0), size=(1080, 100)
    compositionType=DEVICE
    buffer=0x7f8a9d0000 (1080x100 RGBA_8888)

常用调试属性

bash 复制代码

# 强制GPU合成（禁用HWC）
adb shell setprop debug.sf.disable_hwc 1

# 显示Layer边界
adb shell setprop debug.sf.show_layers 1

# 显示CPU使用情况
adb shell setprop debug.sf.show_cpu 1

# 显示刷新率
adb shell setprop debug.sf.show_refresh_rate 1

# 禁用三重缓冲
adb shell setprop debug.sf.enable_triple_buffer 0

# 重启SurfaceFlinger使属性生效
adb shell stop surfaceflinger && adb shell start surfaceflinger

黑屏/花屏问题排查

黑屏问题排查思路：

检查Surface是否创建成功

bash 复制代码

adb shell dumpsys SurfaceFlinger --list | grep <package-name>
# 如果没有输出，说明Surface未创建

检查Buffer是否提交

bash 复制代码

adb shell dumpsys SurfaceFlinger | grep -A20 <layer-name>
# 查看buffer字段是否为null

检查Display电源状态

bash 复制代码

adb shell dumpsys SurfaceFlinger | grep power
# 应该显示 power: ON

查看日志

bash 复制代码

adb logcat -b all | grep -E "SurfaceFlinger|BufferQueue|GraphicBuffer"

花屏问题排查：

检查Buffer格式是否正确（RGBA vs YUV）
检查stride对齐问题
查看是否有GPU渲染错误

性能分析工具

systrace / Perfetto：

bash 复制代码

# 抓取显示系统trace
python systrace.py -t 10 gfx view sched freq -o trace.html

# 重点关注：
# - SurfaceFlinger: 合成耗时
# - RenderThread: 应用侧渲染耗时
# - VSYNC: 是否按时完成

GPU呈现模式：

bash 复制代码

# 在开发者选项中启用"GPU呈现模式分析"
# 或通过命令：
adb shell setprop debug.hwui.profile true
adb shell setprop debug.hwui.profile.maxframes 128

总结与展望

本文作为《Android 15核心子系统深度解析》系列的开篇之作，全面介绍了Android显示系统的整体架构和SurfaceFlinger的核心机制。

核心要点回顾

Android显示系统采用四层架构：应用层、Framework层、Native层、驱动层，各司其职，协同工作
SurfaceFlinger是显示系统的核心：
- 负责所有Layer的合成
- 由Vsync驱动工作
- 智能选择GPU/HWC合成策略
Surface是跨进程共享的绘制缓冲区：
- 应用通过Producer接口绘制
- SurfaceFlinger通过Consumer接口消费
- BufferQueue实现生产者-消费者模式
合成流程包含五个关键阶段：
- Transaction处理
- Layer遍历与准备
- 合成策略决策
- 执行合成（GPU或HWC）
- 输出到Display
Android 15的显示优化：
- Canvas现代化
- HWC 3.0支持
- 动态刷新率
- HDR增强

下一步学习

在下一篇文章《图形缓冲区管理与HWC硬件合成》中，我们将深入探讨：

GraphicBuffer和BufferQueue的实现细节
Gralloc HAL的工作机制
HWC 3.0的架构和合成策略
Fence同步的底层原理
Android 15的Buffer管理优化

实践建议

动手实验 ：修改debug.sf.*属性，观察显示行为变化
阅读源码 ：从main_surfaceflinger.cpp开始，跟踪完整启动流程
使用工具：熟练使用systrace和dumpsys分析实际问题
关注性能：理解HWC硬件合成的优势，优化应用渲染策略

参考资源

源码路径

复制代码

frameworks/native/services/surfaceflinger/  # SurfaceFlinger主目录
frameworks/native/libs/gui/                 # GUI库(Surface, BufferQueue)
frameworks/native/libs/ui/                  # UI库(GraphicBuffer)
frameworks/base/core/java/android/view/     # Framework层

官方文档

调试命令速查

bash 复制代码

# SurfaceFlinger状态
adb shell dumpsys SurfaceFlinger

# Layer列表
adb shell dumpsys SurfaceFlinger --list

# 强制GPU合成
adb shell setprop debug.sf.disable_hwc 1

# Systrace抓取
python systrace.py -t 10 gfx view sched -o trace.html

系列文章

下一篇：Android 15 显示子系统深度解析(二)：图形缓冲区管理与HWC硬件合成

欢迎来我中的个人主页找到更多有用的知识和有趣的产品

Android 15 显示子系统深度解析(一)：显示框架总览与SurfaceFlinger核心机制

引言

你将学到什么

前置知识

Android显示系统架构总览

显示栈的分层架构

1. 应用层 (Application Layer)

2. Framework层 (Framework Layer)

3. Native层 (Native Layer)

4. 驱动层 (Driver Layer)

从应用绘制到屏幕显示的完整流程

Android 15显示系统的新特性

SurfaceFlinger服务启动与初始化

SurfaceFlinger的启动时机

服务启动流程

核心数据结构初始化

与系统服务的交互

Surface创建与管理机制

Surface的本质：跨进程共享的画布

Surface创建流程详解

1. 应用侧：Activity启动

2. Framework侧：ViewRootImpl创建Surface

3. Native侧：SurfaceFlinger创建Layer和BufferQueue

Layer的类型与管理

Layer树的组织结构

Layer的关键属性

SurfaceFlinger的合成流程

合成循环的触发机制

合成流程核心步骤

阶段1：Transaction处理 (commitTransactions)

阶段2：Layer遍历与准备 (latchBuffers)

阶段3：合成策略决策

阶段4：执行合成

阶段5：输出到Display

Frame buffer管理与Fence同步

调试技巧与常见问题

dumpsys SurfaceFlinger详解

常用调试属性

黑屏/花屏问题排查

性能分析工具

总结与展望

核心要点回顾

下一步学习

实践建议

参考资源

源码路径

官方文档

调试命令速查

系列文章

阶段1：Transaction处理 (`commitTransactions`)

阶段2：Layer遍历与准备 (`latchBuffers`)