Android View绘制的三大流程

时间  2019-11-06
标签 android view 绘制 三大 流程 栏目 Android 繁體版
原文   原文链接

本文讲的是Android视图的绘制的三大流程，视图的工做流程主要是指测量，布局，绘制这三大流程，即测量，布局和绘制，其中测量肯定查看的测量宽高，布局根据测量的宽高肯定视图在其父视图中的四个顶点的位置，而平局则将查看绘制到屏幕上，这样经过一个ViewGroup的递归遍历，一个景观树就展示在屏幕上了。说的简单，下面带你们一步一步从源码中分析：java

安卓的视图是树形结构的：微信

基本概念布局

在介绍视图的三大流程以前，咱们必须先介绍一些基本的概念，才能更好地理解这整个过程。this

窗口的概念orm

窗口表示的是一个窗口的概念，它是站在WindowManagerService角度上的一个抽象的概念，安卓中全部的视图都是经过窗口来呈现的，不论是活动，对话仍是面包，只要有浏览的地方就必定有窗口。对象

这里须要注意的是，这个抽象的窗口概念和PhoneWindow这个类并非同一个东西，PhoneWindow表示的是手机屏幕的抽象，它充当活动和DecorView之间的媒介，就算没有PhoneWindow也是能够展现查看的。blog

抛开一切，仅站在WindowManagerService的角度上，安卓的界面就是由一个个窗口层叠展示的，而窗户又是一个抽象的概念，它并非实际存在的，它是以景观的形式存在，这个视图就是DecorView。继承

关于窗口这方面的内容，咱们这里先了解一个大概递归

DecorView的概念事件

DecorView是整个窗口界面的最顶层视图，视图的测量，布局，绘制，事件分发都是由DecorView往下遍历这个景观树.DecorView做为顶级景观，通常状况下它内部会包含一个竖直方向的LinearLayout中，在这个的LinearLayout里面有上下两个部分（具体状况和的Android的版本及主题有关），上面是【标题栏】，下面是【内容栏】。在活动中咱们经过的setContentView所设置的布局文件其实就是被加载到【内容栏】中的，而内容栏的ID是内容，所以指定布局的方法叫setContent（）。

的ViewRoot的概念

的ViewRoot对应于ViewRootImpl类，它是链接的WindowManager和DecorView的纽带，查看的三大流程均是经过的ViewRoot来完成的。在ActivityThread中，当活动对象被建立完以后，会讲DecorView添加到窗口中，同时会建立对应的ViewRootImpl，并将ViewRootImpl和DecorView创建关联，并保存到WindowManagerGlobal对象中。

 
  1. WindowManagerGlobal.java 
  2.  
  3. root = new ViewRootImpl（view .getContext（），display）;   
  4. root.setView（view ，wparams，panelParentView）;  

Java的

查看的绘制流程是从的ViewRoot的performTraversals方法开始的，它通过测量，布局和绘制三个过程才能最终将一个视图绘制出来，大体流程以下图：

测量测量

