Android 7.1 GUI系统-vsync信号的处理（六）

我就是我 2022-06-04 03:19 268阅读 0赞

一旦有事件发生，MessageQueue::cb\_eventReceiver就会执行，进一步调用eventReceiver，如果事件类型是DisplayEventReceiver::DISPLAY\_EVENT\_VSYNC，开始处理UI数据的合成。

MessageQueue.cpp

int MessageQueue::cb_eventReceiver(int fd, int events, void* data) {
        MessageQueue* queue = reinterpret_cast<MessageQueue *>(data);
        return queue->eventReceiver(fd, events);
    }

int MessageQueue::eventReceiver(int /*fd*/, int /*events*/) {
        ssize_t n;
        DisplayEventReceiver::Event buffer[8];
        while ((n = DisplayEventReceiver::getEvents(mEventTube, buffer, 8)) > 0) {
            for (int i=0 ; i<n ; i++) {
                if (buffer[i].header.type == DisplayEventReceiver::DISPLAY_EVENT_VSYNC) {
                    mHandler->dispatchInvalidate();
                    break;
                }
            }
        }
        return 1;
    }

dispatchInvalidate会发出MessageQueue::INVALIDATE消息，然后触发surfaceflinger的onMessageReceived。

void SurfaceFlinger::onMessageReceived(int32_t what) {
        switch (what) {
            case MessageQueue::INVALIDATE: {
                bool refreshNeeded = handleMessageTransaction();
                refreshNeeded |= handleMessageInvalidate();
                refreshNeeded |= mRepaintEverything;
                if (refreshNeeded) {
                    // Signal a refresh if a transaction modified the window state,
                    // a new buffer was latched, or if HWC has requested a full
                    // repaint
                    signalRefresh();
                }
                break;
            }
            case MessageQueue::REFRESH: {
                handleMessageRefresh();
                break;
            }
        }
    }

在onMessageReceived中，除了INVALIDATE，还有REFRESH，什么时候会收到MessageQueue::REFRESH消息呢？一种情况就是signalRefresh()的调用，会发出MessageQueue::REFRESH消息，所以INVALIDATE可能包含了REFRESH，比REFRESH多执行了handleMessageTransaction，handleMessageInvalidate，mRepaintEverything这几个函数，这几个函数的返回值，也决定了会不会去触发signalRefresh()的调用。

所以先看这几个函数都做了什么事情，然后在分析handleMessageRefresh()做了什么事情。

1），handleMessageTransaction()，调用了handleTransaction(transactionFlags);真正处理事务的地方是handleTransactionLocked(transactionFlags);

void SurfaceFlinger::handleTransaction(uint32_t transactionFlags){
    	Mutex::Autolock _l(mStateLock);
    	handleTransactionLocked(transactionFlags);
    //这个值会在build the h/w work list时用到。
    	mHwWorkListDirty = true;
    }

在调用handleTransactionLocked前，获取了mStateLock，保证在transaction提交之前，mCurrentState的不会被改变。

