SurfaceFlinger Layer 到 HWC 通信流程详解

dalancon
21 阅读16分钟

SurfaceFlinger Layer 到 HWC 通信流程详解

概述

本文档详细描述 Android 14 (AOSP android-14.0.0_r21) 中 SurfaceFlinger 的 Layer 如何转变为 OutputLayer，以及如何与 Hardware Composer (HWC) 进行通信的完整流程。

一、核心类关系图

┌─────────────────────────────────────────────────────────────────────────────┐
│                              SurfaceFlinger                                  │
│  ┌─────────────────┐                                                        │
│  │     Layer       │ ───────────────────────────────────────────┐           │
│  │  (前端层对象)    │                                          │           │
│  └────────┬────────┘                                          │           │
│           │ getCompositionEngineLayerFE()                      │           │
│           ▼                                                   │           │
│  ┌─────────────────┐                                          │           │
│  │     LayerFE     │ (Layer FrontEnd - 组合引擎前端接口)        │           │
│  └────────┬────────┘                                          │           │
└───────────┼───────────────────────────────────────────────────┼───────────┘
            │                                                   │
            │ 包含 LayerFECompositionState                      │
            ▼                                                   │
┌───────────────────────────────────────────────────────────────┼───────────┐
│                     CompositionEngine                          │           │
│  ┌─────────────────────────────────────────────────────────────┼──────┐   │
│  │                      Display                                 │      │   │
│  │  ┌──────────────────────────────────────────────────────────┼───┐  │   │
│  │  │                    Output                                 │   │  │   │
│  │  │  ┌───────────────────────────────────────────────────────┼─┐│  │   │
│  │  │  │              OutputLayer                              │ ││  │   │
│  │  │  │  ┌─────────────────┐    ┌──────────────────────────┐ │ ││  │   │
│  │  │  │  │   LayerFE&      │    │ OutputLayerComposition   │ │ ││  │   │
│  │  │  │  │   (引用)        │    │ State (组合状态)          │ │ ││  │   │
│  │  │  │  └─────────────────┘    └──────────────────────────┘ │ ││  │   │
│  │  │  │                          │                           │ ││  │   │
│  │  │  │                          │ 包含 Hwc state            │ ││  │   │
│  │  │  │                          ▼                           │ ││  │   │
│  │  │  │              ┌───────────────────────┐               │ ││  │   │
│  │  │  │              │   HWC2::Layer*        │◄──────────────┼─┼┼──┼──┤
│  │  │  │              │   (HWC 硬件层)        │               │ ││  │   │
│  │  │  │              └───────────────────────┘               │ ││  │   │
│  │  │  └──────────────────────────────────────────────────────┘ ││  │   │
│  │  └────────────────────────────────────────────────────────────┘│  │   │
│  └─────────────────────────────────────────────────────────────────┘  │   │
└────────────────────────────────────────────────────────────────────────┘   │
                                                                              │
┌─────────────────────────────────────────────────────────────────────────────┘
│  ┌─────────────────────────────────────────────────────────────────────┐
│  │                          HWComposer                                  │
│  │  ┌───────────────────────────────────────────────────────────────┐  │
│  │  │                    HWC2::Display                               │  │
│  │  │  ┌─────────────────────────────────────────────────────────┐  │  │
│  │  │  │                  HWC2::Layer                             │  │  │
│  │  │  │  (硬件抽象层 - 与 HAL 通信)                               │  │  │
│  │  │  └─────────────────────────────────────────────────────────┘  │  │
│  │  └───────────────────────────────────────────────────────────────┘  │
│  └─────────────────────────────────────────────────────────────────────┘
└─────────────────────────────────────────────────────────────────────────────┘

二、完整调用流程

阶段 1: SurfaceFlinger 入口

2.1 SurfaceFlinger::composite() - 组合入口

文件路径: frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

// SurfaceFlinger.cpp:2489
CompositeResultsPerDisplay SurfaceFlinger::composite(
        PhysicalDisplayId pacesetterId, const scheduler::FrameTargeters& frameTargeters) {
    const scheduler::FrameTarget& pacesetterTarget =
            frameTargeters.get(pacesetterId)->get()->target();

    const VsyncId vsyncId = pacesetterTarget.vsyncId();
    ATRACE_NAME(ftl::Concat(__func__, ' ', ftl::to_underlying(vsyncId)).c_str());

    // 构建组合刷新参数
    compositionengine::CompositionRefreshArgs refreshArgs;
    refreshArgs.powerCallback = this;
    const auto& displays = FTL_FAKE_GUARD(mStateLock, mDisplays);
    refreshArgs.outputs.reserve(displays.size());

    // 添加物理显示器的输出
    for (const auto& [id, targeter] : frameTargeters) {
        ftl::FakeGuard guard(mStateLock);
        if (const auto display = getCompositionDisplayLocked(id)) {
            refreshArgs.outputs.push_back(display);
        }
    }

    // 添加虚拟显示器的输出
    for (const auto& [_, display] : displays) {
        if (display->isVirtual()) {
            const Fps refreshRate = display->getAdjustedRefreshRate();
            if (!refreshRate.isValid() ||
                mScheduler->isVsyncInPhase(pacesetterTarget.frameBeginTime(), refreshRate)) {
                refreshArgs.outputs.push_back(display->getCompositionDisplay());
            }
        }
    }

    // 收集有队列帧的 Layer
    refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
    for (auto layer : mLayersWithQueuedFrames) {
        if (auto layerFE = layer->getCompositionEngineLayerFE())
            refreshArgs.layersWithQueuedFrames.push_back(layerFE);
    }

    // 设置各种刷新参数
    refreshArgs.outputColorSetting = useColorManagement ? mDisplayColorSetting
                                                        : compositionengine::OutputColorSetting::kUnmanaged;
    refreshArgs.updatingOutputGeometryThisFrame = mVisibleRegionsDirty;
    refreshArgs.updatingGeometryThisFrame = mGeometryDirty.exchange(false) || mVisibleRegionsDirty;
    refreshArgs.internalDisplayRotationFlags = getActiveDisplayRotationFlags();
    refreshArgs.devOptForceClientComposition = mDebugDisableHWC;

    // ★★★ 调用 CompositionEngine 进行呈现 ★★★
    mCompositionEngine->present(refreshArgs);

    // ... 后续处理
}

阶段 2: CompositionEngine 主流程

2.2 CompositionEngine::present() - 引擎入口

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/CompositionEngine.cpp

// CompositionEngine.cpp:75
void CompositionEngine::present(CompositionRefreshArgs& args) {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);

    // 预组合处理
    preComposition(args);

    {
        // 用于跟踪已锁定的前端层状态
        LayerFESet latchedLayers;

        // 为每个输出准备（重建 Layer 栈）
        for (const auto& output : args.outputs) {
            output->prepare(args, latchedLayers);
        }
    }

    // 为每个输出执行呈现
    for (const auto& output : args.outputs) {
        output->present(args);
    }
}
2.3 Output::prepare() - 准备阶段

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:420
void Output::prepare(const compositionengine::CompositionRefreshArgs& refreshArgs,
                     LayerFESet& geomSnapshots) {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);

    // ★★★ 重建 Layer 栈 - 创建 OutputLayer ★★★
    rebuildLayerStacks(refreshArgs, geomSnapshots);

    // 清理缓冲区缓存
    uncacheBuffers(refreshArgs.bufferIdsToUncache);
}

阶段 3: 重建 Layer 栈 (rebuildLayerStacks)

