Android GUI系统之SurfaceFlinger(09)服务端分析4-handleMessageRefresh处理

该系列文章总纲链接:Android GUI系统之SurfaceFlinger 系列文章目录


本章关键点总结 & 说明:

Android GUI系统之SurfaceFlinger(09)服务端分析4-handleMessageRefresh处理_第1张图片

本章节思维导图如上。主要讲述了SurfaceFlinger 处理Vsync机制的流程。主要分析handleMessageRefresh 处理方法。


1 从signalRefresh到handleMessageRefresh

signalRefresh的代码实现如下:

void SurfaceFlinger::signalRefresh() {
    mEventQueue.refresh();
}

这里继续分析mEventQueue的refresh方法,代码实现如下:

void MessageQueue::refresh() {
#if INVALIDATE_ON_VSYNC
    mHandler->dispatchRefresh();//调用这里
#else
    mEvents->requestNextVsync();
#endif
}

继续分析mHandler的dispatchRefresh()方法,代码实现如下:

void MessageQueue::Handler::dispatchRefresh() {
    if ((android_atomic_or(eventMaskRefresh, &mEventMask) & eventMaskRefresh) == 0) {
        mQueue.mLooper->sendMessage(this, Message(MessageQueue::REFRESH));
    }
}

这里使用了handler Message 机制,因此看如何处理的,代码如下:

void MessageQueue::Handler::handleMessage(const Message& message) {
    switch (message.what) {
        case INVALIDATE:
            android_atomic_and(~eventMaskInvalidate, &mEventMask);
            mQueue.mFlinger->onMessageReceived(message.what);
            break;
        case REFRESH:
            android_atomic_and(~eventMaskRefresh, &mEventMask);
            mQueue.mFlinger->onMessageReceived(message.what);
            break;
        case TRANSACTION:
            android_atomic_and(~eventMaskTransaction, &mEventMask);
            mQueue.mFlinger->onMessageReceived(message.what);
            break;
    }
}

这里会调用SurfaceFlinger的onMessageReceived方法,最后调用的是onMessageReceived,代码如下:

void SurfaceFlinger::onMessageReceived(int32_t what) {
    switch (what) {
        //...
        case MessageQueue::REFRESH: {
            handleMessageRefresh();
            break;
        }
    }
}

到这里可以看到,signalRefresh的调用最后还会回到SurfaceFlinger的onMessageReceived调用,只不过参数变成了MessageQueue::REFRESH,这里继续分析handleMessageRefresh(),

2 handleMessageRefresh 分析

handleMessageRefresh()的代码实现如下:

void SurfaceFlinger::handleMessageRefresh() {
    //关键点1 合成前预处理
    preComposition();
    //关键点2 计算可见区域,主要依据:z-order大的覆盖有重叠区域z-order小的
    rebuildLayerStacks();

    //关键点3 下面几个方法都是页面合成相关
    setUpHWComposer();
    doDebugFlashRegions();
    //关键点4 合成所有层的图像, 经过这一步后,就显示新的内容了
    doComposition();
    //合成之后的工作
    postComposition();
}

这里重点分析rebuildLayerStacks,最后整体简要分析下preComposition函数 和 合成界面相关的函数。

2.1 preComposition简要分析

先看Vsync Rate相关的代码:

virtual void setVsyncRate(uint32_t count)

当count为1时,表示每个信号都要报告,当count =2 时,表示信号 间隔一个后才报告,当count=0时表示不自动报告,除非主动触发requestNextVsync,接下来分析preComposition,代码实现如下:

void SurfaceFlinger::preComposition()
{
    bool needExtraInvalidate = false;
    const LayerVector& layers(mDrawingState.layersSortedByZ);
    const size_t count = layers.size();
    //获取全部的layer
    for (size_t i=0 ; ionPreComposition()) {
            needExtraInvalidate = true;
        }
    }
    if (needExtraInvalidate) {
        signalLayerUpdate();//请求VSYNC
    }
}

这里会调用 每个Layer 的onPreComposition,代码实现如下:

bool Layer::onPreComposition() {
    mRefreshPending = false;
    return mQueuedFrames > 0 || mSidebandStreamChanged;
}

