2. 程式人生 > >android中View.measure方法詳解

android中View.measure方法詳解

阿新 • • 發佈：2019-01-22

當Activity獲得焦點時，它將被要求繪製自己的佈局，Android framework將會處理繪製過程，Activity只需提供它的佈局的根節點。

　　繪製過程從佈局的根節點開始，從根節點開始測量和繪製整個layout tree。

　　每一個ViewGroup 負責要求它的每一個孩子被繪製，每一個View負責繪製自己。

　　因為整個樹是按順序遍歷的，所以父節點會先被繪製，而兄弟節點會按照它們在樹中出現的順序被繪製。

　　繪製是一個兩遍（two pass）的過程：一個measure pass和一個layout pass。

　　測量過程（measuring pass）是在measure(int, int)中實現的，是從樹的頂端由上到下進行的。

　　在這個遞迴過程中，每一個View會把自己的dimension specifications傳遞下去。

　　在measure pass的最後，每一個View都儲存好了自己的measurements，即測量結果。

　　第二個是佈局過程（layout pass），它發生在 layout(int, int, int, int)中，仍然是從上到下進行（top-down）。

　　在這一遍中，每一個parent都會負責用測量過程中得到的尺寸，把自己的所有孩子放在正確的地方。
現在就來看看這個 measure(int, int)

View.java

measure

 /**
     * <p>
     * This is called to find out how big a view should be. The parent
     * supplies constraint information in the width and height parameters.
     * </p>
     *
     * <p>
     * The actual measurement work of a view is performed in
     * {@link #onMeasure(int, int)}, called by this method. Therefore, only
     * {@link #onMeasure(int, int)} can and must be overridden by subclasses.
     * </p>
     *
     *
     * @param
 
 widthMeasureSpec Horizontal space requirements as imposed by the
     *        parent
     * @param heightMeasureSpec Vertical space requirements as imposed by the
     *        parent
     *
     * @see #onMeasure(int, int)
     */
    public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
        boolean
 
 optical = isLayoutModeOptical(this);
        if (optical != isLayoutModeOptical(mParent)) {
            Insets insets = getOpticalInsets();
            int oWidth  = insets.left + insets.right;
            int oHeight = insets.top  + insets.bottom;
            widthMeasureSpec  = MeasureSpec.adjust(widthMeasureSpec,  optical ? -oWidth  : oWidth);
            heightMeasureSpec = MeasureSpec.adjust(heightMeasureSpec, optical ? -oHeight : oHeight);
        }

        // Suppress sign extension for the low bytes
        long key = (long) widthMeasureSpec << 32 | (long) heightMeasureSpec & 0xffffffffL;
        if (mMeasureCache == null) mMeasureCache = new LongSparseLongArray(2);

        if ((mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ||
                widthMeasureSpec != mOldWidthMeasureSpec ||
                heightMeasureSpec != mOldHeightMeasureSpec) {

            // first clears the measured dimension flag
            mPrivateFlags &= ~PFLAG_MEASURED_DIMENSION_SET;

            resolveRtlPropertiesIfNeeded();

            int cacheIndex = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ? -1 :
                    mMeasureCache.indexOfKey(key);
            if (cacheIndex < 0 || sIgnoreMeasureCache) {
                // measure ourselves, this should set the measured dimension flag back
                onMeasure(widthMeasureSpec, heightMeasureSpec);
                mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
            } else {
                long value = mMeasureCache.valueAt(cacheIndex);
                // Casting a long to int drops the high 32 bits, no mask needed
                setMeasuredDimensionRaw((int) (value >> 32), (int) value);
                mPrivateFlags3 |= PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
            }

            // flag not set, setMeasuredDimension() was not invoked, we raise
            // an exception to warn the developer
            if ((mPrivateFlags & PFLAG_MEASURED_DIMENSION_SET) != PFLAG_MEASURED_DIMENSION_SET) {
                throw new IllegalStateException("View with id " + getId() + ": "
                        + getClass().getName() + "#onMeasure() did not set the"
                        + " measured dimension by calling"
                        + " setMeasuredDimension()");
            }

            mPrivateFlags |= PFLAG_LAYOUT_REQUIRED;
        }

        mOldWidthMeasureSpec = widthMeasureSpec;
        mOldHeightMeasureSpec = heightMeasureSpec;

        mMeasureCache.put(key, ((long) mMeasuredWidth) << 32 |
                (long) mMeasuredHeight & 0xffffffffL); // suppress sign extension
    }

