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

绪

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

这篇文章要解决的问题有：

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

一切从DecorView说起

大家都知道在我们的应用窗口中最顶层的View是DecorView， 那么自然而然，一个测量的开始肯定就是从DecorView开始的，而且，我们还知道，一个测量的开始是从ViewRootImpl的performTraversals方法开始，所以我们理所当然的要从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，那这里肯定就是测量的开始了，但是，重点是我们关心的childWidthMeasureSpec和childWidthMeasureSpec是怎么计算出来的， 这里调用了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，未经博主允许不得转载。

时间： 2024-10-11 23:52:09

View测量机制详解—从DecorView说起的相关文章

Android事件分发机制详解(1)----探究View的事件分发

探究View的事件分发 在Activity中,只有一个按钮,注册一个点击事件 [java] view plaincopy button.setOnClickListener(new OnClickListener() { @Override public void onClick(View v) { Log.d("TAG", "onClick execute"); } }); 如果在需要一个触摸事件 [java] view plaincopy button.setO

Android Touch事件传递机制详解 上

尊重原创:http://blog.csdn.net/yuanzeyao/article/details/37961997 最近总是遇到关于Android Touch事件的问题,如:滑动冲突的问题,以前也花时间学习过Android Touch事件的传递机制,可以每次用起来的时候总是忘记了,索性自己总结一下写篇文章避免以后忘记了,其实网上关于Touch事件的传递的文章真的很多,但是很少有系统性的,都是写了一个简单的demo运行了一下,对于我们了解Android Touch事件基本上没有任何帮助. 今

View绘制过程详解

View绘制过程详解 界面窗口的根布局是DecorView,该类继承自FrameLayout.说到View绘制,想到的就是从这里入手,而FrameLayout继承自ViewGroup.感觉绘制肯定会在ViewGroup或者View中, 但是木有找到.发现ViewGroup实现ViewParent接口,而ViewParent有一个实现类是ViewRootImpl, ViewGruop中会使用ViewRootImpl- /** * The top of a view hierarchy, imple

Android触摸屏事件派发机制详解与源码分析三(Activity篇)

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 该篇承接上一篇<Android触摸屏事件派发机制详解与源码分析二(ViewGroup篇)>,阅读本篇之前建议先阅读. 1 背景 还记得前面两篇从Android的基础最小元素控件(View)到ViewGroup控件的触摸屏事件分发机制分析吗?你可能看完会有疑惑,View的事件是ViewGro

Android View measure流程详解

Android View measure流程详解 Android中View绘制的流程包括:measure(测量)->layout(布局)->draw(绘制). 因为Android中每个View都占据了一块矩形的空间,当我们要在屏幕上显示这个矩形的View的时候 首先我们需要知道这个矩形的大小(宽和高)这就对应了View的measure流程. 有了View的宽和高,我们还需要知道View左上角的起点在哪里,右下角的终点在哪里,这就对应了View的layout流程. 当矩形的区域在屏幕上确定之后,

Android触摸屏事件派发机制详解与源码分析二(ViewGroup篇)

1 背景 还记得前一篇<Android触摸屏事件派发机制详解与源码分析一(View篇)>中关于透过源码继续进阶实例验证模块中存在的点击Button却触发了LinearLayout的事件疑惑吗?当时说了,在那一篇咱们只讨论View的触摸事件派发机制,这个疑惑留在了这一篇解释,也就是ViewGroup的事件派发机制. PS:阅读本篇前建议先查看前一篇<Android触摸屏事件派发机制详解与源码分析一(View篇)>,这一篇承接上一篇. 关于View与ViewGroup的区别在前一篇的A

Android触摸屏事件派发机制详解与源码分析

请看下面三篇博客,思路还是蛮清晰的,不过还是没写自定义控件系列哥们的思路清晰: Android触摸屏事件派发机制详解与源码分析一(View篇) http://blog.csdn.net/yanbober/article/details/45887547 Android触摸屏事件派发机制详解与源码分析二(ViewGroup篇) http://blog.csdn.net/yanbober/article/details/45912661 Android触摸屏事件派发机制详解与源码分析三(Activi

SpringMVC视图机制详解[附带源码分析]

目录 前言 重要接口和类介绍 源码分析 编码自定义的ViewResolver 总结 参考资料 前言 SpringMVC是目前主流的Web MVC框架之一. 如果有同学对它不熟悉,那么请参考它的入门blog:http://www.cnblogs.com/fangjian0423/p/springMVC-introduction.html 本文将分析SpringMVC的视图这部分内容,让读者了解SpringMVC视图的设计原理. 重要接口和类介绍 1. View接口 视图基础接口,它的各种实现类是无

Android ViewGroup触摸屏事件派发机制详解与源码分析

PS一句:最终还是选择CSDN来整理发表这几年的知识点,该文章平行迁移到CSDN.因为CSDN也支持MarkDown语法了,牛逼啊! [工匠若水 http://blog.csdn.net/yanbober] 该篇承接上一篇<Android View触摸屏事件派发机制详解与源码分析>,阅读本篇之前建议先阅读. 1 背景 还记得前一篇<Android View触摸屏事件派发机制详解与源码分析>中关于透过源码继续进阶实例验证模块中存在的点击Button却触发了LinearLayout的事