×

自定义View Measure过程 - 最易懂的自定义View原理系列(2)

96
Carson_Ho 595a1b60 08f6 4beb 998f 2bf55e230555
2017.02.20 10:50* 字数 3149

前言

  • 自定义View是Android开发者必须了解的基础
  • 网上有大量关于自定义View原理的文章,但存在一些问题:内容不全、思路不清晰、无源码分析、简单问题复杂化等等
  • 今天,我将全面总结自定义View原理中的measure过程,我能保证这是市面上的最全面、最清晰、最易懂的
  • 文章较长,建议收藏等充足时间再进行阅读

目录

目录

1. 作用

测量View的宽/高

  1. 在某些情况下,需要多次测量(measure)才能确定View最终的宽/高;
  2. 在这种情况下measure过程后得到的宽/高可能是不准确的;
  3. 建议在layout过程中onLayout()去获取最终的宽/高

2. 准备的基础

在了解measure 过程前,我们需要先了解measure过程中传递尺寸(宽 / 高测量值)的两个类:

  • ViewGroup.LayoutParams (View 自身的布局参数)
  • MeasureSpecs 类(父视图对子视图的测量要求)

2.1 ViewGroup.LayoutParams

  • 这个类我们很常见,用来指定视图的高度(height)和宽度(width)等布局参数。可通过以下参数进行指定:
参数 解释
具体值 dp / px
fill_parent 强制性使子视图的大小扩展至与父视图大小相等(不含 padding )
match_parent 与fill_parent相同,用于Android 2.3及之后版本
wrap_content 自适应大小,强制性地使视图扩展以便显示其全部内容(含 padding )
android:layout_weight="wrap_content"   //自适应大小  
android:layout_weight="match_parent"   //与父视图等高  
android:layout_weight="fill_parent"    //与父视图等高  
android:layout_weight="100dip"         //精确设置高度值为 100dip  
  • ViewGroup 的子类有其对应的 ViewGroup.LayoutParams 子类
  1. ViewGroup 的子类包括RelativeLayout、LinearLayout等;
  2. 如 RelativeLayout的 ViewGroup.LayoutParams 的子类是RelativeLayoutParams。
  • 构造函数
    构造函数是View的入口,可以用于初始化一些的内容,和获取自定义属性。
// View的构造函数有四种重载
    public DIY_View(Context context){
        super(context);
    }

    public DIY_View(Context context,AttributeSet attrs){
        super(context, attrs);
    }

    public DIY_View(Context context,AttributeSet attrs,int defStyleAttr ){
        super(context, attrs,defStyleAttr);

// 第三个参数:默认Style
// 默认Style:指在当前Application或Activity所用的Theme中的默认Style
// 且只有在明确调用的时候才会生效,
    }
    
    public DIY_View(Context context,AttributeSet attrs,int defStyleAttr ,int defStyleRes){
        super(context, attrs,defStyleAttr,defStyleRes);
    }

// 最常用的是1和2
}

2.2 MeasureSpec

2.2.1 定义

测量规格

可以理解为:测量View的依据

2.2.2 类型

MeasureSpec的类型分为两种:


测量规格类型

每个MeasureSpec代表了一组宽度和高度的测量规格

2.2.3 作用

决定了一个View的大小(宽/高)

即宽测量值(widthMeasureSpec)和高测量值(heightMeasureSpec)决定了View的大小

2.2.4 组成

如下图:

MeasureSpec组成 - 1
MeasureSpec组成 - 2

其中,Mode模式共分为三类

  • UNSPECIFIED模式
  • EXACTLY模式
  • AT_MOST模式

具体说明如下图:

Mode模式说明

2.2.5 MeasureSpec类的使用

  • MeasureSpec 、Mode 和Size都封装在View类中的一个内部类里 - MeasureSpec类。
  • MeasureSpec类通过使用二进制,将mode和size打包成一个int值来减少对象内存分配,用一个变量携带两个数据(size,mode),并提供了打包和解包的方法。具体源代码解析如下:
