theme: channing-cyan

[Android禅修之路] 解读Layer

一前言

Layer（我看网上一些博客翻译为图元，所以后续我也用图元称呼）, 它是 SurfaceFlinger 中一个非常重要的角色。从 SurfaceFlinger 合成前的准备开始，就一直通过 Layer 的一些函数来完成一些操作SurfaceFlinger合成前的预处理。例如 rebuildLayerStacks 。

并且在合成中也是有频繁的调用，所以本文会详细的介绍一下图元和它内部的工作原理。

例如： cpp // 重建Layer集合,并计算每个Layer的可见区域的脏数据 rebuildLayerStacks();

二 Layer

2.1 Layer 的定义

首先看 Layer.h 头文件, 这个类非常长, 这里就简单看一下它的定义

```c class Layer; class Layer : public virtual compositionengine::LayerFE { ... void onFirstRef() override; }

class LayerFE : public virtual RefBase { } ```

Layer 继承自 LayerFE，而 LayerFE 则继承自 Android 的智能指针 RefBase，对于 RefBase，当系统第一次将它的弱指针转换为强指针的时候会调用 onFirstRef，不过我们看到 Layer 对这个函数是一个空实现，说明具体的工作，还是通过子类实现的。

2.2 Layer 的实现

关于 Layer 的代码实现, 这里先简单介绍一些比较重要的类。

2.2.1 State

首先要说的就是这个结构体 State，同名的 State 还有一个是 SurfaceFlinger.h 中定义的内部类，虽然都叫 State，但是它们还是不同的，这里我们看一下 Layer 中的 State

```c [/frameworks/native/services/surfaceflinger/Layer.h] struct State { Geometry active_legacy; Geometry requested_legacy; // z 坐标轴的值 int32_t z;

// 此图元所属的图元堆栈的标识符。一个图元只能关联到一个图元堆栈。
// 图元堆栈是一组按 z 轴排序的图元，可与一个或多个显示器关联。在不同的显示器上使用相同的 layerStack 是实现镜像的一种方法
uint32_t layerStack;

uint8_t flags;
uint8_t reserved[2];
// 该图元的序列号，每次图元的属性发生改变时，这个序列号都需要自增
int32_t sequence;
bool modified;

...

// 数据空间，仅 BufferStateLayer 和 ColorLayer 使用
ui::Dataspace dataspace;

// 此点下方的字段仅由 BufferStateLayer 使用
Geometry active;


std::list<std::shared_ptr<SyncPoint>> mLocalSyncPoints;
...

}; ```

关于 State，这里列举出来一些经常用到的，比如决定图元顺序的Z轴坐标，决定图元显示在哪个显示器的 layerStack 等等。

再看一下 Layer 中的两个 State 变量

mCurrentState：当前图元的 State
mDrawingState：上次绘制图元时的 State

这两个变量代表了图元的两个状态，一个是当前的状态，一个是上次绘制的状态，因为图元的状态是可以更改的，如果当前的状态和上次绘制的状态不一致，那么就说明状态发生了改变。

2.2.1 Layer 的构造函数

```cpp [/frameworks/native/services/surfaceflinger/Layer.h] Layer::Layer(const LayerCreationArgs& args) : mFlinger(args.flinger), mName(args.name), mClientRef(args.client), mWindowType(args.metadata.getInt32(METADATA_WINDOW_TYPE, 0)) { mCurrentCrop.makeInvalid();

uint32_t layerFlags = 0;
if (args.flags & ISurfaceComposerClient::eHidden) layerFlags |= layer_state_t::eLayerHidden;
if (args.flags & ISurfaceComposerClient::eOpaque) layerFlags |= layer_state_t::eLayerOpaque;
if (args.flags & ISurfaceComposerClient::eSecure) layerFlags |= layer_state_t::eLayerSecure;

mTransactionName = String8("TX - ") + mName;

// 给 mCurrentState 成员变量的赋值
mCurrentState.active_legacy.w = args.w;
mCurrentState.active_legacy.h = args.h;
mCurrentState.flags = layerFlags;

...

//将当前状态赋值给绘制状态
mDrawingState = mCurrentState;

CompositorTiming compositorTiming;
args.flinger->getCompositorTiming(&compositorTiming);
mFrameEventHistory.initializeCompositorTiming(compositorTiming);
mFrameTracker.setDisplayRefreshPeriod(compositorTiming.interval);

mSchedulerLayerHandle = mFlinger->mScheduler->registerLayer(mName.c_str(), mWindowType);
    // 然后回调 SurfaceFlinger 的 onLayerCreated
mFlinger->onLayerCreated();

} ```