也就是说,当layer里存放被queue的frame以后,就会出发layer update,signalLayerUpdate这这里分析过,具体位置在这个链接:(Android GUI系统之SurfaceFlinger(06)服务端分析1-处理VSYNC)因此这里就不展开了。

2.2 rebuildLayerStacks 分析

在分析之前需要明确个基本概念:

  1. dirtyRegion:表示该区域是需要被刷新的。
  2. opaqueRegion:表示不透明区域。
  3. transparentRegion:表示完全透明区域。
  4. translucentRegion:表示半透明区域。

说明:对于opaqueRegion,应为layer是按Z-order排序的,左右排在前面的opaqueRegion 会挡住后面的layer。

接下来开始分析代码,rebuildLayerStacks 代码 实现如下:

void SurfaceFlinger::rebuildLayerStacks() {
    // rebuild the visible layer list per screen
    if (CC_UNLIKELY(mVisibleRegionsDirty)) {
        mVisibleRegionsDirty = false;
        invalidateHwcGeometry();
        //计算每个设备上的可见Layer
        const LayerVector& layers(mDrawingState.layersSortedByZ);
        //系统的display可能不止一个,存在于mDisplays中
        for (size_t dpy=0 ; dpy > layersSortedByZ;
            const sp& hw(mDisplays[dpy]);
            const Transform& tr(hw->getTransform());
            const Rect bounds(hw->getBounds());
            if (hw->isDisplayOn()) {
                //计算可视区域,最关键方法
                SurfaceFlinger::computeVisibleRegions(layers,
                        hw->getLayerStack(), dirtyRegion, opaqueRegion);

                const size_t count = layers.size();
                for (size_t i=0 ; i& layer(layers[i]);
                    const Layer::State& s(layer->getDrawingState());
                    //这里只要 和显示设备的layerStack相同的 layer
                    if (s.layerStack == hw->getLayerStack()) {
                        //程序需要进一步得出每个layer 绘制的区域
                        Region drawRegion(tr.transform(
                                layer->visibleNonTransparentRegion));
                        drawRegion.andSelf(bounds);
                        //如果Layer的显示区域和显示设备的窗口有交集
                        if (!drawRegion.isEmpty()) {
                            layersSortedByZ.add(layer);
                        }
                    }
                }
            }
            //设置显示设备的可见列表,将这些结果保存在hw中
            hw->setVisibleLayersSortedByZ(layersSortedByZ);//Z序layer
            hw->undefinedRegion.set(bounds);
            hw->undefinedRegion.subtractSelf(tr.transform(opaqueRegion));//
            hw->dirtyRegion.orSelf(dirtyRegion);//刷新区
        }
    }
}

rebuildLayerStacks主要是做两件事:

  1. 重建每个显示设备的可见layer对象的列表。layer按照Z序排列,但每个Layer都有 透明区、不透明区、半透明区即下面的Layer某些区域也是有机会显示的
  2. 对每个显示设备,先计算和显示设备相同的layerStack值的layer对象在显示设备上的可见区域,然后将可见区域和显示设备的窗口有交集的layer组成一个新的列表,最后把这个列表设置到显示设备对象中。

这里 主要关注computeVisibleRegions的实现,代码如下:

void SurfaceFlinger::computeVisibleRegions(
        const LayerVector& currentLayers, uint32_t layerStack,
        Region& outDirtyRegion, Region& outOpaqueRegion)
{
    Region aboveOpaqueLayers;//当前层之上累计的不透明区域
    Region aboveCoveredLayers;//当前层之上累计的被覆盖区域,不透明+半透明
    Region dirty;
    outDirtyRegion.clear();总值

    size_t i = currentLayers.size();//最上层layer的索引
    while (i--) {//从Z轴 最上面的layer开始处理,由上到下
        const sp& layer = currentLayers[i];
        const Layer::State& s(layer->getDrawingState());
        // 只计算和layerstack相同的layer,其他忽略
        if (s.layerStack != layerStack)
            continue;

        Region opaqueRegion;        //不透明区域
        Region visibleRegion;       //可见区域,不透明区域+半透明区域
        Region coveredRegion;       //覆盖区域,可见区域覆盖的地方
        Region transparentRegion;   //完全透明区域
        //stage1-start 得到当前Layer的原始可视区域 和 opaque区域
        // handle hidden surfaces by setting the visible region to empty
        if (CC_LIKELY(layer->isVisible())) {
            const bool translucent = !layer->isOpaque(s);
            Rect bounds(s.transform.transform(layer->computeBounds()));
            visibleRegion.set(bounds);
            if (!visibleRegion.isEmpty()) {
                // Remove the transparent area from the visible region
                if (translucent) {//计算透明区域
                    const Transform tr(s.transform);
                    if (tr.transformed()) {
                        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();
                        }
                    } else {
                        transparentRegion = s.activeTransparentRegion;
                    }
                }

                // 计算不透明区域
                const int32_t layerOrientation = s.transform.getOrientation();
                if (s.alpha==255 && !translucent &&
                        ((layerOrientation & Transform::ROT_INVALID) == false)) {
                    opaqueRegion = visibleRegion;
                }
            }
        }
        //stage1-end

        //当前Layer被遮盖区域:上层的覆盖区 和 layer所在区域的 交集
        coveredRegion = aboveCoveredLayers.intersect(visibleRegion);

        // 扩大覆盖区域,为下次循环、即下层计算做准备
        aboveCoveredLayers.orSelf(visibleRegion);

        //可见区域 = 抠掉上层的不透明区域
        visibleRegion.subtractSelf(aboveOpaqueLayers);

        // 计算需要重绘的区域
        if (layer->contentDirty) {
            //内容变了,重绘整个可见区域
            dirty = visibleRegion;
            //以前的看见区域也要加进来,因为以前的内容需要抹掉
            dirty.orSelf(layer->visibleRegion);
            layer->contentDirty = false;
        } else {
            //暴露区域 = 可见区域-被覆盖区域
            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);
        }
        
        //layer的重绘区域 = 抠掉上层的不透明区域
        dirty.subtractSelf(aboveOpaqueLayers);

        //累计每层需要重绘的区域
        outDirtyRegion.orSelf(dirty);

        //更新aboveOpaqueLayers,为下层layer绘制做准备
        aboveOpaqueLayers.orSelf(opaqueRegion);

        //设置layer对象的区域
        layer->setVisibleRegion(visibleRegion);
        layer->setCoveredRegion(coveredRegion);
        //设置可见的非透明区域
        layer->setVisibleNonTransparentRegion(
                visibleRegion.subtract(transparentRegion));
    }

    outOpaqueRegion = aboveOpaqueLayers;
}

总结下computeVisibleRegions的逻辑如下:

先计算每个layer在设备上的可见区域visibleRegion(不透明区域 + 半透明区域)。计算方法:整个Layer的区域-上层所有不透明区域aboveOpaqueLayers。而上层所有不透明区域的值 是一个逐层累积的过程,每层都把自己的不透明区域累加到aboveOpaqueLayers中。

每层的不透明区域的计算方法:如果layer的alpha值=255,并且layer的isOpaque = true,则本层的不透明区域 == layer所在区域。否则为0。这样一层层计算下来,就很容易得到每层的可见区域大小了。

这里以下图为例,解读下computeVisibleRegions这段逻辑:

Android GUI系统之SurfaceFlinger(09)服务端分析4-handleMessageRefresh处理_第2张图片

假设有三个Layer,按照Z值从大到小,依次是Layer1->Layer2->Layer3,最后按照computeVisibleRegions的规则来合成Layer。有了这个图,看这段逻辑 便会更加直观。同时理解这段逻辑 最好的方法是将3个Layer带入到computeVisibleRegions方法中。

2.3 setUpHWComposer

setUpHWComposer的代码实现如下:

