Android DisplayList 构建过程

2字数 1683阅读 5711

转载请标注出处:http://www.jianshu.com/p/7bf306c09c7e

先推荐一篇很不错的关于DisplayList构建的文章 Android N中UI硬件渲染(hwui)的HWUI_NEW_OPS(基于Android 7.1)
看得出来作者对于硬件加速这块研究的很透彻, 对于一些概念性的东西解释的很到位,强烈建议大家去拜读一下。

而本文以具体的例子(MyView绘制)来解释DisplayList的构建过程,相信会更加直观, 更易理解DisplayList相关的代码与概念。

一、前言

1.1 代码环境

本文就是一个很简单的Android sample,onCreate里去inflate activity_main.xml

    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        ...
    }

activity_main.xml

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/sample_text"
        android:layout_width="match_parent"
        android:layout_height="60dp"
        android:gravity="center"
        android:textSize="20sp"
        android:text="Hello World!" />
    
    <cc.bobby.debugapp.MyView
        android:layout_width="match_parent"
        android:layout_height="100dp" />
</LinearLayout>

而MyView也就是override了 onDraw函数,这个见第二节。

最终的整个View图大致如下所示

图1 View Hierarchy

1.2 updateRootDisplayList的递归调用过程

基于1.1的View Hierarchy的代码调用过程如下所示

图2 DisplayList构建过程

二、MyView的回调 onDraw

MyView的onDraw(Canvas canvas)回调函数允许开发者在已经获得的Canvas上绘制了, 这些绘制就是直接在显示设备上画图了么? 当然不是,实际上它仅仅是将绘制命令保存到 DisplayList 里面。

来看下自定义的 MyView中的 onDraw函数

protected void onDraw(Canvas canvas) {
    super.onDraw(canvas);

    mPaint.setColor(Color.RED);
    canvas.drawCircle(100, 100, 100, mPaint); //绘制一个圆,圆心(100, 100), 半径100

    canvas.save();
    canvas.translate(250, 0);  //坐标系向右移动250

    mPaint.setColor(Color.GRAY);
    canvas.drawRect(0, 0, 200, 200, mPaint);  //在新的坐标系中画一个200x200的正方形

    mPaint.setColor(Color.YELLOW);

    Path path = new Path();
    path.moveTo(500, 0);
    path.lineTo(700, 0);
    path.lineTo(500, 200);
    path.close();
    canvas.drawPath(path, mPaint);   //在新的坐标系中画一个三角形
    canvas.restore();
}

最终绘制出来的图如下MyView所示,一个圆,一个正方形,一个三角形


图3 MyView

那这些绘制命令是怎么保存到DisplayList中的呢?

图4 Canvas类图

如图所示,RenderNode在绘制时会创建一个DisplayListCanvas,而对应于Native的是一个RecordingCanvas(这个HWUI_NEW_OPS宏已经被默认为true了), 这个RecordingCanvas会将后续的绘制命令保存到DisplayList当中, 其中

  • mSnapshot: 表示当前的快照,用来记录当前绘制的坐标系
  • mFirstSnapshot: 一个初始快照,保存初始化的一些值

注意: 一个RenderNode可以有多个Snapshot, 这取决于程序调用 canvas.save的个数,所有的Snapshot通过单链表(*previous)组织起来,表头由 mSnapshot 指定。

2.1 没有Canvas.save

正常情况下,如果没有 canvas.save, 所有的绘制都是在mSnapshot中进行
如 MyView 中的 drawCircle

    mPaint.setColor(Color.RED);
    canvas.drawCircle(getPivotX(), getPivotY(), getHeight()/2, mPaint);

drawCircle在Native层的调用过程如下

void RecordingCanvas::drawCircle(float x, float y, float radius, const SkPaint& paint) {
    if (radius <= 0) return;
    drawOval(x - radius, y - radius, x + radius, y + radius, paint);
}

void RecordingCanvas::drawOval(float left, float top, float right, float bottom, const SkPaint& paint) {
    addOp(alloc().create_trivial<OvalOp>(
            Rect(left, top, right, bottom),
            *(mState.currentSnapshot()->transform),
            getRecordedClip(),
            refPaint(&paint)));
}

mState.currentSnapshot() 即 mSnapshot,Snapshot中的transform是一个Matrix4的矩阵类,它主要保存当前Snapshot中的 translate/rotate/scale等值, 其实就是坐标系的值。

drawCircle在MyView的(100, 100)位置画一个半径为100的圆圈, 它在RecordingCanvas中表示如下,

图5 drawCircle

2.2 有canvas.save的情况