public class MeasureSpec {  
        //进位大小为2的30次方
        //int的大小为32位,所以进位30位就是要使用int的32和31位做标志位) 
        private static final int MODE_SHIFT = 30;  
          
        // 运算遮罩,0x3为16进制,10进制为3,二进制为11。3向左进位30,就是11 00000000000(11后跟30个0)  
        // 遮罩的作用是用1标注需要的值,0标注不要的值。因为1与任何数做与运算都得任何数,0与任何数做与运算都得0
        private static final int MODE_MASK  = 0x3 << MODE_SHIFT;  
  
        // 0向左进位30 = 00后跟30个0,即00 00000000000
        public static final int UNSPECIFIED = 0 << MODE_SHIFT;  
        
        // 1向左进位30 = 01后跟30个0 ,即01 00000000000
        public static final int EXACTLY     = 1 << MODE_SHIFT;  

        // 2向左进位30 = 10后跟30个0,即10 00000000000
        public static final int AT_MOST     = 2 << MODE_SHIFT;  
  
        /* 根据提供的size和mode得到一个详细的测量结果 */  
        public static int makeMeasureSpec(int size, int mode) {  
        // measureSpec = size + mode
        //注:二进制的加法,不是十进制的加法!
            return size + mode;  
        //设计的目的就是使用一个32位的二进制数,32和31位代表了mode的值,后30位代表size的值  
        // 例如size=100(4),mode=AT_MOST,则measureSpec=100+10000...00=10000..00100  
        }  
  

        /* 通过详细测量结果获得mode */   
        public static int getMode(int measureSpec) {  
         // mode = measureSpec & MODE_MASK;  
        // MODE_MASK = 11 00000000000(11后跟30个0)
        //原理:用MODE_MASK后30位的0替换掉measureSpec后30位中的1,再保留32和31位的mode值。  
        // 例如10 00..00100 & 11 00..00(11后跟30个0) = 10 00..00(AT_MOST),这样就得到了mode的值
            return (measureSpec & MODE_MASK);  
        }  
  


        /* 通过详细测量结果获得size */   
        public static int getSize(int measureSpec) {  
         // size = measureSpec & ~MODE_MASK;  
        // 原理同上,不过这次是将MODE_MASK取反,也就是变成了00 111111(00后跟30个1),将32,31替换成0也就是去掉mode,保留后30位的size  
            return (measureSpec & ~MODE_MASK);  
        } 

}  

// 可以通过下面方式获取specMode和SpecSize
//获取specMode
int specMode = MeasureSpec.getMode(measureSpec)

//获取SpecSize
int specSize = MeasureSpec.getSize(measureSpec)

//也可以通过这两个值生成新的SpecMode
int measureSpec=MeasureSpec.makeMeasureSpec(size, mode);

2.2.6 MeasureSpec值的确定

  • 上面讲了那么久MeasureSpec,那么,MeasureSpec值到底是如何计算得来的呢?
  • 结论:子View的MeasureSpec值是根据子View的布局参数(LayoutParams)和父容器的MeasureSpec值计算得来的,具体计算逻辑封装在getChildMeasureSpec()里。

如下图:

对于普通View

下面,我们来看getChildMeasureSpec()的源码分析:


//作用:
/ 根据父视图的MeasureSpec & 布局参数LayoutParams,计算单个子View的MeasureSpec
//即子view的确切大小由两方面共同决定:父view的MeasureSpec 和 子view的LayoutParams属性 