void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags){
    // mCurrentState记录了系统中layers的状态，这个变量表示当前的状态，还有一个变量mDrawingState表示上一次drawing时的状态。其中的 layersSortedByZ成员变量保存的是按顺序排列的所有的layers。
    	const LayerVector& currentLayers(mCurrentState.);
    	const size_t count = currentLayers.size();
    	if (transactionFlags & eTraversalNeeded) {
    //step1，遍历所有的layers，看其是否需要 doTransaction，这个判断的依据是 getTransactionFlags返回值，只要一个layers的位置、大小、可见度、Matrix等属性发生了变化，这个函数返回值都是true。
    		for (size_t i=0 ; i<count ; i++) {
    			const sp<Layer>& layer(currentLayers[i]);
    			uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
    			if (!trFlags) continue;
    			const uint32_t flags = layer→doTransaction(0);
    //当可见区域发生变化时，用 mVisibleRegionsDirty备注下。
    			if (flags & Layer::eVisibleRegion){
    				mVisibleRegionsDirty = true;
    			}
    		}
    	}
    
    	if (transactionFlags & eDisplayTransactionNeeded) {
    		const KeyedVector<  wp<IBinder>, DisplayDeviceState>& curr(mCurrentState.displays);
    		const KeyedVector<  wp<IBinder>, DisplayDeviceState>& 			
    			draw(mDrawingState.displays);
    //判断displays是否有增加、移除，如果curr 、draw 这个两个向量是相等的，displays就没有变化。否则，如果在draw中有，在curr中没有，就要找出被移除的displays；如果在curr中有，在draw中没有，就要找到添加的displays。
    		if (!curr.isIdenticalTo(draw)) {
    			const ssize_t j = curr.indexOfKey(draw.keyAt(i));
    			if (draw.indexOfKey(curr.keyAt(i)) < 0) {}
    		}
    	}
    
    //新增layer，当前的layer数量增加了，重新计算可见区域。
    	const LayerVector& layers(mDrawingState.layersSortedByZ);
    	if (currentLayers.size() > layers.size()) {
    		mVisibleRegionsDirty = true;
    	}
    //layer被移除了，原来被其遮挡的区域可能需要重新显示，所以需要重新计算可见区域。
    	if (mLayersRemoved) {
    		mVisibleRegionsDirty = true;
    		const Layer::State& s(layer->getDrawingState());
    		Region visibleReg = s.active.transform.transform(
    			Region(Rect(s.active.w, s.active.h)));
    		invalidateLayerStack(s.layerStack, visibleReg);
    	}
    //提交事务，一方面调用被移除layer的回调函数onRemoved()，另一方面mDrawingState = mCurrentState，这样他们的状态就又一样了，最后通过mTransactionCV.broadcast()唤醒在等待Transaction结束的线程。
    	commitTransaction();
    }

每个layer的doTransaction()都做了什么事情呢？

uint32_t Layer::doTransaction(uint32_t flags) @Layer.cpp{
    //layer中也有两个变量mCurrentState，mDrawingState跟surfaceflinger中变量名字一样，数据结构完全不同，表示的意义相同，一个是当前的状态，一个是上一次drawing的状态。
    	Layer::State c = getCurrentState();
    	const Layer::State& s(getDrawingState());
    //如果尺寸有变化，需要告诉客户端申请一个新的buffer，通过 setDefaultBufferSize记录这个新的尺寸，当客户端申请一个buffer时，就会使用这个新的尺寸。
    	 const bool sizeChanged = (c.requested.w != s.requested.w) ||
    		(c.requested.h != s.requested.h);
    	if (sizeChanged) {
    		mSurfaceFlingerConsumer->setDefaultBufferSize(
    			c.requested.w, c.requested.h);
    	}
    //active中包含w、h、transform属性，如果active不同了，也要重新计算可见区域。
    	if (s.active != c.active) {
    		flags |= Layer::eVisibleRegion;
    	}
    //sequence的值在每一个属性（position，size，alpha，flags，crop等）变化时都会自增，
    	if (c.sequence != s.sequence) {
    		flags |= eVisibleRegion;
    		this->contentDirty = true;
    	}
    //提交transaction，就是把mCurrentState赋值给mDrawingState，让两个状态又保持一样。
    	commitTransaction(c);
    	return flags;
    }

2），handleMessageInvalidate，界面无效了需要重绘。

bool SurfaceFlinger::handleMessageInvalidate() @SurfaceFlinger_hwc1.cpp{
        return handlePageFlip();
    }

直接调用了handlePageFlip()，

bool SurfaceFlinger::handlePageFlip(){
    	const LayerVector& layers(mDrawingState.layersSortedByZ);
    //layer跟图层缓冲区buffer有关系的，layer间接继承了FrameAvailableListener（通过SurfaceFlingerConsumer的内部类ContentsChangedListener继承的），监听onFrameAvailable这个回调，当bufferqueue中一个bufferslot被应用进程填充好之后会被queued，这时会通知这个Listener，并增加mQueuedFrames的计数，判断是否有QueuedFrame的函数 hasQueuedFrame()就是根据这个mQueuedFrames是否大于0；
    	Vector<Layer*> layersWithQueuedFrames;
    	for (size_t i = 0, count = layers.size(); i<count ; i++) {
    		const sp<Layer>& layer(layers[i]);
    		if (layer->hasQueuedFrame()) {
    			frameQueued = true;
    			layersWithQueuedFrames.push_back(layer.get());
    		}
    	}
    
    //循环处理有queued frame的layer，通过latchBuffer锁住这个layer要处理的缓冲区。
    	for (size_t i = 0, count = layersWithQueuedFrames.size() ; i<count ; i++) {
    		Layer* layer = layersWithQueuedFrames[i];
    		const Region dirty(layer->latchBuffer(visibleRegions));
    		invalidateLayerStack(s.layerStack, dirty);
    	}
    
    	mVisibleRegionsDirty |= visibleRegions;
    //如果需要在将来的某个时间去处理一个在这次的vsync周期中不应该显示的queued frame，就需要发出一个invalidate信号，也就是请求下一个vsync，这是 signalLayerUpdate()做的事情。
    	if (frameQueued && layersWithQueuedFrames.empty()) {
    		signalLayerUpdate();
    	}
    }

