Android View绘制流程

最新推荐文章于 2024-05-08 18:19:13 发布

It一zhai男

最新推荐文章于 2024-05-08 18:19:13 发布

阅读量603

点赞数 1

分类专栏： Android

本文链接：https://blog.csdn.net/u013293125/article/details/90780157

版权

Android 专栏收录该内容

119 篇文章 1 订阅

订阅专栏

View绘制流程

1 概述
2 view绘制流程
3 layout过程
4 draw过程
相关问答
参考文章

1 概述

在这里插入图片描述对上图做出简单解释：DecorView是一个应用窗口的根容器，它本质上是一个FrameLayout。DecorView有唯一一个子View，它是一个垂直LinearLayout，包含两个子元素，一个是TitleView（ActionBar的容器），另一个是ContentView（窗口内容的容器）。关于ContentView，它是一个FrameLayout（android.R.id.content)，我们平常用的setContentView就是设置它的子View。上图还表达了每个Activity都与一个Window（具体来说是PhoneWindow）相关联，用户界面则由Window所承载。

2 view绘制流程

view的绘制是由ViewRootImlp类来负责的

2.1 view绘制的三个阶段

measure: 判断是否需要重新计算View的大小，需要的话则计算；
layout: 判断是否需要重新计算View的位置，需要的话则计算；
draw: 判断是否需要重新绘制View，需要的话则重绘制。

这三个子阶段可以用下图来描述：
在这里插入图片描述

2.2 measure阶段

此阶段的目的是计算出控件树中各个控件显示所需要的尺寸。
measure方法是为了确定View的大小，父容器会提供宽度和高度参数的约束信息。该方法是一个final类型的方法，意味着子类不能重写它。真正的测量工作是在View的onMeasure方法中进行，因此关注onMeasure方法的实现即可。

2.2.1测量参数

MeasureSpec.UNSPECIFIED:父容器不对View有任何限制，要多大给多大。这种情况一般用于系统内部，表示一种测量的状态。
MeasureSpec.EXACTLY：父容器已经为子容器设置了尺寸,子容器应当服从这些边界,不论子容器想要多大的空间。它对应于LayoutParams中的match_parent和具体数值这两种模式
MeasureSpec.AT_MOST：父容器指定了一个可用大小，View的大小不能超过这个值。它对应于LayoutParams中的wrap_content。

父View的measure的过程会先测量子View，等子View测量结果出来后，再来测量自己，上面的measureChildWithMargins就是用来测量某个子View的，我们来分析是怎样测量的，具体看注释：

protected void measureChildWithMargins(View child, int parentWidthMeasureSpec, int widthUsed, int parentHeightMeasureSpec, int heightUsed) {
 
// 子View的LayoutParams，你在xml的layout_width和layout_height,
// layout_xxx的值最后都会封装到这个个LayoutParams。
final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();  
 
//根据父View的测量规格和父View自己的Padding，
//还有子View的Margin和已经用掉的空间大小（widthUsed），就能算出子View的MeasureSpec,具体计算过程看getChildMeasureSpec方法。
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); 
 
//通过父View的MeasureSpec和子View的自己LayoutParams的计算，算出子View的MeasureSpec，然后父容器传递给子容器的
// 然后让子View用这个MeasureSpec（一个测量要求，比如不能超过多大）去测量自己，如果子View是ViewGroup 那还会递归往下测量。
child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
 
}
 
