booknote

安卓开发艺术探索-View的工作原理（一）-笔记

安卓开发艺术探索笔记

View的工作原理

初始ViewRoot和DecorView

  • ViewRoot对应的实体类是ViewRootImpl类，它时连接WindowManager和DecorView的纽带

  • View的三大流程都是通过ViewRoot完成的

  • 在ActivityThread中，当Activity对象被创建后，会将DecorView添加到Window中，同时会创建ViewRootImpl对象，并将ViewImpl对象和DecorView建立关联：

1
2
root = new ViewRootImpl(view.getContext, display);
root.setView(view, wparams, panelParentView);

  • View的绘制流程是从ViewRoot的performTraversals中开始的，它经过measure，layout，draw三个过程。

  • performTraversals大致流程：

childLayoutParams\parentSpecMode ECACTLY AT_MOST UNSPECIFIED
dp/px EXACTLY/childSize EXACTLY/childSize EXACTLY/childSize
match_parent EXACTLY/parentSize AT_MOST/parentSize UNSPECIFIED/0
wrap_content AT_MOST/parentSize AT_MOST/parentSize UNSPECIFIED/0

  • DecorView作为顶级View，本质是一个LinearLayout，该layout中一般情况下包含标题栏和内容栏。

  • 在Activity中，我们setContentView所设置的布局，其实就是被加到内容栏中的

理解MeasureSpec

MeasureSpec很大程度上决定了一个View的尺寸规格，之所以说很大程度，其实时因为在这个过程中还受父容器的影响，父容器回影响View的MeasureSpec的创建。

  • MeasureSpec代表一个32位的int值，高2位代表SpecMode：测量模式，低30位表示SpecSize：在某种模式下的测量规格。

  • 在下面的源码中，MeasureSpec将SpecMode和SpecSize打包成一个int值来避免过多对象内存的分配。为了方便操作提供了打包和解包的方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
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;
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);
        }

  • SpecMode有三类：

    • UNSPECIFIED：父容器不对View有限制，这种情况一般用于系统内部，表示一种测量的状态

    • EXACTLY：父容器已经检验出View所需要的大小，这个时候View的最终大小就是SpecSize所指定的值。它对应于LayoutParams中的match_parent和具体的数值这两种模式

    • AT_MOST:父容器指定了一个可用的大小，即SpecSize，View的大小不能大于这个值。它对应于LayoutParams中的wrap_content

  • MeasureSpec和LayoutParams的对应关系

    • 正常情况下我们使用View指定MeasureSpec，尽管如此，但是我们可以给View设置LayoutParams。在View测量的时候，系统会将LayoutParams在父容器的约束下转为对应的MeasureSpec，然后再根据这个MeasureSpec来确定View的宽高

    • LayoutParams需要和父容器一起才能决定View的MeasureSpec，从而进一步决定View的宽高

    • 对于顶级View（DecorView）和普通View来说，MeasureSpec的转换过程略有不同。对于DecorView，其MeasureSpec由窗口的尺寸和其自身的LayoutParams来共同确定

    • DecorView的MeasureSpec创建过程是在ViewRootImpl中的measureHierarchy方法创建的：

    1
    2
    3
     childWidthMeasureSpec = getRootMeasureSpec(desiredWindowWidth, lp.width);
    childHeightMeasureSpec = getRootMeasureSpec(desiredWindowHeight, lp.height);
    performMeasure(childWidthMeasureSpec, childHeightMeasureSpec);

  • 接着看看getRootMeasureSpec：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    <pre style="background-color:#21282d;color:#e0e2e4;font-family:'Courier New';font-size:15.0pt;">private static int getRootMeasureSpec(int windowSize, int rootDimension) {
     int measureSpec;
     switch (rootDimension) {
     case ViewGroup.LayoutParams.MATCH_PARENT:
     // Window can't resize. Force root view to be windowSize.
     measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
     break;
     case ViewGroup.LayoutParams.WRAP_CONTENT:
     // Window can resize. Set max size for root view.
     measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
     break;
     default:
     // Window wants to be an exact size. Force root view to be that size.
     measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
     break;
    }  return measureSpec;</pre>

  • LayoutParams.MATCH_PARENT:精确模式，大小就是窗口的大小；

  • LayoutParams.WRAP_CONTENT:最大模式，大小不定，但是不能超过窗口的大小

  • 固定大小：精确模式，大小为LayoutParams中指定的大小。

  • 对于普通View来说（指的时我们布局中的View），它的measure过程是由ViewGroup传递过来的，下面看看ViewGroup中的measureChildWithMargins：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
protected void measureChildWithMargins(View child,
           int parentWidthMeasureSpec, int widthUsed,
           int parentHeightMeasureSpec, int heightUsed) {
       final MarginLayoutParams lp = (MarginLayoutParams) child.getLayoutParams();
       final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
               mPaddingLeft + mPaddingRight + lp.leftMargin + lp.rightMargin
                       + widthUsed, lp.width);
       final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
               mPaddingTop + mPaddingBottom + lp.topMargin + lp.bottomMargin
                       + heightUsed, lp.height);
       child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
   }
  • 从上面代码来看，子元素的MeasureSpec的创建与父容器的MeasureSpec和子元素本身的LayoutParams有关，此外还有与View的margin和padding有关，下面再看看ViewGroup的getChildMeasureSpec：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
