Android View 绘制过程

最新推荐文章于 2024-11-04 11:45:54 发布

HTYBAY

最新推荐文章于 2024-11-04 11:45:54 发布

阅读量685

点赞数

文章标签： android view 绘制

Android的View绘制是从根节点（Activity是DecorView）开始，他是一个自上而下的过程。View的绘制经历三个过程：Measure、Layout、Draw。基本流程如下图：

技术分享

performTraversals函数，具体的可以参考一下源代码：

1 private void performTraversals() {
2     final View host = mView;
3     ...
4     host.measure(childWidthMeasureSpec, childHeightMeasureSpec);
5     ...
6     host.layout(0, 0, host.getMeasuredWidth(), host.getMeasuredHeight());
7     ...
8     draw(fullRedrawNeeded);
9 }

1、Measure过程

Measure过程是计算视图大小，View中视图measure过程相关的方法主要有三个：

1 public final void measure(int widthMeasureSpec, int heightMeasureSpec)
2 protected final void setMeasuredDimension(int measuredWidth, int measuredHeight)
3 protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec)

measure调用onMeasure，onMeasure调用setMeasureDimension，measure，setMeasureDimension是final类型，view的子类不需要重写，onMeasure在view的子类中重写。

measure函数：

 1     public final void measure(int widthMeasureSpec, int heightMeasureSpec) {
 2         if ((mPrivateFlags & FORCE_LAYOUT) == FORCE_LAYOUT ||
 3                 widthMeasureSpec != mOldWidthMeasureSpec ||
 4                 heightMeasureSpec != mOldHeightMeasureSpec) {
 5 
 6             // first clears the measured dimension flag
 7             mPrivateFlags &= ~MEASURED_DIMENSION_SET;
 8 
 9             if (ViewDebug.TRACE_HIERARCHY) {
10                 ViewDebug.trace(this, ViewDebug.HierarchyTraceType.ON_MEASURE);
11             }
12 
13             // measure ourselves, this should set the measured dimension flag back
14             onMeasure(widthMeasureSpec, heightMeasureSpec);
15 
16             // flag not set, setMeasuredDimension() was not invoked, we raise
17             // an exception to warn the developer
18             if ((mPrivateFlags & MEASURED_DIMENSION_SET) != MEASURED_DIMENSION_SET) {
19                 throw new IllegalStateException("onMeasure() did not set the"
20                         + " measured dimension by calling"
21                         + " setMeasuredDimension()");
22             }
23 
24             mPrivateFlags |= LAYOUT_REQUIRED;
25         }
26 
27         mOldWidthMeasureSpec = widthMeasureSpec;
28         mOldHeightMeasureSpec = heightMeasureSpec;
29     }

onMeasure函数：

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

重写onMeasure时，要调用setMeasuredDimension或者super.onMeasure来设置自身的mMeasuredWidth和mMeasuredHeight，否则，就会抛出异常.

setMeasuredDimension函数，用来设置view的大小：

1     protected final void setMeasuredDimension(int measuredWidth, int measuredHeight) {
2         mMeasuredWidth = measuredWidth;
3         mMeasuredHeight = measuredHeight;
4 
5         mPrivateFlags |= MEASURED_DIMENSION_SET;
6     }

再看一下onMeasure的getDefaultSize函数：

 1     public static int getDefaultSize(int size, int measureSpec) {
 2         int result = size;
 3         int specMode = MeasureSpec.getMode(measureSpec);
 4         int specSize = MeasureSpec.getSize(measureSpec);
 5 
 6         switch (specMode) {
 7         case MeasureSpec.UNSPECIFIED:
 8             result = size;
 9             break;
10         case MeasureSpec.AT_MOST:
11         case MeasureSpec.EXACTLY:
12             result = specSize;
13             break;
14         }
15         return result;
16     }

