這是我在學習android 自定義UI控件時的一些瓶頸，現(xiàn)在琳瑯滿目的各種UI控件，其實讓很多開發(fā)者感覺很便利。但要寫出不同的高效控件和復雜動畫，抄抄寫寫是不行的，須先理解android View 的繪制過程。

1.View的遍歷過程

整個View樹的繪圖流程是在ViewRoot.java類的performTraversals()函數(shù)展開的，該函數(shù)做的執(zhí)行過程可簡單概況為

根據(jù)之前設置的狀態(tài)，判斷是否需要重新計算視圖大小(measure)、是否重新需要安置視圖的位置(layout)、以及是否需要重繪

(draw)，其框架過程如下：

Paste_Image.png

performTraversals函數(shù)，具體的可以參考一下源代碼：

private void performTraversals() {  
    final View host = mView;  
    ...  
    host.measure(childWidthMeasureSpec, childHeightMeasureSpec);  
    ...  
    host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());  
    ...  
    draw(fullRedrawNeeded);  

可以看出View的主要繪制經(jīng)歷三個過程：Measure、Layout、Draw。

1.mesarue()過程

為整個View樹計算實際的大小，即設置實際的高(對應屬性:mMeasuredHeight)和寬(對應屬性:
mMeasureWidth)，每個View的控件的實際寬高都是由父視圖和本身視圖決定的。
具體的調(diào)用鏈如下：
ViewRoot根對象地屬性mView(其類型一般為ViewGroup類型)調(diào)用measure()方法去計算View樹的大小，回調(diào)View/ViewGroup對象的onMeasure()方法，該方法實現(xiàn)的功能如下：
1、設置本View視圖的最終大小，該功能的實現(xiàn)通過調(diào)用setMeasuredDimension()方法去設置實際的高(對應屬性：
mMeasuredHeight)和寬(對應屬性：mMeasureWidth);
2 、如果該View對象是個ViewGroup類型，需要重寫該onMeasure()方法，對其子視圖進行遍歷的measure()過程;
3、 對每個子視圖的measure()過程，是通過調(diào)用父類ViewGroup.java類里的measureChildWithMargins()方法去實現(xiàn)，該方法內(nèi)部只是簡單地調(diào)用了View對象的measure()方法。(由于measureChildWithMargins()方法只是一個過渡層更簡單的做法是直接調(diào)用View對象的measure()方法)。整個measure調(diào)用流程就是個樹形的遞歸過程

** measure函數(shù)原型為 View.java 該函數(shù)不能被重載**
來看代碼，主要方法有：

public final void measure(int widthMeasureSpec, int heightMeasureSpec)  
protected final void setMeasuredDimension(int measuredWidth, int measuredHeight)  
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)  

measure調(diào)用onMeasure，onMeasure調(diào)用setMeasureDimension，measure，setMeasureDimension是final類型，view的子類不需要重寫，onMeasure在view的子類中重寫。

measure函數(shù):

public final void measure(int widthMeasureSpec, int heightMeasureSpec) {  
    if ((mPrivateFlags & FORCE_LAYOUT) == FORCE_LAYOUT ||  
            widthMeasureSpec != mOldWidthMeasureSpec ||  
            heightMeasureSpec != mOldHeightMeasureSpec) {  
  
        // first clears the measured dimension flag  
        mPrivateFlags &= ~MEASURED_DIMENSION_SET;  
  
        if (ViewDebug.TRACE_HIERARCHY) {  
            ViewDebug.trace(this, ViewDebug.HierarchyTraceType.ON_MEASURE);  
        }  
  
        // measure ourselves, this should set the measured dimension flag back  
        onMeasure(widthMeasureSpec, heightMeasureSpec);  
  
        // flag not set, setMeasuredDimension() was not invoked, we raise  
        // an exception to warn the developer  
        if ((mPrivateFlags & MEASURED_DIMENSION_SET) != MEASURED_DIMENSION_SET) {  
            throw new IllegalStateException("onMeasure() did not set the"  
                    + " measured dimension by calling"  
                    + " setMeasuredDimension()");  
        }  
  
        mPrivateFlags |= LAYOUT_REQUIRED;  
    }  
  
    mOldWidthMeasureSpec = widthMeasureSpec;  
    mOldHeightMeasureSpec = heightMeasureSpec;  
}  

onMeasure函數(shù)：

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

