Android学习笔记（六）| View的工作原理（下）

参考书籍：《Android开发艺术探索》 任玉刚
如有错漏，请批评指出！

View的工作流程

前面说过，View的工作流程主要是指 measure、layout、draw 这三大流程，下面来一一进行分析。

measure过程

View和ViewGroup的 measure 过程是不同的，如果只是一个普通View，那么通过 measure 方法就能完成其测量过程，如果是一个ViewGroup，除了完成自己的测量过程外，还会遍历所有子元素，并调用其 measure 方法，各个子元素再递归去执行这个流程。

• View 的 measure 过程
  View的 measure 过程由其 measure() 方法来完成，measure()方法是一个 final 类型的方法，也就是说子类不能重写这个方法，在 measure() 方法中会调用 onMeasure() 方法，因此我们只需要看 onMeasure() 方法的源码实现：

  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
      setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
              getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
  }
  

  onMeasure() 方法通过调用 setMeasuredDimension() 方法来设置 View 的测量宽高（不等同于实际宽高），而这个测量宽高是通过 getDefaultSize() 方法来处理的，我们再来看 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;
  }
  

  这个方法的逻辑很简单，我们需要注意的是，传入的 measureSpec 参数就是 View 宽 / 高的测量值，也就是说，当View的测量模式为 AT_MOST 或 EXACTLY 模式时，这个方法返回的就是View测量后的 SpecSize。
  当View测量模式为 UNSPECIFIED 模式时，一般用于系统内部的测量过程，这种情况下，会返回第一个参数，也就是getSuggestedMinimumWidth() 和 getSuggestedMinimumHeight() 方法的返回值。我们来看一下它们的源码：

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

  这两个方法的实现原理是相同的，我们只看 getSuggestedMinimumWidth()，这个方法里面涉及到三个值：
  mBackground —— 即当前View的背景
  mMinWidth —— android:mMinWidth 这个属性指定的值
  mBackground.getMinimumWidth() —— 当前View背景Drawable的原始宽度
  这个逻辑很简单，我们直接来看这三个值，前两个很好理解，第三个是什么意思呢？来看一下 Drawable 的 getMinimumWidth() 方法的实现：

  public int getMinimumWidth() {
      // Drawable 的原始宽高
      final int intrinsicWidth = getIntrinsicWidth();
      return intrinsicWidth > 0 ? intrinsicWidth : 0;
  }
  

  可以看到，当Drawable有原始宽高时，这个方法返回的是 Drawable 的原始宽高。至于Drawable什么时候有原始宽高（暂且略过，或者可以先看看《Android开发艺术探索》第六章），这里先举个例子，ShapeDrawable 无原始宽高，而BitmapDrawable有原始宽高（图片尺寸）。

  从getDefaultSize() 方法的实现可以得出一个结论，当我们自定义View时，如果直接继承View，就需要重写 onMeasure() 方法并设置 wrap_content（即AT_MOST模式） 的默认大小，否则在布局中使用 wrap_content 属性的效果
  和 match_parent 属性的效果是一样的。原因如下：当我们给View的宽高指定 wrap_content 属性时，它的 specMode
  是 AT_MOST模式， 在这种模式下，它的宽高等于 specSize。在 Android学习笔记（五）| View的工作原理（上） 的结尾，我们总结了一张表，在这种模式下，View的 specSize不会超过 parentSize，而 parentSize 是父容器的 可用空间，但是View 类并没有对这个specSize作任何处理，所以 specSize 就是 parentSize ，也就是说，这种模式下View会填充满父容器的可用空间，即和 match_parent 的效果相同。

  这个问题很好解决。只需要重写 onMeasure() 方法，给 AT_MOST 模式指定一个默认宽高即可：

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
      super.onMeasure(widthMeasureSpec, heightMeasureSpec);
      int widthMeasureMode = MeasureSpec.getMode(widthMeasureSpec);
      int widthMeasureSize = MeasureSpec.getSize(widthMeasureSpec);
      int heightMeasureMode = MeasureSpec.getMode(heightMeasureSpec);
      int heightMeasureSize = MeasureSpec.getSize(heightMeasureSpec);
      // mWidth 即指定的默认宽度
      if (widthMeasureMode == MeasureSpec.AT_MOST){
          widthMeasureSize = mWidth;
      }
      // mHeight 即指定的默认高度
      if (heightMeasureMode == MeasureSpec.AT_MOST){
          heightMeasureSize = mHeight;
      }
      setMeasuredDimension(widthMeasureSize, heightMeasureSize);
  }
  