public static int getChildMeasureSpec(int spec, int padding, int childDimension) {  

 //参数说明
 * @param spec 父view的详细测量值(MeasureSpec) 
 * @param padding view当前尺寸的的内边距和外边距(padding,margin) 
 * @param childDimension 子视图的布局参数(宽/高)

    //父view的测量模式
    int specMode = MeasureSpec.getMode(spec);     

    //父view的大小
    int specSize = MeasureSpec.getSize(spec);     
  
    //通过父view计算出的子view = 父大小-边距(父要求的大小,但子view不一定用这个值)   
    int size = Math.max(0, specSize - padding);  
  
    //子view想要的实际大小和模式(需要计算)  
    int resultSize = 0;  
    int resultMode = 0;  
  
    //通过父view的MeasureSpec和子view的LayoutParams确定子view的大小  


    // 当父view的模式为EXACITY时,父view强加给子view确切的值
   //一般是父view设置为match_parent或者固定值的ViewGroup 
    switch (specMode) {  
    case MeasureSpec.EXACTLY:  
        // 当子view的LayoutParams>0,即有确切的值  
        if (childDimension >= 0) {  
            //子view大小为子自身所赋的值,模式大小为EXACTLY  
            resultSize = childDimension;  
            resultMode = MeasureSpec.EXACTLY;  

        // 当子view的LayoutParams为MATCH_PARENT时(-1)  
        } else if (childDimension == LayoutParams.MATCH_PARENT) {  
            //子view大小为父view大小,模式为EXACTLY  
            resultSize = size;  
            resultMode = MeasureSpec.EXACTLY;  

        // 当子view的LayoutParams为WRAP_CONTENT时(-2)      
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {  
            //子view决定自己的大小,但最大不能超过父view,模式为AT_MOST  
            resultSize = size;  
            resultMode = MeasureSpec.AT_MOST;  
        }  
        break;  
  
    // 当父view的模式为AT_MOST时,父view强加给子view一个最大的值。(一般是父view设置为wrap_content)  
    case MeasureSpec.AT_MOST:  
        // 道理同上  
        if (childDimension >= 0) {  
            resultSize = childDimension;  
            resultMode = MeasureSpec.EXACTLY;  
        } else if (childDimension == LayoutParams.MATCH_PARENT) {  
            resultSize = size;  
            resultMode = MeasureSpec.AT_MOST;  
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {  
            resultSize = size;  
            resultMode = MeasureSpec.AT_MOST;  
        }  
        break;  
  
    // 当父view的模式为UNSPECIFIED时,父容器不对view有任何限制,要多大给多大
    // 多见于ListView、GridView  
    case MeasureSpec.UNSPECIFIED:  
        if (childDimension >= 0) {  
            // 子view大小为子自身所赋的值  
            resultSize = childDimension;  
            resultMode = MeasureSpec.EXACTLY;  
        } else if (childDimension == LayoutParams.MATCH_PARENT) {  
            // 因为父view为UNSPECIFIED,所以MATCH_PARENT的话子类大小为0  
            resultSize = 0;  
            resultMode = MeasureSpec.UNSPECIFIED;  
        } else if (childDimension == LayoutParams.WRAP_CONTENT) {  
            // 因为父view为UNSPECIFIED,所以WRAP_CONTENT的话子类大小为0  
            resultSize = 0;  
            resultMode = MeasureSpec.UNSPECIFIED;  
        }  
        break;  
    }  
    return MeasureSpec.makeMeasureSpec(resultSize, resultMode);  
}  
  • 关于getChildMeasureSpec()里对于子View的测量模式和大小的判断逻辑有点复杂;
  • 别担心,我已经帮大家总结好。具体子View的测量模式和大小请看下表:
Paste_Image.png

规律总结:(以子View为标准,横向观察)

  • 当子View采用具体数值(dp / px)时
    无论父容器的测量模式是什么,子View的测量模式都是EXACTLY且大小等于设置的具体数值;
  • 当子View采用match_parent时
  • 子View的测量模式与父容器的测量模式一致
  • 若测量模式为EXACTLY,则子View的大小为父容器的剩余空间;若测量模式为AT_MOST,则子View的大小不超过父容器的剩余空间
  • 当子View采用wrap_parent时
    无论父容器的测量模式是什么,子View的测量模式都是AT_MOST且大小不超过父容器的剩余空间。

UNSPECIFIED模式:由于适用于系统内部多次measure情况,很少用到,故此处不讨论

注:区别于顶级View(即DecorView)的计算逻辑

对于顶级View

2.3 最基本的知识储备

具体请看我写的另外一篇文章:自定义View基础 - 最易懂的自定义View原理系列


3. measure过程详解

measure过程根据View的类型分为两种情况:

  1. View类型 = 单一View时:只测量自身一个View;
  2. View类型 = ViewGroup时:对ViewGroup视图中所有的子View都进行测量

即遍历去调用所有子元素的measure方法,然后各子元素再递归去执行这个流程。

接下来,我将详细分析这两个measure过程。

3.1 单一View的measure过程

  • 应用场景
    在没有现成的View,需要自己实现的时候,就使用自定义View,一般继承自View,SurfaceView或其他的View,不包含子View。
  1. 如:制作一个支持加载网络图片的ImageView
  2. 特别注意:自定义View在大多数情况下都有替代方案,利用图片或者组合动画来实现,但是使用后者可能会面临内存耗费过大,制作麻烦更诸多问题。
    单一View的measure过程如下图所示:
单一View的measure过程

下面我将一个个方法进行详细分析。

3.1.1 measure()

  • 作用:基本测量逻辑的判断;调用onMeasure()

属于View.java类 & final类型,即子类不能重写此方法

  • 源码分析如下:
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {

//参数说明:View的宽 / 高测量规格
    ...
    int cacheIndex = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ? -1 :
            mMeasureCache.indexOfKey(key);
    if (cacheIndex < 0 || sIgnoreMeasureCache) {
        // 计算视图大小
        onMeasure(widthMeasureSpec, heightMeasureSpec);
        mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
    } else {
        ...
  
}

measure()最终会调用onMeasure()方法。下面继续看onMeasure()的介绍

3.1.2 onMeasure()

  • 作用:调用getDefaultSize()定义对View尺寸的测量逻辑;调用setMeasuredDimension()存储测量后的View宽 / 高
  • 源码分析如下:
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  
//参数说明:View的宽 / 高测量规格

//setMeasuredDimension()  用于获得View宽/高的测量值
//这两个参数是通过getDefaultSize()获得的
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),  
           getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));  
} 


