Android 同步DisplayList信息

转载请标注出处: http://www.jianshu.com/p/8facd77fac09

Android DisplayList 构建过程 写了DisplayList的构建，接下来要做的事情就是开始渲染DisplayList了，具体的函数是nSyncAndDrawFrame , UI线程通过RenderProxy请求RenderThread执行一个DrawFrameTask, 然后阻塞式等着RenderThread的通知

void DrawFrameTask::postAndWait() {
    AutoMutex _lock(mLock);
    mRenderThread->queue(this);
    mSignal.wait(mLock);  //UI线程blocking等着 RenderThread的回应
}

当RenderThread调度到DrawFrameTask时会执行DrawFrameTask::run()函数。

void DrawFrameTask::run() {
    bool canUnblockUiThread;
    bool canDrawThisFrame;
    {
        TreeInfo info(TreeInfo::MODE_FULL, *mContext);
        info.observer = mObserver;
        canUnblockUiThread = syncFrameState(info);  //同步DisplayList信息
        canDrawThisFrame = info.out.canDrawThisFrame;
    }

    // Grab a copy of everything we need
    CanvasContext* context = mContext;

    if (canUnblockUiThread) { 
        //是否unblock ui线程, 有可能需要RenderThread在这一帧画完后才unblock ui thread
        unblockUiThread();
    }

    if (CC_LIKELY(canDrawThisFrame)) {
        context->draw();
    }

    if (!canUnblockUiThread) {  //与上面的 if(canUnblockUiThread)相反，肯定最后都会unblock ui的，否则就会发生ANR了
        unblockUiThread();
    }
}

上面的run函数包含两个动作，一是sync DisplayList的动作，一个是渲染DisplayList的动作，这篇blog仅分析 DisplayList同步的过程

注意: 这里并不考虑Texture, Layer相关, 那么syncFrameState简化后的代码如下，

bool DrawFrameTask::syncFrameState(TreeInfo& info) {
    // mFrameInfo是一个int形数组，它主要记录事件发生的各种时刻，
    // 比如接收到vsync时间, draw start时间等等
    int64_t vsync = mFrameInfo[static_cast<int>(FrameInfoIndex::Vsync)];
    mRenderThread->timeLord().vsyncReceived(vsync);
    bool canDraw = mContext->makeCurrent(); 

    mContext->prepareTree(info, mFrameInfo, mSyncQueued, mTargetNode);

    // If prepareTextures is false, we ran out of texture cache space
    return info.prepareTextures; 
}

其中 makeCurrent()函数直接调用了eglMakeCurrent,

eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)

该接口将申请到的display，draw（surface）和 egl context进行了绑定。也就是说，在egl context下的OpenGL API指令将draw（surface）作为其渲染最终目的地, 而display作为draw（surface）的前端显示。调用后，当前线程使用的EGLContex为mEglContext. 参考这篇文章

而参数 TreeInfo是个临时变量，它的初始化在 DrawFrameTask::run()

TreeInfo info(TreeInfo::MODE_FULL, *mContext);

如果传入的就 MODE_FULL, TreeInfo里的成员prepareTextures将会置为true, 因为本例代码并不涉及到Texture相关，所以返回值 info.prepareTextures始终为true.

syncFrameState接着开始 prepareTree, 它从CanvasContext开始调用. 如图所示, 就是递归遍历整个Tree.

图1 CanvasContext的UML图
void CanvasContext::prepareTree(TreeInfo& info, int64_t* uiFrameInfo,
        int64_t syncQueued, RenderNode* target) {
    info.damageAccumulator = &mDamageAccumulator; 
    for (const sp<RenderNode>& node : mRenderNodes) {
        // info.mode 依然是MODE_FULL
        info.mode = (node.get() == target ? TreeInfo::MODE_FULL : TreeInfo::MODE_RT_ONLY);
        node->prepareTree(info);
    }
}

CanvasContext里的mRenderNodes是一个Vector，也就是它储存了一系列的RenderNode, 但是这个盒子只有一个RenderNode, 也就是整个UI的RootRenderNode.

void RenderNode::prepareTree(TreeInfo& info) {
    prepareTreeImpl(info, functorsNeedLayer);
}