可以看到measure函式有2個引數，widthMeasureSpec 和 heightMeasureSpec。我最初的疑問是不知道該怎麼傳這兩個引數，於是跟到原始碼裡面看看。這個函式的工作大概如下：
至於這個mPrivateFlags先跳過了。

  1. 檢查傳入的widthMeasureSpec和heightMeasureSpec是否與當前的值是一樣的，不一樣的話，呼叫onMeasure函式，並設定mPrivateFlags。

  2. 儲存新值到mOldWidthMeasureSpec和mOldHeightMeasureSpec。這兩個變數不用深究了，沒有其他地方用到，就只是在這個函式中用來比較值用的。

  3. 這裡判斷符合條件後會丟擲一個IllegalStateException的異常，它的提示資訊很清楚，告訴我們要呼叫setMeasuredDimension()方法。但到底是怎麼回事呢？這是在你需要重寫onMeasure函式時需要注意的。

onMeasure

先來看看預設的View的onMeasure函式吧：

 /**
     * <p>
     * Measure the view and its content to determine the measured width and the
     * measured height. This method is invoked by {@link #measure(int, int)} and
     * should be overridden by subclasses to provide accurate and efficient
     * measurement of their contents.
     * </p>
     *
     * <p>
     * <strong>CONTRACT:</strong> When overriding this method, you
     * <em>must</em> call {@link #setMeasuredDimension(int, int)} to store the
     * measured width and height of this view. Failure to do so will trigger an
     * <code>IllegalStateException</code>, thrown by
     * {@link #measure(int, int)}. Calling the superclass'
     * {@link #onMeasure(int, int)} is a valid use.
     * </p>
     *
     * <p>
     * The base class implementation of measure defaults to the background size,
     * unless a larger size is allowed by the MeasureSpec. Subclasses should
     * override {@link #onMeasure(int, int)} to provide better measurements of
     * their content.
     * </p>
     *
     * <p>
     * If this method is overridden, it is the subclass's responsibility to make
     * sure the measured height and width are at least the view's minimum height
     * and width ({@link #getSuggestedMinimumHeight()} and
     * {@link #getSuggestedMinimumWidth()}).
     * </p>
     *
     * @param widthMeasureSpec horizontal space requirements as imposed by the parent.
     *                         The requirements are encoded with
     *                         {@link android.view.View.MeasureSpec}.
     * @param heightMeasureSpec vertical space requirements as imposed by the parent.
     *                         The requirements are encoded with
     *                         {@link android.view.View.MeasureSpec}.
     *
     * @see #getMeasuredWidth()
     * @see #getMeasuredHeight()
     * @see #setMeasuredDimension(int, int)
     * @see #getSuggestedMinimumHeight()
     * @see #getSuggestedMinimumWidth()
     * @see android.view.View.MeasureSpec#getMode(int)
     * @see android.view.View.MeasureSpec#getSize(int)
     */
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
                getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
    }

當我們需要重寫onMeasure時，記得要呼叫setMeasuredDimension來設定自身的mMeasuredWidth和mMeasuredHeight，否則，就會丟擲上面那個異常哦~

setMeasuredDimension