// spec参数   表示父View的MeasureSpec
// padding参数    父View的Padding+子View的Margin，父View的大小减去这些边距，才能精确算出
//               子View的MeasureSpec的size
// childDimension参数  表示该子View内部LayoutParams属性的值（lp.width或者lp.height）
//                    可以是wrap_content、match_parent、一个精确指(an exactly size), 
public static int getChildMeasureSpec(int spec, int padding, int childDimension) { 
    int specMode = MeasureSpec.getMode(spec);  //获得父View的mode 
    int specSize = MeasureSpec.getSize(spec);  //获得父View的大小 
 
   //父View的大小-自己的Padding+子View的Margin，得到值才是子View的大小。
    int size = Math.max(0, specSize - padding);  
 
    int resultSize = 0;    //初始化值，最后通过这个两个值生成子View的MeasureSpec
    int resultMode = 0;    //初始化值，最后通过这个两个值生成子View的MeasureSpec
 
    switch (specMode) { 
    // Parent has imposed an exact size on us 
    //1、父View是EXACTLY的 ！ 
    case MeasureSpec.EXACTLY:  
        //1.1、子View的width或height是个精确值 (an exactly size) 
        if (childDimension >= 0) {           
            resultSize = childDimension;         //size为精确值 
            resultMode = MeasureSpec.EXACTLY;    //mode为 EXACTLY 。 
        }  
        //1.2、子View的width或height为 MATCH_PARENT/FILL_PARENT  
        else if (childDimension == LayoutParams.MATCH_PARENT) { 
            // Child wants to be our size. So be it. 
            resultSize = size;                   //size为父视图大小 
            resultMode = MeasureSpec.EXACTLY;    //mode为 EXACTLY 。 
        }  
        //1.3、子View的width或height为 WRAP_CONTENT 
        else if (childDimension == LayoutParams.WRAP_CONTENT) { 
            // Child wants to determine its own size. It can't be 
            // bigger than us. 
            resultSize = size;                   //size为父视图大小 
            resultMode = MeasureSpec.AT_MOST;    //mode为AT_MOST 。 
        } 
        break; 
 
    // Parent has imposed a maximum size on us 
    //2、父View是AT_MOST的 ！     
    case MeasureSpec.AT_MOST: 
        //2.1、子View的width或height是个精确值 (an exactly size) 
        if (childDimension >= 0) { 
            // Child wants a specific size... so be it 
            resultSize = childDimension;        //size为精确值 
            resultMode = MeasureSpec.EXACTLY;   //mode为 EXACTLY 。 
        } 
        //2.2、子View的width或height为 MATCH_PARENT/FILL_PARENT 
        else if (childDimension == LayoutParams.MATCH_PARENT) { 
            // Child wants to be our size, but our size is not fixed. 
            // Constrain child to not be bigger than us. 
            resultSize = size;                  //size为父视图大小 
            resultMode = MeasureSpec.AT_MOST;   //mode为AT_MOST 
        } 
        //2.3、子View的width或height为 WRAP_CONTENT 
        else if (childDimension == LayoutParams.WRAP_CONTENT) { 
            // Child wants to determine its own size. It can't be 
            // bigger than us. 
            resultSize = size;                  //size为父视图大小 
            resultMode = MeasureSpec.AT_MOST;   //mode为AT_MOST 
        } 
        break; 
 
    // Parent asked to see how big we want to be 
    //3、父View是UNSPECIFIED的 ！ 
    case MeasureSpec.UNSPECIFIED: 
        //3.1、子View的width或height是个精确值 (an exactly size) 
        if (childDimension >= 0) { 
            // Child wants a specific size... let him have it 
            resultSize = childDimension;        //size为精确值 
            resultMode = MeasureSpec.EXACTLY;   //mode为 EXACTLY 
        } 
        //3.2、子View的width或height为 MATCH_PARENT/FILL_PARENT 
        else if (childDimension == LayoutParams.MATCH_PARENT) { 
            // Child wants to be our size... find out how big it should 
            // be 
            resultSize = 0;                        //size为0！ ,其值未定 
            resultMode = MeasureSpec.UNSPECIFIED;  //mode为 UNSPECIFIED 
        }  
        //3.3、子View的width或height为 WRAP_CONTENT 
        else if (childDimension == LayoutParams.WRAP_CONTENT) { 
            // Child wants to determine its own size.... find out how 
            // big it should be 
            resultSize = 0;                        //size为0! ，其值未定 
            resultMode = MeasureSpec.UNSPECIFIED;  //mode为 UNSPECIFIED 
        } 
        break; 
    } 
    //根据上面逻辑条件获取的mode和size构建MeasureSpec对象。 
    return MeasureSpec.makeMeasureSpec(resultSize, resultMode); 
}

如果父View的MeasureSpec 是EXACTLY，说明父View的大小是确切的，（确切的意思很好理解，如果一个View的MeasureSpec 是EXACTLY，那么它的size 是多大，最后展示到屏幕就一定是那么大）

