SurfaceControl 的事务提交给 SurfaceFlinger，以及 SurfaceFlinger 如何将这些数据设置到对应 Layer 的完整流程

dalancon
8 阅读19分钟

Android SurfaceFlinger Transaction 应用流程详细分析

概述

本文档详细描述了 Android 15 (AOSP R35) 中，App 通过 SurfaceComposerClient::Transaction::apply() 方法将 SurfaceControl 的事务提交给 SurfaceFlinger，以及 SurfaceFlinger 如何将这些数据设置到对应 Layer 的完整流程。

目录

  1. 客户端侧：Transaction::apply 流程
  2. Binder IPC：setTransactionState
  3. TransactionHandler：事务队列管理
  4. Vsync 触发与主循环
  5. updateLayerSnapshots：核心状态更新入口
  6. LayerLifecycleManager：状态合并
  7. RequestedLayerState::merge：状态合并核心
  8. layer_state_t::merge：底层状态合并
  9. Legacy Layer 状态应用
  10. Layer::setBuffer：缓冲区设置核心
  11. latchBuffer：缓冲区锁定
  12. 状态提交与 mDrawingState = mCurrentState
  13. LayerSnapshot 生成
  14. 关键数据结构关系
  15. 完整流程图
  16. 总结

1. 客户端侧：Transaction::apply 流程

1.1 Transaction 类概述

Transaction 类位于 frameworks/native/libs/gui/include/gui/SurfaceComposerClient.h，是客户端用于原子性地修改多个 SurfaceControl 属性的核心类。

class Transaction : public Parcelable {
    // 存储所有 SurfaceControl 的状态变更
    std::unordered_map<sp<IBinder>, ComposerState, IBinderHash> mComposerStates;

    // 显示状态变更
    SortedVector<DisplayState> mDisplayStates;

    // 回调监听器
    std::unordered_map<sp<ITransactionCompletedListener>, CallbackInfo, TCLHash>
            mListenerCallbacks;

    // 其他关键属性
    int64_t mDesiredPresentTime = 0;  // 期望的呈现时间
    bool mIsAutoTimestamp = true;     // 是否自动时间戳
    FrameTimelineInfo mFrameTimelineInfo; // 帧时间线信息
    sp<IBinder> mApplyToken;          // 应用令牌
    InputWindowCommands mInputWindowCommands; // 输入窗口命令
};

1.2 Transaction::apply 方法实现

位置：frameworks/native/libs/gui/SurfaceComposerClient.cpp 第 1285 行

status_t SurfaceComposerClient::Transaction::apply(bool synchronous, bool oneWay) {
    if (mStatus != NO_ERROR) {
        return mStatus;
    }

    // 1. 处理同步回调
    std::shared_ptr<SyncCallback> syncCallback = std::make_shared<SyncCallback>();
    if (synchronous) {
        syncCallback->init();
        addTransactionCommittedCallback(SyncCallback::getCallback(syncCallback),
                                        /*callbackContext=*/nullptr);
    }

    // 2. 处理监听器回调
    bool hasListenerCallbacks = !mListenerCallbacks.empty();
    std::vector<ListenerCallbacks> listenerCallbacks;
    for (const auto& [listener, callbackInfo] : mListenerCallbacks) {
        auto& [callbackIds, surfaceControls] = callbackInfo;
        if (callbackIds.empty()) continue;

        if (surfaceControls.empty()) {
            listenerCallbacks.emplace_back(IInterface::asBinder(listener),
                                           std::move(callbackIds));
        } else {
            // 将监听器信息附加到 layer_state_t
            for (const auto& surfaceControl : surfaceControls) {
                layer_state_t* s = getLayerState(surfaceControl);
                if (!s) continue;
                std::vector<CallbackId> callbacks(callbackIds.begin(), callbackIds.end());
                s->what |= layer_state_t::eHasListenerCallbacksChanged;
                s->listeners.emplace_back(IInterface::asBinder(listener), callbacks);
            }
        }
    }

    // 3. 缓存缓冲区
    cacheBuffers();

    // 4. 准备 ComposerState 和 DisplayState
    Vector<ComposerState> composerStates;
    Vector<DisplayState> displayStates;
    uint32_t flags = 0;

    for (auto const& kv : mComposerStates) {
        composerStates.add(kv.second);
    }
    displayStates = std::move(mDisplayStates);

    // 5. 设置事务标志
    if (mAnimation) flags |= ISurfaceComposer::eAnimation;
    if (oneWay) flags |= ISurfaceComposer::eOneWay;
    if (mEarlyWakeupStart && !mEarlyWakeupEnd) flags |= ISurfaceComposer::eEarlyWakeupStart;
    if (mEarlyWakeupEnd && !mEarlyWakeupStart) flags |= ISurfaceComposer::eEarlyWakeupEnd;

    // 6. 获取 applyToken
    sp<IBinder> applyToken = mApplyToken ? mApplyToken : getDefaultApplyToken();

    // 7. 通过 Binder IPC 调用 SurfaceFlinger
    sp<ISurfaceComposer> sf(ComposerService::getComposerService());
    status_t binderStatus =
            sf->setTransactionState(mFrameTimelineInfo, composerStates, displayStates, flags,
                                    applyToken, mInputWindowCommands, mDesiredPresentTime,
                                    mIsAutoTimestamp, mUncacheBuffers, hasListenerCallbacks,
                                    listenerCallbacks, mId, mMergedTransactionIds);

    // 8. 清理并等待同步完成
    clear();
    if (synchronous && binderStatus == OK) {
        syncCallback->wait();
    }

    return binderStatus;
}

1.3 layer_state_t 结构

layer_state_t 是描述单个 Layer 状态变更的核心数据结构，位于 frameworks/native/libs/gui/include/gui/LayerState.h。

主要变更标志 (what 字段)：

标志说明
ePositionChanged位置变更 (x, y)
eLayerChangedZ-order 变更
eAlphaChanged透明度变更
eMatrixChanged变换矩阵变更
eFlagsChangedLayer 标志变更 (隐藏、透明、安全等)
eLayerStackChangedLayerStack 变更
eCropChanged裁剪区域变更
eBufferChanged缓冲区变更
eDataspaceChanged数据空间变更
eReparent父 Layer 变更
eRelativeLayerChanged相对 Layer 变更
eInputInfoChanged输入信息变更
eColorTransformChanged颜色变换变更
eFrameRateChanged帧率变更

2. Binder IPC：setTransactionState

2.1 SurfaceFlinger::setTransactionState

位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp 第 4825 行