为了更好地理解查看的测量过程，咱们还须要理解MeasureSpec，它是搜索的一个内部类，它表示对查看的测量规格.MeasureSpec表明一个32位INT值，高2位表明SpecMode（测量模式），低30位表明SpecSize（测量大小），咱们能够看看它的具体实现：

 
  1. MeasureSpec.java 
  2.  
  3. 公共静态 类MeasureSpec {    
  4.         private  static  final  int  MODE_SHIFT = 30; 
  5.         private  static  final  int  MODE_MASK = 0x3 << MODE_SHIFT; 
  6.  
  7.         / ** 
  8.           *未知模式： 
  9.           *父查看不对子查看有任何限制，子查看须要多大就多大 
  10.           * /  
  11.         公共静态 最终  诠释 Unknown = 0 << MODE_SHIFT;  
  12.  
  13.         / ** 
  14.           *精确模式： 
  15.           *父查看已经测量出子Viwe所须要的精确大小，这时候查看的最终大小 
  16.           *就是SpecSize所指定的值。对应于match_parent和精确数值这两种模式 
  17.           * /  
  18.         public static  final  int  EXACTLY = 1 << MODE_SHIFT;  
  19.  
  20.         / ** 
  21.           * AT_MOST模式： 
  22.           *子查看的最终大小是父查看指定的SpecSize值，而且子查看的大小不能大于这个值， 
  23.           *即对应wrap_content这种模式 
  24.           * /  
  25.         public static  final  int  AT_MOST = 2 << MODE_SHIFT;  
  26.  
  27.         //将大小和模式打包成一个32位的INT 型数值 
  28.         //高2位表示SpecMode，测量模式，低30位表示SpecSize，某种测量模式下的规格大小 
  29.         public static int  makeMeasureSpec（int size ，  int  mode）{    
  30.             if（sUseBrokenMakeMeasureSpec）{ 
  31.                 返回大小 +模式;  
  32.             }  else  { 
  33.                 返回 （size  ＆〜MODE_MASK）| （mode＆MODE_MASK）; 
  34.             } 
  35.         } 
  36.  
  37.         //将32位的MeasureSpec解包，返回SpecMode，测量模式 
  38.         public static int  getMode（int  measureSpec）{   
  39.             return  （measureSpec＆MODE_MASK）; 
  40.         } 
  41.  
  42.         //将32位的MeasureSpec解包，返回SpecSize，某种测量模式下的规格大小 
  43.         public static int  getSize（int  measureSpec）{   
  44.             return  （measureSpec＆〜MODE_MASK）; 
  45.         } 
  46.         // ... 
  47.     }  

Java的

MeasureSpec经过将SpecMode和SpecSize打包成一个INT值来避免过多的对象内存分配，并提供了打包和解包的方法。

SpecMode有三种类型，每一类都表示特殊的含义：

UNSPECIFIED

父容器不对视图有任何限制，要多大就给多大，这种状况通常用于系统内部，表示一种测量的状态;

究竟

父容器已经检测出查看所需的精确大小，这个时候搜索的最终打消就是SpecSize所指定的值。它对应于的LayoutParams中的match_parent和具体数值这两种模式。

最多

父容器指定了一个可用大小即SpecSize，查看的大小不能大于这个值，具体是什么值要看不一样观的具体实现。它对应于的LayoutParams中WRAP_CONTENT。

查看的MeasureSpec是由父容器的MeasureSpec和本身的的LayoutParams决定的，可是对于DecorView来讲有点不一样，由于它没有父类。在ViewRootImpl中的measureHierarchy方法中有以下一段代码展现了DecorView的MeasureSpec的建立过程，其中desiredWindowWidth和desireWindowHeight是屏幕的尺寸大小：

ViewGroup中的措施

 
  1. childWidthMeasureSpec = getRootMeasureSpec（desiredWindowWidth，lp.width）; 
  2.  
  3. childHeightMeasureSpec = getRootMeasureSpec（desiredWindowHeight，lp.height）; 
  4.  
  5. performMeasure（childWidthMeasureSpec，childHeightMeasureSpec）;  

Java的

再看看getRootMeasureSpec方法：

 
  1. private  static int  getRootMeasureSpec（int  windowSize，  int  rootDimension）{  
  2.         int  measureSpec; 
  3.         开关（rootDimension）{ 
  4.  
  5.         case  ViewGroup.LayoutParams.MATCH_PARENT： 
  6.             //窗口没法调整大小。 强制 根  视图为 windowSize。  
  7.             measureSpec = MeasureSpec.makeMeasureSpec（windowSize，MeasureSpec.EXACTLY）; 
  8.             打破; 
  9.         案例 ViewGroup.LayoutParams.WRAP_CONTENT： 
  10.             //窗口能够调整大小 设置最大尺寸为 根  视图。    
  11.             measureSpec = MeasureSpec.makeMeasureSpec（windowSize，MeasureSpec.AT_MOST）; 
  12.             打破; 
  13.         默认： 
  14.             //窗口要  到 成为一门精确  的尺寸。 力 根  视图到 是  尺寸。  
  15.             measureSpec = MeasureSpec.makeMeasureSpec（rootDimension，MeasureSpec.EXACTLY）; 
  16.             打破; 
  17.         } 
  18.         返回 measureSpec; 
  19.     }  

Java的