void SurfaceFlinger::setUpHWComposer() {
    //mDisplays变量中维护者每个显示变量的信息
    for (size_t dpy=0 ; dpygetDirtyRegion(false).isEmpty();
        bool empty = mDisplays[dpy]->getVisibleLayersSortedByZ().size() == 0;
        bool wasEmpty = !mDisplays[dpy]->lastCompositionHadVisibleLayers;
        bool mustRecompose = dirty && !(empty && wasEmpty);
        mDisplays[dpy]->beginFrame(mustRecompose);

        if (mustRecompose) {
            mDisplays[dpy]->lastCompositionHadVisibleLayers = !empty;
        }
    }

    HWComposer& hwc(getHwComposer());//得到系统的HWC对象
    if (hwc.initCheck() == NO_ERROR) {
        // build the h/w work list
        if (CC_UNLIKELY(mHwWorkListDirty)) {
            mHwWorkListDirty = false;
            for (size_t dpy=0 ; dpy hw(mDisplays[dpy]);
                const int32_t id = hw->getHwcDisplayId();
                if (id >= 0) {
                    //遍历DisplayDevice所有可见layer 
                    const Vector< sp >& currentLayers(
                        hw->getVisibleLayersSortedByZ());
                    const size_t count = currentLayers.size();
                    //根据layer数量调用createWorkList创建hwc_layer_list_t列表  
                    if (hwc.createWorkList(id, count) == NO_ERROR) {
                        //...
                    }
                }
            }
        }

        // set the per-frame data
        for (size_t dpy=0 ; dpy hw(mDisplays[dpy]);
            const int32_t id = hw->getHwcDisplayId();
            if (id >= 0) {
                const Vector< sp >& 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& layer(currentLayers[i]);
                    //将layer的ActiveBuffer设置到HWComposer中的hwc_layer_1_t中
                    layer->setPerFrameData(hw, *cur);
                }
            }
        }

        // If possible, attempt to use the cursor overlay on each display.
        for (size_t dpy=0 ; dpy hw(mDisplays[dpy]);
            hw->prepareFrame(hwc);
        }
    }
}

该函数的作用是更新HWComposer对象中图层对象列表以及涂层属性。详细点就是 构造Worklist,并且给DisplayData的list 申请空间,并填充各个layer的数据,最后调用HWComposer的prepare函数(往下延伸,这部分就是由厂家来实现了)。

2.4 doCompostion

setUpHWComposer 只是交给HWC来负责显示,真正显示的地方在这,doCompostion的代码实现如下:

void SurfaceFlinger::doComposition() {
    const bool repaintEverything = android_atomic_and(0, &mRepaintEverything);
    for (size_t dpy=0 ; dpy& hw(mDisplays[dpy]);
        if (hw->isDisplayOn()) {
            // transform the dirty region into this screen's coordinate space
            const Region dirtyRegion(hw->getDirtyRegion(repaintEverything));

            //关键点1:进行图像合成
            doDisplayComposition(hw, dirtyRegion);

            hw->dirtyRegion.clear();
            hw->flip(hw->swapRegion);
            hw->swapRegion.clear();
        }
        // 通知HWC合成结束了
        hw->compositionComplete();
    }
    //关键点2:完成后调用该方法
    postFramebuffer();
}

这里我们关键分析几个方法:getDirtyRegiondoDisplayComposition和postFramebuffer。

2.4.1 getDirtyRegion分析

在前面重构Layer时,Display的脏区域dirtyRegion已经计算出来。如果是重画,mRepaintEverything为true,那么脏区域就是整个屏幕的大小。getDirtyRegion的代码实现如下:

Region DisplayDevice::getDirtyRegion(bool repaintEverything) const {
    Region dirty;
    if (repaintEverything) {
        dirty.set(getBounds());
    } else {
        const Transform& planeTransform(mGlobalTransform);
        dirty = planeTransform.transform(this->dirtyRegion);
        dirty.andSelf(getBounds());
    }
    return dirty;
}

2.4.2 doDisplayComposition分析

doDisplayComposition代码实现如下:

void SurfaceFlinger::doDisplayComposition(const sp& hw,
        const Region& inDirtyRegion)
{
    bool isHwcDisplay = hw->getHwcDisplayId() >= 0;
    if (!isHwcDisplay && inDirtyRegion.isEmpty()) {
        return;
    }

    Region dirtyRegion(inDirtyRegion);
    //swapRegion设置为 需要更新的区域
    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 {
            // we need to redraw everything (the whole screen)
            dirtyRegion.set(hw->bounds());//将更新区域调整为整个窗口的大小
            hw->swapRegion = dirtyRegion;
        }
    }
    //关键点1:都会执行 doComposeSurfaces方法
    if (CC_LIKELY(!mDaltonize && !mHasColorMatrix)) {
        if (!doComposeSurfaces(hw, dirtyRegion)) return;
    } else {
        RenderEngine& engine(getRenderEngine());
        mat4 colorMatrix = mColorMatrix;
        if (mDaltonize) {
            colorMatrix = colorMatrix * mDaltonizer();
        }
        engine.beginGroup(colorMatrix);
        doComposeSurfaces(hw, dirtyRegion);
        engine.endGroup();
    }

    // update the swap region and clear the dirty region
    hw->swapRegion.orSelf(dirtyRegion);

    //关键点2:在系统不支持HWC的情况下调用eglSwapBuffers来输出图像到显示设备。
    hw->swapBuffers(getHwComposer());
}

传入的参数inDirtyRegion,是要刷新的“脏”区域,但我们的刷新机制决定了必须是矩形的区域。因此需要一个最小的矩形,能够包裹inDirtyRegion的区域。这里有两种模式:

  1. SWAP_RECTANGLE:系统支持软件层面的部分刷新,就需要计算这个最小矩形。
  2. PARTIAL_UPDATES:硬件层面的部分刷新,同理需要这个最小矩形。

总之 最后就是重绘这个区域。 该部分专注两个关键方法 doComposeSurfaces 和 hw->swapBuffers(getHwComposer());

@1 doComposeSurfaces分析

doComposeSurfaces的代码实现如下:

bool SurfaceFlinger::doComposeSurfaces(const sp& hw, const Region& dirty)
{
    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);

    bool hasGlesComposition = hwc.hasGlesComposition(id);
    if (hasGlesComposition) {
        if (!hw->makeCurrent(mEGLDisplay, mEGLContext)) {
            eglMakeCurrent(mEGLDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
            if(!getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext)) {
              ALOGE("DisplayDevice::makeCurrent on default display failed. Aborting.");
            }
            return false;
        }

        // Never touch the framebuffer if we don't have any framebuffer layers
        const bool hasHwcComposition = hwc.hasHwcComposition(id);
        if (hasHwcComposition) {
            engine.clearWithColor(0, 0, 0, 0);
        } else {
            const Region bounds(hw->getBounds());
            const Region letterbox(bounds.subtract(hw->getScissor()));
            Region region(hw->undefinedRegion.merge(letterbox));
            region.andSelf(dirty);

            // screen is already cleared here
            if (!region.isEmpty()) {
                // can happen with SurfaceView
                drawWormhole(hw, region);
            }
        }

        if (hw->getDisplayType() != DisplayDevice::DISPLAY_PRIMARY) {
            const Rect& bounds(hw->getBounds());
            const Rect& scissor(hw->getScissor());
            if (scissor != bounds) {
                const uint32_t height = hw->getHeight();
                engine.setScissor(scissor.left, height - scissor.bottom,
                        scissor.getWidth(), scissor.getHeight());
            }
        }
    }

    const Vector< sp >& layers(hw->getVisibleLayersSortedByZ());
    const size_t count = layers.size();
    const Transform& tr = hw->getTransform();
    if (cur != end) {
        // 使用 h/w composer
        for (size_t i=0 ; i& layer(layers[i]);
            const Region clip(dirty.intersect(tr.transform(layer->visibleRegion)));
            if (!clip.isEmpty()) {
                switch (cur->getCompositionType()) {
                    case HWC_CURSOR_OVERLAY:
                    case HWC_OVERLAY: {
                        const Layer::State& state(layer->getDrawingState());
                        if ((cur->getHints() & HWC_HINT_CLEAR_FB)
                                && i
                                && layer->isOpaque(state) && (state.alpha == 0xFF)
                                && hasGlesComposition) {
                            layer->clearWithOpenGL(hw, clip);
                        }
                        break;
                    }
                    case HWC_FRAMEBUFFER: {
                        layer->draw(hw, clip);
                        break;
                    }
                    case HWC_FRAMEBUFFER_TARGET: {
                        // this should not happen as the iterator shouldn't
                        // let us get there.
                        ALOGW("HWC_FRAMEBUFFER_TARGET found in hwc list (index=%zu)", i);
                        break;
                    }
                }
            }
            layer->setAcquireFence(hw, *cur);
        }
    } else {
        // 不使用 h/w composer,只用openGL ES
        for (size_t i=0 ; i& layer(layers[i]);
            const Region clip(dirty.intersect(
                    tr.transform(layer->visibleRegion)));
            if (!clip.isEmpty()) {
                layer->draw(hw, clip);
            }
        }
    }

    // disable scissor at the end of the frame
    engine.disableScissor();
    return true;
}