status_t SurfaceFlinger::setTransactionState(
        const FrameTimelineInfo& frameTimelineInfo, Vector<ComposerState>& states,
        Vector<DisplayState>& displays, uint32_t flags, const sp<IBinder>& applyToken,
        InputWindowCommands inputWindowCommands, int64_t desiredPresentTime, bool isAutoTimestamp,
        const std::vector<client_cache_t>& uncacheBuffers, bool hasListenerCallbacks,
        const std::vector<ListenerCallbacks>& listenerCallbacks, uint64_t transactionId,
        const std::vector<uint64_t>& mergedTransactionIds) {
    SFTRACE_CALL();

    // 1. 获取调用者信息并检查权限
    IPCThreadState* ipc = IPCThreadState::self();
    const int originPid = ipc->getCallingPid();
    const int originUid = ipc->getCallingUid();
    uint32_t permissions = LayerStatePermissions::getTransactionPermissions(originPid, originUid);

    // 2. 清理状态数据
    for (auto& composerState : states) {
        composerState.state.sanitize(permissions);
    }

    // 3. 解析 ComposerState，准备 ResolvedComposerState
    std::vector<ResolvedComposerState> resolvedStates;
    resolvedStates.reserve(states.size());
    for (auto& state : states) {
        resolvedStates.emplace_back(std::move(state));
        auto& resolvedState = resolvedStates.back();
        resolvedState.layerId = LayerHandle::getLayerId(resolvedState.state.surface);

        // 处理缓冲区变更
        if (resolvedState.state.hasBufferChanges() && resolvedState.state.hasValidBuffer() &&
            resolvedState.state.surface) {
            sp<Layer> layer = LayerHandle::getLayer(resolvedState.state.surface);
            resolvedState.externalTexture =
                    getExternalTextureFromBufferData(*resolvedState.state.bufferData,
                                                     layerName.c_str(), transactionId);
        }

        // 解析父 Layer ID 和相对 Layer ID
        if (resolvedState.state.what & layer_state_t::eReparent) {
            resolvedState.parentId =
                    getLayerIdFromSurfaceControl(
                        resolvedState.state.parentSurfaceControlForChild);
        }
        if (resolvedState.state.what & layer_state_t::eRelativeLayerChanged) {
            resolvedState.relativeParentId =
                    getLayerIdFromSurfaceControl(
                        resolvedState.state.relativeLayerSurfaceControl);
        }
    }

    // 4. 创建 TransactionState 并入队
    const int64_t postTime = systemTime();
    TransactionState state{frameTimelineInfo,
                           resolvedStates,
                           displays,
                           flags,
                           applyToken,
                           std::move(inputWindowCommands),
                           desiredPresentTime,
                           isAutoTimestamp,
                           std::move(uncacheBufferIds),
                           postTime,
                           hasListenerCallbacks,
                           listenerCallbacks,
                           originPid,
                           originUid,
                           transactionId,
                           mergedTransactionIds};

    // 5. 将事务入队到 TransactionHandler
    {
        ftl::FakeGuard guard(kMainThreadContext);
        mTransactionHandler.queueTransaction(std::move(state));
    }

    // 6. 设置事务标志，触发 SurfaceFlinger 处理
    setTransactionFlags(eTransactionFlushNeeded, schedule, applyToken, frameHint);
    return NO_ERROR;
}

3. TransactionHandler：事务队列管理

3.1 TransactionHandler 概述

位置：frameworks/native/services/surfaceflinger/FrontEnd/TransactionHandler.h

TransactionHandler 负责事务的排队和过滤，确定哪些事务已准备好被应用。

class TransactionHandler {
public:
    enum class TransactionReadiness {
        Ready,                // 事务已准备好应用
        NotReady,             // 事务未满足条件（fence、present time 等）
        NotReadyBarrier,      // 事务等待 barrier
        NotReadyUnsignaled,   // 事务有未信号化的 fence
    };

private:
    // 按 applyToken 分组的事务队列
    std::unordered_map<sp<IBinder>, std::queue<TransactionState>, IListenerHash>
            mPendingTransactionQueues;

    // 无锁事务队列（用于快速入队）
    LocklessQueue<TransactionState> mLocklessTransactionQueue;
};

3.2 事务入队

void TransactionHandler::queueTransaction(TransactionState&& state) {
    mLocklessTransactionQueue.push(std::move(state));
    mPendingTransactionCount.fetch_add(1);
}

3.3 事务收集与刷新

void TransactionHandler::collectTransactions() {
    // 从无锁队列转移到按 applyToken 分组的队列
    while (!mLocklessTransactionQueue.isEmpty()) {
        auto maybeTransaction = mLocklessTransactionQueue.pop();
        if (!maybeTransaction.has_value()) break;
        auto transaction = maybeTransaction.value();
        mPendingTransactionQueues[transaction.applyToken].emplace(std::move(transaction));
    }
}

std::vector<TransactionState> TransactionHandler::flushTransactions() {
    std::vector<TransactionState> transactions;
    TransactionFlushState flushState;
    flushState.queueProcessTime = systemTime();

    // 循环处理直到没有 barrier 等待的事务
    int lastTransactionsPendingBarrier = 0;
    int transactionsPendingBarrier = 0;
    do {
        lastTransactionsPendingBarrier = transactionsPendingBarrier;
        transactionsPendingBarrier = flushPendingTransactionQueues(transactions, flushState);
    } while (lastTransactionsPendingBarrier != transactionsPendingBarrier);

    return transactions;
}

4. Vsync 触发与主循环

4.1 scheduleCommit 触发

当 setTransactionFlags() 被调用时，会触发 scheduleCommit()：

void SurfaceFlinger::setTransactionFlags(uint32_t mask, TransactionSchedule schedule,
                                         const sp<IBinder>& applyToken, FrameHint frameHint) {
    mScheduler->modulateVsync({}, &VsyncModulator::setTransactionSchedule, schedule, applyToken);
    uint32_t transactionFlags = mTransactionFlags.fetch_or(mask);

    if (const bool scheduled = transactionFlags & mask; !scheduled) {
        mScheduler->resync();
        scheduleCommit(frameHint);  // 调度 commit
    }
}

void SurfaceFlinger::scheduleCommit(FrameHint hint, Duration workDurationSlack) {
    if (hint == FrameHint::kActive) {
        mScheduler->resetIdleTimer();
    }
    mPowerAdvisor->notifyDisplayUpdateImminentAndCpuReset();
    mScheduler->scheduleFrame(workDurationSlack);  // 调度帧处理
}

4.2 commit 主循环入口

Vsync 信号触发后，Scheduler 会调用 SurfaceFlinger::commit()：

bool SurfaceFlinger::commit(PhysicalDisplayId pacesetterId,
                            const scheduler::FrameTargets& frameTargets) {
    const VsyncId vsyncId = pacesetterFrameTarget.vsyncId();

    // 清除 eTransactionFlushNeeded 标志，获取是否需要刷新事务
    const bool flushTransactions = clearTransactionFlags(eTransactionFlushNeeded);

    bool transactionsAreEmpty = false;
    // 核心：更新 Layer 快照
    mustComposite |= updateLayerSnapshots(vsyncId, pacesetterFrameTarget.frameBeginTime().ns(),
                                          flushTransactions, transactionsAreEmpty);

    // 如果还有待处理的事务，重新设置标志
    if (transactionFlushNeeded()) {
        setTransactionFlags(eTransactionFlushNeeded);
    }

    return mustComposite;
}

5. updateLayerSnapshots：核心状态更新入口

位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp 第 2451 行

这是整个事务处理的核心入口函数：

bool SurfaceFlinger::updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs,
                                          bool flushTransactions, bool& outTransactionsAreEmpty) {
    using Changes = frontend::RequestedLayerState::Changes;
    SFTRACE_CALL();
    frontend::Update update;

    if (flushTransactions) {
        SFTRACE_NAME("TransactionHandler:flushTransactions");

        // 步骤1: 收集事务（从无锁队列转移到分组队列）
        mTransactionHandler.collectTransactions();

        // 步骤2: 处理新创建的 Layer
        {
            std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
            update.legacyLayers = std::move(mCreatedLayers);
            update.newLayers = std::move(mNewLayers);
            mNewLayers.clear();
            update.destroyedHandles = std::move(mDestroyedHandles);
            mDestroyedHandles.clear();
        }

        // 步骤3: 添加新 Layer 到生命周期管理器
        mLayerLifecycleManager.addLayers(std::move(update.newLayers));

        // 步骤4: 刷新就绪的事务
        update.transactions = mTransactionHandler.flushTransactions();

        // 步骤5: 应用事务到 LayerLifecycleManager
        mLayerLifecycleManager.applyTransactions(update.transactions);

        // 步骤6: 处理销毁的句柄
        mLayerLifecycleManager.onHandlesDestroyed(update.destroyedHandles);

        // 步骤7: 更新 Layer 层级结构
        mLayerHierarchyBuilder.update(mLayerLifecycleManager);
    }

    // 步骤8: 应用显示事务
    bool mustComposite = false;
    Mutex::Autolock lock(mStateLock);
    mustComposite |= applyAndCommitDisplayTransactionStatesLocked(update.transactions);

    // 步骤9: 更新 LayerSnapshotBuilder
    {
        SFTRACE_NAME("LayerSnapshotBuilder:update");
        frontend::LayerSnapshotBuilder::Args args{...};
        mLayerSnapshotBuilder.update(args);
    }

    // 步骤10: 应用事务到 Legacy Layer
    mustComposite |= applyTransactionsLocked(update.transactions);

    // 步骤11: 提交 Legacy Layer 事务
    traverseLegacyLayers([&](Layer* layer) { layer->commitTransaction(); });

    // 步骤12: 锁定缓冲区（latchBuffer）
    const nsecs_t latchTime = systemTime();
    for (auto& layer : mLayerLifecycleManager.getLayers()) {
        if (layer->hasReadyFrame() || layer->willReleaseBufferOnLatch()) {
            auto it = mLegacyLayers.find(layer->id);
            it->second->latchBufferImpl(unused, latchTime, bgColorOnly);
            newDataLatched = true;
        }
    }

    // 步骤13: 提交变更
    if (mustComposite) {
        commitTransactions();
    }

    return mustComposite;
}

