Android自定义控件之测量,布局,绘制过程

发表于 | 分类于

控件的测量,布局,绘制过程

目录:
    - 测量
        1. 测量之MeasureSpec与LayoutParams
        2. View # onMeasure(int,int)
        3. ViewGroup # measureChildren()
        4. 测量某个View的宽高的方式
    - 布局
        1. View # layout(int,int,int,int)
        2. View # onLayout()
            1. LinearLayout
            2. RelativeLayout
            3. FrameLayout
    - 绘制
        View # draw(Canvas)
            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) 绘制附加内容

参考自:
        1. 《 Android 开发艺术探索 》 : Page 174
        2. Android开发之自定义控件(二)---onLayout详解 : http://blog.csdn.net/dmk877/article/details/49632959

测量

1. 测量之MeasureSpec与LayoutParams

WindowManager$LayoutParams 友情链接 点击此处

《 Android 开发艺术探索 》
对于 DecorView ，其 MeasureSpec 由窗口的尺寸和其自身的 LayoutParams 来共同决定;
对于普通 View，其 MeasureSpec 由 父容器 的MeasureSpec和自身的 LayoutParams 来共同决定。

parentSize指父容器当前剩余的空间大小。

MeasureSpec

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

//ViewGroup.java

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

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;
       }
       //noinspection ResourceType
       return MeasureSpec.makeMeasureSpec(resultSize, resultMode);
   }

2. View # onMeasure(int,int)

  1. MeasureSpec.getSize(measureSpec) 就是View测量后的大小,在layout()阶段确定;
  2. getSuggestedMinimumWidth/Height()设置默认大小:
    • 当未设置背景时,由android:minWidth/minHeight决定;
    • 当已设置背景时,由背景Drawable原始大小最小值与android:minWidth/minHeight决定;
  3. 依照上表, 当自定义View 直接继承自View重写onMeasure()并设置wrap_content时,相当于直接填充了父容器剩余所有空间match_parent。可以通过onMeasure()设置宽高默认值解决 
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
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        int widthMode = MeasureSpec.getMode(widthMeasureSpec);
        int widthSize = MeasureSpec.getSize(widthMeasureSpec);
        int heightMode = MeasureSpec.getMode(heightMeasureSpec);
        int heightSize = MeasureSpec.getSize(heightMeasureSpec);
		if( widthMode==MeasureSpec.AT_MOST 
				&& heightMode==MeasureSpec.AT_MOST){
			setMeasureDimension(mWidth , mHeight);  
		}else if(widthMode==MeasureSpec.AT_MOST){
			setMeasureDimension(mWidth , heightSize);
		}else if(heightMode==MeasureSpec.AT_MOST){
			setMeasureDimension(widthSize , mHeight);
		}
    }	  

```	


```java
	/*
     * @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));
    }

	/**
	 * 设置默认值
     * 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;
    }

3. ViewGroup # measureChildren()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

  /**
* ViewGroup.java 
* 循环创建子元素的测量算子和子元素的LayoutParams通过子元素的measure()进行测量;
   * Ask all of the children of this view to measure themselves, taking into
   * account both the MeasureSpec requirements for this view and its padding.
   * We skip children that are in the GONE state The heavy lifting is done in
   * getChildMeasureSpec.
   *
   * @param widthMeasureSpec The width requirements for this view
   * @param heightMeasureSpec The height requirements for this view
   */
  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);
          }
      }
  }