• ViewGroup 的 measure 过程
  ViewGroup 除了完成自己的 measure 过程，还会遍历所有的子元素并调用其 measure 方法，各个子元素再递归去执行这个过程。不过ViewGroup是一个抽象类，没有重写View的 onMeasure() 方法，但是它提供了一个 measureChildren() 的方法：

  protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
      final int size = mChildrenCount;
      final View[] children = mChildren;
      for (int i = 0; i < size; ++i) {
          final View child = children[i];
          if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
              measureChild(child, widthMeasureSpec, heightMeasureSpec);
          }
      }
  }
  

  这个方法会依次遍历所有子元素，若当前子元素的 visibility 不为 GONE 时，就会调用 measureChild() 方法：

  protected void measureChild(View child, int parentWidthMeasureSpec,
          int parentHeightMeasureSpec) {
      final LayoutParams lp = child.getLayoutParams();
  
      final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
              mPaddingLeft + mPaddingRight, lp.width);
      final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
              mPaddingTop + mPaddingBottom, lp.height);
  
      child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
  }
  

  这个方法的逻辑也很简单，就是取出当前子元素的 LayoutParams，通过 getChildMeasureSpec() 方法（在前面关于 MeasureSpec 的内容中分析过这个方法的源码）来创建子元素的 MeasureSpec，然后将MeasureSpec直接传递给子元素的 measure() 方法进行测量。
  通过上面的分析，我们会发现 ViewGroup 并没有定义其具体测量过程，其测量过程的 onMeasure 方法需要各个子类去具体实现，比如LinearLayout、RelativeLayout等。之所以这么设计，是因为不同的ViewGroup子类有不同的布局特性，因此他们的测量细节存在差异，无法统一实现。

  接下类会从一个具体的ViewGroup（LinearLayout）的源码层面来分析其 measure 过程。

