【Android】View绘制流程

作者: 秀叶寒冬 | 来源:发表于2019-06-27 13:27 被阅读5次

    1 概述

    图1.1 Activity绘制过程

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

    2 view绘制流程

    2.1 view绘制的三个阶段

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

    这三个子阶段可以用下图来描述:


    图2.1 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进行测量。


    图2.2 DecorView结构图

    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 这个标记位。

    相关问答

    1. 在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
    
    
    1. Activity显示流程
      ViewRoot对应于ViewRootImpl类,它是连接WindowManager和DecorView的纽带,View的三大流程均是通过viewRoot来完成的。在ActivityThread中,当Activity对象创建完毕后,会将decorView添加到window中,同时会创建ViewRootImpl对象viewRoot,并将viewRoot和decorView建立关联。
      View的绘制流程从viewRoot的performTraversals方法开始的。
    2. 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);
    }
    
    1. MeasureSpec的赋值原理
      答:MeasureSpec代表一个32位的int值,高2位代表SpecMode,低30位代表SpecSize。
      DecorView:MeasureSpec由窗口的尺寸和自身的LayoutParams共同决定;
      普通View:MeasureSpec由父容器的MeasureSpec和自身的LayoutParams共同决定
    2. 当一个TextView的实例调用setText()方法后执行了什么
      答:setText最后会调用requestLayout()和invalidate()。requestLayout()会调用父容器的requestLayout方法,直至顶层View。requestLayout()会调用measure过程和layout过程,invalidate()会调用draw过程。
    3. 几个常用方法介绍
      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

    相关文章

      网友评论

        本文标题:【Android】View绘制流程

        本文链接:https://www.haomeiwen.com/subject/mpolcctx.html