下面继续看setMeasuredDimension()的分析

3.1.3 setMeasuredDimension()

  • 作用:存储测量后的View宽 / 高。

该方法就是我们重写onMeasure()所要实现的最终目的

  • 源码分析如下:

protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {  

//参数说明:测量后子View的宽 / 高值

//将测量后子View的宽 / 高值进行传递
    mMeasuredWidth = measuredWidth;  
    mMeasuredHeight = measuredHeight;  
  
    mPrivateFlags |= PFLAG_MEASURED_DIMENSION_SET;  
}  

由于setMeasuredDimension(int measuredWidth, int measuredHeight)的参数是从getDefaultSize()获得的,下面我们继续看getDefaultSize()的介绍

3.1.4 getDefaultSize()

  • 作用:根据View宽/高的测量规格计算View的宽/高值
  • 源码分析如下:

public static int getDefaultSize(int size, int measureSpec) {  

//参数说明:
// 第一个参数size:提供的默认大小
// 第二个参数:宽/高的测量规格(含模式 & 测量大小)

    //设置默认大小
    int result = size; 
    
    //获取宽/高测量规格的模式 & 测量大小
    int specMode = MeasureSpec.getMode(measureSpec);  
    int specSize = MeasureSpec.getSize(measureSpec);  
  
    switch (specMode) {  
        // 模式为UNSPECIFIED时,使用提供的默认大小
        // 即第一个参数:size 
        case MeasureSpec.UNSPECIFIED:  
            result = size;  
            break;  
        // 模式为AT_MOST,EXACTLY时,使用View测量后的宽/高值
        // 即measureSpec中的specSize
        case MeasureSpec.AT_MOST:  
        case MeasureSpec.EXACTLY:  
            result = specSize;  
            break;  
    }  

 //返回View的宽/高值
    return result;  
}  
  • 上面提到,当模式是UNSPECIFIED时,使用的是提供的默认大小(即第一个参数size)。
    那么,提供的默认大小具体是多少呢?
  • 答:在onMeasure()方法中,getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec)中传入的默认大小是getSuggestedMinimumWidth()

