4源码的角度分析View

内容：View的三大工作流程源码分析

measure过程

1.View的measure过程

• 由measure方法来完成，该方法是静态的不能被子类重写，在view的measure中会调用onMeasure：

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

setMeasuredDimension方法设置宽高的测量值，看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;
    }

EXACTLY情况：getDefaultSize返回的大小就是MeasureSpec中的specSize，这个specSize就是测量后的大小。
UNSPECIFIED情况：view的大小为size，即宽高分别为getSuggestedMinimumWidth和getSuggestedMinimumHeight的返回值

    protected int getSuggestedMinimumWidth() {
        return (mBackground == null) ? mMinWidth : max(mMinWidth, mBackground.getMinimumWidth());
    }
    protected int getSuggestedMinimumHeight() {
        return (mBackground == null) ? mMinHeight : max(mMinHeight, mBackground.getMinimumHeight());

    }

可以看出，如果view没有设置背景，那么view的宽度为mMinWidth，mMinWidth 对应于android:minWidth属性所指的值，
不指定默认为0。如果view指定背景，则view的宽度为max(mMinWidth, mBackground.getMinimumWidth()),看下getMinimumWidth()方法

    public int getMinimumWidth() {
        final int intrinsicWidth = getIntrinsicWidth();
        return intrinsicWidth > 0 ? intrinsicWidth : 0;
    }

getMinimumWidth()返回的就是Drawable的原始宽度，没有原始宽度则为0，例：ShapeDrawable无原始宽度，BitmapDrawable有。

• 总结：从getDefaultSize方法中来看，View的宽高由specSize决定。
  结论：直接继承View的自定义控件需要重写onMeasure方法并设置wrap_content时的自身大小，否则wrap_content效果为match_parent。
  原因：结合上述代码和表4-1理解，上述代码中可知view在代码中使用wrap_content，那么specMode是AT_MOST模式，宽高等于
  specSize；差表4-1可知，这种情况specSize是parentSize,而parentSize是父容器中可以使用的大小，match_parent效果一致。
  解决：

    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec);
        int widthSpaceSize = MeasureSpec.getSize(widthMeasureSpec);
        int widthSpecMode = MeasureSpec.getMode(widthMeasureSpec);
        int heightSpaceSize = MeasureSpec.getSize(heightMeasureSpec);
        int heightSpecMode = MeasureSpec.getMode(heightMeasureSpec);
        if ((widthSpecMode == MeasureSpec.AT_MOST && heightSpecMode == MeasureSpec.AT_MOST){
            setMeasuredDimension(mWidth,mHeight);
        }else if (heightSpecMode == MeasureSpec.AT_MOST) {
            setMeasuredDimension(widthSpaceSize, mHeight);
        } else if (widthSpecMode == MeasureSpec.AT_MOST) {
            setMeasuredDimension(mWidth, heightSpaceSize);
        } else {
        }
    }

在代码中只需要给view指定一个默认的内部宽高(mWidth,mHeight),并在wrap_content时设置即可，对于非wrap_content沿用系统的测量值即可。（可参考TextView，imageView源码）

2.ViewGroup的measure过程

• 对于ViewGroup除了完成自己的measure过程外，还会调用所有子元素的measure方法，各个子元素再递归去执行这个过程。ViewGroup是一个抽象类，没有重写view的onMeasure方法，但提供了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);
            }
        }
    }

ViewGroup在measure时，会对每一个子元素进行measure,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);
    }

measureChild思想是取出子元素的LayoutParams，然后再通过getChildMeasureSpec来创建子元素的MeasureSpec，接着将MeasureSpec直接传递给View的measure方法来进行测量。

• 下面通过LinearLayout的onMeasure方法来分析ViewGroup的measure过程。

protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        if (mOrientation == VERTICAL) {
            measureVertical(widthMeasureSpec, heightMeasureSpec);
        } else {
            measureHorizontal(widthMeasureSpec, heightMeasureSpec);
        }
    }

看下measureVertical方法：由于有300行代码所以只看核心

 void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {
        for (int i = 0; i < count; ++i) {
            final View child = getVirtualChildAt(i);
            measureChildBeforeLayout(child, i, widthMeasureSpec, 0,heightMeasureSpec, usedHeight);
           final int childHeight = child.getMeasuredHeight();
           final int totalLength = mTotalLength;
           mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
                       lp.bottomMargin + getNextLocationOffset(child));
        }
}

系统会遍历子元素并对每个子元素执行measureChildBeforeLayout方法，这个方法内部会调用measure方法，各个元素依次进入measure过程，系统会通过mTotalLength来存储LinearLayout在竖直方向的初步高度。每测量一个子元素mTotalLength都会增加，增加的部分主要包括了子元素的高度以及子元素在竖直方向上的margin等.当子元素测量完毕后，LinearLayout测量自己的大小：

        // Add in our padding
        mTotalLength += mPaddingTop + mPaddingBottom;

        int heightSize = mTotalLength;

        // Check against our minimum height
        heightSize = Math.max(heightSize, getSuggestedMinimumHeight());
        
        // Reconcile our calculated size with the heightMeasureSpec
        int heightSizeAndState = resolveSizeAndState(heightSize, heightMeasureSpec, 0);
        heightSize = heightSizeAndState & MEASURED_SIZE_MASK;
        ···
        setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
                heightSizeAndState);