重寫onMeasure時，要調(diào)用setMeasuredDimension或者super.onMeasure來設置自身的mMeasuredWidth和mMeasuredHeight，否則，就會拋出異常.
setMeasuredDimension函數(shù)，用來設置view的大?。?/p>

protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {  
    mMeasuredWidth = measuredWidth;  
    mMeasuredHeight = measuredHeight;  
  
    mPrivateFlags |= MEASURED_DIMENSION_SET;  
}  

再看一下onMeasure的

getDefaultSize函數(shù)：

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類：

public static class MeasureSpec {  
  
    private static final int MODE_SHIFT = 30;  
    private static final int MODE_MASK  = 0x3 << MODE_SHIFT;  
    public static final int UNSPECIFIED = 0 << MODE_SHIFT;  
    public static final int EXACTLY     = 1 << MODE_SHIFT;  
    public static final int AT_MOST     = 2 << MODE_SHIFT;  
  
    public static int makeMeasureSpec(int size, int mode) {  
        return size + mode;  
    }  
  
    public static int getMode(int measureSpec) {  
        return (measureSpec & MODE_MASK);  
    }  
  
    public static int getSize(int measureSpec) {  
        return (measureSpec & ~MODE_MASK);  
    }  
}  

MODE_MASK為30為長度的二進制數(shù)，前兩位標示Mode，后面的標示Size。MeasureSpec有三種模式分別是UNSPECIFIED, EXACTLY和AT_MOST。
EXACTLY表示父視圖希望子視圖的大小應該是由specSize的值來決定的，系統(tǒng)默認會按照這個規(guī)則來設置子視圖的大小，開發(fā)人員當然也可以按照自己的意愿設置成任意的大小。
AT_MOST表示子視圖最多只能是specSize中指定的大小，開發(fā)人員應該盡可能小得去設置這個視圖，并且保證不會超過specSize。系統(tǒng)默認會按照這個規(guī)則來設置子視圖的大小，開發(fā)人員當然也可以按照自己的意愿設置成任意的大小。
UNSPECIFIED表示開發(fā)人員可以將視圖按照自己的意愿設置成任意的大小，沒有任何限制。這種情況比較少見，不太會用到。
widthMeasureSpec和heightMeasureSpec決定了Mode和Size的值，widthMeasureSpec和heightMeasureSpec來自父視圖，這兩個值都是由父視圖經(jīng)過計算后傳遞給子視圖的，說明父視圖會在一定程度上決定子視圖的大小。但是最外層的根視圖，它的widthMeasureSpec和heightMeasureSpec又是從哪里得到的呢？這就需要去分析ViewRoot中的源碼了，觀察performTraversals()方法可以發(fā)現(xiàn)如下代碼：

childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);  
childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height); 

可以看到，這里調(diào)用了getRootMeasureSpec()方法去獲取widthMeasureSpec和heightMeasureSpec的值，注意方法中傳入的參數(shù)，其中l(wèi)p.width和lp.height在創(chuàng)建ViewGroup實例的時候就被賦值了，它們都等于MATCH_PARENT。然后看下getRootMeasureSpec()方法中的代碼，如下所示：

private int getRootMeasureSpec(int windowSize, int rootDimension) {  
    int measureSpec;  
    switch (rootDimension) {  
    case ViewGroup.LayoutParams.MATCH_PARENT:  
        measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);  
        break;  
    case ViewGroup.LayoutParams.WRAP_CONTENT:  
        measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);  
        break;  
    default:  
        measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);  
        break;  
    }  
    return measureSpec;  
}  

可以看到，這里使用了MeasureSpec.makeMeasureSpec()方法來組裝一個MeasureSpec，當rootDimension參數(shù)等于MATCH_PARENT的時候，MeasureSpec的specMode就等于EXACTLY，當rootDimension等于WRAP_CONTENT的時候，MeasureSpec的specMode就等于AT_MOST。并且MATCH_PARENT和WRAP_CONTENT時的specSize都是等于windowSize的，也就意味著根視圖總是會充滿全屏的。

Measure是一個復雜的過程，因為一個布局中一般都會包含多個子視圖，每個視圖都需要經(jīng)歷一次measure過程。ViewGroup中定義了一個measureChildren()方法來去測量子視圖的大小，如下所示：

measureChildren函數(shù):

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

