devbox
木道寻08
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android13 SurfaceFlinger commit(提交)流程分析_surfaceflinger::commit

作者：木道寻08 | 2024-07-14 14:52:54

赞

踩

surfaceflinger::commit

SurfaceFlinger的commit方法用于将应用程序的绘制结果提交到屏幕上显示。

主要就是处理app端发起的一系列transaction的事务请求，需要对这些请求进行识别是否当前帧处理，处理过程就是把事务中的属性取出，然后更新到Layer中，偶尔buffer更新的还需要进行相关的latchbuffer操作，SurfaceFlinger的commit代码如下：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. bool SurfaceFlinger::commit(nsecs_t frameTime, int64_t vsyncId, nsecs_t expectedVsyncTime) //这里frameTime代表当前时间，expectedVsyncTime代表硬件vsync时间，即屏幕先的vsync时间
  3.         FTL_FAKE_GUARD(kMainThreadContext) {
  4.     // we set this once at the beginning of commit to ensure consistency throughout the whole frame
  5.     mPowerHintSessionData.sessionEnabled = mPowerAdvisor->usePowerHintSession();
  6.     if (mPowerHintSessionData.sessionEnabled) {
  7.         mPowerHintSessionData.commitStart = systemTime();
  8.     }
  9.  
  10.  
  11.     // calculate the expected present time once and use the cached
  12.     // value throughout this frame to make sure all layers are
  13.     // seeing this same value.
  14.     if (expectedVsyncTime >= frameTime) {
  15.         mExpectedPresentTime = expectedVsyncTime;
  16.     } else {
  17.         const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(frameTime);
  18.         mExpectedPresentTime = calculateExpectedPresentTime(stats);
  19.     }
  20.  
  21.  
  22.     const nsecs_t lastScheduledPresentTime = mScheduledPresentTime;
  23.     mScheduledPresentTime = expectedVsyncTime;
  24.  
  25.  
  26.     if (mPowerHintSessionData.sessionEnabled) {
  27.         mPowerAdvisor->setTargetWorkDuration(mExpectedPresentTime -
  28.                                              mPowerHintSessionData.commitStart);
  29.     }
  30.     const auto vsyncIn = [&] {
  31.         if (!ATRACE_ENABLED()) return 0.f;
  32.         return (mExpectedPresentTime - systemTime()) / 1e6f;
  33.     }();
  34.     ATRACE_FORMAT("%s %" PRId64 " vsyncIn %.2fms%s", __func__, vsyncId, vsyncIn,
  35.                   mExpectedPresentTime == expectedVsyncTime ? "" : " (adjusted)");
  36.  
  37.  
  38.     // When Backpressure propagation is enabled we want to give a small grace period
  39.     // for the present fence to fire instead of just giving up on this frame to handle cases
  40.     // where present fence is just about to get signaled.
  41.     const int graceTimeForPresentFenceMs =
  42.             (mPropagateBackpressureClientComposition || !mHadClientComposition) ? 1 : 0;
  43.  
  44.  
  45.     // Pending frames may trigger backpressure propagation.
  46.     const TracedOrdinal<bool> framePending = {"PrevFramePending",
  47.                                               previousFramePending(graceTimeForPresentFenceMs)};
  48.  
  49.  
  50.     // Frame missed counts for metrics tracking.
  51.     // A frame is missed if the prior frame is still pending. If no longer pending,
  52.     // then we still count the frame as missed if the predicted present time
  53.     // was further in the past than when the fence actually fired.
  54.  
  55.  
  56.     // Add some slop to correct for drift. This should generally be
  57.     // smaller than a typical frame duration, but should not be so small
  58.     // that it reports reasonable drift as a missed frame.
  59.     const DisplayStatInfo stats = mScheduler->getDisplayStatInfo(systemTime());
  60.     const nsecs_t frameMissedSlop = stats.vsyncPeriod / 2;
  61.     const nsecs_t previousPresentTime = previousFramePresentTime();
  62.     const TracedOrdinal<bool> frameMissed = {"PrevFrameMissed",
  63.                                              framePending ||
  64.                                                      (previousPresentTime >= 0 &&
  65.                                                       (lastScheduledPresentTime <
  66.                                                        previousPresentTime - frameMissedSlop))};
  67.     const TracedOrdinal<bool> hwcFrameMissed = {"PrevHwcFrameMissed",
  68.                                                 mHadDeviceComposition && frameMissed};
  69.     const TracedOrdinal<bool> gpuFrameMissed = {"PrevGpuFrameMissed",
  70.                                                 mHadClientComposition && frameMissed};
  71.  
  72.  
  73.     if (frameMissed) {
  74.         mFrameMissedCount++;
  75.         mTimeStats->incrementMissedFrames();
  76.     }
  77.  
  78.  
  79.     if (hwcFrameMissed) {
  80.         mHwcFrameMissedCount++;
  81.     }
  82.  
  83.  
  84.     if (gpuFrameMissed) {
  85.         mGpuFrameMissedCount++;
  86.     }
  87.  
  88.  
  89.     // If we are in the middle of a mode change and the fence hasn't
  90.     // fired yet just wait for the next commit.
  91.     // 如果我们正处于模式更改的过程中，并且围栏尚未触发，请等待下一次提交。
  92.     if (mSetActiveModePending) {
  93.         if (framePending) {
  94.             mScheduler->scheduleFrame();
  95.             return false;
  96.         }
  97.  
  98.  
  99.         // We received the present fence from the HWC, so we assume it successfully updated
  100.         // the mode, hence we update SF.
  101.         mSetActiveModePending = false;
  102.         {
  103.             Mutex::Autolock lock(mStateLock);
  104.             updateInternalStateWithChangedMode();
  105.         }
  106.     }
  107.  
  108.  
  109.     if (framePending) {
  110.         if ((hwcFrameMissed && !gpuFrameMissed) || mPropagateBackpressureClientComposition) {
  111.             scheduleCommit(FrameHint::kNone);
  112.             return false;
  113.         }
  114.     }
  115.  
  116.  
  117.     if (mTracingEnabledChanged) {
  118.         mLayerTracingEnabled = mLayerTracing.isEnabled();
  119.         mTracingEnabledChanged = false;
  120.     }
  121.  
  122.  
  123.     if (mRefreshRateOverlaySpinner) {
  124.         Mutex::Autolock lock(mStateLock);
  125.         if (const auto display = getDefaultDisplayDeviceLocked()) {
  126.             display->animateRefreshRateOverlay();
  127.         }
  128.     }
  129.  
  130.  
  131.     // Composite if transactions were committed, or if requested by HWC.
  132.     bool mustComposite = mMustComposite.exchange(false);
  133.     {
  134.         mFrameTimeline->setSfWakeUp(vsyncId, frameTime, Fps::fromPeriodNsecs(stats.vsyncPeriod));
  135.  
  136.  
  137.         bool needsTraversal = false;
  138.         if (clearTransactionFlags(eTransactionFlushNeeded)) { //满足eTransactionFlushNeeded条件进入
  139.             needsTraversal |= commitCreatedLayers(); //负责新创建的layer相关业务处理
  140.             needsTraversal |= flushTransactionQueues(vsyncId); //这里是对前面的Transaction处理的核心部分
  141.         }
  142.  
  143.  
  144.         const bool shouldCommit =
  145.                 (getTransactionFlags() & ~eTransactionFlushNeeded) || needsTraversal;
  146.         if (shouldCommit) {
  147.             commitTransactions(); //进行Transaction提交主要就是交换mCurrentState和DrawingState
  148.         }
  149.  
  150.  
  151.         if (transactionFlushNeeded()) { //判断是否又要启动新vsync信号
  152.             setTransactionFlags(eTransactionFlushNeeded);
  153.         }
  154.  
  155.  
  156.         mustComposite |= shouldCommit;
  157.         mustComposite |= latchBuffers(); //进行核心的latchBuffer
  158.  
  159.  
  160.         // This has to be called after latchBuffers because we want to include the layers that have
  161.         // been latched in the commit callback
  162.         if (!needsTraversal) {
  163.             // Invoke empty transaction callbacks early.
  164.             mTransactionCallbackInvoker.sendCallbacks(false /* onCommitOnly */);
  165.         } else {
  166.             // Invoke OnCommit callbacks.
  167.             mTransactionCallbackInvoker.sendCallbacks(true /* onCommitOnly */);
  168.         }
  169.  
  170.  
  171.         updateLayerGeometry(); //对要这次vsync显示刷新的layer进行脏区设置
  172.     }
  173.  
  174.  
  175.     // Layers need to get updated (in the previous line) before we can use them for
  176.     // choosing the refresh rate.
  177.     // Hold mStateLock as chooseRefreshRateForContent promotes wp<Layer> to sp<Layer>
  178.     // and may eventually call to ~Layer() if it holds the last reference
  179.     {
  180.         Mutex::Autolock _l(mStateLock);
  181.         mScheduler->chooseRefreshRateForContent();
  182.         setActiveModeInHwcIfNeeded();
  183.     }
  184.  
  185.  
  186.     updateCursorAsync(); //鼠标相关layer处理
  187.     updateInputFlinger(); //更新触摸input下的相关的window等，这里也非常关键哈，直接影响触摸是否到app
  188.  
  189.  
  190.     if (mLayerTracingEnabled && !mLayerTracing.flagIsSet(LayerTracing::TRACE_COMPOSITION)) {
  191.         // This will block and tracing should only be enabled for debugging.
  192.         mLayerTracing.notify(mVisibleRegionsDirty, frameTime);
  193.     }
  194.  
  195.  
  196.     persistDisplayBrightness(mustComposite);
  197.  
  198.  
  199.     return mustComposite && CC_LIKELY(mBootStage != BootStage::BOOTLOADER);
  200. }

上面方法主要处理如下：

