SurfaceFlinger08-Layer层级结构管理

前言

Layer在surfaceflinger进程中也是以树结构管理，LayerTree表示一棵Layer树，最顶层Layer称为Root Layer，存放在SurfaceFlinger类中的一个有序列表中，子Layer则存放在父Layer中的有序列表中。这两个有序列表的类型为LayerVector，是一个继承于SortedVector类、结合Layer层级值、创建序列等升序排序的一个有序列表。

Z-Order表示Layer的层级顺序，其值越大表示显示层级越高，该Layer区域内的其他低层级Layer将被覆盖。根据参考物又可分为两种类型：

• 默认层级值：或绝对层级值，在同一LayerTree上、以父Layer为参照确定层级关系（Root Layer直接按照层级大小升序排序）；
• 相对层级值：其层级顺序以指定Layer为参照物（Relative Layer）确定层级关系；

LayerTree描述Layer间的逻辑关系，Z-Order则描述Layer间的空间关系。

Android V开始，Layer的层级结构由树结构变成了图结构。

一、LayerTree的实现

在创建Layer时，会根据该Layer是否可以作为Root Layer将该Layer放置在不同的位置，如果是Root Layer，则直接保存在SurfaceFlinger类中的mCurrentState.layersSortedByZ和mDrawingState.layersSortedByZ列表中，如果是子Layer则保存在对应Parent Layer的mCurrentChildren和mDrawingChildren列表中。

在Layer创建过程中，就会添加到对应的列表中：

// frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp

void SurfaceFlinger::handleLayerCreatedLocked(const LayerCreatedState& state, VsyncId vsyncId) {
    sp<Layer> layer = state.layer.promote();
    sp<Layer> parent;
    bool addToRoot = state.addToRoot;
    ......
    // 未指定Parent时，作为Root Layer添加到mCurrentState.layersSortedByZ列表中
    if (parent == nullptr && addToRoot) {
        layer->setIsAtRoot(true);
        mCurrentState.layersSortedByZ.add(layer);
    } else if (parent == nullptr) {
        layer->onRemovedFromCurrentState();
    } else if (parent->isRemovedFromCurrentState()) {
        // 否则添加到parent layer中
        parent->addChild(layer);
        layer->onRemovedFromCurrentState();
    } else {
        parent->addChild(layer);
    }
    ......
}

1.1、Root Layer和Child Layer的保存

SurfaceFlinger中通过两个状态对象对两帧间的Layer相关状态变更进行更新：

// frameworks/native/services/surfaceflinger/SurfaceFlinger.h

// 表示当前状态，已更新但未应用的状态
State mCurrentState{LayerVector::StateSet::Current};

// 表示已绘制完成状态，已经完成了应用，等待合成输出或已经输出的状态
State mDrawingState{LayerVector::StateSet::Drawing};

layersSortedByZ便是State中的一个成员对象，用于保存Root Layer：

// frameworks/native/services/surfaceflinger/SurfaceFlinger.h
class State {
public:
    explicit State(LayerVector::StateSet set) : stateSet(set), layersSortedByZ(set) {}
    ......
    // 用于保存Root Layer
    LayerVector layersSortedByZ;
    ......
};

Layer中也同样通过两个LayerVector列表保存Current状态和Drawing状态的子Layer：

// frameworks/native/services/surfaceflinger/Layer.h
// 表示当前状态，已更新但未应用的状态
LayerVector mCurrentChildren{LayerVector::StateSet::Current};
// 表示已绘制完成状态，已经完成了应用，等待合成输出或已经输出的状态
LayerVector mDrawingChildren{LayerVector::StateSet::Drawing};

当SurfaceFlinger中收到VSYNC并发起commit操作后，在这个过程中，会分别将Current状态更新给Drawing状态，从而完成状态的更新。

因此，在创建、移除Layer时，会先将Current状态的Layer列表进行更新，然后在下一帧将其同步给Drawing状态列表。

除了在创建过程中可以指定Layer逻辑关系外，SurfaceFlinger中还可以通过其他方法调整Layer间的逻辑关系，包括：添加/移除子Layer、设置/重设父Layer等，下面分别对这些操作进行说明。

1.2、Layer::addChild() 添加子Layer

Layer::addChild()方法用于向该Layer中添加子Layer：