接下来我们继续看getSuggestedMinimumWidth()的源码分析

由于getSuggestedMinimumHeight()类似,所以此处仅分析getSuggestedMinimumWidth()

  • 源码分析如下:
protected int getSuggestedMinimumWidth() {
    return (mBackground == null) ? mMinWidth : max(mMinWidth,mBackground.getMinimumWidth());
}

//getSuggestedMinimumHeight()同理

从代码可以看出:

  • 如果View没有设置背景,View的宽度为mMinWidth
  1. mMinWidth = android:minWidth属性所指定的值;
  2. 若android:minWidth没指定,则默认为0
  • 如果View设置了背景,View的宽度为mMinWidth和mBackground.getMinimumWidth()中的最大值

那么,mBackground.getMinimumWidth()的大小具体是指多少呢?接下来继续看getMinimumWidth()的源码分析:

public int getMinimumWidth() {
    final int intrinsicWidth = getIntrinsicWidth();
    //返回背景图Drawable的原始宽度
    return intrinsicWidth > 0 ? intrinsicWidth :0 ;
}

由源码可知:mBackground.getMinimumWidth()的大小具体是指背景图Drawable的原始宽度。

  1. 若无原始宽度,则为0;
  2. 那么Drawable什么情况下有原始宽度?如:ShapeDrawable没有,但BitmapDrawable有。

总结:
对于getDefaultSize()计算View的宽/高值的逻辑如下:

计算View的宽/高值的逻辑

至此,单一View的宽/高值已经测量完成,即对于单一View的measure过程已经完成。

3.1.6 总结

  • 对于单一View的measure过程,如下:
单一View的measure过程
  • 对于每个方法的总结如下:
方法总结

3.2 ViewGroup的measure过程

  • 应用场景
    自定义ViewGroup一般是利用现有的组件根据特定的布局方式来组成新的组件,大多继承自ViewGroup或各种Layout(含有子View)。

如:底部导航条中的条目,一般都是上图标(ImageView)、下文字(TextView),那么这两个就可以用自定义ViewGroup组合成为一个Veiw,提供两个属性分别用来设置文字和图片,使用起来会更加方便。


Paste_Image.png
  • 原理
    通过遍历所有的子View进行子View的测量,然后将所有子View的尺寸进行合并,最终得到ViewGroup父视图的测量值。
Paste_Image.png

这样自上而下、一层层地传递下去,直到完成整个View树的measure()过程

  • ViewGroup的measure过程
    如下图所示:


    ViewGroup的Measure过程

下面我将一个个方法进行详细分析。

3.2.1 measureChildren()

  • 和单一View的measure过程是从measure()开始不同,ViewGroup的measure过程是从measureChildren()开始的。
  1. ViewGroup是一个抽象类,自身没有重写View的onMeasure();
  2. 若需要进行自定义View,则需要对onMeasure()进行重写,下文会提到
  • 作用:遍历子View并调用measureChild()进行下一步测量
  • 源码分析如下:

protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
//参数说明:父视图的测量规格(MeasureSpec)

        final int size = mChildrenCount;
        final View[] children = mChildren;

        //遍历所有的子view
        for (int i = 0; i < size; ++i) {
            final View child = children[i];
        //如果View的状态不是GONE就调用measureChild()去进行下一步的测量
            if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
                measureChild(child, widthMeasureSpec, heightMeasureSpec);
            }
        }
    }