1、调用SurfaceFlinger的commitCreatedLayers，创建的layer。

2、调用SurfaceFlinger的flushTransactionQueues方法。

3、调用SurfaceFlinger的commitTransactions方法，进行Transaction提交。

4、调用SurfaceFlinger的latchBuffers方法，将应用程序的图形缓冲区（buffer）与显示器进行关联。

5、调用SurfaceFlinger的updateLayerGeometry方法，这次vsync显示刷新的layer进行脏区设置。

6、调用SurfaceFlinger的updateInputFlinger方法，更新输入处理。

下面分别进行分析：

SurfaceFlinger commitCreatedLayers

调用SurfaceFlinger的commitCreatedLayers，创建的layer：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. bool SurfaceFlinger::commitCreatedLayers() {
  3.     std::vector<LayerCreatedState> createdLayers;
  4.     {
  5.         std::scoped_lock<std::mutex> lock(mCreatedLayersLock);
  6.         createdLayers = std::move(mCreatedLayers);
  7.         mCreatedLayers.clear();
  8.         if (createdLayers.size() == 0) {
  9.             return false;
  10.         }
  11.     }
  12.  
  13.  
  14.     Mutex::Autolock _l(mStateLock);
  15.     for (const auto& createdLayer : createdLayers) {
  16.         handleLayerCreatedLocked(createdLayer);
  17.     }
  18.     createdLayers.clear();
  19.     mLayersAdded = true;
  20.     return true;
  21. }

SurfaceFlinger flushTransactionQueues

调用SurfaceFlinger的flushTransactionQueues方法：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. bool SurfaceFlinger::flushTransactionQueues(int64_t vsyncId) {
  3.     // to prevent onHandleDestroyed from being called while the lock is held,
  4.     // we must keep a copy of the transactions (specifically the composer
  5.     // states) around outside the scope of the lock
  6.     std::vector<TransactionState> transactions;
  7.     // Layer handles that have transactions with buffers that are ready to be applied.
  8.     std::unordered_map<sp<IBinder>, uint64_t, SpHash<IBinder>> bufferLayersReadyToPresent;
  9.     std::unordered_set<sp<IBinder>, SpHash<IBinder>> applyTokensWithUnsignaledTransactions;
  10.     {
  11.         Mutex::Autolock _l(mStateLock);
  12.         {
  13.             Mutex::Autolock _l(mQueueLock);
  14.  
  15.  
  16.             int lastTransactionsPendingBarrier = 0;
  17.             int transactionsPendingBarrier = 0;
  18.             // First collect transactions from the pending transaction queues.
  19.             // We are not allowing unsignaled buffers here as we want to
  20.             // collect all the transactions from applyTokens that are ready first.
  21.      //刷新一下PendingTransactionQueues，这个主要是上次vsync中没有满足条件的Transaction放入的
  22.             transactionsPendingBarrier =
  23.                     flushPendingTransactionQueues(transactions, bufferLayersReadyToPresent,
  24.                             applyTokensWithUnsignaledTransactions, /*tryApplyUnsignaled*/ false);
  25.  
  26.  
  27.             // Second, collect transactions from the transaction queue.
  28.             // Here as well we are not allowing unsignaled buffers for the same
  29.             // reason as above.
  30.      //开始遍历当次vsync的mTransactionQueue
  31.             while (!mTransactionQueue.empty()) {
  32.                 auto& transaction = mTransactionQueue.front();
  33.   //判断是否处于mPendingTransactionQueues队里里面
  34.                 const bool pendingTransactions =
  35.                         mPendingTransactionQueues.find(transaction.applyToken) !=
  36.                         mPendingTransactionQueues.end();
  37.   //这里有个ready的判断，主要就是看看当前的Transaction是否已经ready，没有ready则不予进行传递Transaction
  38.                 const auto ready = [&]() REQUIRES(mStateLock) {
  39.                     if (pendingTransactions) {
  40.                         ATRACE_NAME("pendingTransactions");
  41.                         return TransactionReadiness::NotReady;
  42.                     }
  43.  
  44.  
  45.                     return transactionIsReadyToBeApplied(transaction, transaction.frameTimelineInfo,
  46.                                                          transaction.isAutoTimestamp,
  47.                                                          transaction.desiredPresentTime,
  48.                                                          transaction.originUid, transaction.states,
  49.                                                          bufferLayersReadyToPresent,
  50.                                                          transactions.size(),
  51.                                                          /*tryApplyUnsignaled*/ false); //检查当前的事务是否准备好被应用
  52.                 }();
  53.                 ATRACE_INT("TransactionReadiness", static_cast<int>(ready));
  54.                 if (ready != TransactionReadiness::Ready) {
  55.                     if (ready == TransactionReadiness::NotReadyBarrier) {
  56.                         transactionsPendingBarrier++;
  57.                     }
  58.       //放入mPendingTransactionQueues
  59.                     mPendingTransactionQueues[transaction.applyToken].push(std::move(transaction));
  60.                 } else {
  61.       //已经ready则进入如下的操作
  62.                     transaction.traverseStatesWithBuffers([&](const layer_state_t& state) {
  63.                         const bool frameNumberChanged = state.bufferData->flags.test(
  64.                                 BufferData::BufferDataChange::frameNumberChanged);
  65.   //会把state放入到bufferLayersReadyToPresent这个map中
  66.                         if (frameNumberChanged) {
  67.                             bufferLayersReadyToPresent[state.surface] = state.bufferData->frameNumber;
  68.                         } else {
  69.                             // Barrier function only used for BBQ which always includes a frame number.
  70.                             // This value only used for barrier logic.
  71.                             bufferLayersReadyToPresent[state.surface] =
  72.                                 std::numeric_limits<uint64_t>::max();
  73.                         }
  74.                     });
  75.       //最重要的放入到transactions
  76.                     transactions.emplace_back(std::move(transaction));
  77.                 }
  78.   //从mTransactionQueue这里移除
  79.                 mTransactionQueue.pop_front();
  80.                 ATRACE_INT("TransactionQueue", mTransactionQueue.size());
  81.             }
  82.  
  83.  
  84.             // Transactions with a buffer pending on a barrier may be on a different applyToken
  85.             // than the transaction which satisfies our barrier. In fact this is the exact use case
  86.             // that the primitive is designed for. This means we may first process
  87.             // the barrier dependent transaction, determine it ineligible to complete
  88.             // and then satisfy in a later inner iteration of flushPendingTransactionQueues.
  89.             // The barrier dependent transaction was eligible to be presented in this frame
  90.             // but we would have prevented it without case. To fix this we continually
  91.             // loop through flushPendingTransactionQueues until we perform an iteration
  92.             // where the number of transactionsPendingBarrier doesn't change. This way
  93.             // we can continue to resolve dependency chains of barriers as far as possible.
  94.             while (lastTransactionsPendingBarrier != transactionsPendingBarrier) {
  95.                 lastTransactionsPendingBarrier = transactionsPendingBarrier;
  96.                 transactionsPendingBarrier =
  97.                     flushPendingTransactionQueues(transactions, bufferLayersReadyToPresent,
  98.                         applyTokensWithUnsignaledTransactions,
  99.                         /*tryApplyUnsignaled*/ false);
  100.             }
  101.  
  102.  
  103.             // We collected all transactions that could apply without latching unsignaled buffers.
  104.             // If we are allowing latch unsignaled of some form, now it's the time to go over the
  105.             // transactions that were not applied and try to apply them unsignaled.
  106.      //根据enableLatchUnsignaledConfig属性，不是disabled的话需要对前面的notready情况进行第二次的校验放过
  107.             if (enableLatchUnsignaledConfig != LatchUnsignaledConfig::Disabled) {
  108.                 flushUnsignaledPendingTransactionQueues(transactions, bufferLayersReadyToPresent,
  109.                                                         applyTokensWithUnsignaledTransactions);
  110.             }
  111.      //进行关键的applyTransactions操作
  112.             return applyTransactions(transactions, vsyncId);
  113.         }
  114.     }
  115. }

上面方法的主要处理如下：

1、调用SurfaceFlinger的transactionIsReadyToBeApplied方法，检查当前的事务是否准备好被应用

2、调用SurfaceFlinger的applyTransactions方法，应用事务。

下面分别进行分析：

SurfaceFlinger transactionIsReadyToBeApplied