// frameworks/native/services/surfaceflinger/Layer.cpp

void Layer::addChild(const sp<Layer>& layer) {
    // 用于标记Layer结构发生变化
    mFlinger->mSomeChildrenChanged = true;
    // 设置eTransactionNeeded flag
    setTransactionFlags(eTransactionNeeded);
    // 将参数layer添加到mCurrentChildren列表中
    mCurrentChildren.add(layer);
    // 将当前Layer作为父Layer设置给子Layer
    layer->setParent(sp<Layer>::fromExisting(this));
    ......
}

1.3、Layer::removeChild() 移除子Layer

Layer::removeChild()用于将子Layer从该Layer中移除：

// frameworks/native/services/surfaceflinger/Layer.cpp

ssize_t Layer::removeChild(const sp<Layer>& layer) {
    // 标记Layer结构发生变化
    mFlinger->mSomeChildrenChanged = true;
    // 设置eTransactionNeeded flag
    setTransactionFlags(eTransactionNeeded);
    // 将子Layer的Parent设置为null
    layer->setParent(nullptr);
    // 从当前mCurrentChildren列表中移除
    const auto removeResult = mCurrentChildren.remove(layer);
    ......
    return removeResult;
}

1.4、Layer::setParent() 设置父Layer

Layer::setParent()方法用于为该Layer设置父Layer：

// frameworks/native/services/surfaceflinger/Layer.cpp

void Layer::setParent(const sp<Layer>& layer) {
    // 当前该Layer的Parent Layer
    mCurrentParent = layer;
}

1.5、Layer::reparent() 重设父Layer

Layer::reparent()方法用于为该Layer重新设置reparent()，这个方法中结合上述提到的这些方法，完成对应Layer父Layer更新：

// frameworks/native/services/surfaceflinger/Layer.cpp

bool Layer::reparent(const sp<IBinder>& newParentHandle) {
    sp<Layer> newParent;
    // 判断新Parent Layer是否有效
    if (newParentHandle != nullptr) {
        newParent = LayerHandle::getLayer(newParentHandle);
        // 如果新Parent Layer提升失败，说明已经被析构
        if (newParent == nullptr) {
            ALOGE("Unable to promote Layer handle");
            return false;
        }
        // 如果新Parent Layer为自身，不能出现递归
        if (newParent == this) {
            ALOGE("Invalid attempt to reparent Layer (%s) to itself", getName().c_str());
            return false;
        }
    }

    sp<Layer> parent = getParent();
    // 从当前ParentLayer的子类列表中移除该Layer
    if (parent != nullptr) {
        parent->removeChild(sp<Layer>::fromExisting(this));
    }

    if (newParentHandle != nullptr) {
        // 将该Layer添加到新Parent Layer中
        newParent->addChild(sp<Layer>::fromExisting(this));
        // Layer状态将跟随新Layer，如果新Parent Layer参与合成过程，则该Layer也将参与到合成过程
        // 否则，将该Layer添加到待移除列表中，最终进入OffscreenLayer列表中
        if (!newParent->isRemovedFromCurrentState()) {
            addToCurrentState();
        } else {
            onRemovedFromCurrentState();
        }
    } else {
        // 如果新Parent Layer为空，直接添加到待移除列表
        onRemovedFromCurrentState();
    }

    return true;
}

二、Layer层级设置

Layer的层级相关状态保存其状态成员Layer::State中，如mDrawingState.z或mCurrentState.z等：

// frameworks/native/services/surfaceflinger/Layer.h

struct State {
    int32_t z;                               // Layer层级值
    int32_t sequence;                        // Layer更新序列号
    bool modified;                           // 状态是否发生过变更
    wp<Layer> zOrderRelativeOf;              // Layer的Relative Layer，非空说明使用了相对层级
    bool isRelativeOf{false};                // 表示是否使用了相对层级
    SortedVector<wp<Layer>> zOrderRelatives; // 使用相对层级且将该Layer作为参照物的Layer列表
    ......
};

由于Layer层级根据参照物的不同，分为默认层级和相对层级，因此提供了两个方法来分别设置，在SurfaceControl中提供接口如下：

• 设置默认层级：

// frameworks/base/core/java/android/view/SurfaceControl.java