这里用引入了MeasureSpec类：

 1     public static class MeasureSpec {
 2 
 3         private static final int MODE_SHIFT = 30;
 4         private static final int MODE_MASK  = 0x3 << MODE_SHIFT;
 5         public static final int UNSPECIFIED = 0 << MODE_SHIFT;
 6         public static final int EXACTLY     = 1 << MODE_SHIFT;
 7         public static final int AT_MOST     = 2 << MODE_SHIFT;
 8 
 9         public static int makeMeasureSpec(int size, int mode) {
10             return size + mode;
11         }
12 
13         public static int getMode(int measureSpec) {
14             return (measureSpec & MODE_MASK);
15         }
16 
17         public static int getSize(int measureSpec) {
18             return (measureSpec & ~MODE_MASK);
19         }
20     }

MODE_MASK为30为长度的二进制数，前两位标示Mode，后面的标示Size。MeasureSpec有三种模式分别是UNSPECIFIED, EXACTLY和AT_MOST。

EXACTLY表示父视图希望子视图的大小应该是由specSize的值来决定的，系统默认会按照这个规则来设置子视图的大小，开发人员当然也可以按照自己的意愿设置成任意的大小。

AT_MOST表示子视图最多只能是specSize中指定的大小，开发人员应该尽可能小得去设置这个视图，并且保证不会超过specSize。系统默认会按照这个规则来设置子视图的大小，开发人员当然也可以按照自己的意愿设置成任意的大小。

UNSPECIFIED表示开发人员可以将视图按照自己的意愿设置成任意的大小，没有任何限制。这种情况比较少见，不太会用到。

widthMeasureSpec和heightMeasureSpec决定了Mode和Size的值，widthMeasureSpec和heightMeasureSpec来自父视图，这两个值都是由父视图经过计算后传递给子视图的，说明父视图会在一定程度上决定子视图的大小。但是最外层的根视图，它的widthMeasureSpec和heightMeasureSpec又是从哪里得到的呢？这就需要去分析ViewRoot中的源码了，观察performTraversals()方法可以发现如下代码：

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

可以看到，这里调用了getRootMeasureSpec()方法去获取widthMeasureSpec和heightMeasureSpec的值，注意方法中传入的参数，其中lp.width和lp.height在创建ViewGroup实例的时候就被赋值了，它们都等于MATCH_PARENT。然后看下getRootMeasureSpec()方法中的代码，如下所示：

 1 private int getRootMeasureSpec(int windowSize, int rootDimension) {
 2     int measureSpec;
 3     switch (rootDimension) {
 4     case ViewGroup.LayoutParams.MATCH_PARENT:
 5         measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.EXACTLY);
 6         break;
 7     case ViewGroup.LayoutParams.WRAP_CONTENT:
 8         measureSpec = MeasureSpec.makeMeasureSpec(windowSize, MeasureSpec.AT_MOST);
 9         break;
10     default:
11         measureSpec = MeasureSpec.makeMeasureSpec(rootDimension, MeasureSpec.EXACTLY);
12         break;
13     }
14     return measureSpec;
15 }

可以看到，这里使用了MeasureSpec.makeMeasureSpec()方法来组装一个MeasureSpec，当rootDimension参数等于MATCH_PARENT的时候，MeasureSpec的specMode就等于EXACTLY，当rootDimension等于WRAP_CONTENT的时候，MeasureSpec的specMode就等于AT_MOST。并且MATCH_PARENT和WRAP_CONTENT时的specSize都是等于windowSize的，也就意味着根视图总是会充满全屏的。

Measure是一个复杂的过程，因为一个布局中一般都会包含多个子视图，每个视图都需要经历一次measure过程。ViewGroup中定义了一个measureChildren()方法来去测量子视图的大小，如下所示：

 1  protected void measureChildren(int widthMeasureSpec, int heightMeasureSpec) {
 2         final int size = mChildrenCount;
 3         final View[] children = mChildren;
 4         for (int i = 0; i < size; ++i) {
 5             final View child = children[i];
 6             if ((child.mViewFlags & VISIBILITY_MASK) != GONE) {
 7                 measureChild(child, widthMeasureSpec, heightMeasureSpec);
 8             }
 9         }
10     }