2.4 Output::rebuildLayerStacks() - 重建 Layer 栈

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:471
void Output::rebuildLayerStacks(const compositionengine::CompositionRefreshArgs& refreshArgs,
                                LayerFESet& layerFESet) {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);

    auto& outputState = editState();

    // 如果输出未启用或不需要更新几何，直接返回
    if (!outputState.isEnabled || CC_LIKELY(!refreshArgs.updatingOutputGeometryThisFrame)) {
        return;
    }

    // 处理 Layer 以确定可见性和覆盖区域
    compositionengine::Output::CoverageState coverage{layerFESet};
    coverage.aboveCoveredLayersExcludingOverlays = refreshArgs.hasTrustedPresentationListener
            ? std::make_optional<Region>()
            : std::nullopt;

    // ★★★ 收集可见 Layer ★★★
    collectVisibleLayers(refreshArgs, coverage);

    // 计算并存储覆盖信息
    const ui::Transform& tr = outputState.transform;
    Region undefinedRegion{outputState.displaySpace.getBoundsAsRect()};
    undefinedRegion.subtractSelf(tr.transform(coverage.aboveOpaqueLayers));

    outputState.undefinedRegion = undefinedRegion;
    outputState.dirtyRegion.orSelf(coverage.dirtyRegion);
}
2.5 Output::collectVisibleLayers() - 收集可见 Layer

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:493
void Output::collectVisibleLayers(const compositionengine::CompositionRefreshArgs& refreshArgs,
                                  compositionengine::Output::CoverageState& coverage) {
    // 从前到后遍历 Layer 以确定可见性
    for (auto layer : reversed(refreshArgs.layers)) {
        // 为每个 Layer 增量处理覆盖信息
        ensureOutputLayerIfVisible(layer, coverage);
    }

    setReleasedLayers(refreshArgs);
    finalizePendingOutputLayers();
}
2.6 Output::ensureOutputLayerIfVisible() - 确保可见 Layer 有 OutputLayer

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:516
void Output::ensureOutputLayerIfVisible(sp<compositionengine::LayerFE>& layerFE,
                                        compositionengine::Output::CoverageState& coverage) {
    // 确保每个候选 Layer 只锁定一次快照
    if (!coverage.latchedLayers.count(layerFE)) {
        coverage.latchedLayers.insert(layerFE);
    }

    // 只考虑在此输出上的 Layer
    if (!includesLayer(layerFE)) {
        return;
    }

    // 获取前端层状态
    const auto* layerFEState = layerFE->getCompositionState();
    if (CC_UNLIKELY(!layerFEState)) {
        return;
    }

    // 处理隐藏表面
    if (CC_UNLIKELY(!layerFEState->isVisible)) {
        return;
    }

    // 计算各种区域（可见区域、不透明区域、覆盖区域等）
    Region opaqueRegion;
    Region visibleRegion;
    Region coveredRegion;
    Region transparentRegion;
    Region shadowRegion;

    const ui::Transform& tr = layerFEState->geomLayerTransform;
    const Rect visibleRect(tr.transform(layerFEState->geomLayerBounds));
    visibleRegion.set(visibleRect);

    // 处理阴影
    if (layerFEState->shadowRadius > 0.0f) {
        const auto inset = static_cast<int32_t>(ceilf(layerFEState->shadowRadius) * -1.0f);
        Rect visibleRectWithShadows(visibleRect);
        visibleRectWithShadows.inset(inset, inset, inset, inset);
        visibleRegion.set(visibleRectWithShadows);
        shadowRegion = visibleRegion.subtract(visibleRect);
    }

    // 如果可见区域为空，直接返回
    if (visibleRegion.isEmpty()) {
        return;
    }

    // 计算不透明区域
    const auto layerOrientation = tr.getOrientation();
    if (layerFEState->isOpaque && ((layerOrientation & ui::Transform::ROT_INVALID) == 0)) {
        opaqueRegion.set(visibleRect);
    }

    // 计算覆盖区域
    coveredRegion = coverage.aboveCoveredLayers.intersect(visibleRegion);
    coverage.aboveCoveredLayers.orSelf(visibleRegion);

    // 减去上方不透明区域
    visibleRegion.subtractSelf(coverage.aboveOpaqueLayers);

    if (visibleRegion.isEmpty()) {
        return;
    }

    // 获取之前显示的覆盖信息
    auto prevOutputLayerIndex = findCurrentOutputLayerForLayer(layerFE);

    // ★★★ Layer 可见，获取或创建 OutputLayer ★★★
    auto result = ensureOutputLayer(prevOutputLayerIndex, layerFE);

    // 存储 Layer 覆盖信息到状态
    auto& outputLayerState = result->editState();
    outputLayerState.visibleRegion = visibleRegion;
    outputLayerState.visibleNonTransparentRegion = visibleRegion.subtract(transparentRegion);
    outputLayerState.coveredRegion = coveredRegion;
    outputLayerState.outputSpaceVisibleRegion = outputState.transform.transform(
            visibleRegion.subtract(shadowRegion).intersect(outputState.layerStackSpace.getContent()));
    outputLayerState.shadowRegion = shadowRegion;

    // 更新上方不透明区域
    coverage.aboveOpaqueLayers.orSelf(opaqueRegion);
}

阶段 4: 创建 OutputLayer

2.7 impl::Output::ensureOutputLayer() - 模板实现

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/Output.h

// 在 createOutputTemplated 模板中定义
template <typename BaseOutput, typename CompositionEngine, typename... Args>
std::shared_ptr<BaseOutput> createOutputTemplated(const CompositionEngine& compositionEngine,
                                                  Args... args) {
    class Output final : public BaseOutput {
    public:
        // ...

        // ★★★ ensureOutputLayer 的核心实现 ★★★
        OutputLayer* ensureOutputLayer(std::optional<size_t> prevIndex,
                                       const sp<LayerFE>& layerFE) {
            // 判断是否可以复用已有的 OutputLayer
            auto outputLayer = (prevIndex && *prevIndex <= mCurrentOutputLayersOrderedByZ.size())
                    ? std::move(mCurrentOutputLayersOrderedByZ[*prevIndex])  // 复用已有的
                    : BaseOutput::createOutputLayer(layerFE);                 // ★ 创建新的

            auto result = outputLayer.get();

            // 将 OutputLayer 添加到待处理列表
            mPendingOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));

            return result;
        }

    private:
        std::vector<std::unique_ptr<OutputLayer>> mCurrentOutputLayersOrderedByZ;
        std::vector<std::unique_ptr<OutputLayer>> mPendingOutputLayersOrderedByZ;
    };

    return std::make_shared<Output>(compositionEngine, std::forward<Args>(args)...);
}
2.8 Output::createOutputLayer() - 基类实现

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:396
std::unique_ptr<compositionengine::OutputLayer> Output::createOutputLayer(
        const sp<LayerFE>& layerFE) const {
    return impl::createOutputLayer(*this, layerFE);
}
2.9 Display::createOutputLayer() - Display 重写实现

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Display.cpp

// Display.cpp:156
std::unique_ptr<compositionengine::OutputLayer> Display::createOutputLayer(
        const sp<compositionengine::LayerFE>& layerFE) const {
    // ★ 步骤 1: 创建 OutputLayer 对象
    auto outputLayer = impl::createOutputLayer(*this, layerFE);

    // ★ 步骤 2: 如果是 HWC 支持的显示，创建 HWC Layer
    if (const auto halDisplayId = HalDisplayId::tryCast(mId);
        outputLayer && !mIsDisconnected && halDisplayId) {

        auto& hwc = getCompositionEngine().getHwComposer();

        // ★★★ 创建 HWC Layer ★★★
        auto hwcLayer = hwc.createLayer(*halDisplayId);

        ALOGE_IF(!hwcLayer, "Failed to create a HWC layer for a HWC supported display %s",
                 getName().c_str());

        // ★ 步骤 3: 将 HWC Layer 设置到 OutputLayer
        outputLayer->setHwcLayer(std::move(hwcLayer));
    }
    return outputLayer;
}