繼續來看setMeasuredDimension：

    /**
     * <p>This method must be called by {@link #onMeasure(int, int)} to store the
     * measured width and measured height. Failing to do so will trigger an
     * exception at measurement time.</p>
     *
     * @param measuredWidth The measured width of this view.  May be a complex
     * bit mask as defined by {@link #MEASURED_SIZE_MASK} and
     * {@link #MEASURED_STATE_TOO_SMALL}.
     * @param measuredHeight The measured height of this view.  May be a complex
     * bit mask as defined by {@link #MEASURED_SIZE_MASK} and
     * {@link #MEASURED_STATE_TOO_SMALL}.
     */
    protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
        boolean optical = isLayoutModeOptical(this);
        if (optical != isLayoutModeOptical(mParent)) {
            Insets insets = getOpticalInsets();
            int opticalWidth  = insets.left + insets.right;
            int opticalHeight = insets.top  + insets.bottom;

            measuredWidth  += optical ? opticalWidth  : -opticalWidth;
            measuredHeight += optical ? opticalHeight : -opticalHeight;
        }
        setMeasuredDimensionRaw(measuredWidth, measuredHeight);
    }

setMeasuredDimensionRaw

又呼叫了setMeasuredDimensionRaw

 /**
     * Sets the measured dimension without extra processing for things like optical bounds.
     * Useful for reapplying consistent values that have already been cooked with adjustments
     * for optical bounds, etc. such as those from the measurement cache.
     *
     * @param measuredWidth The measured width of this view.  May be a complex
     * bit mask as defined by {@link #MEASURED_SIZE_MASK} and
     * {@link #MEASURED_STATE_TOO_SMALL}.
     * @param measuredHeight The measured height of this view.  May be a complex
     * bit mask as defined by {@link #MEASURED_SIZE_MASK} and
     * {@link #MEASURED_STATE_TOO_SMALL}.
     */
    private void setMeasuredDimensionRaw(int measuredWidth, int measuredHeight) {
        mMeasuredWidth = measuredWidth;
        mMeasuredHeight = measuredHeight;

        mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;
    }

哦，很簡單，就是設定了mMeasuredWidth和mMeasuredHeight，然後給mPrivateFlags設定了MEASURED_DIMENSION_SET標誌位。那麼計算都是在getDefaultSize函式裡實現的：

getDefaultSize

    /**
     * Utility to return a default size. Uses the supplied size if the
     * MeasureSpec imposed no constraints. Will get larger if allowed
     * by the MeasureSpec.
     *
     * @param size Default size for this view
     * @param measureSpec Constraints imposed by the parent
     * @return The size this view should be.
     */
    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，看來主要工作是在這裡，必須得進去看看了這是View的一個內部類。

MeasureSpec

