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