调用SurfaceFlinger的transactionIsReadyToBeApplied方法，检查当前的事务是否准备好被应用：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. auto SurfaceFlinger::transactionIsReadyToBeApplied(TransactionState& transaction,
  3.         const FrameTimelineInfo& info, bool isAutoTimestamp, int64_t desiredPresentTime,
  4.         uid_t originUid, const Vector<ComposerState>& states,
  5.         const std::unordered_map<
  6.             sp<IBinder>, uint64_t, SpHash<IBinder>>& bufferLayersReadyToPresent,
  7.         size_t totalTXapplied, bool tryApplyUnsignaled) const -> TransactionReadiness {
  8.     ATRACE_FORMAT("transactionIsReadyToBeApplied vsyncId: %" PRId64, info.vsyncId);
  9.     const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
  10.     // Do not present if the desiredPresentTime has not passed unless it is more than one second
  11.     // in the future. We ignore timestamps more than 1 second in the future for stability reasons.
  12.     if (!isAutoTimestamp && desiredPresentTime >= expectedPresentTime &&
  13.         desiredPresentTime < expectedPresentTime + s2ns(1)) {
  14.         ATRACE_NAME("not current");
  15.         return TransactionReadiness::NotReady;
  16.     }
  17.  
  18.  
  19.     if (!mScheduler->isVsyncValid(expectedPresentTime, originUid)) {
  20.         ATRACE_NAME("!isVsyncValid");
  21.         return TransactionReadiness::NotReady;
  22.     }
  23.  
  24.  
  25.     // If the client didn't specify desiredPresentTime, use the vsyncId to determine the expected
  26.     // present time of this transaction.
  27.     if (isAutoTimestamp && frameIsEarly(expectedPresentTime, info.vsyncId)) {
  28.         ATRACE_NAME("frameIsEarly");
  29.         return TransactionReadiness::NotReady;
  30.     }
  31.  
  32.  
  33.     bool fenceUnsignaled = false;
  34.     auto queueProcessTime = systemTime();
  35.     //关键部分对transaction的states进行挨个state遍历情况
  36.     for (const ComposerState& state : states) {
  37.         const layer_state_t& s = state.state;
  38.  
  39.  
  40.         sp<Layer> layer = nullptr;
  41.  //这里会判断到底有没有surface。没有的话就不会进入下面判断环节
  42.         if (s.surface) {
  43.             layer = fromHandle(s.surface).promote();
  44.         } else if (s.hasBufferChanges()) {
  45.             ALOGW("Transaction with buffer, but no Layer?");
  46.             continue;
  47.         }
  48.         if (!layer) {
  49.             continue;
  50.         }
  51.  
  52.  
  53.         if (s.hasBufferChanges() && s.bufferData->hasBarrier &&
  54.             ((layer->getDrawingState().frameNumber) < s.bufferData->barrierFrameNumber)) {
  55.             const bool willApplyBarrierFrame =
  56.                 (bufferLayersReadyToPresent.find(s.surface) != bufferLayersReadyToPresent.end()) &&
  57.                 (bufferLayersReadyToPresent.at(s.surface) >= s.bufferData->barrierFrameNumber);
  58.             if (!willApplyBarrierFrame) {
  59.                 ATRACE_NAME("NotReadyBarrier");
  60.                 return TransactionReadiness::NotReadyBarrier;
  61.             }
  62.         }
  63.  
  64.  
  65.  //注意这里会有一个标志allowLatchUnsignaled意思是是否可以latch非signaled的buffer
  66.         const bool allowLatchUnsignaled = tryApplyUnsignaled &&
  67.                 shouldLatchUnsignaled(layer, s, states.size(), totalTXapplied);
  68.         ATRACE_FORMAT("%s allowLatchUnsignaled=%s", layer->getName().c_str(),
  69.                       allowLatchUnsignaled ? "true" : "false");
  70.  
  71.  
  72.         const bool acquireFenceChanged = s.bufferData &&
  73.                 s.bufferData->flags.test(BufferData::BufferDataChange::fenceChanged) &&
  74.                 s.bufferData->acquireFence;
  75.  //这里会进行关键的判断，判断state的bufferData->acquireFence是否已经signaled
  76.         fenceUnsignaled = fenceUnsignaled ||
  77.                 (acquireFenceChanged &&
  78.                  s.bufferData->acquireFence->getStatus() == Fence::Status::Unsignaled);
  79.  
  80.  
  81.  //如果fenceUnsignaled属于fenceUnsignaled，allowLatchUnsignaled也为false
  82.         if (fenceUnsignaled && !allowLatchUnsignaled) {
  83.             if (!transaction.sentFenceTimeoutWarning &&
  84.                 queueProcessTime - transaction.queueTime > std::chrono::nanoseconds(4s).count()) {
  85.                 transaction.sentFenceTimeoutWarning = true;
  86.                 auto listener = s.bufferData->releaseBufferListener;
  87.                 if (listener) {
  88.                     listener->onTransactionQueueStalled();
  89.                 }
  90.             }
  91.      //那么就代表不可以传递transaction，会返回NotReady
  92.             ATRACE_NAME("fence unsignaled");
  93.             return TransactionReadiness::NotReady;
  94.         }
  95.  
  96.  
  97.         if (s.hasBufferChanges()) {
  98.             // If backpressure is enabled and we already have a buffer to commit, keep the
  99.             // transaction in the queue.
  100.             const bool hasPendingBuffer = bufferLayersReadyToPresent.find(s.surface) !=
  101.                 bufferLayersReadyToPresent.end();
  102.      //如果前面已经有state放入了，则不在放入，会放入pending
  103.             if (layer->backpressureEnabled() && hasPendingBuffer && isAutoTimestamp) {
  104.                 ATRACE_NAME("hasPendingBuffer");
  105.                 return TransactionReadiness::NotReady;
  106.             }
  107.         }
  108.     }
  109.     return fenceUnsignaled ? TransactionReadiness::ReadyUnsignaled : TransactionReadiness::Ready;
  110. }

SurfaceFlinger applyTransactions

调用SurfaceFlinger的applyTransactions方法，应用事务：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. bool SurfaceFlinger::applyTransactions(std::vector<TransactionState>& transactions,
  3.                                        int64_t vsyncId) {
  4.     bool needsTraversal = false;
  5.     // Now apply all transactions.
  6.     //遍历每一个上面判断为ready的transaction
  7.     for (auto& transaction : transactions) {
  8.  //核心方法又调用到了applyTransactionState
  9.         needsTraversal |=
  10.                 applyTransactionState(transaction.frameTimelineInfo, transaction.states,
  11.                                       transaction.displays, transaction.flags,
  12.                                       transaction.inputWindowCommands,
  13.                                       transaction.desiredPresentTime, transaction.isAutoTimestamp,
  14.                                       transaction.buffer, transaction.postTime,
  15.                                       transaction.permissions, transaction.hasListenerCallbacks,
  16.                                       transaction.listenerCallbacks, transaction.originPid,
  17.                                       transaction.originUid, transaction.id);
  18.         if (transaction.transactionCommittedSignal) {
  19.             mTransactionCommittedSignals.emplace_back(
  20.                     std::move(transaction.transactionCommittedSignal));
  21.         }
  22.     }
  23.  
  24.  
  25.     if (mTransactionTracing) {
  26.         mTransactionTracing->addCommittedTransactions(transactions, vsyncId);
  27.     }
  28.     return needsTraversal;
  29. }

SurfaceFlinger applyTransactionState

调用SurfaceFlinger的applyTransactionState方法：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. bool SurfaceFlinger::applyTransactionState(const FrameTimelineInfo& frameTimelineInfo,
  3.                                            Vector<ComposerState>& states,
  4.                                            const Vector<DisplayState>& displays, uint32_t flags,
  5.                                            const InputWindowCommands& inputWindowCommands,
  6.                                            const int64_t desiredPresentTime, bool isAutoTimestamp,
  7.                                            const client_cache_t& uncacheBuffer,
  8.                                            const int64_t postTime, uint32_t permissions,
  9.                                            bool hasListenerCallbacks,
  10.                                            const std::vector<ListenerCallbacks>& listenerCallbacks,
  11.                                            int originPid, int originUid, uint64_t transactionId) {
  12.     uint32_t transactionFlags = 0;
  13.     //遍历是transaction的dispplays
  14.     for (const DisplayState& display : displays) {
  15.  //遍历是否有dispplay相关的变化
  16.         transactionFlags |= setDisplayStateLocked(display);
  17.     }
  18.  
  19.  
  20.     // start and end registration for listeners w/ no surface so they can get their callback.  Note
  21.     // that listeners with SurfaceControls will start registration during setClientStateLocked
  22.     // below.
  23.     for (const auto& listener : listenerCallbacks) {
  24.         mTransactionCallbackInvoker.addEmptyTransaction(listener);
  25.     }
  26.  
  27.  
  28.     uint32_t clientStateFlags = 0;
  29.     for (int i = 0; i < states.size(); i++) { //最关键方法开始遍历一个个的states
  30.         ComposerState& state = states.editItemAt(i);
  31.  //调用到了setClientStateLocked方法
  32.         clientStateFlags |= setClientStateLocked(frameTimelineInfo, state, desiredPresentTime,
  33.                                                  isAutoTimestamp, postTime, permissions);
  34.         if ((flags & eAnimation) && state.state.surface) {
  35.             if (const auto layer = fromHandle(state.state.surface).promote()) {
  36.                 using LayerUpdateType = scheduler::LayerHistory::LayerUpdateType;
  37.                 mScheduler->recordLayerHistory(layer.get(),
  38.                                                isAutoTimestamp ? 0 : desiredPresentTime,
  39.                                                LayerUpdateType::AnimationTX);
  40.             }
  41.         }
  42.     }
  43.  
  44.  
  45.     transactionFlags |= clientStateFlags;
  46.  
  47.  
  48.     if (permissions & layer_state_t::Permission::ACCESS_SURFACE_FLINGER) {
  49.         transactionFlags |= addInputWindowCommands(inputWindowCommands);
  50.     } else if (!inputWindowCommands.empty()) {
  51.         ALOGE("Only privileged callers are allowed to send input commands.");
  52.     }
  53.  
  54.  
  55.     if (uncacheBuffer.isValid()) {
  56.         ClientCache::getInstance().erase(uncacheBuffer);
  57.     }
  58.  
  59.  
  60.     // If a synchronous transaction is explicitly requested without any changes, force a transaction
  61.     // anyway. This can be used as a flush mechanism for previous async transactions.
  62.     // Empty animation transaction can be used to simulate back-pressure, so also force a
  63.     // transaction for empty animation transactions.
  64.     if (transactionFlags == 0 &&
  65.             ((flags & eSynchronous) || (flags & eAnimation))) {
  66.         transactionFlags = eTransactionNeeded;
  67.     }
  68.  
  69.  
  70.     bool needsTraversal = false;
  71.     if (transactionFlags) {
  72.         if (mInterceptor->isEnabled()) {
  73.             mInterceptor->saveTransaction(states, mCurrentState.displays, displays, flags,
  74.                                           originPid, originUid, transactionId);
  75.         }
  76.  
  77.  
  78.         // We are on the main thread, we are about to preform a traversal. Clear the traversal bit
  79.         // so we don't have to wake up again next frame to preform an unnecessary traversal.
  80.         if (transactionFlags & eTraversalNeeded) {
  81.             transactionFlags = transactionFlags & (~eTraversalNeeded);
  82.             needsTraversal = true;
  83.         }
  84.         if (transactionFlags) {
  85.             setTransactionFlags(transactionFlags);
  86.         }
  87.  
  88.  
  89.         if (flags & eAnimation) {
  90.             mAnimTransactionPending = true;
  91.         }
  92.     }
  93.  
  94.  
  95.     return needsTraversal;
  96. }