public static int getChildMeasureSpec(int spec, int padding, int childDimension) {
      int specMode = MeasureSpec.getMode(spec);
      int specSize = MeasureSpec.getSize(spec);
      int size = Math.max(0, specSize - padding);
      int resultSize = 0;
      int resultMode = 0;
      switch (specMode) {
      // Parent has imposed an exact size on us
      case MeasureSpec.EXACTLY:
          if (childDimension >= 0) {
              resultSize = childDimension;
              resultMode = MeasureSpec.EXACTLY;
          } else if (childDimension == LayoutParams.MATCH_PARENT) {
              // Child wants to be our size. So be it.
              resultSize = size;
              resultMode = MeasureSpec.EXACTLY;
          } else if (childDimension == LayoutParams.WRAP_CONTENT) {
              // Child wants to determine its own size. It can't be
              // bigger than us.
              resultSize = size;
              resultMode = MeasureSpec.AT_MOST;
          }
          break;
      // Parent has imposed a maximum size on us
      case MeasureSpec.AT_MOST:
          if (childDimension >= 0) {
              // Child wants a specific size... so be it
              resultSize = childDimension;
              resultMode = MeasureSpec.EXACTLY;
          } else if (childDimension == LayoutParams.MATCH_PARENT) {
              // Child wants to be our size, but our size is not fixed.
              // Constrain child to not be bigger than us.
              resultSize = size;
              resultMode = MeasureSpec.AT_MOST;
          } else if (childDimension == LayoutParams.WRAP_CONTENT) {
              // Child wants to determine its own size. It can't be
              // bigger than us.
              resultSize = size;
              resultMode = MeasureSpec.AT_MOST;
          }
          break;
      // Parent asked to see how big we want to be
      case MeasureSpec.UNSPECIFIED:
          if (childDimension >= 0) {
              // Child wants a specific size... let him have it
              resultSize = childDimension;
              resultMode = MeasureSpec.EXACTLY;
          } else if (childDimension == LayoutParams.MATCH_PARENT) {
              // Child wants to be our size... find out how big it should
              // be
              resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
              resultMode = MeasureSpec.UNSPECIFIED;
          } else if (childDimension == LayoutParams.WRAP_CONTENT) {
              // Child wants to determine its own size.... find out how
              // big it should be
              resultSize = View.sUseZeroUnspecifiedMeasureSpec ? 0 : size;
              resultMode = MeasureSpec.UNSPECIFIED;
          }
          break;
      }
      return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
  }

  • 从上面的方法来看，它的主要作用时结合父容器发MeasureSpec同时结合View本身的LayoutParams来确定子元素的MeasureSpec，参数中的padding指的是父容器中已被占用的空间大小。

  • 下面的表是对getChildMeasureSpec的工作原理的梳理，其中parentSize指的是父容器中目前可以使用的大小。

View的工作过程

View的measure过程：
  • measure方法时一个final方法，则意味着不能重写该方法，在该方法中会调用View的onMeasure方法（真正测量的方法）， 下面我们看看onMeasure的实现：