经过以上代码，DecorView的MeasureSpec的产生过程就很明确了，由于DecorView是FrameLyaout的子类，属于ViewGroup中，对于ViewGroup中来讲，除了完成本身的测量过程外，还会遍历去调用全部子元素的测量方法，各个子元素再递归去执行这个过程。和查看不一样的是，一个ViewGroup是一个抽象类，他没有重写查看的onMeasure方法，这里很好理解，由于每一个具体的ViewGroup中实现类的功能是不一样的，如何测量应该让它本身决定，好比LinearLayout中和RelativeLayout的。

所以在具体的一个ViewGroup中须要遍历去测量子查看，这里咱们看看一个ViewGroup中提供的测量子视图的measureChildWithMargins方法：

 
  1. 保护无效measureChildWithMargins（查看 孩子， 
  2.             int  parentWidthMeasureSpec，  int  widthUsed， 
  3.             int  parentHeightMeasureSpec，  int  heightUsed）{ 
  4.         最终MarginLayoutParams lp =（MarginLayoutParams）child.getLayoutParams（）; 
  5.  
  6.         final  int  childWidthMeasureSpec = getChildMeasureSpec（parentWidthMeasureSpec， 
  7.                 mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin 
  8.                         + widthUsed，lp.width）; 
  9.         final  int  childHeightMeasureSpec = getChildMeasureSpec（parentHeightMeasureSpec， 
  10.                 mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin 
  11.                         + heightUsed，lp.height）; 
  12.  
  13.         child.measure（childWidthMeasureSpec，childHeightMeasureSpec）; 
  14.     }  

Java的

上述方法会对子元素进行测量，在调用子元素的测量方法以前会先经过getChildMeasureSpec方法来获得子元素的MeasureSpec。从代码上看，子元素的MeasureSpec的建立与父容器的MeasureSpec和自己的的LayoutParams有关，此外和查看的保证金和父类的填充有关，如今看看getChildMeasureSpec的具体实现：

 
  1. ViewGroup.java 
  2.  
  3. public static int  getChildMeasureSpec（int  spec，  int  padding，  int  childDimension）{     
  4.     int  specMode = MeasureSpec.getMode（spec）; 
  5.     int  specSize = MeasureSpec.getSize（spec）; 
  6.  
  7.     int size  = Math。max （0，specSize - padding）;  
  8.  
  9.     int  resultSize = 0; 
  10.     int  resultMode = 0; 
  11.  
  12.     开关（specMode）{ 
  13.     //父母对 咱们 施加了一个确切的  大小 
  14.     case  MeasureSpec.EXACTLY： 
  15.         if（childDimension> = 0）{ 
  16.             resultSize = childDimension; 
  17.             resultMode = MeasureSpec.EXACTLY; 
  18.         }  else  if（childDimension == LayoutParams.MATCH_PARENT）{ 
  19.             //孩子要  到 是咱们的  大小。就这样吧。 
  20.             resultSize =  size ; 
  21.             resultMode = MeasureSpec.EXACTLY; 
  22.         }  else  if（childDimension == LayoutParams.WRAP_CONTENT）{ 
  23.             //孩子想  以 肯定本身的  大小。不可能 
  24.             //比咱们大 
  25.             resultSize =  size ; 
  26.             resultMode = MeasureSpec.AT_MOST; 
  27.         } 
  28.         打破; 
  29.  
  30.     //父母对 咱们 施加了最大的  尺寸 
  31.     case  MeasureSpec.AT_MOST： 
  32.         if（childDimension> = 0）{ 
  33.             //孩子想要一个特定的  尺寸...就这样吧 
  34.             resultSize = childDimension; 
  35.             resultMode = MeasureSpec.EXACTLY; 
  36.         }  else  if（childDimension == LayoutParams.MATCH_PARENT）{ 
  37.             //孩子要  到 是咱们的  规模，但咱们的  规模是不 固定的。   
  38.             //约束孩子  到不 比咱们更大。  
  39.             resultSize =  size ; 
  40.             resultMode = MeasureSpec.AT_MOST; 
  41.         }  else  if（childDimension == LayoutParams.WRAP_CONTENT）{ 
  42.             //孩子想  以 肯定本身的  大小。不可能 
  43.             //比咱们大 
  44.             resultSize =  size ; 
  45.             resultMode = MeasureSpec.AT_MOST; 
  46.         } 
  47.         打破; 
  48.  
  49.     //家长问  到 看到咱们想有多大  ，以 成为 
  50.     案例 MeasureSpec.UNSPECIFIED： 
  51.         if（childDimension> = 0）{ 
  52.             //孩子想要一个特定的  尺寸...让他拥有它 
  53.             resultSize = childDimension; 
  54.             resultMode = MeasureSpec.EXACTLY; 
  55.         }  else  if（childDimension == LayoutParams.MATCH_PARENT）{ 
  56.             //孩子要  到 是咱们的  规模......发现  了 它有多大应该 
  57.             // be 
  58.             resultSize =  查看.sUseZeroUnspecifiedMeasureSpec？0：  尺寸; 
  59.             resultMode = MeasureSpec.UNSPECIFIED; 
  60.         }  else  if（childDimension == LayoutParams.WRAP_CONTENT）{ 
  61.             //孩子想  以 肯定本身的  大小....找到  了 如何 
  62.             //它应该是大的 
  63.             resultSize =  查看.sUseZeroUnspecifiedMeasureSpec？0：  尺寸; 
  64.             resultMode = MeasureSpec.UNSPECIFIED; 
  65.         } 
  66.         打破; 
  67.     } 
  68.     //没有检查ResourceType 
  69.     返回 MeasureSpec.makeMeasureSpec（resultSize，resultMode）; 
  70. }  