阶段 5: HWC Layer 创建

2.10 HWComposer::createLayer() - HWC 创建 Layer

文件路径: frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp

// HWComposer.cpp:326
std::shared_ptr<HWC2::Layer> HWComposer::createLayer(HalDisplayId displayId) {
    RETURN_IF_INVALID_DISPLAY(displayId, nullptr);

    // 调用 HWC2::Display 创建 Layer
    auto expected = mDisplayData[displayId].hwcDisplay->createLayer();
    if (!expected.has_value()) {
        auto error = std::move(expected).error();
        RETURN_IF_HWC_ERROR(error, displayId, nullptr);
    }
    return std::move(expected).value();
}
2.11 HWC2::Display::createLayer() - HWC2 创建 Layer

文件路径: frameworks/native/services/surfaceflinger/DisplayHardware/HWC2.cpp

// HWC2.cpp:175
base::expected<std::shared_ptr<HWC2::Layer>, hal::Error> Display::createLayer() {
    HWLayerId layerId = 0;

    // ★★★ 调用 Composer HAL 创建 Layer ★★★
    auto intError = mComposer.createLayer(mId, &layerId);
    auto error = static_cast<Error>(intError);
    if (error != Error::NONE) {
        return base::unexpected(error);
    }

    // 创建 HWC2::impl::Layer 对象
    auto layer = std::make_shared<impl::Layer>(mComposer, mCapabilities, *this, layerId);

    // 存储到 Layer 映射表
    mLayers.emplace(layerId, layer);
    return layer;
}

阶段 6: OutputLayer 与 HWC Layer 关联

2.12 impl::createOutputLayer() - 创建 OutputLayer

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp

// OutputLayer.cpp:59
std::unique_ptr<OutputLayer> createOutputLayer(const compositionengine::Output& output,
                                               const sp<compositionengine::LayerFE>& layerFE) {
    return createOutputLayerTemplated<OutputLayer>(output, layerFE);
}
2.13 createOutputLayerTemplated() - 模板实现

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayer.h

// OutputLayer.h
template <typename BaseOutputLayer>
std::unique_ptr<BaseOutputLayer> createOutputLayerTemplated(const Output& output,
                                                            sp<LayerFE> layerFE) {
    // 定义局部类 OutputLayer，继承自 BaseOutputLayer
    class OutputLayer final : public BaseOutputLayer {
    public:
        using OutputLayerCompositionState = std::remove_const_t<
                std::remove_reference_t<decltype(std::declval<BaseOutputLayer>().getState())>>;
        using Output = std::remove_const_t<
                std::remove_reference_t<decltype(std::declval<BaseOutputLayer>().getOutput())>>;
        using LayerFE =
                std::remove_reference_t<decltype(std::declval<BaseOutputLayer>().getLayerFE())>>;

        // ★★★ 构造函数 ★★★
        OutputLayer(const Output& output, const sp<LayerFE>& layerFE)
              : mOutput(output),        // 存储 Output 引用
                mLayerFE(layerFE)       // 存储 LayerFE 引用
        {}

        ~OutputLayer() override = default;

    private:
        const Output& getOutput() const override { return mOutput; }
        LayerFE& getLayerFE() const override { return *mLayerFE; }
        const OutputLayerCompositionState& getState() const override { return mState; }
        OutputLayerCompositionState& editState() override { return mState; }
        void dumpState(std::string& out) const override { mState.dump(out); }

        const Output& mOutput;                              // Output 引用
        const sp<LayerFE> mLayerFE;                         // LayerFE 智能指针
        OutputLayerCompositionState mState;                 // 组合状态
    };

    return std::make_unique<OutputLayer>(output, layerFE);
}
2.14 OutputLayer::setHwcLayer() - 建立关联

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp

// OutputLayer.cpp:66
void OutputLayer::setHwcLayer(std::shared_ptr<HWC2::Layer> hwcLayer) {
    auto& state = editState();
    if (hwcLayer) {
        // ★★★ 将 HWC Layer 存储到 OutputLayer 的状态中 ★★★
        state.hwc.emplace(std::move(hwcLayer));
    } else {
        state.hwc.reset();
    }
}

阶段 7: Output::present() 主流程

2.15 Output::present() - 呈现主流程

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:445
void Output::present(const compositionengine::CompositionRefreshArgs& refreshArgs) {
    ATRACE_FORMAT("%s for %s", __func__, mNamePlusId.c_str());
    ALOGV(__FUNCTION__);

    // 1. 更新颜色配置
    updateColorProfile(refreshArgs);

    // 2. 更新组合状态（在 prepare 阶段已重建 Layer 栈）
    updateCompositionState(refreshArgs);

    // 3. 规划组合策略
    planComposition();

    // 4. 写入组合状态到 HWC
    writeCompositionState(refreshArgs);

    // 5. 设置颜色变换
    setColorTransform(refreshArgs);

    // 6. 开始帧
    beginFrame();

    // 7. 准备帧（与 HWC 交互）
    GpuCompositionResult result;
    const bool predictCompositionStrategy = canPredictCompositionStrategy(refreshArgs);
    if (predictCompositionStrategy) {
        result = prepareFrameAsync();
    } else {
        prepareFrame();
    }

    // 8. 开发选项：重绘闪烁
    devOptRepaintFlash(refreshArgs);

    // 9. 完成帧（GPU 合成）
    finishFrame(std::move(result));

    // 10. 提交帧缓冲
    postFramebuffer();

    // 11. 渲染缓存集
    renderCachedSets(refreshArgs);
}

阶段 8: 更新组合状态

2.16 Output::updateCompositionState() - 更新组合状态

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:755
void Output::updateCompositionState(const compositionengine::CompositionRefreshArgs& refreshArgs) {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);

    if (!getState().isEnabled) {
        return;
    }

    // 查找请求背景模糊的 Layer
    mLayerRequestingBackgroundBlur = findLayerRequestingBackgroundComposition();
    bool forceClientComposition = mLayerRequestingBackgroundBlur != nullptr;

    // 为每个 OutputLayer 更新组合状态
    for (auto* layer : getOutputLayersOrderedByZ()) {
        layer->updateCompositionState(refreshArgs.updatingGeometryThisFrame,
                                      refreshArgs.devOptForceClientComposition ||
                                              forceClientComposition,
                                      refreshArgs.internalDisplayRotationFlags);

        if (mLayerRequestingBackgroundBlur == layer) {
            forceClientComposition = false;
        }
    }

    updateCompositionStateForBorder(refreshArgs);
}
2.17 OutputLayer::updateCompositionState() - 更新 Layer 组合状态

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp

// OutputLayer.cpp:296
void OutputLayer::updateCompositionState(
        bool includeGeometry, bool forceClientComposition,
        ui::Transform::RotationFlags internalDisplayRotationFlags) {
    const auto* layerFEState = getLayerFE().getCompositionState();
    if (!layerFEState) {
        return;
    }

    const auto& outputState = getOutput().getState();
    const auto& profile = *getOutput().getDisplayColorProfile();
    auto& state = editState();

    if (includeGeometry) {
        // 清除强制客户端组合标志
        state.forceClientComposition = false;

        // ★★★ 计算输出相关几何状态 ★★★
        state.displayFrame = calculateOutputDisplayFrame();
        state.sourceCrop = calculateOutputSourceCrop(internalDisplayRotationFlags);
        state.bufferTransform = static_cast<Hwc2::Transform>(
                calculateOutputRelativeBufferTransform(internalDisplayRotationFlags));

        // 安全检查：安全 Layer 在非安全输出上需要客户端组合
        if ((layerFEState->isSecure && !outputState.isSecure) ||
            (state.bufferTransform & ui::Transform::ROT_INVALID)) {
            state.forceClientComposition = true;
        }
    }

    // 确定数据空间
    state.dataspace = layerFEState->isColorspaceAgnostic &&
                    outputState.targetDataspace != ui::Dataspace::UNKNOWN
            ? outputState.targetDataspace
            : layerFEState->dataspace;

    // 检查是否需要强制客户端组合
    if (layerFEState->forceClientComposition ||
        !profile.isDataspaceSupported(state.dataspace) ||
        forceClientComposition) {
        state.forceClientComposition = true;
    }
}

阶段 9: 写入状态到 HWC

2.18 Output::writeCompositionState() - 写入组合状态

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:830
void Output::writeCompositionState(const compositionengine::CompositionRefreshArgs& refreshArgs) {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);

    if (!getState().isEnabled) {
        return;
    }

    uint32_t z = 0;
    for (auto* layer : getOutputLayersOrderedByZ()) {
        layer->writeStateToHWC(refreshArgs.updatingGeometryThisFrame,
                               /* skipLayer */ false, z,
                               /* zIsOverridden */ false, /* isPeekingThrough */ false);
        z++;
    }
}
2.19 OutputLayer::writeStateToHWC() - 写入状态到 HWC

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp

// OutputLayer.cpp:380
void OutputLayer::writeStateToHWC(bool includeGeometry, bool skipLayer, uint32_t z,
                                  bool zIsOverridden, bool isPeekingThrough) {
    const auto& state = getState();

    // 如果没有 HWC 接口，直接返回
    if (!state.hwc) {
        return;
    }

    auto& hwcLayer = (*state.hwc).hwcLayer;
    if (!hwcLayer) {
        ALOGE("[%s] failed to write composition state to HWC -- no hwcLayer for output %s",
              getLayerFE().getDebugName(), getOutput().getName().c_str());
        return;
    }

    const auto* outputIndependentState = getLayerFE().getCompositionState();
    if (!outputIndependentState) {
        return;
    }

    auto requestedCompositionType = outputIndependentState->compositionType;

    // 处理覆盖缓冲区的情况
    if (requestedCompositionType == Composition::SOLID_COLOR && state.overrideInfo.buffer) {
        requestedCompositionType = Composition::DEVICE;
    }

    const bool isOverridden = state.overrideInfo.buffer != nullptr || isPeekingThrough || zIsOverridden;
    const bool prevOverridden = state.hwc->stateOverridden;

    // ★★★ 1. 写入几何状态 ★★★
    if (isOverridden || prevOverridden || skipLayer || includeGeometry) {
        writeOutputDependentGeometryStateToHWC(hwcLayer.get(), requestedCompositionType, z);
        writeOutputIndependentGeometryStateToHWC(hwcLayer.get(), *outputIndependentState, skipLayer);
    }

    // ★★★ 2. 写入每帧状态 ★★★
    writeOutputDependentPerFrameStateToHWC(hwcLayer.get());
    writeOutputIndependentPerFrameStateToHWC(hwcLayer.get(), *outputIndependentState,
                                             requestedCompositionType, skipLayer);

    // ★★★ 3. 写入组合类型 ★★★
    writeCompositionTypeToHWC(hwcLayer.get(), requestedCompositionType, isPeekingThrough,
                              skipLayer);

    // 处理纯色 Layer
    if (requestedCompositionType == Composition::SOLID_COLOR) {
        writeSolidColorStateToHWC(hwcLayer.get(), *outputIndependentState);
    }

    editState().hwc->stateOverridden = isOverridden;
    editState().hwc->layerSkipped = skipLayer;
}
2.20 writeOutputDependentGeometryStateToHWC() - 写入几何状态

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp

// OutputLayer.cpp:430
void OutputLayer::writeOutputDependentGeometryStateToHWC(HWC2::Layer* hwcLayer,
                                                         Composition requestedCompositionType,
                                                         uint32_t z) {
    const auto& outputDependentState = getState();

    Rect displayFrame = outputDependentState.displayFrame;
    FloatRect sourceCrop = outputDependentState.sourceCrop;

    // 处理覆盖缓冲区的情况
    if (outputDependentState.overrideInfo.buffer != nullptr) {
        displayFrame = outputDependentState.overrideInfo.displayFrame;
        sourceCrop = FloatRect(0.f, 0.f,
                          static_cast<float>(outputDependentState.overrideInfo.buffer->getBuffer()->getWidth()),
                          static_cast<float>(outputDependentState.overrideInfo.buffer->getBuffer()->getHeight()));
    }

    // ★ 设置显示帧
    if (auto error = hwcLayer->setDisplayFrame(displayFrame); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set display frame [%d, %d, %d, %d]: %s (%d)",
              getLayerFE().getDebugName(), displayFrame.left, displayFrame.top,
              displayFrame.right, displayFrame.bottom, to_string(error).c_str(),
              static_cast<int32_t>(error));
    }

    // ★ 设置源裁剪
    if (auto error = hwcLayer->setSourceCrop(sourceCrop); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set source crop [%.3f, %.3f, %.3f, %.3f]: %s (%d)",
              getLayerFE().getDebugName(), sourceCrop.left, sourceCrop.top,
              sourceCrop.right, sourceCrop.bottom, to_string(error).c_str(),
              static_cast<int32_t>(error));
    }

    // ★ 设置 Z 顺序
    if (auto error = hwcLayer->setZOrder(z); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set Z %u: %s (%d)", getLayerFE().getDebugName(), z,
              to_string(error).c_str(), static_cast<int32_t>(error));
    }

    // ★ 设置变换
    const auto bufferTransform = (requestedCompositionType != Composition::SOLID_COLOR &&
                                  getState().overrideInfo.buffer == nullptr)
            ? outputDependentState.bufferTransform
            : static_cast<hal::Transform>(0);
    if (auto error = hwcLayer->setTransform(static_cast<hal::Transform>(bufferTransform));
        error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set transform %s: %s (%d)", getLayerFE().getDebugName(),
              toString(outputDependentState.bufferTransform).c_str(),
              to_string(error).c_str(), static_cast<int32_t>(error));
    }
}
2.21 writeOutputIndependentGeometryStateToHWC() - 写入独立几何状态

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp

// OutputLayer.cpp:480
void OutputLayer::writeOutputIndependentGeometryStateToHWC(
        HWC2::Layer* hwcLayer, const LayerFECompositionState& outputIndependentState,
        bool skipLayer) {
    // 设置混合模式
    const auto& overrideInfo = getState().overrideInfo;
    const auto blendMode = overrideInfo.buffer || overrideInfo.peekThroughLayer
            ? hardware::graphics::composer::hal::BlendMode::PREMULTIPLIED
            : outputIndependentState.blendMode;
    if (auto error = hwcLayer->setBlendMode(blendMode); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set blend mode %s: %s (%d)", getLayerFE().getDebugName(),
              toString(blendMode).c_str(), to_string(error).c_str(), static_cast<int32_t>(error));
    }

    // 设置平面透明度
    const float alpha = skipLayer ? 0.0f
            : (getState().overrideInfo.buffer ? 1.0f : outputIndependentState.alpha);
    if (auto error = hwcLayer->setPlaneAlpha(alpha); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set plane alpha %.3f: %s (%d)", getLayerFE().getDebugName(), alpha,
              to_string(error).c_str(), static_cast<int32_t>(error));
    }

    // 设置通用元数据
    for (const auto& [name, entry] : outputIndependentState.metadata) {
        if (auto error = hwcLayer->setLayerGenericMetadata(name, entry.mandatory, entry.value);
            error != hal::Error::NONE) {
            ALOGE("[%s] Failed to set generic metadata %s %s (%d)", getLayerFE().getDebugName(),
                  name.c_str(), to_string(error).c_str(), static_cast<int32_t>(error));
        }
    }
}
2.22 writeOutputDependentPerFrameStateToHWC() - 写入每帧状态

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp

// OutputLayer.cpp:510
void OutputLayer::writeOutputDependentPerFrameStateToHWC(HWC2::Layer* hwcLayer) {
    const auto& outputDependentState = getState();

    // 设置可见区域
    Region visibleRegion = outputDependentState.overrideInfo.buffer
            ? Region(outputDependentState.overrideInfo.visibleRegion)
            : outputDependentState.outputSpaceVisibleRegion;
    if (auto error = hwcLayer->setVisibleRegion(visibleRegion); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set visible region: %s (%d)", getLayerFE().getDebugName(),
              to_string(error).c_str(), static_cast<int32_t>(error));
    }

    // 设置阻塞区域
    if (auto error = hwcLayer->setBlockingRegion(outputDependentState.outputSpaceBlockingRegionHint);
        error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set blocking region: %s (%d)", getLayerFE().getDebugName(),
              to_string(error).c_str(), static_cast<int32_t>(error));
    }

    // 设置数据空间
    const auto dataspace = outputDependentState.overrideInfo.buffer
            ? outputDependentState.overrideInfo.dataspace
            : outputDependentState.dataspace;
    if (auto error = hwcLayer->setDataspace(dataspace); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set dataspace %d: %s (%d)", getLayerFE().getDebugName(), dataspace,
              to_string(error).c_str(), static_cast<int32_t>(error));
    }

    // 设置亮度（调光比例）
    const auto dimmingRatio = outputDependentState.overrideInfo.buffer
            ? (getOutput().getState().displayBrightnessNits != 0.f
                       ? std::clamp(getOutput().getState().sdrWhitePointNits /
                                            getOutput().getState().displayBrightnessNits,
                                    0.f, 1.f)
                       : 1.f)
            : outputDependentState.dimmingRatio;
    if (auto error = hwcLayer->setBrightness(dimmingRatio); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set brightness %f: %s (%d)", getLayerFE().getDebugName(),
              dimmingRatio, to_string(error).c_str(), static_cast<int32_t>(error));
    }
}
2.23 writeOutputIndependentPerFrameStateToHWC() - 写入独立每帧状态

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp

// OutputLayer.cpp:550
void OutputLayer::writeOutputIndependentPerFrameStateToHWC(
        HWC2::Layer* hwcLayer, const LayerFECompositionState& outputIndependentState,
        Composition compositionType, bool skipLayer) {
    // 设置颜色变换
    switch (auto error = hwcLayer->setColorTransform(outputIndependentState.colorTransform)) {
        case hal::Error::NONE:
            break;
        case hal::Error::UNSUPPORTED:
            editState().forceClientComposition = true;
            break;
        default:
            ALOGE("[%s] Failed to set color transform: %s (%d)", getLayerFE().getDebugName(),
                  to_string(error).c_str(), static_cast<int32_t>(error));
    }

    // 设置表面损伤区域
    const Region& surfaceDamage = getState().overrideInfo.buffer
            ? getState().overrideInfo.damageRegion
            : (getState().hwc->stateOverridden ? Region::INVALID_REGION
                                               : outputIndependentState.surfaceDamage);
    if (auto error = hwcLayer->setSurfaceDamage(surfaceDamage); error != hal::Error::NONE) {
        ALOGE("[%s] Failed to set surface damage: %s (%d)", getLayerFE().getDebugName(),
              to_string(error).c_str(), static_cast<int32_t>(error));
    }

    // 根据组合类型写入特定状态
    switch (compositionType) {
        case Composition::SOLID_COLOR:
            break;
        case Composition::SIDEBAND:
            writeSidebandStateToHWC(hwcLayer, outputIndependentState);
            break;
        case Composition::CURSOR:
        case Composition::DEVICE:
        case Composition::DISPLAY_DECORATION:
        case Composition::REFRESH_RATE_INDICATOR:
            writeBufferStateToHWC(hwcLayer, outputIndependentState, skipLayer);
            break;
        case Composition::INVALID:
        case Composition::CLIENT:
            break;
    }
}

阶段 10: HWC HAL 调用

2.24 HWC2::impl::Layer - HAL 调用实现

文件路径: frameworks/native/services/surfaceflinger/DisplayHardware/HWC2.cpp

// HWC2.cpp - Layer 实现
namespace impl {

Layer::Layer(android::Hwc2::Composer& composer,
             const std::unordered_set<AidlCapability>& capabilities,
             HWC2::Display& display, HWLayerId layerId)
      : mComposer(composer), mCapabilities(capabilities),
        mDisplay(&display), mId(layerId) {
    ALOGV("Created layer %" PRIu64 " on display %" PRIu64, layerId, display.getId());
}

// 设置显示帧
Error Layer::setDisplayFrame(const android::Rect& frame) {
    auto intError = mComposer.setLayerDisplayFrame(mDisplay->getId(), mId, frame);
    return static_cast<Error>(intError);
}

// 设置源裁剪
Error Layer::setSourceCrop(const android::FloatRect& crop) {
    auto intError = mComposer.setLayerSourceCrop(mDisplay->getId(), mId, crop);
    return static_cast<Error>(intError);
}

// 设置 Z 顺序
Error Layer::setZOrder(uint32_t z) {
    auto intError = mComposer.setLayerZOrder(mDisplay->getId(), mId, z);
    return static_cast<Error>(intError);
}

// 设置变换
Error Layer::setTransform(Transform transform) {
    auto intError = mComposer.setLayerTransform(mDisplay->getId(), mId, transform);
    return static_cast<Error>(intError);
}

// 设置混合模式
Error Layer::setBlendMode(BlendMode mode) {
    auto intError = mComposer.setLayerBlendMode(mDisplay->getId(), mId, mode);
    return static_cast<Error>(intError);
}

// 设置平面透明度
Error Layer::setPlaneAlpha(float alpha) {
    auto intError = mComposer.setLayerPlaneAlpha(mDisplay->getId(), mId, alpha);
    return static_cast<Error>(intError);
}

// 设置可见区域
Error Layer::setVisibleRegion(const android::Region& region) {
    auto intError = mComposer.setLayerVisibleRegion(mDisplay->getId(), mId, region);
    return static_cast<Error>(intError);
}

// 设置数据空间
Error Layer::setDataspace(android::ui::Dataspace dataspace) {
    auto intError = mComposer.setLayerDataspace(mDisplay->getId(), mId, dataspace);
    return static_cast<Error>(intError);
}

// 设置缓冲区
Error Layer::setBuffer(uint32_t slot, const android::sp<android::GraphicBuffer>& buffer,
                       const android::sp<android::Fence>& acquireFence) {
    int32_t fenceFd = acquireFence->dup();
    auto intError = mComposer.setLayerBuffer(mDisplay->getId(), mId, slot, buffer, fenceFd);
    return static_cast<Error>(intError);
}

// 设置组合类型
Error Layer::setCompositionType(Composition type) {
    auto intError = mComposer.setLayerCompositionType(mDisplay->getId(), mId, type);
    return static_cast<Error>(intError);
}

} // namespace impl

