這是我在學(xué)習(xí)android 自定義UI控件時(shí)的一些瓶頸襟沮，現(xiàn)在琳瑯滿目的各種UI控件履因，其實(shí)讓很多開發(fā)者感覺(jué)很便利。但要寫出不同的高效控件和復(fù)雜動(dòng)畫还惠，抄抄寫寫是不行的，須先理解android View 的繪制過(guò)程私杜。

1.View的遍歷過(guò)程

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

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

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

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)歷三個(gè)過(guò)程：Measure嫉晶、Layout、Draw田篇。

1.mesarue()過(guò)程

為整個(gè)View樹計(jì)算實(shí)際的大小替废，即設(shè)置實(shí)際的高(對(duì)應(yīng)屬性:mMeasuredHeight)和寬(對(duì)應(yīng)屬性:
mMeasureWidth)，每個(gè)View的控件的實(shí)際寬高都是由父視圖和本身視圖決定的泊柬。
具體的調(diào)用鏈如下：
ViewRoot根對(duì)象地屬性mView(其類型一般為ViewGroup類型)調(diào)用measure()方法去計(jì)算View樹的大小椎镣，回調(diào)View/ViewGroup對(duì)象的onMeasure()方法，該方法實(shí)現(xiàn)的功能如下：
1兽赁、設(shè)置本View視圖的最終大小状答，該功能的實(shí)現(xiàn)通過(guò)調(diào)用setMeasuredDimension()方法去設(shè)置實(shí)際的高(對(duì)應(yīng)屬性：
mMeasuredHeight)和寬(對(duì)應(yīng)屬性：mMeasureWidth);
2 、如果該View對(duì)象是個(gè)ViewGroup類型刀崖，需要重寫該onMeasure()方法惊科，對(duì)其子視圖進(jìn)行遍歷的measure()過(guò)程;
3、 對(duì)每個(gè)子視圖的measure()過(guò)程亮钦，是通過(guò)調(diào)用父類ViewGroup.java類里的measureChildWithMargins()方法去實(shí)現(xiàn)馆截，該方法內(nèi)部只是簡(jiǎn)單地調(diào)用了View對(duì)象的measure()方法。(由于measureChildWithMargins()方法只是一個(gè)過(guò)渡層更簡(jiǎn)單的做法是直接調(diào)用View對(duì)象的measure()方法)蜂莉。整個(gè)measure調(diào)用流程就是個(gè)樹形的遞歸過(guò)程

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

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時(shí)合陵，要調(diào)用setMeasuredDimension或者super.onMeasure來(lái)設(shè)置自身的mMeasuredWidth和mMeasuredHeight，否則澄阳，就會(huì)拋出異常.
setMeasuredDimension函數(shù)拥知，用來(lái)設(shè)置view的大小：

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為長(zhǎng)度的二進(jìn)制數(shù)碎赢，前兩位標(biāo)示Mode低剔，后面的標(biāo)示Size。MeasureSpec有三種模式分別是UNSPECIFIED, EXACTLY和AT_MOST肮塞。
EXACTLY表示父視圖希望子視圖的大小應(yīng)該是由specSize的值來(lái)決定的襟齿，系統(tǒng)默認(rèn)會(huì)按照這個(gè)規(guī)則來(lái)設(shè)置子視圖的大小，開發(fā)人員當(dāng)然也可以按照自己的意愿設(shè)置成任意的大小枕赵。
AT_MOST表示子視圖最多只能是specSize中指定的大小猜欺，開發(fā)人員應(yīng)該盡可能小得去設(shè)置這個(gè)視圖，并且保證不會(huì)超過(guò)specSize拷窜。系統(tǒng)默認(rèn)會(huì)按照這個(gè)規(guī)則來(lái)設(shè)置子視圖的大小开皿，開發(fā)人員當(dāng)然也可以按照自己的意愿設(shè)置成任意的大小。
UNSPECIFIED表示開發(fā)人員可以將視圖按照自己的意愿設(shè)置成任意的大小篮昧，沒(méi)有任何限制赋荆。這種情況比較少見(jiàn)，不太會(huì)用到懊昨。
widthMeasureSpec和heightMeasureSpec決定了Mode和Size的值窄潭，widthMeasureSpec和heightMeasureSpec來(lái)自父視圖，這兩個(gè)值都是由父視圖經(jīng)過(guò)計(jì)算后傳遞給子視圖的酵颁，說(shuō)明父視圖會(huì)在一定程度上決定子視圖的大小嫉你。但是最外層的根視圖，它的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實(shí)例的時(shí)候就被賦值了潦蝇，它們都等于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()方法來(lái)組裝一個(gè)MeasureSpec贤牛，當(dāng)rootDimension參數(shù)等于MATCH_PARENT的時(shí)候，MeasureSpec的specMode就等于EXACTLY则酝，當(dāng)rootDimension等于WRAP_CONTENT的時(shí)候殉簸，MeasureSpec的specMode就等于AT_MOST闰集。并且MATCH_PARENT和WRAP_CONTENT時(shí)的specSize都是等于windowSize的，也就意味著根視圖總是會(huì)充滿全屏的般卑。