接着看下onDraw后面的绘制

    canvas.save();
    canvas.translate(250, 0);  //坐标系向右移动250

    mPaint.setColor(Color.GRAY);
    canvas.drawRect(0, 0, 200, 200, mPaint);  //在新的坐标系中画一个200x200的正方形

    mPaint.setColor(Color.YELLOW);

    Path path = new Path();
    path.moveTo(500, 0);
    path.lineTo(700, 0);
    path.lineTo(500, 200);
    path.close();
    canvas.drawPath(path, mPaint);   //在新的坐标系中画一个三角形
    canvas.restore();

canvas.save()在Native中使用一个新Snapshot_2来保存后续的绘制,因为canvas可能会有一些translate/scale又或者是rotate的操作, 而这些操作又会导致坐标系的改变,如果直接在当前Snapshot_1中绘制,一旦坐标系变了,那可能会对后续的绘制命令造成意料之外的结果。
接下来我们来看下canvas.save的实现

    public int save() {
        return native_save(mNativeCanvasWrapper, MATRIX_SAVE_FLAG | CLIP_SAVE_FLAG);
    }

native_save中第二个参数指明是否将当前的Snapshot_1中的Matrix/clip相关信息保存到新的Snapshot_2中,即是否是基于当前坐标系绘制。而 native_save最终会调用CanvasState的saveSnapshot

int CanvasState::saveSnapshot(int flags) {
    mSnapshot = allocSnapshot(mSnapshot, flags);
    return mSaveCount++;
}
Snapshot* CanvasState::allocSnapshot(Snapshot* previous, int savecount) {
    void* memory;
    if (mSnapshotPool) {
        memory = mSnapshotPool;
        mSnapshotPool = mSnapshotPool->previous;
        mSnapshotPoolCount--;
    } else {
        memory = malloc(sizeof(Snapshot));
    }   
    return new (memory) Snapshot(previous, savecount);
}

mSnapshotPool是一个Snapshot的内存沲子,因为Java层的DisplayListCanvas是临时绘制,最终都会回收掉,同样native的RecordingCanvas一样,因此为了避免重复的申请/释放内存,索性就不释放,只需重置一下就好, 而Snapshot在一个Canvas的个数取决于canvas.save的调用次数, 尽管对调用次数没有限制,但是防止内存被消耗完,与save对应的restore会释放掉多于10个以上的Snapshot,即一个RecordingCanvas最多保存10个Snapshot内存, 并储存在 mSnapshotPool内存沲子里。

最终的RecordingCanvas绘制后的类图如下所示

图6 canvas.save

注意: 事实上 canvas.restore会将 Snapshot_2回收到 mSnapshotPool中,为了方便,这里就不再刻意画出来。
从图中可以看出来,对坐标系的变换比如translate会直接操作Snapshot的transform所指向的Matrix4, 而绘制命令(由RecordedOp表示)如 drawRect/drawPath会保存到DisplayList的ops vector中,

DisplayList中的chunk表示一组RecordedOp, 它用于记录一组RecordedOp在ops中的位置区域,如图中所示 chunk的beginOpIndex=0, endOpIndex=3, 表示ops[0], ops[1], ops[2]是一组InOder的绘制命令。

在Java层与Chunk相关的两个函数被设置成了hide, 即开发者不能直接调用

insertInorderBarrier()
insertReorderBarrier()

而这两个函数最终会影响 RecordingCanvas mDeferredBarrierType,最终影响addOp这个函数

以上是MyView在canvas里绘制过程, 下面来看下DisplayList是怎样保存到MyView的RenderNode中的

三、MyView保存DisplayList到RenderNode中

MyView的绘制过程

MyView.draw(canvas_LinearLayout_2, ViewGroup parent, long drawingTime)   //MyView开始draw, 注意此时传进来还是canvas_LinearLayout_2
    MyView.updateDisplayListIfDirty   //生成canvas_MyView(1200x100)
        draw(canvas_MyView)  //MyView开始draw  此时的canvas: canvas_MyView
            drawBackground(canvas_MyView) //不讨论这个
            onDraw(canvas_MyView)   //回调MyView的onDraw
            onDrawForeground(canvas_MyView) //略过
            
        MyView.mRenderNode.end(canvas_MyView) //MyView的结束recording display list 
    canvas_LinearLayout_2.drawRenderNode(MyView.mRenderNode) //将MyView的DisplayList加入到LinearLayout_2的DisplayList中

MyView在updateDisplayListIfDirty函数中会去获得一张Canvas,用来记录绘制命令

public RenderNode updateDisplayListIfDirty() {
    ...
    final DisplayListCanvas canvas = renderNode.start(width, height);
    ...
}
图7 RenderNode and Canvas

onDraw过程请参考第一节

现在来看下 MyView.mRenderNode.end(canvas_MyView)

    public void end(DisplayListCanvas canvas) {
        long displayList = canvas.finishRecording();
        nSetDisplayList(mNativeRenderNode, displayList);
        canvas.recycle(); //将Java层中的canvas回收到sPool中
        mValid = true;  //mValid=true表示RenderNode中DisplayList已经有效了
    }

