performDraw

1. 初始化app后DecorView调用performTraversals()，执行完measure和layout后知道了view的ltrb（左上右下）坐标信息，下一步就是执行performDraw进行绘制了
2. performDraw中经过层层调用，最终构造了canvas，并调用mView.draw（canvas）
3. view的draw分了六步
       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)
   1. 画背景
      1. setBackgroundBounds中根据layout获得的ltrb参数设置绘制区域
   2. 保存canvas的layer信息
   3. 画view内容
      1. 空函数，需要具体类去实现
   4. 遍历画子view dispatchDraw(canvas);
      
      1. 没有子view不需要处理
      2. 看一下viewGroup中的处理
         

         protected void dispatchDraw(Canvas canvas) {
             boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);
             final int childrenCount = mChildrenCount;
             final View[] children = mChildren;
             int flags = mGroupFlags;
         
             if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {
                 final boolean buildCache = !isHardwareAccelerated();
                 for (int i = 0; i < childrenCount; i++) {
                     final View child = children[i];
                     if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
                         final LayoutParams params = child.getLayoutParams();
                         attachLayoutAnimationParameters(child, params, i, childrenCount);
                         bindLayoutAnimation(child);
                     }
                 }
         
                 final LayoutAnimationController controller = mLayoutAnimationController;
                 if (controller.willOverlap()) {
                     mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;
                 }
         
                 controller.start();
         
                 mGroupFlags &= ~FLAG_RUN_ANIMATION;
                 mGroupFlags &= ~FLAG_ANIMATION_DONE;
         
                 if (mAnimationListener != null) {
                     mAnimationListener.onAnimationStart(controller.getAnimation());
                 }
             }
         
             int clipSaveCount = 0;
             final boolean clipToPadding = (flags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK;
             if (clipToPadding) {
                 clipSaveCount = canvas.save();
                 canvas.clipRect(mScrollX + mPaddingLeft, mScrollY + mPaddingTop,
                         mScrollX + mRight - mLeft - mPaddingRight,
                         mScrollY + mBottom - mTop - mPaddingBottom);
             }
         
             // We will draw our child's animation, let's reset the flag
             mPrivateFlags &= ~PFLAG_DRAW_ANIMATION;
             mGroupFlags &= ~FLAG_INVALIDATE_REQUIRED;
         
             boolean more = false;
             final long drawingTime = getDrawingTime();
         
             if (usingRenderNodeProperties) canvas.insertReorderBarrier();
             final int transientCount = mTransientIndices == null ? 0 : mTransientIndices.size();
             int transientIndex = transientCount != 0 ? 0 : -1;
             // Only use the preordered list if not HW accelerated, since the HW pipeline will do the
             // draw reordering internally
             final ArrayList<View> preorderedList = usingRenderNodeProperties
                     ? null : buildOrderedChildList();
             final boolean customOrder = preorderedList == null
                     && isChildrenDrawingOrderEnabled();
             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;
                     }
                 }
         
                 final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
                 final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);
                 if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
                     more |= drawChild(canvas, child, drawingTime);
                 }
             }
             while (transientIndex >= 0) {
                 // there may be additional transient views after the normal views
                 final View transientChild = mTransientViews.get(transientIndex);
                 if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
                         transientChild.getAnimation() != null) {
                     more |= drawChild(canvas, transientChild, drawingTime);
                 }
                 transientIndex++;
                 if (transientIndex >= transientCount) {
                     break;
                 }
             }
             if (preorderedList != null) preorderedList.clear();
         
             // Draw any disappearing views that have animations
             if (mDisappearingChildren != null) {
                 final ArrayList<View> disappearingChildren = mDisappearingChildren;
                 final int disappearingCount = disappearingChildren.size() - 1;
                 // Go backwards -- we may delete as animations finish
                 for (int i = disappearingCount; i >= 0; i--) {
                     final View child = disappearingChildren.get(i);
                     more |= drawChild(canvas, child, drawingTime);
                 }
             }
             if (usingRenderNodeProperties) canvas.insertInorderBarrier();
         
             if (debugDraw()) {
                 onDebugDraw(canvas);
             }
         
             if (clipToPadding) {
                 canvas.restoreToCount(clipSaveCount);
             }
         
             // mGroupFlags might have been updated by drawChild()
             flags = mGroupFlags;
         
             if ((flags & FLAG_INVALIDATE_REQUIRED) == FLAG_INVALIDATE_REQUIRED) {
                 invalidate(true);
             }
         
             if ((flags & FLAG_ANIMATION_DONE) == 0 && (flags & FLAG_NOTIFY_ANIMATION_LISTENER) == 0 &&
                     mLayoutAnimationController.isDone() && !more) {
                 // We want to erase the drawing cache and notify the listener after the
                 // next frame is drawn because one extra invalidate() is caused by
                 // drawChild() after the animation is over
                 mGroupFlags |= FLAG_NOTIFY_ANIMATION_LISTENER;
                 final Runnable end = new Runnable() {
                    @Override
                    public void run() {
                        notifyAnimationListener();
                    }
                 };
                 post(end);
             }
         }

         
         
         
      3. 遍历子view执行 drawChild(canvas, transientChild, drawingTime)，drawChild里面执行了child.draw
   5. 画渐变的效果，并保存layrers
   6. 画scrollbars和foreground