Measure是一個(gè)復(fù)雜的過(guò)程武鲁，因?yàn)橐粋€(gè)布局中一般都會(huì)包含多個(gè)子視圖，每個(gè)視圖都需要經(jīng)歷一次measure過(guò)程蝠检。ViewGroup中定義了一個(gè)measureChildren()方法來(lái)去測(cè)量子視圖的大小沐鼠，如下所示：

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

這里會(huì)去遍歷當(dāng)前布局下的所有子視圖，然后逐個(gè)調(diào)用measureChild()方法來(lái)測(cè)量相應(yīng)子視圖的大刑舅：

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決定焰檩。父視圖提供尺寸大小的一個(gè)能力憔涉，子視圖最終尺寸與父視圖能力、子視圖期望的關(guān)系如下：

關(guān)于視圖的measure過(guò)程可以閱讀以下LinearLayout源碼析苫，這樣可以更清楚的了解過(guò)程兜叨。

2.Layout過(guò)程

measure過(guò)程確定視圖的大小，而layout過(guò)程確定視圖的位置藤违。
主要作用 ：為將整個(gè)根據(jù)子視圖的大小以及布局參數(shù)將View樹放到合適的位置上浪腐。具體的調(diào)用是：host.layout()開始View樹的布局，繼而回調(diào)給View/ViewGroup類中的layout()方法顿乒。
具體流程如下:
1 议街、layout方法會(huì)設(shè)置該View視圖位于父視圖的坐標(biāo)軸，即mLeft璧榄，mTop特漩，mLeft，mBottom(調(diào)用setFrame()函數(shù)去實(shí)現(xiàn))骨杂。接下來(lái)回調(diào)onLayout()方法(如果該View是ViewGroup對(duì)象涂身，需要實(shí)現(xiàn)該方法，對(duì)每個(gè)子視圖進(jìn)行布局) 搓蚪；
2蛤售、如果該View是個(gè)ViewGroup類型，需要遍歷每個(gè)子視圖chiildView妒潭，調(diào)用該子視圖的layout()方法去設(shè)置它的坐標(biāo)值悴能。

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的左、上谎亩、右炒嘲、底的位置宇姚，這幾個(gè)參數(shù)是父視圖傳入的，而根視圖中參數(shù)是由performTraversals()方法傳入的夫凸。

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

我們關(guān)注一下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設(shè)置了view的位置浑劳，還設(shè)置了子視圖位置，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也是一個(gè)自上而下的過(guò)程呀洲，先設(shè)置父視圖位置，在循環(huán)子視圖啼止，父視圖位置一定程度上決定了子視圖位置道逗。

3.Draw()過(guò)程

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