Layer 的构造函数的参数是 LayerCreationArgs，这是一个封装好的结构体，它里面保存的是构造函数真正需要的参数。

在构造函数中，会做一些变量的初始化，然后给 mCurrentState 里的一些属性赋值，并将 mCurrentState 赋值给 mDrawingState，也就是说到目前位置，图元当前的状态就是绘制状态。之后如果再对图元进行修改，就会修改到 mCurrentState 中，这样两者就产生了差异，直到下次绘制，又让两者达到一致。

2.2.2 LayerCreationArgs

接下来再看一下 LayerCreationArgs 这个类, 看名字也知道它是图元创建时使用到的参数, 它将图元创建时需要的参数进行的封装

```c [/frameworks/native/services/surfaceflinger/Layer.h] struct LayerCreationArgs { LayerCreationArgs(SurfaceFlinger* flinger, const sp& client, const String8& name, uint32_t w, uint32_t h, uint32_t flags, LayerMetadata metadata) : flinger(flinger), client(client), name(name), w(w), h(h), flags(flags), metadata(std::move(metadata)) {}

SurfaceFlinger* flinger;
const sp<Client>& client;
const String8& name;
uint32_t w;
uint32_t h;
uint32_t flags;
LayerMetadata metadata;

}; ```

这里面的参数都比较简单，唯一一个需要注意的是这个 Client，它是定义在frameworks/native/services/surfaceflinger/Client.h，这个 Client 在 SurfaceFlinger 中代表应用端(App端)。

2.2.3 SyncPoint

SyncPoint 是定义在 Layer.h 头文件中的一个内部类，翻译过来就是同步点

```c class SyncPoint { public: explicit SyncPoint(uint64_t frameNumber, wp requestedSyncLayer) : mFrameNumber(frameNumber), mFrameIsAvailable(false), mTransactionIsApplied(false), mRequestedSyncLayer(requestedSyncLayer) {}

uint64_t getFrameNumber() const { return mFrameNumber; }

bool frameIsAvailable() const { return mFrameIsAvailable; }

void setFrameAvailable() { mFrameIsAvailable = true; }

bool transactionIsApplied() const { return mTransactionIsApplied; }

void setTransactionApplied() { mTransactionIsApplied = true; }

// wp 是 Android native 中的智能弱指针，sp 是Android native 中的智能强指针
// promote 其实就是将智能弱指针转换未智能强指针
sp<Layer> getRequestedSyncLayer() { return mRequestedSyncLayer.promote(); }

private: const uint64_t mFrameNumber; std::atomic mFrameIsAvailable; std::atomic mTransactionIsApplied; wp mRequestedSyncLayer; };

// 定义在 Layer.h 中的关于 SyncPoint 个对象 Mutex mLocalSyncPointMutex; //锁 // 一个 SyncPoint 的列表 std::list> mLocalSyncPoints;

// 应用事务时将发出信号然后移除的同步点 std::list> mRemoteSyncPoints; ```

同步点，当正确的帧位于队列的头部时将发出信号，并在帧被锁定后丢弃。受mLocalSyncPointMutex保护

2.3 LayerFE

接下来再看 LayerFE 的定义，

```c [frameworks/native/services/surfaceflinger/CompositionEngine/include/compositionengine/LayerFE.h]

class LayerFE : public virtual RefBase { public: // 更新与显示无关的合成状态。如果 includeGeometry 为 false ，则可以跳过 geometry 状态 virtual void latchCompositionState(LayerFECompositionState&, bool includeGeometry) const = 0; // 在 Layer 显示后调用以更新 Fence virtual void onLayerDisplayed(const sp&) = 0;

// debug name
virtual const char* getDebugName() const = 0;

}; ```

对于 LayerFE , 根据官方的说法, 它是一个接口，这个接口定义了 CompositionEngine 合成引擎向前端层发出请求的函数。

三合成前的Layer

接下来我们先按照之前 SurfaceFlinger 的合成流程，来看 Layer 的工作原理，首先是合成前 Layer 做了什么。具体的 SurfaceFlinger 的合成流程可以查看SurfaceFlinger的合成总览