对竖直LinearLayout而言，它在水平方向的测量过程遵循View的测量过程，在竖直方向的测量过程则和view不同。如果它的布局中高度采用的是mathch_parent或者具体数值，那么它的测量过程与view一致，即高度为specSize；如果它的布局中高度采用wrap_content,那么它的高度是所有子元素所占的高度总和，但是仍然不能超过父容器的剩余空间，它的最终高度还需要考虑其在竖直方向的padding,看源码：

       public static int resolveSizeAndState(int size, int measureSpec, int childMeasuredState) {
        final int specMode = MeasureSpec.getMode(measureSpec);
        final int specSize = MeasureSpec.getSize(measureSpec);
        final int result;
        switch (specMode) {
            case MeasureSpec.AT_MOST:
                if (specSize < size) {
                    result = specSize | MEASURED_STATE_TOO_SMALL;
                } else {
                    result = size;
                }
                break;
            case MeasureSpec.EXACTLY:
                result = specSize;
                break;
            case MeasureSpec.UNSPECIFIED:
            default:
                result = size;
        }
        return result | (childMeasuredState & MEASURED_STATE_MASK);
    }

measure完成后，通过getMeasureWidth/Heigth获取测量高度。在极端情况下系统多次measure才能确定最终高度，这种情况在onMeasure方法中拿到的测量宽高不准确。好的习惯是在onLayout方法中获得View的测量宽高或最终宽高。

• 一种情况：在Activity已启动的时候就做一件任务，任务需要获取某个View的宽高。
  View的measure过程和Activity的生命周期方法不是同步执行，无法保证Activity执行了onCreate、onStart、onResume时View已经测量完毕，如果View还没有测量完毕，那么获得的宽高就是0。

四种解决办法：
(1)Activity/View#onWindowFocusChanged
onWindowFocusChanged方法含义：View已经初始化完毕，宽高已经准备好了，这时候获取宽高没有问题。注意：当Activty继续执行和暂停执行时，onWindowFocusChanged均会被调用，如果频繁的进行onResume和onPause，那么onWindowFocusChanged也会被频繁的调用。代码：

    public void onWindowFocusChanged(boolean hasFocus) {
        super.onWindowFocusChanged(hasFocus);
        if(hasFocus){
           int width = view.getMeasuredWidth();
           int height = view.getMeasuredHeight();
        }
    }

(2)view.post(runnable)
通过post可以将一个runnable投递到消息队列尾部，然后等待Looper调用此runnable的时候，View也已经初始化好了，代码：

    protected void onStart() {
        super.onStart();
        view.post(new Runnable() {
            @Override
            public void run() {
                int width = view.getMeasuredWidth();
                int height = view.getMeasuredHeight();
            }
        });
    }

(3)VeiwTreeObserver
使用VeiwTreeObserver的众多回调可以完成这个功能，比如使用
OnGlobalLayoutListener接口，当View树的状态发生改变或者View树内部的View的可见性发生改变时，onGlobalLayout方法将被回调，此时获取View的宽高。注意：伴随view树的状态改变，onGlobalLayout会被调用多次。

 protected void onStart() {
        super.onStart();
        ViewTreeObserver observer = view.getViewTreeObserver();
        observer.addOnGlobalLayoutListener(new OnGlobalLayoutListener() {

            @SuppressWarnings("deprecation")
            @Override
            public void onGlobalLayout() {
                view.getViewTreeObserver().removeGlobalOnLayoutListener(this);
                int width = view.getMeasuredWidth();
                int height = view.getMeasuredHeight();
            }
        });
    }

(4)view.measure(int widthMeasureSpec, int heightMeasureSpec)
手动对View进行measure来得到View的宽高。根据View的LayoutParams分情况处理：

• match_parent
  无法measure出具体宽高。
• 具体的数值（dp/px）
  比如宽高都是100px:

    private void measureView() {
        int widthMeasureSpec = MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY);
        int heightMeasureSpec = MeasureSpec.makeMeasureSpec(100, MeasureSpec.EXACTLY);
        view.measure(widthMeasureSpec, heightMeasureSpec);
    }

• wrap_content

    private void measureView() {
        int widthMeasureSpec = MeasureSpec.makeMeasureSpec((1 << 30) - 1, MeasureSpec.AT_MOST);
        int heightMeasureSpec = MeasureSpec.makeMeasureSpec((1 << 30) - 1, MeasureSpec.AT_MOST);
        view.measure(widthMeasureSpec, heightMeasureSpec);
    }

