天天看點
傳回

Android View的測量、布局、繪制過程詳解（下）

View的measure()方法是final的，是以我們無法在子類中去重寫這個方法，在該方法内部會調用onMeasure()方法。是以我們自定義view時，要重寫也是重寫onMeasure方法。同理，layout、draw也是final的，我們根據需要重寫onLayout和onDraw方法即可。

1、measure過程

measure過程要分成兩種情況來看：

  • 1、如果隻是一個view，那麼直接調用其measure方法即可完成測量；
  • 2、如果是一個ViewGroup，除了完成自己的測量外，還會周遊調用所有子view的measure方法；

首先看第一種情況，也就是View的情況。

1.1、 View的Measure過程

View的measure()方法是final的，我們無法在子類中去重寫這個方法，在該方法内部會調用onMeasure()方法，如果自定義時需要，可以重寫此方法， 源碼如下所示：

// (frameworks\base\core\java\android\view\View.java)

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

上述代碼很簡潔，就是給view設定寬高，都是通過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;
}

邏輯很簡單，如果是UNSPECIFIED，直接傳回系統給的建議值size， 如果是AT_MOST或EXACTLY，就傳回在MeasureSpec中的實際測量值，而實際測量值的來源有三種情況：

（1）如果View設定了固定寬高，傳回的就是設定的大小；

（2）如果設定了MATCH_PARENT，View的測量模式會有兩種情況，不過不管是哪一種，傳回最大值的都是父容器剩餘大小；

（3）如果是自定義view，設定了WRAP_CONTENT，需要自己在onMeasure中重寫代碼，計算此種情況下應該是什麼大小，否則WRAP_CONTENT的效果可能會失效；

第一二點都好了解，第三點通常發生在自定義view，因為從上述代碼可見，如果沒自己進行計算，則最後效果MATCH_PARENT是一緻的，都是得到父容器剩餘大小。常見的解決方式就是在onMeasure裡針對WRAP_CONTENT屬性直接通過setMeasuredDimension()方法為其指定一個預設的寬高。

1.2 ViewGroup的Measure過程

ViewGroup類是沒有onMeasure()方法的，因為不同的ViewGroup子類布局都不一樣，是以這個方法是交給子類去實作的。

ViewGroup中定義了一個measureChildren()方法，其中通過for循環來周遊測量子視圖的大小，然後就可以确定自己的大小：

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， 去調用每個子view的measure方法：

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

2、号外：何時去擷取View的寬高是最合适的？

通常來說，在measure後，view的大小就測量出來了，就可擷取view的寬高了，但是measure是三大流程中最複雜的一個，有的情況下可能需要多次measure後才能最終确定寬高，是以，一種比較好的方式就是在onLayout中去擷取View的最終測量寬高。

此外，如果我們不是在view内部的onLayout中去擷取寬高，而是在Activity中想去擷取某個View的寬高，應該怎麼做呢？ 因為view的繪制流程和Activity的生命周期無關，是以不能保證在哪個Activity的生命周期時，View繪制完畢，此時我們又以下四種方法來解決：

  • 1、Activity/View的 onWindowFocusChanged方法： 回調這個方法時，就表示View已經初始化完畢，但onWindowFocusChanged可能會被回調多次，是以我們要做好相應的邏輯判斷；
  • 2、view.post(Runnable): 通過view的post方法将一個Runnable加入到消息隊列，然後Looper調用Runnable時，view也就完成初始化了；
  • 3、通過ViewTreeObserver監聽View的變化：當View樹的狀态或可見性改變，會回調給它的onGloableLayout方法，但也會回調多次，需要處理好多次的邏輯；
  • 4、調用view.measure：手動調用view的measure方法，此種方法比較複雜，這裡不進行擴充；

3、layout過程

layout的作用就是ViewGroup用來确定子view的位置，當ViewGroup的位置确定後，它會在onLayout中周遊所有子view并調用其layout方法，然後layout方法又會調用子view的onLayout方法，layout方法确定view自己的位置，onLayout方法确定所有子view的位置, 以下是ViewGroup的layout：

public final void layout(int l, int t, int r, int b) {
    if (!mSuppressLayout && (mTransition == null || !mTransition.isChangingLayout())) {
        if (mTransition != null) {
            mTransition.layoutChange(this);
        }
        super.layout(l, t, r, b);
    } else {
        // record the fact that we noop'd it; request layout when transition finishes
        mLayoutCalledWhileSuppressed = true;
    }
}

ViewGroup的layout什麼都沒做，直接調用了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);//注釋1

    if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
        onLayout(changed, l, t, r, b);//注釋2

        if (shouldDrawRoundScrollbar()) {
            if(mRoundScrollbarRenderer == null) {
                mRoundScrollbarRenderer = new RoundScrollbarRenderer(this);
            }
        } else {
            mRoundScrollbarRenderer = null;
        }

        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;

    if ((mPrivateFlags3 & PFLAG3_NOTIFY_AUTOFILL_ENTER_ON_LAYOUT) != 0) {
        mPrivateFlags3 &= ~PFLAG3_NOTIFY_AUTOFILL_ENTER_ON_LAYOUT;
        notifyEnterOrExitForAutoFillIfNeeded(true);
    }
}

上述代碼中：

  • 注釋1： 通過setFrame，完成對View四個頂點的初始化，也就确定了view相對父view的位置，并且會判斷視圖的大小是否發生過變化，避免未發生變化時進行重繪操作；
  • 注釋2：調用view的onLayout方法，完成真正的layout，onLayout在View和ViewGroup中均是抽象方法，需要子view實作；

4、draw過程

measure和layout的過程都結束後，就進入到對View進行繪制的draw過程了。

首先會建立出一個Canvas對象，然後調用View的draw()方法來執行具體的繪制工作，大緻可以分為四步：

  • 1、繪制背景background.draw(canvas);
  • 2、繪制自己 onDraw；
  • 3、繪制childview（dispatchDraw）；
  • 4、繪制裝飾（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);

        drawAutofilledHighlight(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);

        // Step 7, draw the default focus highlight
        drawDefaultFocusHighlight(canvas);

        if (debugDraw()) {
            debugDrawFocus(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);
        p.setShader(fade);
        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);
        p.setShader(fade);
        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);
        p.setShader(fade);
        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);
        p.setShader(fade);
        canvas.drawRect(right - length, top, right, bottom, p);
    }

    canvas.restoreToCount(saveCount);

    drawAutofilledHighlight(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);

    if (debugDraw()) {
        debugDrawFocus(canvas);
    }
}

View的繪制流程就講完了，如果您覺得還可以，麻煩點個贊吧~~

Android源碼分析 android view View的繪制流程 View的測量布局繪制 Android View的測量布局繪制
上一篇: view的流程（測量，布局，繪制）
下一篇: Synchronized 同步鎖

繼續閱讀