Android视图绘制流程和原理分析

作为一个Android开发人员，我们每天开发工作都会与View打交道，Android提供的任何布局，控件都是直接或者间接的继承View的，如LinearLayout，RelativeLayout，TextView，Button，ImageView，RecyclerView，ListView等；这些都是Android系统本身就提供好的，我们只需要拿过来使用就可以了，有时候我们需要自定义一些布局，那我们就需要知道View如何绘制到屏幕上？，以便我们能更好完成开发工作；

Activity启动以后如何完成View的绘制工作呢？首页我们就需要了解Activity启动以后的绘制View执行流程；

1.View绘制流程源码路径

1.1Activity加载ViewRootImpl

ActivityThread.handleResumeActivity() 
--> WindowManagerImpl.addView(decorView, layoutParams) 
--> WindowManagerGlobal.addView()
WindowManagerGlobal.addView()负责创建ViewRootImpl，同时执行root.setView(view, wparams, panelParentView);

1.2ViewRootImpl启动View树的遍历

ViewRootImpl.setView(decorView, layoutParams, parentView)
-->ViewRootImpl.requestLayout()
-->scheduleTraversals()
-->TraversalRunnable.run()
-->doTraversal()
-->performTraversals()（performMeasure、performLayout、performDraw）

以上是Activity启动以后View绘制的关键流程，任何一个视图都不是凭空突然出现在屏幕上，它们都是要经过非常科学的绘制流程才能显示出来，通过以上关键流程发现真正绘制是视图主要包含三个阶段performMeasure(测量)，performMeasure(布局)，performDraw(绘制)，下面我们逐个对这三个阶段展开讨论；

2.View绘制流程

2.1measure()测量

measure是测量的意思，那么onMeasure()方法顾名思义就是用于测量视图的大小的。View系统的绘制流程会从ViewRoot的performTraversals()方法中开始，在其内部调用View的measure()方法。measure()方法接收两个参数，widthMeasureSpec和heightMeasureSpec，这两个值分别用于确定视图的宽度和高度的测量模式和大小。

首先要了解视图的宽度和高度的测量模式和大小是使用MeasureSpec表示；

(1).MeasureSpec怎么表示视图的测量模式和大小

重写过onMeasure()方法都知道，测量需要用到MeasureSpec类获取View的测量模式和大小，那么这个类是怎样存储这两个信息呢？

留心观察的话会发现，onMeasure方法的两个参数实际是32位int类型数据，即：

00 000000 00000000 00000000 00000000

而其结构为 mode + size ，前2位为mode，而后30位为size；

如何生成MeasureSpec数据？

makeMeasureSpec()方法（mode + size --> measureSpec）

MeasureSpec
public static int makeMeasureSpec(@IntRange(from = 0, to = (1 << MeasureSpec.MODE_SHIFT) - 1) int size,
                                          @MeasureSpecMode int mode) {
            if (sUseBrokenMakeMeasureSpec) {
                return size + mode;
            } else {
                return (size & ~MODE_MASK) | (mode & MODE_MASK);
            }
        }

这里解释一下，按位或左侧为size的高2位清零后的结果，右侧为mode的低30位清零后的结果，两者按位或运算的结果正好为高2位mode、低30位size，例：

01000000 00000000 00000000 00000000 | 00001000 00001011 11110101 10101101 = 01001000 00001011 11110101 10101101

如何获取测量模式和视图大小呢？

getMode()方法（measureSpec --> mode）

private static final int MODE_SHIFT = 30;
// 0x3转换为二进制即为：11
// 左移30位后：11000000 00000000 00000000 00000000
private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

public static int getMode(int measureSpec) {
    // 与MODE_MASK按位与运算后，即将低30位清零，结果为mode左移30位后的值
    return (measureSpec & MODE_MASK);
}

getSize()方法同理；

MeasureSpec下定义了三种测量模式，都包含哪些模式，怎么确定使用哪些模式？

public static final int UNSPECIFIED = 0 << MODE_SHIFT;
public static final int EXACTLY     = 1 << MODE_SHIFT;
public static final int AT_MOST     = 2 << MODE_SHIFT;

• UNSPECIFIED：父容器不对View作任何限制，系统内部使用；
• EXACTLY：精确模式，父容器检测出View大小，即为SpecSize；对应LayoutParams中的match_parent和指定大小的情况；
• AT_MOST：最大模式，父容器指定可用大小，View的大小不能超出这个值；对应wrap_content；