SurfaceFlinger setClientStateLocked

调用SurfaceFlinger的setClientStateLocked方法：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. uint32_t SurfaceFlinger::setClientStateLocked(const FrameTimelineInfo& frameTimelineInfo,
  3.                                               ComposerState& composerState,
  4.                                               int64_t desiredPresentTime, bool isAutoTimestamp,
  5.                                               int64_t postTime, uint32_t permissions) {
  6.     layer_state_t& s = composerState.state;
  7.     s.sanitize(permissions);
  8.  
  9.  
  10.     std::vector<ListenerCallbacks> filteredListeners;
  11.     for (auto& listener : s.listeners) {
  12.         // Starts a registration but separates the callback ids according to callback type. This
  13.         // allows the callback invoker to send on latch callbacks earlier.
  14.         // note that startRegistration will not re-register if the listener has
  15.         // already be registered for a prior surface control
  16.  
  17.  
  18.         ListenerCallbacks onCommitCallbacks = listener.filter(CallbackId::Type::ON_COMMIT);
  19.         if (!onCommitCallbacks.callbackIds.empty()) {
  20.             filteredListeners.push_back(onCommitCallbacks);
  21.         }
  22.  
  23.  
  24.         ListenerCallbacks onCompleteCallbacks = listener.filter(CallbackId::Type::ON_COMPLETE);
  25.         if (!onCompleteCallbacks.callbackIds.empty()) {
  26.             filteredListeners.push_back(onCompleteCallbacks);
  27.         }
  28.     }
  29.  
  30.  
  31.     const uint64_t what = s.what;
  32.     uint32_t flags = 0;
  33.     sp<Layer> layer = nullptr;
  34.     if (s.surface) {
  35.         layer = fromHandle(s.surface).promote();
  36.     } else {
  37.         // The client may provide us a null handle. Treat it as if the layer was removed.
  38.         ALOGW("Attempt to set client state with a null layer handle");
  39.     }
  40.     if (layer == nullptr) {
  41.         for (auto& [listener, callbackIds] : s.listeners) {
  42.             mTransactionCallbackInvoker.registerUnpresentedCallbackHandle(
  43.                     new CallbackHandle(listener, callbackIds, s.surface));
  44.         }
  45.         return 0;
  46.     }
  47.  
  48.  
  49.     // Only set by BLAST adapter layers
  50.     if (what & layer_state_t::eProducerDisconnect) {
  51.         layer->onDisconnect();
  52.     }
  53.  
  54.  
  55.     if (what & layer_state_t::ePositionChanged) {
  56.         if (layer->setPosition(s.x, s.y)) {
  57.             flags |= eTraversalNeeded;
  58.         }
  59.     }
  60.     if (what & layer_state_t::eLayerChanged) {
  61.         // NOTE: index needs to be calculated before we update the state
  62.         const auto& p = layer->getParent();
  63.         if (p == nullptr) {
  64.             ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
  65.             if (layer->setLayer(s.z) && idx >= 0) {
  66.                 mCurrentState.layersSortedByZ.removeAt(idx);
  67.                 mCurrentState.layersSortedByZ.add(layer);
  68.                 // we need traversal (state changed)
  69.                 // AND transaction (list changed)
  70.                 flags |= eTransactionNeeded|eTraversalNeeded;
  71.             }
  72.         } else {
  73.             if (p->setChildLayer(layer, s.z)) {
  74.                 flags |= eTransactionNeeded|eTraversalNeeded;
  75.             }
  76.         }
  77.     }
  78.     if (what & layer_state_t::eRelativeLayerChanged) {
  79.         // NOTE: index needs to be calculated before we update the state
  80.         const auto& p = layer->getParent();
  81.         const auto& relativeHandle = s.relativeLayerSurfaceControl ?
  82.                 s.relativeLayerSurfaceControl->getHandle() : nullptr;
  83.         if (p == nullptr) {
  84.             ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
  85.             if (layer->setRelativeLayer(relativeHandle, s.z) &&
  86.                 idx >= 0) {
  87.                 mCurrentState.layersSortedByZ.removeAt(idx);
  88.                 mCurrentState.layersSortedByZ.add(layer);
  89.                 // we need traversal (state changed)
  90.                 // AND transaction (list changed)
  91.                 flags |= eTransactionNeeded|eTraversalNeeded;
  92.             }
  93.         } else {
  94.             if (p->setChildRelativeLayer(layer, relativeHandle, s.z)) {
  95.                 flags |= eTransactionNeeded|eTraversalNeeded;
  96.             }
  97.         }
  98.     }
  99.     if (what & layer_state_t::eSizeChanged) {
  100.         if (layer->setSize(s.w, s.h)) {
  101.             flags |= eTraversalNeeded;
  102.         }
  103.     }
  104.     if (what & layer_state_t::eAlphaChanged) {
  105.         if (layer->setAlpha(s.alpha))
  106.             flags |= eTraversalNeeded;
  107.     }
  108.     if (what & layer_state_t::eColorChanged) {
  109.         if (layer->setColor(s.color))
  110.             flags |= eTraversalNeeded;
  111.     }
  112.     if (what & layer_state_t::eColorTransformChanged) {
  113.         if (layer->setColorTransform(s.colorTransform)) {
  114.             flags |= eTraversalNeeded;
  115.         }
  116.     }
  117.     if (what & layer_state_t::eBackgroundColorChanged) {
  118.         if (layer->setBackgroundColor(s.color, s.bgColorAlpha, s.bgColorDataspace)) {
  119.             flags |= eTraversalNeeded;
  120.         }
  121.     }
  122.     if (what & layer_state_t::eMatrixChanged) {
  123.         if (layer->setMatrix(s.matrix)) flags |= eTraversalNeeded;
  124.     }
  125.     if (what & layer_state_t::eTransparentRegionChanged) {
  126.         if (layer->setTransparentRegionHint(s.transparentRegion))
  127.             flags |= eTraversalNeeded;
  128.     }
  129.     if (what & layer_state_t::eFlagsChanged) {
  130.         if (layer->setFlags(s.flags, s.mask)) flags |= eTraversalNeeded;
  131.     }
  132.     if (what & layer_state_t::eCornerRadiusChanged) {
  133.         if (layer->setCornerRadius(s.cornerRadius))
  134.             flags |= eTraversalNeeded;
  135.     }
  136.     if (what & layer_state_t::eBackgroundBlurRadiusChanged && mSupportsBlur) {
  137.         if (layer->setBackgroundBlurRadius(s.backgroundBlurRadius)) flags |= eTraversalNeeded;
  138.     }
  139.     if (what & layer_state_t::eBlurRegionsChanged) {
  140.         if (layer->setBlurRegions(s.blurRegions)) flags |= eTraversalNeeded;
  141.     }
  142.     if (what & layer_state_t::eLayerStackChanged) {
  143.         ssize_t idx = mCurrentState.layersSortedByZ.indexOf(layer);
  144.         // We only allow setting layer stacks for top level layers,
  145.         // everything else inherits layer stack from its parent.
  146.         if (layer->hasParent()) {
  147.             ALOGE("Attempt to set layer stack on layer with parent (%s) is invalid",
  148.                   layer->getDebugName());
  149.         } else if (idx < 0) {
  150.             ALOGE("Attempt to set layer stack on layer without parent (%s) that "
  151.                   "that also does not appear in the top level layer list. Something"
  152.                   " has gone wrong.",
  153.                   layer->getDebugName());
  154.         } else if (layer->setLayerStack(s.layerStack)) {
  155.             mCurrentState.layersSortedByZ.removeAt(idx);
  156.             mCurrentState.layersSortedByZ.add(layer);
  157.             // we need traversal (state changed)
  158.             // AND transaction (list changed)
  159.             flags |= eTransactionNeeded | eTraversalNeeded | eTransformHintUpdateNeeded;
  160.         }
  161.     }
  162.     if (what & layer_state_t::eTransformChanged) {
  163.         if (layer->setTransform(s.transform)) flags |= eTraversalNeeded;
  164.     }
  165.     if (what & layer_state_t::eTransformToDisplayInverseChanged) {
  166.         if (layer->setTransformToDisplayInverse(s.transformToDisplayInverse))
  167.             flags |= eTraversalNeeded;
  168.     }
  169.     if (what & layer_state_t::eCropChanged) {
  170.         if (layer->setCrop(s.crop)) flags |= eTraversalNeeded;
  171.     }
  172.     if (what & layer_state_t::eDataspaceChanged) {
  173.         if (layer->setDataspace(s.dataspace)) flags |= eTraversalNeeded;
  174.     }
  175.     if (what & layer_state_t::eHdrMetadataChanged) {
  176.         if (layer->setHdrMetadata(s.hdrMetadata)) flags |= eTraversalNeeded;
  177.     }
  178.     if (what & layer_state_t::eSurfaceDamageRegionChanged) {
  179.         if (layer->setSurfaceDamageRegion(s.surfaceDamageRegion)) flags |= eTraversalNeeded;
  180.     }
  181.     if (what & layer_state_t::eApiChanged) {
  182.         if (layer->setApi(s.api)) flags |= eTraversalNeeded;
  183.     }
  184.     if (what & layer_state_t::eSidebandStreamChanged) {
  185.         if (layer->setSidebandStream(s.sidebandStream)) flags |= eTraversalNeeded;
  186.     }
  187.     if (what & layer_state_t::eInputInfoChanged) {
  188.         layer->setInputInfo(*s.windowInfoHandle->getInfo());
  189.         flags |= eTraversalNeeded;
  190.     }
  191.     std::optional<nsecs_t> dequeueBufferTimestamp;
  192.     if (what & layer_state_t::eMetadataChanged) {
  193.         dequeueBufferTimestamp = s.metadata.getInt64(METADATA_DEQUEUE_TIME);
  194.  
  195.  
  196.         if (const int32_t gameMode = s.metadata.getInt32(METADATA_GAME_MODE, -1); gameMode != -1) {
  197.             // The transaction will be received on the Task layer and needs to be applied to all
  198.             // child layers. Child layers that are added at a later point will obtain the game mode
  199.             // info through addChild().
  200.             layer->setGameModeForTree(static_cast<GameMode>(gameMode));
  201.         }
  202.  
  203.  
  204.         if (layer->setMetadata(s.metadata)) flags |= eTraversalNeeded;
  205.     }
  206.     if (what & layer_state_t::eColorSpaceAgnosticChanged) {
  207.         if (layer->setColorSpaceAgnostic(s.colorSpaceAgnostic)) {
  208.             flags |= eTraversalNeeded;
  209.         }
  210.     }
  211.     if (what & layer_state_t::eShadowRadiusChanged) {
  212.         if (layer->setShadowRadius(s.shadowRadius)) flags |= eTraversalNeeded;
  213.     }
  214.     if (what & layer_state_t::eFrameRateSelectionPriority) {
  215.         if (layer->setFrameRateSelectionPriority(s.frameRateSelectionPriority)) {
  216.             flags |= eTraversalNeeded;
  217.         }
  218.     }
  219.     if (what & layer_state_t::eFrameRateChanged) {
  220.         const auto compatibility =
  221.             Layer::FrameRate::convertCompatibility(s.frameRateCompatibility);
  222.         const auto strategy =
  223.             Layer::FrameRate::convertChangeFrameRateStrategy(s.changeFrameRateStrategy);
  224.  
  225.  
  226.         if (layer->setFrameRate(
  227.                 Layer::FrameRate(Fps::fromValue(s.frameRate), compatibility, strategy))) {
  228.           flags |= eTraversalNeeded;
  229.         }
  230.     }
  231.     if (what & layer_state_t::eFixedTransformHintChanged) {
  232.         if (layer->setFixedTransformHint(s.fixedTransformHint)) {
  233.             flags |= eTraversalNeeded | eTransformHintUpdateNeeded;
  234.         }
  235.     }
  236.     if (what & layer_state_t::eAutoRefreshChanged) {
  237.         layer->setAutoRefresh(s.autoRefresh);
  238.     }
  239.     if (what & layer_state_t::eDimmingEnabledChanged) {
  240.         if (layer->setDimmingEnabled(s.dimmingEnabled)) flags |= eTraversalNeeded;
  241.     }
  242.     if (what & layer_state_t::eTrustedOverlayChanged) {
  243.         if (layer->setTrustedOverlay(s.isTrustedOverlay)) {
  244.             flags |= eTraversalNeeded;
  245.         }
  246.     }
  247.     if (what & layer_state_t::eStretchChanged) {
  248.         if (layer->setStretchEffect(s.stretchEffect)) {
  249.             flags |= eTraversalNeeded;
  250.         }
  251.     }
  252.     if (what & layer_state_t::eBufferCropChanged) {
  253.         if (layer->setBufferCrop(s.bufferCrop)) {
  254.             flags |= eTraversalNeeded;
  255.         }
  256.     }
  257.     if (what & layer_state_t::eDestinationFrameChanged) {
  258.         if (layer->setDestinationFrame(s.destinationFrame)) {
  259.             flags |= eTraversalNeeded;
  260.         }
  261.     }
  262.     if (what & layer_state_t::eDropInputModeChanged) {
  263.         if (layer->setDropInputMode(s.dropInputMode)) {
  264.             flags |= eTraversalNeeded;
  265.             mInputInfoChanged = true;
  266.         }
  267.     }
  268.     // This has to happen after we reparent children because when we reparent to null we remove
  269.     // child layers from current state and remove its relative z. If the children are reparented in
  270.     // the same transaction, then we have to make sure we reparent the children first so we do not
  271.     // lose its relative z order.
  272.     if (what & layer_state_t::eReparent) {
  273.         bool hadParent = layer->hasParent();
  274.         auto parentHandle = (s.parentSurfaceControlForChild)
  275.                 ? s.parentSurfaceControlForChild->getHandle()
  276.                 : nullptr;
  277.         if (layer->reparent(parentHandle)) {
  278.             if (!hadParent) {
  279.                 layer->setIsAtRoot(false);
  280.                 mCurrentState.layersSortedByZ.remove(layer);
  281.             }
  282.             flags |= eTransactionNeeded | eTraversalNeeded;
  283.         }
  284.     }
  285.     std::vector<sp<CallbackHandle>> callbackHandles;
  286.     if ((what & layer_state_t::eHasListenerCallbacksChanged) && (!filteredListeners.empty())) {
  287.         for (auto& [listener, callbackIds] : filteredListeners) {
  288.             callbackHandles.emplace_back(new CallbackHandle(listener, callbackIds, s.surface));
  289.         }
  290.     }
  291.  
  292.  
  293.     if (what & layer_state_t::eBufferChanged) {  //如果发现有buffer变化
  294.         std::shared_ptr<renderengine::ExternalTexture> buffer =
  295.                 getExternalTextureFromBufferData(*s.bufferData, layer->getDebugName());
  296.  //把state的bufferData相关信息设置到了layer中去
  297.         if (layer->setBuffer(buffer, *s.bufferData, postTime, desiredPresentTime, isAutoTimestamp,
  298.                              dequeueBufferTimestamp, frameTimelineInfo)) {
  299.             flags |= eTraversalNeeded;
  300.         }
  301.     } else if (frameTimelineInfo.vsyncId != FrameTimelineInfo::INVALID_VSYNC_ID) {
  302.         layer->setFrameTimelineVsyncForBufferlessTransaction(frameTimelineInfo, postTime);
  303.     }
  304.  
  305.  
  306.     if (layer->setTransactionCompletedListeners(callbackHandles)) flags |= eTraversalNeeded;
  307.     // Do not put anything that updates layer state or modifies flags after
  308.     // setTransactionCompletedListener
  309.     return flags;
  310. }