• LinearLayout 的 measure 过程
  首先来看 LinearLayout 的 onMeasure() 方法：

  @Override
  protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
      if (mOrientation == VERTICAL) {
          measureVertical(widthMeasureSpec, heightMeasureSpec);
      } else {
          measureHorizontal(widthMeasureSpec, heightMeasureSpec);
      }
  }
  

  这里就是单纯的判断 LinearLayout 的布局方式，我们选择 VERTICAL 方式来进行分析，下面是 measureVertical() 方法的源码主干部分（因为这个方法很长，我们只看大概逻辑）：

  void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
      
      ...  (变量定义)
  
      // See how tall everyone is. Also remember max width.
      for (int i = 0; i < count; ++i) {
          final View child = getVirtualChildAt(i);
          
          ...    (判断View是否需要测量以及是否有分割线)
  
          final LayoutParams lp = (LayoutParams) child.getLayoutParams();
  
          totalWeight += lp.weight;
          // 是否使用了额外的空间
          final boolean useExcessSpace = lp.height == 0 && lp.weight > 0;
          if (heightMode == MeasureSpec.EXACTLY && useExcessSpace) {
              // Optimization: don't bother measuring children who are only
              // laid out using excess space. These views will get measured
              // later if we have space to distribute.
              final int totalLength = mTotalLength;
              mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
              skippedMeasure = true;
          } else {
              if (useExcessSpace) {
                  // The heightMode is either UNSPECIFIED or AT_MOST, and
                  // this child is only laid out using excess space. Measure
                  // using WRAP_CONTENT so that we can find out the view's
                  // optimal height. We'll restore the original height of 0
                  // after measurement.
                  lp.height = LayoutParams.WRAP_CONTENT;
              }
  
              // Determine how big this child would like to be. If this or
              // previous children have given a weight, then we allow it to
              // use all available space (and we will shrink things later
              // if needed).
              final int usedHeight = totalWeight == 0 ? mTotalLength : 0;
              measureChildBeforeLayout(child, i, widthMeasureSpec, 0,
                      heightMeasureSpec, usedHeight);
  
              final int childHeight = child.getMeasuredHeight();
              if (useExcessSpace) {
                  // Restore the original height and record how much space
                  // we've allocated to excess-only children so that we can
                  // match the behavior of EXACTLY measurement.
                  lp.height = 0;
                  consumedExcessSpace += childHeight;
              }
  
              final int totalLength = mTotalLength;
              mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
                     lp.bottomMargin + getNextLocationOffset(child));
  
              if (useLargestChild) {
                  largestChildHeight = Math.max(childHeight, largestChildHeight);
              }
          }
  
          ...            
      // 子元素测量完成
      }
      
      ...
  
  }
  

  从这段代码可以看出，LinearLayout 内部会遍历子元素并对需要测量的子元素执行 measureChildBeforeLayout() 方法，这个方法里面调用了 measureChildWithMargins() 方法（前面介绍 MeasureSpec 时分析过），这样每个子元素就依次进入 measure 流程了。并且 所有子元素的测量高度都会被累计起来，用 mTotalLength 这个变量来存储，每测量一个子元素，mTotalLength 就会增加（包括子View的高度和竖直方向的 mgrgin）。当子元素测量完毕后，LinearLayout会测量自己的大小，这部分代码刚才省略了：

  
      ...
  
      // Add in our padding
      mTotalLength += mPaddingTop + mPaddingBottom;
  
      int heightSize = mTotalLength;
  
      // Check against our minimum height
      heightSize = Math.max(heightSize, getSuggestedMinimumHeight());
  
      // Reconcile our calculated size with the heightMeasureSpec
      int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
      heightSize = heightSizeAndState & MEASURED_SIZE_MASK;
      ...
      setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
                  heightSizeAndState);
  
      ...
  
  

  这段代码的逻辑也很清晰，就是确定 LinearLayout 的高度，然后调用 setMeasuredDimension() 方法来设置其宽高。对于竖直方向的 LinearLayout 而言，它在水平方向的测量过程遵循 View 的测量过程，这里调用了 resolveSizeAndState() 方法来确定测量宽度，具体逻辑与View的测量过程相似，这里不作分析。在竖直方向则有所不同，如果它的布局中高度采用的是 match_parent 或具体数值，则测量过程和View一致，即高度为specSize；如果它的布局中高度采用 wrap_content，那么它的高度是所有子View所占用高度的和（最大为它的父容器剩余空间）；当然，它的最终高度还要减掉竖直方向上的 padding 值。

  View的 measure 过程是三大流程中最复杂的一个， measure 完成后，通过 getMeasuredWidth() / getMeasuredHeight()方法可以获取到测量宽高。不过在某些极端情况，系统可能需要多次测量才能确定最终的测量宽高，这个时候 onMeasure() 方法中拿到的测量宽高可能不准确。比较好的做法就是在 onLayout() 方法中去获取View的测量宽高或最终宽高。

layout 过程

参考博客：自定义View Layout过程
Layout 过程的作用是确定View的位置，对于ViewGroup而言，layout() 方法确定自身位置，然后在layout() 方法中会调用 onLayout() 方法，这个方法中会遍历所有子元素，并调用其layout方法，依次递归；而对于普通View，则只需要确定自身的位置。