這里會去遍歷當前布局下的所有子視圖，然后逐個調(diào)用measureChild()方法來測量相應子視圖的大?。?/p>

measureChild函數(shù)：

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

從這里我們可以看到視圖的大小是由父視圖和子視圖共同決定的。子布局里面的Android:layout_width和android:layout_height只是期望值，父View大小最終是由DecorView決定。父視圖提供尺寸大小的一個能力，子視圖最終尺寸與父視圖能力、子視圖期望的關系如下：

關于視圖的measure過程可以閱讀以下LinearLayout源碼，這樣可以更清楚的了解過程。

2.Layout過程

measure過程確定視圖的大小，而layout過程確定視圖的位置。
主要作用 ：為將整個根據(jù)子視圖的大小以及布局參數(shù)將View樹放到合適的位置上。具體的調(diào)用是：host.layout()開始View樹的布局，繼而回調(diào)給View/ViewGroup類中的layout()方法。
具體流程如下:
1 、layout方法會設置該View視圖位于父視圖的坐標軸，即mLeft，mTop，mLeft，mBottom(調(diào)用setFrame()函數(shù)去實現(xiàn))。接下來回調(diào)onLayout()方法(如果該View是ViewGroup對象，需要實現(xiàn)該方法，對每個子視圖進行布局) ；
2、如果該View是個ViewGroup類型，需要遍歷每個子視圖chiildView，調(diào)用該子視圖的layout()方法去設置它的坐標值。

public void layout(int l, int t, int r, int b) {  
       int oldL = mLeft;  
       int oldT = mTop;  
       int oldB = mBottom;  
       int oldR = mRight;  
       boolean changed = setFrame(l, t, r, b);  
       if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {  
           onLayout(changed, l, t, r, b);  
           mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;  
  
           ListenerInfo li = mListenerInfo;  
           if (li != null && li.mOnLayoutChangeListeners != null) {  
               ArrayList<OnLayoutChangeListener> listenersCopy =  
                       (ArrayList<OnLayoutChangeListener>)li.mOnLayoutChangeListeners.clone();  
               int numListeners = listenersCopy.size();  
               for (int i = 0; i < numListeners; ++i) {  
                   listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB);  
               }  
           }  
       }  
       mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;  
   }  

函數(shù)中參數(shù)l、t、r、b是指view的左、上、右、底的位置，這幾個參數(shù)是父視圖傳入的，而根視圖中參數(shù)是由performTraversals()方法傳入的。

host.layout(0, 0, host.mMeasuredWidth, host.mMeasuredHeight);  

我們關注一下LinearLayout：

@Override  
  protected void onLayout(boolean changed, int l, int t, int r, int b) {  
      if (mOrientation == VERTICAL) {  
          layoutVertical();  
      } else {  
          layoutHorizontal();  
      }  
  }  

void layoutVertical() {  
      final int paddingLeft = mPaddingLeft;  
  
      int childTop;  
      int childLeft;  
        
      // Where right end of child should go  
      final int width = mRight - mLeft;  
      int childRight = width - mPaddingRight;  
        
      // Space available for child  
      int childSpace = width - paddingLeft - mPaddingRight;  
        
      final int count = getVirtualChildCount();  
  
      final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;  
      final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;  
  
      switch (majorGravity) {  
         case Gravity.BOTTOM:  
             // mTotalLength contains the padding already  
             childTop = mPaddingTop + mBottom - mTop - mTotalLength;  
             break;  
  
             // mTotalLength contains the padding already  
         case Gravity.CENTER_VERTICAL:  
             childTop = mPaddingTop + (mBottom - mTop - mTotalLength) / 2;  
             break;  
  
         case Gravity.TOP:  
         default:  
             childTop = mPaddingTop;  
             break;  
      }  
  
      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;  
              setChildFrame(child, childLeft, childTop + getLocationOffset(child),  
                      childWidth, childHeight);  
              childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);  
  
              i += getChildrenSkipCount(child, i);  
          }  
      }  
  }  

layout設置了view的位置，還設置了子視圖位置，layoutHorizontal()方法中調(diào)用了setChildFrame方法：

layoutHorizontal函數(shù):

private void setChildFrame(View child, int left, int top, int width, int height) {          
    child.layout(left, top, left + width, top + height);  
} 

