Android View 测量流程(Measure)全面解析

private void performtraversals() {
  ...

 if (!mstopped) {
  int childwidthmeasurespec = getrootmeasurespec(mwidth, lp.width); // 1
  int childheightmeasurespec = getrootmeasurespec(mheight, lp.height);
  performmeasure(childwidthmeasurespec, childheightmeasurespec); 
  }
 }

 if (didlayout) {
  performlayout(lp, desiredwindowwidth, desiredwindowheight);
  ...
 }


 if (!canceldraw && !newsurface) {
  if (!skipdraw || mreportnextdraw) {
  if (mpendingtransitions != null && mpendingtransitions.size() > 0) {
   for (int i = 0; i < mpendingtransitions.size(); ++i) {
   mpendingtransitions.get(i).startchanginganimations();
   }
   mpendingtransitions.clear();
  }

  performdraw();
  }
 } 
 ...
}

public static class measurespec {
 private static final int mode_shift = 30;
 private static final int mode_mask = 0x3 << mode_shift;

 /**
  * unspecified 模式：
  * 父view不对子view有任何限制，子view需要多大就多大
  */ 
 public static final int unspecified = 0 << mode_shift;

 /**
  * exactyly 模式：
  * 父view已经测量出子viwe所需要的精确大小，这时候view的最终大小
  * 就是specsize所指定的值。对应于match_parent和精确数值这两种模式
  */ 
 public static final int exactly = 1 << mode_shift;

 /**
  * at_most 模式：
  * 子view的最终大小是父view指定的specsize值，并且子view的大小不能大于这个值，
  * 即对应wrap_content这种模式
  */ 
 public static final int at_most = 2 << mode_shift;

 //将size和mode打包成一个32位的int型数值
 //高2位表示specmode，测量模式，低30位表示specsize，某种测量模式下的规格大小
 public static int makemeasurespec(int size, int mode) {
  if (susebrokenmakemeasurespec) {
  return size + mode;
  } else {
  return (size & ~mode_mask) | (mode & mode_mask);
  }
 }

 //将32位的measurespec解包，返回specmode,测量模式
 public static int getmode(int measurespec) {
  return (measurespec & mode_mask);
 }

 //将32位的measurespec解包，返回specsize，某种测量模式下的规格大小
 public static int getsize(int measurespec) {
  return (measurespec & ~mode_mask);
 }
 //...
 }

/**
 * @param windowsize
 *  the available width or height of the window
 *
 * @param rootdimension
 *  the layout params for one dimension (width or height) of the
 *  window.
 *
 * @return the measure spec to use to measure the root view.
 */
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;
 //省略...

 }
 return measurespec;
}

private void performmeasure(int childwidthmeasurespec, int childheightmeasurespec) {
 trace.tracebegin(trace.trace_tag_view, "measure");
 try {
 mview.measure(childwidthmeasurespec, childheightmeasurespec);
 } finally {
 trace.traceend(trace.trace_tag_view);
 }
}