SurfaceFlinger commitTransactions

调用SurfaceFlinger的commitTransactions方法，进行Transaction提交：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. void SurfaceFlinger::commitTransactions() {
  3.     ATRACE_CALL();
  4.  
  5.  
  6.     // Keep a copy of the drawing state (that is going to be overwritten
  7.     // by commitTransactionsLocked) outside of mStateLock so that the side
  8.     // effects of the State assignment don't happen with mStateLock held,
  9.     // which can cause deadlocks.
  10.     State drawingState(mDrawingState);
  11.  
  12.  
  13.     Mutex::Autolock lock(mStateLock);
  14.     mDebugInTransaction = systemTime();
  15.  
  16.  
  17.     // Here we're guaranteed that some transaction flags are set
  18.     // so we can call commitTransactionsLocked unconditionally.
  19.     // We clear the flags with mStateLock held to guarantee that
  20.     // mCurrentState won't change until the transaction is committed.
  21.     modulateVsync(&VsyncModulator::onTransactionCommit);
  22.     commitTransactionsLocked(clearTransactionFlags(eTransactionMask));
  23.  
  24.  
  25.     mDebugInTransaction = 0;
  26. }

调用SurfaceFlinger的commitTransactionsLocked方法：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. void SurfaceFlinger::commitTransactionsLocked(uint32_t transactionFlags) {
  3.     // Commit display transactions.
  4.     const bool displayTransactionNeeded = transactionFlags & eDisplayTransactionNeeded;
  5.     if (displayTransactionNeeded) { //如果需要显示
  6.         processDisplayChangesLocked(); //处理显示变化相关
  7.         processDisplayHotplugEventsLocked();
  8.     }
  9.     mForceTransactionDisplayChange = displayTransactionNeeded;
  10.  
  11.  
  12.     if (mSomeChildrenChanged) {
  13.         mVisibleRegionsDirty = true;
  14.         mSomeChildrenChanged = false;
  15.     }
  16.  
  17.  
  18.     // Update transform hint.
  19.     if (transactionFlags & (eTransformHintUpdateNeeded | eDisplayTransactionNeeded)) {
  20.         // Layers and/or displays have changed, so update the transform hint for each layer.
  21.         //
  22.         // NOTE: we do this here, rather than when presenting the display so that
  23.         // the hint is set before we acquire a buffer from the surface texture.
  24.         //
  25.         // NOTE: layer transactions have taken place already, so we use their
  26.         // drawing state. However, SurfaceFlinger's own transaction has not
  27.         // happened yet, so we must use the current state layer list
  28.         // (soon to become the drawing state list).
  29.         //
  30.         sp<const DisplayDevice> hintDisplay;
  31.         ui::LayerStack layerStack;
  32.  
  33.  
  34.         mCurrentState.traverse([&](Layer* layer) REQUIRES(mStateLock) {
  35.             // NOTE: we rely on the fact that layers are sorted by
  36.             // layerStack first (so we don't have to traverse the list
  37.             // of displays for every layer).
  38.             if (const auto filter = layer->getOutputFilter(); layerStack != filter.layerStack) {
  39.                 layerStack = filter.layerStack;
  40.                 hintDisplay = nullptr;
  41.  
  42.  
  43.                 // Find the display that includes the layer.
  44.                 for (const auto& [token, display] : mDisplays) {
  45.                     if (!display->getCompositionDisplay()->includesLayer(filter)) {
  46.                         continue;
  47.                     }
  48.  
  49.  
  50.                     // Pick the primary display if another display mirrors the layer.
  51.                     if (hintDisplay) {
  52.                         hintDisplay = nullptr;
  53.                         break;
  54.                     }
  55.  
  56.  
  57.                     hintDisplay = display;
  58.                 }
  59.             }
  60.  
  61.  
  62.             if (!hintDisplay) {
  63.                 // NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
  64.                 // redraw after transform hint changes. See bug 8508397.
  65.  
  66.  
  67.                 // could be null when this layer is using a layerStack
  68.                 // that is not visible on any display. Also can occur at
  69.                 // screen off/on times.
  70.                 hintDisplay = getDefaultDisplayDeviceLocked();
  71.             }
  72.  
  73.  
  74.             layer->updateTransformHint(hintDisplay->getTransformHint());
  75.         });
  76.     }
  77.  
  78.  
  79.     if (mLayersAdded) {
  80.         mLayersAdded = false;
  81.         // Layers have been added.
  82.         mVisibleRegionsDirty = true;
  83.     }
  84.  
  85.  
  86.     // some layers might have been removed, so
  87.     // we need to update the regions they're exposing.
  88.     if (mLayersRemoved) {
  89.         mLayersRemoved = false;
  90.         mVisibleRegionsDirty = true;
  91.         mDrawingState.traverseInZOrder([&](Layer* layer) {
  92.             if (mLayersPendingRemoval.indexOf(layer) >= 0) {
  93.                 // this layer is not visible anymore
  94.                 Region visibleReg;
  95.                 visibleReg.set(layer->getScreenBounds());
  96.                 invalidateLayerStack(layer, visibleReg);
  97.             }
  98.         });
  99.     }
  100.  
  101.  
  102.     doCommitTransactions();
  103.     signalSynchronousTransactions(CountDownLatch::eSyncTransaction);
  104.     mAnimTransactionPending = false;
  105. }