• 先来看普通 View 的 layout() 方法:

  public void layout(int l, int t, int r, int b) {
      if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
          onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
          mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
      }
  
      int oldL = mLeft;
      int oldT = mTop;
      int oldB = mBottom;
      int oldR = mRight;
  
      // 确定自身位置参数
      // 并判断当前View大小和位置是否发生变化
      boolean changed = isLayoutModeOptical(mParent) ?
              setOpticalFrame(l, t, r, b) : setFrame(l, t, r, b);
  
      if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
          // 普通View 没有子View，因此onLayout() 方法是一个空实现
          onLayout(changed, l, t, r, b);
  
          ···
      }
      ...
  }
  

  可以看到，这里其实就是确定自身的位置，不过涉及到两个方法 setOpticalFrame() 和 setFrame() ，这两个方法的区别在于是否有 视觉边界，直接看源码：

  /**
    * setFrame()
    * 设置View自身位置（包含视觉边界）
    */
  private boolean setOpticalFrame(int left, int top, int right, int bottom) {
      Insets parentInsets = mParent instanceof View ?
              ((View) mParent).getOpticalInsets() : Insets.NONE;
      Insets childInsets = getOpticalInsets();
      // 实际还是调用 setFrame() 方法
      return setFrame(
              left   + parentInsets.left - childInsets.left,
              top    + parentInsets.top  - childInsets.top,
              right  + parentInsets.left + childInsets.right,
              bottom + parentInsets.top  + childInsets.bottom);
  }
  
   /**
    * setFrame()
    * 设置View自身位置（不考虑视觉边界）
    * 返回值用来标记View大小和位置是否改变
    */
  protected boolean setFrame(int left, int top, int right, int bottom) {
      boolean changed = false;
  
      ···
  
      if (mLeft != left || mRight != right || mTop != top || mBottom != bottom) {
          changed = true;
  
          // Remember our drawn bit
          int drawn = mPrivateFlags & PFLAG_DRAWN;
  
          int oldWidth = mRight - mLeft;
          int oldHeight = mBottom - mTop;
          int newWidth = right - left;
          int newHeight = bottom - top;
          boolean sizeChanged = (newWidth != oldWidth) || (newHeight != oldHeight);
  
          // Invalidate our old position
          invalidate(sizeChanged);
  
          mLeft = left;
          mTop = top;
          mRight = right;
          mBottom = bottom;
          mRenderNode.setLeftTopRightBottom(mLeft, mTop, mRight, mBottom);
  
          ···
      }
      return changed;
  }
  

  从上面的代码可以看到，setOpticalFrame() 方法实际上还是调用了 setFrame() 方法，setFrame() 方法实际就是根据传入的位置参数确定View实际的位置，如果View的位置大小发生变化，就会调用invalidate() 方法，从而让系统重绘这个View。