void RenderNode::prepareTreeImpl(TreeInfo& info, bool functorsNeedLayer) {
    info.damageAccumulator->pushTransform(this);
    if (info.mode == TreeInfo::MODE_FULL) {
        pushStagingPropertiesChanges(info);
    }
    ...
    if (info.mode == TreeInfo::MODE_FULL) {
        pushStagingDisplayListChanges(info);
    }
    prepareSubTree(info, childFunctorsNeedLayer, mDisplayList);
    info.damageAccumulator->popTransform();
}

由prepareTreeImpl的实现看出，先同步 当前的 RenderNode, 然后再递归同步子RenderNode.

一、同步RenderProperties和DisplayList

1.1 pushStagingPropertiesChanges

void RenderNode::pushStagingPropertiesChanges(TreeInfo& info) {
    if (mDirtyPropertyFields) {
        mDirtyPropertyFields = 0;
        damageSelf(info);
        info.damageAccumulator->popTransform();
        syncProperties();
        info.damageAccumulator->pushTransform(this);
        damageSelf(info);
    }
}

mDirtyPropertyFields是一个int变量，它的每一位都表示一种Dirty的类型， 只要RenderNode中 RenderProperties(mStagingProperties表示，该值由UI线程维护)发生变化时，mDirtyPropertyFields就不为0，就表示要同步该Properties.

而同步的方法就是 mProperties = mStagingProperties

其中 mProperites由RenderThread线程维护， 而mStagingProperties由 UI线程维护.

1.2 pushStagingDisplayListChanges

void RenderNode::pushStagingDisplayListChanges(TreeInfo& info) {
        mNeedsDisplayListSync = false;
        damageSelf(info);
        syncDisplayList(&info);
        damageSelf(info);
    }
}

当Java层调用RenderNode.end()后，就会将Canvas中的DisplayList更新到RenderNode中的mStagingDisplayList中，具体参考 Android DisplayList 构建过程第三节。
同时会将 mNeedDisplayListSync置为true, 这样，在sync的时候就会去同步DisplayList, 同步过程如下所示.

void RenderNode::syncDisplayList(TreeInfo* info) {
    // Make sure we inc first so that we don't fluctuate between 0 and 1,
    // which would thrash the layer cache 
    if (mStagingDisplayList) {
        for (auto&& child : mStagingDisplayList->getChildren()) {
            child->renderNode->incParentRefCount();  //增加parent的引用计数
        }    
    }    
    deleteDisplayList(info ? info->observer : nullptr, info);
    mDisplayList = mStagingDisplayList; //重新赋值
    mStagingDisplayList = nullptr; 
    ...
}

从代码中看出，在同步DisplayList后，UI线程维护的mStagingDisplayList就被重新置为null了。而 RenderThread 维护的mDisplayList指向了UI线程的mStagingDisplayList.

二、递归同步子RenderNode

void RenderNode::prepareSubTree(TreeInfo& info, bool functorsNeedLayer, DisplayList* subtree) {
    if (subtree) {
        for (auto&& op : subtree->getChildren()) {
            RenderNode* childNode = op->renderNode;
            info.damageAccumulator->pushTransform(&op->localMatrix);
            childNode->prepareTreeImpl(info, childFunctorsNeedLayer);
            info.damageAccumulator->popTransform();
        }
    }
}

RenderNode在同步完自己的RenderProperties和DisplayList后，开始递归同步子RenderNode信息。
就这样就把整个DisplayTree的信息从UI thread同步到了RenderThread.

三、计算脏区域

3.1 damageSelf()

damageSelf在同步Properties和DisplayList时被调用了两次。
damageSelf这个函数从字面上理解就是"自毁"，那自毁什么呢？从函数定义来看

void RenderNode::damageSelf(TreeInfo& info) {
    if (isRenderable()) {
        if (properties().getClipDamageToBounds()) {
            info.damageAccumulator->dirty(0, 0, properties().getWidth(), properties().getHeight());
        } else {
            info.damageAccumulator->dirty(DIRTY_MIN, DIRTY_MIN, DIRTY_MAX, DIRTY_MAX);
        }    
    }    
}

damageSelf()是RenderNode里面的函数，猜想这个自毁应该是和RenderNode相关。

  • 自毁的前提

damageSelf要工作的一个前提就是 RenderNode是可Renderable (isRenderable())的，从 isRenderable函数定义可以看出，也就是当前的RenderNode已经同步过DisplayList(pushStagingDisplayListChanges)，并且这个DisplayList里有绘制命令。

  • 自毁什么？
    从if else可以看出，自毁是调用DamageAccumulator->dirty