阶段 11: 准备帧 (prepareFrame)

2.25 Output::prepareFrame() - 准备帧

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:1063
void Output::prepareFrame() {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);

    auto& outputState = editState();
    if (!outputState.isEnabled) {
        return;
    }

    std::optional<android::HWComposer::DeviceRequestedChanges> changes;
    bool success = chooseCompositionStrategy(&changes);
    resetCompositionStrategy();
    outputState.strategyPrediction = CompositionStrategyPredictionState::DISABLED;
    outputState.previousDeviceRequestedChanges = changes;
    outputState.previousDeviceRequestedSuccess = success;
    if (success) {
        applyCompositionStrategy(changes);
    }
    finishPrepareFrame();
}
2.26 Display::chooseCompositionStrategy() - 选择组合策略

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Display.cpp

// Display.cpp:226
bool Display::chooseCompositionStrategy(
        std::optional<android::HWComposer::DeviceRequestedChanges>* outChanges) {
    ATRACE_FORMAT("%s for %s", __func__, getNamePlusId().c_str());
    ALOGV(__FUNCTION__);

    if (mIsDisconnected) {
        return false;
    }

    const auto halDisplayId = HalDisplayId::tryCast(mId);
    if (!halDisplayId) {
        return false;
    }

    auto& hwc = getCompositionEngine().getHwComposer();
    const bool requiresClientComposition = anyLayersRequireClientComposition();

    // ★★★ 调用 HWC 获取设备组合变化 ★★★
    if (status_t result = hwc.getDeviceCompositionChanges(
                *halDisplayId, requiresClientComposition,
                getState().earliestPresentTime,
                getState().expectedPresentTime, outChanges);
        result != NO_ERROR) {
        ALOGE("chooseCompositionStrategy failed for %s: %d (%s)",
              getName().c_str(), result, strerror(-result));
        return false;
    }

    return true;
}
2.27 HWComposer::getDeviceCompositionChanges() - HWC 验证

文件路径: frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp

// HWComposer.cpp:418
status_t HWComposer::getDeviceCompositionChanges(
        HalDisplayId displayId, bool frameUsesClientComposition,
        std::optional<std::chrono::steady_clock::time_point> earliestPresentTime,
        nsecs_t expectedPresentTime,
        std::optional<android::HWComposer::DeviceRequestedChanges>* outChanges) {
    ATRACE_CALL();

    RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);

    auto& displayData = mDisplayData[displayId];
    auto& hwcDisplay = displayData.hwcDisplay;

    uint32_t numTypes = 0;
    uint32_t numRequests = 0;

    // 尝试跳过验证直接呈现
    const bool canSkipValidate = !frameUsesClientComposition && ...;

    if (canSkipValidate) {
        // 尝试 presentOrValidate
        error = hwcDisplay->presentOrValidate(expectedPresentTime, &numTypes, &numRequests,
                                              &outPresentFence, &state);
        if (state == 1) { // Present 成功
            displayData.validateWasSkipped = true;
            return NO_ERROR;
        }
    } else {
        // ★★★ 调用 validate ★★★
        error = hwcDisplay->validate(expectedPresentTime, &numTypes, &numRequests);
    }

    // 获取变化的组合类型
    android::HWComposer::DeviceRequestedChanges::ChangedTypes changedTypes;
    error = hwcDisplay->getChangedCompositionTypes(&changedTypes);

    // 获取请求
    auto displayRequests = static_cast<hal::DisplayRequest>(0);
    android::HWComposer::DeviceRequestedChanges::LayerRequests layerRequests;
    error = hwcDisplay->getRequests(&displayRequests, &layerRequests);

    // 接受变化
    error = hwcDisplay->acceptChanges();

    outChanges->emplace(DeviceRequestedChanges{std::move(changedTypes),
                                               std::move(displayRequests),
                                               std::move(layerRequests), ...});
    return NO_ERROR;
}

阶段 12: 完成帧 (finishFrame)

2.28 Output::finishFrame() - 完成帧

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:1135
void Output::finishFrame(GpuCompositionResult&& result) {
    ATRACE_CALL();
    ALOGV(__FUNCTION__);
    const auto& outputState = getState();
    if (!outputState.isEnabled) {
        return;
    }

    std::optional<base::unique_fd> optReadyFence;
    std::shared_ptr<renderengine::ExternalTexture> buffer;
    base::unique_fd bufferFence;

    if (outputState.strategyPrediction == CompositionStrategyPredictionState::SUCCESS) {
        optReadyFence = std::move(result.fence);
    } else {
        if (result.bufferAvailable()) {
            buffer = std::move(result.buffer);
            bufferFence = std::move(result.fence);
        } else {
            updateProtectedContentState();
            if (!dequeueRenderBuffer(&bufferFence, &buffer)) {
                return;
            }
        }

        // ★★★ GPU 合成 ★★★
        optReadyFence = composeSurfaces(Region::INVALID_REGION, buffer, bufferFence);
    }

    if (!optReadyFence) {
        return;
    }

    // 交换缓冲区（呈现）
    mRenderSurface->queueBuffer(std::move(*optReadyFence));
}

阶段 13: 提交帧缓冲 (postFramebuffer)

2.29 Output::postFramebuffer() - 提交帧缓冲

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp

// Output.cpp:1523
void Output::postFramebuffer() {
    ATRACE_FORMAT("%s for %s", __func__, mNamePlusId.c_str());
    ALOGV(__FUNCTION__);

    if (!getState().isEnabled) {
        return;
    }

    auto& outputState = editState();
    outputState.dirtyRegion.clear();

    // ★★★ 呈现并获取帧 Fence ★★★
    auto frame = presentAndGetFrameFences();

    mRenderSurface->onPresentDisplayCompleted();

    // 处理每个 OutputLayer 的释放 Fence
    for (auto* layer : getOutputLayersOrderedByZ()) {
        sp<Fence> releaseFence = Fence::NO_FENCE;

        if (auto hwcLayer = layer->getHwcLayer()) {
            if (auto f = frame.layerFences.find(hwcLayer); f != frame.layerFences.end()) {
                releaseFence = f->second;
            }
        }

        if (outputState.usesClientComposition) {
            releaseFence = Fence::merge("LayerRelease", releaseFence,
                                        frame.clientTargetAcquireFence);
        }
        layer->getLayerFE().onLayerDisplayed(
                ftl::yield<FenceResult>(std::move(releaseFence)).share(),
                outputState.layerFilter.layerStack);
    }
}
2.30 Display::presentAndGetFrameFences() - 呈现并获取 Fence

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/src/Display.cpp

// Display.cpp:351
compositionengine::Output::FrameFences Display::presentAndGetFrameFences() {
    auto fences = impl::Output::presentAndGetFrameFences();

    const auto halDisplayIdOpt = HalDisplayId::tryCast(mId);
    if (mIsDisconnected || !halDisplayIdOpt) {
        return fences;
    }

    auto& hwc = getCompositionEngine().getHwComposer();

    // ★★★ 调用 HWC present ★★★
    hwc.presentAndGetReleaseFences(*halDisplayIdOpt, getState().earliestPresentTime);

    fences.presentFence = hwc.getPresentFence(*halDisplayIdOpt);

    // 获取每个 Layer 的释放 Fence
    for (const auto* layer : getOutputLayersOrderedByZ()) {
        auto hwcLayer = layer->getHwcLayer();
        if (!hwcLayer) {
            continue;
        }
        fences.layerFences.emplace(hwcLayer, hwc.getLayerReleaseFence(*halDisplayIdOpt, hwcLayer));
    }

    hwc.clearReleaseFences(*halDisplayIdOpt);
    return fences;
}
2.31 HWComposer::presentAndGetReleaseFences() - HWC 呈现