3.1 notifyAvailableFrames

首先是 handleTransactionLocked 中的 notifyAvailableFrames，这个函数在 Layer.h 中是一个空实现，看来又是由它的子类处理的。但是根据我的查看，真正实现了这个函数的子类只有 BufferLayer。

c [frameworks/native/services/surfaceflinger/Layer.h] virtual void notifyAvailableFrames() {}

3.1.1 BufferLayer::notifyAvailableFrames

```cpp [/frameworks/native/services/surfaceflinger/BufferLayer.cpp] void BufferLayer::notifyAvailableFrames() { const auto headFrameNumber = getHeadFrameNumber(); const bool headFenceSignaled = fenceHasSignaled(); const bool presentTimeIsCurrent = framePresentTimeIsCurrent(); Mutex::Autolock lock(mLocalSyncPointMutex);

// 遍历 mLocalSyncPoints，这个是一个同步点的集合[2.2.3]
for (auto& point : mLocalSyncPoints) {

    // 如果头部帧的序号大于同步点中帧的序号，并且头部帧已经发送过Fence信号
    // Fence 信号是用于软硬件间同步的
    if (headFrameNumber >= point->getFrameNumber() && headFenceSignaled &&
        presentTimeIsCurrent) {
        // 通知同步点，将同步点中的 mFrameIsAvailable 设置为 true，见 [2.2.3]
        point->setFrameAvailable();
        // 从同步点获取需要同步的图元，并更新它的事务标志
        sp<Layer> requestedSyncLayer = point->getRequestedSyncLayer();
        if (requestedSyncLayer) {
            // 更新事务标志以确保应用层的挂起事务，实现在 Layer.cpp 中
            requestedSyncLayer->setTransactionFlags(eTransactionNeeded);
        }
    }
}

}

```

3.2 getTransactionFlags

接下来是 handleTransactionLocked 中的 getTransactionFlags，它直接返回了 Layer 中的 mTransactionFlags 。忘记 handleTransactionLocked 可以看SurfaceFlinger合成前的预处理。

c [frameworks/native/services/surfaceflinger/Layer.h] uint32_t getTransactionFlags() const { return mTransactionFlags; }

3.3 doTransaction

doTransaction 就是处理事务，Layer 会依据当前的图元哪些属性发生了改变，来决定具体应该怎么做，在介绍之前Layer 中 State 结构体的时候，看到了一个成员变量 sequence，这个序列号就是用来记录图元属性发生改变的。

```c [frameworks/native/services/surfaceflinger/Layer.cpp] uint32_t Layer::doTransaction(uint32_t flags) {

... // 前面会进行一些属性判断
    State c = getCurrentState();

// doTransactionResize 判断当前图元的 size 是否发生了改变
flags = doTransactionResize(flags, &c);

// 获取绘制时的状态
const State& s(getDrawingState());

// 如果当前的的状态和绘制时的状态的活动区域不相同，那么就需要重新计算可见区域
if (getActiveGeometry(c) != getActiveGeometry(s)) {
    // 需要重新计算可见区域，如果活动区域 active_legacy 不一致，则需要重新计算可见区域
    flags |= Layer::eVisibleRegion;
}

// 如果当前状态的序列号和绘制时的序列号不一致，那么当前的图元属性肯定发生了变化
if (c.sequence != s.sequence) {
    // 重新计算可见区域
    flags |= eVisibleRegion;
    // 内容脏了，即当前图元存在脏区域，需要重新合成绘制等操作
    this->contentDirty = true;

    ...
}

...

// 提交事务
commitTransaction(c);
mCurrentState.callbackHandles = {};
return flags;

} ```

doTransaction 这个函数的逻辑很简单

先判断活动区域是否发生了变化
再判断图元的属性是否发生了变化
最后提交事务

3.3.1 commitTransaction

再来看一下提交事务的逻辑，原来就是将当前的图元的状态赋值给绘制图元的状态，这样状态就同步了，然后等到下一轮状态发生改变时，再重复之前的动作即可。

c void Layer::commitTransaction(const State& stateToCommit) { mDrawingState = stateToCommit; }

关于序列号 sequence 的改变，这里就不再扩展了，简单来说，就是当调用图元 Layer 的 set 之类的方法时，sequence 就会自增。

