通过前面小节的讲解我们知道，surfaceflinger在接收到Vsync信号之后，会执行一系列的函数，这些函数做了哪些事情呢？在之前提到SurfaceFlinger.cpp中：
void SurfaceFlinger::onMessageReceived(int32_t what) { case MessageQueue::INVALIDATE: { /*处理事务，实际大部分做了一些标志位的操作*/ bool refreshNeeded = handleMessageTransaction(); /*切换各个层的buffer*/ refreshNeeded |= handleMessageInvalidate(); /*发出一个界面更新的信号，最终导致handleMessageRefresh被调用*/ refreshNeeded |= mRepaintEverything; case MessageQueue::REFRESH: { handleMessageRefresh();
以上函数都做了哪些工作呢？下面是一个草图：
我们猜测一下handleMessageRefresh函数会做什么事情。在android系统中存在对个应用程序，每个程序都有有一个Layer，这些Layer从上到下，一层层的排放，上面的层会挡住下面的。那么handleMessageRefresh会去算出每个层的可视区域，最终在他他们合并显示出来。如下图：
主要工作如下： 1.计算各个Layer的显示区域 2.合成显示：a（软件）.使用openGL把各个Layer的可视区域在一个内存上描绘出来。b（硬件）.使用HWcomposer合成 下面我们查看handleMessageRefresh：
void SurfaceFlinger::handleMessageRefresh() { /*做一些预先的处理*/ preComposition(); /*计算各个层的可视区域。对每个屏幕构建可视的Layer*/ rebuildLayerStacks(); setUpHWComposer(); doDebugFlashRegions(); doComposition(); postComposition(refreshStartTime);
首先我们来看看preComposition
preCompositionvoid SurfaceFlinger::preComposition() /*在Layer.cpp中实现*/ onPreComposition() /*如果有多个buffer需要处理返回true*/ return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh; needExtraInvalidate = true; signalLayerUpdate();rebuildLayerStacks
void SurfaceFlinger::rebuildLayerStacks() { // rebuild the visible layer list per screen /*对每个显示器质性for中代码*/ for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) { /*如果显示器是打开的状态*/ if (hw->isDisplayOn()) { /*计算可视区域*/ SurfaceFlinger::computeVisibleRegions(layers,hw->getLayerStack(), dirtyRegion, opaqueRegion);
假设有多个APP，如下体所示：
在最上面的APP可以完全显示，下面的APP会被遮挡一部分。怎么计算各个Layer的可视区域了？
1.从Z轴最大的层开始计算，
2.Z轴小的Layer会被他上面的Layer遮盖
下面我们使用一个例子来讲解这些代码：
假设有3个层：
void SurfaceFlinger::computeVisibleRegions( const LayerVector& currentLayers, uint32_t layerStack, Region& outDirtyRegion, Region& outOpaqueRegion) { ATRACE_CALL(); /*在当前层之上的不透明区域*/ Region aboveOpaqueLayers; /*当前层之前的被遮盖的区域:.opaque+transucent，当前层之上各层课时区域*/ Region aboveCoveredLayers; /**/ Region dirty; outDirtyRegion.clear(); /*当前需要合成的Layer层数*/ size_t i = currentLayers.size(); while (i--) { /*从Z轴最大的那一层开始处理*/ const sp<Layer>& layer = currentLayers[i]; // start with the whole surface at its current location const Layer::State& s(layer->getDrawingState()); // only consider the layers on the given layer stack if (s.layerStack != layerStack) continue; /*
* opaqueRegion: area of a surface that is fully opaque.
*/ Region opaqueRegion; /*
* visibleRegion: area of a surface that is visible on screen
* and not fully transparent. This is essentially the layer's
* footprint minus the opaque regions above it.
* Areas covered by a translucent surface are considered visible.
*/ Region visibleRegion; /*
* coveredRegion: area of a surface that is covered by all
* visible regions above it (which includes the translucent areas).
*/ Region coveredRegion; /*
* transparentRegion: area of a surface that is hinted to be completely
* transparent. This is only used to tell when the layer has no visible
* non-transparent regions and can be removed from the layer list. It
* does not affect the visibleRegion of this layer or any layers
* beneath it. The hint may not be correct if apps don't respect the
* SurfaceView restrictions (which, sadly, some don't).
*/ Region transparentRegion; // handle hidden surfaces by setting the visible region to empty if (CC_LIKELY(layer->isVisible())) { const bool translucent = !layer->isOpaque(s); Rect bounds(s.active.transform.transform(layer->computeBounds())); visibleRegion.set(bounds); if (!visibleRegion.isEmpty()) { // Remove the transparent area from the visible region if (translucent) { const Transform tr(s.active.transform); if (tr.preserveRects()) { // transform the transparent region transparentRegion = tr.transform(s.activeTransparentRegion); } else { // transformation too complex, can't do the // transparent region optimization. transparentRegion.clear(); } } // compute the opaque region const int32_t layerOrientation = s.active.transform.getOrientation(); if (s.alpha==255 && !translucent && ((layerOrientation & Transform::ROT_INVALID) == false)) { // the opaque region is the layer's footprint opaqueRegion = visibleRegion; } } } // Clip the covered region to the visible region coveredRegion = aboveCoveredLayers.intersect(visibleRegion); // Update aboveCoveredLayers for next (lower) layer aboveCoveredLayers.orSelf(visibleRegion); // subtract the opaque region covered by the layers above us visibleRegion.subtractSelf(aboveOpaqueLayers); // compute this layer's dirty region if (layer->contentDirty) { // we need to invalidate the whole region dirty = visibleRegion; // as well, as the old visible region dirty.orSelf(layer->visibleRegion); layer->contentDirty = false; } else { /* compute the exposed region:
* the exposed region consists of two components:
* 1) what's VISIBLE now and was COVERED before
* 2) what's EXPOSED now less what was EXPOSED before
*
* note that (1) is conservative, we start with the whole
* visible region but only keep what used to be covered by
* something -- which mean it may have been exposed.
*
* (2) handles areas that were not covered by anything but got
* exposed because of a resize.
*/ 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); // accumulate to the screen dirty region outDirtyRegion.orSelf(dirty); // Update aboveOpaqueLayers for next (lower) layer aboveOpaqueLayers.orSelf(opaqueRegion); // Store the visible region in screen space layer->setVisibleRegion(visibleRegion); layer->setCoveredRegion(coveredRegion); layer->setVisibleNonTransparentRegion( visibleRegion.subtract(transparentRegion)); } outOpaqueRegion = aboveOpaqueLayers; }
代码注释比较详细，有兴趣的同学可以分析一下。