/**
     * A MeasureSpec encapsulates the layout requirements passed from parent to child.
     * Each MeasureSpec represents a requirement for either the width or the height.
     * A MeasureSpec is comprised of a size and a mode. There are three possible
     * modes:
     * <dl>
     * <dt>UNSPECIFIED</dt>
     * <dd>
     * The parent has not imposed any constraint on the child. It can be whatever size
     * it wants.
     * </dd>
     *
     * <dt>EXACTLY</dt>
     * <dd>
     * The parent has determined an exact size for the child. The child is going to be
     * given those bounds regardless of how big it wants to be.
     * </dd>
     *
     * <dt>AT_MOST</dt>
     * <dd>
     * The child can be as large as it wants up to the specified size.
     * </dd>
     * </dl>
     *
     * MeasureSpecs are implemented as ints to reduce object allocation. This class
     * is provided to pack and unpack the &lt;size, mode&gt; tuple into the int.
     */
    public static class MeasureSpec {
        private static final int MODE_SHIFT = 30;
        private static final int MODE_MASK  = 0x3 << MODE_SHIFT;

        /**
         * Measure specification mode: The parent has not imposed any constraint
         * on the child. It can be whatever size it wants.
         */
        public static final int UNSPECIFIED = 0 << MODE_SHIFT;

        /**
         * Measure specification mode: The parent has determined an exact size
         * for the child. The child is going to be given those bounds regardless
         * of how big it wants to be.
         */
        public static final int EXACTLY     = 1 << MODE_SHIFT;

        /**
         * Measure specification mode: The child can be as large as it wants up
         * to the specified size.
         */
        public static final int AT_MOST     = 2 << MODE_SHIFT;

        /**
         * Creates a measure specification based on the supplied size and mode.
         *
         * The mode must always be one of the following:
         * <ul>
         *  <li>{@link android.view.View.MeasureSpec#UNSPECIFIED}</li>
         *  <li>{@link android.view.View.MeasureSpec#EXACTLY}</li>
         *  <li>{@link android.view.View.MeasureSpec#AT_MOST}</li>
         * </ul>
         *
         * <p><strong>Note:</strong> On API level 17 and lower, makeMeasureSpec's
         * implementation was such that the order of arguments did not matter
         * and overflow in either value could impact the resulting MeasureSpec.
         * {@link android.widget.RelativeLayout} was affected by this bug.
         * Apps targeting API levels greater than 17 will get the fixed, more strict
         * behavior.</p>
         *
         * @param size the size of the measure specification
         * @param mode the mode of the measure specification
         * @return the measure specification based on size and mode
         */
        public static int makeMeasureSpec(int size, int mode) {
            if (sUseBrokenMakeMeasureSpec) {
                return size + mode;
            } else {
                return (size & ~MODE_MASK) | (mode & MODE_MASK);
            }
        }

        /**
         * Like {@link #makeMeasureSpec(int, int)}, but any spec with a mode of UNSPECIFIED
         * will automatically get a size of 0. Older apps expect this.
         *
         * @hide internal use only for compatibility with system widgets and older apps
         */
        public static int makeSafeMeasureSpec(int size, int mode) {
            if (sUseZeroUnspecifiedMeasureSpec && mode == UNSPECIFIED) {
                return 0;
            }
            return makeMeasureSpec(size, mode);
        }

        /**
         * Extracts the mode from the supplied measure specification.
         *
         * @param measureSpec the measure specification to extract the mode from
         * @return {@link android.view.View.MeasureSpec#UNSPECIFIED},
         *         {@link android.view.View.MeasureSpec#AT_MOST} or
         *         {@link android.view.View.MeasureSpec#EXACTLY}
         */
        public static int getMode(int measureSpec) {
            return (measureSpec & MODE_MASK);
        }

        /**
         * Extracts the size from the supplied measure specification.
         *
         * @param measureSpec the measure specification to extract the size from
         * @return the size in pixels defined in the supplied measure specification
         */
        public static int getSize(int measureSpec) {
            return (measureSpec & ~MODE_MASK);
        }

        static int adjust(int measureSpec, int delta) {
            final int mode = getMode(measureSpec);
            int size = getSize(measureSpec);
            if (mode == UNSPECIFIED) {
                // No need to adjust size for UNSPECIFIED mode.
                return makeMeasureSpec(size, UNSPECIFIED);
            }
            size += delta;
            if (size < 0) {
                Log.e(VIEW_LOG_TAG, "MeasureSpec.adjust: new size would be negative! (" + size +
                        ") spec: " + toString(measureSpec) + " delta: " + delta);
                size = 0;
            }
            return makeMeasureSpec(size, mode);
        }

        /**
         * Returns a String representation of the specified measure
         * specification.
         *
         * @param measureSpec the measure specification to convert to a String
         * @return a String with the following format: "MeasureSpec: MODE SIZE"
         */
        public static String toString(int measureSpec) {
            int mode = getMode(measureSpec);
            int size = getSize(measureSpec);

            StringBuilder sb = new StringBuilder("MeasureSpec: ");

            if (mode == UNSPECIFIED)
                sb.append("UNSPECIFIED ");
            else if (mode == EXACTLY)
                sb.append("EXACTLY ");
            else if (mode == AT_MOST)
                sb.append("AT_MOST ");
            else
                sb.append(mode).append(" ");

            sb.append(size);
            return sb.toString();
        }
    }

這裡MODE_MASK二進位制是11000（一共30個0）00，也就是最高2位標識mode，其餘位標識size。

總結

接下來回到getDefaultSize函式