public Transaction setLayer(@NonNull SurfaceControl sc,
        @IntRange(from = Integer.MIN_VALUE, to = Integer.MAX_VALUE) int z) {
    checkPreconditions(sc);
    nativeSetLayer(mNativeObject, sc.mNativeObject, z);
    return this;
}

• 设置相对层级：

// frameworks/base/core/java/android/view/SurfaceControl.java

public Transaction setRelativeLayer(SurfaceControl sc, SurfaceControl relativeTo, int z) {
    checkPreconditions(sc);
    nativeSetRelativeLayer(mNativeObject, sc.mNativeObject, relativeTo.mNativeObject, z);
    return this;
}

同时，由于Root Layer和子Layer的管理对象和保存位置的不同，因此又在surfaceflinger内部针对Root Layer和子Layer，在层级设置方式上略有差别，下面一一进行说明。

2.1、Layer::setLayer() 设置Layer层级关系

Layer::setLayer()方法用于设置所有Layer的层级关系：

// frameworks/native/services/surfaceflinger/Layer.cpp

bool Layer::setLayer(int32_t z) {
    // 如果该Layer使用了RelativeLayer层级值，直接返回
    if (mDrawingState.z == z && !usingRelativeZ(LayerVector::StateSet::Current)) return false;
    mDrawingState.sequence++;
    // 更新Layer层级值
    mDrawingState.z = z;
    // 表示状态值进行了更改
    mDrawingState.modified = true;
    // 表示Layer状态进行了更改
    mFlinger->mSomeChildrenChanged = true;

    // 如果存在相对关系，解除相对关系
    if (mDrawingState.zOrderRelativeOf != nullptr) {
        sp<Layer> strongRelative = mDrawingState.zOrderRelativeOf.promote();
        if (strongRelative != nullptr) {
            strongRelative->removeZOrderRelative(wp<Layer>::fromExisting(this));
        }
        setZOrderRelativeOf(nullptr);
    }
    setTransactionFlags(eTransactionNeeded);
    return true;
}

2.2、Layer::setChildLayer() 设置子Layer层级关系

Layer::setChildLayer()方法则用于设置子Layer的层级关系，由其Parent Layer执行调用：

// frameworks/native/services/surfaceflinger/Layer.cpp

bool Layer::setChildLayer(const sp<Layer>& childLayer, int32_t z) {
    // 从子Layer列表中获取子Layer
    ssize_t idx = mCurrentChildren.indexOf(childLayer);
    if (idx < 0) {
        return false;
    }
    // 设置子Layer的层级值
    if (childLayer->setLayer(z)) {
        // 从mCurrentChildren中移除
        mCurrentChildren.removeAt(idx);
        // 重新添加到mCurrentChildren，添加时自动保证有序性
        mCurrentChildren.add(childLayer);
        return true;
    }
    return false;
}

以上方法中，在完成子Layer层级值设置后，进行了从mCurrentChildren列表中先移除、又添加到mCurrentChildren列表的操作，这是因为mCurrentChildren列表实现了自动排序，因此通过这种操作方式，可以更新该子Layer在mCurrentChildren列表中的顺序和位置。

2.3、Layer::setRelativeLayer() 设置相对层级关系

Layer::setRelativeLayer()方法用于为该Layer设置相对层级关系，因此参数中会携带有参照物Relative Layer：

// frameworks/native/services/surfaceflinger/Layer.cpp