canvas.finishRecording()函数会直接返回native中RecordingCanvas所指示的DisplayList地址
然后通过 nSetDisplayList将DisplayList保存到Native的RenderNode的mStagingDisplayList中, 如下图所示

图8 将cavnas中的DisplayList保存到MyView的Native RenderNode当中

四、LinearLayout_2保存MyView的DisplayList

第二节仅仅是将DisplayList保存到MyView的RenderNode中了,扩展到一般性,即每个View都有自己的RenderNode, DisplayList, 各个View之间有没有联系? 如果有,那它们是怎样联系起来的呢?

接下来看第二节开始的最后那块代码,

canvas_LinearLayout_2.drawRenderNode(MyView.mRenderNode) 

canvas_LinearLayout_2即是LinearLayout_2的canvas, 而MyView又是LinearLayout_2的一个子view, 它们之间通过DisplayListCanvas的drawRenderNode 有了相关联系,

public void drawRenderNode(RenderNode renderNode) {
    nDrawRenderNode(mNativeCanvasWrapper, renderNode.getNativeDisplayList());
    //mNativeCanvasWrapper指向LinearLayout_2对应的native canvas, 
    //renderNode是MyView的RenderNode, 这里获得的renderNode对应jni中的RenderNode地址
}

nDrawRenderNode最终后调用到jni android_view_DisplayListCanvas_drawRenderNode

static void android_view_DisplayListCanvas_drawRenderNode(JNIEnv* env,
        jobject clazz, jlong canvasPtr, jlong renderNodePtr) {
    Canvas* canvas = reinterpret_cast<Canvas*>(canvasPtr);    // LinearLayout_2的canvas
    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr); //MyView的RenderNode
    canvas->drawRenderNode(renderNode);
}

接着来看下drawRenderNode()

void RecordingCanvas::drawRenderNode(RenderNode* renderNode) {
    auto&& stagingProps = renderNode->stagingProperties();
    RenderNodeOp* op = alloc().create_trivial<RenderNodeOp>(
            Rect(stagingProps.getWidth(), stagingProps.getHeight()),
            *(mState.currentSnapshot()->transform),
            getRecordedClip(),
            renderNode);
    int opIndex = addOp(op); //加入到DisplayList的ops中
    if (CC_LIKELY(opIndex >= 0)) {
        int childIndex = mDisplayList->addChild(op); //加入到 DisplayList的chirldren中,

        // update the chunk's child indices
        DisplayList::Chunk& chunk = mDisplayList->chunks.back();
        chunk.endChildIndex = childIndex + 1;

        if (renderNode->stagingProperties().isProjectionReceiver()) {
            // use staging property, since recording on UI thread
            mDisplayList->projectionReceiveIndex = opIndex;
        }
    }
}

由代码可见,drawRenderNode会将子View的RenderNode封装进一个RenderNodeOp插入到ops中,作为一个绘制命令,这个绘制命令的意思是绘制整个子View, 而非普通的 OvalOp, RectOp。最后也将它插入到 children中,表示是子View(并不是说children里保存的仅仅是子View, 像绘制背景这样的也会保存到 children, 为了简单,就认为children保存的是子View的RenderNode吧).

最后LinearLayout_2绘制完TextView和MyView的UML图如下所示, 这样子,父View与子View的DisplayList就构建起联系了。

图9 Linearlayout与子View的DisplayList图

五、DisplayList的树形图

    private void updateRootDisplayList(View view, HardwareDrawCallbacks callbacks) {
        updateViewTreeDisplayList(view); //此处View是DecorView, 更新View Tree的DisplayList
        if (mRootNodeNeedsUpdate || !mRootNode.isValid()) {
            DisplayListCanvas canvas = mRootNode.start(mSurfaceWidth, mSurfaceHeight);
            try {
                final int saveCount = canvas.save();
                canvas.translate(mInsetLeft, mInsetTop);
                callbacks.onHardwarePreDraw(canvas);

                canvas.insertReorderBarrier();
                canvas.drawRenderNode(view.updateDisplayListIfDirty());
                canvas.insertInorderBarrier();

                callbacks.onHardwarePostDraw(canvas);
                canvas.restoreToCount(saveCount);
                mRootNodeNeedsUpdate = false;
            } finally {
                mRootNode.end(canvas);
            }
        }
    }

updateViewTreeDisplayList更新了整个UI的树形DisplayList, 此时整个RenderNode头是DecorView, 而在updateViewTreeDisplayList后面的代码中又会将DecorView的RenderNode也就是DisplayList保存到ThreadedRenderer的的RootRenderNode中。

至此整个UI的DisplayList树形图就画完了,盗用Android N中UI硬件渲染(hwui)的HWUI_NEW_OPS(基于Android 7.1)中的图

DisplayList树形图

推荐阅读更多精彩内容