4. 测量某个View的宽高的方式

  1. Activity/View # onWindowFocusChanged(boolean)

    1
    2
    3
    4
    5
    6
    7
    8

    @Override
    public void onWindowFocusChanged(boolean hasWindowFocus) {
        super.onWindowFocusChanged(hasWindowFocus);
        if (hasWindowFocus) {
            //measureLines();
        }
    }

  2. View # post(Runnable)

    1
    2
    3
    4
    5
    6
    7
    8
    9

    view.post(new Runnable() {

        @Override
        public void run() {
            view.getWidth(); // 获取宽度
            view.getHeight(); // 获取高度
        }
    });

  3. ViewTreeObserver

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    view.getViewTreeObserver().addOnGlobalLayoutListener(
            new ViewTreeObserver.OnGlobalLayoutListener() {

        @Override
        public void onGlobalLayout() {
            if (Build.VERSION.SDK_INT >= 16) {
                view.getViewTreeObserver()
                        .removeOnGlobalLayoutListener(this);
            }
            else {
                view.getViewTreeObserver()
                        .removeGlobalOnLayoutListener(this);
            }
            view.getWidth(); // 获取宽度
            view.getHeight(); // 获取高度
        }
    });

  4. View # measure(int,int)

    • 设置固定数值

      1
      2
      3
      4
      5
      6

      int width = View.MeasureSpec.makeMeasureSpec(100,
            		View.MeasureSpec.EXACTLY);
      int height = View.MeasureSpec.makeMeasureSpec(100,
              View.MeasureSpec.EXACTLY);
      view.measure(width, height);

    • wrap_content

      1
      2
      3
      4
      5
      6

      int width = View.MeasureSpec.makeMeasureSpec((1<<30)-1,
            		View.MeasureSpec.AT_MOST);
      int height = View.MeasureSpec.makeMeasureSpec((1<<30)-1,
              View.MeasureSpec.AT_MOST);
      view.measure(width, height);

布局Layout

《 Android 开发艺术探索 》: ViewGroup用来确定子元素的位置, layout()确定的是ViewGroup本身的位置,而onLayout()确定的是所有子控件的位置;.
onLayout详解 : 自定义控件的第二步onLayout即确定控件的位置

1. layout(int,int,int,int)

主要有以下步骤:

  1. View # setFrame(l, t, r, b)初始化mLeft、mRight、mTop、mBottom，设置当前View/ViewGroup的四个顶点的位置;
  2. View # onLayout(changed, l, t, r, b)确定子控件位置;
  3. 判断viewGroup.mOnLayoutChangeListeners的存在,并调用View $ OnLayoutChangeListener # onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB); 
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

/**
    * android-26/android.view.ViewGroup.java
    * ViewGroup # layout(int l, int t, int r, int b)
    */
   @Override
   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;
       }
   }

-----------------------------------------------------------------------

   /**
    * android-26/android.view.View.java
    * View # layout(int l, int t, int r, int b)
    * 
    * Assign a size and position to a view and all of its
    * descendants
    *
    * <p>This is the second phase of the layout mechanism.
    * (The first is measuring). In this phase, each parent calls
    * layout on all of its children to position them.
    * This is typically done using the child measurements
    * that were stored in the measure pass().</p>
    *
    * <p>Derived classes should not override this method.
    * Derived classes with children should override
    * onLayout. In that method, they should
    * call layout on each of their children.</p>
    *
    * @param l Left position, relative to parent
    * @param t Top position, relative to parent
    * @param r Right position, relative to parent
    * @param b Bottom position, relative to parent
    */
   @SuppressWarnings({"unchecked"})
   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);

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

2. View # onLayout()

以 LinearLayout、RelativeLayout、FrameLayout 为例,代码如下.

LinearLayout

以竖直方向为例,由于 LinearLayout特性,当设置竖直方向时,循环得到子控件的mTop(childTop,包含marginTop), 根据模拟测量宽高调用setChildFrame(...)间接调用child.layout(...)为子控件指定对应的位置; 然后继续叠加mTop.

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

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

/**
 * 以竖直方向为例
 * 
 * Position the children during a layout pass if the orientation of this
 * LinearLayout is set to {@link #VERTICAL}.
 *
 * @see #getOrientation()
 * @see #setOrientation(int)
 * @see #onLayout(boolean, int, int, int, int)
 * @param left
 * @param top
 * @param right
 * @param bottom
 */
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);
        }
    }
}
RelativeLayout