bool Layer::setRelativeLayer(const sp<IBinder>& relativeToHandle, int32_t relativeZ) {
    sp<Layer> relative = LayerHandle::getLayer(relativeToHandle);
    // 校验Relative Layer是否存在
    if (relative == nullptr) {
        return false;
    }
    // 如果已经设置该Relative Layer且层级一致，则直接返回
    if (mDrawingState.z == relativeZ && usingRelativeZ(LayerVector::StateSet::Current) &&
        mDrawingState.zOrderRelativeOf == relative) {
        return false;
    }

    // 判断是否存在循环设置
    if (CC_UNLIKELY(relative->usingRelativeZ(LayerVector::StateSet::Drawing)) &&
        (relative->mDrawingState.zOrderRelativeOf == this)) {
        ALOGE("Detected relative layer loop between %s and %s",
              mName.c_str(), relative->mName.c_str());
        ALOGE("Ignoring new call to set relative layer");
        return false;
    }

    mFlinger->mSomeChildrenChanged = true;
    mDrawingState.sequence++;
    mDrawingState.modified = true;
    // 更新层级值
    mDrawingState.z = relativeZ;
    // 获取旧的Relative Layer
    auto oldZOrderRelativeOf = mDrawingState.zOrderRelativeOf.promote();
    // 将该Layer从旧RelativeLayer中移除
    if (oldZOrderRelativeOf != nullptr) {
        oldZOrderRelativeOf->removeZOrderRelative(wp<Layer>::fromExisting(this));
    }
    // 为该Layer设置新的Relative Layer
    setZOrderRelativeOf(relative);
    // 将该Layer添加到他的Relative Layer中
    relative->addZOrderRelative(wp<Layer>::fromExisting(this));

    setTransactionFlags(eTransactionNeeded);

    return true;
}

2.4、Layer::setChildRelativeLayer() 给子Layer设置相对层级关系

Layer::setChildRelativeLayer()方法则用于为该Layer的子Layer设置相对层级关系，由Parent Layer执行调用：

// frameworks/native/services/surfaceflinger/Layer.cpp

bool Layer::setChildRelativeLayer(const sp<Layer>& childLayer,
        const sp<IBinder>& relativeToHandle, int32_t relativeZ) {
    // 检查该Layer的子Layer列表中是否存在子Layer
    ssize_t idx = mCurrentChildren.indexOf(childLayer);
    if (idx < 0) {
        return false;
    }
    // 给childLayer设置Relative Layer
    if (childLayer->setRelativeLayer(relativeToHandle, relativeZ)) {
        // 先从mCurrentChildren列表中移除，并重新加入
        mCurrentChildren.removeAt(idx);
        mCurrentChildren.add(childLayer);
        return true;
    }
    return false;
}

2.5、Layer::removeZOrderRelative() 移除相对关系

Layer::removeZOrderRelative()方法用于移除该Layer和参数Layer的相对关系：

// frameworks/native/services/surfaceflinger/Layer.cpp

void Layer::removeZOrderRelative(const wp<Layer>& relative) {
    // 从mDrawingState.zOrderRelatives列表中移除
    mDrawingState.zOrderRelatives.remove(relative);
    mDrawingState.sequence++;
    mDrawingState.modified = true;
    setTransactionFlags(eTransactionNeeded);
}

2.6、Layer::setZOrderRelativeOf() 设置Relative Layer

setZOrderRelativeOf()方法用于为该Layer设置一个Relative Layer：

// frameworks/native/services/surfaceflinger/Layer.cpp

void Layer::setZOrderRelativeOf(const wp<Layer>& relativeOf) {
    // 为该Layer设置Relative Layer
    mDrawingState.zOrderRelativeOf = relativeOf;
    mDrawingState.sequence++;
    mDrawingState.modified = true;
    // 表示是否使用相对顺序
    mDrawingState.isRelativeOf = relativeOf != nullptr;

    setTransactionFlags(eTransactionNeeded);
}

2.7、Layer::addZOrderRelative() 将layer添加到指定的RelativeLayer的列表中

Layer::addZOrderRelative()方法用于将参数Layer添加到该Layer的mDrawingState.zOrderRelatives列表中，新增被参照Layer：

// frameworks/native/services/surfaceflinger/Layer.cpp

void Layer::addZOrderRelative(const wp<Layer>& relative) {
    // 添加到mDrawingState.zOrderRelatives列表中
    mDrawingState.zOrderRelatives.add(relative);
    mDrawingState.modified = true;
    mDrawingState.sequence++;
    setTransactionFlags(eTransactionNeeded);
}

三、LayerVector实现

不管是SurfaceFlinger中的mDrawingState.layersSortedByZ，还是Layer中的mDrawingChildren列表，都是LayerVector类型，它实现了自动排序，在Layer的树结构实现、层级管理、以及运行过程中的循环遍历都作用重大。这里从两个方面进一步了解LayerVector：

• LayerVector的排序规则；
• LayerVector的遍历方式。

3.1、LayerVector排序规则

LayerVector类定义如下：

// frameworks/native/services/surfaceflinger/LayerVector.h