6. LayerLifecycleManager：状态合并

6.1 applyTransactions 实现

位置：frameworks/native/services/surfaceflinger/FrontEnd/LayerLifecycleManager.cpp 第 185 行

void LayerLifecycleManager::applyTransactions(const std::vector<TransactionState>& transactions,
                                              bool ignoreUnknownLayers) {
    for (const auto& transaction : transactions) {
        for (const auto& resolvedComposerState : transaction.states) {
            const auto& clientState = resolvedComposerState.state;
            uint32_t layerId = resolvedComposerState.layerId;

            // 获取目标 Layer
            RequestedLayerState* layer = getLayerFromId(layerId);
            if (layer == nullptr) {
                continue;
            }

            // 记录变更的 Layer
            if (layer->changes.get() == 0) {
                mChangedLayers.push_back(layer);
            }

            // 核心：合并状态
            layer->merge(resolvedComposerState);

            // 更新层级关系链接
            if (oldParentId != layer->parentId) {
                unlinkLayer(oldParentId, layer->id);
                layer->parentId = linkLayer(layer->parentId, layer->id);
            }

            // 更新全局变更标志
            mGlobalChanges |= layer->changes;
        }
    }
}

7. RequestedLayerState::merge：状态合并核心

位置：frameworks/native/services/surfaceflinger/FrontEnd/RequestedLayerState.cpp 第 148 行

RequestedLayerState 继承自 layer_state_t，是服务端存储 Layer 状态的数据类。

void RequestedLayerState::merge(const ResolvedComposerState& resolvedComposerState) {
    // 记录旧值用于变更检测
    const uint32_t oldFlags = flags;
    const half oldAlpha = color.a;
    const bool hadBuffer = externalTexture != nullptr;
    const bool hadSideStream = sidebandStream != nullptr;
    const bool hadSomethingToDraw = hasSomethingToDraw();

    const layer_state_t& clientState = resolvedComposerState.state;
    uint64_t clientChanges = what | layer_state_t::diff(clientState);

    // 核心：调用父类 layer_state_t::merge
    layer_state_t::merge(clientState);
    what = clientChanges;

    // === 变更检测和标志设置 ===

    // 缓冲区变更
    if (clientState.what & layer_state_t::eBufferChanged) {
        externalTexture = resolvedComposerState.externalTexture;
        const bool hasBuffer = externalTexture != nullptr;

        if (hasBuffer || hasBuffer != hadBuffer) {
            changes |= Changes::Buffer;
        }
        if (hasBuffer != hadBuffer) {
            changes |= Changes::Geometry | Changes::VisibleRegion |
                       Changes::Visibility | Changes::Input;
        }
    }

    // 层级关系变更
    if (clientState.what & layer_state_t::eReparent) {
        changes |= Changes::Parent;
        parentId = resolvedComposerState.parentId;
    }

    if (clientState.what & layer_state_t::eRelativeLayerChanged) {
        changes |= Changes::RelativeParent;
        relativeParentId = resolvedComposerState.relativeParentId;
    }

    // 分类变更
    if (clientChanges & layer_state_t::HIERARCHY_CHANGES)
        changes |= Changes::Hierarchy;
    if (clientChanges & layer_state_t::CONTENT_CHANGES)
        changes |= Changes::Content;
    if (clientChanges & layer_state_t::GEOMETRY_CHANGES)
        changes |= Changes::Geometry;
    if (clientChanges & layer_state_t::INPUT_CHANGES)
        changes |= Changes::Input;
}

8. layer_state_t::merge：底层状态合并

位置：frameworks/native/libs/gui/LayerState.cpp 第 562 行

void layer_state_t::merge(const layer_state_t& other) {
    // 位置变更
    if (other.what & ePositionChanged) {
        what |= ePositionChanged;
        x = other.x;
        y = other.y;
    }

    // Z-order 变更
    if (other.what & eLayerChanged) {
        what |= eLayerChanged;
        what &= ~eRelativeLayerChanged;
        z = other.z;
    }

    // Alpha 变更
    if (other.what & eAlphaChanged) {
        what |= eAlphaChanged;
        color.a = other.color.a;
    }

    // 缓冲区变更
    if (other.what & eBufferChanged) {
        what |= eBufferChanged;
        bufferData = other.bufferData;
    }

    // 裁剪区域变更
    if (other.what & eCropChanged) {
        what |= eCropChanged;
        crop = other.crop;
    }

    // 数据空间变更
    if (other.what & eDataspaceChanged) {
        what |= eDataspaceChanged;
        dataspace = other.dataspace;
    }

    // ... 其他属性变更处理
}

9. Legacy Layer 状态应用

9.1 applyTransactionsLocked

位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp 第 4748 行

bool SurfaceFlinger::applyTransactionsLocked(std::vector<TransactionState>& transactions) {
    bool needsTraversal = false;
    for (auto& transaction : transactions) {
        needsTraversal |=
                applyTransactionState(transaction.frameTimelineInfo, transaction.states,
                                      transaction.displays, transaction.flags,
                                      transaction.inputWindowCommands,
                                      transaction.desiredPresentTime, transaction.isAutoTimestamp,
                                      std::move(transaction.uncacheBufferIds), transaction.postTime,
                                      transaction.hasListenerCallbacks,
                                      transaction.listenerCallbacks, transaction.originPid,
                                      transaction.originUid, transaction.id);
    }
    return needsTraversal;
}

9.2 applyTransactionState

bool SurfaceFlinger::applyTransactionState(const FrameTimelineInfo& frameTimelineInfo,
                                           std::vector<ResolvedComposerState>& states, ...) {
    uint32_t transactionFlags = 0;

    for (auto& resolvedState : states) {
        transactionFlags |=
                updateLayerCallbacksAndStats(frameTimelineInfo, resolvedState, ...);
    }

    return needsTraversal;
}

9.3 updateLayerCallbacksAndStats

位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp 第 5109 行

uint32_t SurfaceFlinger::updateLayerCallbacksAndStats(const FrameTimelineInfo& frameTimelineInfo,
                                                      ResolvedComposerState& composerState, ...) {
    layer_state_t& s = composerState.state;
    const uint64_t what = s.what;
    uint32_t flags = 0;

    // 获取 Layer 对象
    sp<Layer> layer = LayerHandle::getLayer(s.surface);
    if (layer == nullptr) return 0;

    // === 应用各种状态变更到 Layer ===

    // 缓冲区变换
    if (what & layer_state_t::eBufferTransformChanged) {
        if (layer->setTransform(s.bufferTransform)) flags |= eTraversalNeeded;
    }

    // 裁剪区域
    if (what & layer_state_t::eCropChanged) {
        if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
    }

    // 数据空间
    if (what & layer_state_t::eDataspaceChanged) {
        if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
    }

    // === 缓冲区变更（核心）===
    if (what & layer_state_t::eBufferChanged) {
        layer->setTransformHint(transformHint);
        if (layer->setBuffer(composerState.externalTexture, *s.bufferData, postTime,
                             desiredPresentTime, isAutoTimestamp, frameTimelineInfo, gameMode)) {
            flags |= eTraversalNeeded;
        }
        mLayersWithQueuedFrames.emplace(layer, gameMode);
    }

    return flags;
}