void DamageAccumulator::dirty(float left, float top, float right, float bottom) {
    mHead->pendingDirty.join(left, top, right, bottom); 
}

原来是将mHead的pendingDirty与自毁的区域求并集(具体可以查看 join函数),

DirtyStack* mHead

mHead是在DamageAccumulator里定义的，DamageAccumulator里维护着一个栈，栈顶由mHead指定。

整个DamageAccumulator的栈图如下所示

图2 DamageAccumulator的栈图

damageSelf()函数会计算出 图中浅蓝色背景方块的 pendingDirty, 也就是脏区域. 注意这幅图是针对第一次同步时的栈图。

  • 为什么damageSelf都调用两次呢？

从 1.2 的pushStagingPropertiesChanges和 1.3 的 pushStagingDisplayListChanges可以看出，这两个函数都分别调用了两次 damageSelf(), 为什么呢？

pushStagingPropertiesChanges和pushStagingDisplayListChanges都是从UI线程同步相应的信息到RenderThread线程，那说明RenderThread的线程里保存的是旧数据，而UI线程是新数据，

既然是求脏区域，那么不能只求新数据的脏区域啊，比如，如果一个操作是将View从 1200x300(旧数据) 缩小到1200x150(新数据), 那么这块脏区域是多少呢？ 1200x150？这显然不对了吧，数据从1200x300变换到1200x150, 那么整个脏区域就应该是它们的并集，1200x300.

所以调用两次damageSelf，第一次是针对旧数据，得到一个脏区域，第二次是针对新数据，然后再计算它们的并集也就是整个脏区域。

  • 脏区域的大小

这个就具体参考 getClipDamageToBounds了，它的意思是说是否可以裁剪脏区域到固定的区域, 如果可以的话，那么就将脏区域裁剪到 View的 Width和Height.

3.2 push/pop Transform

pushTransform与popTransform都是成对出现的，它们是DamageAccumulator里的成员函数，
pushTransform有两种定义

  • pushTransform(const RenderNode* transform)
    这种函数形式在prepareTreeImpl中调用，主要是将当前的RenderNode push进栈

  • pushTransform(const Matrix4* transform)
    这种函数形式在prepareSubTree中调用，主要是将RenderNodeOp中的localMatrix进栈

  • popTransform()
    这个就是出栈的操作

通过pushTransform操作就形成了图2 DamageAccumulator的栈图
图中1和2是子view, 它们本就没有子children，所以栈的操作是先对TextView入栈，待TextView的DisplayList与RenderProperties更新完后就会依次对TextView的RenderNode pop，然后对TextView的matrix4 pop.

那么popTransform的操作是干什么的呢？

void DamageAccumulator::popTransform() { 
    DirtyStack* dirtyFrame = mHead;
    mHead = mHead->prev;
    switch (dirtyFrame->type) {
    case TransformRenderNode:  
        applyRenderNodeTransform(dirtyFrame);
        break;
    case TransformMatrix4:     
        applyMatrix4Transform(dirtyFrame);
        break;
    case TransformNone:
        mHead->pendingDirty.join(dirtyFrame->pendingDirty);
        break;
    default:
        LOG_ALWAYS_FATAL("Tried to pop an invalid type: %d", dirtyFrame->type);
    } 
}

从代码可以看出来，先将栈顶元素出栈得到 dirtyFrame, 然后再重新assign 栈顶， 接着针对dirtyFrame的类型再作具体的变换。

以TextView为例

图3 TextView的栈图

TransformRenderNode

void DamageAccumulator::applyRenderNodeTransform(DirtyStack* frame) {
    if (frame->pendingDirty.isEmpty()) { //此时的frame为图中的dirtyFrame, 可以看出它的pendingDirty不为空
        return;
    }   

    const RenderProperties& props = frame->renderNode->properties();
    if (props.getAlpha() <= 0) { //如果 alpha是透明的，那么就没必要继续计算脏区域了，
        return;  
    }   

    // Perform clipping
    if (props.getClipDamageToBounds() && !frame->pendingDirty.isEmpty()) {
        //进入分支， 
        if (!frame->pendingDirty.intersect(0, 0, props.getWidth(), props.getHeight())) {
            frame->pendingDirty.setEmpty();
        }   
    }   

    // apply all transforms
    mapRect(props, frame->pendingDirty, &mHead->pendingDirty);
    ...
}
  • getAlpha() <=0
    那说明这个是透明的属性， 透明的意思就是不显示？ 就不需要应用这些矩阵变换了
  • frame->pendingDirty.intersect()
    这个是求交集的意思，pendingDirty的区域是 (0, 0, 1200, 120)， 而props,getWidth(), props.getHeight()分别也是1200, 120

