Android 16 显示系统 | 从View 到屏幕系列 - 9 | SurfaceFlinger 合成 (二)

狂浪天涯2025-08-08 9:55

SurfaceFlinger Composite

SurfaceFlinger 的 Composite 是什么时候被调用的呢？ 由 VSync 信号触发, 因为 SurfaceFlinger 注册了对 VSync 的监听，所以一旦 VSync 到来，会触发 Vsync 的回调，关于 VSync 部分，后面会有单独的一个章节描述，这里介绍回调的 flow

rust 复制代码 
MessageQueue::vsyncCallback
    --> MessageQueue::Handler::dispatchFrame
        --> MessageQueue::Handler::handleMessage
            --> Scheduler::onFrameSignal

在 onFrameSignal 中会调用 SurfaceFlinger 的 commit 和 composite

javascript 复制代码 
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 做准备。

scss 复制代码 
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

arduino 复制代码 
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;
    ...
};
  1. outputs 代表所有需要刷新的输出设备，如物理显示器，虚拟显示器，每一个 Output 代表一个显示目标。
  2. layers 是所有可能参加合成的所有图层
  3. layersWithQueuedFrames 是 layers 的子集，表示当前有新内容等待被显示的图层

2. moveSnapshotsToCompositionArgs

rust 复制代码 
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

ini 复制代码 
    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;
    }

LayerFE(Layer-Front-End),在进行合成的时候，不会直接操作 Layer 上的数据，而是使用 LayerFE，并且 Layer 也把自身的 Snapshot 交给了 LayerFE 的 Snapshot。此时，从 App 端传过来的数据流就变成了下面这样：

3. CompositionEngine Present

CompositionRefreshArgs 参数都准备好了之后，CompositionEngine 开始合成

scss 复制代码 
    mCompositionEngine->present(refreshArgs);

present的实现如下

scss 复制代码 
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);
}

1. 合成前数据准备

每一个显示设备执行 prepare

javascript 复制代码 
void Output::prepare(const compositionengine::CompositionRefreshArgs& refreshArgs,
                     LayerFESet& geomSnapshots) {
    ...
    // 构建需要参与合成的 Layer Stacks
    rebuildLayerStacks(refreshArgs, geomSnapshots);
    ...
}

prepare 的核心工作是 rebuildLayerStacks

ini 复制代码 
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

scss 复制代码 
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 可见区域计算
ini 复制代码 
    void Output::ensureOutputLayerIfVisible(sp<compositionengine::LayerFE>& layerFE,
                                            compositionengine::Output::CoverageState& coverage) {
      

        // 只获取需要显示在当前这块屏幕的 Layer
        // 比如有些 Layer 是需要展示到其他屏幕上(如虚拟屏)的，这里直接跳过
        if (!includesLayer(layerFE)) {
            return;
        }


        // 设置为不可见的直接跳过
        if (CC_UNLIKELY(!layerFEState->isVisible)) {
            return;
        }

        bool computeAboveCoveredExcludingOverlays = coverage.aboveCoveredLayersExcludingOverlays &&
                !layerFEState->outputFilter.toInternalDisplay;

        Region opaqueRegion;
        Region visibleRegion;
        Region coveredRegion;
        Region transparentRegion;
        Region shadowRegion;

        std::optional<Region> coveredRegionExcludingDisplayOverlays = std::nullopt;

        const ui::Transform& tr = layerFEState->geomLayerTransform;
        // 计算当前 Layer 的可见区域
        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);
        }

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

        // Remove the transparent area from the visible region
        if (!layerFEState->isOpaque) {
            if (tr.preserveRects()) {
                const Region clippedTransparentRegionHint =
                        layerFEState->transparentRegionHint.intersect(
                                Rect(layerFEState->geomLayerBounds));

                if (clippedTransparentRegionHint.isEmpty()) {
                    if (!layerFEState->transparentRegionHint.isEmpty()) {
                        ALOGD("Layer: %s had an out of bounds transparent region",
                              layerFE->getDebugName());
                        layerFEState->transparentRegionHint.dump("transparentRegionHint");
                    }
                    transparentRegion.clear();
                } else {
                    transparentRegion = tr.transform(clippedTransparentRegionHint);
                }
            } else {
                transparentRegion.clear();
            }
        }

        // compute the opaque region
        const auto layerOrientation = tr.getOrientation();
        if (layerFEState->isOpaque && ((layerOrientation & ui::Transform::ROT_INVALID) == 0)) {
            opaqueRegion.set(visibleRect);
        }

        // aboveCoveredLayers 代表已经遍历过的 layer 的集合
        // 计算当前 Layer 被前面的 layer 所遮挡的区域
        coveredRegion = coverage.aboveCoveredLayers.intersect(visibleRegion);
        // 加上当前的可见区域，那么对于下一个 layer 就是全部的遮挡区域了
        coverage.aboveCoveredLayers.orSelf(visibleRegion);

        // 剪去上层不透明区域
        visibleRegion.subtractSelf(coverage.aboveOpaqueLayers);
         
        // 无可视区域，直接跳过当前 Layer
        if (visibleRegion.isEmpty()) {
            return;
        }

        // 拿到 LayerFE 对应的 OutputLayer，用于后面的 "脏区"计算
        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;

        // 计算"脏区"
        Region dirty;
        if (layerFEState->contentDirty) {
        
            dirty = visibleRegion;
       
            dirty.orSelf(oldVisibleRegion);
        } else {
            const Region newExposed = visibleRegion - coveredRegion;
            const Region oldExposed = oldVisibleRegion - oldCoveredRegion;
            dirty = (visibleRegion & oldCoveredRegion) | (newExposed - oldExposed);
        }
        
        dirty.subtractSelf(coverage.aboveOpaqueLayers);

        // accumulate to the screen dirty region
        coverage.dirtyRegion.orSelf(dirty);

        // Update accumAboveOpaqueLayers for next (lower) layer
        coverage.aboveOpaqueLayers.orSelf(opaqueRegion);

        // Compute the visible non-transparent region
        Region visibleNonTransparentRegion = visibleRegion.subtract(transparentRegion);

        // Perform the final check to see if this layer is visible on this output
        const auto& outputState = getState();
        Region drawRegion(outputState.transform.transform(visibleNonTransparentRegion));
        drawRegion.andSelf(outputState.displaySpace.getBoundsAsRect());
        if (drawRegion.isEmpty()) {
            return;
        }

        Region visibleNonShadowRegion = visibleRegion.subtract(shadowRegion);
        

        // The layer is visible. Either reuse the existing outputLayer if we have
        // one, or create a new one if we do not.
        // 创建对应的 OutputLayer
        auto outputLayer = ensureOutputLayer(prevOutputLayerIndex, layerFE);

        // 把计算的结果保存到 OutputLayer 的 outputLayerState 中
        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);
        }
    }
  1. 上面的的计算逻辑是，计算当前 LayerFE 的可见区域，然后和上一次参与合成的 LayerFE 所对应的 OutputLayer 做对比，计算"脏区"，只有 "脏区" (内容发生变化的区域)才需要重新合成。
  2. 如果这个 LayerFE 是新添加的(比如 App 端新增加了一块 Surface)，那么会通过 ensureOutputLayer 创建了与 LayerFE 对应的 OutputLayer
