Android SurfaceFlinger对VSync信号的处理过程分析

void SurfaceFlinger::handleTransaction(uint32_t transactionFlags)
{
    ATRACE_CALL();
    // here we keep a copy of the drawing state (that is the state that's
    // going to be overwritten by handleTransactionLocked()) outside of
    // mStateLock so that the side-effects of the State assignment
    // don't happen with mStateLock held (which can cause deadlocks).
    State drawingState(mDrawingState);

    Mutex::Autolock _l(mStateLock);
    const nsecs_t now = systemTime();
    mDebugInTransaction = now;
	//系统显示屏的属性发生了变化，eTransactionNeeded位就会等于1
	//应用程序窗口的属性发生了变化，eTraversalNeeded位就会等于1
    const uint32_t mask = eTransactionNeeded | eTraversalNeeded;
	//检查系统显示屏或者应用程序窗口的属性是否发生了变化
    transactionFlags = getTransactionFlags(mask);
    handleTransactionLocked(transactionFlags);

    mLastTransactionTime = systemTime() - now;
    mDebugInTransaction = 0;
    invalidateHwcGeometry();
    // here the transaction has been committed
}

void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
{
	//mCurrentState指向当前状态State对象，State对象的成员变量layersSortedByZ保存了SufaceFlinger服///务当前所需要渲染的应用程序窗口
    const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
    const size_t count = currentLayers.size();
	//应用程序窗口的属性发生了变化
    const bool layersNeedTransaction = transactionFlags & eTraversalNeeded;
    if (layersNeedTransaction) {
		//循环检查每一个应用程序窗口的属性是否发生了变化
        for (size_t i=0 ; i<count ; i++) {
            const sp<LayerBase>& layer = currentLayers[i];
            uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
			//应用程序窗口的属性被修改过
            if (!trFlags) continue;
			//处理应用程序窗口的属性变化
            const uint32_t flags = layer->doTransaction(0);
			//如果一个应用程序窗口发生的属性变化是可见区域发生了改变
            if (flags & Layer::eVisibleRegion)
				//要重新计算各个应用程序窗口的可见区域
                mVisibleRegionsDirty = true;
        }
    }
	//系统显示屏的属性发生了变化
    if (transactionFlags & eTransactionNeeded) {
		//mDrawingState用来描述SufaceFlinger服务的上一次渲染状态
		//mCurrentState用来描述SufaceFlinger服务当前渲染状态
		//判断系统显示屏的旋转方向是否发生变化
        if (mCurrentState.orientation != mDrawingState.orientation) {
			//重新设置系统显示屏的旋转方向
            const int dpy = 0;
            const int orientation = mCurrentState.orientation;
            // Currently unused: const uint32_t flags = mCurrentState.orientationFlags;
            GraphicPlane& plane(graphicPlane(dpy));
            plane.setOrientation(orientation);
			//同步更新的是mServerCblk中的信息,它是提供给各应用程序查询当前显示属性的,
			//包括宽、高、格式、旋转角度、fps、密度等一系列数据。
            // update the shared control block
            const DisplayHardware& hw(plane.displayHardware());
            volatile display_cblk_t* dcblk = mServerCblk->displays + dpy;
            dcblk->orientation = orientation;
            dcblk->w = plane.getWidth();
            dcblk->h = plane.getHeight();
			//需要重新计算各个应用程序窗口的可见区域
            mVisibleRegionsDirty = true;
			//需要重新绘制整个显示屏
            mDirtyRegion.set(hw.bounds());
        }
        //判断是否增加了应用程序窗口
        if (currentLayers.size() > mDrawingState.layersSortedByZ.size()) {
            //需要重新计算各个应用程序窗口的可见区域
            mVisibleRegionsDirty = true;
        }
        //判断是否移除了某些应用程序窗口
        if (mLayersRemoved) {
            mLayersRemoved = false;
			//一旦图层被移除,意味着被它遮盖的区域就有可能重新显露出来
			//所以需要重新计算各个应用程序窗口的可见区域
            mVisibleRegionsDirty = true;
            const LayerVector& previousLayers(mDrawingState.layersSortedByZ);
            const size_t count = previousLayers.size();
			//查找已经被移除的应用程序窗口
            for (size_t i=0 ; i<count ; i++) {
                const sp<LayerBase>& layer(previousLayers[i]);
				//在mCurrentState找不到了,就认为被移除了
                if (currentLayers.indexOf( layer ) < 0) {
					//需要将它所占用的区域增加到mDirtyRegionRemovedLayer所描述的一个区域去
                    mDirtyRegionRemovedLayer.orSelf(layer->visibleRegionScreen);
                }
            }
        }
    }
	//系统显示屏以及各个应用程序窗口的属性变化已经处理完毕,把mCurrentState赋给mmDrawingState
    commitTransaction();
}

uint32_t Layer::doTransaction(uint32_t flags)
{
    ATRACE_CALL();
	//每一个应用程序窗口在内部也分别使用两个类型为State的成员变量来描述前后状态
	//mDrawingState描述上一次的渲染状态
    const Layer::State& front(drawingState());
	//mCurrentState描述当前渲染状态
    const Layer::State& temp(currentState());
	//判断窗口大小是否改变
    const bool sizeChanged = (temp.requested.w != front.requested.w) ||
                             (temp.requested.h != front.requested.h);
	//应用程序窗口的大小发生了变化
    if (sizeChanged) {
        // the size changed, we need to ask our client to request a new buffer
        // record the new size, form this point on, when the client request
        // a buffer, it'll get the new size.
        mSurfaceTexture->setDefaultBufferSize(temp.requested.w, temp.requested.h);
    }
	//判断是否为固定大小模式
    if (!isFixedSize()) {
        const bool resizePending = (temp.requested.w != temp.active.w) ||
                                   (temp.requested.h != temp.active.h);
        if (resizePending) {
            flags |= eDontUpdateGeometryState;
        }
    }
    return LayerBase::doTransaction(flags);
}

uint32_t LayerBase::doTransaction(uint32_t flags)
{
    const Layer::State& front(drawingState());
    const Layer::State& temp(currentState());
    // always set active to requested, unless we're asked not to
    // this is used by Layer, which special cases resizes.
    if (flags & eDontUpdateGeometryState)  {
    } else {
        Layer::State& editTemp(currentState());
        editTemp.active = temp.requested;
    }
	//窗口激活状态发生变化，需要重新计算可见区域
    if (front.active != temp.active) {
        // invalidate and recompute the visible regions if needed
        flags |= Layer::eVisibleRegion;
    }
	//sequence用来描述一个应用程序窗口的其它属性是否发生过变化，当Layer的position、z­order、alpha
	//matrix、transparent region、flags、crop等一系列属性发生变化，sequence的值就会比原来增加1。
	//通过sequence收集属性的变化,而到了VSYNC信号产生时才做统一处理
    if (temp.sequence != front.sequence) {
        // invalidate and recompute the visible regions if needed
        flags |= eVisibleRegion;
        this->contentDirty = true;
        // we may use linear filtering, if the matrix scales us
        const uint8_t type = temp.transform.getType();
        mNeedsFiltering = (!temp.transform.preserveRects() ||(type >= Transform::SCALE));
    }
    //应用程序窗口属性变化已经处理完毕，交换前后状态
    commitTransaction();
    return flags;
}