文件路径: frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp

// HWComposer.cpp:510
status_t HWComposer::presentAndGetReleaseFences(
        HalDisplayId displayId,
        std::optional<std::chrono::steady_clock::time_point> earliestPresentTime) {
    ATRACE_CALL();

    RETURN_IF_INVALID_DISPLAY(displayId, BAD_INDEX);

    auto& displayData = mDisplayData[displayId];
    auto& hwcDisplay = displayData.hwcDisplay;

    if (displayData.validateWasSkipped) {
        // 执行命令
        auto error = static_cast<hal::Error>(mComposer->executeCommands(hwcDisplay->getId()));
        return NO_ERROR;
    }

    // 等待最早呈现时间
    if (earliestPresentTime) {
        ATRACE_NAME("wait for earliest present time");
        std::this_thread::sleep_until(*earliestPresentTime);
    }

    // ★★★ 调用 HWC present ★★★
    auto error = hwcDisplay->present(&displayData.lastPresentFence);
    RETURN_IF_HWC_ERROR_FOR("present", error, displayId, UNKNOWN_ERROR);

    // 获取释放 Fence
    std::unordered_map<HWC2::Layer*, sp<Fence>> releaseFences;
    error = hwcDisplay->getReleaseFences(&releaseFences);
    RETURN_IF_HWC_ERROR_FOR("getReleaseFences", error, displayId, UNKNOWN_ERROR);

    displayData.releaseFences = std::move(releaseFences);
    return NO_ERROR;
}

三、完整调用流程图

┌─────────────────────────────────────────────────────────────────────────────┐
│                          SurfaceFlinger 主线程                               │
│                                                                              │
│  SurfaceFlinger::composite()                                                 │
│  │                                                                           │
│  ├── 构建 CompositionRefreshArgs                                             │
│  │   ├── 收集 outputs (物理/虚拟显示器)                                      │
│  │   ├── 收集 layersWithQueuedFrames                                         │
│  │   └── 设置各种刷新参数                                                    │
│  │                                                                           │
│  └── mCompositionEngine->present(refreshArgs)                               │
│      │                                                                       │
│      ▼                                                                       │
└──────┼──────────────────────────────────────────────────────────────────────┘
       │
       ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                          CompositionEngine                                   │
│                                                                              │
│  CompositionEngine::present(refreshArgs)                                     │
│  │                                                                           │
│  ├── preComposition(args)                                                    │
│  │                                                                           │
│  ├── for each output:                                                        │
│  │   └── output->prepare(args, latchedLayers)                                │
│  │       │                                                                   │
│  │       ├── rebuildLayerStacks(refreshArgs, layerFESet)                    │
│  │       │   │                                                               │
│  │       │   └── collectVisibleLayers(refreshArgs, coverage)                │
│  │       │       │                                                           │
│  │       │       └── for each layer: ensureOutputLayerIfVisible(layer, cov) │
│  │       │           │                                                       │
│  │       │           ├── 计算可见区域/覆盖区域                               │
│  │       │           ├── prevIndex = findCurrentOutputLayerForLayer(layerFE) │
│  │       │           └── result = ensureOutputLayer(prevIndex, layerFE)      │
│  │       │               │                                                   │
│  │       │               └── Display::createOutputLayer(layerFE)             │
│  │       │                   │                                               │
│  │       │                   ├── impl::createOutputLayer(*this, layerFE)     │
│  │       │                   │   └── createOutputLayerTemplated<OutputLayer> │
│  │       │                   │       └── 创建 OutputLayer 实例               │
│  │       │                   │           ├── mOutput = output                │
│  │       │                   │           ├── mLayerFE = layerFE              │
│  │       │                   │           └── mState = OutputLayerCompositionState│
│  │       │                   │                                               │
│  │       │                   ├── hwc.createLayer(*halDisplayId)              │
│  │       │                   │   └── HWComposer::createLayer(displayId)      │
│  │       │                   │       └── HWC2::Display::createLayer()        │
│  │       │                   │           ├── mComposer.createLayer() → HAL   │
│  │       │                   │           └── 创建 HWC2::impl::Layer          │
│  │       │                   │                                               │
│  │       │                   └── outputLayer->setHwcLayer(std::move(hwcLayer))│
│  │       │                       └── state.hwc.emplace(std::move(hwcLayer))  │
│  │       │                                                                   │
│  │       └── uncacheBuffers(bufferIdsToUncache)                              │
│  │                                                                           │
│  └── for each output:                                                        │
│      └── output->present(refreshArgs)                                        │
│          │                                                                   │
│          ├── updateColorProfile(refreshArgs)                                 │
│          │                                                                   │
│          ├── updateCompositionState(refreshArgs)                             │
│          │   └── for each layer: layer->updateCompositionState(...)          │
│          │       ├── state.displayFrame = calculateOutputDisplayFrame()      │
│          │       ├── state.sourceCrop = calculateOutputSourceCrop()          │
│          │       └── state.bufferTransform = calculateOutputRelativeBufferTransform()│
│          │                                                                   │
│          ├── planComposition()                                               │
│          │                                                                   │
│          ├── writeCompositionState(refreshArgs)                              │
│          │   └── for each layer: layer->writeStateToHWC(...)                 │
│          │       ├── writeOutputDependentGeometryStateToHWC()                │
│          │       │   ├── hwcLayer->setDisplayFrame(displayFrame)             │
│          │       │   ├── hwcLayer->setSourceCrop(sourceCrop)                 │
│          │       │   ├── hwcLayer->setZOrder(z)                              │
│          │       │   └── hwcLayer->setTransform(bufferTransform)             │
│          │       ├── writeOutputIndependentGeometryStateToHWC()              │
│          │       │   ├── hwcLayer->setBlendMode(blendMode)                   │
│          │       │   └── hwcLayer->setPlaneAlpha(alpha)                      │
│          │       ├── writeOutputDependentPerFrameStateToHWC()                │
│          │       │   ├── hwcLayer->setVisibleRegion(visibleRegion)           │
│          │       │   ├── hwcLayer->setDataspace(dataspace)                   │
│          │       │   └── hwcLayer->setBrightness(dimmingRatio)               │
│          │       ├── writeOutputIndependentPerFrameStateToHWC()              │
│          │       │   ├── hwcLayer->setColorTransform(colorTransform)         │
│          │       │   ├── hwcLayer->setSurfaceDamage(surfaceDamage)           │
│          │       │   └── writeBufferStateToHWC()                             │
│          │       │       └── hwcLayer->setBuffer(slot, buffer, acquireFence) │
│          │       └── writeCompositionTypeToHWC()                             │
│          │           └── hwcLayer->setCompositionType(compositionType)       │
│          │                                                                   │
│          ├── setColorTransform(refreshArgs)                                  │
│          ├── beginFrame()                                                    │
│          │   └── RenderSurface::beginFrame()                                 │
│          │                                                                   │
│          ├── prepareFrame() / prepareFrameAsync()                            │
│          │   └── Display::chooseCompositionStrategy(&changes)                │
│          │       └── hwc.getDeviceCompositionChanges(...)                    │
│          │           ├── HWC2::Display::validate() → HAL                     │
│          │           ├── HWC2::Display::getChangedCompositionTypes()         │
│          │           ├── HWC2::Display::getRequests()                        │
│          │           └── HWC2::Display::acceptChanges()                      │
│          │                                                                   │
│          ├── finishFrame(result)                                             │
│          │   ├── dequeueRenderBuffer()                                       │
│          │   ├── composeSurfaces() (GPU 合成)                                │
│          │   │   └── RenderEngine::drawLayers()                              │
│          │   └── RenderSurface::queueBuffer(fence)                           │
│          │                                                                   │
│          └── postFramebuffer()                                               │
│              └── Display::presentAndGetFrameFences()                         │
│                  └── hwc.presentAndGetReleaseFences()                        │
│                      ├── HWC2::Display::present() → HAL                      │
│                      └── HWC2::Display::getReleaseFences()                   │
│                                                                              │
└──────────────────────────────────────────────────────────────────────────────┘