從上面看出，layout也是一個自上而下的過程，先設置父視圖位置，在循環(huán)子視圖，父視圖位置一定程度上決定了子視圖位置。

3.Draw()過程

draw過程調(diào)用順序在measure()和layout()之后，同樣的，performTraversals()發(fā)起的draw過程最終會調(diào)用到mView的draw()函數(shù)，值得注意的是每次發(fā)起繪圖時，并不會重新繪制每個View樹的視圖，而只會重新繪制那些“需要重繪”的視圖，View類內(nèi)部變量包含了一個標志位DRAWN，當該視圖需要重繪時，就會為該View添加該標志位。

調(diào)用流程 ：
mView.draw()開始繪制，draw()方法實現(xiàn)的功能如下：
1 、繪制該View的背景；
2 、為顯示漸變框做一些準備操作(見5，大多數(shù)情況下，不需要改漸變框);
3、調(diào)用onDraw()方法繪制視圖本身 (每個View都需要重載該方法，ViewGroup不需要實現(xiàn)該方法);
4、調(diào)用dispatchDraw ()方法繪制子視圖(如果該View類型不為ViewGroup，即不包含子視圖，不需要重載該方法)值得說明的是，ViewGroup類已經(jīng)為我們重寫了dispatchDraw ()的功能實現(xiàn)，應用程序一般不需要重寫該方法，但可以重載父類函數(shù)實現(xiàn)具體的功能;
5、 dispatchDraw()方法內(nèi)部會遍歷每個子視圖，調(diào)用drawChild()去重新回調(diào)每個子視圖的draw()方法(注意，這個 地方“需要重繪”的視圖才會調(diào)用draw()方法)。值得說明的是，ViewGroup類已經(jīng)為我們重寫了dispatchDraw()的功能；
實現(xiàn)，應用程序一般不需要重寫該方法，但可以重載父類函數(shù)實現(xiàn)具體的功能。
6、繪制滾動條;

于是，整個調(diào)用鏈就這樣遞歸下去了?？匆幌聉iew類的draw方法。