10. Layer::setBuffer：缓冲区设置核心

位置：frameworks/native/services/surfaceflinger/Layer.cpp 第 890 行

bool Layer::setBuffer(std::shared_ptr<renderengine::ExternalTexture>& buffer,
                      const BufferData& bufferData, nsecs_t postTime, nsecs_t desiredPresentTime,
                      bool isAutoTimestamp, const FrameTimelineInfo& info,
                      gui::GameMode gameMode) {
    // 计算帧号
    const bool frameNumberChanged =
            bufferData.flags.test(BufferData::BufferDataChange::frameNumberChanged);
    const uint64_t frameNumber =
            frameNumberChanged ? bufferData.frameNumber : mDrawingState.frameNumber + 1;

    // 释放旧缓冲区
    if (mDrawingState.buffer) {
        releasePreviousBuffer();
    }

    // 设置时间戳信息
    mDrawingState.desiredPresentTime = desiredPresentTime;
    mDrawingState.isAutoTimestamp = isAutoTimestamp;
    mDrawingState.latchedVsyncId = info.vsyncId;

    if (!buffer) {
        resetDrawingStateBufferInfo();
        setTransactionFlags(eTransactionNeeded);
        return true;
    }

    // 更新 DrawingState
    mDrawingState.producerId = bufferData.producerId;
    mDrawingState.frameNumber = frameNumber;
    mDrawingState.releaseBufferListener = bufferData.releaseBufferListener;
    mDrawingState.buffer = std::move(buffer);
    mDrawingState.acquireFence = bufferData.acquireFence;
    mDrawingState.acquireFenceTime = std::make_unique<FenceTime>(mDrawingState.acquireFence);

    setTransactionFlags(eTransactionNeeded);

    // 更新 TimeStats 和 FrameTracer
    mFlinger->mTimeStats->setPostTime(layerId, mDrawingState.frameNumber, ...);
    setFrameTimelineVsyncForBufferTransaction(info, postTime, gameMode);

    return true;
}

11. latchBuffer：缓冲区锁定

11.1 latchBufferImpl

位置：frameworks/native/services/surfaceflinger/Layer.cpp 第 1474 行

在 updateLayerSnapshots() 中，对于有就绪帧的 Layer，会调用 latchBufferImpl()：

bool Layer::latchBufferImpl(bool& recomputeVisibleRegions, nsecs_t latchTime, bool bgColorOnly) {
    bool refreshRequired = latchSidebandStream(recomputeVisibleRegions);
    if (refreshRequired) return refreshRequired;

    // 检查 acquire fence 是否已信号化
    if (!fenceHasSignaled()) {
        mFlinger->onLayerUpdate();
        return false;
    }

    // 更新纹理图像
    updateTexImage(latchTime, bgColorOnly);

    // 收集缓冲区信息
    BufferInfo oldBufferInfo = mBufferInfo;
    mPreviousFrameNumber = mCurrentFrameNumber;
    mCurrentFrameNumber = mDrawingState.frameNumber;
    gatherBufferInfo();

    // 检测是否需要重新计算可见区域
    if (mBufferInfo.mBuffer) {
        mPreviouslyPresentedLayerStacks.clear();
    }

    if (mDrawingState.buffer == nullptr) {
        const bool bufferReleased = oldBufferInfo.mBuffer != nullptr;
        recomputeVisibleRegions = bufferReleased;
        return bufferReleased;
    }

    if (oldBufferInfo.mBuffer == nullptr) {
        recomputeVisibleRegions = true;
    }

    return true;
}

11.2 updateTexImage

void Layer::updateTexImage(nsecs_t latchTime, bool bgColorOnly) {
    const State& s(getDrawingState());

    if (!s.buffer) {
        return;
    }

    // 更新回调句柄的 latch 时间
    for (auto& handle : mDrawingState.callbackHandles) {
        if (handle->frameNumber == mDrawingState.frameNumber) {
            handle->latchTime = latchTime;
        }
    }

    // 更新 TimeStats 和 FrameTracer
    mFlinger->mTimeStats->setAcquireFence(layerId, frameNumber, acquireFence);
    mFlinger->mTimeStats->setLatchTime(layerId, frameNumber, latchTime);
    mFlinger->mFrameTracer->traceFence(layerId, bufferId, frameNumber, acquireFence,
                                       FrameTracer::FrameEvent::ACQUIRE_FENCE);

    // 处理 bufferSurfaceFrame
    if (bufferSurfaceFrame != nullptr) {
        addSurfaceFramePresentedForBuffer(bufferSurfaceFrame, ...);
    }
}

11.3 gatherBufferInfo

void Layer::gatherBufferInfo() {
    mPreviousReleaseCallbackId = {getCurrentBufferId(), mBufferInfo.mFrameNumber};
    mPreviousReleaseBufferEndpoint = mBufferInfo.mReleaseBufferEndpoint;

    if (!mDrawingState.buffer) {
        mBufferInfo = {};
        return;
    }

    // 从 mDrawingState 复制到 mBufferInfo
    mBufferInfo.mBuffer = mDrawingState.buffer;
    mBufferInfo.mReleaseBufferEndpoint = mDrawingState.releaseBufferEndpoint;
    mBufferInfo.mFence = mDrawingState.acquireFence;
    mBufferInfo.mFrameNumber = mDrawingState.frameNumber;
    mBufferInfo.mPixelFormat = mBufferInfo.mBuffer->getPixelFormat();
    mBufferInfo.mDesiredPresentTime = mDrawingState.desiredPresentTime;
    mBufferInfo.mFenceTime = std::make_shared<FenceTime>(mDrawingState.acquireFence);
    mBufferInfo.mTransform = mDrawingState.bufferTransform;
    mBufferInfo.mDataspace = translateDataspace(mDrawingState.dataspace);
    mBufferInfo.mCrop = computeBufferCrop(mDrawingState);
    mBufferInfo.mTransformToDisplayInverse = mDrawingState.transformToDisplayInverse;
}

12. 状态提交与 mDrawingState = mCurrentState

12.1 SurfaceFlinger::State 结构

位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.h 第 396 行

class State {
public:
    explicit State(LayerVector::StateSet set) : stateSet(set) {}

    State& operator=(const State& other) {
        // 注意：不复制 stateSet，保持 mDrawingState 使用 Drawing StateSet
        displays = other.displays;
        colorMatrixChanged = other.colorMatrixChanged;
        if (colorMatrixChanged) {
            colorMatrix = other.colorMatrix;
        }
        globalShadowSettings = other.globalShadowSettings;
        return *this;
    }

    const LayerVector::StateSet stateSet;  // 标识是 Current 还是 Drawing 状态

    DefaultKeyedVector<wp<IBinder>, DisplayDeviceState> displays;
    bool colorMatrixChanged = true;
    mat4 colorMatrix;
    ShadowSettings globalShadowSettings;
};

12.2 mCurrentState 与 mDrawingState 的定义

// 位于 SurfaceFlinger.h

// mCurrentState: 当前状态，由事务更新
// 可以从非主线程读取（需要锁），只能由主线程写入
State mCurrentState{LayerVector::StateSet::Current};

// mDrawingState: 绘制状态，用于合成
// 只能从主线程访问，不需要同步
State mDrawingState{LayerVector::StateSet::Drawing};

12.3 doCommitTransactions 中的状态提交

位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp 第 4495 行

void SurfaceFlinger::doCommitTransactions() {
    SFTRACE_CALL();
    mDrawingState = mCurrentState;  // 核心：将当前状态提交为绘制状态
    mCurrentState.colorMatrixChanged = false;
}

