本内容基于自己对于代码的理解以及网上大牛的博客参考写的，作为回顾时的参考之用。
这里为什么要用Transaction(事务)这个词呢？ 我们从数据库事务概念大致可以看出一点端倪, 它的其中一个很重要的信息就是说**"将一组相关操作组合成一个单元去处理"**, 这个有点意思，这个思路也运用在了SurfaceFlinger里，为什么呢？handleTransaction就是处理一次事务，因为每一个Vsync去刷新一次，但是在一个Vsync周期里，Layer中的属性可能改变了，由于Layer的属性有很多，如果改变一个就去触发相关操作，这样显然是浪费资源的事情，所以正确的做法就是当Layer属性的值改变了，然后记录下来，最后在 handleTransaction 一次就处理完了。
事务标志位有三种基本类形(可以是多种组合)
enum {
eTransactionNeeded = 0x01, //Layer的属性发生变化了，表示需要处理事务
eTraversalNeeded = 0x02, //遍历的是SurfaceFlinger中所有的Layer
eDisplayTransactionNeeded = 0x04, //这个是显示器相关的事务,如显示器hotplug
eTransactionMask = 0x07 //掩码
};
-
State mCurrentState SurfaceFlinger下一帧的状态
-
State mDrawingState 当前正在绘制的状态，这个是SurfaceFlinger处理完事务后更新出来的状态，是最终的状态
-
mVisibleRegionsDirty 表示当前可见区域是否脏了，如果脏了的话，比如(layer added/removed, Display added/remove相关)在最后合成的时候会对每个屏幕重建layer stack, 但是一般都为false
struct State {
LayerVector layersSortedByZ; //SurfaceFlinger中所有的按照Z order排序的 Layer
DefaultKeyedVector< wp<IBinder>, DisplayDeviceState> displays; //外接的显示屏
};
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).
//保存 mDrawingState, 但是这里根本没有使用到
State drawingState(mDrawingState);
Mutex::Autolock _l(mStateLock);
const nsecs_t now = systemTime();
mDebugInTransaction = now;
// Here we're guaranteed that some transaction flags are set
// so we can call handleTransactionLocked() unconditionally.
// We call getTransactionFlags(), which will also clear the flags,
// with mStateLock held to guarantee that mCurrentState won't change
// until the transaction is committed.
//获得SurfaceFlinger中的Transaction标志位
transactionFlags = getTransactionFlags(eTransactionMask);
handleTransactionLocked(transactionFlags); //真正处理事务的函数
mLastTransactionTime = systemTime() - now;
mDebugInTransaction = 0;
invalidateHwcGeometry();
// here the transaction has been committed
}
void SurfaceFlinger::handleTransactionLocked(uint32_t transactionFlags)
{
//获得当前所有Layer
const LayerVector& currentLayers(mCurrentState.layersSortedByZ);
const size_t count = currentLayers.size();
// Notify all layers of available frames
for (size_t i = 0; i < count; ++i) {
//检查当前Frame是否是SyncPoint需要的(也就说之前想延迟的Buffer已经到来了), 如果是，则设置SyncPoint中mFrameIsAvailable为true
currentLayers[i]->notifyAvailableFrames();
}
/*
* Traversal of the children
* (perform the transaction for each of them if needed)
*/
//遍历所有的Layer, 让Layer去执行自己的事务
if (transactionFlags & eTraversalNeeded) {
for (size_t i=0 ; i<count ; i++) {
const sp<Layer>& layer(currentLayers[i]);
// 获得Layer的Transaction flags
uint32_t trFlags = layer->getTransactionFlags(eTransactionNeeded);
if (!trFlags) continue;
// Layer处理自己的事务
const uint32_t flags = layer->doTransaction(0);
if (flags & Layer::eVisibleRegion)
//如果Layer的可见区域改变了，则SurfaceFlinger就标注出当前可视区域改变了
mVisibleRegionsDirty = true;
}
}
/*
* Perform display own transactions if needed
*/
//跟显示器相关的事务，比如hotplug显示屏, 初始化/销除显示屏，显示屏的配置变化，
if (transactionFlags & eDisplayTransactionNeeded) {
}
if (transactionFlags & (eTraversalNeeded|eDisplayTransactionNeeded)) {
// The transform hint might have changed for some layers
// (either because a display has changed, or because a layer
// as changed).
//
// Walk through all the layers in currentLayers,
// and update their transform hint.
//
// If a layer is visible only on a single display, then that
// display is used to calculate the hint, otherwise we use the
// default display.
//
// NOTE: we do this here, rather than in rebuildLayerStacks() so that
// the hint is set before we acquire a buffer from the surface texture.
//
// NOTE: layer transactions have taken place already, so we use their
// drawing state. However, SurfaceFlinger's own transaction has not
// happened yet, so we must use the current state layer list
// (soon to become the drawing state list).
//
sp<const DisplayDevice> disp;
uint32_t currentlayerStack = 0;
for (size_t i=0; i<count; i++) {
// NOTE: we rely on the fact that layers are sorted by
// layerStack first (so we don't have to traverse the list
// of displays for every layer).
const sp<Layer>& layer(currentLayers[i]);
//获得Layer的 layer stack
uint32_t layerStack = layer->getDrawingState().layerStack;
//通过遍历所有的Display来找到Layer所在的显示屏
if (i==0 || currentlayerStack != layerStack) {
currentlayerStack = layerStack;
// figure out if this layerstack is mirrored
// (more than one display) if so, pick the default display,
// if not, pick the only display it's on.
disp.clear();
for (size_t dpy=0 ; dpy<mDisplays.size() ; dpy++) {
sp<const DisplayDevice> hw(mDisplays[dpy]);
if (hw->getLayerStack() == currentlayerStack) {
if (disp == NULL) {
disp = hw;
} else {
disp = NULL;
break;
}
}
}
}
if (disp == NULL) {
// NOTE: TEMPORARY FIX ONLY. Real fix should cause layers to
// redraw after transform hint changes. See bug 8508397.
// could be null when this layer is using a layerStack
// that is not visible on any display. Also can occur at
// screen off/on times.
disp = getDefaultDisplayDevice();
}
//更新Layer的旋转方向，最终会体现在 BufferQueueCore中的mTransformHint变量
layer->updateTransformHint(disp);
}
}
/*
* Perform our own transaction if needed
*/
//前面都是执行的Layer相关的事务
//下面就是执行SurfaceFlinger自己的事务
const LayerVector& layers(mDrawingState.layersSortedByZ);
if (currentLayers.size() > layers.size()) {
// layers have been added , 有新的Layer加入
mVisibleRegionsDirty = true;
}
// some layers might have been removed, so
// we need to update the regions they're exposing.
//下面有Layer移出了的情况
if (mLayersRemoved) {
mLayersRemoved = false;
mVisibleRegionsDirty = true;
const size_t count = layers.size();
for (size_t i=0 ; i<count ; i++) {
const sp<Layer>& layer(layers[i]);
if (currentLayers.indexOf(layer) < 0) {
// this layer is not visible anymore
// TODO: we could traverse the tree from front to back and
// compute the actual visible region
// TODO: we could cache the transformed region
const Layer::State& s(layer->getDrawingState());
//获得移除的Layer的可见区域, 这块可见区域就是dirty的
Region visibleReg = s.active.transform.transform(
Region(Rect(s.active.w, s.active.h)));
//找到被移除掉的Layer所在的Display, 然后更新Diplay的dirty 区域，也就是对region做或运算
invalidateLayerStack(s.layerStack, visibleReg);
}
}
}
//提交事务
commitTransaction();
//更新Display中光标的位置
updateCursorAsync();
}
void SurfaceFlinger::commitTransaction()
{
//mLayersPendingRemoval是保存的是pending 着需要移除的Layer. 比如APP调用destroySurface
if (!mLayersPendingRemoval.isEmpty()) {
// Notify removed layers now that they can't be drawn from
for (size_t i = 0; i < mLayersPendingRemoval.size(); i++) {
mLayersPendingRemoval[i]->onRemoved(); //回调 onRemoved， 调用Consumer的consumerDisconnect，清理BufferQueueBuffer
}
mLayersPendingRemoval.clear();
}
// If this transaction is part of a window animation then the next frame
// we composite should be considered an animation as well.
mAnimCompositionPending = mAnimTransactionPending;
//更新 mDrawingState
mDrawingState = mCurrentState;
mTransactionPending = false;
mAnimTransactionPending = false;
//释放mTransactionCV, 如果SurfaceFlinger正在处理事务，而这时如果调用setTransactionState就可能会一直等着mTransactionCV,
//因为setTransactionState可能会改变SurfaceFlinger的Transaction标志位，导致前后不一致
mTransactionCV.broadcast();
}
-
sp mSidebandStream; //sideband buffer stream
-
std::list<std::shared_ptr> mLocalSyncPoints; //一系列的SyncPoint, 这些SyncPoint是在特定的Frame来了才更新
-
State mCurrentState; 表示Layer下一帧的属性状态，当某个属性变化时，直接操作该变量
-
State mDrawingState;
表示当前正在绘制的帧的属性状态。Layer处理完事务后，最终的用于绘制的状态
struct State {
Geometry active; //当前Layer的可见区域
Geometry requested; //请求的Layer的可见区域, 在Layer做doTransaction时会将 requested赋值给active. setSize/setMatrix/setPosition
uint32_t z;
uint32_t layerStack; //layerStack指明当前Layer属于哪个Display，Display的layer stack可以用 hw->getLayerStack获得
uint8_t alpha;
uint8_t flags;
uint8_t mask;
uint8_t reserved[2];
int32_t sequence; //当Layer的属性变化时， sequence就会加1
bool modified; //当Layer的属性变化了，该变量就会被置为true
Rect crop;
Rect finalCrop;
// If set, defers this state update until the Layer identified by handle
// receives a frame with the given frameNumber
sp<IBinder> handle; //延迟更新特定的Frame
uint64_t frameNumber; //这个就是Handle要延迟的Frame号
// the transparentRegion hint is a bit special, it's latched only
// when we receive a buffer -- this is because it's "content"
// dependent.
Region activeTransparentRegion;
Region requestedTransparentRegion;
};
struct Geometry {
uint32_t w;
uint32_t h;
Transform transform; //Geometry的传输矩阵
};
// Layer处理的事务
uint32_t Layer::doTransaction(uint32_t flags) {
ATRACE_CALL();
pushPendingState(); //将mCurrentState保存到mPendingStates中
//获得Layer的mCurrentState, 这里为什么不直接用mCurrentState呢？是因为防止mCurrentState在处理的时候被其它线程给改变了
Layer::State c = getCurrentState();
if (!applyPendingStates(&c)) { //针对 SyncPoints相关
return 0;
}
//获得上一次的Drawing state
const Layer::State& s(getDrawingState());
//如果requested的可见区域与旧的可见区域不同了，则size changed
const bool sizeChanged = (c.requested.w != s.requested.w) ||
(c.requested.h != s.requested.h);
if (sizeChanged) {
// 如果size changed, 把新的 w|h 设置到 BufferQueueCore中的 mDefaultWidth|mDefaultHeight中去
mSurfaceFlingerConsumer->setDefaultBufferSize(
c.requested.w, c.requested.h);
}
//如果新的请求的 w|h 与新的原本要显示的区域不同，表明是 resize了
const bool resizePending = (c.requested.w != c.active.w) ||
(c.requested.h != c.active.h);
if (!isFixedSize()) {
if (resizePending && mSidebandStream == NULL) {
//resize只发生在非固定尺寸模式，并且sideband layer(sideband buffer stream)为空的情况
// don't let Layer::doTransaction update the drawing state
// if we have a pending resize, unless we are in fixed-size mode.
// the drawing state will be updated only once we receive a buffer
// with the correct size.
//
// in particular, we want to make sure the clip (which is part
// of the geometry state) is latched together with the size but is
// latched immediately when no resizing is involved.
//
// If a sideband stream is attached, however, we want to skip this
// optimization so that transactions aren't missed when a buffer
// never arrives
flags |= eDontUpdateGeometryState;
}
}
// always set active to requested, unless we're asked not to
// this is used by Layer, which special cases resizes.
if (flags & eDontUpdateGeometryState) { //这个是在resize里面做的，
} else {
//这里是允许更新 可见区域
Layer::State& editCurrentState(getCurrentState());
if (mFreezePositionUpdates) {
float tx = c.active.transform.tx();
float ty = c.active.transform.ty();
c.active = c.requested;
c.active.transform.set(tx, ty);
editCurrentState.active = c.active;
} else {
editCurrentState.active = editCurrentState.requested;
c.active = c.requested;
}
}
if (s.active != c.active) {
// invalidate and recompute the visible regions if needed
flags |= Layer::eVisibleRegion;
}
// 只要Layer有属性发生变化了，sequence就会加1,这样可以很直观判断是否当前的state和旧的state是否发生变化了
// 但是这样并不能保证sequence相同，但是属性变化的这种情况
if (c.sequence != s.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 = c.active.transform.getType();
mNeedsFiltering = (!c.active.transform.preserveRects() ||
(type >= Transform::SCALE));
}
// If the layer is hidden, signal and clear out all local sync points so
// that transactions for layers depending on this layer's frames becoming
// visible are not blocked
//是否Layer是hide的
if (c.flags & layer_state_t::eLayerHidden) {
Mutex::Autolock lock(mLocalSyncPointMutex);
for (auto& point : mLocalSyncPoints) {
point->setFrameAvailable();
}
mLocalSyncPoints.clear();
}
// Commit the transaction
//提交事务
commitTransaction(c);
return flags;
}
void Layer::pushPendingState() {
//只要Layer的属性改变了，都会将modified置为true
if (!mCurrentState.modified) {
return;
}
// If this transaction is waiting on the receipt of a frame, generate a sync
// point and send it to the remote layer.
if (mCurrentState.handle != nullptr) { //表示当前需要等着特定的frame(frame number号标识)
sp<Handle> handle = static_cast<Handle*>(mCurrentState.handle.get());
sp<Layer> handleLayer = handle->owner.promote();
if (handleLayer == nullptr) {
ALOGE("[%s] Unable to promote Layer handle", mName.string());
// If we can't promote the layer we are intended to wait on,
// then it is expired or otherwise invalid. Allow this transaction
// to be applied as per normal (no synchronization).
mCurrentState.handle = nullptr;
} else {
//创建一个 SyncPoint， 表示只在 frameNumber的这个Frame才更新
auto syncPoint = std::make_shared<SyncPoint>(
mCurrentState.frameNumber);
if (handleLayer->addSyncPoint(syncPoint)) { //加入到 mLocalSyncPoints
mRemoteSyncPoints.push_back(std::move(syncPoint));
} else {
// We already missed the frame we're supposed to synchronize
// on, so go ahead and apply the state update
mCurrentState.handle = nullptr;
}
}
// Wake us up to check if the frame has been received
setTransactionFlags(eTransactionNeeded);
}
//将当前的状态保存在mPendingStates, 接下来会处理到
mPendingStates.push_back(mCurrentState);
}
//提交事务， 也就是更新 Layer的 mDrawingState
void Layer::commitTransaction(const State& stateToCommit) {
mDrawingState = stateToCommit;
}