class LayerVector : public SortedVector<sp<Layer>> {
public:
    enum class StateSet {
        Invalid,
        Current,
        Drawing,
    };

    explicit LayerVector(const StateSet stateSet);
    LayerVector(const LayerVector& rhs, const StateSet stateSet);
    ~LayerVector() override;

    LayerVector& operator=(const LayerVector& rhs);

    // Sorts layer by layer-stack, Z order, and finally creation order (sequence).
    int do_compare(const void* lhs, const void* rhs) const override;

    // 定义了一个接收Layer指针类型且无返回值的std::function对象，使用Visitor别名
    using Visitor = std::function<void(Layer*)>;
    void traverseInReverseZOrder(StateSet stateSet, const Visitor& visitor) const;
    void traverseInZOrder(StateSet stateSet, const Visitor& visitor) const;
    void traverse(const Visitor& visitor) const;
private:
    const StateSet mStateSet;
};

继承于SortedVector类，本身就具有有序性，同时它重写了do_compare()方法，制定了它的排序规则：按照LayerStack、Layer层级、Layer序列号升序排序。

do_compare()方法如下：

// frameworks/native/services/surfaceflinger/LayerVector.cpp

int LayerVector::do_compare(const void* lhs, const void* rhs) const
{
    // sort layers per layer-stack, then by z-order and finally by sequence
    // 获得Layer引用
    const auto& l = *reinterpret_cast<const sp<Layer>*>(lhs);
    const auto& r = *reinterpret_cast<const sp<Layer>*>(rhs);
    // 获取Layer mDrawingState对象
    const auto& lState = l->getDrawingState();
    const auto& rState = r->getDrawingState();

    const auto ls = lState.layerStack;
    const auto rs = rState.layerStack;
    // 先按照LayerStack值从大到小排序
    if (ls != rs)
        return (ls > rs) ? 1 : -1;
    
    int32_t lz = lState.z;
    int32_t rz = rState.z;
    // 再根据Layer的层级值从大到小排序
    if (lz != rz)
        return (lz > rz) ? 1 : -1;

    if (l->sequence == r->sequence)
        return 0;
    // 最后根据Layer的sequence从大到小排序
    return (l->sequence > r->sequence) ? 1 : -1;
}

以上方法中：

1. 首先比较两个Layer的LayerStack值大小，根据LayerStack值升序排序；

2. 然后比较两个Layer的层级值大小，根据层级值升序排序；

3. 最后比较两个Layer的序列号大小，根据序列号升序排序。

2.2、LayerVector遍历方式

LayerVector针对不同场景需求，提供了三种遍历方式：

• 直接遍历：以BFS方式对列表中Layer进行倒序遍历，对其子Layer进行顺序遍历，不会针对相对层级值做特殊处理；
• 顺序遍历：对列表中Layer及其子类进行顺序遍历，对使用相对层级的Layer跟随其Relative Layer遍历；
• 倒序遍历：对列表中Layer及其子类进行逆序遍历，对使用相对层级的Layer跟随其Relative Layer遍历；

直接遍历的方式只按照Layer层级值和父子关系进行遍历，因此适用于进行Layer结构的记录。

后两种方式则对Relative Layer也加以考虑，因此适用于进行图形化操作，比如合成过程的遍历、最终Layer层级的排序等等。

遍历过程也涉及到Layer内部对其子类的遍历。

2.2.1、LayerVector::traverse()直接遍历

LayerVector::traverse()方法中，从该LayerVector的最后一个元素倒序开始遍历，并依次执行Layer::traverse()方法：

// frameworks/native/services/surfaceflinger/LayerVector.cpp

void LayerVector::traverse(const Visitor& visitor) const {
    // 从LayerVector最后一个元素向前遍历
    for (auto i = static_cast<int64_t>(size()) - 1; i >= 0; i--) {
        // 根据索引获取获取Layer引用
        const auto& layer = (*this)[i];
        // 执行Layer->traverse()对其子类遍历
        layer->traverse(mStateSet, visitor);
    }
}

Layer::traverse()中会对该Layer的子Layer进行遍历：

