码迷,mamicode.com
首页 > 其他好文 > 详细

View测量机制详解—从DecorView说起

时间:2015-10-19 09:27:11      阅读:302      评论:0      收藏:0      [点我收藏+]

标签:measure

很多朋友都沉迷于自定义View, 而自定义View离不开measure、layout、draw三个步骤,在测量方面,很多朋友仅仅是知道怎么去测量一个控件,而对于为什么要这么做等等问题都搞的不是很清楚,今天这篇文章我们就从View树的最顶层DecorView开始分析测量到底是怎么一回事。
这篇文章要解决的问题有:

  1. onMeasure的两个参数从哪来。
  2. 最开始的参数是怎么计算出来的。
  3. 测量规格是根据什么得到的。

一切从DecorView说起

大家都知道在我们的应用窗口中最顶层的View是DecorView, 那么自然而然,一个测量的开始肯定就是从DecorView开始的,而且,我们还知道,一个测量的开始是从ViewRootImplperformTraversals方法开始,所以我们理所当然的要从performTraversals方法开始看起。performTraversals很长,看起来甚至有点可怕,不过没关系,我们仅仅关心我们需要的代码就ok,

private void performTraversals() {
  ...
  if (!mStopped) {
    boolean focusChangedDueToTouchMode = ensureTouchModeLocally(
            (relayoutResult&WindowManagerGlobal.RELAYOUT_RES_IN_TOUCH_MODE) != 0);
    if (focusChangedDueToTouchMode || mWidth != host.getMeasuredWidth()
            || mHeight != host.getMeasuredHeight() || contentInsetsChanged) {
        // mark
        // 获取测量规格 mWidth和mHeight当前视图frame的大小
        // lp是WindowManager.LayoutParams
        int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);
        int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);

        if (DEBUG_LAYOUT) Log.v(TAG, "Ooops, something changed!  mWidth="
                + mWidth + " measuredWidth=" + host.getMeasuredWidth()
                + " mHeight=" + mHeight
                + " measuredHeight=" + host.getMeasuredHeight()
                + " coveredInsetsChanged=" + contentInsetsChanged);

         // Ask host how big it wants to be
        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);
        ...
      }
      ...
    }
}

在这里我们看到了performMeasure,那这里肯定就是测量的开始了,但是,重点是我们关心的childWidthMeasureSpecchildWidthMeasureSpec是怎么计算出来的, 这里调用了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;
}

这个方法很简单,就是根据rootDimension的值来定义不同的measureSpec

当是MATCH_PARENT的时候,我们make一个大小是windowSize,规格是精确值的MeasureSpec
当是WRAP_CONTENT的时候,我们make一个大小是windowSize,规格是最大为windowSize的MeasureSpec
其他的情况,也就是rootDimension是具体值,那我们得到的是一个大小为rootDimension,规格为精确的MeasureSpec

DecorView的测量

通过看上面的代码,我们最终有了一个测量规格,而且,我们可以猜测到宽高值都是固定的,就是我们视图的大小,所以,最后的measureSpec是精确的。现在我们就来到DecorView,看看到底是怎么测量的。

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  // 获取测量规格, 这里是EXACTLY
   final int widthMode = getMode(widthMeasureSpec);
   final int heightMode = getMode(heightMeasureSpec);

   boolean fixedWidth = false;

   // 这里有点意思,如果不是EXACTLY的
   // 这里还是要获取下视图的大小
   // 让测量规格是EXACTLY
   if (widthMode == AT_MOST) {
       final TypedValue tvw = isPortrait ? mFixedWidthMinor : mFixedWidthMajor;
       if (tvw != null && tvw.type != TypedValue.TYPE_NULL) {
           final int w;
           if (tvw.type == TypedValue.TYPE_DIMENSION) {
               w = (int) tvw.getDimension(metrics);
           } else if (tvw.type == TypedValue.TYPE_FRACTION) {
               w = (int) tvw.getFraction(metrics.widthPixels, metrics.widthPixels);
           } else {
               w = 0;
           }

           if (w > 0) {
               // 这里重新设置了测量规格
               // 大小是performMeasure中给出的大小和自己获取的大小的最小值
               final int widthSize = MeasureSpec.getSize(widthMeasureSpec);
               widthMeasureSpec = MeasureSpec.makeMeasureSpec(
                       Math.min(w, widthSize), EXACTLY);
               fixedWidth = true;
           }
       }
   }
   ...
   // 下面同样有一个高度的判断
   ...
   super.onMeasure(widthMeasureSpec, heightMeasureSpec);
   ...
}