1
2
3
4
protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
  setMeasuredDimension(getDefaultSize(getSuggestedMinimumWidth(), widthMeasureSpec),
  getDefaultSize(getSuggestedMinimumHeight(), heightMeasureSpec));
}

setMeasureDimension方法中会设置View的宽高的测量值，因此，我们来看看getDefaultSize方法：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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;
}

对于我我们来说，我们只看AT_MOST和EXACTLY这两种情况。简单的理解，其实getDefaultSize返回的大小就是measureSpec中的specSize，这个specSize就是测量后View的大小，这里说时是测量后，是因为View的最终大小是在layout阶段确定的，除了特殊情况外，View的测量大小和最终大小是相等的。

  • 对于UNSPECIFIED来说，一般用于系统内部测量，在这种情况下，View的大小为getDefaultSize第一个参数size，即分别为getSuggestedMinimumWidth/Height：
1
2
3
4
protected int getSuggestedMinimumHeight() {
  return (mBackground == null) ? mMinHeight : max(mMinHeight, mBackground.getMinimumHeight());
}

如果View没有设置背景，那么View的高度为mMinHeight，而该属性对应于aandroid：minWidth，如果这个属性不指定的话，默认为0。如果设置了背景则返回minHeight和背景的最小高度中的最大值

  • 从getDefaultSize的实现来看，我们可以得到以下小结：

    • 直接继承View的自定义控件需要重写onMeasure方法设置wrap_content时的自身大小，否则在布局中使用就相当于match_parent

    • 通过之前分析，如果View在布局中被设为wrap_content的话，它的specMode时AT_MOST模式，此时它的宽高等于specSize，而View的specSize是parentSize，parentSize是父容器目前所剩余的空间大小。这样这种效果就相当于match_parent

    • 解决方法：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
     super.onMeasure(widthMeasureSpec, heightMeasureSpec);
     int widthSpecMode = View.MeasureSpec.getMode((widthMeasureSpec));
     int widthSpecSize = View.MeasureSpec.getMode((widthMeasureSpec));
     int heightSpecMode = View.MeasureSpec.getMode((heightMeasureSpec));
     int heightSpecSize = View.MeasureSpec.getMode((heightMeasureSpec));
     if(widthSpecMode == View.MeasureSpec.AT_MOST && heightSpecMode == View.MeasureSpec.AT_MOST) {
     setMeasureDimension(mWidth, mHeight);
    } else if(widthSpecMode == View.MeasureSpec.AT_MOST) {
     setMeasureDimension(mWidth, heightSpecSize);
    } else if(heightSpecMode == View.MeasureSpec.AT_MOST){
     setMeasureDimension(widthSpecSize, mHeight);
    }}

对于wrap_content的情形，我们直接设置我们默认的大小就可以

ViewGroup的measure过程：

  • ViewGroup除了测量自身的大小外，还会遍历所有的子元素的measure方法，各个子元素再递归去执行这个过程

  • ViewGroup是一个抽象类，因此它没有重写View的onMeasure方法，但是提供了一个measureChildren的方法：

1
2
3
4
5
6
7
8
9
10
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在meaure的时候，会对每个子元素进行measure，下面来看看measureChild：

1
2
3
4
5
6
7
8
9
10
11
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);
   }

meaureChild中，就是取出子元素的LayoutParams，然后通过getChildMeasureSpec来创建子元素的MeasureSpec。将MeaureSpec直接传递给View的meaure进行测量。

  • 我们知道ViewGroup是一个抽象类，并没有实现具体的测量过程，所以，我们来看看它子类中的实现，下面用LinearLayout来当例子

  • 首先先来看看其onMeasure方法：

1
2
3
4
5
6
7
8
@Override
   protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
       if (mOrientation == VERTICAL) {
           measureVertical(widthMeasureSpec, heightMeasureSpec);
       } else {
           measureHorizontal(widthMeasureSpec, heightMeasureSpec);
       }
   }