看下latchBuffer如何处理bufferQueue的关系的。

Layer.cpp
    Region Layer::latchBuffer(bool& recomputeVisibleRegions)@Layer.cpp{
    // mQueuedFrames大于0，说明有需要处理的queued frame。
    	if (mQueuedFrames > 0 || mAutoRefresh) {
    		sp<GraphicBuffer> oldActiveBuffer = mActiveBuffer;
    //定义了一个Reject数据结构，
    		struct Reject : public SurfaceFlingerConsumer::BufferRejecter {
    // reject会被 mSurfaceFlingerConsumer调用，判断这个缓冲区 是否符合surfaceflinger的要求。
    			virtual bool reject(const sp<GraphicBuffer>& buf,const BufferItem& item) {
    				uint32_t bufWidth  = buf->getWidth();
    				uint32_t bufHeight = buf->getHeight();
    				if (item.mTransform & Transform::ROT_90) {
    					swap(bufWidth, bufHeight);
    				}
    				if (isFixedSize ||(bufWidth == front.requested.w &&
    					bufHeight == front.requested.h)){}
    			}
    		}；
    
    		Reject r(mDrawingState, getCurrentState(), recomputeVisibleRegions,
    			getProducerStickyTransform() != 0, mName.string(),
    			mOverrideScalingMode, mFreezePositionUpdates);
    //Reject类型的对象r作为参数传给了updateTexImage，surfaceflinger如果需要对某个buffer进行操作，要先accquire它，这个操作是在 updateTexImage中调用的，
    		status_t updateResult = mSurfaceFlingerConsumer->updateTexImage(&r,
    			mFlinger->mPrimaryDispSync, &mAutoRefresh, &queuedBuffer,
    			mLastFrameNumberReceived);
    // 如果updateResult 是成功的，就update the active buffer，更新 mCurrentCrop， mCurrentTransform， mCurrentScalingMode。
    		mActiveBuffer = mSurfaceFlingerConsumer->getCurrentBuffer();
    		Rect crop(mSurfaceFlingerConsumer→getCurrentCrop());
    		const uint32_t transform(mSurfaceFlingerConsumer→getCurrentTransform());
    		const uint32_t scalingMode(mSurfaceFlingerConsumer→getCurrentScalingMode());
    		mCurrentCrop = crop;
    		mCurrentTransform = transform;
    		mCurrentScalingMode = scalingMode;
    	}
    }

SurfaceFlingerConsumer.cpp
    status_t SurfaceFlingerConsumer::updateTexImage(BufferRejecter* rejecter,
            const DispSync& dispSync, bool* autoRefresh, bool* queuedBuffer,
            uint64_t maxFrameNumber)@SurfaceFlingerConsumer.cpp{
    //accquire下一个要处理的缓冲区，accquirebuffer的实现在BufferQueueConsumer.cpp中的acquireBuffer()函数中，源码的注释：In asynchronous mode the list is guaranteed to be one buffer deep,while in synchronous mode we use the oldest buffer.异步、同步模式下不同，不太理解，获取的buffer就是队列的第一个mCore->mQueue.begin()。获取这个buffer存在了 item（BufferItem）中，item中的变量mSlot是这个buffer在bufferSlots中的序号。
    	BufferItem item;
    	err = acquireBufferLocked(&item, computeExpectedPresent(dispSync),
    		maxFrameNumber);
    
    //调用 BufferRejecter的reject方法，判断这个buffer是否有效，如果返回值是true表明这个buffer是无效的，就要释放掉这个buffer，
    	int slot = item.mSlot;
    	if (rejecter && rejecter->reject(mSlots[slot].mGraphicBuffer, item)) {
    		releaseBufferLocked(slot, mSlots[slot].mGraphicBuffer, EGL_NO_SYNC_KHR);
    		return BUFFER_REJECTED;
    	}
    //从buffer得到mEglImage，然后就可以释放掉这个buffer了。然后把转成ANativeWindowBuffer绑定到GLTexture。
    	err = updateAndReleaseLocked(item);
    	err = bindTextureImageLocked();
    }