这里无论是使用openGL ES  还是HWC 来处理,都会调用layer->draw方法。只不过HWC的相对复杂一些而已。

@2 hw->swapBuffers(getHwComposer())分析

这里hw就是DisplayDevice,该部分 在章节(Android GUI系统之SurfaceFlinger(14)理解DisplayDevice)中 分析过,所以这里不再重复。

2.4.3 postFramebuffer分析

postFramebuffer代码实现如下:

void SurfaceFlinger::postFramebuffer()
{
    const nsecs_t now = systemTime();
    mDebugInSwapBuffers = now;

    HWComposer& hwc(getHwComposer());
	//检查是否支持HWC,如果不支持在前面就输出了,直接返回
    if (hwc.initCheck() == NO_ERROR) {
        if (!hwc.supportsFramebufferTarget()) {
            getDefaultDisplayDevice()->makeCurrent(mEGLDisplay, mEGLContext);
        }
		//关键点:支持HWC则 调用该方法
        hwc.commit();
    }
	//...
}

这里继续分析hwc的commit()方法,代码实现如下:

status_t HWComposer::commit() {
    int err = NO_ERROR;
    if (mHwc) {
        if (!hwcHasApiVersion(mHwc, HWC_DEVICE_API_VERSION_1_1)) {
            mLists[0]->dpy = eglGetCurrentDisplay();
            mLists[0]->sur = eglGetCurrentSurface(EGL_DRAW);
        }

        for (size_t i=VIRTUAL_DISPLAY_ID_BASE; ioutbuf = disp.outbufHandle;
                mLists[i]->outbufAcquireFenceFd =
                        disp.outbufAcquireFence->dup();
            }
        }
        //关键点
        err = mHwc->set(mHwc, mNumDisplays, mLists);
        //...
    }
    return (status_t)err;
}

这里主要调用了HWC的 set函数处理之后的工作(set的代码实现往下延伸,就是由厂家来实现了)。同时图像最后输出到显示屏上。

2.5 postComposition分析

postComposition的代码实现如下:

void SurfaceFlinger::postComposition()
{
    const LayerVector& layers(mDrawingState.layersSortedByZ);
    const size_t count = layers.size();
    for (size_t i=0 ; ionPostComposition();
    }
	
    const HWComposer& hwc = getHwComposer();
    sp presentFence = hwc.getDisplayFence(HWC_DISPLAY_PRIMARY);

	//VSync同步
    if (presentFence->isValid()) {
        if (mPrimaryDispSync.addPresentFence(presentFence)) {
            enableHardwareVsync();
        } else {
            disableHardwareVsync(false);
        }
    }

    if (kIgnorePresentFences) {
        const sp hw(getDefaultDisplayDevice());
        if (hw->isDisplayOn()) {
            enableHardwareVsync();
        }
    }
	
	//动画合成处理
    if (mAnimCompositionPending) {
        mAnimCompositionPending = false;

        if (presentFence->isValid()) {
            mAnimFrameTracker.setActualPresentFence(presentFence);
        } else {
            nsecs_t presentTime = hwc.getRefreshTimestamp(HWC_DISPLAY_PRIMARY);
            mAnimFrameTracker.setActualPresentTime(presentTime);
        }
        mAnimFrameTracker.advanceFrame();
    }
}

至此,整个handleMessageRefresh的处理流程就分析结束了。

你可能感兴趣的:(显示子系统,android,android)