上面方法主要处理如下：

1、调用SurfaceFlinger的processDisplayChangesLocked方法，处理显示器变化相关。

2、调用SurfaceFlinger的doCommitTransactions方法，执行提交事务。

下面分别进行分析：

SurfaceFlinger processDisplayChangesLocked

调用SurfaceFlinger的processDisplayChangesLocked方法：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. void SurfaceFlinger::processDisplayChangesLocked() {
  3.     // here we take advantage of Vector's copy-on-write semantics to
  4.     // improve performance by skipping the transaction entirely when
  5.     // know that the lists are identical
  6.     const KeyedVector<wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
  7.     const KeyedVector<wp<IBinder>, DisplayDeviceState>& draw(mDrawingState.displays);
  8.     if (!curr.isIdenticalTo(draw)) {
  9.         mVisibleRegionsDirty = true;
  10.  
  11.  
  12.         // find the displays that were removed
  13.         // (ie: in drawing state but not in current state)
  14.         // also handle displays that changed
  15.         // (ie: displays that are in both lists)
  16.         for (size_t i = 0; i < draw.size(); i++) {
  17.             const wp<IBinder>& displayToken = draw.keyAt(i);
  18.             const ssize_t j = curr.indexOfKey(displayToken);
  19.             if (j < 0) {
  20.                 // in drawing state but not in current state
  21.                 // 处于绘图状态，但不在当前状态
  22.                 processDisplayRemoved(displayToken);
  23.             } else {
  24.                 // this display is in both lists. see if something changed.
  25.  // 此显示在两个列表中。看看是否有变化。
  26.                 const DisplayDeviceState& currentState = curr[j];
  27.                 const DisplayDeviceState& drawingState = draw[i];
  28.                 processDisplayChanged(displayToken, currentState, drawingState);
  29.             }
  30.         }
  31.  
  32.  
  33.         // find displays that were added
  34.         // 查找已添加的显示
  35.         // (ie: in current state but not in drawing state)
  36.         for (size_t i = 0; i < curr.size(); i++) {
  37.             const wp<IBinder>& displayToken = curr.keyAt(i);
  38.             if (draw.indexOfKey(displayToken) < 0) {
  39.                 processDisplayAdded(displayToken, curr[i]);
  40.             }
  41.         }
  42.     }
  43.  
  44.  
  45.     mDrawingState.displays = mCurrentState.displays;
  46. }

上面方法根据不同的调节调用如下方法：

1、调用processDisplayRemoved方法，处理显示器删除。

2、调用processDisplayChanged方法，处理显示器变更。

3、调用processDisplayAdded方法，处理显示器添加。

下面分别进行分析：

SurfaceFlinger processDisplayRemoved

调用processDisplayRemoved方法，处理显示器删除：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. void SurfaceFlinger::processDisplayRemoved(const wp<IBinder>& displayToken) {
  3.     auto display = getDisplayDeviceLocked(displayToken);
  4.     if (display) {
  5.         display->disconnect(); //与Display断开连接
  6.  
  7.  
  8.         if (display->isVirtual()) {
  9.             releaseVirtualDisplay(display->getVirtualId()); //如果是虚拟显示器，就进行资源释放
  10.         } else {
  11.             dispatchDisplayHotplugEvent(display->getPhysicalId(), false);  //分配显示器热插拔事件
  12.         }
  13.     }
  14.  
  15.  
  16.     mDisplays.erase(displayToken);
  17.  
  18.  
  19.     if (display && display->isVirtual()) {
  20.         static_cast<void>(mScheduler->schedule([display = std::move(display)] {
  21.             // Destroy the display without holding the mStateLock.
  22.             // This is a temporary solution until we can manage transaction queues without
  23.             // holding the mStateLock.
  24.             // With blast, the IGBP that is passed to the VirtualDisplaySurface is owned by the
  25.             // client. When the IGBP is disconnected, its buffer cache in SF will be cleared
  26.             // via SurfaceComposerClient::doUncacheBufferTransaction. This call from the client
  27.             // ends up running on the main thread causing a deadlock since setTransactionstate
  28.             // will try to acquire the mStateLock. Instead we extend the lifetime of
  29.             // DisplayDevice and destroy it in the main thread without holding the mStateLock.
  30.             // The display will be disconnected and removed from the mDisplays list so it will
  31.             // not be accessible.
  32.         }));
  33.     }
  34. }

SurfaceFlinger processDisplayChanged

调用processDisplayChanged方法，处理显示器变更：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. void SurfaceFlinger::processDisplayChanged(const wp<IBinder>& displayToken,
  3.                                            const DisplayDeviceState& currentState,
  4.                                            const DisplayDeviceState& drawingState) {
  5.     const sp<IBinder> currentBinder = IInterface::asBinder(currentState.surface);
  6.     const sp<IBinder> drawingBinder = IInterface::asBinder(drawingState.surface);
  7.  
  8.  
  9.     // Recreate the DisplayDevice if the surface or sequence ID changed.
  10.     // 如果图面或序列 ID 发生更改，请重新创建 DisplayDevice。
  11.     if (currentBinder != drawingBinder || currentState.sequenceId != drawingState.sequenceId) {
  12.         getRenderEngine().cleanFramebufferCache();
  13.  
  14.  
  15.         if (const auto display = getDisplayDeviceLocked(displayToken)) {
  16.             display->disconnect();
  17.             if (display->isVirtual()) {
  18.                 releaseVirtualDisplay(display->getVirtualId());
  19.             }
  20.         }
  21.  
  22.  
  23.         mDisplays.erase(displayToken);
  24.  
  25.  
  26.         if (const auto& physical = currentState.physical) {
  27.             getHwComposer().allocatePhysicalDisplay(physical->hwcDisplayId, physical->id);
  28.         }
  29.  
  30.  
  31.         processDisplayAdded(displayToken, currentState);
  32.  
  33.  
  34.         if (currentState.physical) {
  35.             const auto display = getDisplayDeviceLocked(displayToken);
  36.             setPowerModeInternal(display, hal::PowerMode::ON);
  37.  
  38.  
  39.             // TODO(b/175678251) Call a listener instead.
  40.             if (currentState.physical->hwcDisplayId == getHwComposer().getPrimaryHwcDisplayId()) {
  41.                 updateInternalDisplayVsyncLocked(display);
  42.             }
  43.         }
  44.         return;
  45.     }
  46.  
  47.  
  48.     if (const auto display = getDisplayDeviceLocked(displayToken)) {
  49.         if (currentState.layerStack != drawingState.layerStack) {
  50.             display->setLayerStack(currentState.layerStack); //设置显示器层堆栈
  51.         }
  52.         if (currentState.flags != drawingState.flags) {
  53.             display->setFlags(currentState.flags); //设置显示器标志
  54.         }
  55.         if ((currentState.orientation != drawingState.orientation) ||
  56.             (currentState.layerStackSpaceRect != drawingState.layerStackSpaceRect) ||
  57.             (currentState.orientedDisplaySpaceRect != drawingState.orientedDisplaySpaceRect)) {
  58.             display->setProjection(currentState.orientation, currentState.layerStackSpaceRect,
  59.                                    currentState.orientedDisplaySpaceRect); //设置显示器投影
  60.             if (isDisplayActiveLocked(display)) {
  61.                 mActiveDisplayTransformHint = display->getTransformHint();
  62.             }
  63.         }
  64.         if (currentState.width != drawingState.width ||
  65.             currentState.height != drawingState.height) {
  66.             display->setDisplaySize(currentState.width, currentState.height); //设置显示器尺寸
  67.  
  68.  
  69.             if (isDisplayActiveLocked(display)) {
  70.                 onActiveDisplaySizeChanged(display);
  71.             }
  72.         }
  73.     }
  74. }

SurfaceFlinger processDisplayAdded