3）前面两个函数是收到MessageQueue::INVALIDATE消息后的操作。接下来看下收到MessageQueue::REFRESH消息后操作，即handleMessageRefresh()中方法。

void SurfaceFlinger::handleMessageRefresh() @SurfaceFlinger_hwc1.cpp{
        preComposition();
        rebuildLayerStacks();
        setUpHWComposer();
        doDebugFlashRegions();
        doComposition();
        postComposition(refreshStartTime);
    }

先看preComposition()。

void SurfaceFlinger::preComposition()@SurfaceFlinger_hwc1.cpp{
        bool needExtraInvalidate = false;
        const LayerVector& layers(mDrawingState.layersSortedByZ);
        const size_t count = layers.size();
    //循环调用系统中每一个layer的接口 onPreComposition，以决定是否需要Invalidate， onPreComposition的返回值依赖一个关键的变量mQueuedFrames，只要layer中有被queued的frame，就需要执行Invalidate，也就是 needExtraInvalidate = true。
        for (size_t i=0 ; i<count ; i++) {
            if (layers[i]->onPreComposition()) {
                needExtraInvalidate = true;
            }
        }
        if (needExtraInvalidate) {
            signalLayerUpdate();
        }
    }

详细分析下signalLayerUpdate()做了什么，看下它的调用堆栈：

SurfaceFlinger::signalLayerUpdate()@SurfaceFlinger\_hwc1.cpp--> mEventQueue.invalidate()@MessageQueue.cpp -->

EventThread::Connection::requestNextVsync()@EventThread.cpp$Connection→

EventThread::requestNextVsync(…)

最终的实现是在EventThread.cpp中。

void EventThread::requestNextVsync(
            const sp<EventThread::Connection>& connection) @EventThread.cpp{
    //这里会执行一次硬件的vsync，条件是距离上次合成的时间间隔大于500ns（ms2ns(500)）。
        mFlinger.resyncWithRateLimit();
    //connection->count 标示了eventthread传送vsync事件的频率，可以通过setVsyncRate(uint32_t count)函数设置，值大于等于1表示持续性发送事件，值为0表示发送一次性事件，值为-1（count ==-1 : one-shot event that fired this round / disabled）
        if (connection->count < 0) {
            connection->count = 0;
    //这里会唤醒eventthread线程。
            mCondition.broadcast();
        }
    }

4）rebuildLayerStacks()。rebuild所有可见的区域。

void SurfaceFlinger::rebuildLayerStacks()@SurfaceFlinger_hwc1.cpp {
    //所有已排好序的layers。
    	const LayerVector& layers(mDrawingState.layersSortedByZ);
    //rebuild每个屏幕的可见layer。
    	for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
    //计算需要重绘的脏区域和不透明区域，然后重新排序 layersSortedByZ。
    		Region opaqueRegion;
    		Region dirtyRegion;
    		Vector< sp<Layer> > layersSortedByZ;
    		const sp<DisplayDevice>& hw(mDisplays[dpy]);
    		const Transform& tr(hw→getTransform());
    //这是Display的范围。
    		const Rect bounds(hw→getBounds());
    //当前display是turn on的。
    		if (hw->isDisplayOn()) {
    //计算属于这个display的每个layer的可见区域，及可见区域中的脏区域。
    			computeVisibleRegions(hw->getHwcDisplayId(), layers,
    				hw->getLayerStack(), dirtyRegion, opaqueRegion);
    			const size_t count = layers.size();
    			for (size_t i=0 ; i<count ; i++) {
    				const sp<Layer>& layer(layers[i]);
    				Region drawRegion(tr.transform(
    					layer→visibleNonTransparentRegion));
    				drawRegion.andSelf(bounds);
    //脏区域不为空，就是后面需要绘制的区域，添加到 layersSortedByZ。
    				if (!drawRegion.isEmpty()) {
    					layersSortedByZ.add(layer);
    				}
    			}
    		}
    //保存计算结果到hw，作用于后面的合成。
    		hw→setVisibleLayersSortedByZ(layersSortedByZ);
    		hw->undefinedRegion.set(bounds);
    		hw→undefinedRegion.subtractSelf(tr.transform(opaqueRegion));
    		hw->dirtyRegion.orSelf(dirtyRegion);
    	}
    }