上面代码中，根据不同的布局方向来测量，我们选择来看竖直方向的测量过程中的一段代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
// See how tall everyone is. Also remember max width.
      for (int i = 0; i < count; ++i) {
          final View child = getVirtualChildAt(i);
          if (child == null) {
              mTotalLength += measureNullChild(i);
              continue;
          }
          if (child.getVisibility() == View.GONE) {
             i += getChildrenSkipCount(child, i);
             continue;
          }
          if (hasDividerBeforeChildAt(i)) {
              mTotalLength += mDividerHeight;
          }
          LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
          totalWeight += lp.weight;
          
          if (heightMode == MeasureSpec.EXACTLY && lp.height == 0 && lp.weight > 0) {
              // Optimization: don't bother measuring children who are going to use
              // leftover space. These views will get measured again down below if
              // there is any leftover space.
              final int totalLength = mTotalLength;
              mTotalLength = Math.max(totalLength, totalLength + lp.topMargin + lp.bottomMargin);
              skippedMeasure = true;
          } else {
              int oldHeight = Integer.MIN_VALUE;
              if (lp.height == 0 && lp.weight > 0) {
                  // heightMode is either UNSPECIFIED or AT_MOST, and this
                  // child wanted to stretch to fill available space.
                  // Translate that to WRAP_CONTENT so that it does not end up
                  // with a height of 0
                  oldHeight = 0;
                  lp.height = LayoutParams.WRAP_CONTENT;
              }
              // Determine how big this child would like to be. If this or
              // previous children have given a weight, then we allow it to
              // use all available space (and we will shrink things later
              // if needed).
              measureChildBeforeLayout(
                     child, i, widthMeasureSpec, 0, heightMeasureSpec,
                     totalWeight == 0 ? mTotalLength : 0);
              if (oldHeight != Integer.MIN_VALUE) {
                 lp.height = oldHeight;
              }
              final int childHeight = child.getMeasuredHeight();
              final int totalLength = mTotalLength;
              mTotalLength = Math.max(totalLength, totalLength + childHeight + lp.topMargin +
                     lp.bottomMargin + getNextLocationOffset(child));

系统会遍历每个子元素，并且对每个子元素进行measureChildBeforeLayout，这个方法会调用子元素的measure，这样就开始了measure过程，并且系统会通过mToatalLength这个变量来保存LinearLayout在竖直方向上的初步高度，当测量完子元素时，LinearLauout会测量自己的大小：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
// 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;
       
       // Either expand children with weight to take up available space or
       // shrink them if they extend beyond our current bounds. If we skipped
       // measurement on any children, we need to measure them now.
       int delta = heightSize - mTotalLength;
       if (skippedMeasure || delta != 0 && totalWeight > 0.0f) {
           float weightSum = mWeightSum > 0.0f ? mWeightSum : totalWeight;
           mTotalLength = 0;
           for (int i = 0; i < count; ++i) {
               final View child = getVirtualChildAt(i);
               
               if (child.getVisibility() == View.GONE) {
                   continue;
               }
               
               LinearLayout.LayoutParams lp = (LinearLayout.LayoutParams) child.getLayoutParams();
               
               float childExtra = lp.weight;
               if (childExtra > 0) {
                   // Child said it could absorb extra space -- give him his share
                   int share = (int) (childExtra * delta / weightSum);
                   weightSum -= childExtra;
                   delta -= share;
                   final int childWidthMeasureSpec = getChildMeasureSpec(widthMeasureSpec,
                           mPaddingLeft + mPaddingRight +
                                   lp.leftMargin + lp.rightMargin, lp.width);
                   // TODO: Use a field like lp.isMeasured to figure out if this
                   // child has been previously measured
                   if ((lp.height != 0) || (heightMode != MeasureSpec.EXACTLY)) {
                       // child was measured once already above...
                       // base new measurement on stored values
                       int childHeight = child.getMeasuredHeight() + share;
                       if (childHeight < 0) {
                           childHeight = 0;
                       }
                       
                       child.measure(childWidthMeasureSpec,
                               MeasureSpec.makeMeasureSpec(childHeight, MeasureSpec.EXACTLY));
                   } else {
                       // child was skipped in the loop above.
                       // Measure for this first time here      
                       child.measure(childWidthMeasureSpec,
                               MeasureSpec.makeMeasureSpec(share > 0 ? share : 0,
                                       MeasureSpec.EXACTLY));
                   }
                   // Child may now not fit in vertical dimension.
                   childState = combineMeasuredStates(childState, child.getMeasuredState()
                           & (MEASURED_STATE_MASK>>MEASURED_HEIGHT_STATE_SHIFT));
               }
               final int margin =  lp.leftMargin + lp.rightMargin;
               final int measuredWidth = child.getMeasuredWidth() + margin;
               maxWidth = Math.max(maxWidth, measuredWidth);
               boolean matchWidthLocally = widthMode != MeasureSpec.EXACTLY &&
                       lp.width == LayoutParams.MATCH_PARENT;
               alternativeMaxWidth = Math.max(alternativeMaxWidth,
                       matchWidthLocally ? margin : measuredWidth);
               allFillParent = allFillParent && lp.width == LayoutParams.MATCH_PARENT;
               final int totalLength = mTotalLength;
               mTotalLength = Math.max(totalLength, totalLength + child.getMeasuredHeight() +
                       lp.topMargin + lp.bottomMargin + getNextLocationOffset(child));
           }
           // Add in our padding
           mTotalLength += mPaddingTop + mPaddingBottom;
           // TODO: Should we recompute the heightSpec based on the new total length?
       } else {
           alternativeMaxWidth = Math.max(alternativeMaxWidth,
                                          weightedMaxWidth);
           // We have no limit, so make all weighted views as tall as the largest child.
           // Children will have already been measured once.
           if (useLargestChild && heightMode != MeasureSpec.EXACTLY) {
               for (int i = 0; i < count; i++) {
                   final View child = getVirtualChildAt(i);
                   if (child == null || child.getVisibility() == View.GONE) {
                       continue;
                   }
                   final LinearLayout.LayoutParams lp =
                           (LinearLayout.LayoutParams) child.getLayoutParams();
                   float childExtra = lp.weight;
                   if (childExtra > 0) {
                       child.measure(
                               MeasureSpec.makeMeasureSpec(child.getMeasuredWidth(),
                                       MeasureSpec.EXACTLY),
                               MeasureSpec.makeMeasureSpec(largestChildHeight,
                                       MeasureSpec.EXACTLY));
                   }
               }
           }
       }
       if (!allFillParent && widthMode != MeasureSpec.EXACTLY) {
           maxWidth = alternativeMaxWidth;
       }
       
       maxWidth += mPaddingLeft + mPaddingRight;
       // Check against our minimum width
       maxWidth = Math.max(maxWidth, getSuggestedMinimumWidth());
       
       setMeasuredDimension(resolveSizeAndState(maxWidth, widthMeasureSpec, childState),
               heightSizeAndState);

  • 分析到这里算是把measure分析完了，下面我们来看看需要注意的一些地方：

    • 如果要获取View的测量宽高或者最终宽高的话，比较好的做法是在onLayout中获取，因为在某些极端的情况下，measure可能会被多次调用，这样在onMeasure获取的宽高就不准确

  • 四种方法中的三种解决Activity启动时获取View的宽高

    • 在onWindowFocusChanged中获取： 该方法会在窗口的得到和失去焦点的时候被调用。代码如下：

      1
      2
      3
      4
      5
      6
      7
      public void onWindowFocusChanged(boolean hasFocus) {
          super.onWindowFocusChanged(hasFocus);
          if(hasFocus) {
              int width = view.getMeasureWidth();
              int heigh = view.getMeasureHeight();
          }
      }

    • view.post(runnable):将一个runnable投递到消息队列尾部，等待Looper调用此runnable的时候，View已经初始化完成了。代码如下：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      protected void onStart() {
              super.onStart();
              view.post(new Runnable() {
                  @Override
                  public void run() {
                      int width = view.getMeasureWidth();
                      int height = view.getMeasureHeight();
                  }
              });
          }

    • ViewTreeObserver：使用其中的OnGlobalLayoutListener这个接口，当View状态或者View树内部的View可见性发现改变时，onGlobalLayout会被回调。代码如下：

      1
      2
      3
      4
      5
      6
      7
      8
      9
      10
      11
      12
      13
      protected void onStart() {
              super.onStart();
              ViewTreeObserver observer = view.getViewTreeObserver();
              observer.addOnGlobalLayoutListener(new ViewTreeObserver.OnGlobalLayoutListener() {
                  @Override
                  public void onGlobalLayout() {
                      view.getViewTreeObserver().removeGlobalOnLayoutListener(this);
                      int width = view.getMeasureWidth();
                      int height = view.getMeasureHeight();
                  }
              });
          }
layout过程
  • 先看看View的layout方法：
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    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;
        }

在layout中首先会通过setFrame方法来设定View的四个顶点位置，即初始化mLeft， mRight， mTop， mBottom，view的顶点确定后，那么View在ViewGroup中的位置也相应的确定；接着调用onLayout的方法，该方法的具体实现是在ViewGroup的子类中，我们来看看LinearLayout中是怎么实现的：

1
2
3
4
5
6
7
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);
       }
   }

  • 我们只拿竖直方向上的来分析：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