如果子View 的layout_xxxx是MATCH_PARENT，父View的大小是确切，子View的大小又MATCH_PARENT（充满整个父View），那么子View的大小肯定是确切的，而且大小值就是父View的size。所以子View的size=父View的size，mode=EXACTLY
如果子View 的layout_xxxx是WRAP_CONTENT，也就是子View的大小是根据自己的content 来决定的，但是子View的毕竟是子View，大小不能超过父View的大小，但是子View的是WRAP_CONTENT，我们还不知道具体子View的大小是多少，要等到child.measure(childWidthMeasureSpec, childHeightMeasureSpec) 调用的时候才去真正测量子View 自己content的大小（比如TextView wrap_content 的时候你要测量TextView content 的大小，也就是字符占用的大小，这个测量就是在child.measure(childWidthMeasureSpec, childHeightMeasureSpec)的时候，才能测出字符的大小，MeasureSpec 的意思就是假设你字符100px，但是MeasureSpec 要求最大的只能50px，这时候就要截掉了）。通过上述描述，子View MeasureSpec mode的应该是AT_MOST，而size 暂定父View的 size，表示的意思就是子View的大小没有不确切的值，子View的大小最大为父View的大小，不能超过父View的大小（这就是AT_MOST 的意思），然后这个MeasureSpec 做为子View measure方法的参数，做为子View的大小的约束或者说是要求，有了这个MeasureSpec子View再实现自己的测量。
如果如果子View 的layout_xxxx是确定的值（200dp），那么就更简单了，不管你父View的mode和size是什么，我都写死了就是200dp，那么控件最后展示就是就是200dp，不管我的父View有多大，也不管我自己的content 有多大，反正我就是这么大，所以这种情况MeasureSpec 的mode = EXACTLY 大小size=你在layout_xxxx 填的那个值

如果父View的MeasureSpec 是AT_MOST，说明父View的大小是不确定，最大的大小是MeasureSpec 的size值，不能超过这个值。

如果子View 的layout_xxxx是MATCH_PARENT，父View的大小是不确定（只知道最大只能多大），子View的大小MATCH_PARENT（充满整个父View），那么子View你即使充满父容器，你的大小也是不确定的，父View自己都确定不了自己的大小，你MATCH_PARENT你的大小肯定也不能确定的，所以子View的mode=AT_MOST，size=父View的size，也就是你在布局虽然写的是MATCH_PARENT，但是由于你的父容器自己的大小不确定，导致子View的大小也不确定，只知道最大就是父View的大小。
如果子View 的layout_xxxx是WRAP_CONTENT，父View的大小是不确定（只知道最大只能多大），子View又是WRAP_CONTENT，那么在子View的Content没算出大小之前，子View的大小最大就是父View的大小，所以子View MeasureSpec mode的就是AT_MOST，而size 暂定父View的 size。
如果如果子View 的layout_xxxx是确定的值（200dp），同上，写多少就是多少，改变不了的。

如果父View的MeasureSpec 是UNSPECIFIED(未指定),表示没有任何束缚和约束，不像AT_MOST表示最大只能多大，也不像EXACTLY表示父View确定的大小，子View可以得到任意想要的大小，不受约束

如果子View 的layout_xxxx是MATCH_PARENT，因为父View的MeasureSpec是UNSPECIFIED，父View自己的大小并没有任何约束和要求，那么对于子View来说无论是WRAP_CONTENT还是MATCH_PARENT，子View也是没有任何束缚的，想多大就多大，没有不能超过多少的要求，一旦没有任何要求和约束，size的值就没有任何意义了，所以一般都直接设置成0
同上
如果如果子View 的layout_xxxx是确定的值（200dp），同上，写多少就是多少，改变不了的（记住，只有设置的确切的值，那么无论怎么测量，大小都是不变的，都是你写的那个值）

2.2.2 测量过程

View的测量过程主要是在onMeasure()方法中，measure方法是final，所以这个方法不可重写，如果想自定义View的测量，应该去重写onMeasure()方法。在onMeasure方法的最后需要调用setMeasuredDimension方法，不然会抛异常

基本思想：父View把自己的MeasureSpec，传给子View结合子View自己的LayoutParams 算出子View 的MeasureSpec，然后继续往下传，传递叶子节点，叶子节点没有子View，根据传下来的这个MeasureSpec测量自己就好了。所有的孩子测量之后，经过一系类的计算之后通过setMeasuredDimension设置自己的宽高，对于FrameLayout 可能用最大的字View的大小，对于LinearLayout，可能是高度的累加，具体测量的原理去看看源码。总的来说，父View是等所有的子View测量结束之后，再来测量自己。通过setMeasuredDimension进行测量。
在这里插入图片描述