Java的

上述代码根据父类的MeasureSpec和自身的的LayoutParams建立子元素的MeasureSpec，具体过程同窗们自行分析，最终的建立规则以下表：

ViewGroup中在遍历完子视图后，须要根据子元素的测量结果来决定本身最终的测量大小，并调用setMeasuredDimension方法保存测量宽高值。

 
  1. setMeasuredDimension（resolveSizeAndState（maxWidth，widthMeasureSpec，childState），heightSizeAndState）; 

Java的

这里调用了resolveSizeAndState来肯定最终的大小，主要是保证测量的大小不能超过父容器的最大剩余空间maxWidth，这里咱们看看它里面的实现：

 
  1. public static int  resolveSizeAndState（int size ，  int  measureSpec，  int  childMeasuredState）{    
  2.         final  int  specMode = MeasureSpec.getMode（measureSpec）; 
  3.         final  int  specSize = MeasureSpec.getSize（measureSpec）; 
  4.         最终  INT  结果; 
  5.         开关（specMode）{ 
  6.             case  MeasureSpec.AT_MOST： 
  7.                 if（specSize <  size ）{ 
  8.                     结果= specSize | MEASURED_STATE_TOO_SMALL; 
  9.                 }  else  { 
  10.                     结果=  大小; 
  11.                 } 
  12.                 打破; 
  13.             case  MeasureSpec.EXACTLY： 
  14.                 结果= specSize; 
  15.                 打破; 
  16.             案例 MeasureSpec.UNSPECIFIED： 
  17.             默认： 
  18.                 结果=  大小; 
  19.         } 
  20.         返回 结果| （childMeasuredState＆MEASURED_STATE_MASK）; 
  21.     }  

Java的

关于具体的ViewGroup的onMeasure过程这里不作分析，因为每种布局的测量方式不同，不可能逐个分析，但在它们的onMeasure里面的步骤是有必定规律的：

1.根据各自的测量规则遍历儿童元素，调用getChildMeasureSpec方法获得孩子的measureSpec;

2.调用儿童的度量方法;

3.调用setMeasuredDimension肯定最终的大小。

查看的措施

查看的测量过程由其测量方法来完成，测量方法是一个最终的类型的方法，这意味着子类不能重写此方法，在景观的措施方法里面会去调用onMeasure方法，咱们这里只要看onMeasure的实现便可，以下：

 
  1. 查看.java 
  2.  
  3.     protected void onMeasure（int  widthMeasureSpec，  int  heightMeasureSpec）{ 
  4.         setMeasuredDimension（getDefaultSize（getSuggestedMinimumWidth（），widthMeasureSpec）） 
  5.                 getDefaultSize（getSuggestedMinimumHeight（），heightMeasureSpec））; 
  6.     }  

Java的

