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

一旦有事件发生，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将图像送到显示设备。