3 layout过程

Layout的作用是ViewGroup用来确定子元素的位置，当ViewGroup的位置被确定后，它在onLayout中会遍历所有子元素并调用其layout方法，在layout方法中又会调用onLayout方法。
layout方法的大致流程：首先会通过setFrame方法来设定View的四个顶点的位置，即初始化mLeft、mRight、mTop和mBottom，View的四个顶点一旦确定，那么View在父容器中的位置也就确定了；接着会调用onLayout方法，这个方法的用途是父容器确定子元素的位置，因为它的具体实现和具体的布局有关，所以View和ViewGroup都没有真正实现它，而是由子类重写。
注意：ViewGroup的layout方法是final类型的，它会调用onLayout方法（ViewGroup中是抽象方法，子类必须重写），所以子类根据布局需要重写onLayout方法。View的layout方法是public类型的，但是最终的位置确定是在onLayout方法（View中是public的空方法）中进行的，所以重写onLayout方法即可。

4 draw过程

draw的绘制过程主要分为6步

绘制背景
如有必要，保存画布的图层以准备淡化
对view内容进行绘制
对当前view的所有子view进行绘制
如有必要，绘制淡化边缘并恢复图层
对view的滚动条进行绘制

接下来看View的一个方法：

/**
* If this view doesn't do any drawing on its own, set this flag to
* allow further optimizations. By default, this flag is not set on
* View, but could be set on some View subclasses such as ViewGroup.
*
* Typically, if you override {@link #onDraw(android.graphics.Canvas)}
* you should clear this flag.
*
* @param willNotDraw whether or not this View draw on its own
*/
public void setWillNotDraw(boolean willNotDraw) {
	setFlags(willNotDraw ? WILL_NOT_DRAW : 0, DRAW_MASK);
}

从setWillNotDraw这个方法的注释可看出，如果一个View不需要绘制任何内容，那么设置这个标记为为true以后，系统会进行相应的优化。默认情况下，View没有起用这个优化标记位，但是ViewGroup会默认启用。这个标记位对实际开发的意义是：当我们的自定义控件继承于ViewGroup并且本身不具备绘制功能时，就可以开始这个标记位便于系统进行优化。如果明确知道一个ViewGroup需要通过onDraw来绘制内容，就需要显式的关闭WILL_NOT_DRAW 这个标记位。

相关问答

在Activity启动的时候获取某个View的宽高
答：在onCreate、onStart、onResume中均无法获取到某个View的正确宽高，因为View的measure过程和Activity的生命周期方法并不是同步执行的，无法保证Activity执行了onCreate、onStart、onResume时某个View已经测量完毕，获取到的宽高可能为0。可以通过下列四种方法来解决这个问题：

Activity重写onWindowFocusChanged
onWindowFocusChanged这个方法的含义是：View已经初始化完毕，宽高已经准备好了，所以这时候获取的宽高是没问题的。这个方法会被调用多次，当Activity窗口得到焦点和失去焦点的时候都会被调用。
view.post(runnable)
通过post可以讲一个runnable投递到消息队列的尾部，然后等待Looper调用此runnable的时候，View已经初始化好了。
ViewTreeObserver
使用ViewTreeObserver的众多回调可以完成这个功能，比如OnGlobalLayoutListener接口：当View树的状态发生改变或者View树内部的View的可见性发生改变时，onGlobalLayout方法将会被回调，这是获取View宽高的一个好时机。注意该方法会被调用多次。
view.measure(int widthMeasureSpec, int heightMeasureSpec)
通过手动对View进行measure来得到View的宽高，个人不推荐该方法，有局限性，而且容易出错，就不介绍了。

public class TestActivity extends Activity {