看似很简单的操作.更多的操作已经在初始化或在onMeasure()中已经完成,例如在onMeasure()中子控件之间的”toLeftOf“等相关view,已经存储入对应数组,并在循环中调用 applyHorizontalSizeRules(params, myWidth, rules) 对子控件位置信息进行设置;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@Override
   protected void onLayout(boolean changed, int l, int t, int r, int b) {
       //  The layout has actually already been performed and the positions
       //  cached.  Apply the cached values to the children.
       final int count = getChildCount();

       for (int i = 0; i < count; i++) {
           View child = getChildAt(i);
           if (child.getVisibility() != GONE) {
               RelativeLayout.LayoutParams st =
                       (RelativeLayout.LayoutParams) child.getLayoutParams();
               child.layout(st.mLeft, st.mTop, st.mRight, st.mBottom);
           }
       }
   }
FrameLayout
与RelativeLayout相比,多了权重的判断,少了关系判断. 
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

@Override
protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
    layoutChildren(left, top, right, bottom, false /* no force left gravity */);
}

void layoutChildren(int left, int top, int right, int bottom, boolean forceLeftGravity) {
    final int count = getChildCount();

    final int parentLeft = getPaddingLeftWithForeground();
    final int parentRight = right - left - getPaddingRightWithForeground();

    final int parentTop = getPaddingTopWithForeground();
    final int parentBottom = bottom - top - getPaddingBottomWithForeground();

    for (int i = 0; i < count; i++) {
        final View child = getChildAt(i);
        if (child.getVisibility() != GONE) {
            final LayoutParams lp = (LayoutParams) child.getLayoutParams();

            final int width = child.getMeasuredWidth();
            final int height = child.getMeasuredHeight();

            int childLeft;
            int childTop;

            int gravity = lp.gravity;
            if (gravity == -1) {
                gravity = DEFAULT_CHILD_GRAVITY;
            }

            final int layoutDirection = getLayoutDirection();
            final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
            final int verticalGravity = gravity & Gravity.VERTICAL_GRAVITY_MASK;

            switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
                case Gravity.CENTER_HORIZONTAL:
                    childLeft = parentLeft + (parentRight - parentLeft - width) / 2 +
                    lp.leftMargin - lp.rightMargin;
                    break;
                case Gravity.RIGHT:
                    if (!forceLeftGravity) {
                        childLeft = parentRight - width - lp.rightMargin;
                        break;
                    }
                case Gravity.LEFT:
                default:
                    childLeft = parentLeft + lp.leftMargin;
            }

            switch (verticalGravity) {
                case Gravity.TOP:
                    childTop = parentTop + lp.topMargin;
                    break;
                case Gravity.CENTER_VERTICAL:
                    childTop = parentTop + (parentBottom - parentTop - height) / 2 +
                    lp.topMargin - lp.bottomMargin;
                    break;
                case Gravity.BOTTOM:
                    childTop = parentBottom - height - lp.bottomMargin;
                    break;
                default:
                    childTop = parentTop + lp.topMargin;
            }

            child.layout(childLeft, childTop, childLeft + width, childTop + height);
        }
    }
}

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
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219

/**
    * Manually render this view (and all of its children) to the given Canvas.
    * The view must have already done a full layout before this function is
    * called.  When implementing a view, implement
    * {@link #onDraw(android.graphics.Canvas)} instead of overriding this method.
    * If you do need to override this method, call the superclass version.
    *
    * @param canvas The Canvas to which the View is rendered.
    */
   @CallSuper
   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);
       }
   }

1. 绘制背景

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

/**
 * /sdk/sources/android-26/android/view/View.java
 * 
 * Draws the background onto the specified canvas.
 * 
 * @param canvas Canvas on which to draw the background
 */
private void drawBackground(Canvas canvas) {
    final Drawable background = mBackground;
    if (background == null) {
        return;
    }

    setBackgroundBounds();

    // Attempt to use a display list if requested.
    if (canvas.isHardwareAccelerated() && mAttachInfo != null
            && mAttachInfo.mThreadedRenderer != null) {
        mBackgroundRenderNode = getDrawableRenderNode(background, mBackgroundRenderNode);

        final RenderNode renderNode = mBackgroundRenderNode;
        if (renderNode != null && renderNode.isValid()) {
            setBackgroundRenderNodeProperties(renderNode);
            ((DisplayListCanvas) canvas).drawRenderNode(renderNode);
            return;
        }
    }

    final int scrollX = mScrollX;
    final int scrollY = mScrollY;
    if ((scrollX | scrollY) == 0) {
        background.draw(canvas);
    } else {
        canvas.translate(scrollX, scrollY);
        background.draw(canvas);
        canvas.translate(-scrollX, -scrollY);
    }
}