• 对于ViewGroup，因为它是继承自View类的，因此它的 layout() 方法与 View 相似，而 onLayout() 的具体实现和具体布局有关，因此View和ViewGroup均没有具体实现onLayout() 方法，所以我们需要结合一个具体的ViewGroup来分析其 onLayout() 过程。这里以LinearLayout 为例，来看 LinearLayout的 onLayout() 方法：

  /**
   * onLayout() 方法分两种情况（就是 orientation 属性指定的 vertical 或 horizontal）
   * 分为水平布局和垂直布局（下面只看垂直布局）
   */
  @Override
  protected void onLayout(boolean changed, int l, int t, int r, int b) {
      if (mOrientation == VERTICAL) {
          layoutVertical(l, t, r, b);
      } else {
          layoutHorizontal(l, t, r, b);
      }
  }
  
  /**
   * onLayout() 在垂直布局情况下的实现
   */
  void layoutVertical(int left, int top, int right, int bottom) {
      final int paddingLeft = mPaddingLeft;
  
      int childTop;
      int childLeft;
  
      // Where right end of child should go
      final int width = right - left;
      int childRight = width - mPaddingRight;
  
      // Space available for child
      int childSpace = width - paddingLeft - mPaddingRight;
  
      // 子View数量
      final int count = getVirtualChildCount();
  
      final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
      final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
  
      // 根据指定的停靠位置（gravity属性）来决定 子View 在竖直方向上的布局起始位置
      switch (majorGravity) {
         case Gravity.BOTTOM:
             // mTotalLength contains the padding already
             childTop = mPaddingTop + bottom - top - mTotalLength;
             break;
  
             // mTotalLength contains the padding already
         case Gravity.CENTER_VERTICAL:
             childTop = mPaddingTop + (bottom - top - mTotalLength) / 2;
             break;
  
         case Gravity.TOP:
         default:
             childTop = mPaddingTop;
             break;
      }
  
      // 依次遍历子Viwe
      for (int i = 0; i < count; i++) {
          final View child = getVirtualChildAt(i);
          if (child == null) {
              childTop += measureNullChild(i);
          } else if (child.getVisibility() != GONE) {
              final int childWidth = child.getMeasuredWidth();
              final int childHeight = child.getMeasuredHeight();
  
              final LinearLayout.LayoutParams lp =
                      (LinearLayout.LayoutParams) child.getLayoutParams();
  
              int gravity = lp.gravity;
              if (gravity < 0) {
                  gravity = minorGravity;
              }
              final int layoutDirection = getLayoutDirection();
              final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
              switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
                  case Gravity.CENTER_HORIZONTAL:
                      childLeft = paddingLeft + ((childSpace - childWidth) / 2)
                              + lp.leftMargin - lp.rightMargin;
                      break;
  
                  case Gravity.RIGHT:
                      childLeft = childRight - childWidth - lp.rightMargin;
                      break;
  
                  case Gravity.LEFT:
                  default:
                      childLeft = paddingLeft + lp.leftMargin;
                      break;
              }
             
              if (hasDividerBeforeChildAt(i)) {
                  childTop += mDividerHeight;
              }
  
              childTop += lp.topMargin;
              // 确定子View的位置
              setChildFrame(child, childLeft, childTop + getLocationOffset(child),
                      childWidth, childHeight);
              childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);
               // 将当前View的高度（包括divider、padding、margin）累加到chileTop中，下一个View从这个位置开始
              i += getChildrenSkipCount(child, i);
          }
      }
  }
  
  /**
   * 将 layout 过程传递到子View
   */
  private void setChildFrame(View child, int left, int top, int width, int height) {
      child.layout(left, top, left + width, top + height);
  }
  

  逻辑其实很简单，就是依次从上往下排布子View，并且将layout过程传递到子View。这样自上而下就完成了整个View树的 layout 过程。

draw 过程

参考博客：自定义View Draw过程