    @BindView(R.id.btn)
    TextView textView;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_test);
        ButterKnife.bind(this);

        textView.post(new Runnable() {
            @Override
            public void run() {
                int width = textView.getMeasuredWidth();
                int height = textView.getMeasuredHeight();
                Log.d("==========", "onCreate view.post  width = " + width + " ; height = " + height);
            }
        });

        ViewTreeObserver viewTreeObserver = textView.getViewTreeObserver();
        viewTreeObserver.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
            @Override
            public void onGlobalLayout() {
                //特别注意：此处不能直接使用viewTreeObserver.removeGlobalOnLayoutListener(this); 会有如下异常：
                //java.lang.IllegalStateException: This ViewTreeObserver is not alive, call getViewTreeObserver() again
                textView.getViewTreeObserver().removeGlobalOnLayoutListener(this);
                int width = textView.getMeasuredWidth();
                int height = textView.getMeasuredHeight();
                Log.d("==========", "onCreate viewTreeObserver.addOnGlobalLayoutListener  width = " + width + " ; height = " + height);
            }
        });
    }

    @Override
    protected void onStart() {
        super.onStart();
        textView.post(new Runnable() {
            @Override
            public void run() {
                int width = textView.getMeasuredWidth();
                int height = textView.getMeasuredHeight();
                Log.d("==========", "onStart view.post  width = " + width + " ; height = " + height);
            }
        });
    }

    @Override
    protected void onResume() {
        super.onResume();
        int width = textView.getMeasuredWidth();
        int height = textView.getMeasuredHeight();
        Log.d("==========", "onResume  width = " + width + " ; height = " + height);
    }

    @Override
    public void onWindowFocusChanged(boolean hasFocus) {
        super.onWindowFocusChanged(hasFocus);
        if(hasFocus) {
            int width = textView.getMeasuredWidth();
            int height = textView.getMeasuredHeight();
            Log.d("==========", "onWindowFocusChanged  width = " + width + " ; height = " + height);
        }
    }
}

//测试结果：
//onResume  width = 0 ; height = 0
//onCreate viewTreeObserver.addOnGlobalLayoutListener  width = 391 ; height = 57
//onCreate view.post  width = 391 ; height = 57
//onStart view.post  width = 391 ; height = 57
//onWindowFocusChanged  width = 391 ; height = 57

Activity显示流程
ViewRoot对应于ViewRootImpl类，它是连接WindowManager和DecorView的纽带，View的三大流程均是通过viewRoot来完成的。在ActivityThread中，当Activity对象创建完毕后，会将decorView添加到window中，同时会创建ViewRootImpl对象viewRoot，并将viewRoot和decorView建立关联。
View的绘制流程从viewRoot的performTraversals方法开始的。
View的测量宽高和显示的最终宽高区别
答：测量宽高是在measure过程中确定的，为onMeasure方法中通过setMeasuredDimension设置的值；最终宽高是在layout过程中确定的，宽为mRight - mLeft，高为mBottom - mTop。
正常情况下，它两是相等的，某些特殊情况会不一致，比如：

//重写View的layout方法
public void layout(int l, int t, int r, int b) {
    //最终宽高会比测量宽高大100px
    super.layout(l, t, r + 100, b + 100);
}

MeasureSpec的赋值原理
答：MeasureSpec代表一个32位的int值，高2位代表SpecMode，低30位代表SpecSize。
DecorView：MeasureSpec由窗口的尺寸和自身的LayoutParams共同决定；
普通View：MeasureSpec由父容器的MeasureSpec和自身的LayoutParams共同决定
当一个TextView的实例调用setText()方法后执行了什么
答：setText最后会调用requestLayout()和invalidate()。requestLayout()会调用父容器的requestLayout方法，直至顶层View。requestLayout()会调用measure过程和layout过程，invalidate()会调用draw过程。
几个常用方法介绍
requestLayout()：调用measure过程和layout过程；
invalidate()：必须要在UI线程调用；View可见的话，会调用onDraw方法；
postInvalidate()：可以在非UI线程调用，通过handler发送一个MSG_INVALIDATE消息，然后在主线程处理消息，执行invalidate()方法。

参考文章

https://www.cnblogs.com/jycboy/p/6219915.html
https://www.jianshu.com/p/c4412f878508

It一zhai男

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android View绘制流程

View绘制流程1 概述2 view绘制流程2.1 view绘制的三个阶段2.2 measure阶段2.2.1测量参数2.2.2 测量过程3 layout过程4 draw过程相关问答参考文章1 概述对上图做出简单解释：DecorView是一个应用窗口的根容器，它本质上是一个FrameLayout。DecorView有唯一一个子View，它是一个垂直LinearLayout，包含两个子元素，一个...
复制链接

扫一扫