DecorView的测量有点意思,在发现performMeasure中给的测量规格不是精确值的时候,自己又去获取一下并且取两者的最小值,当然这里肯定是吧测量规格设置为精确值了。判断好后,接着调用了super.onMeasure,通过源码我们可以知道其实DecorView继承自FrameLayout,所以,现在我们要去FrameLayout的onMeasure方法看看了。

FrameLayout的测量

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  int count = getChildCount();

  // 如果测量规格有一个不是精确值,这里就为true
  final boolean measureMatchParentChildren =
          MeasureSpec.getMode(widthMeasureSpec) != MeasureSpec.EXACTLY ||
          MeasureSpec.getMode(heightMeasureSpec) != MeasureSpec.EXACTLY;
  mMatchParentChildren.clear();

  int maxHeight = 0;
  int maxWidth = 0;
  int childState = 0;

  for (int i = 0; i < count; i++) {
      final View child = getChildAt(i);
      if (mMeasureAllChildren || child.getVisibility() != GONE) {
          // 测量子view
          measureChildWithMargins(child, widthMeasureSpec, 0, heightMeasureSpec, 0);
          final LayoutParams lp = (LayoutParams) child.getLayoutParams();
          // 宽度为前一个计算出来的宽度和当前view的宽度取最大值
          maxWidth = Math.max(maxWidth,
                  child.getMeasuredWidth() + lp.leftMargin + lp.rightMargin);
          maxHeight = Math.max(maxHeight,
                  child.getMeasuredHeight() + lp.topMargin + lp.bottomMargin);
          childState = combineMeasuredStates(childState, child.getMeasuredState());
          if (measureMatchParentChildren) {
              // 如果当前view有match_parent的地方,
              // 记录一下当前view
              if (lp.width == LayoutParams.MATCH_PARENT ||
                      lp.height == LayoutParams.MATCH_PARENT) {
                  mMatchParentChildren.add(child);
              }
          }
      }
  }

  // 一些常规的边边角角和保证现在的大小能包含的了所有组件

  // Account for padding too
  maxWidth += getPaddingLeftWithForeground() + getPaddingRightWithForeground();
  maxHeight += getPaddingTopWithForeground() + getPaddingBottomWithForeground();

  // Check against our minimum height and width
  maxHeight = Math.max(maxHeight, getSuggestedMinimumHeight());
  maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());

  // Check against our foreground‘s minimum height and width
  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));

  count = mMatchParentChildren.size();
  // 这里有值表明了两点:
  // 1 当前FrameLayout的宽和高的建议规格有不是精确值的
  // 2 子view有含有match_parent的地方
  if (count > 1) {
      for (int i = 0; i < count; i++) {
          final View child = mMatchParentChildren.get(i);

          final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
          int childWidthMeasureSpec;
          int childHeightMeasureSpec;

          if (lp.width == LayoutParams.MATCH_PARENT) {
              childWidthMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredWidth() -
                      getPaddingLeftWithForeground() - getPaddingRightWithForeground() -
                      lp.leftMargin - lp.rightMargin,
                      MeasureSpec.EXACTLY);
          } else {
              childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                      getPaddingLeftWithForeground() + getPaddingRightWithForeground() +
                      lp.leftMargin + lp.rightMargin,
                      lp.width);
          }

          if (lp.height == LayoutParams.MATCH_PARENT) {
              childHeightMeasureSpec = MeasureSpec.makeMeasureSpec(getMeasuredHeight() -
                      getPaddingTopWithForeground() - getPaddingBottomWithForeground() -
                      lp.topMargin - lp.bottomMargin,
                      MeasureSpec.EXACTLY);
          } else {
              childHeightMeasureSpec = getChildMeasureSpec(heightMeasureSpec,
                      getPaddingTopWithForeground() + getPaddingBottomWithForeground() +
                      lp.topMargin + lp.bottomMargin,
                      lp.height);
          }

          child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
      }
  }
}