• draw 也分 普通 View 的 draw过程 和 ViewGroup 的 draw 过程，只不过差别不是很大，先来看View类的 draw() 方法：

  public void draw(Canvas canvas) {
      final int privateFlags = mPrivateFlags;
      final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
              (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
      mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
  
      // Step 1, draw the background, if needed
      int saveCount;
  
      if (!dirtyOpaque) {
          drawBackground(canvas);
      }
  
      // skip step 2 & 5 if possible (common case)
      final int viewFlags = mViewFlags;
      boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
      boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
      if (!verticalEdges && !horizontalEdges) {
          // Step 3, draw the content
          if (!dirtyOpaque) onDraw(canvas);
  
          // Step 4, draw the children
          dispatchDraw(canvas);
  
          ···
  
          // Step 6, draw decorations (foreground, scrollbars)
          onDrawForeground(canvas);
  
          // Step 7, draw the default focus highlight
          drawDefaultFocusHighlight(canvas);
  
          if (debugDraw()) {
              debugDrawFocus(canvas);
          }
  
          // we're done...
          return;
      }
      ···
  }
  

  根据代码逻辑可以看到，View 的 draw 过程主要分为4步：

  1. step1 drawBackground() —— 绘制背景；
  2. step3 onDraw() —— 绘制View自身；
  3. step4 dispatchDraw() —— 绘制子View
  4. step6、step7 —— 绘制装饰
     （step2和step5 是涉及到优化的内容，这里先不管）

  对于普通View而言，显然是没有子View需要绘制的，因此对于普通View，dispatchDraw()方法是一个空实现；对于ViewGroup，则必须实现dispatchDraw() 方法。
  我们先来看 drawBackground()、onDraw()、onDrawForeground()这三个方法的实现：

  /**
   *  如果给View指定了背景，就会 调用了个方法来绘制背景
   */
  private void drawBackground(Canvas canvas) {
      final Drawable background = mBackground;
      if (background == null) {
          return;
      }
      // 根据 layout 过程获得的位置参数，来确定绘制背景的边界
      setBackgroundBounds();
  
      ···
  
      final int scrollX = mScrollX;
      final int scrollY = mScrollY;
      if ((scrollX | scrollY) == 0) {
          background.draw(canvas);
      } else {
          // 若 scrollX 和 scrollY有值，则对画布（canvas）的坐标进行偏移（有没有联想到scrollTo和ScrollBy方法）
          canvas.translate(scrollX, scrollY);
          background.draw(canvas);
          canvas.translate(-scrollX, -scrollY);
      }
  }
  
  /**
   * 自定义View时 必须 且 只需 实现这个方法，来绘制View
   */
  protected void onDraw(Canvas canvas) {
  // View 类没有实现，需要根据View自身的情况重写这个方法
  }
  
  /**
   * 绘制装饰，如滚动条、点击效果（最常见的如水波纹点击效果）
   */
  public void onDrawForeground(Canvas canvas) {
      onDrawScrollIndicators(canvas);
      onDrawScrollBars(canvas);
  
      final Drawable foreground = mForegroundInfo != null ? mForegroundInfo.mDrawable : null;
      if (foreground != null) {
          if (mForegroundInfo.mBoundsChanged) {
              mForegroundInfo.mBoundsChanged = false;
              final Rect selfBounds = mForegroundInfo.mSelfBounds;
              final Rect overlayBounds = mForegroundInfo.mOverlayBounds;
  
              if (mForegroundInfo.mInsidePadding) {
                  selfBounds.set(0, 0, getWidth(), getHeight());
              } else {
                  selfBounds.set(getPaddingLeft(), getPaddingTop(),
                          getWidth() - getPaddingRight(), getHeight() - getPaddingBottom());
              }
  
              final int ld = getLayoutDirection();
              Gravity.apply(mForegroundInfo.mGravity, foreground.getIntrinsicWidth(),
                      foreground.getIntrinsicHeight(), selfBounds, overlayBounds, ld);
              foreground.setBounds(overlayBounds);
          }
  
          foreground.draw(canvas);
      }
  }
  

  上面这三个方法在ViewGroup类中均没有重写，说明无论是普通View亦或是ViewGroup，都是一样实现这三个过程的，所以，我们只需要看ViewGroup类的 dispatchDraw() 方法：

  @Override
  protected void dispatchDraw(Canvas canvas) {
      ···
      final int childrenCount = mChildrenCount;
      ···
      for (int i = 0; i < childrenCount; i++) {
          while (transientIndex >= 0 && mTransientIndices.get(transientIndex) == i) {
              final View transientChild = mTransientViews.get(transientIndex);
              if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
                      transientChild.getAnimation() != null) {
                  more |= drawChild(canvas, transientChild, drawingTime);
              }
              ···
          }
  
          ···
      }
      ···
  }
  

  这里只给出了遍历子View的部分，其他的内容在这里不需要关心。其实就是遍历每一个子View，然后调用 drawChild() 方法：

  protected boolean drawChild(Canvas canvas, View child, long drawingTime) {
      return child.draw(canvas, this, drawingTime);
  }
  

  这个方法就是调用 子View 的draw方法，将draw过程传递给子View，依次递归。

  这里还有一个细节问题需要注意：View类有一个 setWillNotDraw() 方法

  public void setWillNotDraw(boolean willNotDraw) {
      setFlags(willNotDraw ? WILL_NOT_DRAW : 0, DRAW_MASK);
  }
  

  这个方法涉及到一个标记位 WILL_NOT_DRAW，设置这个标记位为 true 以后，表示当前View不需要绘制任何内容，系统会进行相应优化。

  1. 默认情况下，View没有启用这个标记位（false），而ViewGroup启用了（true）；
  2. 当我们自定义控件继承 ViewGroup 类时，如果需要通过 onDraw() 方法绘制内容，就需要显式关闭这个标记位。

---

上一篇：Android学习笔记（五）| View的工作原理（上）
下一篇：Android学习笔记（七）| Android动画（上）—— View动画