Android view绘制流程

我们先来看一张图：

这张图显示了一个Activity中View的结构，途中id为content的内容就是整个View树的结构，所以对每个具体View对象的操作，其实就是个递归的实现。
View的绘制经历三个过程：Measure、Layout、Draw。整个View树的绘图流程是在ViewRoot.java类的performTraversals()函数展开的，该函数做的执行过程可简单概况为根据之前设置的状态，判断是否需要重新计算视图大小(measure)、是否重新需要安置视图的位置(layout)、以及是否需要重绘(draw)。

performTraversals函数

private void performTraversals() {        ......        //最外层的根视图的widthMeasureSpec和heightMeasureSpec由来        //lp.width和lp.height在创建ViewGroup实例时等于MATCH_PARENT        int childWidthMeasureSpec = getRootMeasureSpec(mWidth, lp.width);        int childHeightMeasureSpec = getRootMeasureSpec(mHeight, lp.height);        ......        mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);        ......        mView.layout(0, 0, mView.getMeasuredWidth(), mView.getMeasuredHeight());        ......        mView.draw(canvas);        ......    }

注意getRootMeasureSpec方法中传入的参数，其中lp.width和lp.height在创建ViewGroup实例的时候就被赋值了，它们都等于MATCH_PARENT
getRootMeasureSpec函数

/**     * Figures out the measure spec for the root view in a window based on it's     * layout params.     *     * @param windowSize     *            The available width or height of the window     *     * @param rootDimension     *            The layout params for one dimension (width or height) of the     *            window.     *     * @return The measure spec to use to measure the root view.     */    private static int getRootMeasureSpec(int windowSize, int rootDimension) {        int measureSpec;        switch (rootDimension) {        case ViewGroup.LayoutParams.MATCH_PARENT:            // Window can't resize. Force root view to be windowSize.            measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);            break;        ......        }        return measureSpec;    }

这里使用了MeasureSpec.makeMeasureSpec()方法来组装一个MeasureSpec，当rootDimension参数等于MATCH_PARENT的时候，MeasureSpec的specMode就等于EXACTLY，当rootDimension等于WRAP_CONTENT的时候，MeasureSpec的specMode就等于AT_MOST。并且MATCH_PARENT和WRAP_CONTENT时的specSize都是等于windowSize的，也就意味着根视图总是会充满全屏的。

1、Measure过程

Measure过程是计算视图大小，View中视图measure过程相关的方法主要有三个：

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

measure调用onMeasure，onMeasure调用setMeasureDimension，measure，setMeasureDimension是final类型，view的子类不需要重写，onMeasure在view的子类中重写。
onMeasure函数

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

重写onMeasure时，要调用setMeasuredDimension或者super.onMeasure来设置自身的mMeasuredWidth和mMeasuredHeight，否则，就会抛出异常.
setMeasuredDimension函数，用来设置view的大小：

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

再看一下onMeasure的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类：

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为长度的二进制数，前两位标示Mode，后面的标示Size。MeasureSpec有三种模式分别是UNSPECIFIED, EXACTLY和AT_MOST。

• EXACTLY：在这种模式下，尺寸的值是多少，那么这个组件的长或宽就是多少。比如我们将控件的layout_width或layout_height指定为具体数值时如andorid:layout_width=”50dip”，或者为MATCH_PARENT是，都是控件大小已经确定的情况，都是精确尺寸。
• AT_MOST：这个也就是父组件，能够给出的最大的空间，当前组件的长或宽最大只能为这么大，当然也可以比这个小。当控件的layout_width或layout_height指定为WRAP_CONTENT时，控件大小一般随着控件的子空间或内容进行变化，此时控件尺寸只要不超过父控件允许的最大尺寸即可。因此，此时的mode是AT_MOST，size给出了父控件允许的最大尺寸。
• 未指定尺寸，这种情况不多，一般都是父控件是AdapterView，通过measure方法传入的模式。
  widthMeasureSpec和heightMeasureSpec决定了Mode和Size的值，widthMeasureSpec和heightMeasureSpec来自父视图，这两个值都是由父视图经过计算后传递给子视图的，说明父视图会在一定程度上决定子视图的大小。

Measure是一个复杂的过程，因为一个布局中一般都会包含多个子视图，每个视图都需要经历一次measure过程。ViewGroup中定义了一个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);             }         }     }  

这里会去遍历当前布局下的所有子视图，然后逐个调用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);     }  

从这里我们可以看到视图的大小是由父视图和子视图共同决定的。子布局里面的android:layout_width和android:layout_height只是期望值，父View大小最终是由DecorView决定。父视图提供尺寸大小的一个能力，子视图最终尺寸与父视图能力、子视图期望的值共同决定