public final void measure(int widthmeasurespec, int heightmeasurespec) {
 boolean optical = islayoutmodeoptical(this);
 if (optical != islayoutmodeoptical(mparent)) {
 ...
 if ((mprivateflags & pflag_force_layout) == pflag_force_layout ||
  widthmeasurespec != moldwidthmeasurespec ||
  heightmeasurespec != moldheightmeasurespec) {
  ...
  if (cacheindex < 0 || signoremeasurecache) {
  // measure ourselves, this should set the measured dimension flag back
  onmeasure(widthmeasurespec, heightmeasurespec);
  mprivateflags3 &= ~pflag3_measure_needed_before_layout;
  } 
 ...
}

@override
protected void onmeasure(int widthmeasurespec, int heightmeasurespec) {
 //获取当前布局内的子view数量
 int count = getchildcount();

 //判断当前布局的宽高是否是match_parent模式或者指定一个精确的大小，如果是则置measurematchparent为false.
 final boolean measurematchparentchildren =
  measurespec.getmode(widthmeasurespec) != measurespec.exactly ||
  measurespec.getmode(heightmeasurespec) != measurespec.exactly;
 mmatchparentchildren.clear();

 int maxheight = 0;
 int maxwidth = 0;
 int childstate = 0;

 //遍历所有类型不为gone的子view
 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中宽高的最大者，因为如果framelayout是wrap_content属性
  //那么它的大小取决于子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());
  //如果framelayout是wrap_content模式，那么往mmatchparentchildren中添加
  //宽或者高为match_parent的子view，因为该子view的最终测量大小会受到framelayout的最终测量大小影响
  if (measurematchparentchildren) {
  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));

 //子view中设置为match_parent的个数
 count = mmatchparentchildren.size();
 //只有framelayout的模式为wrap_content的时候才会执行下列语句
 if (count > 1) {
 for (int i = 0; i < count; i++) {
  final view child = mmatchparentchildren.get(i);
  final marginlayoutparams lp = (marginlayoutparams) child.getlayoutparams();

  //对framelayout的宽度规格设置，因为这会影响子view的测量
  final int childwidthmeasurespec;

  /**
  * 如果子view的宽度是match_parent属性，那么对当前framelayout的measurespec修改：
  * 把widthmeasurespec的宽度规格修改为:总宽度 - padding - margin，这样做的意思是：
  * 对于子viw来说，如果要match_parent，那么它可以覆盖的范围是framelayout的测量宽度
  * 减去padding和margin后剩下的空间。
  *
  * 以下两点的结论，可以查看getchildmeasurespec()方法：
  *
  * 如果子view的宽度是一个确定的值，比如50dp，那么framelayout的widthmeasurespec的宽度规格修改为：
  * specsize为子view的宽度，即50dp，specmode为exactly模式
  * 
  * 如果子view的宽度是wrap_content属性，那么framelayout的widthmeasurespec的宽度规格修改为：
  * specsize为子view的宽度减去padding减去margin，specmode为at_most模式
  */
  if (lp.width == layoutparams.match_parent) {
  final int width = math.max(0, getmeasuredwidth()
   - getpaddingleftwithforeground() - getpaddingrightwithforeground()
   - lp.leftmargin - lp.rightmargin);
  childwidthmeasurespec = measurespec.makemeasurespec(
   width, measurespec.exactly);
  } else {
  childwidthmeasurespec = getchildmeasurespec(widthmeasurespec,
   getpaddingleftwithforeground() + getpaddingrightwithforeground() +
   lp.leftmargin + lp.rightmargin,
   lp.width);
  }
  //同理对高度进行相同的处理，这里省略...

  //对于这部分的子view需要重新进行measure过程
  child.measure(childwidthmeasurespec, childheightmeasurespec);
 }
 }
}

public static int resolvesizeandstate(int size, int measurespec, int childmeasuredstate) {
 final int specmode = measurespec.getmode(measurespec);
 final int specsize = measurespec.getsize(measurespec);
 final int result;
 switch (specmode) {
 case measurespec.at_most:
  if (specsize < size) {
  result = specsize | measured_state_too_small;
  } else {
  result = size;
  }
  break;
 case measurespec.exactly:
  result = specsize;
  break;
 case measurespec.unspecified:
 default:
  result = size;
 }
 return result | (childmeasuredstate & measured_state_mask);
}

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); // 1
}

public static int getchildmeasurespec(int spec, int padding, int childdimension) {
 int specmode = measurespec.getmode(spec);
 int specsize = measurespec.getsize(spec);

 //size表示子view可用空间：父容器尺寸减去padding
 int size = math.max(0, specsize - padding);

 int resultsize = 0;
 int resultmode = 0;

 switch (specmode) {
 // parent has imposed an exact size on us
 case measurespec.exactly:
 if (childdimension >= 0) {
  resultsize = childdimension;
  resultmode = measurespec.exactly;
 } else if (childdimension == layoutparams.match_parent) {
  // child wants to be our size. so be it.
  resultsize = size;
  resultmode = measurespec.exactly;
 } else if (childdimension == layoutparams.wrap_content) {
  // 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
 case measurespec.at_most:
 //省略..具体可自行参考源码
 break;

 // parent asked to see how big we want to be
 case measurespec.unspecified:
 //省略...具体可自行参考源码
 break;
 }
 return measurespec.makemeasurespec(resultsize, resultmode);
}

protected void onmeasure(int widthmeasurespec, int heightmeasurespec) {
 setmeasureddimension(getdefaultsize(getsuggestedminimumwidth(), widthmeasurespec),
  getdefaultsize(getsuggestedminimumheight(), heightmeasurespec));
}

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

protected int getsuggestedminimumwidth() {
 return (mbackground == null) ? mminwidth : max(mminwidth, mbackground.getminimumwidth());
}