这里会去遍历当前布局下的所有子视图，然后逐个调用measureChild()方法来测量相应子视图的大小：

 1  protected void measureChild(View child, int parentWidthMeasureSpec,
 2             int parentHeightMeasureSpec) {
 3         final LayoutParams lp = child.getLayoutParams();
 4 
 5         final int childWidthMeasureSpec = getChildMeasureSpec(parentWidthMeasureSpec,
 6                 mPaddingLeft + mPaddingRight, lp.width);
 7         final int childHeightMeasureSpec = getChildMeasureSpec(parentHeightMeasureSpec,
 8                 mPaddingTop + mPaddingBottom, lp.height);
 9 
10         child.measure(childWidthMeasureSpec, childHeightMeasureSpec);
11     }

从这里我们可以看到视图的大小是由父视图和子视图共同决定的。子布局里面的android:layout_width和android:layout_height只是期望值，父View大小最终是由DecorView决定。父视图提供尺寸大小的一个能力，子视图最终尺寸与父视图能力、子视图期望的关系如下：

父视图能力尺寸	子视图期望尺寸	子视图最终允许尺寸
EXACTLY + Size1	EXACTLY + Size2	EXACTLY + Size2
EXACTLY + Size1	fill_parent/match_parent	EXACTLY+Size1
EXACTLY + Size1	wrap_content	AT_MOST+Size1
AT_MOST+Size1	EXACTLY + Size2	EXACTLY+Size2
AT_MOST+Size1	fill_parent/match_parent	AT_MOST+Size1
AT_MOST+Size1	wrap_content	AT_MOST+Size1
UNSPECIFIED+Size1	EXACTLY + Size2	EXACTLY + Size2
UNSPECIFIED+Size1	fill_parent/match_parent	UNSPECIFIED+0
UNSPECIFIED+Size1	wrap_content	UNSPECIFIED+0

关于视图的measure过程可以阅读以下LinearLayout源码，这样可以更清楚的了解过程。

2、Layout过程

measure过程确定视图的大小，而layout过程确定视图的位置。loyout是从view的layout方法开始的：

 1  public void layout(int l, int t, int r, int b) {
 2         int oldL = mLeft;
 3         int oldT = mTop;
 4         int oldB = mBottom;
 5         int oldR = mRight;
 6         boolean changed = setFrame(l, t, r, b);
 7         if (changed || (mPrivateFlags & PFLAG_LAYOUT_REQUIRED) == PFLAG_LAYOUT_REQUIRED) {
 8             onLayout(changed, l, t, r, b);
 9             mPrivateFlags &= ~PFLAG_LAYOUT_REQUIRED;
10 
11             ListenerInfo li = mListenerInfo;
12             if (li != null && li.mOnLayoutChangeListeners != null) {
13                 ArrayList<OnLayoutChangeListener> listenersCopy =
14                         (ArrayList<OnLayoutChangeListener>)li.mOnLayoutChangeListeners.clone();
15                 int numListeners = listenersCopy.size();
16                 for (int i = 0; i < numListeners; ++i) {
17                     listenersCopy.get(i).onLayoutChange(this, l, t, r, b, oldL, oldT, oldR, oldB);
18                 }
19             }
20         }
21         mPrivateFlags &= ~PFLAG_FORCE_LAYOUT;
22     }

函数中参数l、t、r、b是指view的左、上、右、底的位置，这几个参数是父视图传入的，而根视图中参数是由performTraversals()方法传入的。

1   host.layout(0, 0, host.mMeasuredWidth, host.mMeasuredHeight);

layout中调用了onLayout方法，在view中onLayout方法是一个空函数，他需要其子类实现。

1 protected void onLayout(boolean changed, int left, int top, int right, int bottom) {
2 }

我们关注一下LinearLayout：