通過這個類的方法從引數measureSpec中提取出了specMode和specSize。 specMode的作用在下面的switch語句中可以看出來。

        case MeasureSpec.UNSPECIFIED:
            result = size;
            break;

這裡的size就是getSuggestedMinimumWidth()或者getSuggestedMinimumHeight()，是一個預設的最小寬或高，可以看到如果specMode為MeasureSpec.UNSPECIFIED時，specSize（即我們希望設定的size）是沒有用到的。

        case MeasureSpec.AT_MOST:
        case MeasureSpec.EXACTLY:
            result = specSize;
            break;
        }

當specMode為MeasureSpec.AT_MOST或MeasureSpec.EXACTLY時，從我們傳入的引數measureSpec中提取出來的specSize被採用了。這種情況下上面的size就被廢棄了。當result確定後，就是setMeasuredDimension被呼叫了，在裡面將會對mMeasuredWidth和mMeasuredHeight進行設定。

示例

OK，現在應該理解了吧，下面是一個呼叫measure方法的示例：

mView.measure(MeasureSpec.EXACTLY + mView.getWidth(), MeasureSpec.EXACTLY);  
mView.layout(0, 0, mView.getMeasuredWidth(), mView.getMeasuredHeight());

把mode標誌和你想設定的大小相加，傳進去就OK啦。這裡設定height的時候我是想設0，因此直接傳了MeasureSpec.EXACTLY進去。

注意 measure完後，並不會實際改變View的尺寸，需要呼叫View.layout方法去進行佈局。按示例呼叫layout函式後，View的大小將會變成你想要設定成的大小。

相關推薦

android中View.measure方法詳解

當Activity獲得焦點時，它將被要求繪製自己的佈局，Android framework將會處理繪製過程，Activity只需提供它的佈局的根節點。 　　繪製過程從佈局的根節點開始，從根節點開始測量和繪製整個layout tree。 　　每一個ViewGr

Android measure方法詳解

1. MeasureSpec類 MeasureSpec用來計運算元檢視的大小，有三種類型，UNSPECIFIED、EXACTLY和AT_MOST。 UNSPECIFIED表示未定義，即父控制元件未做限制，可以為任何值，一般設定為0。 EXACTLY表示實際值

android專案生成aar包和在其他專案中的使用方法詳解

aar是一個類似於jar的檔案格式,包含了class檔案和資原始檔。是Android的專屬“jar” 將程式碼打包成aar檔案，可以在一定程度上加快AndroidStudio的速度,尤其是將Module打包成aar檔案，提升的效果很顯著。 第一步:新建一個module 建立

Android中的windowSoftInputMode屬性詳解

stun -h oid 中文意思 ecif andro 標題 進行 模式 如何實現軟鍵盤不自動彈出，使用的方法是設置android:windowSoftInputMode屬性。那麽，這個屬性到底是幹什麽的，他有什麽作用呢？今天這篇文章，就是探索android:win

Java中的main()方法詳解

普通 什麽 javac 無限 reflect ase 理解 jvm cep 在Java中，main()方法是Java應用程序的入口方法，也就是說，程序在運行的時候，第一個執行的方法就是main()方法，這個方法和其他的方法有很大的不同，比如方法的名字必須是main，方法必須

(轉)shell中test命令方法詳解

目的 判斷字符串 演示 警告 gic 一個數 平臺 oracl 差異 test命令用法。功能：檢查文件和比較值 原文：https://www.cnblogs.com/guanyf/p/7553940.html 　　 1）判斷表達式 　　if test (表達式為真)

Laravel框架中的make方法詳解

option 節奏 構建 可能 特性 關系 翻譯 空數組 過程 為什麽網上已經有這麽多的介紹Laravel的執行流程了，Laravel的容器詳解了，Laravel的特性了，Laravel的啟動過程了之類的文章，我還要來再分享呢？ 因為，每個人的思維方式和方向是不一樣的，所以

layer-list：Android中layer-list使用詳解

