App的启动过程（10）surfaceflinger对数据合成，送显

以你之姓@ 2022-06-15 11:26 483阅读 0赞

下面就是SurfaceFlinger执行实际的数据合成，然后刷新到屏幕上。

voidSurfaceFlinger::onMessageReceived(int32\_t what) \{

switch(what) \{

case MessageQueue::INVALIDATE: \{

bool refreshNeeded =handleMessageTransaction();

refreshNeeded |=handleMessageInvalidate();

refreshNeeded |=mRepaintEverything;

if (refreshNeeded) \{ signalRefresh();\}

Break;

case MessageQueue::REFRESH: \{

handleMessageRefresh();

break;

上面是surfaceflinger收到vsync时的处理代码，signalRefresh跟handleMessageRefresh是一样的，所以INVALIDATE比REFRESH多了两个函数：handleMessageTransaction（对layer属性变更的处理）和handleMessageInvalidate（数据的刷新），在看handleMessageRefresh包含了那些工作：

void SurfaceFlinger::handleMessageRefresh()\{

preComposition();//合成前的准备

rebuildLayerStacks();//重建layer堆栈

setUpHWComposer();//hwcomposer的设定

doComposition();//正式的合成处理

postComposition(refreshStartTime);//合成后期的处理

整个UI的就是上面handleMessageRefresh中几个函数，加上INVALIDATE中那两个函数。

Step1，handleMessageTransaction

handleMessageTransaction真正处理业务的地方是handleTransactionLocked。

voidSurfaceFlinger::handleTransactionLocked(uint32\_t transactionFlags)\{

if(transactionFlags & eTraversalNeeded) \{

for(size\_t i=0 ; i<count ; i++) \{

const uint32\_t flags = layer->doTransaction(0); \}

commitTransaction();

transactionFlags有多个类别，这里以eTraversalNeeded为例，首先会循环判断每个layer是否要doTransaction，如果需要就调用layer->doTransaction由各layer做内部处理。

uint32\_t Layer::doTransaction(uint32\_tflags) \{

//尺寸发生变化，调用setDefaultBufferSize使它生效，SurfaceFlingerConsumer，可以这样理解：surfaceflinger作为buffer的消费者，并没有直接管理Buffer，surfaceflinger直接拥有的是跟存储“图层数据”有关的layer，而layer也没有直接持有ＢｕｆｆｅｒＱｕｅｕｅ对象，而是通过SurfaceFlingerConsumer来管理，

if(sizeChanged) \{

mSurfaceFlingerConsumer->setDefaultBufferSize(c.requested.w,c.requested.h); \}

//重新计算可见区域，这个要作为flags传给surfaceflinger统一部署

if(s.active != c.active) \{

flags |= Layer::eVisibleRegion; \}

//当layer的position，z-order，transparentregion，crop等属性变化时，mCurrentState：：Sequence的值就会递增，在doTransaction时，它和mDrawingState::sequence的值就不一样了，它在平时收集属性的变化，到vsync信号产生时做统一处理。mCurrentState和mDrawingState分别表示当前的状态和上一次drawing时的状态。Surfaceflinger中也有两个这样的变量，但是数据结构不同，surfaceflinger中的mCurrentState，内部包含了一个变量：LayerVector layersSortedByZ;记录了所有按Z-order顺序排列的layers。

if(c.sequence != s.sequence) \{

this->contentDirty = true; \}

//把mCurrentState赋值给mDrawingState,

commitTransaction(c);

完成所有layer的遍历后，返回到handleTransactionLocked，

voidSurfaceFlinger::handleTransactionLocked(uint32\_t transactionFlags)\{

//有新增的layer，可见区域要重新计算，同样还有移除layer的处理

if(currentLayers.size() > layers.size()) \{

mVisibleRegionsDirty= true;\}

//结束业务处理，会回调被移除layer的onRemoved()，最后通过mTransactionCV.broadcast();唤醒等待Transaction结束的线程，如应用进程中的处理surface跟新的线程、surfaceflinger中的显示线程。

commitTransaction();

Step2,handleMessageInvalidate--界面重新绘制，这个函数处理bufferQueue相关的工作。

bool SurfaceFlinger::handleMessageInvalidate()\{

returnhandlePageFlip();

bool SurfaceFlinger::handlePageFlip()\{

//锁定一个buffer，也就是每个layer当前要处理的缓冲区

const Regiondirty(layer->latchBuffer(visibleRegions));

//更新displayDevice中的脏区域

invalidateLayerStack(s.layerStack,dirty);

Region Layer::latchBuffer(bool&recomputeVisibleRegions)\{

if(mQueuedFrames > 0 || mAutoRefresh) \{

status\_t updateResult =mSurfaceFlingerConsumer->updateTexImage(&r,

mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer,

mLastFrameNumberReceived);

mFlinger->signalLayerUpdate();

mActiveBuffer= mSurfaceFlingerConsumer->getCurrentBuffer();

status\_tSurfaceFlingerConsumer::updateTexImage(...)\{

err =acquireBufferLocked(&item, computeExpectedPresent(dispSync),...);

前面说过，当应用进程填充好一块buffer后，会通过BufferQueue的方法queue把这个bufferslot入队，同时BufferQueue会调用onFrameAvailable通知消费者有一帧数据准备好了，可以消费了，继承FrameAvailableListener这个监听的消费者\--layer的方法onFrameAvailable就会被调用，这个函数会增加mQueuedFrames的计数，也会向surfaceflinger发去一个invalidate信号。Layer对BufferQueue的管理是通过SurfaceFlingerConsumer实现的，这个消费者想要操作一块buffer，要先accquire它，这个操作封装在mSurfaceFlingerConsumer->updateTexImage()中，accquire到的buffer封装在BufferItem中，如果有多个mQueuedFrames，还会通过signalLayerUpdate组织一次新的invalidate，最后更新当前活跃的缓冲区mActiveBuffer。

Step3,预合成\--合成前的准备，preComposition

void SurfaceFlinger::preComposition()｛

const LayerVector& layers(mDrawingState.layersSortedByZ);

for (size\_t i=0 ; i<count ; i++) \{

if (layers\[i\]->onPreComposition()) \{

needExtraInvalidate = true;｝

if (needExtraInvalidate) \{

signalLayerUpdate();｝

｝

首先得到当前所有layer的集合，然后调用每个layer的预合成接口onPreComposition，只要有一个layer中存在被Queued的Frames，即mQueuedFrames>0，那么needExtraInvalidate就会变成true，最后触发signalLayerUpdate()调用，通过EventThread安排一次vsync。

Step4，计算可见layer及它们的可见区域—rebuildLayerStacks

void SurfaceFlinger::rebuildLayerStacks() \{

//当前所有的layers都是通过mDrawingState.layersSortedByZ来记录的，每个layer都有一个layerStack来区别它属于哪个Display。

constLayerVector& layers(mDrawingState.layersSortedByZ);

//系统的Display可能不止一个，都存储在mDisplays中，逐个处理这些Display。

for(size\_t dpy=0 ; dpy<mDisplays.size() ; dpy++) \{

if(hw->isDisplayOn()) \{

//根据所有layers的当前状态，计算dirtyRegion—需要重新绘制的区域，opaqueRegion—不透明区域。

computeVisibleRegions(hw->getHwcDisplayId(),layers,

hw->getLayerStack(),dirtyRegion, opaqueRegion);\}

for(size\_t i=0 ; i<count ; i++) \{

constsp<Layer>& layer(layers\[i\]);

//把需要绘制的layer添加到layersSortedByZ中。

layersSortedByZ.add(layer);

Step5，为合成搭建环境—setUpHWComposer

把需要显示的那些layer的数据准备好，报给Hwc模块来决定由谁进行最终的合成工作。

void SurfaceFlinger::setUpHWComposer() \{

//这个HWComposer并不是真正的Hal模块，而是surfaceflinger为管理HWComposer模块而设计的一个类，路径是：frameworks/native/service/surfaceflinger/displayhardware/。 HWComposer& hwc(getHwComposer());

//依次处理各个Display，构造WorkList，

for(size\_t dpy=0 ; dpy<mDisplays.size() ; dpy++) \{

sp<const DisplayDevice> hw(mDisplays\[dpy\]);

const int32\_t id = hw->getHwcDisplayId();

const Vector< sp<Layer> >&currentLayers(hw->getVisibleLayersSortedByZ());

const size\_t count = currentLayers.size();

if (hwc.createWorkList(id, count) == NO\_ERROR) \{…\}

//填充各个layer的数据，由每个layer自己完成。

layer->setPerFrameData(hw,\*cur);

//合成过程既可以有Hwc模块完成，也可以通过OpengGlEs来完成，具体用哪种方式是有prepare()中的compositionType来决定的。

status\_t err =hwc.prepare();

Step6，执行合成、显示到屏幕上—doComposition

void SurfaceFlinger::doComposition() \{

//逐个Display去处理，对每个DisplayDevice，需要单独调用doDisplayComposition。

for(size\_t dpy=0 ; dpy<mDisplays.size() ; dpy++) \{

doDisplayComposition(hw,dirtyRegion);

//通知hwc合成已经完成。

hw->compositionComplete();

postFramebuffer();

void SurfaceFlinger::doDisplayComposition(…)\{

//相关layer的数据合成。

doComposeSurfaces(hw,dirtyRegion);

//交换前后台数据，将UI数据显示到屏幕上的关键是eglSwapBuffers。

hw->swapBuffers(getHwComposer());àeglSwapBuffers(mDisplay, mSurface);

bool SurfaceFlinger::doComposeSurfaces(…)\{

boolhasGlesComposition = hwc.hasGlesComposition(id);

//需要openglEs合成，通过makeCurrent设置当前的渲染环境。

if(hasGlesComposition) \{

hw->makeCurrent(mEGLDisplay,mEGLContext);

//需要Hwc执行合成layer，hasHwcComposition跟hasGlesComposition不是互斥的，他们有可能同时为true，这种情况说明既有要OpengGlES处理的layer，也有要Hwc处理的layer。对layer的处理：layer->draw(hw, clip)àLayer::onDraw();

constbool hasHwcComposition = hwc.hasHwcComposition(id) ||

isS3DLayerPresent(hw);

if(hasHwcComposition) \{

engine.clearWithColor(0,0, 0, 0);\}

// doComposition的最后调用了这个函数，核心功能是调用Hwc模块的hal接口set，把那些需要hwc处理的layer的数据传给hwc做实际的处理，set的内部也调用了eglSwapBuffers。

void SurfaceFlinger::postFramebuffer()\{

hwc.commit();àmHwc->set(mHwc, mNumDisplays, mLists);