FrameLayout的测量很简单,先去计算所有子view中最大的宽和高,然后调用resolveSizeAndState去最终确认大小, 那我们来看看resolveSizeAndState方法到底干了嘛,这个方法位于View类中,

public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
    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:
        if (specSize < size) {
            result = specSize | MEASURED_STATE_TOO_SMALL;
        } else {
            result = size;
        }
        break;
    case MeasureSpec.EXACTLY:
        result = specSize;
        break;
    }
    return result | (childMeasuredState&MEASURED_STATE_MASK);
}

这里的逻辑也很简单,但是绝对是有代表性的,我们自己写的测量跟这里有很大的相似之处,首先这里去判断测量规格,如果是EXACTLY,则结果直接是MeasureSpec里获取的大小,如果是AT_MOST,这里取两个大小的最小值。到这里FrameLayout的测量也就完成了,而且我们也看懂了测量是如何从DecorView开始一步步的到child的测量过程,不过这个过程我们还没有细看。

测量子view

下面我们就从measureChildWithMargins方法开始分析一下如何进行的子view的测量,这个方法在ViewGroup中定义的。

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中,这里获取了父Group对子View的建议,最后调用child.measure将建议传递进去,从而开始了整个View树的测量流程。

public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
    int specMode = MeasureSpec.getMode(spec);
    int specSize = MeasureSpec.getSize(spec);

    int size = Math.max(0, specSize - padding);

    int resultSize = 0;
    int resultMode = 0;

    switch (specMode) {
    // Parent has imposed an exact size on u
    // 如果父view的规格是精确值
    case MeasureSpec.EXACTLY:
        // 如果子view的layout_XXX是一个确定的值
        if (childDimension >= 0) {
            // 测建议的值是子view指定的值
            // 规格是EXACTLY
            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
            // 如果子view的layout_XXX是MATCH_PARENT
            // 则建议的值是子view自己想要的的大小,也就是父view剩下的大小
            // 规格是EXACTLY
            // Child wants to be our size. So be it.
            resultSize = size;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
            // 如果子view的layout_XXX是WRAP_CONTENT
            // 则建议的值是子view自己想要的的大小,也就是父view剩下的大小
            // 规格是AT_MOST
            // Child wants to determine its own size. It can‘t be
            // bigger than us.
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        }
        break;

    // Parent has imposed a maximum size on us
    // 如果父view的规格是AT_MOST
    case MeasureSpec.AT_MOST:
        // 如果子view的layout_XXX是一个确定的值
        if (childDimension >= 0) {
            // 测建议的值是子view指定的值
            // 规格是EXACTLY
            // Child wants a specific size... so be it
            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
            // 如果子view的layout_XXX是MATCH_PARENT
            // 则建议的值是子view自己想要的的大小,也就是父view剩下的大小
            // 规格是AT_MOST
            // Child wants to be our size, but our size is not fixed.
            // Constrain child to not be bigger than us.
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
            // 如果子view的layout_XXX是WRAP_CONTENT
            // 则建议的值是子view自己想要的的大小,也就是父view剩下的大小
            // 规格是AT_MOST
            // Child wants to determine its own size. It can‘t be
            // bigger than us.
            resultSize = size;
            resultMode = MeasureSpec.AT_MOST;
        }
        break;

    // Parent asked to see how big we want to be
    // 如果父view的规格是不确定的
    case MeasureSpec.UNSPECIFIED:
        // 如果子view的layout_XXX是一个确定的值
        if (childDimension >= 0) {
            // 测建议的值是子view指定的值
            // 规格是EXACTLY
            // Child wants a specific size... let him have it
            resultSize = childDimension;
            resultMode = MeasureSpec.EXACTLY;
        } else if (childDimension == LayoutParams.MATCH_PARENT) {
            // 如果子view的layout_XXX是MATCH_PARENT
            // 则建议的值0
            // 规格是UNSPECIFIED
            // Child wants to be our size... find out how big it should
            // be
            resultSize = 0;
            resultMode = MeasureSpec.UNSPECIFIED;
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {
            // 如果子view的layout_XXX是WRAP_CONTENT
            // 则建议的值0
            // 规格是UNSPECIFIED
            // Child wants to determine its own size.... find out how
            // big it should be
            resultSize = 0;
            resultMode = MeasureSpec.UNSPECIFIED;
        }
        break;
    }
    return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
}