调用processDisplayAdded方法，处理显示器添加：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. void SurfaceFlinger::processDisplayAdded(const wp<IBinder>& displayToken,
  3.                                          const DisplayDeviceState& state) {
  4.     ui::Size resolution(0, 0);
  5.     ui::PixelFormat pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_UNKNOWN);
  6.     if (state.physical) {
  7.         resolution = state.physical->activeMode->getResolution();
  8.         pixelFormat = static_cast<ui::PixelFormat>(PIXEL_FORMAT_RGBA_8888);
  9.     } else if (state.surface != nullptr) {
  10.         int status = state.surface->query(NATIVE_WINDOW_WIDTH, &resolution.width);
  11.         ALOGE_IF(status != NO_ERROR, "Unable to query width (%d)", status);
  12.         status = state.surface->query(NATIVE_WINDOW_HEIGHT, &resolution.height);
  13.         ALOGE_IF(status != NO_ERROR, "Unable to query height (%d)", status);
  14.         int format;
  15.         status = state.surface->query(NATIVE_WINDOW_FORMAT, &format);
  16.         ALOGE_IF(status != NO_ERROR, "Unable to query format (%d)", status);
  17.         pixelFormat = static_cast<ui::PixelFormat>(format);
  18.     } else {
  19.         // Virtual displays without a surface are dormant:
  20.         // they have external state (layer stack, projection,
  21.         // etc.) but no internal state (i.e. a DisplayDevice).
  22.         return;
  23.     }
  24.  
  25.  
  26.     compositionengine::DisplayCreationArgsBuilder builder;
  27.     if (const auto& physical = state.physical) {
  28.         builder.setId(physical->id);
  29.     } else {
  30.         builder.setId(acquireVirtualDisplay(resolution, pixelFormat));
  31.     }
  32.  
  33.  
  34.     builder.setPixels(resolution);
  35.     builder.setIsSecure(state.isSecure);
  36.     builder.setPowerAdvisor(mPowerAdvisor.get());
  37.     builder.setName(state.displayName);
  38.     auto compositionDisplay = getCompositionEngine().createDisplay(builder.build());
  39.     compositionDisplay->setLayerCachingEnabled(mLayerCachingEnabled);
  40.  
  41.  
  42.     sp<compositionengine::DisplaySurface> displaySurface;
  43.     sp<IGraphicBufferProducer> producer;
  44.     sp<IGraphicBufferProducer> bqProducer;
  45.     sp<IGraphicBufferConsumer> bqConsumer;
  46.     getFactory().createBufferQueue(&bqProducer, &bqConsumer, /*consumerIsSurfaceFlinger =*/false);
  47.  
  48.  
  49.     if (state.isVirtual()) {
  50.         const auto displayId = VirtualDisplayId::tryCast(compositionDisplay->getId());
  51.         LOG_FATAL_IF(!displayId);
  52.         auto surface = sp<VirtualDisplaySurface>::make(getHwComposer(), *displayId, state.surface,
  53.                                                        bqProducer, bqConsumer, state.displayName);
  54.         displaySurface = surface;
  55.         producer = std::move(surface);
  56.     } else {
  57.         ALOGE_IF(state.surface != nullptr,
  58.                  "adding a supported display, but rendering "
  59.                  "surface is provided (%p), ignoring it",
  60.                  state.surface.get());
  61.         const auto displayId = PhysicalDisplayId::tryCast(compositionDisplay->getId());
  62.         LOG_FATAL_IF(!displayId);
  63.         displaySurface =
  64.                 sp<FramebufferSurface>::make(getHwComposer(), *displayId, bqConsumer,
  65.                                              state.physical->activeMode->getResolution(),
  66.                                              ui::Size(maxGraphicsWidth, maxGraphicsHeight));
  67.         producer = bqProducer;
  68.     }
  69.  
  70.  
  71.     LOG_FATAL_IF(!displaySurface);
  72.     auto display = setupNewDisplayDeviceInternal(displayToken, std::move(compositionDisplay), state,
  73.                                                  displaySurface, producer);
  74.     if (display->isPrimary()) {
  75.         initScheduler(display);
  76.     }
  77.     if (!state.isVirtual()) {
  78.         dispatchDisplayHotplugEvent(display->getPhysicalId(), true);
  79.     }
  80.  
  81.  
  82.     mDisplays.try_emplace(displayToken, std::move(display));
  83. }

SurfaceFlinger doCommitTransactions

调用SurfaceFlinger的doCommitTransactions方法：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. void SurfaceFlinger::doCommitTransactions() {
  3.     ATRACE_CALL();
  4.  
  5.  
  6.     if (!mLayersPendingRemoval.isEmpty()) {
  7.         // Notify removed layers now that they can't be drawn from
  8.         for (const auto& l : mLayersPendingRemoval) {
  9.             // Ensure any buffers set to display on any children are released.
  10.             if (l->isRemovedFromCurrentState()) {
  11.                 l->latchAndReleaseBuffer();
  12.             }
  13.  
  14.  
  15.             // If a layer has a parent, we allow it to out-live it's handle
  16.             // with the idea that the parent holds a reference and will eventually
  17.             // be cleaned up. However no one cleans up the top-level so we do so
  18.             // here.
  19.             if (l->isAtRoot()) {
  20.                 l->setIsAtRoot(false);
  21.                 mCurrentState.layersSortedByZ.remove(l);
  22.             }
  23.  
  24.  
  25.             // If the layer has been removed and has no parent, then it will not be reachable
  26.             // when traversing layers on screen. Add the layer to the offscreenLayers set to
  27.             // ensure we can copy its current to drawing state.
  28.             if (!l->getParent()) {
  29.                 mOffscreenLayers.emplace(l.get());
  30.             }
  31.         }
  32.         mLayersPendingRemoval.clear();
  33.     }
  34.  
  35.  
  36.     // If this transaction is part of a window animation then the next frame
  37.     // we composite should be considered an animation as well.
  38.     //最关键mCurrentState赋值给了mDrawingState
  39.     mAnimCompositionPending = mAnimTransactionPending;
  40.  
  41.  
  42.     mDrawingState = mCurrentState;
  43.     // clear the "changed" flags in current state
  44.     mCurrentState.colorMatrixChanged = false;
  45.  
  46.  
  47.     if (mVisibleRegionsDirty) {
  48.         for (const auto& rootLayer : mDrawingState.layersSortedByZ) {
  49.             rootLayer->commitChildList();
  50.         }
  51.     }
  52.  
  53.  
  54.     commitOffscreenLayers();
  55.     if (mNumClones > 0) {
  56.         mDrawingState.traverse([&](Layer* layer) { layer->updateMirrorInfo(); });
  57.     }
  58. }

SurfaceFlinger latchBuffers

调用SurfaceFlinger的latchBuffers方法，将应用程序的图形缓冲区（buffer）与显示器进行关联：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. bool SurfaceFlinger::latchBuffers() {
  3.     ATRACE_CALL();
  4.  
  5.  
  6.     const nsecs_t latchTime = systemTime();
  7.  
  8.  
  9.     bool visibleRegions = false;
  10.     bool frameQueued = false;
  11.     bool newDataLatched = false;
  12.  
  13.  
  14.     const nsecs_t expectedPresentTime = mExpectedPresentTime.load();
  15.  
  16.  
  17.     // Store the set of layers that need updates. This set must not change as
  18.     // buffers are being latched, as this could result in a deadlock.
  19.     // Example: Two producers share the same command stream and:
  20.     // 1.) Layer 0 is latched
  21.     // 2.) Layer 0 gets a new frame
  22.     // 2.) Layer 1 gets a new frame
  23.     // 3.) Layer 1 is latched.
  24.     // Display is now waiting on Layer 1's frame, which is behind layer 0's
  25.     // second frame. But layer 0's second frame could be waiting on display.
  26.     mDrawingState.traverse([&](Layer* layer) {
  27.         if (layer->clearTransactionFlags(eTransactionNeeded) || mForceTransactionDisplayChange) {
  28.             const uint32_t flags = layer->doTransaction(0);
  29.             if (flags & Layer::eVisibleRegion) {
  30.                 mVisibleRegionsDirty = true;
  31.             }
  32.         }
  33.  
  34.  
  35.  //判断是否有buffer
  36.         if (layer->hasReadyFrame()) {
  37.             frameQueued = true;
  38.      //是否应该显示
  39.             if (layer->shouldPresentNow(expectedPresentTime)) {
  40.   //如果要显示放入到mLayersWithQueuedFrames队列
  41.                 mLayersWithQueuedFrames.emplace(layer);
  42.             } else {
  43.                 ATRACE_NAME("!layer->shouldPresentNow()");
  44.                 layer->useEmptyDamage();
  45.             }
  46.         } else {
  47.             layer->useEmptyDamage();
  48.         }
  49.     });
  50.     //上面主要是为了从sf的mDrawingState遍历寻找出有buffer的layer
  51.  
  52.  
  53.     mForceTransactionDisplayChange = false;
  54.  
  55.  
  56.     // The client can continue submitting buffers for offscreen layers, but they will not
  57.     // be shown on screen. Therefore, we need to latch and release buffers of offscreen
  58.     // layers to ensure dequeueBuffer doesn't block indefinitely.
  59.     for (Layer* offscreenLayer : mOffscreenLayers) {
  60.         offscreenLayer->traverse(LayerVector::StateSet::Drawing,
  61.                                          [&](Layer* l) { l->latchAndReleaseBuffer(); });
  62.     }
  63.  
  64.  
  65.     //如果buffer队列不为空
  66.     if (!mLayersWithQueuedFrames.empty()) {
  67.         // mStateLock is needed for latchBuffer as LayerRejecter::reject()
  68.         // writes to Layer current state. See also b/119481871
  69.         Mutex::Autolock lock(mStateLock);
  70.  
  71.  
  72.         for (const auto& layer : mLayersWithQueuedFrames) {
  73.      //进行关键的latchBuffer操作,然后newDataLatched设置成了true
  74.             if (layer->latchBuffer(visibleRegions, latchTime, expectedPresentTime)) {
  75.                 mLayersPendingRefresh.push_back(layer); /这里有latchBuffer说明有buffer刷新，放入mLayersPendingRefresh
  76.                 newDataLatched = true;
  77.             }
  78.             layer->useSurfaceDamage();
  79.         }
  80.     }
  81.  
  82.  
  83.     mVisibleRegionsDirty |= visibleRegions;
  84.  
  85.  
  86.     // If we will need to wake up at some time in the future to deal with a
  87.     // queued frame that shouldn't be displayed during this vsync period, wake
  88.     // up during the next vsync period to check again.
  89.     if (frameQueued && (mLayersWithQueuedFrames.empty() || !newDataLatched)) {
  90.         scheduleCommit(FrameHint::kNone);
  91.     }
  92.  
  93.  
  94.     // enter boot animation on first buffer latch
  95.     if (CC_UNLIKELY(mBootStage == BootStage::BOOTLOADER && newDataLatched)) {
  96.         ALOGI("Enter boot animation");
  97.         mBootStage = BootStage::BOOTANIMATION;
  98.     }
  99.  
  100.  
  101.     if (mNumClones > 0) {
  102.         mDrawingState.traverse([&](Layer* layer) { layer->updateCloneBufferInfo(); });
  103.     }
  104.  
  105.  
  106.     // Only continue with the refresh if there is actually new work to do
  107.     return !mLayersWithQueuedFrames.empty() && newDataLatched;
  108. }