最后关于 doTransaction 需要说一点的是，它的函数传入的是一个 int 值 flag，返回的也是一个 int 值，当前这个值在之前判断图元属性时已经发生了改变，而它的返回值也决定了后续 SurfaceFlinger 合成的一些操作。这里可以回顾一下SurfaceFlinger合成前的预处理

四 Layer 的子类

Layer 表示的是 Android 系统中的图元, 那么对于 Layer 的子类, 则是具体的图元操作的封装。Layer 的子类主要有三个

ColorLayer
BufferLayer
BufferStateLayer

3.1 ColorLayer

ColorLayer 即颜色图元, 它算是 Layer 的几个子类中最简单的一个子类了, 不过麻雀虽小, 五脏俱全. 通过查看 ColorLayer , 我们基本能够看到图元的一些基础操作

3.1.1 ColorLayer 的定义

首先还是先看 ColorLayer.h 头文件

```c [frameworks/native/services/surfaceflinger/ColorLayer.h] class ColorLayer : public Layer { public: // 构造函数和析构函数 explicit ColorLayer(const LayerCreationArgs&); ~ColorLayer() override;

// 
std::shared_ptr<compositionengine::Layer> getCompositionLayer() const override;

// Layer 的类型: ColorLayer
virtual const char* getTypeId() const { return "ColorLayer"; }
// 可见状态
bool isVisible() const override;

// 颜色
bool setColor(const half3& color) override;
// 数据空间
bool setDataspace(ui::Dataspace dataspace) override;
// 将帧数据设置到 HWComposer 中
void setPerFrameData(const sp<const DisplayDevice>& display, const ui::Transform& transform,
                     const Rect& viewport, int32_t supportedPerFrameMetadata,
                     const ui::Dataspace targetDataspace) override;

// 提交操作
void commitTransaction(const State& stateToCommit) override;

// 合成前的预处理
// 在 ColorLayer 中直接返回了 fasle , 没有做任何逻辑, 因为 ColorLayer 没有合成前预处理
bool onPreComposition(nsecs_t /*refreshStartTime*/) override { return false; }

protected:

virtual bool prepareClientLayer(const RenderArea& renderArea, const Region& clip,
                                bool useIdentityTransform, Region& clearRegion,
                                const bool supportProtectedContent,
                                renderengine::LayerSettings& layer);

private:

std::shared_ptr<compositionengine::Layer> mCompositionLayer;

};

```

3.1.2 ColorLayer 的实现

3.1.2.1 构造函数

cpp ColorLayer::ColorLayer(const LayerCreationArgs& args) : Layer(args), mCompositionLayer{mFlinger->getCompositionEngine().createLayer( compositionengine::LayerCreationArgs{this})} {}

ColorLayer 中构造时, 调用了父类 Layer 的构造函数, 然后还创建了一个 mCompositionLayer 对象

3.1.2.2 commitTransaction

最后再来看一下 commitTransaction 的，它其实调用的也是 Layer 的 commitTransaction (见3.3.1)。

cpp void ColorLayer::commitTransaction(const State& stateToCommit) { Layer::commitTransaction(stateToCommit); mCurrentDataSpace = mDrawingState.dataspace; }

3.1.2.3 prepareClientLayer

再来说说 prepareClientLayer 这个函数，它会在 SurfaceFlinger 的合成中调用，详情可以查看 SurfaceFlinger合成中的工作中的 3.2 doComposeSurfaces 的第二部分。

cpp bool ColorLayer::prepareClientLayer(const RenderArea& renderArea, const Region& clip, bool useIdentityTransform, Region& clearRegion, const bool supportProtectedContent, renderengine::LayerSettings& layer) { Layer::prepareClientLayer(renderArea, clip, useIdentityTransform, clearRegion, supportProtectedContent, layer); half4 color(getColor()); half3 solidColor(color.r, color.g, color.b); layer.source.solidColor = solidColor; return true; }

3.1.2.3 setPerFrameData

setPerFrameData 的作用是为每一层图元设置需要显示的数据。所以它做的大致是如下几件事情 1. 设置可见区域 2. 设置输出图元 3. 设置图元的合成方式为颜色图元 4. 设置数据空间 5. 设置数据（即颜色）