layer可见区域的计算，

void SurfaceFlinger::computeVisibleRegions(size_t dpy,
    	const LayerVector& currentLayers, uint32_t layerStack,
    	Region& outDirtyRegion, Region& outOpaqueRegion){
    //这个layer上面的不透明区域，即上面的被覆盖区域(一个layer的可见区域减去它的完全透明区域)。
        	Region aboveOpaqueLayers;
        	Region aboveCoveredLayers;
    	Region dirty;	
    //逐个处理当前所有的layer。
    	size_t i = currentLayers.size();
    	while (i--) {
    		const sp<Layer>& layer = currentLayers[i];
    		const Layer::State& s(layer→getDrawingState());
    //完全不透明区域。
    		Region opaqueRegion;
    //可见区域，就是可见的和不完全透明的区域，本质上就是layer的整个范围减去不透明区域，半透明区域也认为是可见区域。
    		Region visibleRegion;
    //被覆盖区域，被它上面的可见区域盖住的部分，它上面的可见区域包括半透明区域。
    		Region coveredRegion;
    //透明区域，就是完全透明的区域，这也说明当一个layer没有可见的不透明区域时，就可以把它从layer列表中删除了。
    		Region transparentRegion;
    
    		if (CC_LIKELY(layer->isVisible())) {
    			const bool translucent = !layer->isOpaque(s);
    			Rect bounds(s.active.transform.transform(layer->computeBounds()));
    			visibleRegion.set(bounds);
    //移除可见区域中的透明区域。
    			if (translucent) {
    				const Transform tr(s.active.transform);
    				transparentRegion = tr.transform(s.activeTransparentRegion);
    			}
    
    //计算不透明区域，实际不透明区域就是它的可见区域。
    			const int32_t layerOrientation = s.active.transform.getOrientation();
    			if (s.alpha==255 && !translucent &&
    				((layerOrientation & Transform::ROT_INVALID) == false))
    				opaqueRegion = visibleRegion;
    		}
    //从可见区域中剪去被覆盖的区域。
    		coveredRegion = aboveCoveredLayers.intersect(visibleRegion);
    //为下一个layer计算被覆盖区域。
    		aboveCoveredLayers.orSelf(visibleRegion);
    //从可见区域中剪去被上面的layer覆盖的不透明区域。
    		visibleRegion.subtractSelf(aboveOpaqueLayers);
    
    //计算这个layer的脏区域。
    		if (layer->contentDirty) {
    //这里需要重绘所有区域，脏区域及时刚刚计算出的可见区域，加上老的可见区域。
    			dirty = visibleRegion;
    			dirty.orSelf(layer->visibleRegion);
    		}else{
    //这里是不需要重绘所有区域。
    // newExposed这次被暴露出来的区域，现在可见了原来不可见。
    			const Region newExposed = visibleRegion – coveredRegion;
    //上一次的可见区域。
    			const Region oldVisibleRegion = layer→visibleRegion;
    //上一次被覆盖的区域。
    			const Region oldCoveredRegion = layer→coveredRegion;
    //上一次暴露的区域，
    			const Region oldExposed = oldVisibleRegion – oldCoveredRegion;
    			dirty = (visibleRegion&oldCoveredRegion) | (newExposed-oldExposed);
    		}
    		dirty.subtractSelf(aboveOpaqueLayers);
    //累加到全局变量中。
    		outDirtyRegion.orSelf(dirty);
    //为下一个layer更新它上面的不透明区域。
    		aboveOpaqueLayers.orSelf(opaqueRegion);
    //存储这个写可见区域。
    		layer->setVisibleRegion(visibleRegion);
    		layer->setCoveredRegion(coveredRegion);
    		layer->setVisibleNonTransparentRegion(visibleRegion.subtract(transparentRegion));
    	}
    //最终的不透明区域。
    	 outOpaqueRegion = aboveOpaqueLayers;
    }

5，setUpHWComposer,前面把合成需要的数据都准备好了，现在就要把需要显示的layer的数据准备好，然后确定有opengles或者HWC进行最终的合成。如果layer对应的surface的图像缓冲区是在帧缓冲区分配的，是直接渲染到屏幕的，如果surface的图形缓冲区在匿名共享内存中分配，是要通过surfaceflinger执行合成操作的。