// frameworks/native/services/surfaceflinger/Layer.cpp
void Layer::traverse(LayerVector::StateSet state, const LayerVector::Visitor& visitor) {
    // 执行函数
    visitor(this);
    // 获取该Layer子类列表
    const LayerVector& children =
          state == LayerVector::StateSet::Drawing ? mDrawingChildren : mCurrentChildren;
    // 继续遍历子Layer
    for (const sp<Layer>& child : children) {
        child->traverse(state, visitor);
    }
}

从以上方法可知，这种方式执行顺序为：

1. 先执行高层级Layer的回调方法；
2. 然后按照层级从低到高的顺序，执行其子Layer的回调方法；
3. 最后执行低层级Layer回调方法。

2.2.2、LayerVector::traverseInZOrder()顺序遍历

LayerVector::traverseInZOrder()方法用于对列表中Layer及其子类进行顺序遍历，其中对存在Relative Layer的Layer跳过遍历，将跟随它的Relative Layer一起进行遍历，整个过程中，按照层级值由低到高的顺序进行遍历。

// frameworks/native/services/surfaceflinger/LayerVector.cpp

void LayerVector::traverseInZOrder(StateSet stateSet, const Visitor& visitor) const {
    // 从LayerVector第一个元素开始遍历
    for (size_t i = 0; i < size(); i++) {
        // 根据索引获取获取Layer引用
        const auto& layer = (*this)[i];
        // 获取Layer mDrawingState对象
        auto& state = layer->getDrawingState();
        // 不会对于使用RelativeLayer的Layer执行遍历
        if (state.isRelativeOf) {
            continue;
        }
        // 执行Layer->traverseInZOrder()对其子类遍历
        layer->traverseInZOrder(stateSet, visitor);
    }
}

Layer中与之对应的traverseInZOrder()方法如下：

// frameworks/native/services/surfaceflinger/Layer.cpp

void Layer::traverseInZOrder(LayerVector::StateSet stateSet, const LayerVector::Visitor& visitor) {
    bool skipRelativeZUsers = false;
    // 创建一个遍历列表
    const LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers);

    size_t i = 0;
    for (; i < list.size(); i++) {
        const auto& relative = list[i];
        // skipRelativeZUsers表示需要在遍历过程中自行处理子Layer使用相对层级的情况，
        // 这里处理相对层级的场景，如果Layer使用了相对层级，则跳过此次遍历
        if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
            continue;
        }
        // 层级值>=0时终止此次循环
        if (relative->getZ(stateSet) >= 0) {
            break;
        }
        // 遍历层级值为负数的Layer
        relative->traverseInZOrder(stateSet, visitor);
    }
    // 执行该Layer方法回调
    visitor(this);
    // 继续在中断索引处执行循环，遍历层级值大于等于0的Layer
    for (; i < list.size(); i++) {
        const auto& relative = list[i];

        if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
            continue;
        }
        // 遍历层级值为正数的Layer
        relative->traverseInZOrder(stateSet, visitor);
    }
}

以上方法中，通过Layer::makeTraversalList()方法创建一个遍历列表执行遍历：

1. 先执行当前Layer中层级小于0的子Layer或Relative Layer的回调方法；

2. 再执行当前Layer的回调方法；

3. 最后执行当前Layer中层级大于0的子Layer或Relative Layer的回调方法。

Layer::makeTraversalList()方法用于对LayerTree结合Relative Layer创建一个遍历列表：

// frameworks/native/services/surfaceflinger/Layer.cpp

LayerVector Layer::makeTraversalList(
        LayerVector::StateSet stateSet, bool* outSkipRelativeZUsers) {
    // 根据LayerVector StateSet确定要遍历的Layer内的子Layer列表
    const bool useDrawing = stateSet == LayerVector::StateSet::Drawing;
    const LayerVector& children = useDrawing ? mDrawingChildren : mCurrentChildren;
    const State& state = useDrawing ? mDrawingState : mDrawingState;

    // 如果当前Layer不存在相对于它的Relative Layer时，直接返回子Layer列表，
    // 同时将outSkipRelativeZUsers设置为true，表示需要在遍历过程中自行处理子Layer使用
    // 相对层级(或存在Relative Layer)的情况
    if (state.zOrderRelatives.size() == 0) {
        *outSkipRelativeZUsers = true;
        return children;
    }
    // 否则，说明存在其他Layer以该Layer为Relative Layer，
    // 则创建一个新的LayerVector，将这些以它为Relative Layer的Layer一同进行遍历
    LayerVector traverse(stateSet);
    // 将以当前Layer为Relative Layer的Layer添加到列表中
    for (const wp<Layer>& weakRelative : state.zOrderRelatives) {
        sp<Layer> strongRelative = weakRelative.promote();
        if (strongRelative != nullptr) {
            traverse.add(strongRelative);
        }
    }
    // 遍历子Layer列表，并将不存在Relative Layer的子Layer添加到列表
    for (const sp<Layer>& child : children) {
        // 存在Relative Layer的Layer跟随其Relative Layer一起遍历
        if (child->usingRelativeZ(stateSet)) {
            continue;
        }
        traverse.add(child);
    }

    return traverse;
}