```cpp

void ColorLayer::setPerFrameData(const sp& display, const ui::Transform& transform, const Rect& viewport, int32_t / supportedPerFrameMetadata /, const ui::Dataspace targetDataspace) {

// 处理可见区域
Region visible = transform.transform(visibleRegion.intersect(viewport));
// 找到需要输出的显示图元
const auto outputLayer = findOutputLayerForDisplay(display);

// hwcLayer
auto& hwcLayer = (*outputLayer->getState().hwc).hwcLayer;

//
auto error = hwcLayer->setVisibleRegion(visible);
if (error != HWC2::Error::None) {
    visible.dump(LOG_TAG);
}
outputLayer->editState().visibleRegion = visible;

// 设置合成方式为颜色图元
setCompositionType(display, Hwc2::IComposerClient::Composition::SOLID_COLOR);

const ui::Dataspace dataspace =
        isColorSpaceAgnostic() && targetDataspace != ui::Dataspace::UNKNOWN ? targetDataspace

// 设置数据空间
error = hwcLayer->setDataspace(dataspace);

auto& layerCompositionState = getCompositionLayer()->editState().frontEnd;
layerCompositionState.dataspace = mCurrentDataSpace;

half4 color = getColor();
error = hwcLayer->setColor({static_cast<uint8_t>(std::round(255.0f * color.r)),
                            static_cast<uint8_t>(std::round(255.0f * color.g)),
                            static_cast<uint8_t>(std::round(255.0f * color.b)), 255});

layerCompositionState.color = {static_cast<uint8_t>(std::round(255.0f * color.r)),
                               static_cast<uint8_t>(std::round(255.0f * color.g)),
                               static_cast<uint8_t>(std::round(255.0f * color.b)), 255};

// Clear out the transform, because it doesn't make sense absent a source buffer
error = hwcLayer->setTransform(HWC2::Transform::None);

outputLayer->editState().bufferTransform = static_cast<Hwc2::Transform>(0);

error = hwcLayer->setColorTransform(getColorTransform());

layerCompositionState.colorTransform = getColorTransform();

error = hwcLayer->setSurfaceDamage(surfaceDamageRegion);

layerCompositionState.surfaceDamage = surfaceDamageRegion;

} ```

3.2 BufferLayer

3.2.1 BufferLayer 的定义

相比于 ColorLayer , BufferLayer 中包含的函数多了许多, 这也是因为 BufferLayer 的处理比简单颜色图元的处理要复杂许多, 不过后续我们需要关注的, 还是从父类中继承来的那些公共的函数

```c class BufferLayer : public Layer { public: explicit BufferLayer(const LayerCreationArgs& args); ~BufferLayer() override;

public: std::shared_ptr getCompositionLayer() const override;

// 如果我们在这个帧中收到一个新的缓冲区，我们将把它的表脏区域传递给 hardware composer (后续简称hwc)
// 否则，我们必须发送一个包含一个空 rect 的区域
void useSurfaceDamage() override;
void useEmptyDamage() override;

// 图元的类型: BufferLayer
const char* getTypeId() const override { return "BufferLayer"; }

// 是否是不透明的
bool isOpaque(const Layer::State& s) const override;

// 是否可见
bool isVisible() const override;

// isProtected - true if the layer may contain protected content in the
// GRALLOC_USAGE_PROTECTED sense.
// 是否包含受保护的内容(在 GRALLOC_USAGE_PROTECTED 区域), true 表示包含
bool isProtected() const override;

// 内容是否是固定大小, true 表示是的
bool isFixedSize() const override;

bool usesSourceCrop() const override;

bool isHdrY410() const override;

// 设置帧数据
void setPerFrameData(const sp<const DisplayDevice>& display, const ui::Transform& transform,
                     const Rect& viewport, int32_t supportedPerFrameMetadata,
                     const ui::Dataspace targetDataspace) override;

// 合成前预处理
bool onPreComposition(nsecs_t refreshStartTime) override;

// 合成后的处理
bool onPostComposition(const std::optional<DisplayId>& displayId,
                       const std::shared_ptr<FenceTime>& glDoneFence,
                       const std::shared_ptr<FenceTime>& presentFence,
                       const CompositorTiming& compositorTiming) override;


// latchBuffer-每次重新绘制屏幕时调用，并返回是否需要重新计算可见区域。
// 这是一个相当重的操作，所以只在需要时才设置）。
// 通常，这用于确定 Surface 的内容或大小是否已更改
bool latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime) override;

bool isBufferLatched() const override { return mRefreshPending; }

void notifyAvailableFrames() override;

bool hasReadyFrame() const override;

// 返回当前缩放模式, 如果设置了mOverrideScalingMode 则返回 mOverrideScalingMode
uint32_t getEffectiveScalingMode() const override;


// -----------------------------------------------------------------------
// 必须由派生类实现的函数
// -----------------------------------------------------------------------
...

} ```

