SurfaceFlinger Composite
SurfaceFlinger 的 Composite 是什么时候被调用的呢？
由 VSync 信号触发, 因为 SurfaceFlinger 注册了对 VSync 的监听，所以一旦 VSync 到来，会触发 Vsync 的回调，关于 VSync 部分，后面会有单独的一个章节描述，这里介绍回调的 flow
MessageQueue::vsyncCallback
--> MessageQueue::Handler::dispatchFrame
--> MessageQueue::Handler::handleMessage
--> Scheduler::onFrameSignal
在 onFrameSignal 中会调用 SurfaceFlinger 的 commit 和 composite
void Scheduler::onFrameSignal(ICompositor& compositor, VsyncId vsyncId,
TimePoint expectedVsyncTime) {
// 这里的 compositor 指的是 SurfaceFlinger
...
compositor.commit(pacesetterPtr->displayId, targets);
...
compositor.composite(pacesetterPtr->displayId, targeters);
...
}
SurfaceFlinger commit 前面已经分析过了，在juejin.cn/post/753499… ，commit 的作用是根据 App 端的 Transaction 请求(如 setbuffer)，对 Layer 进行相应的更新，为后续 Composite 做准备。
CompositeResultsPerDisplay SurfaceFlinger::composite(
PhysicalDisplayId pacesetterId, const scheduler::FrameTargeters& frameTargeters) {
// 1. 初始化 CompositionRefreshArgs
compositionengine::CompositionRefreshArgs refreshArgs;
refreshArgs.powerCallback = this;
// mDisplays 是 DisplayDevice 类型的容器
const auto& displays = FTL_FAKE_GUARD(mStateLock, mDisplays);
// refreshArgs.outputs 是 Output 类型的容器，一个 Output 代表一块屏幕
refreshArgs.outputs.reserve(displays.size());
ui::DisplayMap<PhysicalDisplayId, ui::LayerStack> physicalDisplayLayerStacks;
for (auto& [_, display] : displays) {
const auto id = asPhysicalDisplayId(display->getDisplayIdVariant());
if (id && frameTargeters.contains(*id)) {
physicalDisplayLayerStacks.try_emplace(*id, display->getLayerStack());
}
}
// Tracks layer stacks of displays that are added to CompositionEngine output.
ui::DisplayMap<ui::LayerStack, ftl::Unit> outputLayerStacks;
auto isUniqueOutputLayerStack = [&outputLayerStacks](DisplayId id, ui::LayerStack layerStack) {
if (FlagManager::getInstance().reject_dupe_layerstacks()) {
if (layerStack != ui::INVALID_LAYER_STACK && outputLayerStacks.contains(layerStack)) {
// TODO: remove log and DisplayId from params once reject_dupe_layerstacks flag is
// removed
ALOGD("Existing layer stack ID %d output to another display %" PRIu64
", dropping display from outputs",
layerStack.id, id.value);
return false;
}
}
outputLayerStacks.try_emplace(layerStack);
return true;
};
// Add outputs for physical displays.
for (const auto& [id, targeter] : frameTargeters) {
// 从 DisplayDevice 中获取 Composition::Display 成员变量
if (const auto display = getCompositionDisplayLocked(id)) {
const auto layerStack = physicalDisplayLayerStacks.get(id)->get();
if (isUniqueOutputLayerStack(display->getId(), layerStack)) {
// 把 Composition::Display 添加到 refreshArgs.outputs 数组中
refreshArgs.outputs.push_back(display);
}
}
refreshArgs.frameTargets.try_emplace(id, &targeter->target());
}
const auto presentTime = systemTime();
// 2. moveSnapshotsToCompositionArgs
const auto layers = moveSnapshotsToCompositionArgs(refreshArgs, kCursorOnly);
...
refreshArgs.refreshStartTime = systemTime(SYSTEM_TIME_MONOTONIC);
for (auto& [layer, layerFE] : layers) {
layer->onPreComposition(refreshArgs.refreshStartTime);
}
for (auto& [layer, layerFE] : layers) {
attachReleaseFenceFutureToLayer(layer, layerFE,
layerFE->mSnapshot->outputFilter.layerStack);
}
refreshArgs.layersWithQueuedFrames.reserve(mLayersWithQueuedFrames.size());
for (auto& [layer, _] : mLayersWithQueuedFrames) {
if (const auto& layerFE =
layer->getCompositionEngineLayerFE({static_cast<uint32_t>(layer->sequence)})) {
refreshArgs.layersWithQueuedFrames.push_back(layerFE);
...
}
}
//3. CompositionEngine 开始合成
mCompositionEngine->present(refreshArgs);
...
//4. 合成后处理，Buffer资源的释放
}
1. 初始化 CompositionRefreshArgs
CompositionRefreshArgs 是后续合成的主要参数，CompositionRefreshArgs 中比较重要的是
outputs 和 layersWithQueuedFrames
struct CompositionRefreshArgs {
// All the outputs being refreshed
Outputs outputs;
// All the layers that are potentially visible in the outputs. The order of
// the layers is important, and should be in traversal order from back to
// front.
Layers layers;
// All the layers that have queued updates.
Layers layersWithQueuedFrames;
...
};
outputs代表所有需要刷新的输出设备，如物理显示器，虚拟显示器，每一个 Output 代表一个显示目标。layers是所有可能参加合成的所有图层layersWithQueuedFrames是 layers 的子集，表示当前有新内容等待被显示的图层
2. moveSnapshotsToCompositionArgs
std::vector<std::pair<Layer*, LayerFE*>> SurfaceFlinger::moveSnapshotsToCompositionArgs(
compositionengine::CompositionRefreshArgs& refreshArgs, bool cursorOnly) {
std::vector<std::pair<Layer*, LayerFE*>> layers;
nsecs_t currentTime = systemTime();
// 遍历 mSnapshots 这个容器中的所有 LayerSnapshot
mLayerSnapshotBuilder.forEachSnapshot(
[&](std::unique_ptr<frontend::LayerSnapshot>& snapshot) FTL_FAKE_GUARD(
kMainThreadContext) {
...
auto it = mLegacyLayers.find(snapshot->sequence);
auto& legacyLayer = it->second;
// 1. 创建 LayerFE
sp<LayerFE> layerFE = legacyLayer->getCompositionEngineLayerFE(snapshot->path);
snapshot->fps = getLayerFramerate(currentTime, snapshot->sequence);
// 把 Layer 的 Snapshot 交给 LayerFE
layerFE->mSnapshot = std::move(snapshot);
refreshArgs.layers.push_back(layerFE);
layers.emplace_back(legacyLayer.get(), layerFE.get());
},
[needsMetadata](const frontend::LayerSnapshot& snapshot) {
return snapshot.isVisible ||
(needsMetadata &&
snapshot.changes.test(frontend::RequestedLayerState::Changes::Metadata));
});
return layers;
}
1. 创建 LayerFE (Layer-Front-End)
sp<LayerFE> Layer::getCompositionEngineLayerFE(
const frontend::LayerHierarchy::TraversalPath& path) {
for (auto& [p, layerFE] : mLayerFEs) {
if (p == path) {
return layerFE;
}
}
// 创建 LayerFE
auto layerFE = mFlinger->getFactory().createLayerFE(mName, this);
mLayerFEs.emplace_back(path, layerFE);
return layerFE;
}
在进行合成的时候，为了保护 Layer 上的数据不会被影响，不会直接操作 Layer 上的数据，而是使用 LayerFE，并且 Layer 也把自身的 Snapshot 交给了 LayerFE 的 Snapshot。此时，从 App 端传过来的数据流就变成了下面这样：
3. CompositionEngine Present
CompositionRefreshArgs 参数都准备好了之后，CompositionEngine 开始合成
mCompositionEngine->present(refreshArgs);
present的实现如下
void CompositionEngine::present(CompositionRefreshArgs& args) {
// 遍历每个 LayerFE 的 onPreComposition，记录合成开始时间
preComposition(args);
{
LayerFESet latchedLayers;
// 前面提到过，每一个 Output 代表一个显示设备
// 遍历每一个显示设备，如 主屏幕，虚拟屏(如果存在)
for (const auto& output : args.outputs) {
// 1. 合成前数据准备
output->prepare(args, latchedLayers);
}
}
offloadOutputs(args.outputs);
ui::DisplayVector<ftl::Future<std::monostate>> presentFutures;
for (const auto& output : args.outputs) {
// 2. 硬件 & GPU 合成
presentFutures.push_back(output->present(args));
}
{
for (auto& future : presentFutures) {
future.get();
}
}
postComposition(args);
}
1. 合成前数据准备
每一个显示设备执行 prepare
void Output::prepare(const compositionengine::CompositionRefreshArgs& refreshArgs,
LayerFESet& geomSnapshots) {
...
// 构建需要参与合成的 Layer Stacks
rebuildLayerStacks(refreshArgs, geomSnapshots);
...
}
prepare 的核心工作是 rebuildLayerStacks
void Output::rebuildLayerStacks(const compositionengine::CompositionRefreshArgs& refreshArgs,
LayerFESet& layerFESet) {
auto& outputState = editState();
...
// 1. 计算每个属于当前 Display 的所有 LayerFE 的可见区域和 “脏区”
collectVisibleLayers(refreshArgs, coverage);
// 2. 把所有的 Layer 的 Region 信息保存到 OutputState
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);
}
先看 collectVisibleLayers
void Output::collectVisibleLayers(const compositionengine::CompositionRefreshArgs& refreshArgs,
compositionengine::Output::CoverageState& coverage) {
// 遍历每一个 LayerFE
for (auto layer : reversed(refreshArgs.layers)) {
关注点1: 计算每个 LayerFE 的可见区域并创建 OutputLayer
ensureOutputLayerIfVisible(layer, coverage);
}
setReleasedLayers(refreshArgs);
// 把 mPendingOutputLayersOrderedByZ 里面所有的 OutputLayer 转移到 mCurrentOutputLayersOrderedByZ
finalizePendingOutputLayers();
}
1. LayerFE 可见区域计算
void Output::ensureOutputLayerIfVisible(sp<compositionengine::LayerFE>& layerFE,
compositionengine::Output::CoverageState& coverage) {
// 如果当前 LayerFE 不属于当前的显示设备，直接跳过，不需要参与计算
if (!includesLayer(layerFE)) {
return;
}
...
// 不透明区域
Region opaqueRegion;
// 可见区域
Region visibleRegion;
// 被覆盖的区域
Region coveredRegion;
// 透明区域
Region transparentRegion;
// 阴影区域
Region shadowRegion;
// 以 Layer 的边界大小初始化 Layer 的可见区域
const ui::Transform& tr = layerFEState->geomLayerTransform;
const Rect visibleRect(tr.transform(layerFEState->geomLayerBounds));
visibleRegion.set(visibleRect);
// 处理阴影
if (layerFEState->shadowSettings.length > 0.0f) {
const auto inset = static_cast<int32_t>(ceilf(layerFEState->shadowSettings.length) * -1.0f);
Rect visibleRectWithShadows(visibleRect);
visibleRectWithShadows.inset(inset, inset, inset, inset);
visibleRegion.set(visibleRectWithShadows);
shadowRegion = visibleRegion.subtract(visibleRect);
}
...
// Remove the transparent area from the visible region
if (!layerFEState->isOpaque) {
...
}
// compute the opaque region
const auto layerOrientation = tr.getOrientation();
if (layerFEState->isOpaque && ((layerOrientation & ui::Transform::ROT_INVALID) == 0)) {
opaqueRegion.set(visibleRect);
}
// Clip the covered region to the visible region
coveredRegion = coverage.aboveCoveredLayers.intersect(visibleRegion);
// Update accumAboveCoveredLayers for next (lower) layer
coverage.aboveCoveredLayers.orSelf(visibleRegion);
if (CC_UNLIKELY(computeAboveCoveredExcludingOverlays)) {
coveredRegionExcludingDisplayOverlays =
coverage.aboveCoveredLayersExcludingOverlays->intersect(visibleRegion);
coverage.aboveCoveredLayersExcludingOverlays->orSelf(visibleRegion);
}
// 当前 Layer 的可见区域要减去上层所有 Layer 的不透明区域
visibleRegion.subtractSelf(coverage.aboveOpaqueLayers);
// 如果计算下来，没有可见区域了，那么当前 Layer 就没有必要参与合成
if (visibleRegion.isEmpty()) {
return;
}
// 通过 LayerFE 获取上一次参与合成与之对应的 OutputLayer
// 如果是第一次参与合成, 那么上一次参与合成的 OutputLayer 为 null
auto prevOutputLayerIndex = findCurrentOutputLayerForLayer(layerFE);
auto prevOutputLayer =
prevOutputLayerIndex ? getOutputLayerOrderedByZByIndex(*prevOutputLayerIndex) : nullptr;
const Region kEmptyRegion;
const Region& oldVisibleRegion =
prevOutputLayer ? prevOutputLayer->getState().visibleRegion : kEmptyRegion;
const Region& oldCoveredRegion =
prevOutputLayer ? prevOutputLayer->getState().coveredRegion : kEmptyRegion;
// 开始计算 Layer 的 "脏区"
Region dirty;
// layerFEState->contentDirty 为 true 表示当前 Layer 的内容有更新
// 那么，当前的"脏区" = 本次的可见区域 + 上一次参与合成的可见区域
if (layerFEState->contentDirty) {
dirty = visibleRegion;
dirty.orSelf(oldVisibleRegion);
} else {
const Region newExposed = visibleRegion - coveredRegion;
const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
dirty = (visibleRegion & oldCoveredRegion) | (newExposed - oldExposed);
}
// 脏区需要减去上层 Layer 不透明的区域
dirty.subtractSelf(coverage.aboveOpaqueLayers);
// "脏区"累加， coverage.dirtyRegion 代表当前显示设备的所以有 “脏区”
coverage.dirtyRegion.orSelf(dirty);
// 不透明区域累加
coverage.aboveOpaqueLayers.orSelf(opaqueRegion);
Region visibleNonTransparentRegion = visibleRegion.subtract(transparentRegion);
const auto& outputState = getState();
Region drawRegion(outputState.transform.transform(visibleNonTransparentRegion));
drawRegion.andSelf(outputState.displaySpace.getBoundsAsRect());
if (drawRegion.isEmpty()) {
return;
}
Region visibleNonShadowRegion = visibleRegion.subtract(shadowRegion);
// 确保 OutputLayer 被创建
auto outputLayer = ensureOutputLayer(prevOutputLayerIndex, layerFE);
// 更新 OutputLayer 的 OutputLayerCompositionState 变量
auto& outputLayerState = outputLayer->editState();
outputLayerState.visibleRegion = visibleRegion;
outputLayerState.visibleNonTransparentRegion = visibleNonTransparentRegion;
outputLayerState.coveredRegion = coveredRegion;
outputLayerState.outputSpaceVisibleRegion = outputState.transform.transform(
visibleNonShadowRegion.intersect(outputState.layerStackSpace.getContent()));
outputLayerState.shadowRegion = shadowRegion;
outputLayerState.outputSpaceBlockingRegionHint =
layerFEState->compositionType == Composition::DISPLAY_DECORATION
? outputState.transform.transform(
transparentRegion.intersect(outputState.layerStackSpace.getContent()))
: Region();
if (CC_UNLIKELY(computeAboveCoveredExcludingOverlays)) {
outputLayerState.coveredRegionExcludingDisplayOverlays =
std::move(coveredRegionExcludingDisplayOverlays);
}
}
上面计算逻辑代码很长，但是拆分下来就是如下几点：
- 计算 LayerFE 的可见区域
- 计算 LayerFE 的 "脏区" (内容发生变化的区域), 只有 “脏区” 才需要重新合成
- 确保与 LayerFE 一一对应的
OutputLayer被创建，举个例子，如果这个LayerFE是新添加的(比如 App 端新增加了一块Surface)，那么会通过ensureOutputLayer创建与LayerFE对应的OutputLayer - 把计算结果保存到
OutputLayer的成员变量OutputLayerCompositionState中
这里为什么要创建 OutputLayer 呢？
我们先看 OutputLayer 的创建过程
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 这个容器中
mPendingOutputLayersOrderedByZ.emplace_back(std::move(outputLayer));
return result;
}
Display::createOutputLayer 的实现如下
std::unique_ptr<compositionengine::OutputLayer> Display::createOutputLayer(
const sp<compositionengine::LayerFE>& layerFE) const {
// 1. 创建 OutputLayer
auto outputLayer = impl::createOutputLayer(*this, layerFE);
if (const auto halDisplayId = getDisplayIdVariant().and_then(asHalDisplayId<DisplayIdVariant>);
outputLayer && !mIsDisconnected && halDisplayId) {
auto& hwc = getCompositionEngine().getHwComposer();
// 2. 创建 HWC2::Layer hwcLayer
auto hwcLayer = hwc.createLayer(*halDisplayId);
// 3. 把 hwcLayer 转移给 outputLayer
outputLayer->setHwcLayer(std::move(hwcLayer));
}
return outputLayer;
}
在这个过程中，分别创建了 OutputLayer 和 HWC2::Layer,并且 OutputLayer 会持有 HWC2::Layer, 具体来看
1. 创建 OutputLayer
impl::createOutputLayer 的实现为
std::unique_ptr<OutputLayer> createOutputLayer(const compositionengine::Output& output,
const sp<compositionengine::LayerFE>& layerFE) {
return createOutputLayerTemplated<OutputLayer>(output, layerFE);
}
std::unique_ptr<BaseOutputLayer> createOutputLayerTemplated(const Output& output,
sp<LayerFE> layerFE) {
class OutputLayer final : public BaseOutputLayer {
public:
...
OutputLayer(const Output& output, const sp<LayerFE>& layerFE)
: mOutput(output), mLayerFE(layerFE) {}
...
private:
...
const Output& mOutput;
const sp<LayerFE> mLayerFE;
OutputLayerCompositionState mState;
};
return std::make_unique<OutputLayer>(output, layerFE);
}
这里终于创建了 OutputLayer，OutputLayer 内部持有 Output，LayerFE 以及 OutputLayerCompositionState， OutputLayerCompositionState 用于描述 Layer 在指定的输出设备上合成状态的结构体，主要的数据结构如下：
struct OutputLayerCompositionState {
// 图层中没有被上层不透明层遮挡的区域
Region visibleRegion;
// The portion of the layer that is not obscured and is also opaque
Region visibleNonTransparentRegion;
// 被上层遮挡的其余
Region coveredRegion;
// The portion of the layer that is obscured by all layers on top excluding display overlays.
// This only has a value if there's something needing it, like when a
// TrustedPresentationListener is set.
std::optional<Region> coveredRegionExcludingDisplayOverlays;
// The visibleRegion transformed to output space
Region outputSpaceVisibleRegion;
// Region cast by the layer's shadow
Region shadowRegion;
// 是否强制使用 GPU 合成
bool forceClientComposition{false};
// If true, when doing client composition, the target may need to be cleared
bool clearClientTarget{false};
// The display frame for this layer on this output
Rect displayFrame;
// The source crop for this layer on this output
FloatRect sourceCrop;
// The buffer transform to use for this layer on this output.
Hwc2::Transform bufferTransform{static_cast<Hwc2::Transform>(0)};
// The dataspace for this layer
ui::Dataspace dataspace{ui::Dataspace::UNKNOWN};
// A hint to the HWC that this region is transparent and may be skipped in
// order to save power.
Region outputSpaceBlockingRegionHint;
// The picture profile for this layer.
PictureProfileHandle pictureProfileHandle;
// Overrides the buffer, acquire fence, and display frame stored in LayerFECompositionState
struct {
std::shared_ptr<renderengine::ExternalTexture> buffer = nullptr;
sp<Fence> acquireFence = nullptr;
Rect displayFrame = {};
ui::Dataspace dataspace{ui::Dataspace::UNKNOWN};
ProjectionSpace displaySpace;
Region damageRegion = Region::INVALID_REGION;
Region visibleRegion;
...
} overrideInfo;
// HWC2::Layer 相关
struct Hwc {
explicit Hwc(std::shared_ptr<HWC2::Layer> hwcLayer) : hwcLayer(hwcLayer) {}
// The HWC Layer backing this layer
std::shared_ptr<HWC2::Layer> hwcLayer;
// The most recently set HWC composition type for this layer
aidl::android::hardware::graphics::composer3::Composition hwcCompositionType{
aidl::android::hardware::graphics::composer3::Composition::INVALID};
// The buffer cache for this layer. This is used to lower the
// cost of sending reused buffers to the HWC.
HwcBufferCache hwcBufferCache;
// The previously-active buffer for this layer.
uint64_t activeBufferId;
uint32_t activeBufferSlot;
// Set to true when overridden info has been sent to HW composer
bool stateOverridden = false;
// True when this layer was skipped as part of SF-side layer caching.
bool layerSkipped = false;
// lut information
std::shared_ptr<gui::DisplayLuts> luts;
};
...
};
OutputLayer 创建完成之后，接着创建 HWC2::Layer
1. 创建 HWC2::Layer
std::shared\_ptr[HWC2::Layer](HWC2::Layer) HWComposer::createLayer(HalDisplayId displayId) {
...
auto expected = mDisplayData\[displayId].hwcDisplay->createLayer();
...
return std::move(expected).value();
}
通过 displayId 找到对应的 Display，然后调用 Dispaly 的 createLayer 方法
base::expected<std::shared_ptr<HWC2::Layer>, hal::Error> Display::createLayer() {
HWLayerId layerId = 0;
// mComposer 指的是 AidlComposer
// 返回一个 layerId
auto intError = mComposer.createLayer(mId, &layerId);
auto error = static_cast<Error>(intError);
if (error != Error::NONE) {
return base::unexpected(error);
}
// 基于返回的 LayerId 创建 Layer
auto layer = std::make_shared<impl::Layer>(mComposer, mCapabilities, *this, layerId);
mLayers.emplace(layerId, layer);
return layer;
}
mComposer.createLayer 的实现如下
Error AidlComposer::createLayer(Display display, Layer* outLayer) {
int64_t layer;
if (!mEnableLayerCommandBatchingFlag) {
// createLayer 是一个 Binder call
const auto status = mAidlComposerClient->createLayer(translate<int64_t>(display),
kMaxLayerBufferCount, &layer);
} else {
...
}
*outLayer = translate<Layer>(layer);
return error;
}
mAidlComposerClient->createLayer 的实现在 Binder Server, 在 Binder Server 会创建一个 Layer 并且返回这个索引(Layer) 给 Binder Client。然后基于返回的 Layer Id 创建了一个 HWC2::Layer
// frameworks/native/services/surfaceflinger/DisplayHardware/HWC2.cpp
Layer::Layer(android::Hwc2::Composer& composer,
const std::unordered_set<AidlCapability>& capabilities, HWC2::Display& display,
HWLayerId layerId)
// 内部持有 HWComposer
: mComposer(composer),
mCapabilities(capabilities),
mDisplay(&display),
mId(layerId),
mColorMatrix(android::mat4()) {
}
到此为止，OutputLayer 和 HWC2::Layer 就分别创建完成了，HWCLayer 持有 HWComposer,
并且通过 outputLayer->setHwcLayer(std::move(hwcLayer)) 把 HWC2::Layer 绑定到了当前的 OutputLayer。
回到 ensureOutputLayer 方法，OutputLayer 创建完成之后，都会被添加到 mPendingOutputLayersOrderedByZ 容器中。
再回到 collectVisibleLayers 方法，
void Output::collectVisibleLayers(const compositionengine::CompositionRefreshArgs& refreshArgs,
compositionengine::Output::CoverageState& coverage) {
// 遍历每一个 LayerFE
for (auto layer : reversed(refreshArgs.layers)) {
关注点1: 计算每个 LayerFE 的可见区域并创建 OutputLayer
ensureOutputLayerIfVisible(layer, coverage);
}
setReleasedLayers(refreshArgs);
// 把 mPendingOutputLayersOrderedByZ 里面所有的 OutputLayer 转移到 mCurrentOutputLayersOrderedByZ
finalizePendingOutputLayers();
}
OutputLayer 创建完成之后，通过 finalizePendingOutputLayers 把 mPendingOutputLayersOrderedByZ 转移到 mCurrentOutputLayersOrderedByZ，后续的合成用到的 OutputLayer 都来自于 mCurrentOutputLayersOrderedByZ。
到此，Composite 数据准备这一块，出现了很多 Layer，比如最原始的 Layer，接下来是 LayerFE，后面又是 OutputLayer, 最后是是 HWC2::Layer，这里解释一下
Layer，接收 App 端发送过来的请求数据，比如最重要的 GraphicBufferLayerFE, 用来参与可见区域的计算OutputLayer，最终参与合成的的图层- 至于
HWC2::Layer，是用来和HWComposer传递数据的，如果只是 GPU 合成的话，使用不到这个 Layer 的。
关于各个 Layer 的数据流如下：
回到 CompositionEngine::present 方法
void CompositionEngine::present(CompositionRefreshArgs& args) {
// 遍历每个 LayerFE 的 onPreComposition，记录合成开始时间
preComposition(args);
{
LayerFESet latchedLayers;
// 遍历每一个设备，如 主屏幕，虚拟屏(如果存在)
for (const auto& output : args.outputs) {
// 1. 合成前数据准备
output->prepare(args, latchedLayers);
}
}
offloadOutputs(args.outputs);
ui::DisplayVector<ftl::Future<std::monostate>> presentFutures;
for (const auto& output : args.outputs) {
// 2. 硬件 & GPU 合成
presentFutures.push_back(output->present(args));
}
{
for (auto& future : presentFutures) {
future.get();
}
}
postComposition(args);
}
到这里为止，整个 CompositionEngine::present 的三个核心方法: prepare 的实现就已经分析完了，下一小继续分析 present 和 后续的 postComposition。
