View绘制

之前感觉自己知道什么是View绘制，但是又有点模糊。这里就当作笔记来记录一下。
View绘制是从根类ViewRootImpl.java的performTraversals()方法开始的。依次经过measure、layout、draw三个过程，最终完成整个View的绘制。
先来看看源码:

private void performTraversals() {        final View host = mView;        //................        performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);        //................        performLayout(lp, mWidth, mHeight);        //................        performDraw();        //................}

接下来看看上面三个方法的源码:

private void performMeasure(int childWidthMeasureSpec, int childHeightMeasureSpec) {            //重点       mView.measure(childWidthMeasureSpec, childHeightMeasureSpec);}private void performLayout(WindowManager.LayoutParams lp, int desiredWindowWidth,int desiredWindowHeight) {        //重点        host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());}private void performDraw() {    ......    //下面这个是重点，通过查看源码，其内部调用的是drawSoftware()，最终调用的是mView.draw(canvas);    draw(fullRedrawNeeded);    ......}

一句话，三个过程也就是通过measure()，layout()，draw()三个方法实现的。

一、measure过程
先看View类的measure方法源码：

//这个方法是final的，不能被重写public final void measure(int widthMeasureSpec, int heightMeasureSpec) {    //...............    //回调onMeasure方法    onMeasure(widthMeasureSpec, heightMeasureSpec);    //...............}

分析源码可知，这个方法用来计算整个View树的大小，然后设置实际的宽高尺寸，其中，每个子View的大小是由其父视图的MeasureSpec和自身的LayoutParams共同决定的。实际测量过程是由onMeasure方法实现的，所以如果View的子类想要实现自己的测量逻辑，就需要重写onMeasure方法，而不是measure方法，因为这个方法是final的，不能被重写。

measure方法的两个参数都是父视图传递过来的，表示的是父视图的规格。MeasureSpec：测量规格，是一个32位的int型值，高两位表示规格model，后30位表示父视图的size。有三种类型：MeasureSpec.EXACTLY表示确定大小， MeasureSpec.AT_MOST表示最大大小， MeasureSpec.UNSPECIFIED表示大小不确定。对于根View，也就是DecorView来说，model一般为MeasureSpec.EXACTLY，size就是屏幕的物理尺寸。其他子view的大小是父视图和自身共同决定的。

接着看onMeasure的源码：

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

setMeasuredDimension方法用来设置View的测量宽高，如果不重写此方法，默认调用getDefaultSize获取尺寸。至此，对于普通View来说，已经算是完成了measure过程。当然了，也可以重写onMeasure方法并调用setMeasuredDimension方法来设置任意大小的布局(视图).

onMeasure方法的默认实现仅仅是调用setMeasuredDimension方法，所以setMeasuredDimension方法至关重要，它对View的成员变量mMeasuredWidth 和 mMeasuredHeight赋值，measure的主要目的就是给View树中的每个View的这两个成员变量赋值，所以一旦这两个变量被赋值，意味着测量工作结束。

接着看源码：

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

由以上代码可知，正常情况下（SpecMode为AT_MOST或EXACTLY），getDefaultSize获取的尺寸大小即为specSize，也就是系统默认的规格。由以上代码还可知道，直接继承View的自定义控件需要重写onMeasure方法并设置wrap_content时的自身大小，否则在布局中使用wrap_content就相当于使用match_parent的效果。

至此，一个普通View的measure过程算是结束了。

一般情况下，View是被ViewGroup嵌套的，ViewGroup中定义了measureChildren, measureChild, measureChildWithMargins方法来对子视图进行测量，measureChildren内部实质只是循环调用measureChild，measureChild和measureChildWithMargins的区别就是是否把margin和padding也作为子视图的大小。
通过源码可知，

//调用子View的measure方法，子View的measure中会回调子View的onMeasure方法    child.measure(childWidthMeasureSpec, childHeightMeasureSpec);

ViewGroup中的测量最终是通过调用子View的measure方法，最终回调onMeasure方法实现的。所以一般自定义View是继承自ViewGroup类型时，会重写onMeasure实现自己的测量逻辑。

二、layout过程

当ViewRootImpl中performTraversals()上面的measure过程结束后，接着会执行mView.layout()，源码如下：

//调用的还是View中的layout方法host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());

四个参数：左,上,右,下。分别代表相对父视图的坐标位置。其中，左上都是0，右下分别为上面测量出来的width 和 height。

接下来回到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;    //View的位置是否发生变化，导致的结果就是是否需要layout。这里的实质是通过setFrame方法将参数分别赋值给mLeft,mTop,mBottom,mRight    boolean changed = isLayoutModeOptical(mParent) ?  setOpticalFrame(l, t, r, b) :   setFrame(l, t, r, b);    //需要重新layout    if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {        //重点，回调onLayout        onLayout(changed, l, t, r, b);        .........        //设置需要layout的标记        mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;        .........    }}

接下来看回调的View中的onLayout方法:

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

ok，可以看到竟然是空实现的，那就没什么好说的啦。因为对子View布局的工作只能由容器View来做，也就是ViewGroup。

接下来看ViewGroup中的源码:

@Overridepublic final void layout(int l, int t, int r, int b) {        ......        //这里回调的还是View中的layout方法        super.layout(l, t, r, b);        ......}

对比View的layout方法 和 ViewGroup中的layout方法，View中的layout方法可以被重写，而ViewGroup中的layout方法是final的，不能被重写。所以说ViewGroup只能通过重写onLayout方法实现布局放置。

再来看ViewGroup的onLayout方法：

@Overrideprotected abstract void onLayout(boolean changed,            int l, int t, int r, int b);

明显的，这个方法是抽象的，也就意味着它的子类必须实现这个方法。所以在自定义ViewGroup控件中，需要重写onMeasure方法和onLayout方法，这样可以实现一些复杂的布局。自定义View一般就是先调用onMeasure()进行测量，然后调用onLayout()来获取子View 和 子View的测量大小，然后进行layout布局。重写onLayout就是为了安排子View在其父View中的位置。

这里需要提一下getWidth() 、getHeight()、getMeasuredWidth()、getMeasuredHeight()这几个方法：
都是View的测量宽高。getMeasuredWidth()、getMeasuredHeight()需要在onMeasure之后使用，getWidth() 、getHeight()需要在onLayout之后使用。

好吧，到此处layout算是完事儿啦。

注：measure过程得到是每个View经测量后的measuredWidth 和 measuredHeight，而layout过程得到是对每个View进行位置分配后的mLeft，mTop，mRight，mBottom，这些相对父视图来说的。

三、draw过程
draw过程也是在ViewRootImpl的performTraversals()中调用的，在measure 和 layout之后调用。

canvas = mSurface.lockCanvas(dirty);......//调用View的draw方法来执行绘制mView.draw(canvas);

接下来就来看看View中的draw源码:

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---绘制子View         *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;}

可以看到，draw过程分为6个步骤，上面有写注释。

先来看步骤3，也就是绘制View自身，调用的是View的onDraw()：

protected void onDraw(Canvas canvas) {}

额，竟然是个空实现方法。其实是由于每个View的内容各不相同，所以交给子类去实现各自的绘制逻辑。

步骤4，绘制子View。

看看View的dispatchDraw方法：

/**     * Called by draw to draw the child views. This may be overridden     * by derived classes to gain control just before its children are drawn     * (but after its own view has been drawn).     * @param canvas the canvas on which to draw the view     */protected void dispatchDraw(Canvas canvas) {}

好吧，又是一个空实现的方法。注释上写的很清楚，如果View包含子View就需要重写这个方法。所以就需要看看ViewGroup的dispatchDraw方法：

@Overrideprotected void dispatchDraw(Canvas canvas) {    ......    //遍历子View    for (int i = 0; i < childrenCount; i++) {        if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||transientChild.getAnimation() != null) {    more |= drawChild(canvas, transientChild, 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);            }        }        ......}

重点就是drawChild这个方法：

    protected boolean drawChild(Canvas canvas, View child, long drawingTime) {         //调用的是View的draw方法        return child.draw(canvas, this, drawingTime);    }

也就是说，ViewGroup重写了父类View的dispatchDraw方法，该方法内部通过遍历并调用各个子View的draw方法来实现绘制。重要的是可以知道，ViewGroup内部已经重写了dispatchDraw方法，所以我们一般不需要重写dispatchDraw方法了，但是可以重载这个方法来实现具体的功能。

ok，draw过程结束！！！

到此为止，measure，layout，draw三个过程就结束了，也就是说整个View的绘制结束。后面还是得看看源码，太精深，，，