`
xixinfei
  • 浏览: 410855 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

android-View工作原理（三）视图大小计算过程（measure过程）

阅读更多
一、android中view的measure过程总概
	视图大小计算的过程是从根视图measure()方法开始，接着该方法会调用根视图的onMeasure()方法，onMeasure()方法会对所包含的子视图逐一执行measure()方法，如果子视图是ViewGroup子类对象（LinearLayout、FrameLayout、RelativeLayout等布局），则继续调用子视图的measure()方法，重复这一过程。如果子视图是View子类对象（Button、EditText、TextView、ImageView等），则在子视图重载的onMeasure方法内部不需要进行对子视图进行measure操作，从而一次measure过程完成。过程如下图所示：

二、measure详细过程

View中的measure()方法源码（ViewGroup类继承了View类，measure过程先从ViewGroup子类开始）:

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. public final void measure(int widthMeasureSpec, int heightMeasureSpec) {  
  2.        if ((mPrivateFlags & FORCE_LAYOUT) == FORCE_LAYOUT ||  
  3.                widthMeasureSpec != mOldWidthMeasureSpec ||  
  4.                heightMeasureSpec != mOldHeightMeasureSpec) {  
  5.   
  6.            // first clears the measured dimension flag  
  7.            mPrivateFlags &= ~MEASURED_DIMENSION_SET;  
  8.   
  9.            if (ViewDebug.TRACE_HIERARCHY) {  
  10.                ViewDebug.trace(this, ViewDebug.HierarchyTraceType.ON_MEASURE);  
  11.            }  
  12.   
  13.            // measure ourselves, this should set the measured dimension flag back  
  14.            onMeasure(widthMeasureSpec, heightMeasureSpec);  
  15.   
  16.            // flag not set, setMeasuredDimension() was not invoked, we raise  
  17.            // an exception to warn the developer  
  18.            if ((mPrivateFlags & MEASURED_DIMENSION_SET) != MEASURED_DIMENSION_SET) {  
  19.                throw new IllegalStateException("onMeasure() did not set the"  
  20.                        + " measured dimension by calling"  
  21.                        + " setMeasuredDimension()");  
  22.            }  
  23.   
  24.            mPrivateFlags |= LAYOUT_REQUIRED;  
  25.        }  
  26.   
  27.        mOldWidthMeasureSpec = widthMeasureSpec;  
  28.        mOldHeightMeasureSpec = heightMeasureSpec;  
  29.    }  
	注：通过源码，我们看到该方法的定义中用了final关键字，说明该方法是不能被重写的，即View系统定义的这个measure框架不能被修改。参数widthMeasureSpec和heightMeasureSpec分别对应宽和高的measureSpec，当父视图对子视图进行measure操作时，会调用子视图的measure()方法，该参数得意思是父视图所提供的measure的“规格”，因为父视图为子视图提供的窗口尺寸是由父视图和子视图共同决定。该参数有两部分组成，第一部分：高16位表示specMode，定义在MeasureSpec类中，有三种类型：MeasureSpec.EXACTLY：表示明确的尺寸大小， MeasureSpec.AT_MOST：表示最大大小， MeasureSpec.UNSPECIFIED：不确定大小。第二部分：低16位表示size，即父view的大小，这就是为什么我们在重写onmeasure方法是需要：int specMode = MeasureSpec.getMod(spec); int specSize = MeasureSpec.getSize(spec)这样调用。specMode一般都为MeasureSpec.EXACTLY ，而size分别对应屏幕宽，高。也就是Window第一次掉用的view，一般都是这个值，而对于子view来说，这个值就是你在xml定义的属性  android:layout_width和android:layout_height的值。
	下面我们看看源码执行过程，看注释就能很明白，首先清 除测量尺寸的标识。接着将重新测量自己的尺寸，即调用onMeasure()方法。最后是判断测量尺寸大小的标识是否已经重新赋值，如果没有则不执行setMeasuredDimension()方法。方法结束。这个方法里面主要就是调用自己的onMeasure（）方法，对自己的大小尺寸进行测量。下面来介绍onMeasure（）方法。

 

ViewGroup中的onMeasure方法介绍

其实在ViewGroup类中并没有重写该方法，一般在他的子类中进行重写，比如LinearLayout、RelativeLayout，下面我们以Linearlayout来分析。LinearLayout中onMeasure方法源码如下：
[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. @Override  
  2. protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
  3.     if (mOrientation == VERTICAL) {  
  4.         measureVertical(widthMeasureSpec, heightMeasureSpec);  
  5.     } else {  
  6.         measureHorizontal(widthMeasureSpec, heightMeasureSpec);  
  7.     }  
  8. }  

 

注：通过源码我们可以知道，首先onMeasure会判断这个布局是纵向布局还是横向布局，即对应android:orientation=""属性。下面以纵向布局来分析，源码如下，有点长：

[java] view plaincopy在CODE上查看代码片派生到我的代码片
  1. /** 
  2.    * Measures the children when the orientation of this LinearLayout is set 
  3.    * to {@link #VERTICAL}. 
  4.    * 
  5.    * @param widthMeasureSpec Horizontal space requirements as imposed by the parent. 
  6.    * @param heightMeasureSpec Vertical space requirements as imposed by the parent. 
  7.    * 
  8.    * @see #getOrientation() 
  9.    * @see #setOrientation(int) 
  10.    * @see #onMeasure(int, int) 
  11.    */  
  12.   void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {  
  13.       mTotalLength = 0;  
  14.       int maxWidth = 0;  
  15.       int alternativeMaxWidth = 0;  
  16.       int weightedMaxWidth = 0;  
  17.       boolean allFillParent = true;  
  18.       float totalWeight = 0;  
  19.   
  20.       final int count = getVirtualChildCount();  
  21.        
  22.       final int widthMode = MeasureSpec.getMode(widthMeasureSpec);  
  23.       final int heightMode = MeasureSpec.getMode(heightMeasureSpec);  
  24.       boolean matchWidth = false;  
  25.       final int baselineChildIndex = mBaselineAlignedChildIndex;          
  26.       final boolean useLargestChild = mUseLargestChild;  
  27.       int largestChildHeight = Integer.MIN_VALUE;  
  28.       // See how tall everyone is. Also remember max width.  
  29.       for (int i = 0; i < count; ++i) {  
  30.           final View child = getVirtualChildAt(i);  
  31.   
  32.           if (child == null) {  
  33.               mTotalLength += measureNullChild(i);  
  34.               continue;  
  35.           }  
  36.           if (child.getVisibility() == View.GONE) {  
  37.              i += getChildrenSkipCount(child, i);  
  38.              continue;  
  39.           }  
  40.           LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();  
  41.           totalWeight += lp.weight;              
  42.           if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {  
  43.               // Optimization: don't bother measuring children who are going to use  
  44.               // leftover space. These views will get measured again down below if  
  45.               // there is any leftover space.  
  46.               final int totalLength = mTotalLength;  
  47.               mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);  
  48.           } else {  
  49.               int oldHeight = Integer.MIN_VALUE;  
  50.               if (lp.height == 0 && lp.weight > 0) {  
  51.                   // heightMode is either UNSPECIFIED or AT_MOST, and this  
  52.                   // child wanted to stretch to fill available space.  
  53.                   // Translate that to WRAP_CONTENT so that it does not end up  
  54.                   // with a height of 0  
  55.                   oldHeight = 0;  
  56.                   lp.height = LayoutParams.WRAP_CONTENT;  
  57.               }  
  58.               // Determine how big this child would like to be. If this or  
  59.               // previous children have given a weight, then we allow it to  
  60.               // use all available space (and we will shrink things later  
  61.               // if needed).  
  62.               measureChildBeforeLayout(  
  63.                      child, i, widthMeasureSpec, 0, heightMeasureSpec,  
  64.                      totalWeight == 0 ? mTotalLength : 0);  
  65.   
  66.               if (oldHeight != Integer.MIN_VALUE) {  
  67.                  lp.height = oldHeight;  
  68.               }  
  69.               final int childHeight = child.getMeasuredHeight();  
  70.               final int totalLength = mTotalLength;  
  71.               mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +  
  72.                      lp.bottomMargin + getNextLocationOffset(child));  
  73.   
  74.               if (useLargestChild) {  
  75.                   largestChildHeight = Math.max(childHeight, largestChildHeight);  
  76.               }  
  77.           }  
  78.           /** 
  79.            * If applicable, compute the additional offset to the child's baseline 
  80.            * we'll need later when asked {@link #getBaseline}. 
  81.            */  
  82.           if ((baselineChildIndex >= 0) && (baselineChildIndex == i + 1)) {  
  83.              mBaselineChildTop = mTotalLength;  
  84.           }  
  85.           // if we are trying to use a child index for our baseline, the above  
  86.           // book keeping only works if there are no children above it with  
  87.           // weight.  fail fast to aid the developer.  
  88.           if (i < baselineChildIndex && lp.weight > 0) {  
  89.               throw new RuntimeException("A child of LinearLayout with index "  
  90.                       + "less than mBaselineAlignedChildIndex has weight > 0, which "  
  91.                       + "won't work.  Either remove the weight, or don't set "  
  92.                       + "mBaselineAlignedChildIndex.");  
  93.           }  
  94.           boolean matchWidthLocally = false;  
  95.           if (widthMode != MeasureSpec.EXACTLY && lp.width == LayoutParams.MATCH_PARENT) {  
  96.               // The width of the linear layout will scale, and at least one  
  97.               // child said it wanted to match our width. Set a flag  
  98.               // indicating that we need to remeasure at least that view when  
  99.               // we know our width.  
  100.               matchWidth = true;  
  101.               matchWidthLocally = true;  
  102.           }  
  103.           final int margin = lp.leftMargin + lp.rightMargin;  
  104.           final int measuredWidth = child.getMeasuredWidth() + margin;  
  105.           maxWidth = Math.max(maxWidth, measuredWidth);  
  106.           allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;  
  107.           if (lp.weight > 0) {  
  108.               /* 
  109.                * Widths of weighted Views are bogus if we end up 
  110.                * remeasuring, so keep them separate. 
  111.                */  
  112.               weightedMaxWidth = Math.max(weightedMaxWidth,  
  113.                       matchWidthLocally ? margin : measuredWidth);  
  114.           } else {  
  115.               alternativeMaxWidth = Math.max(alternativeMaxWidth,  
  116.                       matchWidthLocally ? margin : measuredWidth);  
  117.           }  
  118.           i += getChildrenSkipCount(child, i);  
  119.       }  
  120.       if (useLargestChild && heightMode == MeasureSpec.AT_MOST) {  
  121.           mTotalLength = 0;  
  122.           for (int i = 0; i < count; ++i) {  
  123.               final View child = getVirtualChildAt(i);  
  124.               if (child == null) {  
  125.                   mTotalLength += measureNullChild(i);  
  126.                   continue;  
  127.               }  
  128.               if (child.getVisibility() == GONE) {  
  129.                   i += getChildrenSkipCount(child, i);  
  130.                   continue;  
  131.               }  
  132.               final LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams)  
  133.                       child.getLayoutParams();  
  134.               // Account for negative margins  
  135.               final int totalLength = mTotalLength;  
  136.               mTotalLength = Math.max(totalLength, totalLength + largestChildHeight +  
  137.                       lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));  
  138.           }  
  139.       }  
  140.       // Add in our padding  
  141.       mTotalLength += mPaddingTop + mPaddingBottom;  
  142.       int heightSize = mTotalLength;  
  143.       // Check against our minimum height  
  144.       heightSize = Math.max(heightSize, getSuggestedMinimumHeight());          
  145.       // Reconcile our calculated size with the heightMeasureSpec  
  146.       heightSize = resolveSize(heightSize, heightMeasureSpec);          
  147.       // Either expand children with weight to take up available space or  
  148.       // shrink them if they extend beyond our current bounds  
  149.       int delta = heightSize - mTotalLength;  
  150.       if (delta != 0 && totalWeight > 0.0f) {  
  151.           float weightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;  
  152.           mTotalLength = 0;  
  153.           for (int i = 0; i < count; ++i) {  
  154.               final View child = getVirtualChildAt(i);  
  155.               if (child.getVisibility() == View.GONE) {  
  156.                   continue;  
  157.               }                  
  158.               LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();                  
  159.               float childExtra = lp.weight;  
  160.               if (childExtra > 0) {  
  161.                   // Child said it could absorb extra space -- give him his share  
  162.                   int share = (int) (childExtra * delta / weightSum);  
  163.                   weightSum -= childExtra;  
  164.                   delta -= share;  
  165.                   final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,  
  166.                           mPaddingLeft + mPaddingRight +  
  167.                                   lp.leftMargin + lp.rightMargin, lp.width);  
  168.   
  169.                   // TODO: Use a field like lp.isMeasured to figure out if this  
  170.                   // child has been previously measured  
  171.                   if ((lp.height != 0) || (heightMode != MeasureSpec.EXACTLY)) {  
  172.                       // child was measured once already above...  
  173.                       // base new measurement on stored values  
  174.                       int childHeight = child.getMeasuredHeight() + share;  
  175.                       if (childHeight < 0) {  
  176.                           childHeight = 0;  
  177.                       }  
  178.                       child.measure(childWidthMeasureSpec,  
  179.                               MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.EXACTLY));  
  180.                   } else {  
  181.                       // child was skipped in the loop above.  
  182.                       // Measure for this first time here        
  183.                       child.measure(childWidthMeasureSpec,  
  184.                               MeasureSpec.makeMeasureSpec(share > 0 ? share : 0,  
  185.                                       MeasureSpec.EXACTLY));  
  186.                   }  
  187.               }  
  188.               final int margin =  lp.leftMargin + lp.rightMargin;  
  189.               final int measuredWidth = child.getMeasuredWidth() + margin;  
  190.               maxWidth = Math.max(maxWidth, measuredWidth);  
  191.               boolean matchWidthLocally = widthMode != MeasureSpec.EXACTLY &&  
  192.                       lp.width == LayoutParams.MATCH_PARENT;  
  193.               alternativeMaxWidth = Math.max(alternativeMaxWidth,  
  194.                       matchWidthLocally ? margin : measuredWidth);  
  195.               allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;  
  196.               final int totalLength = mTotalLength;  
  197.               mTotalLength = Math.max(totalLength, totalLength + child.getMeasuredHeight() +  
  198.                       lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));  
  199.           }  
  200.           // Add in our padding  
  201.           mTotalLength += mPaddingTop + mPaddingBottom;  
  202.           // TODO: Should we recompute the heightSpec based on the new total length?  
  203.       } else {  
  204.           alternativeMaxWidth = Math.max(alternativeMaxWidth,  
  205.                                          weightedMaxWidth);  
  206.       }  
  207.       if (!allFillParent && widthMode != MeasureSpec.EXACTLY) {  
  208.           maxWidth = alternativeMaxWidth;  
  209.       }  
  210.       maxWidth += mPaddingLeft + mPaddingRight;  
  211.       // Check against our minimum width  
  212.       maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());  
  213.       setMeasuredDimension(resolveSize(maxWidth, widthMeasureSpec), heightSize);  
  214.       if (matchWidth) {  
  215.           forceUniformWidth(count, heightMeasureSpec);  
  216.       }  
  217.   }  
注：
  1. 获取所有的子view数量，对每个子view开始处理，如果子view是GONE的，则直接跳过。
  2. 获取子view的 LayoutParams，在xml中定义的参数，通过layout_weight定义的值累加到变量totalWeight中，然后判断如果view的 height设置为零，但weight设置的大于0，则将height的值设置为LayoutParams.WRAP_CONTENT。
  3. 然 后调用measureChildWithMargins方法，该方法处理的逻辑：计算子view的measureSpec，即specMode和 specSize，调用方法为：getChildMeasureSpec，调用两次，分别 计算宽和高，getChildMeasureSpec内部根据 父view的measure和子view的layout_width和layout_height属性计算子view的measure。 getChildMeasureSpec计算子view的measure，总结如下：1.如果在xml中指定了子view的具体大小，那么计算结果不管父 的measure是什么，结果都是EXACITY+child_size，2.如果子view的height指定的值为FILL_PARENT，则返回的 结果为：EXACITY+size，原因很简单：因为FILL_PARENT的意思是充满这个父view，所以返回的子view的measure就是 view的大小。3.如果子view的大小为wrap_content,那么返回的结果都为AT_MOST+size，原因是：最大不能超过父view的 大小。
  4. 子view的measure确定好以后，然后调用子view的measure方法，如果子view是View对象，则该view 的大小测量结束，开始下一个子view的循环，如果子view是ViewGroup那么，又开始一个新的递归，处理逻辑和上面一样，直到所有的view对 象测量结束。
  5. 所有的子view测量结束后，才开始对layout_weight计算，这样我们可能想到，如果父view已经被占满了， 那么有可能layout_weight大于0的view对象是不会显示的，而计算layout_weight的方法也很简单，就是用总高度减去上面分析完 mTotalLength的值，就是剩下，然后去平分给view对象，注意计算权重时优先去 android:android:weightSum（LinearLayout的xml属性）的值，如果不设置该值会计算和，所以该值既然设置了，就一 定要子view的weight的总和相等，否则平分可能不能得到预期效果。

 过程分析完毕，这篇文章这里提到了LinearLayout中的layout_weight属性，这个属性对很对人来说是又恨又爱，下篇文章，我们将来总结改属性的详细用法，让大家彻底理解这个属性。

分享到：
| android- View工作原理（二）导致View重建 ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

Magicbox
Global site tag (gtag.js) - Google Analytics