四、关键数据结构

4.1 OutputLayerCompositionState 结构

文件路径: frameworks/native/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayerCompositionState.h

struct OutputLayerCompositionState {
    // 可见区域
    Region visibleRegion;
    Region visibleNonTransparentRegion;
    Region coveredRegion;
    Region outputSpaceVisibleRegion;
    Region shadowRegion;
    Region outputSpaceBlockingRegionHint;
    std::optional<Region> coveredRegionExcludingDisplayOverlays;

    // 几何状态
    Rect displayFrame;           // 显示帧
    FloatRect sourceCrop;        // 源裁剪
    Hwc2::Transform bufferTransform;  // 缓冲区变换
    ui::Dataspace dataspace;     // 数据空间

    // 调光
    float dimmingRatio = 1.f;
    float whitePointNits = 0.f;

    // 强制客户端组合
    bool forceClientComposition = false;

    // 清除客户端目标
    bool clearClientTarget = false;

    // 覆盖信息
    struct OverrideInfo {
        std::shared_ptr<renderengine::ExternalTexture> buffer;
        Rect displayFrame;
        Rect visibleRegion;
        Region damageRegion;
        ui::Dataspace dataspace;
        uint64_t bufferId = 0;
        sp<LayerFE> peekThroughLayer;
    } overrideInfo;

    // HWC 状态
    struct Hwc {
        explicit Hwc(std::shared_ptr<HWC2::Layer> hwcLayer) : hwcLayer(hwcLayer) {}

        std::shared_ptr<HWC2::Layer> hwcLayer;  // HWC Layer 指针
        aidl::android::hardware::graphics::composer3::Composition hwcCompositionType;
        HwcBufferCache hwcBufferCache;
        bool stateOverridden = false;
        bool layerSkipped = false;
    };
    std::optional<Hwc> hwc;
};

4.2 Layer 到 OutputLayer 到 HWC Layer 映射

SurfaceFlinger LayerCompositionEngine OutputLayerHWC Layer
Layer::mLayerFEOutputLayer::mLayerFE-
Layer::StateLayerFECompositionState-
-OutputLayerCompositionState-
-OutputLayerCompositionState::Hwc::hwcLayerHWC2::Layer
--HWC2::impl::Layer::mId (HWLayerId)

4.3 状态传递链

Layer::State (应用层状态)
    │
    ├── LayerFECompositionState (前端组合状态)
    │       ├── geomLayerBounds
    │       ├── geomLayerTransform
    │       ├── buffer
    │       ├── acquireFence
    │       ├── dataspace
    │       └── compositionType
    │
    └── OutputLayerCompositionState (输出层组合状态)
            ├── displayFrame (计算后的显示帧)
            ├── sourceCrop (计算后的源裁剪)
            ├── bufferTransform
            ├── visibleRegion
            └── hwc::hwcLayer (HWC Layer 指针)
                    │
                    └── HWC2::impl::Layer
                            ├── mId (HWLayerId)
                            ├── setDisplayFrame()
                            ├── setSourceCrop()
                            ├── setBuffer()
                            └── setCompositionType()

五、关键文件路径汇总

组件文件路径
SurfaceFlingerframeworks/native/services/surfaceflinger/SurfaceFlinger.cpp
Layerframeworks/native/services/surfaceflinger/Layer.h
LayerFEframeworks/native/services/surfaceflinger/LayerFE.h
LayerFECompositionStateframeworks/native/services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFECompositionState.h
CompositionEngineframeworks/native/services/surfaceflinger/CompositionEngine/src/CompositionEngine.cpp
Outputframeworks/native/services/surfaceflinger/CompositionEngine/src/Output.cpp
Output (impl)frameworks/native/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/Output.h
Displayframeworks/native/services/surfaceflinger/CompositionEngine/src/Display.cpp
OutputLayerframeworks/native/services/surfaceflinger/CompositionEngine/include/compositionengine/OutputLayer.h
OutputLayer (impl)frameworks/native/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayer.h
OutputLayer (src)frameworks/native/services/surfaceflinger/CompositionEngine/src/OutputLayer.cpp
OutputLayerCompositionStateframeworks/native/services/surfaceflinger/CompositionEngine/include/compositionengine/impl/OutputLayerCompositionState.h
HWComposerframeworks/native/services/surfaceflinger/DisplayHardware/HWComposer.h
HWComposer (impl)frameworks/native/services/surfaceflinger/DisplayHardware/HWComposer.cpp
HWC2frameworks/native/services/surfaceflinger/DisplayHardware/HWC2.h
HWC2 (impl)frameworks/native/services/surfaceflinger/DisplayHardware/HWC2.cpp

六、总结

SurfaceFlinger 中 Layer 到 HWC 的完整流程可以概括为：

  1. SurfaceFlinger::composite(): 构建 CompositionRefreshArgs，收集所有需要显示的 Layer 和 Output，调用 CompositionEngine::present()。

  2. CompositionEngine::present(): 执行预组合处理，为每个 Output 调用 prepare()（重建 Layer 栈）和 present()（执行呈现）。

  3. Output::prepare() → rebuildLayerStacks(): 遍历所有 Layer，为每个可见 Layer 创建或复用 OutputLayer。对于物理显示器，同时创建对应的 HWC Layer。

  4. Display::createOutputLayer(): 创建 OutputLayer 并关联 HWC Layer。调用 impl::createOutputLayer() 创建 OutputLayer，调用 HWComposer::createLayer() 创建 HWC Layer，最后调用 setHwcLayer() 建立关联。

  5. Output::present() → updateCompositionState(): 计算每个 OutputLayer 的输出相关几何状态（displayFrame、sourceCrop、bufferTransform）。

  6. Output::present() → writeCompositionState(): 将 OutputLayer 的状态写入 HWC。调用 writeStateToHWC()，进一步调用各种 write*ToHWC() 函数，最终调用 HWC2::Layer 的方法。

  7. Output::present() → prepareFrame(): 调用 chooseCompositionStrategy()，通过 HWComposer::getDeviceCompositionChanges() 让 HWC 决定每个 Layer 的组合方式。

  8. Output::present() → finishFrame(): 对于需要 CLIENT 合成的 Layer，通过 RenderEngine 进行 GPU 合成。

  9. Output::present() → postFramebuffer(): 调用 Display::presentAndGetFrameFences()，最终调用 HWComposer::presentAndGetReleaseFences() 将帧呈现到显示器。

整个流程中，OutputLayer 是 Layer 和 HWC Layer 之间的桥梁，它持有 LayerFE 的引用和 HWC Layer 的指针，负责将 Layer 的状态转换为 HWC 可以理解的格式并传递给 HWC。

avatar
文章
阅读
粉丝