1   @Override
2     protected void onLayout(boolean changed, int l, int t, int r, int b) {
3         if (mOrientation == VERTICAL) {
4             layoutVertical();
5         } else {
6             layoutHorizontal();
7         }
8     }

 1   void layoutVertical() {
 2         final int paddingLeft = mPaddingLeft;
 3 
 4         int childTop;
 5         int childLeft;
 6         
 7         // Where right end of child should go
 8         final int width = mRight - mLeft;
 9         int childRight = width - mPaddingRight;
10         
11         // Space available for child
12         int childSpace = width - paddingLeft - mPaddingRight;
13         
14         final int count = getVirtualChildCount();
15 
16         final int majorGravity = mGravity & Gravity.VERTICAL_GRAVITY_MASK;
17         final int minorGravity = mGravity & Gravity.RELATIVE_HORIZONTAL_GRAVITY_MASK;
18 
19         switch (majorGravity) {
20            case Gravity.BOTTOM:
21                // mTotalLength contains the padding already
22                childTop = mPaddingTop + mBottom - mTop - mTotalLength;
23                break;
24 
25                // mTotalLength contains the padding already
26            case Gravity.CENTER_VERTICAL:
27                childTop = mPaddingTop + (mBottom - mTop - mTotalLength) / 2;
28                break;
29 
30            case Gravity.TOP:
31            default:
32                childTop = mPaddingTop;
33                break;
34         }
35 
36         for (int i = 0; i < count; i++) {
37             final View child = getVirtualChildAt(i);
38             if (child == null) {
39                 childTop += measureNullChild(i);
40             } else if (child.getVisibility() != GONE) {
41                 final int childWidth = child.getMeasuredWidth();
42                 final int childHeight = child.getMeasuredHeight();
43                 
44                 final LinearLayout.LayoutParams lp =
45                         (LinearLayout.LayoutParams) child.getLayoutParams();
46                 
47                 int gravity = lp.gravity;
48                 if (gravity < 0) {
49                     gravity = minorGravity;
50                 }
51                 final int layoutDirection = getLayoutDirection();
52                 final int absoluteGravity = Gravity.getAbsoluteGravity(gravity, layoutDirection);
53                 switch (absoluteGravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
54                     case Gravity.CENTER_HORIZONTAL:
55                         childLeft = paddingLeft + ((childSpace - childWidth) / 2)
56                                 + lp.leftMargin - lp.rightMargin;
57                         break;
58 
59                     case Gravity.RIGHT:
60                         childLeft = childRight - childWidth - lp.rightMargin;
61                         break;
62 
63                     case Gravity.LEFT:
64                     default:
65                         childLeft = paddingLeft + lp.leftMargin;
66                         break;
67                 }
68 
69                 if (hasDividerBeforeChildAt(i)) {
70                     childTop += mDividerHeight;
71                 }
72 
73                 childTop += lp.topMargin;
74                 setChildFrame(child, childLeft, childTop + getLocationOffset(child),
75                         childWidth, childHeight);
76                 childTop += childHeight + lp.bottomMargin + getNextLocationOffset(child);
77 
78                 i += getChildrenSkipCount(child, i);
79             }
80         }
81     }

layout设置了view的位置，还设置了子视图位置，layoutHorizontal()方法中调用了setChildFrame方法：

1     private void setChildFrame(View child, int left, int top, int width, int height) {        
2         child.layout(left, top, left + width, top + height);
3     }
4

从上面看出，layout也是一个自上而下的过程，先设置父视图位置，在循环子视图，父视图位置一定程度上决定了子视图位置。

3、Draw过程