3.2.2 BufferLayer 的实现

3.2.2.1 prepareClientLayer

同样，我们也看下 BufferLayer 的 prepareClientLayer 是如何实现的。它和 ColorLayer 一样，会在 SurfaceFlinger 的合成中调用，详情可以查看 SurfaceFlinger合成中的工作中的 3.2 doComposeSurfaces 的第二部分。

```cpp bool BufferLayer::prepareClientLayer(const RenderArea& renderArea, const Region& clip, bool useIdentityTransform, Region& clearRegion, const bool supportProtectedContent, renderengine::LayerSettings& layer) {

Layer::prepareClientLayer(renderArea, clip, useIdentityTransform, clearRegion,
                          supportProtectedContent, layer);
if (CC_UNLIKELY(mActiveBuffer == 0)) {
    //纹理还没有被创建，这个图元实际上从来没有被绘制。这在SurfaceView中经常发生，因为WindowManager不知道客户端什么时候第一次绘制
    // 如下下层没有任何东西, 就把屏幕绘制成黑色, 否则就跳过这个更新

    // 遍历底层
    Region under;
    bool finished = false;
    mFlinger->mDrawingState.traverseInZOrder([&](Layer* layer) {
        if (finished || layer == static_cast<BufferLayer const*>(this)) {
            finished = true;
            return;
        }
        under.orSelf(layer->visibleRegion);
    });
    // 如果没有Layer在这个图元的底部, 就忽略这个图元的空隙
    Region holes(clip.subtract(under));
    if (!holes.isEmpty()) {
        clearRegion.orSelf(holes);
    }
    return false;
}

// DRM处理, 如果图元是安全内存就直接绘制一块黑色. 主要是针对数字版权
bool blackOutLayer =
        (isProtected() && !supportProtectedContent) || (isSecure() && !renderArea.isSecure());
const State& s(getDrawingState());
if (!blackOutLayer) {
    layer.source.buffer.buffer = mActiveBuffer;
    layer.source.buffer.isOpaque = isOpaque(s);
    layer.source.buffer.fence = mActiveBufferFence;
    layer.source.buffer.textureName = mTextureName;
    layer.source.buffer.usePremultipliedAlpha = getPremultipledAlpha();
    layer.source.buffer.isY410BT2020 = isHdrY410();
    // TODO: we could be more subtle with isFixedSize()
    const bool useFiltering = needsFiltering(renderArea.getDisplayDevice()) ||
            renderArea.needsFiltering() || isFixedSize();

    // 查询我们当前过滤模式下的纹理矩阵
    float textureMatrix[16];
    setFilteringEnabled(useFiltering);
    getDrawingTransformMatrix(textureMatrix);

    // 显示器的横竖屏切换, 保证缓冲区和本机的显示方向一致
    if (getTransformToDisplayInverse()) {
        // 下面的代码将主显示的反变换应用到纹理变换
        uint32_t transform = DisplayDevice::getPrimaryDisplayOrientationTransform();
        mat4 tr = inverseOrientation(transform);

        // 确保无论父转换如何，这个缓冲区总是从本机显示方向转换为显示方向。
        // 例如，在一个相机的情况下，缓冲区保持在本机方向，我们希望像素总是垂直的
        sp<Layer> p = mDrawingParent.promote();
        if (p != nullptr) {
            const auto parentTransform = p->getTransform();
            tr = tr * inverseOrientation(parentTransform.getOrientation());
        }

        // 最后将变换应用到原始纹理矩阵中
        const mat4 texTransform(mat4(static_cast<const float*>(textureMatrix)) * tr);
        memcpy(textureMatrix, texTransform.asArray(), sizeof(textureMatrix));
    }

    const Rect win{getBounds()};
    float bufferWidth = getBufferSize(s).getWidth();
    float bufferHeight = getBufferSize(s).getHeight();

    // 如果缓冲区没有设置帧, 就设置一个尺寸为[0,0,-1,-1], 并忽略这个缓冲区
    if (!getBufferSize(s).isValid()) {
        bufferWidth = float(win.right) - float(win.left);
        bufferHeight = float(win.bottom) - float(win.top);
    }

    const float scaleHeight = (float(win.bottom) - float(win.top)) / bufferHeight;
    const float scaleWidth = (float(win.right) - float(win.left)) / bufferWidth;
    const float translateY = float(win.top) / bufferHeight;
    const float translateX = float(win.left) / bufferWidth;

    //因为GLConsumer和OpenGL的约定, 翻转y坐标，
    mat4 tr = mat4::translate(vec4(.5, .5, 0, 1)) * mat4::scale(vec4(1, -1, 1, 1)) *
            mat4::translate(vec4(-.5, -.5, 0, 1)) *
            mat4::translate(vec4(translateX, translateY, 0, 1)) *
            mat4::scale(vec4(scaleWidth, scaleHeight, 1.0, 1.0));

    layer.source.buffer.useTextureFiltering = useFiltering;
    layer.source.buffer.textureTransform = mat4(static_cast<const float*>(textureMatrix)) * tr;
} else {
    // 如果图元被涂黑，强制alpha值为1，这样我们就可以画一个黑色图元
    layer.source.buffer.buffer = nullptr;
    layer.alpha = 1.0;
}

return true;

} ```