2、Layout过程

measure过程确定视图的大小，layout过程确定视图的位置。layout是从view的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;     }  

函数中参数l、t、r、b是指view的左、上、右、底的位置，这几个参数是父视图传入的，而根视图中参数是由performTraversals()方法传入的。当ViewRootImpl的performTraversals中measure执行完成以后会接着执行mView.layout：

private void performTraversals() {    ......    mView.layout(0, 0, mView.getMeasuredWidth(), mView.getMeasuredHeight());    ......}

view中的layout中调用了onLayout方法，在view中onLayout方法是一个空函数，他需要其子类实现。

protected void onLayout(boolean changed, int left, int top, int right, int bottom) {    }

那我们具体来看一下LinearLayout中的onlayout方法：

public class LinearLayout extends ViewGroup {    @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);        }    }}

再具体看下layoutVertical方法：

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;                //调用child的layout设置child的位置              setChildFrame(child, childLeft, childTop + getLocationOffset(child),                        childWidth, childHeight);                childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);                i += getChildrenSkipCount(child, i);            }        }    }  

layout设置了view的位置，还设置了子视图位置，layoutHorizontal()方法中调用了setChildFrame方法：

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

从上面看出，layout也是一个自上而下的过程，先设置父视图位置，在循环子视图，父视图位置一定程度上决定了子视图位置。

3、Draw过程

draw过程调用顺序在measure()和layout()之后，同样的，performTraversals()发起的draw过程最终会调用到mView的draw()函数，这里的mView对于Activity来说就是PhoneWindow.DecorView。看一下view类的draw方法：

 public void draw(Canvas canvas) {        ......        /*         * 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        ......        if (!dirtyOpaque) {            drawBackground(canvas);        }        // skip step 2 & 5 if possible (common case)        ......        // Step 2, save the canvas' layers        ......            if (drawTop) {                canvas.saveLayer(left, top, right, top + length, null, flags);            }        ......        // 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        ......        if (drawTop) {            matrix.setScale(1, fadeHeight * topFadeStrength);            matrix.postTranslate(left, top);            fade.setLocalMatrix(matrix);            p.setShader(fade);            canvas.drawRect(left, top, right, top + length, p);        }        ......        // Step 6, draw decorations (scrollbars)        onDrawScrollBars(canvas);        ......    }

draw方法分为6步

1. 绘制该View的背景
2. 为显示渐变框做一些准备操作
3. 调用onDraw()方法绘制视图本身
4. 调用dispatchDraw ()方法绘制子视图
5. 绘制渐变框
6. 绘制滚动条

第三步, Draw view’s content步骤调用了onDraw方法，子类中实现onDraw方法。
第四步，Draw children步骤使用的dispatchDraw方法，这个方法在ViewGroup中有实现。
View或ViewGroup的子类不用再重载ViewGroup中该方法，因为它已经有了默认而且标准的view系统流程。dispatchDraw()内部for循环调用drawChild()分别绘制每一个子视图，而drawChild()内部又会调用draw（）函数完成子视图的内部绘制工作。

@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的绘制流程完成了。

4、绘制相关方法

invalidate()方法 ：
说明：请求重绘View树，即draw()过程，假如视图大小没有发生变化就不会调用layout()过程，并且只绘制那些“需要重绘的”视图，即谁(View的话，只绘制该View ；ViewGroup，则绘制整个ViewGroup)请求invalidate()方法，就绘制该视图。
一般引起invalidate()操作的函数如下：

• 1、直接调用invalidate()方法，请求重新draw()，但只会绘制调用者本身。

• 2、setSelection()方法 ：请求重新draw()，但只会绘制调用者本身。

• 3、setVisibility()方法 ：当View可视状态在INVISIBLE转换VISIBLE时，会间接调用invalidate()方法，继而绘制该View。

• 4 、setEnabled()方法 ： 请求重新draw()，但不会重新绘制任何视图包括该调用者本身。

requestLayout()方法 ：
说明：会导致调用measure()过程 和 layout()过程 。只是对View树重新布局layout过程包括measure()和layout()过程，不会调用draw()过程，但不会重新绘制任何视图包括该调用者本身。
一般引起invalidate()操作的函数如下：
1、setVisibility()方法： 当View的可视状态在INVISIBLE/ VISIBLE 转换为GONE状态时，会间接调用requestLayout() 和invalidate方法。
同时，由于整个View树大小发生了变化，会请求measure()过程以及draw()过程，同样地，只绘制需要“重新绘制”的视图。

requestFocus()函数说明：
说明：请求View树的draw()过程，但只绘制“需要重绘”的视图。