下面,我们继续看measureChild()的分析。

3.2.2 measureChild()

  • 作用:计算单个子View的MeasureSpec;调用子View的measure()进行每个子View最后的宽 / 高测量

  • 源码分析如下:

protected void measureChild(View child, int parentWidthMeasureSpec,
            int parentHeightMeasureSpec) {

        // 获取子视图的布局参数
        final LayoutParams lp = child.getLayoutParams();

        // 调用getChildMeasureSpec(),根据父视图的MeasureSpec & 布局参数LayoutParams,计算单个子View的MeasureSpec
         // getChildMeasureSpec()请回看上面的解析
        final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,// 获取 ChildView 的 widthMeasureSpec
                mPaddingLeft + mPaddingRight, lp.width);
        final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,// 获取 ChildView 的 heightMeasureSpec
                mPaddingTop + mPaddingBottom, lp.height);

        // 将计算好的子View的MeasureSpec值传入measure(),进行最后的测量
        child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
    }

下面,我们继续看measure()的分析。

3.2.3 measure()

  • 作用:基本测量逻辑的判断;调用onMeasure()

与单一View measure过程中讲的measure()是一致的。

  • 源码分析如下:
public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
    ...
    int cacheIndex = (mPrivateFlags & PFLAG_FORCE_LAYOUT) == PFLAG_FORCE_LAYOUT ? -1 :
            mMeasureCache.indexOfKey(key);
    if (cacheIndex < 0 || sIgnoreMeasureCache) {

        // 调用onMeasure()计算视图大小
        onMeasure(widthMeasureSpec, heightMeasureSpec);
        mPrivateFlags3 &= ~PFLAG3_MEASURE_NEEDED_BEFORE_LAYOUT;
    } else {
        ...

}

下面,我们继续看onMeasure()的分析。

3.2.4 onMeasure()

  • 首先明确:ViewGroup是一个抽象类,自身没有重写View的onMeasure();
  • 问:为什么ViewGroup的measure过程不像单一View的measure过程那样对onMeasure()做统一的实现?(如下代码)
//单一View中的onMeasure统一实现
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  

//setMeasuredDimension()  用于获得View宽/高的测量值
//这两个参数是通过getDefaultSize()获得的
//下面继续看setMeasuredDimension()  源码
setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),  
           getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));  
}
  • 答:因为不同的ViewGroup子类(LinearLayout、RelativeLayout或自定义ViewGroup子类等)具备不同的布局特性,这导致他们子View的测量方法各有不同;而onMeasure()的作用在于测量View的宽/高值。
    因此,ViewGroup无法对onMeasure()作统一实现。

在自定义View中,关键在于根据你的自定义View去复写onMeasure()从而实现你的子View测量逻辑。复写onMeasure()的模板如下:


//根据自身的测量逻辑复写onMeasure()

@Override
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {  

      //定义存放测量后的View宽/高的变量
      int widthMeasure ;
      int heightMeasure ;


      //定义测量方法
      void measureCarson{

       //定义测量的具体逻辑

                }

//记得!最后使用setMeasuredDimension()  存储测量后View宽/高的值
setMeasuredDimension(widthMeasure,  heightMeasure);  
}

//最终setMeasuredDimension()会像上面单一View的measure过程中提到的,存储好测量后View宽/高的值并进行传递。

上面说的便是单一View的measure过程与ViewGroup过程最大的不同:单一View measure过程的onMeasure()具有统一实现,而ViewGroup则没有。

注:其实,在单一View measure过程中,getDefaultSize()只是简单的测量了宽高值,在实际使用时有时需要进行更精细的测量。所以有时候也需要重写onMeasure()。

  • 至此,ViewGroup的measure过程已经分析完毕。

3.2.5 总结

  • 对于ViewGroup的measure过程,如下:


    ViewGroup的measure过程
  • 对于每个方法的总结如下:

方法总结