void layoutVertical(int left, int top, int right, int bottom) {
        final int paddingLeft = mPaddingLeft;
        int childTop;
        int childLeft;
        
        // Where right end of child should go
        final int width = right - left;
        int childRight = width - mPaddingRight;
        
        // Space available for child
        int childSpace = width - paddingLeft - mPaddingRight;
        
        final int count = getVirtualChildCount();
        final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
        final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
        switch (majorGravity) {
           case Gravity.BOTTOM:
               // mTotalLength contains the padding already
               childTop = mPaddingTop + bottom - top - mTotalLength;
               break;
               // mTotalLength contains the padding already
           case Gravity.CENTER_VERTICAL:
               childTop = mPaddingTop + (bottom - top - mTotalLength) / 2;
               break;
           case Gravity.TOP:
           default:
               childTop = mPaddingTop;
               break;
        }
        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();
                
                int gravity = lp.gravity;
                if (gravity < 0) {
                    gravity = minorGravity;
                }
                final int layoutDirection = getLayoutDirection();
                final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
                switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
                    case Gravity.CENTER_HORIZONTAL:
                        childLeft = paddingLeft + ((childSpace - childWidth) / 2)
                                + lp.leftMargin - lp.rightMargin;
                        break;
                    case Gravity.RIGHT:
                        childLeft = childRight - childWidth - lp.rightMargin;
                        break;
                    case Gravity.LEFT:
                    default:
                        childLeft = paddingLeft + lp.leftMargin;
                        break;
                }
                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来为子元素指定相应的位置，该方法中调用了子元素的layout方法，这样就实现了View的一层层测量。

  • 分析完了layout，我们来看看哪些需要注意的地方：

    • View的getMeasureWidth和getWidth有什么区别：我们首先来看看getWidth的实现：
      1
      2
      3
      4
      @ViewDebug.ExportedProperty(category = "layout")
        public final int getWidth() {
            return mRight - mLeft;
        }

    在View的默认实现过程中，View的测量宽高和最终宽高时相等的，只不过两者的赋值时机不同而已，测量宽高是在measure，而最终宽高是在layout。

draw过程：

  • View的绘制过程遵循下面这几步：

    • 绘制自己的背景（bakcground.draw(canvas)）
    • 绘制自己（onDraw）
    • 绘制children（dispatchDraw）
    • 绘制装饰（onDrawScrollBars）

  • 上面的这个步骤可以在draw源码中看出来：

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    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来实现的，该方法回遍历所有子元素的draw（具体的实现实在ViewGroup的子类中），这样draw就可以一层层传递下去。View中的一个特殊方法：setWillNotDraw:

1
2
3
public void setWillNotDraw(boolean willNotDraw) {
       setFlags(willNotDraw ? WILL_NOT_DRAW : 0, DRAW_MASK);
   }

如果一个View不需要绘制任何内容的话，我们就可以把这个标记设为true。默认情况下View没有启动这个标志，但是ViewGroup会默认启动。如果我们自定义控件的时候需要继承ViewGroup时，我们就可以开启这个标记来便于系统的后续优化。

以上的笔记来源于安卓开发艺术探索

分享到