帧缓冲区对应的是显示设备，目前整个系统只有一个显示屏，所以只有一个帧缓冲区，由surfaceflinger来管理，只有surfaceflinger使用的图像缓冲区才会在帧缓冲区上分配，应用程序使用的图像缓冲区通常是在匿名共享内存上分配，app把这块图像缓冲区填充好UI数据，交给surfaceflinger合成渲染到帧缓冲区，也就送到了显示设备。

void SurfaceFlinger::setUpHWComposer() {
    	for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
    		bool dirty = !mDisplays[dpy]→getDirtyRegion(false).isEmpty();
    		bool empty = mDisplays[dpy]->getVisibleLayersSortedByZ().size() == 0;
    		bool wasEmpty = !mDisplays[dpy]->lastCompositionHadVisibleLayers;
    //如果dirty为false，说明没有什么变化，就不需要recompose，如果有变化，但是当前没有可见的layers，而且当前也不是最后一次合成，那么就跳过这次。
    //当所有的layers都从这个display移除了，就发出一个black frame，然后什么也不做直到获取到新的layers，当一个显示设备有一个private layer stack，我们不会发出任何black frames直到有一个layer添加到这个layer stack。
    		bool mustRecompose = dirty && !(empty && wasEmpty);
    		mDisplays[dpy]->beginFrame(mustRecompose);
    		if (mustRecompose) {
    			mDisplays[dpy]->lastCompositionHadVisibleLayers = !empty;
    		}
    	}
    
    //这个hwc是surfaceflinger为管理HWComposer硬件模块而设计的一个类，代码路径是frameworks/native/services/surfaceflinger/displayhardware。它会进一步加载模块名是HWC_HARDWARE_MODULE_ID的设备，
    	HWComposer& hwc(getHwComposer());
    // mHwWorkListDirty值为true，这个值是在第一步 handleMessageTransaction时设置的。
    	if (CC_UNLIKELY(mHwWorkListDirty)) {
    		mHwWorkListDirty = false;
    //每个display，调用createWorkList构建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) {}
    		}
    	}
    
    //通过setPerFrameData设置每一帧的数据，producer生产的数据是放在GraphicBuffer中的，mActiveBuffer就是保存了生产好的数据的buffer，通过layer.setBuffer(mActiveBuffer)设置到layer中。
    	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();
    		HWComposer::LayerListIterator cur = hwc.begin(id);
    		const HWComposer::LayerListIterator end = hwc.end(id);
    		for (size_t i=0 ; cur!=end && i<count ; ++i, ++cur) {
    			const sp<Layer>& layer(currentLayers[i]);
    			layer->setPerFrameData(hw, *cur);
    		}
    	}
    //这里调用surfaceflinger中的hwc的方法prepare。
    	status_t err = hwc.prepare();
    
    // prepareFrame方法，设置合成类型，支持的合成类型定义在hwcomposer_defs.h中，
    //HWC_FRAMEBUFFER = 0,通过surfaceflinger把layer画到framebuffer中。
    //HWC_OVERLAY = 1,这个layer将由HWC模块处理。
    //HWC_BACKGROUND = 2,这是单一的背景layer，用于设置背景颜色值。
    //HWC_FRAMEBUFFER_TARGET = 3,这个layer保存了合成的HWC_FRAMEBUFFER layers的结果，
    	for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
    		sp<const DisplayDevice> hw(mDisplays[dpy]);
    		hw->prepareFrame(hwc);
    	}
    }

status_t HWComposer::prepare() @HWComposer_hwc1.cpp{
    	for (size_t i=0 ; i<mNumDisplays ; i++) {
    //对disp.list中属性赋值，然后保存到全局变量 mLists，它包括了所有Display的list。
    		DisplayData& disp(mDisplayData[i]);
    		if (disp.framebufferTarget) {
    			disp.framebufferTarget->compositionType = HWC_FRAMEBUFFER_TARGET;
    		}
    		mLists[i] = disp.list;
    	}
    //这里的 mHwc对应HWC的HAL模块，代码路径是:hardware/libhardware/modules/hwcomposer/Hwcomposer.cpp。
    	int err = mHwc->prepare(mHwc, mNumDisplays, mLists);
    }