draw过程调用顺序在measure()和layout()之后，同样的，performTraversals()发起的draw过程最终会调用到mView的draw()函数，这里的mView对于Activity来说就是PhoneWindow.DecorView。看一下view类的draw方法：

  1  public void draw(Canvas canvas) {
  2         final int privateFlags = mPrivateFlags;
  3         final boolean dirtyOpaque = (privateFlags & PFLAG_DIRTY_MASK) == PFLAG_DIRTY_OPAQUE &&
  4                 (mAttachInfo == null || !mAttachInfo.mIgnoreDirtyState);
  5         mPrivateFlags = (privateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
  6 
  7         /*
  8          * Draw traversal performs several drawing steps which must be executed
  9          * in the appropriate order:
 10          *
 11          *      1. Draw the background
 12          *      2. If necessary, save the canvas‘ layers to prepare for fading
 13          *      3. Draw view‘s content
 14          *      4. Draw children
 15          *      5. If necessary, draw the fading edges and restore layers
 16          *      6. Draw decorations (scrollbars for instance)
 17          */
 18 
 19         // Step 1, draw the background, if needed
 20         int saveCount;
 21 
 22         if (!dirtyOpaque) {
 23             final Drawable background = mBackground;
 24             if (background != null) {
 25                 final int scrollX = mScrollX;
 26                 final int scrollY = mScrollY;
 27 
 28                 if (mBackgroundSizeChanged) {
 29                     background.setBounds(0, 0,  mRight - mLeft, mBottom - mTop);
 30                     mBackgroundSizeChanged = false;
 31                 }
 32 
 33                 if ((scrollX | scrollY) == 0) {
 34                     background.draw(canvas);
 35                 } else {
 36                     canvas.translate(scrollX, scrollY);
 37                     background.draw(canvas);
 38                     canvas.translate(-scrollX, -scrollY);
 39                 }
 40             }
 41         }
 42 
 43         // skip step 2 & 5 if possible (common case)
 44         final int viewFlags = mViewFlags;
 45         boolean horizontalEdges = (viewFlags & FADING_EDGE_HORIZONTAL) != 0;
 46         boolean verticalEdges = (viewFlags & FADING_EDGE_VERTICAL) != 0;
 47         if (!verticalEdges && !horizontalEdges) {
 48             // Step 3, draw the content
 49             if (!dirtyOpaque) onDraw(canvas);
 50 
 51             // Step 4, draw the children
 52             dispatchDraw(canvas);
 53 
 54             // Step 6, draw decorations (scrollbars)
 55             onDrawScrollBars(canvas);
 56 
 57             // we‘re done...
 58             return;
 59         }
 60 
 61         /*
 62          * Here we do the full fledged routine...
 63          * (this is an uncommon case where speed matters less,
 64          * this is why we repeat some of the tests that have been
 65          * done above)
 66          */
 67 
 68         boolean drawTop = false;
 69         boolean drawBottom = false;
 70         boolean drawLeft = false;
 71         boolean drawRight = false;
 72 
 73         float topFadeStrength = 0.0f;
 74         float bottomFadeStrength = 0.0f;
 75         float leftFadeStrength = 0.0f;
 76         float rightFadeStrength = 0.0f;
 77 
 78         // Step 2, save the canvas‘ layers
 79         int paddingLeft = mPaddingLeft;
 80 
 81         final boolean offsetRequired = isPaddingOffsetRequired();
 82         if (offsetRequired) {
 83             paddingLeft += getLeftPaddingOffset();
 84         }
 85 
 86         int left = mScrollX + paddingLeft;
 87         int right = left + mRight - mLeft - mPaddingRight - paddingLeft;
 88         int top = mScrollY + getFadeTop(offsetRequired);
 89         int bottom = top + getFadeHeight(offsetRequired);
 90 
 91         if (offsetRequired) {
 92             right += getRightPaddingOffset();
 93             bottom += getBottomPaddingOffset();
 94         }
 95 
 96         final ScrollabilityCache scrollabilityCache = mScrollCache;
 97         final float fadeHeight = scrollabilityCache.fadingEdgeLength;
 98         int length = (int) fadeHeight;
 99 
100         // clip the fade length if top and bottom fades overlap
101         // overlapping fades produce odd-looking artifacts
102         if (verticalEdges && (top + length > bottom - length)) {
103             length = (bottom - top) / 2;
104         }
105 
106         // also clip horizontal fades if necessary
107         if (horizontalEdges && (left + length > right - length)) {
108             length = (right - left) / 2;
109         }
110 
111         if (verticalEdges) {
112             topFadeStrength = Math.max(0.0f, Math.min(1.0f, getTopFadingEdgeStrength()));
113             drawTop = topFadeStrength * fadeHeight > 1.0f;
114             bottomFadeStrength = Math.max(0.0f, Math.min(1.0f, getBottomFadingEdgeStrength()));
115             drawBottom = bottomFadeStrength * fadeHeight > 1.0f;
116         }
117 
118         if (horizontalEdges) {
119             leftFadeStrength = Math.max(0.0f, Math.min(1.0f, getLeftFadingEdgeStrength()));
120             drawLeft = leftFadeStrength * fadeHeight > 1.0f;
121             rightFadeStrength = Math.max(0.0f, Math.min(1.0f, getRightFadingEdgeStrength()));
122             drawRight = rightFadeStrength * fadeHeight > 1.0f;
123         }
124 
125         saveCount = canvas.getSaveCount();
126 
127         int solidColor = getSolidColor();
128         if (solidColor == 0) {
129             final int flags = Canvas.HAS_ALPHA_LAYER_SAVE_FLAG;
130 
131             if (drawTop) {
132                 canvas.saveLayer(left, top, right, top + length, null, flags);
133             }
134 
135             if (drawBottom) {
136                 canvas.saveLayer(left, bottom - length, right, bottom, null, flags);
137             }
138 
139             if (drawLeft) {
140                 canvas.saveLayer(left, top, left + length, bottom, null, flags);
141             }
142 
143             if (drawRight) {
144                 canvas.saveLayer(right - length, top, right, bottom, null, flags);
145             }
146         } else {
147             scrollabilityCache.setFadeColor(solidColor);
148         }
149 
150         // Step 3, draw the content
151         if (!dirtyOpaque) onDraw(canvas);
152 
153         // Step 4, draw the children
154         dispatchDraw(canvas);
155 
156         // Step 5, draw the fade effect and restore layers
157         final Paint p = scrollabilityCache.paint;
158         final Matrix matrix = scrollabilityCache.matrix;
159         final Shader fade = scrollabilityCache.shader;
160 
161         if (drawTop) {
162             matrix.setScale(1, fadeHeight * topFadeStrength);
163             matrix.postTranslate(left, top);
164             fade.setLocalMatrix(matrix);
165             canvas.drawRect(left, top, right, top + length, p);
166         }
167 
168         if (drawBottom) {
169             matrix.setScale(1, fadeHeight * bottomFadeStrength);
170             matrix.postRotate(180);
171             matrix.postTranslate(left, bottom);
172             fade.setLocalMatrix(matrix);
173             canvas.drawRect(left, bottom - length, right, bottom, p);
174         }
175 
176         if (drawLeft) {
177             matrix.setScale(1, fadeHeight * leftFadeStrength);
178             matrix.postRotate(-90);
179             matrix.postTranslate(left, top);
180             fade.setLocalMatrix(matrix);
181             canvas.drawRect(left, top, left + length, bottom, p);
182         }
183 
184         if (drawRight) {
185             matrix.setScale(1, fadeHeight * rightFadeStrength);
186             matrix.postRotate(90);
187             matrix.postTranslate(right, top);
188             fade.setLocalMatrix(matrix);
189             canvas.drawRect(right - length, top, right, bottom, p);
190         }
191 
192         canvas.restoreToCount(saveCount);
193 
194         // Step 6, draw decorations (scrollbars)
195         onDrawScrollBars(canvas);
196     }

draw方法分成了6个步骤：

 1  /*
 2          * Draw traversal performs several drawing steps which must be executed
 3          * in the appropriate order:
 4          *
 5          *      1. Draw the background
 6          *      2. If necessary, save the canvas‘ layers to prepare for fading
 7          *      3. Draw view‘s content
 8          *      4. Draw children
 9          *      5. If necessary, draw the fading edges and restore layers
10          *      6. Draw decorations (scrollbars for instance)
11          */

第三部, Draw view‘s content步骤调用了onDraw方法，子类中实现onDraw方法。

第四步，Draw children步骤使用的dispatchDraw方法，这个方法在ViewGroup中有实现。

View或ViewGroup的子类不用再重载ViewGroup中该方法，因为它已经有了默认而且标准的view系统流程。dispatchDraw()内部for循环调用drawChild()分别绘制每一个子视图，而drawChild()内部又会调用draw（）函数完成子视图的内部绘制工作。

  1  /**
  2      * {@inheritDoc}
  3      */
  4     @Override
  5     protected void dispatchDraw(Canvas canvas) {
  6         final int count = mChildrenCount;
  7         final View[] children = mChildren;
  8         int flags = mGroupFlags;
  9 
 10         if ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {
 11             final boolean cache = (mGroupFlags & FLAG_ANIMATION_CACHE) == FLAG_ANIMATION_CACHE;
 12 
 13             final boolean buildCache = !isHardwareAccelerated();
 14             for (int i = 0; i < count; i++) {
 15                 final View child = children[i];
 16                 if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {
 17                     final LayoutParams params = child.getLayoutParams();
 18                     attachLayoutAnimationParameters(child, params, i, count);
 19                     bindLayoutAnimation(child);
 20                     if (cache) {
 21                         child.setDrawingCacheEnabled(true);
 22                         if (buildCache) {                        
 23                             child.buildDrawingCache(true);
 24                         }
 25                     }
 26                 }
 27             }
 28 
 29             final LayoutAnimationController controller = mLayoutAnimationController;
 30             if (controller.willOverlap()) {
 31                 mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;
 32             }
 33 
 34             controller.start();
 35 
 36             mGroupFlags &= ~FLAG_RUN_ANIMATION;
 37             mGroupFlags &= ~FLAG_ANIMATION_DONE;
 38 
 39             if (cache) {
 40                 mGroupFlags |= FLAG_CHILDREN_DRAWN_WITH_CACHE;
 41             }
 42 
 43             if (mAnimationListener != null) {
 44                 mAnimationListener.onAnimationStart(controller.getAnimation());
 45             }
 46         }
 47 
 48         int saveCount = 0;
 49         final boolean clipToPadding = (flags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK;
 50         if (clipToPadding) {
 51             saveCount = canvas.save();
 52             canvas.clipRect(mScrollX + mPaddingLeft, mScrollY + mPaddingTop,
 53                     mScrollX + mRight - mLeft - mPaddingRight,
 54                     mScrollY + mBottom - mTop - mPaddingBottom);
 55 
 56         }
 57 
 58         // We will draw our child‘s animation, let‘s reset the flag
 59         mPrivateFlags &= ~PFLAG_DRAW_ANIMATION;
 60         mGroupFlags &= ~FLAG_INVALIDATE_REQUIRED;
 61 
 62         boolean more = false;
 63         final long drawingTime = getDrawingTime();
 64 
 65         if ((flags & FLAG_USE_CHILD_DRAWING_ORDER) == 0) {
 66             for (int i = 0; i < count; i++) {
 67                 final View child = children[i];
 68                 if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
 69                     more |= drawChild(canvas, child, drawingTime);
 70                 }
 71             }
 72         } else {
 73             for (int i = 0; i < count; i++) {
 74                 final View child = children[getChildDrawingOrder(count, i)];
 75                 if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {
 76                     more |= drawChild(canvas, child, drawingTime);
 77                 }
 78             }
 79         }
 80 
 81         // Draw any disappearing views that have animations
 82         if (mDisappearingChildren != null) {
 83             final ArrayList<View> disappearingChildren = mDisappearingChildren;
 84             final int disappearingCount = disappearingChildren.size() - 1;
 85             // Go backwards -- we may delete as animations finish
 86             for (int i = disappearingCount; i >= 0; i--) {
 87                 final View child = disappearingChildren.get(i);
 88                 more |= drawChild(canvas, child, drawingTime);
 89             }
 90         }
 91 
 92         if (debugDraw()) {
 93             onDebugDraw(canvas);
 94         }
 95 
 96         if (clipToPadding) {
 97             canvas.restoreToCount(saveCount);
 98         }
 99 
100         // mGroupFlags might have been updated by drawChild()
101         flags = mGroupFlags;
102 
103         if ((flags & FLAG_INVALIDATE_REQUIRED) == FLAG_INVALIDATE_REQUIRED) {
104             invalidate(true);
105         }
106 
107         if ((flags & FLAG_ANIMATION_DONE) == 0 && (flags & FLAG_NOTIFY_ANIMATION_LISTENER) == 0 &&
108                 mLayoutAnimationController.isDone() && !more) {
109             // We want to erase the drawing cache and notify the listener after the
110             // next frame is drawn because one extra invalidate() is caused by
111             // drawChild() after the animation is over
112             mGroupFlags |= FLAG_NOTIFY_ANIMATION_LISTENER;
113             final Runnable end = new Runnable() {
114                public void run() {
115                    notifyAnimationListener();
116                }
117             };
118             post(end);
119         }
120     }