(2)Activity下ViewGroup的测量流程

那么你可能会有疑问了，widthMeasureSpec和heightMeasureSpec这两个值又是从哪里得到的呢？通常情况下，这两个值都是由父视图经过计算后传递给子视图的，说明父视图会在一定程度上决定子视图的大小。但是最外层的根视图，它的widthMeasureSpec和heightMeasureSpec又是从哪里得到的呢？这就需要去分析ViewRoot中的源码了，观察performTraversals()方法可以发现如下代码：

childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);

可以看到，这里调用了getRootMeasureSpec()方法去获取widthMeasureSpec和heightMeasureSpec的值，注意方法中传入的参数，其中lp.width和lp.height在创建ViewGroup实例的时候就被赋值了，它们都等于MATCH_PARENT。然后看下getRootMeasureSpec()方法中的代码，如下所示：

 private static int getRootMeasureSpec(int windowSize, int rootDimension) {
        int measureSpec;
        switch (rootDimension) {

        case ViewGroup.LayoutParams.MATCH_PARENT:
            // Window can't resize. Force root view to be windowSize.
            measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
            break;
        case ViewGroup.LayoutParams.WRAP_CONTENT:
            // Window can resize. Set max size for root view.
            measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
            break;
        default:
            // Window wants to be an exact size. Force root view to be that size.
            measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
            break;
        }
        return measureSpec;
    }

可以看到，这里使用了MeasureSpec.makeMeasureSpec()方法来组装一个MeasureSpec，当rootDimension参数等于MATCH_PARENT的时候，MeasureSpec的specMode就等于EXACTLY，当rootDimension等于WRAP_CONTENT的时候，MeasureSpec的specMode就等于AT_MOST。并且MATCH_PARENT和WRAP_CONTENT时的specSize都是等于windowSize的，也就意味着根视图总是会充满全屏的；

往下走，performMeasure方法中调用了DecorView的onMeasure方法，而DecorView继承自FrameLayout，可以看到FL的onMeasure方法中调用了measureChildWithMargins方法，并传入自身的测量规格：

  protected void measureChildWithMargins(View child,
            int parentWidthMeasureSpec, int widthUsed,
            int parentHeightMeasureSpec, int heightUsed) {
        final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();

        final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
                mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
                        + widthUsed, lp.width);
        final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
                mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
                        + heightUsed, lp.height);

        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    }

即测量子控件的大小，测量规则详情可看getChildMeasureSpec方法，总结如下：

childLayoutParams\parentSpecMode	EXACTLY	AT_MOST	UNSPECIFIED
dp	EXACTLY/childSize	EXACTLY/childSize	EXCATLY/childSize
match_parent	EXACTLY/parentSize	AT_MOST/parentSize	UNSPECIFIED/0
wrap_content	AT_MOST/parentSize	AT_MOST/parentSize	UNSPECIFIED/0

回到onMeasure方法，测完子控件之后，ViewGroup会经过一些计算，得出自身大小：

// 加上padding
maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();

// 检查是否小于最小宽度、最小高度
maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

// 检查Drawable的最小高度和宽度
final Drawable drawable = getForeground();
if (drawable != null) {
    maxHeight = Math.max(maxHeight, drawable.getMinimumHeight());
    maxWidth = Math.max(maxWidth, drawable.getMinimumWidth());
}

setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
        resolveSizeAndState(maxHeight, heightMeasureSpec,
                childState << MEASURED_HEIGHT_STATE_SHIFT));

综上，ViewGroup的测量需要先测量子View的大小，而后结合padding等属性计算得出自身大小；

(3)View的测量流程

View.performMeasure()
-->onMeasure(int widthMeasureSpec, int heightMeasureSpec)
-->setMeasuredDimension(int measuredWidth, int measuredHeight)
-->setMeasuredDimensionRaw(int measuredWidth, int measuredHeight)

可以看到setMeasuredDimensionRaw()方法：

private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
    // 存储测量结果
    mMeasuredWidth = measuredWidth;
    mMeasuredHeight = measuredHeight;

    // 设置测量完成的标志位
    mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
}

View不需要考虑子View的大小，根据内容测量得出自身大小即可。