3.2.2.1 onPreComposition

在 ColorLayer 中, 合成前的预处理没有任何工作. 但是对于 BufferLayer , 则会预先做一些事情，onPreComposition 是合成前的预处理工作，它会在SurfaceFlinger的合成前调用，具体的位置可以查看SurfaceFlinger合成前的预处理中的二 preComposition。

cpp bool BufferLayer::onPreComposition(nsecs_t refreshStartTime) { if (mBufferLatched) { Mutex::Autolock lock(mFrameEventHistoryMutex); // 将当前的帧数添加到 mFrameEventHistory mFrameEventHistory.addPreComposition(mCurrentFrameNumber, refreshStartTime); } mRefreshPending = false; // 判断当前是否还有已经准备好的帧需要处理 return hasReadyFrame(); }

hasReadyFrame

cpp bool BufferLayer::hasReadyFrame() const { // 在这三种情况下是需要继续处理的 // 1. hasFrameUpdate 为 true , 即当前状态发生了改变, 并且还有提交来的 buffer // 2. SidebandStream 发生了改变 // 3. 当前是自动刷新模式 return hasFrameUpdate() || getSidebandStreamChanged() || getAutoRefresh(); }

3.2.2.2 setPerFrameData

cpp compositionengine::OutputLayer* Layer::findOutputLayerForDisplay( const sp<const DisplayDevice>& display) const { // DisplayDevice 的 getCompositionDisplay 获取到它的成员变量 mCompositionDisplay // const std::shared_ptr<compositionengine::Display> mCompositionDisplay; // getOutputLayerForLayer 拿到的是一个 return display->getCompositionDisplay()->getOutputLayerForLayer(getCompositionLayer().get()); }

到此，关于 Layer 的介绍已经算是完成了一半了。

为什么我要说是一半呢？因为现在还只是粗略的介绍了 Layer 合成的相关操作，而它是怎么来的，整体上的流程是怎样的还没有说明，下面，我就通过 Activity 开始，结合此篇 Layer 具体的函数，来详细说明 Layer 的界面显示中的作用。

[Android禅修之路] 解读Layer

theme: channing-cyan

[Android禅修之路] 解读Layer

一 前言

二 Layer

2.1 Layer 的定义

2.2 Layer 的实现

2.2.1 State

2.2.1 Layer 的构造函数

2.2.2 LayerCreationArgs

2.2.3 SyncPoint

2.3 LayerFE

三 合成前的Layer

3.1 notifyAvailableFrames

3.1.1 BufferLayer::notifyAvailableFrames

3.2 getTransactionFlags

3.3 doTransaction

3.3.1 commitTransaction

四 Layer 的子类

3.1 ColorLayer

3.1.1 ColorLayer 的定义

3.1.2 ColorLayer 的实现

3.1.2.1 构造函数

3.1.2.2 commitTransaction

3.1.2.3 prepareClientLayer

3.1.2.3 setPerFrameData

3.2 BufferLayer

3.2.1 BufferLayer 的定义

3.2.2 BufferLayer 的实现

3.2.2.1 prepareClientLayer

3.2.2.1 onPreComposition

3.2.2.2 setPerFrameData

一前言

三合成前的Layer