調(diào)用流程 ：
mView.draw()開始繪制，draw()方法實(shí)現(xiàn)的功能如下：
1 东囚、繪制該View的背景跺嗽；
2 、為顯示漸變框做一些準(zhǔn)備操作(見(jiàn)5页藻，大多數(shù)情況下桨嫁，不需要改漸變框);
3、調(diào)用onDraw()方法繪制視圖本身 (每個(gè)View都需要重載該方法份帐，ViewGroup不需要實(shí)現(xiàn)該方法);
4璃吧、調(diào)用dispatchDraw ()方法繪制子視圖(如果該View類型不為ViewGroup，即不包含子視圖废境，不需要重載該方法)值得說(shuō)明的是畜挨，ViewGroup類已經(jīng)為我們重寫了dispatchDraw ()的功能實(shí)現(xiàn)，應(yīng)用程序一般不需要重寫該方法噩凹，但可以重載父類函數(shù)實(shí)現(xiàn)具體的功能;
5朦促、 dispatchDraw()方法內(nèi)部會(huì)遍歷每個(gè)子視圖，調(diào)用drawChild()去重新回調(diào)每個(gè)子視圖的draw()方法(注意栓始，這個(gè) 地方“需要重繪”的視圖才會(huì)調(diào)用draw()方法)。值得說(shuō)明的是血当，ViewGroup類已經(jīng)為我們重寫了dispatchDraw()的功能幻赚；
實(shí)現(xiàn)禀忆，應(yīng)用程序一般不需要重寫該方法，但可以重載父類函數(shù)實(shí)現(xiàn)具體的功能落恼。
6箩退、繪制滾動(dòng)條;

于是，整個(gè)調(diào)用鏈就這樣遞歸下去了佳谦〈骼裕看一下view類的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個(gè)步驟：

/*  
        * 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方法啥刻，子類中實(shí)現(xiàn)onDraw方法；第四步咪笑，Draw children步驟使用的dispatchDraw方法可帽，這個(gè)方法在ViewGroup中有實(shí)現(xiàn)。
View或ViewGroup的子類不用再重載ViewGroup中該方法窗怒，因?yàn)樗呀?jīng)有了默認(rèn)而且標(biāo)準(zhǔn)的view系統(tǒng)流程映跟。dispatchDraw()內(nèi)部for循環(huán)調(diào)用drawChild()分別繪制每一個(gè)子視圖，而drawChild()內(nèi)部又會(huì)調(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);  
       }  
   }  

最后說(shuō)說(shuō)那些“需要重繪”的視圖
請(qǐng)求重繪View樹努隙，即draw()過(guò)程，假如視圖發(fā)生大小沒(méi)有變化就不會(huì)調(diào)用layout()過(guò)程辜昵，并且只繪制那些“需要重繪的”
視圖荸镊，即誰(shuí)(View的話，只繪制該View 路鹰；ViewGroup贷洲，則繪制整個(gè)ViewGroup)請(qǐng)求invalidate()方法，就繪制該視圖晋柱。

一般引起invalidate()操作的函數(shù)如下：
1优构、直接調(diào)用invalidate()方法，請(qǐng)求重新draw()雁竞，但只會(huì)繪制調(diào)用者本身钦椭。
2、setSelection()方法 ：請(qǐng)求重新draw()碑诉，但只會(huì)繪制調(diào)用者本身彪腔。
3、setVisibility()方法 ： 當(dāng)View可視狀態(tài)在INVISIBLE轉(zhuǎn)換VISIBLE時(shí)进栽，會(huì)間接調(diào)用invalidate()方法德挣，繼而繪制該View。
4 快毛、setEnabled()方法 ： 請(qǐng)求重新draw()格嗅，但不會(huì)重新繪制任何視圖包括該調(diào)用者本身番挺。** requestLayout()方法** ：會(huì)導(dǎo)致調(diào)用measure()過(guò)程 和 layout()過(guò)程 ,只是對(duì)View樹重新布局layout過(guò)程包括measure()和layout()過(guò)程，不會(huì)調(diào)用draw()過(guò)程屯掖，但不會(huì)重新繪制
任何視圖包括該調(diào)用者本身霜定。
一般引起invalidate()操作的函數(shù)如下：
1棍掐、setVisibility()方法：
當(dāng)View的可視狀態(tài)在INVISIBLE/ VISIBLE 轉(zhuǎn)換為GONE狀態(tài)時(shí)驮瞧，會(huì)間接調(diào)用requestLayout() 和invalidate方法叹括。
同時(shí)，由于整個(gè)個(gè)View樹大小發(fā)生了變化绍坝，會(huì)請(qǐng)求measure()過(guò)程以及draw()過(guò)程徘意，同樣地，只繪制需要“重新繪制”的視圖陷嘴。

** requestFocus()**函數(shù)說(shuō)明：
請(qǐng)求View樹的draw()過(guò)程映砖，但只繪制“需要重繪”的視圖。

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