12.4 mDrawingState = mCurrentState 的作用详解

核心概念：双缓冲状态机制

SurfaceFlinger 使用双缓冲状态机制来管理显示状态，这与图形系统的双缓冲渲染概念类似：

┌─────────────────────────────────────────────────────────────────────────────┐
│                        双缓冲状态机制                                        │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   ┌─────────────────┐                          ┌─────────────────┐         │
│   │  mCurrentState  │                          │  mDrawingState  │         │
│   │   (当前状态)     │                          │   (绘制状态)    │         │
│   └────────┬────────┘                          └────────┬────────┘         │
│            │                                            │                   │
│            │  事务更新                                  │  合成读取         │
│            │  (随时可能被修改)                          │  (稳定状态)       │
│            ▼                                            ▼                   │
│   ┌─────────────────┐                          ┌─────────────────┐         │
│   │ - 新事务写入    │   commit 时复制          │ - 合成引擎读取  │         │
│   │ - Layer 状态变更│  ─────────────────────►  │ - 渲染使用      │         │
│   │ - 显示配置变更  │                          │ - 稳定不变      │         │
│   └─────────────────┘                          └─────────────────┘         │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

为什么需要双缓冲状态？

  1. 避免撕裂（Tearing）：

    • 如果只有一个状态，事务可能在合成过程中被修改
    • 导致同一帧中部分 Layer 使用旧状态，部分使用新状态
    • 双缓冲确保合成期间状态稳定

  2. 原子性保证：

    • 所有事务先写入 mCurrentState
    • 在 Vsync 边界处原子性地提交到 mDrawingState
    • 保证一帧内所有变更同时生效

  3. 线程安全：

    • mCurrentState 可以被 Binder 线程修改（需要锁）
    • mDrawingState 只在主线程访问，无需锁
    • 通过复制操作实现线程间状态传递

状态流转时序：

时间轴 ─────────────────────────────────────────────────────────────────────►

Vsync N                    Vsync N+1                  Vsync N+2
   │                          │                          │
   │  ┌──────────────────┐    │  ┌──────────────────┐    │
   │  │ Transaction 1    │    │  │ Transaction 3    │    │
   │  │ 写入 mCurrentState│    │  │ 写入 mCurrentState│    │
   │  └──────────────────┘    │  └──────────────────┘    │
   │                          │                          │
   │  ┌──────────────────┐    │  ┌──────────────────┐    │
   │  │ Transaction 2    │    │  │                  │    │
   │  │ 写入 mCurrentState│    │  │ mDrawingState =  │    │
   │  └──────────────────┘    │  │ mCurrentState    │    │
   │                          │  │ (提交 N 的状态)   │    │
   │                          │  └──────────────────┘    │
   │                          │                          │
   ▼                          ▼                          ▼
   │                          │                          │
   │  mCurrentState:          │  mCurrentState:         │  mCurrentState:
   │  [Tx1, Tx2]              │  [Tx1, Tx2, Tx3]        │  [Tx1, Tx2, Tx3]
   │                          │                          │
   │  mDrawingState:          │  mDrawingState:         │  mDrawingState:
   │  [上一帧状态]            │  [Tx1, Tx2] ←── 复制    │  [Tx1, Tx2, Tx3]
   │                          │                          │
   │                          │  合成使用 Tx1, Tx2      │  合成使用 Tx1, Tx2, Tx3

Layer 级别的类似机制：

Layer 类内部也有类似的 mDrawingState：

// Layer.h
class Layer {
    // 只能由主线程访问
    State mDrawingState;  // Layer 的绘制状态
};

Layer::commitTransaction() 清理 bufferlessSurfaceFramesTX：

void Layer::commitTransaction() {
    // 设置 bufferlessSurfaceFramesTX 的呈现状态
    for (auto& [token, surfaceFrame] : mDrawingState.bufferlessSurfaceFramesTX) {
        if (surfaceFrame->getPresentState() != PresentState::Presented) {
            surfaceFrame->setPresentState(PresentState::Presented, mLastLatchTime);
            mFlinger->mFrameTimeline->addSurfaceFrame(surfaceFrame);
        }
    }
    mDrawingState.bufferlessSurfaceFramesTX.clear();
}

12.5 commitTransactions 调用链

// SurfaceFlinger.cpp

void SurfaceFlinger::commitTransactions() {
    SFTRACE_CALL();
    mDebugInTransaction = systemTime();
    mScheduler->modulateVsync({}, &VsyncModulator::onTransactionCommit);
    commitTransactionsLocked(clearTransactionFlags(eTransactionMask));
    mDebugInTransaction = 0;
}

void SurfaceFlinger::commitTransactionsLocked(uint32_t transactionFlags) {
    const bool displayTransactionNeeded = transactionFlags & eDisplayTransactionNeeded;
    mFrontEndDisplayInfosChanged = displayTransactionNeeded;

    if (mSomeChildrenChanged) {
        mVisibleRegionsDirty = true;
        mSomeChildrenChanged = false;
        mUpdateInputInfo = true;
    }

    // ... 其他标志处理

    doCommitTransactions();  // 调用实际的状态提交
}

void SurfaceFlinger::doCommitTransactions() {
    SFTRACE_CALL();
    mDrawingState = mCurrentState;  // 核心：状态提交
    mCurrentState.colorMatrixChanged = false;
}

13. Transaction 如何影响 mCurrentState

13.1 Transaction 包含两种状态

Transaction 中包含两种不同类型的状态变更：

// Transaction 类中的数据成员
class Transaction : public Parcelable {
    // Layer 状态变更
    std::unordered_map<sp<IBinder>, ComposerState, IBinderHash> mComposerStates;

    // Display 状态变更
    SortedVector<DisplayState> mDisplayStates;
};

两种状态的对比：

状态类型数据结构存储位置用途
Layer 状态ComposerState (layer_state_t)RequestedLayerStateLayer 的属性（位置、缓冲区、透明度等）
Display 状态DisplayStatemCurrentState.displays显示设备的配置（LayerStack、方向、尺寸等）

13.2 mCurrentState 的实际内容

位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.h 第 396 行

class State {
public:
    const LayerVector::StateSet stateSet;  // 标识是 Current 还是 Drawing

    // mCurrentState 主要存储 Display 相关状态
    DefaultKeyedVector<wp<IBinder>, DisplayDeviceState> displays;

    // 全局颜色变换
    bool colorMatrixChanged = true;
    mat4 colorMatrix;

    // 全局阴影设置
    ShadowSettings globalShadowSettings;
};

重要说明：mCurrentState 不存储 Layer 状态，Layer 状态存储在 RequestedLayerState 中。

13.3 Display 状态更新路径

Transaction 中的 DisplayState 通过以下路径更新 mCurrentState.displays：