BufferLayer latchBuffer

调用layer的latchBuffer方法：

  1. //frameworks/native/services/surfaceflinger/BufferLayer.cpp
  2. bool BufferLayer::latchBuffer(bool& recomputeVisibleRegions, nsecs_t latchTime,
  3.                               nsecs_t expectedPresentTime) {
  4.     ATRACE_CALL();
  5.  
  6.  
  7.     bool refreshRequired = latchSidebandStream(recomputeVisibleRegions);
  8.  
  9.  
  10.     if (refreshRequired) {
  11.         return refreshRequired;
  12.     }
  13.  
  14.  
  15.     // If the head buffer's acquire fence hasn't signaled yet, return and
  16.     // try again later
  17.     // 如果头部缓冲区的采集围栏尚未发出信号，请返回并稍后重试
  18.     if (!fenceHasSignaled()) {
  19.         ATRACE_NAME("!fenceHasSignaled()");
  20.         mFlinger->onLayerUpdate(); // (692) SurfaceFlinger onLayerUpdate流程分析 | 知识管理 - PingCode 
  21.         return false;
  22.     }
  23.  
  24.  
  25.     // Capture the old state of the layer for comparisons later
  26.     const State& s(getDrawingState());
  27.     const bool oldOpacity = isOpaque(s);
  28.  
  29.  
  30.     BufferInfo oldBufferInfo = mBufferInfo;
  31.  
  32.  
  33.     //调用到BufferStateLayer中的updateTexImage，这里业务主要返回对应的recomputeVisibleRegions
  34.     status_t err = updateTexImage(recomputeVisibleRegions, latchTime, expectedPresentTime);
  35.     if (err != NO_ERROR) {
  36.         return false;
  37.     }
  38.  
  39.  
  40.     //这里主要吧state的相关buffer数据赋值给mBufferInfo
  41.     err = updateActiveBuffer();
  42.     if (err != NO_ERROR) {
  43.         return false;
  44.     }
  45.  
  46.  
  47.     //赋值一下framenumber
  48.     err = updateFrameNumber();
  49.     if (err != NO_ERROR) {
  50.         return false;
  51.     }
  52.  
  53.  
  54.     //这里又一次吧mDrawingState中BufferInfo需要的大部分数据进行赋值
  55.     gatherBufferInfo();
  56.  
  57.  
  58.     if (oldBufferInfo.mBuffer == nullptr) {
  59.         // the first time we receive a buffer, we need to trigger a
  60.         // geometry invalidation.
  61.         recomputeVisibleRegions = true;
  62.     }
  63.  
  64.  
  65.     if ((mBufferInfo.mCrop != oldBufferInfo.mCrop) ||
  66.         (mBufferInfo.mTransform != oldBufferInfo.mTransform) ||
  67.         (mBufferInfo.mScaleMode != oldBufferInfo.mScaleMode) ||
  68.         (mBufferInfo.mTransformToDisplayInverse != oldBufferInfo.mTransformToDisplayInverse)) {
  69.         recomputeVisibleRegions = true;
  70.     }
  71.  
  72.  
  73.     if (oldBufferInfo.mBuffer != nullptr) {
  74.         uint32_t bufWidth = mBufferInfo.mBuffer->getWidth();
  75.         uint32_t bufHeight = mBufferInfo.mBuffer->getHeight();
  76.         if (bufWidth != oldBufferInfo.mBuffer->getWidth() ||
  77.             bufHeight != oldBufferInfo.mBuffer->getHeight()) {
  78.             recomputeVisibleRegions = true;
  79.         }
  80.     }
  81.  
  82.  
  83.     if (oldOpacity != isOpaque(s)) {
  84.         recomputeVisibleRegions = true;
  85.     }
  86.  
  87.  
  88.     return true;
  89. }

BufferQueueLayer updateTexImage

调用BufferLayer的updateTexImage方法，BufferQueueLayer继承与于BufferLayer，调用BufferQueueLayer的updateTexImage方法：

Android13 BufferQueueLayer updateTexImage流程分析-CSDN博客

SurfaceFlinger updateLayerGeometry

调用SurfaceFlinger的updateLayerGeometry方法，这次vsync显示刷新的layer进行脏区设置：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. void SurfaceFlinger::updateLayerGeometry() {
  3.     ATRACE_CALL();
  4.  
  5.  
  6.     if (mVisibleRegionsDirty) {
  7.         computeLayerBounds(); //触发各个layer计算对于的bound
  8.     }
  9.  
  10.  
  11.     //前面有buffer的集合mLayersPendingRefresh进行对应display的dirtyRegion更新
  12.     for (auto& layer : mLayersPendingRefresh) {
  13.         Region visibleReg;
  14.         visibleReg.set(layer->getScreenBounds());
  15.         invalidateLayerStack(layer, visibleReg); //刷新一下display的dirtyRegion
  16.     }
  17.     mLayersPendingRefresh.clear();
  18. }

SurfaceFlinger invalidateLayerStack

调用SurfaceFlinger的invalidateLayerStack方法：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. void SurfaceFlinger::invalidateLayerStack(const sp<const Layer>& layer, const Region& dirty) {
  3.     for (const auto& [token, displayDevice] : FTL_FAKE_GUARD(mStateLock, mDisplays)) {
  4.         auto display = displayDevice->getCompositionDisplay();
  5.         if (display->includesLayer(layer->getOutputFilter())) { //寻找到对应的display
  6.             display->editState().dirtyRegion.orSelf(dirty); //设置到了display->editState中
  7.         }
  8.     }
  9. }

上面主要就是干了一件事，根据这次有buffer的Layer进行遍历，刷新对应display的dirtyRegion。

SurfaceFlinger updateInputFlinger

调用SurfaceFlinger的updateInputFlinger方法，更新输入处理：

  1. //frameworks/native/services/surfaceflinger/Surfaceflinger.cpp
  2. void SurfaceFlinger::updateInputFlinger() {
  3.     ATRACE_CALL();
  4.     if (!mInputFlinger) {
  5.         return;
  6.     }
  7.  
  8.  
  9.     std::vector<WindowInfo> windowInfos;
  10.     std::vector<DisplayInfo> displayInfos;
  11.     bool updateWindowInfo = false;
  12.     if (mVisibleRegionsDirty || mInputInfoChanged) {
  13.         mInputInfoChanged = false;
  14.         updateWindowInfo = true;
  15.  //进行遍历整个系统的layer和display转变成windowInfos，displayInfos信息
  16.         buildWindowInfos(windowInfos, displayInfos);
  17.     }
  18.     if (!updateWindowInfo && mInputWindowCommands.empty()) {
  19.         return;
  20.     }
  21.     //这里放入子线程进行相对应跨进程通讯
  22.     BackgroundExecutor::getInstance().sendCallbacks({[updateWindowInfo,
  23.                                                       windowInfos = std::move(windowInfos),
  24.                                                       displayInfos = std::move(displayInfos),
  25.                                                       inputWindowCommands =
  26.                                                               std::move(mInputWindowCommands),
  27.                                                       inputFlinger = mInputFlinger, this]() {
  28.         ATRACE_NAME("BackgroundExecutor::updateInputFlinger");
  29.         if (updateWindowInfo) {
  30.      //这里调用是mWindowInfosListenerInvoker进行的windowInfos, displayInfos进行跨进程传递
  31.             mWindowInfosListenerInvoker->windowInfosChanged(windowInfos, displayInfos,
  32.                                                             inputWindowCommands.syncInputWindows);
  33.         } else if (inputWindowCommands.syncInputWindows) {
  34.             // If the caller requested to sync input windows, but there are no
  35.             // changes to input windows, notify immediately.
  36.             windowInfosReported();
  37.         }
  38.         for (const auto& focusRequest : inputWindowCommands.focusRequests) {
  39.      //直接调用inputFlinger的bpbinder跨进程设置setFocusedWindow
  40.             inputFlinger->setFocusedWindow(focusRequest);
  41.         }
  42.     }});
  43.  
  44.  
  45.     mInputWindowCommands.clear();
  46. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/木道寻08/article/detail/825174
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号