为了让大家更好地理解ViewGroup的measure过程(特别是复写onMeasure()),所以接下来,我将用ViewGroup的子类LinearLayout来分析下ViewGroup的measure过程。

3.2.6 实例解析(LinearLayout)

LinearLayout的measure流程

在上述流程中,前4个方法的实现与上面所说是一样的,这里不作过多阐述,直接进入LinearLayout复写的onMeasure()代码分析:

// 详细分析请看代码注释
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {

    //根据不同的布局属性进行不同的计算
    if (mOrientation == VERTICAL) {
        measureVertical(widthMeasureSpec, heightMeasureSpec);
    } else {
        measureHorizontal(widthMeasureSpec, heightMeasureSpec);
    }
}

    // 此处只选垂直方向的测量过程,即measureVertical()
    // 该方法代码非常多,此处仅分析重要的逻辑

void measureVertical(int widthMeasureSpec, int heightMeasureSpec) {

    // 获取垂直方向上的子View个数
    final int count = getVirtualChildCount();

    // 遍历子View获取其高度,并记录下子View中最高的高度数值
    for (int i = 0; i < count; ++i) {
        final View child = getVirtualChildAt(i);

        // 子View不可见,直接跳过该View的measure过程,getChildrenSkipCount()返回值恒为0
        // 注:若view的可见属性设置为VIEW.INVISIBLE,还是会计算该view大小
        if (child.getVisibility() == View.GONE) {
           i += getChildrenSkipCount(child, i);
           continue;
        }

        // 记录子View是否有weight属性设置,用于后面判断是否需要二次measure
        totalWeight += lp.weight;

        if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {
            // 如果LinearLayout的specMode为EXACTLY且子View设置了weight属性,在这里会跳过子View的measure过程
            // 同时标记skippedMeasure属性为true,后面会根据该属性决定是否进行第二次measure
          // 若LinearLayout的子View设置了weight,会进行两次measure计算,比较耗时
            // 这就是为什么LinearLayout的子View需要使用weight属性时候,最好替换成RelativeLayout布局
          
            final int totalLength = mTotalLength;
            mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
            skippedMeasure = true;
        } else {
            int oldHeight = Integer.MIN_VALUE;

            // 在该方法内部,最终会调用到子View的measure方法,计算出子View的大小
           //  即遍历子View并调用measure(),形成递归
            measureChildBeforeLayout(
                   child, i, widthMeasureSpec, 0, heightMeasureSpec,
                   totalWeight == 0 ? mTotalLength : 0);

            if (oldHeight != Integer.MIN_VALUE) {
               lp.height = oldHeight;
            }

            
            final int childHeight = child.getMeasuredHeight();
            // mTotalLength用于存储LinearLayout在竖直方向的高度
            final int totalLength = mTotalLength;
            //每测量一个子View的高度, mTotalLength就会增加
            mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
                   lp.bottomMargin + getNextLocationOffset(child));
    }

    // 记录LinearLayout占用的总高度
    // 即除了子View的高度,还有本身的padding属性值
    mTotalLength += mPaddingTop + mPaddingBottom;
    int heightSize = mTotalLength;


// 最终调用setMeasuredDimension()  设置测量后View宽/高的值
setMeasureDimension(resolveSizeAndState(maxWidth,width))


  ...
}

至此,自定义View的中最重要、最复杂的measure过程已经讲完了。

4. 总结


请点赞!因为你们的赞同/鼓励是我写作的最大动力!

相关文章阅读
Android开发:最全面、最易懂的Android屏幕适配解决方案
Android开发:史上最全的Android消息推送解决方案
Android开发:最全面、最易懂的Webview详解
Android开发:JSON简介及最全面解析方法!
Android四大组件:Service服务史上最全面解析
Android四大组件:BroadcastReceiver史上最全面解析


欢迎关注Carson_Ho的简书!

不定期分享关于安卓开发的干货,追求短、平、快,但却不缺深度

最易懂的自定义View
Web note ad 1