┌─────────────────────────────────────────────────────────────────────────────┐
│                    Display 状态更新路径                                      │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Transaction::apply()                                                       │
│       │                                                                     │
│       │  displayStates = std::move(mDisplayStates)                         │
│       │                                                                     │
│       ▼                                                                     │
│  ISurfaceComposer::setTransactionState(displayStates, ...)                  │
│       │                                                                     │
│       │  TransactionState.displays = displays                              │
│       │                                                                     │
│       ▼                                                                     │
│  TransactionHandler::queueTransaction()                                     │
│       │                                                                     │
│       │  [等待 Vsync]                                                       │
│       ▼                                                                     │
│  SurfaceFlinger::updateLayerSnapshots()                                     │
│       │                                                                     │
│       │  Mutex::Autolock lock(mStateLock);                                 │
│       │                                                                     │
│       ▼                                                                     │
│  SurfaceFlinger::applyAndCommitDisplayTransactionStatesLocked()             │
│       │                                                                     │
│       │  for (DisplayState& display : transaction.displays) {              │
│       │      transactionFlags |= setDisplayStateLocked(display);           │
│       │  }                                                                  │
│       │                                                                     │
│       ▼                                                                     │
│  SurfaceFlinger::setDisplayStateLocked(display)                             │
│       │                                                                     │
│       │  // 核心：更新 mCurrentState.displays                              │
│       │  DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);│
│       │                                                                     │
│       │  if (what & DisplayState::eLayerStackChanged) {                    │
│       │      state.layerStack = s.layerStack;                              │
│       │  }                                                                  │
│       │  if (what & DisplayState::eDisplayProjectionChanged) {             │
│       │      state.orientation = s.orientation;                            │
│       │      state.layerStackSpaceRect = s.layerStackSpaceRect;            │
│       │  }                                                                  │
│       │  // ... 其他属性更新                                               │
│       │                                                                     │
│       ▼                                                                     │
│  mCurrentState.displays 已更新                                              │
│       │                                                                     │
│       │  [commit 时]                                                        │
│       ▼                                                                     │
│  SurfaceFlinger::doCommitTransactions()                                     │
│       │                                                                     │
│       │  mDrawingState = mCurrentState;                                    │
│       │                                                                     │
│       ▼                                                                     │
│  mDrawingState.displays 已更新                                              │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

13.4 setDisplayStateLocked 代码证明

位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp 第 5043 行

uint32_t SurfaceFlinger::setDisplayStateLocked(const DisplayState& s) {
    // 1. 查找 Display 在 mCurrentState.displays 中的索引
    const ssize_t index = mCurrentState.displays.indexOfKey(s.token);
    if (index < 0) return 0;  // Display 不存在

    uint32_t flags = 0;

    // 2. 获取 mCurrentState.displays 中的 DisplayDeviceState 引用
    DisplayDeviceState& state = mCurrentState.displays.editValueAt(index);

    const uint32_t what = s.what;

    // 3. 根据 DisplayState.what 标志更新对应属性

    // Surface 变更
    if (what & DisplayState::eSurfaceChanged) {
        if (IInterface::asBinder(state.surface) != IInterface::asBinder(s.surface)) {
            state.surface = s.surface;  // 更新 mCurrentState.displays
            flags |= eDisplayTransactionNeeded;
        }
    }

    // LayerStack 变更
    if (what & DisplayState::eLayerStackChanged) {
        if (state.layerStack != s.layerStack) {
            state.layerStack = s.layerStack;  // 更新 mCurrentState.displays
            flags |= eDisplayTransactionNeeded;
        }
    }

    // 标志变更
    if (what & DisplayState::eFlagsChanged) {
        if (state.flags != s.flags) {
            state.flags = s.flags;  // 更新 mCurrentState.displays
            flags |= eDisplayTransactionNeeded;
        }
    }

    // 显示投影变更（方向、尺寸等）
    if (what & DisplayState::eDisplayProjectionChanged) {
        if (state.orientation != s.orientation) {
            state.orientation = s.orientation;  // 更新 mCurrentState.displays
            flags |= eDisplayTransactionNeeded;
        }
        if (state.orientedDisplaySpaceRect != s.orientedDisplaySpaceRect) {
            state.orientedDisplaySpaceRect = s.orientedDisplaySpaceRect;
            flags |= eDisplayTransactionNeeded;
        }
        if (state.layerStackSpaceRect != s.layerStackSpaceRect) {
            state.layerStackSpaceRect = s.layerStackSpaceRect;
            flags |= eDisplayTransactionNeeded;
        }
    }

    // 显示尺寸变更
    if (what & DisplayState::eDisplaySizeChanged) {
        if (state.width != s.width) {
            state.width = s.width;  // 更新 mCurrentState.displays
            flags |= eDisplayTransactionNeeded;
        }
        if (state.height != s.height) {
            state.height = s.height;
            flags |= eDisplayTransactionNeeded;
        }
    }

    return flags;
}

13.5 applyAndCommitDisplayTransactionStatesLocked 代码证明

位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp 第 5014 行

bool SurfaceFlinger::applyAndCommitDisplayTransactionStatesLocked(
        std::vector<TransactionState>& transactions) {
    bool needsTraversal = false;
    uint32_t transactionFlags = 0;

    // 遍历所有事务中的 Display 状态
    for (auto& transaction : transactions) {
        for (DisplayState& display : transaction.displays) {
            // 核心：调用 setDisplayStateLocked 更新 mCurrentState.displays
            transactionFlags |= setDisplayStateLocked(display);
        }
    }

    if (transactionFlags) {
        if (transactionFlags & eTraversalNeeded) {
            transactionFlags = transactionFlags & (~eTraversalNeeded);
            needsTraversal = true;
        }
        if (transactionFlags) {
            setTransactionFlags(transactionFlags);
        }
    }

    // 处理显示变更
    mFrontEndDisplayInfosChanged = mTransactionFlags & eDisplayTransactionNeeded;
    if (mFrontEndDisplayInfosChanged) {
        processDisplayChangesLocked();
        // ...
    }

    return needsTraversal;
}

13.6 updateLayerSnapshots 中的调用位置

位置：frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp 第 2505 行

bool SurfaceFlinger::updateLayerSnapshots(VsyncId vsyncId, nsecs_t frameTimeNs,
                                          bool flushTransactions, bool& outTransactionsAreEmpty) {
    // ... 前面的 Layer 状态处理 ...

    // 保持 mDrawingState 的副本，避免在锁内进行状态赋值的副作用
    State drawingState(mDrawingState);
    Mutex::Autolock lock(mStateLock);
    bool mustComposite = false;

    // 核心：应用 Display 事务状态到 mCurrentState
    mustComposite |= applyAndCommitDisplayTransactionStatesLocked(update.transactions);

    // ... 后续的 LayerSnapshot 更新 ...
}

13.7 Layer 状态与 mCurrentState 的关系

重要澄清：Layer 状态不存储在 mCurrentState 中，而是通过独立的路径管理：

┌─────────────────────────────────────────────────────────────────────────────┐
│                    Layer 状态 vs Display 状态                                │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Transaction                                                                │
│    │                                                                        │
│    ├── mComposerStates (Layer 状态)                                         │
│    │     │                                                                  │
│    │     │  更新路径                                                        │
│    │     ▼                                                                  │
│    │   LayerLifecycleManager::applyTransactions()                           │
│    │     │                                                                  │
│    │     ▼                                                                  │
│    │   RequestedLayerState::merge()                                         │
│    │     │                                                                  │
│    │     ▼                                                                  │
│    │   RequestedLayerState (存储 Layer 状态)                                │
│    │                                                                        │
│    │     │  commit 时                                                       │
│    │     ▼                                                                  │
│    │   LayerSnapshot (用于合成)                                             │
│    │                                                                        │
│    │   【不涉及 mCurrentState】                                              │
│    │                                                                        │
│    └── mDisplayStates (Display 状态)                                        │
│          │                                                                  │
│          │  更新路径                                                        │
│          ▼                                                                  │
│        applyAndCommitDisplayTransactionStatesLocked()                       │
│          │                                                                  │
│          ▼                                                                  │
│        setDisplayStateLocked()                                              │
│          │                                                                  │
│          ▼                                                                  │
│        mCurrentState.displays (存储 Display 状态)                           │
│          │                                                                  │
│          │  commit 时                                                       │
│          ▼                                                                  │
│        mDrawingState.displays (用于合成)                                    │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

13.8 DisplayState 结构

位置：frameworks/native/libs/gui/include/gui/LayerState.h 第 449 行

struct DisplayState {
    enum : uint32_t {
        eSurfaceChanged = 0x01,           // Surface 变更
        eLayerStackChanged = 0x02,        // LayerStack 变更
        eDisplayProjectionChanged = 0x04, // 显示投影变更
        eDisplaySizeChanged = 0x08,       // 显示尺寸变更
        eFlagsChanged = 0x10,             // 标志变更
        eAllChanged = ~0u
    };