2. 保存画布用于⑤绘制渐变

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

// /sdk/sources/android-26/android/view/View.java
.....
// 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);
      }
.....

3. 绘制内容

1
2
3
4
5
6
7
8
9

 /**
* // /sdk/sources/android-26/android/view/View.java
   * Implement this to do your drawing.
   *
   * @param canvas the canvas on which the background will be drawn
   */
  protected void onDraw(Canvas canvas) {
  }

4. 绘制子控件

步骤:

  1. 设置子控件的LayoutAnimation并设置动画监听;
  2. 判断clipToPadding,是否裁剪;
  3. 循环调用子控件绘制drawChild(canvas, child, drawingTime),保存裁剪信息;
  4. 判断动画是否结束并回调动画结束函数;
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

// /sdk/sources/android-26/android/view/ViewGroup.java
   @Override
   protected void dispatchDraw(Canvas canvas) {
       boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);
       final int childrenCount = mChildrenCount;
       final View[] children = mChildren;
       int flags = mGroupFlags;

       if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {
           final boolean buildCache = !isHardwareAccelerated();
           for (int i = 0; i < childrenCount; i++) {
               final View child = children[i];
               if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
                   final LayoutParams params = child.getLayoutParams();
                   attachLayoutAnimationParameters(child, params, i, childrenCount);
                   bindLayoutAnimation(child);
               }
           }

           final LayoutAnimationController controller = mLayoutAnimationController;
           if (controller.willOverlap()) {
               mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;
           }

           controller.start();

           mGroupFlags &= ~FLAG_RUN_ANIMATION;
           mGroupFlags &= ~FLAG_ANIMATION_DONE;

           if (mAnimationListener != null) {
               mAnimationListener.onAnimationStart(controller.getAnimation());
           }
       }

       int clipSaveCount = 0;
       final boolean clipToPadding = (flags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK;
       if (clipToPadding) {
           clipSaveCount = canvas.save(Canvas.CLIP_SAVE_FLAG);
           canvas.clipRect(mScrollX + mPaddingLeft, mScrollY + mPaddingTop,
                   mScrollX + mRight - mLeft - mPaddingRight,
                   mScrollY + mBottom - mTop - mPaddingBottom);
       }

       // We will draw our child's animation, let's reset the flag
       mPrivateFlags &= ~PFLAG_DRAW_ANIMATION;
       mGroupFlags &= ~FLAG_INVALIDATE_REQUIRED;

       boolean more = false;
       final long drawingTime = getDrawingTime();

       if (usingRenderNodeProperties) canvas.insertReorderBarrier();
       final int transientCount = mTransientIndices == null ? 0 : mTransientIndices.size();
       int transientIndex = transientCount != 0 ? 0 : -1;
       // Only use the preordered list if not HW accelerated, since the HW pipeline will do the
       // draw reordering internally
       final ArrayList<View> preorderedList = usingRenderNodeProperties
               ? null : buildOrderedChildList();
       final boolean customOrder = preorderedList == null
               && isChildrenDrawingOrderEnabled();
       for (int i = 0; i < childrenCount; i++) {
           while (transientIndex >= 0 && mTransientIndices.get(transientIndex) == i) {
               final View transientChild = mTransientViews.get(transientIndex);
               if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
                       transientChild.getAnimation() != null) {
                   more |= drawChild(canvas, transientChild, drawingTime);
               }
               transientIndex++;
               if (transientIndex >= transientCount) {
                   transientIndex = -1;
               }
           }

           final int childIndex = getAndVerifyPreorderedIndex(childrenCount, i, customOrder);
           final View child = getAndVerifyPreorderedView(preorderedList, children, childIndex);
           if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
               more |= drawChild(canvas, child, drawingTime);
           }
       }
       while (transientIndex >= 0) {
           // there may be additional transient views after the normal views
           final View transientChild = mTransientViews.get(transientIndex);
           if ((transientChild.mViewFlags & VISIBILITY_MASK) == VISIBLE ||
                   transientChild.getAnimation() != null) {
               more |= drawChild(canvas, transientChild, drawingTime);
           }
           transientIndex++;
           if (transientIndex >= transientCount) {
               break;
           }
       }
       if (preorderedList != null) preorderedList.clear();

       // Draw any disappearing views that have animations
       if (mDisappearingChildren != null) {
           final ArrayList<View> disappearingChildren = mDisappearingChildren;
           final int disappearingCount = disappearingChildren.size() - 1;
           // Go backwards -- we may delete as animations finish
           for (int i = disappearingCount; i >= 0; i--) {
               final View child = disappearingChildren.get(i);
               more |= drawChild(canvas, child, drawingTime);
           }
       }
       if (usingRenderNodeProperties) canvas.insertInorderBarrier();

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

       if (clipToPadding) {
           canvas.restoreToCount(clipSaveCount);
       }

       // mGroupFlags might have been updated by drawChild()
       flags = mGroupFlags;

       if ((flags & FLAG_INVALIDATE_REQUIRED) == FLAG_INVALIDATE_REQUIRED) {
           invalidate(true);
       }

       if ((flags & FLAG_ANIMATION_DONE) == 0 && (flags & FLAG_NOTIFY_ANIMATION_LISTENER) == 0 &&
               mLayoutAnimationController.isDone() && !more) {
           // We want to erase the drawing cache and notify the listener after the
           // next frame is drawn because one extra invalidate() is caused by
           // drawChild() after the animation is over
           mGroupFlags |= FLAG_NOTIFY_ANIMATION_LISTENER;
           final Runnable end = new Runnable() {
              @Override
              public void run() {
                  notifyAnimationListener();
              }
           };
           post(end);
       }
   }

   /**
    * Draw {@link View#isAutofilled()} highlight over view if the view is autofilled.
    *
    * @param canvas The canvas to draw on
    */
   private void drawAutofilledHighlight(@NonNull Canvas canvas) {
       if (isAutofilled()) {
           Drawable autofilledHighlight = getAutofilledDrawable();

           if (autofilledHighlight != null) {
               autofilledHighlight.setBounds(0, 0, getWidth(), getHeight());
               autofilledHighlight.draw(canvas);
           }
       }
   }