代码很简单，咱们继续看看getDefaultSize方法的实现：

 
  1. 查看.java 
  2.  
  3.     public static int  getDefaultSize（int size ，  int  measureSpec）{    
  4.         int  result =  size ; 
  5.         int  specMode = MeasureSpec.getMode（measureSpec）; 
  6.         int  specSize = MeasureSpec.getSize（measureSpec）; 
  7.  
  8.         开关（specMode）{ 
  9.         案例 MeasureSpec.UNSPECIFIED： 
  10.             结果=  大小; 
  11.             打破; 
  12.         case  MeasureSpec.AT_MOST： 
  13.         case  MeasureSpec.EXACTLY： 
  14.             结果= specSize; 
  15.             打破; 
  16.         } 
  17.         返回 结果; 
  18.     } 

Java的

从上述代码能够得出，景观的宽/高由specSize决定，直接继承视图的自定义控件须要重写onMeasure方法并设置WRAP_CONTENT时的自身大小，不然在布局中使用WRAP_CONTENT就至关于使用match_parent。

上述就是查看的量度大体过程，在测量完成以后，经过getMeasuredWidth /高度方法就能够得到测量后的宽高，这个宽高通常状况下就等于查看的最终宽高了，由于搜索的布局布局的时候就是根据measureWidth /高度来设置宽高的，除非在布局中修改了测量值。

布局布局

布局的做用是一个ViewGroup用来肯定子元素的位置，当ViewGroup中的位置被肯定后，它在onLayout中会遍历全部的子元素并调用其布局方法。简单的来讲就是，布局方法肯定视图自己的位置，而onLayout方法则会肯定全部子元素的位置。

先看看查看的布局方法：

 
  1. public  void layout（int  l，  int  t，  int  r，  int  b）{ 
  2.         if（（mPrivateFlags3＆PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT）！= 0）{ 
  3.             onMeasure（mOldWidthMeasureSpec，mOldHeightMeasureSpec）; 
  4.             mPrivateFlags3＆=〜PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT; 
  5.         } 
  6.  
  7.         int  oldL = mLeft; 
  8.         int  oldT = mTop; 
  9.         int  oldB = mBottom; 
  10.         int  oldR = mRight; 
  11.  
  12.         boolean changed = isLayoutModeOptical（mParent）？ 
  13.                 setOpticalFrame（l，t，r，b）：setFrame（l，t，r，b）; 
  14.  
  15.         if（changed ||（mPrivateFlags＆PFLAG_LAYOUT_REQUIRED）== PFLAG_LAYOUT_REQUIRED）{ 
  16.             onLayout（改变，l，t，r，b）; 
  17.  
  18.             if（shouldDrawRoundScrollbar（））{ 
  19.                 if（mRoundScrollbarRenderer ==  null ）{ 
  20.                     mRoundScrollbarRenderer = new RoundScrollbarRenderer（this）; 
  21.                 } 
  22.             }  else  { 
  23.                 mRoundScrollbarRenderer =  null ; 
  24.             } 
  25.  
  26.             mPrivateFlags＆=〜PFLAG_LAYOUT_REQUIRED; 
  27.  
  28.             ListenerInfo li = mListenerInfo; 
  29.             if（li！=  null  && li.mOnLayoutChangeListeners！=  null ）{ 
  30.                 ArrayList <OnLayoutChangeListener> listenersCopy = 
  31.                         （ArrayList的<OnLayoutChangeListener>）li.mOnLayoutChangeListeners.clone（）; 
  32.                 int  numListeners = listenersCopy。size （）; 
  33.                 for  （int  i = 0; i <numListeners; ++ i）{ 
  34.                     listenerCopy.get（i）.onLayoutChange（this，l，t，r，b，oldL，oldT，oldR，oldB）; 
  35.                 } 
  36.             } 
  37.         } 
  38.  
  39.         mPrivateFlags＆=〜PFLAG_FORCE_LAYOUT; 
  40.         mPrivateFlags3 | = PFLAG3_IS_LAID_OUT; 
  41.     }  

因微信字数限制，请点击原文连接查看完整内容

总结

到这里，查看的措施，布局，绘制三大流程就说完了，这里作一下总结：

  • 若是是自定义的ViewGroup的话，须要重写onMeasure方法，在onMeasure方法里面遍历测量子元素，同理onLayout方法也是同样，最后实现的onDraw方法绘制本身;
  • 若是自定义视图的话，则须要从写onMeasure方法，处理WRAP_CONTENT的状况，不须要处理onLayout，最后实现的onDraw方法绘制本身; 

 

 

阅读原文

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程