    uint32_t what = 0;          // 变更标志
    uint32_t flags = 0;         // Display 标志
    sp<IBinder> token;          // Display token

    ui::LayerStack layerStack;  // LayerStack

    // 显示投影相关
    ui::Rotation orientation = ui::ROTATION_0;
    Rect layerStackSpaceRect;
    Rect orientedDisplaySpaceRect;

    // 虚拟显示相关
    sp<IGraphicBufferProducer> surface;
    uint32_t width = 0;
    uint32_t height = 0;
};

13.9 客户端设置 Display 状态的示例

// 客户端代码示例
SurfaceComposerClient::Transaction t;

// 设置 Display 的 LayerStack
t.setDisplayLayerStack(displayToken, layerStack);

// 设置 Display 的投影（方向和尺寸）
t.setDisplayProjection(displayToken, orientation, layerStackRect, displayRect);

// 设置虚拟 Display 的 Surface
t.setDisplaySurface(displayToken, surface);

// 应用事务
t.apply();

对应的 Transaction 方法：

// SurfaceComposerClient.cpp

SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setDisplayLayerStack(
        const sp<IBinder>& token, ui::LayerStack layerStack) {
    DisplayState& state(getDisplayState(token));
    state.what |= DisplayState::eLayerStackChanged;
    state.layerStack = layerStack;
    return *this;
}

SurfaceComposerClient::Transaction& SurfaceComposerClient::Transaction::setDisplayProjection(
        const sp<IBinder>& token, ui::Rotation orientation,
        const Rect& layerStackRect, const Rect& displayRect) {
    DisplayState& state(getDisplayState(token));
    state.what |= DisplayState::eDisplayProjectionChanged;
    state.orientation = orientation;
    state.layerStackSpaceRect = layerStackRect;
    state.orientedDisplaySpaceRect = displayRect;
    return *this;
}

14. LayerSnapshot 生成

14.1 LayerSnapshotBuilder::update

位置：frameworks/native/services/surfaceflinger/FrontEnd/LayerSnapshotBuilder.cpp 第 511 行

void LayerSnapshotBuilder::update(const Args& args) {
    for (auto& snapshot : mSnapshots) {
        clearChanges(*snapshot);
    }

    if (tryFastUpdate(args)) {
        return;  // 快速路径：简单缓冲区更新
    }
    updateSnapshots(args);
}

14.2 LayerSnapshot::merge

位置：frameworks/native/services/surfaceflinger/FrontEnd/LayerSnapshot.cpp 第 358 行

void LayerSnapshot::merge(const RequestedLayerState& requested, bool forceUpdate,
                          bool displayChanges, bool forceFullDamage,
                          uint32_t displayRotationFlags) {
    clientChanges = requested.what;
    changes = requested.changes;
    autoRefresh = requested.autoRefresh;
    contentDirty = requested.what & layer_state_t::CONTENT_DIRTY || autoRefresh;
    hasReadyFrame = autoRefresh;

    // 更新各种属性
    if (forceUpdate || requested.what & layer_state_t::eBufferChanged) {
        acquireFence = requested.bufferData->acquireFence;
        buffer = requested.externalTexture->getBuffer();
        externalTexture = requested.externalTexture;
        frameNumber = requested.bufferData->frameNumber;
    }

    if (forceUpdate || requested.what & layer_state_t::ePositionChanged) {
        // 更新位置相关属性
    }

    // ... 其他属性更新
}

14.3 LayerSnapshot 的作用

LayerSnapshot 是从 RequestedLayerState 生成的，用于：

  1. CompositionEngine：合成引擎使用 snapshot 进行合成
  2. RenderEngine：渲染引擎使用 snapshot 中的属性进行渲染
  3. Input 系统：输入系统使用 snapshot 中的输入信息
  4. 无状态依赖：snapshot 可以自由克隆，不影响 FrontEnd 状态

15. 关键数据结构关系

┌─────────────────────────────────────────────────────────────────────────────┐
│                          客户端侧数据结构                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Transaction                                                                │
│    └── mComposerStates: map<IBinder, ComposerState>                        │
│          └── ComposerState                                                  │
│                └── state: layer_state_t                                    │
│                      ├── surface (IBinder handle)                          │
│                      ├── layerId                                            │
│                      ├── what (变更标志位掩码)                              │
│                      ├── x, y, z, color, matrix, crop...                   │
│                      └── bufferData (缓冲区数据)                            │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    │ Binder IPC
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                          服务端侧数据结构                                    │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  TransactionState                                                           │
│    └── states: vector<ResolvedComposerState>                               │
│          ├── state: layer_state_t                                          │
│          ├── layerId                                                        │
│          ├── externalTexture                                                │
│          ├── parentId                                                       │
│          └── relativeParentId                                               │
│                                                                             │
│  RequestedLayerState (FrontEnd Layer 状态)                                  │
│    ├── 继承自 layer_state_t                                                 │
│    ├── id, name, parentId, relativeParentId                                │
│    ├── externalTexture, bufferData                                          │
│    ├── what (变更标志)                                                       │
│    └── changes (Changes 标志)                                               │
│                                                                             │
│  Layer::State (Legacy Layer 状态)                                           │
│    ├── buffer, acquireFence                                                 │
│    ├── frameNumber, producerId                                              │
│    ├── desiredPresentTime                                                    │
│    └── callbackHandles                                                       │
│                                                                             │
│  LayerSnapshot (用于合成)                                                    │
│    ├── 从 RequestedLayerState 生成                                          │
│    ├── 包含所有合成所需数据                                                  │
│    └── 无 FrontEnd 依赖                                                      │
│                                                                             │
│  SurfaceFlinger::State (全局状态)                                           │
│    ├── mCurrentState (当前状态，事务写入)                                   │
│    └── mDrawingState (绘制状态，合成读取)                                   │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘

15. 完整流程图

┌─────────────────────────────────────────────────────────────────────────────┐
│                              客户端进程                                      │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  App/WindowManagerService                                                   │
│       │                                                                     │
│       ▼                                                                     │
│  SurfaceComposerClient.Transaction                                          │
│       │  setPosition(), setAlpha(), setBuffer(), etc.                      │
│       │  数据存储在 mComposerStates                                         │
│       │                                                                     │
│       ▼                                                                     │
│  Transaction::apply()                                                       │
│       │  1. 处理监听器回调                                                  │
│       │  2. cacheBuffers()                                                  │
│       │  3. 准备 ComposerState/DisplayState                                 │
│       │  4. 设置事务标志                                                    │
│       │                                                                     │
│       ▼                                                                     │
│  ISurfaceComposer::setTransactionState() [Binder IPC]                       │
│                                                                             │
└─────────────────────────────────────────────────────────────────────────────┘
                                    │
                                    │ Binder IPC
                                    ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│                            SurfaceFlinger 进程                              │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ 阶段1: 事务入队 (Binder 线程)                                        │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  SurfaceFlinger::setTransactionState()                                      │