arduino 复制代码 
        OutputLayer* ensureOutputLayer(std::optional<size_t> prevIndex,
                                       const sp<LayerFE>& layerFE) {
            // 首先判断是否已经存在，如不存在就创建新的
            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;
        }

继续看 OutputLayer 的创建过程

scss 复制代码 
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) {
        // 获取 hwc: 
        auto& hwc = getCompositionEngine().getHwComposer();
        // 2. 创建 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 的实现为

csharp 复制代码 
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 在指定的输出设备上合成状态的结构体，主要的数据结构如下：

arduino 复制代码 
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
c 复制代码 
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 方法

arduino 复制代码 
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 的实现如下

arduino 复制代码 
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

ruby 复制代码 
// 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 方法，

scss 复制代码 
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，这里解释一下

  1. Layer，接收 App 端发送过来的请求数据，比如最重要的 GraphicBuffer
  2. LayerFE, 用来参与可见区域的计算
  3. OutputLayer，最终参与合成的的图层
  4. 至于 HWC2::Layer，是用来和 HWComposer 传递数据的，如果只是 GPU 合成的话，使用不到这个 Layer 的。

关于各个 Layer 的数据流如下：

数据准备好之后，下面一小节讲 硬件&GPU 合成。

相关推荐
鹏多多.33 分钟前
flutter-使用AnimatedDefaultTextStyle实现文本动画
android·前端·css·flutter·ios·html5·web
似霰2 小时前
安卓系统属性之androidboot.xxx转换成ro.boot.xxx
android·gitee
0wioiw02 小时前
Android-Kotlin基础（Jetpack①-ViewModel）
android
用户2018792831673 小时前
限定参数范围的注解之 "咖啡店定价" 的故事
android·java
xzkyd outpaper3 小时前
Android中视图测量、布局、绘制过程
android
泓博3 小时前
Android底部导航栏图标变黑色
android
包达叔3 小时前
使用 Tauri 开发 Android 应用：环境搭建与入门指南
android
初学者-Study3 小时前
Android UI（一）登录注册
android·ui
视觉CG3 小时前
【JS】扁平树数据转为树结构
android·java·javascript
深盾安全4 小时前
Android 安全编程：Kotlin 如何从语言层保障安全性
android
热门推荐
01全球最强模型Grok4，国内已可免费使用！（附教程）02Qwen3-Coder 快速上手教程 | Qwen Code + Claude Code03UV安装并设置国内源04ChatGPT 5发布日期揭秘：2025年8月上线，多模态推理能力全面升级05OpenAI重返开源！GPT-OSS本地部署完全指南06KGG转MP3工具|非KGM文件|解密音频07如何在 Cursor 中继续使用 Claude08Cursor 终端“卡死/无响应”问题的解法09腾讯还是太全面了，限时免费！超全CodeBuddy IDE保姆级教程！（附案例）10Claude Code 效率实战指南：从入门到精通的实用技巧（附安装教程）