private void performDraw() {
 //...
 final boolean fullRedrawNeeded = mFullRedrawNeeded;
 try {
  draw(fullRedrawNeeded);
 } finally {
  mIsDrawing = false;
  Trace.traceEnd(Trace.TRACE_TAG_VIEW);
 }

 //省略...
}

private void draw(boolean fullRedrawNeeded) {
 ...
 //獲取mDirty，該值表示需要重繪的區(qū)域
 final Rect dirty = mDirty;
 if (mSurfaceHolder != null) {
  // The app owns the surface, we won't draw.
  dirty.setEmpty();
  if (animating) {
   if (mScroller != null) {
    mScroller.abortAnimation();
   }
   disposeResizeBuffer();
  }
  return;
 }

 //如果fullRedrawNeeded為真，則把dirty區(qū)域置為整個屏幕，表示整個視圖都需要繪制
 //第一次繪制流程，需要繪制所有視圖
 if (fullRedrawNeeded) {
  mAttachInfo.mIgnoreDirtyState = true;
  dirty.set(0, 0, (int) (mWidth * appScale + 0.5f), (int) (mHeight * appScale + 0.5f));
 }

 //省略...

 if (!drawSoftware(surface, mAttachInfo, xOffset, yOffset, scalingRequired, dirty)) {
    return;
  }
}

private boolean drawSoftware(Surface surface, AttachInfo attachInfo, int xoff, int yoff,
   boolean scalingRequired, Rect dirty) {

 // Draw with software renderer.
 final Canvas canvas;
 try {
  final int left = dirty.left;
  final int top = dirty.top;
  final int right = dirty.right;
  final int bottom = dirty.bottom;

  //鎖定canvas區(qū)域，由dirty區(qū)域決定
  canvas = mSurface.lockCanvas(dirty);

  // The dirty rectangle can be modified by Surface.lockCanvas()
  //noinspection ConstantConditions
  if (left != dirty.left || top != dirty.top || right != dirty.right
    || bottom != dirty.bottom) {
   attachInfo.mIgnoreDirtyState = true;
  }

  canvas.setDensity(mDensity);
 }

 try {

  if (!canvas.isOpaque() || yoff != 0 || xoff != 0) {
   canvas.drawColor(0, PorterDuff.Mode.CLEAR);
  }

  dirty.setEmpty();
  mIsAnimating = false;
  attachInfo.mDrawingTime = SystemClock.uptimeMillis();
  mView.mPrivateFlags |= View.PFLAG_DRAWN;

  try {
   canvas.translate(-xoff, -yoff);
   if (mTranslator != null) {
    mTranslator.translateCanvas(canvas);
   }
   canvas.setScreenDensity(scalingRequired ? mNoncompatDensity : 0);
   attachInfo.mSetIgnoreDirtyState = false;

   //正式開始繪制
   mView.draw(canvas);

  }
 } 
 return true;
}

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;

 /*
  * Draw traversal performs several drawing steps which must be executed
  * in the appropriate order:
  *
  *  1. Draw the background
  *  2. If necessary, save the canvas' layers to prepare for fading
  *  3. Draw view's content
  *  4. Draw children
  *  5. If necessary, draw the fading edges and restore layers
  *  6. Draw decorations (scrollbars for instance)
  */

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

  // Overlay is part of the content and draws beneath Foreground
  if (mOverlay != null && !mOverlay.isEmpty()) {
   mOverlay.getOverlayView().dispatchDraw(canvas);
  }

  // Step 6, draw decorations (foreground, scrollbars)
  onDrawForeground(canvas);

  // we're done...
  return;
 }
 ...
}

private void drawBackground(Canvas canvas) {

 //mBackground是該View的背景參數(shù)，比如背景顏色
 final Drawable background = mBackground;
 if (background == null) {
  return;
 }

 //根據(jù)View四個布局參數(shù)來確定背景的邊界
 setBackgroundBounds();

 ...

 //獲取當前View的mScrollX和mScrollY值
 final int scrollX = mScrollX;
 final int scrollY = mScrollY;
 if ((scrollX | scrollY) == 0) {
  background.draw(canvas);
 } else {
  //如果scrollX和scrollY有值，則對canvas的坐標進行偏移，再繪制背景
  canvas.translate(scrollX, scrollY);
  background.draw(canvas);
  canvas.translate(-scrollX, -scrollY);
 }
}

protected void dispatchDraw(Canvas canvas) {
 boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);
 final int childrenCount = mChildrenCount;
 final View[] children = mChildren;
 int flags = mGroupFlags;

 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);
   }
   transientIndex++;
   if (transientIndex >= transientCount) {
    transientIndex = -1;
   }
  }
  int childIndex = customOrder ? getChildDrawingOrder(childrenCount, i) : i;
  final View child = (preorderedList == null)
    ? children[childIndex] : preorderedList.get(childIndex);
  if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
   more |= drawChild(canvas, child, drawingTime);
  }
 }
 //省略...

}

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

boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {

 //省略...

 if (!drawingWithDrawingCache) {
  if (drawingWithRenderNode) {
   mPrivateFlags &= ~PFLAG_DIRTY_MASK;
   ((DisplayListCanvas) canvas).drawRenderNode(renderNode);
  } else {
   // Fast path for layouts with no backgrounds
   if ((mPrivateFlags & PFLAG_SKIP_DRAW) == PFLAG_SKIP_DRAW) {
    mPrivateFlags &= ~PFLAG_DIRTY_MASK;
    dispatchDraw(canvas);
   } else {
    draw(canvas);
   }
  }
 } else if (cache != null) {
  mPrivateFlags &= ~PFLAG_DIRTY_MASK;
  if (layerType == LAYER_TYPE_NONE) {
   // no layer paint, use temporary paint to draw bitmap
   Paint cachePaint = parent.mCachePaint;
   if (cachePaint == null) {
    cachePaint = new Paint();
    cachePaint.setDither(false);
    parent.mCachePaint = cachePaint;
   }
   cachePaint.setAlpha((int) (alpha * 255));
   canvas.drawBitmap(cache, 0.0f, 0.0f, cachePaint);
  } else {
   // use layer paint to draw the bitmap, merging the two alphas, but also restore
   int layerPaintAlpha = mLayerPaint.getAlpha();
   mLayerPaint.setAlpha((int) (alpha * layerPaintAlpha));
   canvas.drawBitmap(cache, 0.0f, 0.0f, mLayerPaint);
   mLayerPaint.setAlpha(layerPaintAlpha);
  }
 }

}

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