以上方法中：

• 如果当前Layer不存在相对于它的Relative Layer时，直接返回子Layer列表，同时将outSkipRelativeZUsers设置为true，表示需要在遍历过程中自行处理RelativeLayer情况；

• 否则，则创建一个新的LayerVector，将Relative Layer也加入列表；

• 同时，遍历子Layer列表，并将不存在Relative Z order的子Layer添加到列表。

从这里可以得知，顺序遍历时，若子Layer层级小于0，则它会在Parent Layer之前，反之子Layer层级大于等于0时，会在Parent之后，这种排列方式正是通过此处的遍历方式实现的。

2.2.3、LayerVector::traverseInReverseZOrder()倒序遍历

LayerVector::traverseInReverseZOrder()则是以倒序形式，从列表最后一个元素向前遍历，遍历规则和traverseInZOrder()一致，使用相对层级的Layer跟随起Relative Layer一起执行遍历，整个过程中，按照层级值由高到低的顺序进行遍历：

// frameworks/native/services/surfaceflinger/LayerVector.cpp

void LayerVector::traverseInReverseZOrder(StateSet stateSet, const Visitor& visitor) const {
    // 从列表末尾开始倒序遍历
    for (auto i = static_cast<int64_t>(size()) - 1; i >= 0; i--) {
        const auto& layer = (*this)[i];
        auto& state = layer->getDrawingState();
        // 不会对使用了Relative Layer的Layer执行遍历
        if (state.isRelativeOf) {
            continue;
        }
        // 执行Layer内部遍历
        layer->traverseInReverseZOrder(stateSet, visitor);
     }
}

Layer中对应的倒序遍历方法如下：

// frameworks/native/services/surfaceflinger/Layer.cpp

void Layer::traverseInReverseZOrder(LayerVector::StateSet stateSet,
                                    const LayerVector::Visitor& visitor) {
    // See traverseInZOrder for documentation.
    bool skipRelativeZUsers = false;
    // 创建遍历列表
    LayerVector list = makeTraversalList(stateSet, &skipRelativeZUsers);

    int32_t i = 0;
    for (i = int32_t(list.size()) - 1; i >= 0; i--) {
        const auto& relative = list[i];
        // 对使用了Relative Z的Layer跳过遍历
        if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
            continue;
        }
        // 层级值小于0时，终止遍历
        if (relative->getZ(stateSet) < 0) {
            break;
        }
        // 递归遍历层级大于等于0的Layer
        relative->traverseInReverseZOrder(stateSet, visitor);
    }
    // 执行当前Layer回调函数
    visitor(this);
    // 继续遍历层级值小于0的Layer
    for (; i >= 0; i--) {
        const auto& relative = list[i];

        if (skipRelativeZUsers && relative->usingRelativeZ(stateSet)) {
            continue;
        }
        // 递归遍历层级小于0的Layer
        relative->traverseInReverseZOrder(stateSet, visitor);
    }
}

以上方法中，通过Layer::makeTraversalList()方法创建一个遍历列表执行遍历：

1. 先执行当前Layer中层级大于等于0的子Layer或Relative Layer的回调方法；

2. 再执行当前Layer的回调方法；

3. 最后执行当前Layer中层级小于0的子Layer或Relative Layer的回调方法。

从这里也可以得知，逆序遍历时，若子Layer层级大于等于0，则它会在Parent Layer之前，反之子Layer层级小于0时，会在Parent Layer之后。