draw函數(shù)：

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) {  
           final Drawable background = mBackground;  
           if (background != null) {  
               final int scrollX = mScrollX;  
               final int scrollY = mScrollY;  
  
               if (mBackgroundSizeChanged) {  
                   background.setBounds(0, 0,  mRight - mLeft, mBottom - mTop);  
                   mBackgroundSizeChanged = false;  
               }  
  
               if ((scrollX | scrollY) == 0) {  
                   background.draw(canvas);  
               } else {  
                   canvas.translate(scrollX, scrollY);  
                   background.draw(canvas);  
                   canvas.translate(-scrollX, -scrollY);  
               }  
           }  
       }  
  
       // 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 (scrollbars)  
           onDrawScrollBars(canvas);  
  
           // we're done...  
           return;  
       }  
  
       /* 
        * Here we do the full fledged routine... 
        * (this is an uncommon case where speed matters less, 
        * this is why we repeat some of the tests that have been 
        * done above) 
        */  
  
       boolean drawTop = false;  
       boolean drawBottom = false;  
       boolean drawLeft = false;  
       boolean drawRight = false;  
  
       float topFadeStrength = 0.0f;  
       float bottomFadeStrength = 0.0f;  
       float leftFadeStrength = 0.0f;  
       float rightFadeStrength = 0.0f;  
  
       // Step 2, save the canvas' layers  
       int paddingLeft = mPaddingLeft;  
  
       final boolean offsetRequired = isPaddingOffsetRequired();  
       if (offsetRequired) {  
           paddingLeft += getLeftPaddingOffset();  
       }  
  
       int left = mScrollX + paddingLeft;  
       int right = left + mRight - mLeft - mPaddingRight - paddingLeft;  
       int top = mScrollY + getFadeTop(offsetRequired);  
       int bottom = top + getFadeHeight(offsetRequired);  
  
       if (offsetRequired) {  
           right += getRightPaddingOffset();  
           bottom += getBottomPaddingOffset();  
       }  
  
       final ScrollabilityCache scrollabilityCache = mScrollCache;  
       final float fadeHeight = scrollabilityCache.fadingEdgeLength;  
       int length = (int) fadeHeight;  
  
       // clip the fade length if top and bottom fades overlap  
       // overlapping fades produce odd-looking artifacts  
       if (verticalEdges && (top + length > bottom - length)) {  
           length = (bottom - top) / 2;  
       }  
  
       // also clip horizontal fades if necessary  
       if (horizontalEdges && (left + length > right - length)) {  
           length = (right - left) / 2;  
       }  
  
       if (verticalEdges) {  
           topFadeStrength = Math.max(0.0f, Math.min(1.0f, getTopFadingEdgeStrength()));  
           drawTop = topFadeStrength * fadeHeight > 1.0f;  
           bottomFadeStrength = Math.max(0.0f, Math.min(1.0f, getBottomFadingEdgeStrength()));  
           drawBottom = bottomFadeStrength * fadeHeight > 1.0f;  
       }  
  
       if (horizontalEdges) {  
           leftFadeStrength = Math.max(0.0f, Math.min(1.0f, getLeftFadingEdgeStrength()));  
           drawLeft = leftFadeStrength * fadeHeight > 1.0f;  
           rightFadeStrength = Math.max(0.0f, Math.min(1.0f, getRightFadingEdgeStrength()));  
           drawRight = rightFadeStrength * fadeHeight > 1.0f;  
       }  
  
       saveCount = canvas.getSaveCount();  
  
       int solidColor = getSolidColor();  
       if (solidColor == 0) {  
           final int flags = Canvas.HAS_ALPHA_LAYER_SAVE_FLAG;  
  
           if (drawTop) {  
               canvas.saveLayer(left, top, right, top + length, null, flags);  
           }  
  
           if (drawBottom) {  
               canvas.saveLayer(left, bottom - length, right, bottom, null, flags);  
           }  
  
           if (drawLeft) {  
               canvas.saveLayer(left, top, left + length, bottom, null, flags);  
           }  
  
           if (drawRight) {  
               canvas.saveLayer(right - length, top, right, bottom, null, flags);  
           }  
       } else {  
           scrollabilityCache.setFadeColor(solidColor);  
       }  
  
       // Step 3, draw the content  
       if (!dirtyOpaque) onDraw(canvas);  
  
       // Step 4, draw the children  
       dispatchDraw(canvas);  
  
       // Step 5, draw the fade effect and restore layers  
       final Paint p = scrollabilityCache.paint;  
       final Matrix matrix = scrollabilityCache.matrix;  
       final Shader fade = scrollabilityCache.shader;  
  
       if (drawTop) {  
           matrix.setScale(1, fadeHeight * topFadeStrength);  
           matrix.postTranslate(left, top);  
           fade.setLocalMatrix(matrix);  
           canvas.drawRect(left, top, right, top + length, p);  
       }  
  
       if (drawBottom) {  
           matrix.setScale(1, fadeHeight * bottomFadeStrength);  
           matrix.postRotate(180);  
           matrix.postTranslate(left, bottom);  
           fade.setLocalMatrix(matrix);  
           canvas.drawRect(left, bottom - length, right, bottom, p);  
       }  
  
       if (drawLeft) {  
           matrix.setScale(1, fadeHeight * leftFadeStrength);  
           matrix.postRotate(-90);  
           matrix.postTranslate(left, top);  
           fade.setLocalMatrix(matrix);  
           canvas.drawRect(left, top, left + length, bottom, p);  
       }  
  
       if (drawRight) {  
           matrix.setScale(1, fadeHeight * rightFadeStrength);  
           matrix.postRotate(90);  
           matrix.postTranslate(right, top);  
           fade.setLocalMatrix(matrix);  
           canvas.drawRect(right - length, top, right, bottom, p);  
       }  
  
       canvas.restoreToCount(saveCount);  
  
       // Step 6, draw decorations (scrollbars)  
       onDrawScrollBars(canvas);  
   }  

draw方法分成了6個步驟：

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

可以看到，第三部, Draw view's content步驟調(diào)用了onDraw方法，子類中實現(xiàn)onDraw方法；第四步，Draw children步驟使用的dispatchDraw方法，這個方法在ViewGroup中有實現(xiàn)。
View或ViewGroup的子類不用再重載ViewGroup中該方法，因為它已經(jīng)有了默認而且標準的view系統(tǒng)流程。dispatchDraw()內(nèi)部for循環(huán)調(diào)用drawChild()分別繪制每一個子視圖，而drawChild()內(nèi)部又會調(diào)用draw（）函數(shù)完成子視圖的內(nèi)部繪制工作。

dispatchDraw函數(shù)：