注意：(1 << 30) - 1通过分析MeasureSpec的实现可以知道，View的尺寸使用30位二进制表示，最大是30个1（即2^30-1）,也就是(1 << 30) - 1，在最大化模式下，我们用View理论上能支持的最大值去构造MeasureSpec是合理的。

• 关于View的measure的错误用法：原因是违背系统内部实现规范导致measure过程出错，从而结果不能保证是正确的,错误代码：

  private void measureView() {
        int widthMeasureSpec = MeasureSpec.makeMeasureSpec( - 1, MeasureSpec.UNSPECIFIED);
        int heightMeasureSpec = MeasureSpec.makeMeasureSpec(-1, MeasureSpec.UNSPECIFIED);
        view.measure(widthMeasureSpec, heightMeasureSpec);
    }

 view.measure(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);

layout过程

作用是ViewGroup用来确定子元素的位置，确定后它在onLayout中遍历所有子元素并调用其layout方法，在layout方法中onLayout方法又被调用。

• layout方法确定View本身的位置，onLayout确定所有子元素的位置，view的layout方法：

 public void layout(int l, int t, int r, int b) {
        if ((mPrivateFlags3 & PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT) != 0) {
            onMeasure(mOldWidthMeasureSpec, mOldHeightMeasureSpec);
            mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
        }

        int oldL = mLeft;
        int oldT = mTop;
        int oldB = mBottom;
        int oldR = mRight;

        boolean changed = isLayoutModeOptical(mParent) ?
                setOpticalFrame(l, t, r, b) : 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;
        mPrivateFlags3 |= PFLAG3_IS_LAID_OUT;
    }

首先通过setFrame方法设定view的四个顶点的位置，即初始化 mLeft、mTop、mBottom、mRight四值，确定view在父容器中的位置；接着调用onLayout方法，这个方法的用途是父容器确定子元素的位置，实现与具体布局有关，所以View和ViewGroup没有真正实现onLayout方法。

• 看下LinearLayout的onLayout方法：

    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(int left, int top, int right, int bottom) {
        ···
        final int count = getVirtualChildCount();
        ···
        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();
               ···
                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);
            }
        }
    }

setChildFrame中的Width和Height实际上就是子元素的测量宽高，
此方法会遍历所有子元素并调用setChildFrame方法为子元素指定对应位置，childTop会逐渐增大，子元素放在靠下位置。
setChildFrame调用子元素的layout方法，父元素在layout方法中完成自己的定位后，通过onLayout方法调用子元素的layout方法，子元素又会通过自己的layout方法来确定自己的位置，这样一层层传递下去就完成了整个View树的layout过程。
setChildFrame方法：

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

在layout方法中会通过setFrame去设置子元素的四个顶点的位置，在setFrame中有几句赋值语句，这样子元素的位置就确定了

            mLeft = left;
            mTop = top;
            mRight = right;
            mBottom = bottom;

• 问题：View的测量宽高与最终宽高的区别？
  问题具体为：View的getMeasuredWidth和getWidth这两种方法有什么区别。
  首先看getWidth和getHeight的方法实现：

    public final int getWidth() {
        return mRight - mLeft;
    }
    public final int getHeight() {
        return mBottom - mTop;
    }

getWidth方法返回的是View的测量宽度。
答案：在View的默认实现中，View的测量宽高和最终宽高是相等的，区别在于测量宽高形成于View的measure过程，而最终宽高形成于View的layout过程，测量宽高的赋值时机稍微早一些。
在日常开发中可以认为View的测量宽高等于最终宽高，特殊情况下才会不同。

draw过程

View的绘制过程遵循如下几步：

• 绘制背景background.draw(canvas).
• 绘制自己(onDraw).
• 绘制children(dispatchaDraw).
• 绘制装饰(onDrawScrollBars)
  源码：

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

View绘制过程的传递是通过dispatchDraw来实现，dispatchDraw会遍历调用所有子元素的draw方法，draw事件就一层层传递下去。看下View的setWillNotDraw源码：

    /**
     * If this view doesn't do any drawing on its own, set this flag to
     * allow further optimizations. By default, this flag is not set on
     * View, but could be set on some View subclasses such as ViewGroup.
     *
     * Typically, if you override {@link #onDraw(android.graphics.Canvas)}
     * you should clear this flag.
     *
     * @param willNotDraw whether or not this View draw on its own
     */
    public void setWillNotDraw(boolean willNotDraw) {
        setFlags(willNotDraw ? WILL_NOT_DRAW : 0, DRAW_MASK);
    }

注释中可以看出，如果一个view中不需要绘制任何内容，那么设置这个标记位为true以后，系统会进行相应的优化。
默认情况下view没有启动这个默认标记位，但是ViewGroup会默认启动这个优化标记位。
实际开发的意义：当我们的自定义控件继承ViewGroup并且本身不具备绘制功能时，就可以开启这个标记位便于系统进行后续的优化。当明确知道一个ViewGroup需要通过onDraw来绘制内容时，我们需要显示的关闭WILL_NOT_DRAW这个标记位。