layout nbsp 分享 sel 效果圖 技術分享 ner select ati 使用layer-list可以將多個drawable按照順序層疊在一起顯示，默認情況下，所有的item中的drawable都會自動根據它附上view的大小而進行縮放， layer-list

Servlet中的getServletContext()方法詳解

     這兩天剛剛學到這個類，看了視訊，翻了書，我覺得還是比較亂，javaee裡面的jdk也寫的比較亂，所以今天有時間整理一下吧： 其實我覺得還是從下面這段話先來解釋吧： public class ServletContext01 extends HttpSe

手把手教你ExtJS從入門到放棄——篇二十四(示例21:Ext.dom.Element類中操作樣式方法詳解）

只挑幾個講解： applyStyle:引數可以是如下形式,也可以是物件形式：物件的屬性為樣式如{width:300px},或者是個方法，返回值形式為 前面兩種 setStyle:跟jquery裡的css方法一樣，第一個引數是樣式屬性的key，第二個是值

jQuery中的$.ajax()方法詳解

jquery中的ajax方法引數總是記不住，這裡記錄一下。   1.url:  要求為String型別的引數，（預設為當前頁地址）傳送請求的地址。 2.type:  要求為String型別的引數，請求方式（post或get）預設為get。注意其他http請求

ArrayList中的remove方法詳解

ArrayList類中一共給出了兩種remove方法，下面來對這兩種方法詳解： 1、引數為元素下標（int型） 對於這個方法，裡面的引數是要刪除元素的下標，我們可以使用students(arraylis

mongodb中的aggregate() 方法詳解

按照 支付狀態進行分組 db.weixin_pay_log.aggregate([ {$group:{_id:"$payStatus",count:{$sum:1},total:{$sum:"$sum"}}} ]) 支付型別payType = “5” 

Android中的廣播Broadcast詳解

                今天來看一下Android中的廣播機制，我們知道廣播Broadcast是Android中的四大元件之一，可見他的重要性了，當然它的用途也很大的，比如一些系統的廣播：電量低、開機、鎖屏等一些操作都會發送一個廣播，具體的Android系統中的廣播可以參見我的另外一篇部落格:http

OkHttp面試之--HttpEngine中的sendRequest方法詳解

上一節我們介紹了OkHttp網路非同步請求的整個流程。其中在流程的最後階段，我們發現最終建立了HttpEngine物件，並分別呼叫的此物件的sendRequest和readResponse方法。這兩個方法 分別有它相應的作用。這一節我們著重來分析sendRequ

Android中Broadcast Receiver元件詳解

BroadcastReceiver（廣播接收器）是Android中的四大元件之一。 下面是Android Doc中關於BroadcastReceiver的概述：①廣播接收器是一個專注於接收廣播通知資訊，並做出對應處理的元件。很多廣播是源自於系統程式碼的──比如，通知時區改

Python 中 str.format() 方法詳解

Python 中 str.format() 方法詳解 轉載請註明出處：https://blog.csdn.net/jpch89/article/details/84099277 文章目錄 Python 中 str.format() 方法詳解

Android中persistent屬性用法詳解

看見好的東西，不轉載真是罪過 本文例項講述了Android中persistent屬性用法。分享給大家供大家參考，具體如下： 前段時間在研究telephony時，一直沒有在framework下發現對telephony的初始化(PhoneFactory.Java中的make

android matrix 最全方法詳解與進階

1 概述 這裡我們會詳細講解matrix的各個方法，以及它的用法。matrix叫做矩陣，在前面講解 ColorFilter 的文章中，我們講解了ColorMatrix，他是一個4*5的矩陣。而這裡，我們講解的Matrix不是用於處理顏色的，而是處理圖形的。他是一個3*3的

深入Android MediaPlayer的使用方法詳解

1）如何獲得MediaPlayer例項：可以使用直接new的方式：MediaPlayer mp = new MediaPlayer();也可以使用create的方式，如：MediaPlayer mp = MediaPlayer.create(this, R.raw.test)