│       │  1. 权限检查                                                        │
│       │  2. 解析 ComposerState -> ResolvedComposerState                    │
│       │  3. 处理缓冲区 (getExternalTextureFromBufferData)                  │
│       │  4. 解析 Layer ID、父 ID、相对 ID                                   │
│       │  5. 创建 TransactionState                                           │
│       │                                                                     │
│       ▼                                                                     │
│  TransactionHandler::queueTransaction()                                     │
│       │  - 入队到 mLocklessTransactionQueue                                 │
│       │                                                                     │
│       ▼                                                                     │
│  setTransactionFlags(eTransactionFlushNeeded)                               │
│       │  - 触发 scheduleCommit()                                            │
│       │                                                                     │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │ 阶段2: Vsync 触发 (主线程)                                           │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  Scheduler::onFrameSignal()                                                 │
│       │                                                                     │
│       ▼                                                                     │
│  SurfaceFlinger::commit()                                                   │
│       │                                                                     │
│       ▼                                                                     │
│  SurfaceFlinger::updateLayerSnapshots()                                     │
│       │                                                                     │
│       ├─────────────────────────────────────────────────────────────────┐  │
│       │ 步骤1: TransactionHandler::collectTransactions()                │  │
│       │         - 从无锁队列转移到按 applyToken 分组的队列              │  │
│       └─────────────────────────────────────────────────────────────────┘  │
│       │                                                                     │
│       ├─────────────────────────────────────────────────────────────────┐  │
│       │ 步骤2: TransactionHandler::flushTransactions()                  │  │
│       │         - 应用过滤器检查事务就绪状态                            │  │
│       │         - 返回就绪的事务列表                                    │  │
│       └─────────────────────────────────────────────────────────────────┘  │
│       │                                                                     │
│       ├─────────────────────────────────────────────────────────────────┐  │
│       │ 步骤3: LayerLifecycleManager::applyTransactions()               │  │
│       │         - 对每个事务的每个 ResolvedComposerState:               │  │
│       │           - 获取 RequestedLayerState                            │  │
│       │           - 调用 RequestedLayerState::merge()                   │  │
│       │           - 更新层级关系链接                                    │  │
│       │           - 设置变更标志                                        │  │
│       └─────────────────────────────────────────────────────────────────┘  │
│       │                                                                     │
│       ├─────────────────────────────────────────────────────────────────┐  │
│       │ 步骤4: RequestedLayerState::merge()                              │  │
│       │         - 调用 layer_state_t::merge() 合并底层状态              │  │
│       │         - 检测变更并设置 Changes 标志                           │  │
│       └─────────────────────────────────────────────────────────────────┘  │
│       │                                                                     │
│       ├─────────────────────────────────────────────────────────────────┐  │
│       │ 步骤5: LayerSnapshotBuilder::update()                            │  │
│       │         - 从 RequestedLayerState 生成 LayerSnapshot             │  │
│       │         - 用于 CompositionEngine 和 RenderEngine                │  │
│       └─────────────────────────────────────────────────────────────────┘  │
│       │                                                                     │
│       ├─────────────────────────────────────────────────────────────────┐  │
│       │ 步骤6: applyTransactionsLocked() [Legacy Layer 处理]             │  │
│       │         - applyTransactionState()                                │  │
│       │         - updateLayerCallbacksAndStats()                        │  │
│       │           - Layer::setBuffer()                                   │  │
│       │           - Layer::setCrop()                                     │  │
│       │           - Layer::setDataspace()                                │  │
│       │           - ... 其他 Layer 方法                                  │  │
│       └─────────────────────────────────────────────────────────────────┘  │
│       │                                                                     │
│       ├─────────────────────────────────────────────────────────────────┐  │
│       │ 步骤7: Layer::commitTransaction()                                │  │
│       │         - 清理 bufferlessSurfaceFramesTX                        │  │
│       └─────────────────────────────────────────────────────────────────┘  │
│       │                                                                     │
│       ├─────────────────────────────────────────────────────────────────┐  │
│       │ 步骤8: latchBufferImpl() [对有就绪帧的 Layer]                   │  │
│       │         - fenceHasSignaled() 检查 fence                         │  │
│       │         - updateTexImage() 更新纹理                             │  │
│       │         - gatherBufferInfo() 收集缓冲区信息                     │  │
│       └─────────────────────────────────────────────────────────────────┘  │
│       │                                                                     │
│       ├─────────────────────────────────────────────────────────────────┐  │
│       │ 步骤9: commitTransactions()                                      │  │
│       │         - commitTransactionsLocked()                            │  │
│       │         - doCommitTransactions()                                │  │
│       │           - mDrawingState = mCurrentState (状态提交)            │  │
│       └─────────────────────────────────────────────────────────────────┘  │
│       │                                                                     │
│       ▼                                                                     │
│  CompositionEngine::present()                                               │
│       │  - 使用 LayerSnapshot 进行合成                                    │
│       │                                                                     │
└─────────────────────────────────────────────────────────────────────────────┘

16. 总结

16.1 核心流程总结

  1. 客户端：通过 Transaction 类收集多个 SurfaceControl 的状态变更，存储在 layer_state_t 结构中。

  2. Binder IPC：Transaction::apply() 通过 ISurfaceComposer::setTransactionState() 将事务发送到 SurfaceFlinger。

  3. 事务入队：setTransactionState() 解析状态数据，创建 TransactionState，入队到 TransactionHandler 的无锁队列。

  4. Vsync 触发：scheduleCommit() 调度帧处理，Vsync 信号触发后调用 commit()。

  5. 事务刷新：TransactionHandler::flushTransactions() 应用过滤器检查事务就绪状态。

  6. 状态合并：LayerLifecycleManager::applyTransactions() → RequestedLayerState::merge() → layer_state_t::merge()。

  7. Legacy Layer 应用：applyTransactionState() → updateLayerCallbacksAndStats() → Layer::setBuffer() 等方法更新 mDrawingState。

  8. 缓冲区锁定：latchBufferImpl() 检查 fence，调用 updateTexImage() 和 gatherBufferInfo()。

  9. 状态提交：doCommitTransactions() 中 mDrawingState = mCurrentState 将当前状态提交为绘制状态。

  10. 合成准备：LayerSnapshotBuilder 从 RequestedLayerState 生成 LayerSnapshot，供 CompositionEngine 使用。

16.2 mDrawingState = mCurrentState 的核心意义

  • 双缓冲状态机制：避免合成过程中的状态撕裂
  • 原子性保证：所有事务在 Vsync 边界处原子性生效
  • 线程安全：通过复制操作实现 Binder 线程与主线程间的状态传递
  • 稳定合成：合成期间 mDrawingState 保持稳定不变

16.3 关键设计特点

  1. 原子性：事务中的所有变更原子性地应用。

  2. 分层架构：

    • FrontEnd：TransactionHandler、LayerLifecycleManager、RequestedLayerState
    • Legacy：Layer、Layer::State
    • Composition：LayerSnapshot、CompositionEngine

  3. 变更追踪：通过 what 和 changes 标志位高效追踪变更。

  4. 异步处理：事务入队后等待 Vsync 触发才处理。

  5. 双缓冲状态：mCurrentState 和 mDrawingState 分离，保证合成稳定性。

参考文献

  • frameworks/native/libs/gui/SurfaceComposerClient.cpp
  • frameworks/native/libs/gui/include/gui/SurfaceComposerClient.h
  • frameworks/native/libs/gui/LayerState.cpp
  • frameworks/native/libs/gui/include/gui/LayerState.h
  • frameworks/native/services/surfaceflinger/SurfaceFlinger.cpp
  • frameworks/native/services/surfaceflinger/SurfaceFlinger.h
  • frameworks/native/services/surfaceflinger/Layer.cpp
  • frameworks/native/services/surfaceflinger/Layer.h
  • frameworks/native/services/surfaceflinger/FrontEnd/TransactionHandler.cpp
  • frameworks/native/services/surfaceflinger/FrontEnd/TransactionHandler.h
  • frameworks/native/services/surfaceflinger/FrontEnd/LayerLifecycleManager.cpp
  • frameworks/native/services/surfaceflinger/FrontEnd/LayerLifecycleManager.h
  • frameworks/native/services/surfaceflinger/FrontEnd/RequestedLayerState.cpp
  • frameworks/native/services/surfaceflinger/FrontEnd/RequestedLayerState.h
  • frameworks/native/services/surfaceflinger/FrontEnd/LayerSnapshot.cpp
  • frameworks/native/services/surfaceflinger/FrontEnd/LayerSnapshot.h
  • frameworks/native/services/surfaceflinger/FrontEnd/LayerSnapshotBuilder.cpp
  • frameworks/native/services/surfaceflinger/FrontEnd/readme.md
avatar
文章
阅读
粉丝