这里的代码正是measureSpec依据什么而来最有力的回答,在代码中已经注释的很详细了,不过下面还是要总结一下:

  1. 父View是EXACTLY,子view的大小指定为确定值,则给子view的建议大小是子view自己设置的大小,规格为EXACTLY。
  2. 父View是EXACTLY,子view的大小指定为MATCH_PARENT,则给子view的建议大小是父view剩下的大小,规格为EXACTLY。
  3. 父View是EXACTLY,子view的大小指定为WRAP_CONTENT,则给子view的建议大小是父view剩下的大小,规格为AT_MOST。
  4. 父View是AT_MOST,子view的大小指定为确定值,则给子view的建议大小是子view自己设置的大小,规格为EXACTLY。
  5. 父View是AT_MOST,子view的大小指定为MATCH_PARENT,则给子view的建议大小是父view剩下的大小,规格为AT_MOST。
  6. 父View是AT_MOST,子view的大小指定为WRAP_CONTENT,则给子view的建议大小是父view剩下的大小,规格为AT_MOST。
  7. 父View是UNSPECIFIED,子view的大小指定为确定值,则给子view的建议大小是子view自己设置的大小,规格为EXACTLY。
  8. 父View是UNSPECIFIED,子view的大小指定为MATCH_PARENT,则给子view的建议大小0,规格为UNSPECIFIED。
  9. 父View是UNSPECIFIED,子view的大小指定为WRAP_CONTENT,则给子view的建议大小0,规格为UNSPECIFIED。

最后的最后

ok, 到这里,我们虽然只是分析了DecorView和他的父类FrameLayout的测量流程,不过这也算是将整个流程分析完了,为什么这么说呢? 只要我们看到了measure child的部分,就是走完了一个闭环,接下来的子view的测量流程和上面的一样,只不过是测量的细节不一样罢了,最后,我们再来看一个方法,很多同学写测量的时候都会使用getDefaultSize这个方法,那么这个方法究竟干了什么呢?

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;
}

是不是又一种似曾相识的感觉,这里的逻辑也很简单,就是根据测量规格是定义不用的大小,如果是UNSPECIFIED,则结果就是我们传递进来的size,如果是AT_MOST或者EXACTLY,则结果就是我们父布局建议的大小。很多同学可能喜欢这么用,

int width = getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec);

这样做有一个坑,在一些viewgroup中获得的结果是0,为什么呢? 例如HorizontalScrollView,从源码上看, 它最后给子view建议的规格会是UNSPECIFIED,从getDefaultSize源码上看,此时结果就是我们传递的size,也就是getSuggestedMinimumWidth返回的值,我们来看看这个方法的定义,

protected int getSuggestedMinimumWidth() {
    return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
}

这里取值是我们设置的minWidth和背景的minWidth的最大值,如果minWidth和背景我们都没有设置的话,这里返回的也是0了,这样,我们就能理解结果为什么是0了。 从这个小问题是还能看出一点,我们在自己写测量的时候不能只依靠父布局,而是要参考父布局的建议和自己的测量结果。任何有霸权倾向的测量都是不可取的。

好了,这篇文章就到这里吧,相信大家在仔细阅读后会对View的测量机制有一个全新的认识。

版权声明:本文来自Loader's Blog,未经博主允许不得转载。

View测量机制详解—从DecorView说起

标签:measure

原文地址:http://blog.csdn.net/qibin0506/article/details/49245601

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!