另外，View中的onMeasure方法中调用到getDefaultSize方法：

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
    setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
            getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}

public static int getDefaultSize(int size, int measureSpec) {
    int result = size;
    int specMode = MeasureSpec.getMode(measureSpec);
    int specSize = MeasureSpec.getSize(measureSpec);

    switch (specMode) {
    case MeasureSpec.UNSPECIFIED:
        result = size;
        break;
    case MeasureSpec.AT_MOST:
    case MeasureSpec.EXACTLY:
        // 最终测量的结果都是父容器的大小
        result = specSize;
        break;
    }
    return result;
}

这里看到精确模式和最大模式，最终测量的结果都是父容器的大小，即布局中的wrap_content、match_parent以及数值大小效果都一样，这也就是自定义View一定要重写onMeasure方法的原因；

2.2layout布局

布局相对测量而言要简单许多，从ViewRootImpl的performLayout方法出发，可以看到其中调用了DecorView的layout方法：

// 实则为DecorView的left, top, right, bottom四个信息
host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());

在layout()方法中，首先会调用setFrame()方法来判断视图的大小是否发生过变化，以确定有没有必要对当前的视图进行重绘，同时还会在这里把传递过来的四个参数分别赋值给mLeft、mTop、mRight和mBottom这几个变量：

mLeft = left;
mTop = top;
mRight = right;
mBottom = bottom;

另外，layout方法中往下走，可以看到调用了onLayout方法，进入后发现为空方法。因而查看FrameLayout的onLayout方法：

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    layoutChildren(left, top, right, bottom, false /* no force left gravity */);
}

void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) {
    final int count = getChildCount();

    // 省略

    for (int i = 0; i < count; i++) {
        final View child = getChildAt(i);
        if (child.getVisibility() != GONE) {
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();

            // 省略

            child.layout(childLeft, childTop, childLeft + width, childTop + height);
        }
    }
}

可以看到，进行一系列计算后，调用了child的layout方法，对子控件进行布局，同时子控件又会继续往下对自己的子控件布局，从而实现遍历；

综上，布局实际为调用layout方法设置View位置，ViewGroup则需要另外实现onLayout方法摆放子控件；

2.3draw绘制

(1)绘制过程入口

ViewRootImpl.performDraw()
-->ViewRootImpl.draw()
-->ViewRootImpl.drawSoftware()
-->View.draw()

（2）绘制步骤

进入到View的draw方法中，可以看到以下一段注释：

/*
 * Draw traversal performs several drawing steps which must be executed
 * in the appropriate order:
 *
 *      1. Draw the background
 *      2. If necessary, save the canvas' layers to prepare for fading
 *      3. Draw view's content
 *      4. Draw children
 *      5. If necessary, draw the fading edges and restore layers
 *      6. Draw decorations (scrollbars for instance)
 */

结合draw方法的源码，绘制过程的关键步骤如下：

==> 绘制背景：drawBackground(canvas)

==> 绘制自己：onDraw(canvas)

==> 绘制子view：dispatchDraw(canvas)

==> 绘制滚动条、前景等装饰：onDrawForeground(canvas)

3.扩展

自定义视图常见疑惑点？

1)视图绘制的流程包含哪几部分？

2)MeasureSpec生成规则是什么？包含哪些内容？

3)最开始根视图MeasureSpec来源？

4)View视图绘制和ViewGroup绘制区别有哪些？

5)View视图draw包含哪些流程？

其他

getMeasureWidth()和getWidth()区别

getMeasureWidth()方法在measure()过程结束后就可以获取到了，而getWidth()方法要在layout()过程结束后才能获取到。另外，getMeasureWidth()方法中的值是通过setMeasuredDimension()方法来进行设置的，而getWidth()方法中的值则是通过视图右边的坐标减去左边的坐标计算出来的

为什么不建议使用layout_weight属性设置布局权重？

内嵌使用包含layout_weight属性的LinearLayout会在绘制时花费昂贵的系统资源，因为每一个子组件都需要被测量两次。在使用ListView与GridView的时候，这个问题显的尤其重要，因为子组件会重复被创建.所以要尽量避免使用Layout_weight；

参考：

Android UI绘制流程及原理 - jyau - 博客园

Android视图绘制流程完全解析，带你一步步深入了解View(二)_郭霖的专栏-CSDN博客_view的绘制流程郭霖