5. 绘制渐变

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

// /sdk/sources/android-26/android/view/View.java
......
      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);
      }

......

6. 绘制装饰附加内容

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

  /**
* // /sdk/sources/android-26/android/view/View.java
   * Draw any foreground content for this view.
   *
   * <p>Foreground content may consist of scroll bars, a {@link #setForeground foreground}
   * drawable or other view-specific decorations. The foreground is drawn on top of the
   * primary view content.</p>
   *
   * @param canvas canvas to draw into
   */
  public void onDrawForeground(Canvas canvas) {
      onDrawScrollIndicators(canvas);
      onDrawScrollBars(canvas);

      final Drawable foreground = mForegroundInfo != null ? mForegroundInfo.mDrawable : null;
      if (foreground != null) {
          if (mForegroundInfo.mBoundsChanged) {
              mForegroundInfo.mBoundsChanged = false;
              final Rect selfBounds = mForegroundInfo.mSelfBounds;
              final Rect overlayBounds = mForegroundInfo.mOverlayBounds;

              if (mForegroundInfo.mInsidePadding) {
                  selfBounds.set(0, 0, getWidth(), getHeight());
              } else {
                  selfBounds.set(getPaddingLeft(), getPaddingTop(),
                          getWidth() - getPaddingRight(), getHeight() - getPaddingBottom());
              }

              final int ld = getLayoutDirection();
              Gravity.apply(mForegroundInfo.mGravity, foreground.getIntrinsicWidth(),
                      foreground.getIntrinsicHeight(), selfBounds, overlayBounds, ld);
              foreground.setBounds(overlayBounds);
          }

          foreground.draw(canvas);
      }
  }