6，doComposition,前一步通过prepare把数据传给HWC，接下来就要执行合成操作。

void SurfaceFlinger::doComposition() @SurfaceFlinger_hwc1.cpp{
    //是否要重绘所有的内容，
    	const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
    //每个display，逐一处理。
    	for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
    		const sp<DisplayDevice>& hw(mDisplays[dpy]);
    		if (hw->isDisplayOn()) {
    //将dirty区域转成屏幕的坐标空间。
    			const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));
    //绘制framebuffer。
    			doDisplayComposition(hw, dirtyRegion);
    			hw->dirtyRegion.clear();
    			hw->flip(hw->swapRegion);
    			hw->swapRegion.clear();
    		}
    //合成完成，先通过DisplayDevice，然后通过mDisplaySurface（FramebufferSurface），进一步调用mHwc（HWComposer_hwc1.cpp）的fbCompositionComplete，最后通知到到mFbDev（
    hardware/qcom/display/libgralloc/framebuffer.cpp）的fb_compositionComplete。
    		hw->compositionComplete();
    	}
    	postFramebuffer();
    }

//我们只需要实际的去合成显示，条件有两个：如果正在被hardwarecomposer处理，需要保持它跟虚拟显示状态机同步，或者脏区域不为空。

void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
            const Region& inDirtyRegion)@SurfaceFlinger_hwc1.cpp{
    //计算脏区域，虽然前面已经计算好了，这里还要做些调整。
    	hw->swapRegion.orSelf(dirtyRegion);
    
    	uint32_t flags = hw->getFlags();
    	if (flags & DisplayDevice::SWAP_RECTANGLE) {
    //只需要去绘制脏区域，但是这个区域必须是长方形，
    		dirtyRegion.set(hw->swapRegion.bounds());
    	}else {
    		if (flags & DisplayDevice::PARTIAL_UPDATES) {
    //硬件层面的部分区域更新，也要求是矩形。
    			dirtyRegion.set(hw->swapRegion.bounds());
    		}else {
    //需要重绘整个显示区域。
    			dirtyRegion.set(hw->bounds());
    			hw->swapRegion = dirtyRegion;
    		}
    	}
    //合成数据。
    	doComposeSurfaces(hw, dirtyRegion);
    //更新交换区域，清楚脏区域。
    	hw→swapRegion.orSelf(dirtyRegion);
    //交换前后台buffer。
    	hw->swapBuffers(getHwComposer());
    }

bool SurfaceFlinger::doComposeSurfaces(const sp<const DisplayDevice>& hw, const Region& dirty)@SurfaceFlinger_hwc1.cpp{
    	RenderEngine& engine(getRenderEngine());
    	const int32_t id = hw->getHwcDisplayId();
    	HWComposer& hwc(getHwComposer());
    	HWComposer::LayerListIterator cur = hwc.begin(id);
    	const HWComposer::LayerListIterator end = hwc.end(id);
    //是否需要opengl es合成。
    	bool hasGlesComposition = hwc.hasGlesComposition(id);
    	if (hasGlesComposition) {
    //设置当前环境，设置当前的display。
    		if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
    			eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, 
    				EGL_NO_CONTEXT);
    		}
    		
    //是否也有需要HWC合成的layer。
    		const bool hasHwcComposition = hwc.hasHwcComposition(id) ||
    			isS3DLayerPresent(hw);
    		if (hasHwcComposition) {
    //将窗口清除为（0,0，0）的颜色。
    			engine.clearWithColor(0, 0, 0, 0);
    		}else {
    //计算要clear的区域，但是仅限定在dirty区域。
    			const Region bounds(hw->getBounds());
    			const Region letterbox(bounds.subtract(hw->getScissor()));
    			Region region(hw→undefinedRegion.merge(letterbox));
    			region.andSelf(dirty);
    			drawWormHoleIfRequired(cur, end, hw, region);
    		}		
    	}
    
    //准备渲染数据到framebuffer中，
    	const Vector< sp<Layer> >& layers(hw→getVisibleLayersSortedByZ());
    	const size_t count = layers.size();
    	const size_t count = layers.size();
    	if (cur != end) {
    //使用HWC合成，可见layer中可能既有需要hwc处理的，也有需要opengles处理的。
    		for (size_t i=0 ; i<count && cur!=end ; ++i, ++cur) {
    			const sp<Layer>& layer(layers[i]);
    			const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
    			if (!clip.isEmpty()) {
    				switch (cur->getCompositionType()) {
    					case HWC_OVERLAY: {
    						layer->clearWithOpenGL(hw, clip);
    						break;
    					}
    //由opengl es处理的layer，
    					case HWC_FRAMEBUFFER: {
    						layer->draw(hw, clip);
    						break;
    					}
    				}
    			}
    		}
    	}else{
    //不使用HWC处理，核心实现都是 layer->draw。
    		const sp<Layer>& layer(layers[i]);
    		const Region clip(dirty.intersect(tr.transform(layer→visibleRegion)));
    		layer->draw(hw, clip);
    	}
    }