/** 
    * {@inheritDoc} 
    */  
   @Override  
   protected void dispatchDraw(Canvas canvas) {  
       final int count = mChildrenCount;  
       final View[] children = mChildren;  
       int flags = mGroupFlags;  
  
       if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {  
           final boolean cache = (mGroupFlags & FLAG_ANIMATION_CACHE) == FLAG_ANIMATION_CACHE;  
  
           final boolean buildCache = !isHardwareAccelerated();  
           for (int i = 0; i < count; i++) {  
               final View child = children[i];  
               if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {  
                   final LayoutParams params = child.getLayoutParams();  
                   attachLayoutAnimationParameters(child, params, i, count);  
                   bindLayoutAnimation(child);  
                   if (cache) {  
                       child.setDrawingCacheEnabled(true);  
                       if (buildCache) {                          
                           child.buildDrawingCache(true);  
                       }  
                   }  
               }  
           }  
  
           final LayoutAnimationController controller = mLayoutAnimationController;  
           if (controller.willOverlap()) {  
               mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;  
           }  
  
           controller.start();  
  
           mGroupFlags &= ~FLAG_RUN_ANIMATION;  
           mGroupFlags &= ~FLAG_ANIMATION_DONE;  
  
           if (cache) {  
               mGroupFlags |= FLAG_CHILDREN_DRAWN_WITH_CACHE;  
           }  
  
           if (mAnimationListener != null) {  
               mAnimationListener.onAnimationStart(controller.getAnimation());  
           }  
       }  
  
       int saveCount = 0;  
       final boolean clipToPadding = (flags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK;  
       if (clipToPadding) {  
           saveCount = 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 ((flags & FLAG_USE_CHILD_DRAWING_ORDER) == 0) {  
           for (int i = 0; i < count; i++) {  
               final View child = children[i];  
               if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {  
                   more |= drawChild(canvas, child, drawingTime);  
               }  
           }  
       } else {  
           for (int i = 0; i < count; i++) {  
               final View child = children[getChildDrawingOrder(count, i)];  
               if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {  
                   more |= drawChild(canvas, child, drawingTime);  
               }  
           }  
       }  
  
       // 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 (debugDraw()) {  
           onDebugDraw(canvas);  
       }  
  
       if (clipToPadding) {  
           canvas.restoreToCount(saveCount);  
       }  
  
       // 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() {  
              public void run() {  
                  notifyAnimationListener();  
              }  
           };  
           post(end);  
       }  
   }  

最后說說那些“需要重繪”的視圖
請求重繪View樹，即draw()過程，假如視圖發(fā)生大小沒有變化就不會調(diào)用layout()過程，并且只繪制那些“需要重繪的”
視圖，即誰(View的話，只繪制該View ；ViewGroup，則繪制整個ViewGroup)請求invalidate()方法，就繪制該視圖。

一般引起invalidate()操作的函數(shù)如下：
1、直接調(diào)用invalidate()方法，請求重新draw()，但只會繪制調(diào)用者本身。
2、setSelection()方法 ：請求重新draw()，但只會繪制調(diào)用者本身。
3、setVisibility()方法 ： 當View可視狀態(tài)在INVISIBLE轉(zhuǎn)換VISIBLE時，會間接調(diào)用invalidate()方法，繼而繪制該View。
4 、setEnabled()方法 ： 請求重新draw()，但不會重新繪制任何視圖包括該調(diào)用者本身。** requestLayout()方法** ：會導致調(diào)用measure()過程 和 layout()過程 ,只是對View樹重新布局layout過程包括measure()和layout()過程，不會調(diào)用draw()過程，但不會重新繪制
任何視圖包括該調(diào)用者本身。
一般引起invalidate()操作的函數(shù)如下：
1、setVisibility()方法：
當View的可視狀態(tài)在INVISIBLE/ VISIBLE 轉(zhuǎn)換為GONE狀態(tài)時，會間接調(diào)用requestLayout() 和invalidate方法。
同時，由于整個個View樹大小發(fā)生了變化，會請求measure()過程以及draw()過程，同樣地，只繪制需要“重新繪制”的視圖。

** requestFocus()**函數(shù)說明：
請求View樹的draw()過程，但只繪制“需要重繪”的視圖。

上面基本介紹完了View的繪制流程。更多的細節(jié)需要在日常學習中總結(jié)。