接下来看mapRect, frame->pendingDrity这块区域是(0, 0, 1200, 120), 而mHead->pendingDirty是图3中浅黄色的pendingDirty (0, 0, 0, 0)

static inline void mapRect(const RenderProperties& props, const SkRect& in, SkRect* out) {
    if (in.isEmpty()) return;
    const SkMatrix* transform = props.getTransformMatrix();
    SkRect temp(in);
    if (transform && !transform->isIdentity()) { //不会进入该分支
        if (CC_LIKELY(!transform->hasPerspective())) {
            transform->mapRect(&temp);
        } else {
             // Don't attempt to calculate damage for a perspective transform
            // as the numbers this works with can break the perspective
            // calculations. Just give up and expand to DIRTY_MIN/DIRTY_MAX
            temp.set(DIRTY_MIN, DIRTY_MIN, DIRTY_MAX, DIRTY_MAX);
        }   
    }   
    temp.offset(props.getLeft(), props.getTop());
    out->join(temp);
}
  • isIdentity()
    这个判断是否是单位矩阵，一般都是单位矩阵， 所以并不会进入 if分支. 所以最后out的区域大小为(0, 0, 1200, 120). 也就是mHead->pendingDirty，也就是下图黄色块区域
图4 更新RenderNode后的脏区域

TransformMatrix4

void DamageAccumulator::applyMatrix4Transform(DirtyStack* frame) {
    mapRect(frame->matrix4, frame->pendingDirty, &mHead->pendingDirty);
}

static inline void mapRect(const Matrix4* matrix, const SkRect& in, SkRect* out) {
    if (in.isEmpty()) return;
    Rect temp(in);
    if (CC_LIKELY(!matrix->isPerspective())) {
       matrix->mapRect(temp);
    } else {
        // Don't attempt to calculate damage for a perspective transform
        // as the numbers this works with can break the perspective
        // calculations. Just give up and expand to DIRTY_MIN/DIRTY_MAX
        temp.set(DIRTY_MIN, DIRTY_MIN, DIRTY_MAX, DIRTY_MAX);
    }
    out->join(RECT_ARGS(temp));
}

那么现在TextView相关的栈图如下所示

图5 poping Textview Matrix

此时 mHead指向LinearLayout_2, dirtyFrame指向浅黄色的DirtyStack.
即 frame->pendingDirty 区域是(0, 0, 1200, 120), mHead->pendingDirty (0, 0, 1200, 1776),

代码中 isPerspective() 这个意思是判断矩阵是否是投影矩阵。在一般的矩阵都不是投影矩阵，所以一般会进入 if分支 matrix->mapRect(temp), 最后再和out( mHead->pendingDirty)求并集， 最后的out(mHead->pendingDirty)的pendingDirty依然还是 (0, 0, 1200, 1776)

四、小结

经过1, 2小节后，整个DisplayList tree都同步更新了，并且经过3 算出来整张画布的脏区域, 因为是第一次同步，所以这里算出来的脏区域为默认的最大画布(DIRTY_MIN, DIRTY_MIN, DIRTY_MAX, DIRTY_MAX), 且它的值保存在DamageAccumulator.mHead->pendingDirty中.

可以看出， syncFrameState就完成两件事，一件是从UI线程同步 RenderProperties和DisplayList 到RenderThread线程，第二件事就是计算出画面的脏区域。

最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 206,378评论 6赞 481
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 88,356评论 2赞 382
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 152,702评论 0赞 342
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 55,259评论 1赞 279
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 64,263评论 5赞 371
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,036评论 1赞 285
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 38,349评论 3赞 400
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 36,979评论 0赞 259
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 43,469评论 1赞 300
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 35,938评论 2赞 323
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,059评论 1赞 333
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 33,703评论 4赞 323
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,257评论 3赞 307
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,262评论 0赞 19
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 31,485评论 1赞 262
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 45,501评论 2赞 354
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 42,792评论 2赞 345

推荐阅读更多精彩内容