layer->draw直接调用了onDraw。

void Layer::onDraw(const sp<const DisplayDevice>& hw, const Region& clip,
            bool useIdentityTransform) const@Layer.cpp{
    	if (CC_UNLIKELY(mActiveBuffer == 0)) {
    //如果texture还没被创建，这个layer还没被绘制过，这是可能发生的，因为windowmanager不知道client什么时候执行第一次绘制。
    //如果下面什么也没有，就把屏幕刷成黑色，否则跳过这个update。
    		Region under;
    		const SurfaceFlinger::LayerVector& drawingLayers(
    			mFlinger→mDrawingState.layersSortedByZ);
    		const size_t count = drawingLayers.size();
    		for (size_t i=0 ; i<count ; ++i) {
    			const sp<Layer>& layer(drawingLayers[i]);
    //找出这个layer下的可见区域。
    			if (layer.get() == static_cast<Layer const*>(this))
    			break;
    			under.orSelf( hw->getTransform().transform(layer->visibleRegion) );
    		}
    //将可见区域外的区域，刷成黑色。
    		Region holes(clip.subtract(under));
    		clearWithOpenGL(hw, holes, 0, 0, 0, 1);
    	}
    
    //绑定当前缓冲区到opengl纹理，然后等待绘制。
    	status_t err = mSurfaceFlingerConsumer→bindTextureImage();
    
    //接下来就是调用opengl 的api，做最后的处理。
    	RenderEngine& engine(mFlinger->getRenderEngine());
    	drawWithOpenGL(hw, clip, useIdentityTransform);
    }

//对layer的处理完成后，回到doDisplayComposition最后一步，缓冲区交换。

void SurfaceFlinger::doDisplayComposition(const sp<const DisplayDevice>& hw,
            const Region& inDirtyRegion)@SurfaceFlinger_hwc1.cpp{
    	hw->swapBuffers(getHwComposer());
    }

//调用eglSwapBuffers交换前后台数据。

void DisplayDevice::swapBuffers(HWComposer& hwc) const @DisplayDevice.cpp{
    	if (hwc.initCheck() != NO_ERROR ||
    		(hwc.hasGlesComposition(mHwcDisplayId) &&
    		(hwc.supportsFramebufferTarget() || mType >= DISPLAY_VIRTUAL))) {
    		EGLBoolean success = eglSwapBuffers(mDisplay, mSurface);
    	}
    }

//最后通过postFramebuffer送显。

void SurfaceFlinger::doComposition() @SurfaceFlinger_hwc1.cpp{
    	postFramebuffer();
    }

//调用postComposition，来确定启动还是关闭硬件的vsync。

void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)@SurfaceFlinger_hwc1.cpp{
    	const HWComposer& hwc = getHwComposer();
    	sp<Fence> presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);
    	if (presentFence->isValid()) {
    		if (mPrimaryDispSync.addPresentFence(presentFence)) {
    			enableHardwareVsync();
    		} else {
    			disableHardwareVsync(false);
    		}
    	}
    }

一个layer的合成类型是在prepare时确定的。

status_t HWComposer::prepare() @HWComposer_hwc1.cpp{
    	disp.framebufferTarget->compositionType = HWC_FRAMEBUFFER_TARGET;
    //这里调用了HWC的hal模块的实现hardware/qcom/display/libhwcomposer。
    	int err = mHwc->prepare(mHwc, mNumDisplays, mLists);
    
    	disp.hasFbComp = true;
    	disp.hasOvComp = true;
    }

在不支持硬件合成的情况下，调用layer.draw函数逐层合成图像，然后通过eglswapbuffers将图像送到显示设备。