/*** Enables or disables the children's drawing cache during a layout animation.* By default, the drawing cache is enabled but this will prevent nested* layout animations from working. To nest animations, you must disable the* cache.** @param enabled true to enable the animation cache, false otherwise** @see #isAnimationCacheEnabled()* @see View#setDrawingCacheEnabled(boolean)*/public void setAnimationCacheEnabled(boolean enabled) {setBooleanFlag(FLAG_ANIMATION_CACHE, enabled);}

    /*** <p>Forces the drawing cache to be built if the drawing cache is invalid.</p>** <p>If you call {@link #buildDrawingCache()} manually without calling* {@link #setDrawingCacheEnabled(boolean) setDrawingCacheEnabled(true)}, you* should cleanup the cache by calling {@link #destroyDrawingCache()} afterwards.</p>** <p>Note about auto scaling in compatibility mode: When auto scaling is not enabled,* this method will create a bitmap of the same size as this view. Because this bitmap* will be drawn scaled by the parent ViewGroup, the result on screen might show* scaling artifacts. To avoid such artifacts, you should call this method by setting* the auto scaling to true. Doing so, however, will generate a bitmap of a different* size than the view. This implies that your application must be able to handle this* size.</p>** <p>You should avoid calling this method when hardware acceleration is enabled. If* you do not need the drawing cache bitmap, calling this method will increase memory* usage and cause the view to be rendered in software once, thus negatively impacting* performance.</p>** @see #getDrawingCache()* @see #destroyDrawingCache()*/public void buildDrawingCache(boolean autoScale) {if ((mPrivateFlags & PFLAG_DRAWING_CACHE_VALID) == 0 || (autoScale ?mDrawingCache == null : mUnscaledDrawingCache == null)) {mCachingFailed = false;int width = mRight - mLeft;int height = mBottom - mTop;final AttachInfo attachInfo = mAttachInfo;final boolean scalingRequired = attachInfo != null && attachInfo.mScalingRequired;if (autoScale && scalingRequired) {width = (int) ((width * attachInfo.mApplicationScale) + 0.5f);height = (int) ((height * attachInfo.mApplicationScale) + 0.5f);}final int drawingCacheBackgroundColor = mDrawingCacheBackgroundColor;　　　　　　　// 1.这里final boolean opaque = drawingCacheBackgroundColor != 0 || isOpaque();final boolean use32BitCache = attachInfo != null && attachInfo.mUse32BitDrawingCache;final long projectedBitmapSize = width * height * (opaque && !use32BitCache ? 2 : 4);final long drawingCacheSize =ViewConfiguration.get(mContext).getScaledMaximumDrawingCacheSize();if (width <= 0 || height <= 0 || projectedBitmapSize > drawingCacheSize) {if (width > 0 && height > 0) {Log.w(VIEW_LOG_TAG, "View too large to fit into drawing cache, needs "+ projectedBitmapSize + " bytes, only "+ drawingCacheSize + " available");}destroyDrawingCache();mCachingFailed = true;return;}boolean clear = true;Bitmap bitmap = autoScale ? mDrawingCache : mUnscaledDrawingCache;if (bitmap == null || bitmap.getWidth() != width || bitmap.getHeight() != height) {Bitmap.Config quality;　　　　　　　　　 // 2.这里if (!opaque) {// Never pick ARGB_4444 because it looks awful// Keep the DRAWING_CACHE_QUALITY_LOW flag just in caseswitch (mViewFlags & DRAWING_CACHE_QUALITY_MASK) {case DRAWING_CACHE_QUALITY_AUTO:case DRAWING_CACHE_QUALITY_LOW:case DRAWING_CACHE_QUALITY_HIGH:default:quality = Bitmap.Config.ARGB_8888;break;}} else {// Optimization for translucent windows// If the window is translucent, use a 32 bits bitmap to benefit from memcpy()quality = use32BitCache ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565;}// Try to cleanup memoryif (bitmap != null) bitmap.recycle();try {bitmap = Bitmap.createBitmap(mResources.getDisplayMetrics(),width, height, quality);bitmap.setDensity(getResources().getDisplayMetrics().densityDpi);if (autoScale) {mDrawingCache = bitmap;} else {mUnscaledDrawingCache = bitmap;}if (opaque && use32BitCache) bitmap.setHasAlpha(false);} catch (OutOfMemoryError e) {// If there is not enough memory to create the bitmap cache, just// ignore the issue as bitmap caches are not required to draw the// view hierarchyif (autoScale) {mDrawingCache = null;} else {mUnscaledDrawingCache = null;}mCachingFailed = true;return;}clear = drawingCacheBackgroundColor != 0;}Canvas canvas;if (attachInfo != null) {canvas = attachInfo.mCanvas;if (canvas == null) {canvas = new Canvas();}canvas.setBitmap(bitmap);// Temporarily clobber the cached Canvas in case one of our children// is also using a drawing cache. Without this, the children would// steal the canvas by attaching their own bitmap to it and bad, bad// thing would happen (invisible views, corrupted drawings, etc.)attachInfo.mCanvas = null;} else {// This case should hopefully never or seldom happencanvas = new Canvas(bitmap);}if (clear) {bitmap.eraseColor(drawingCacheBackgroundColor);}computeScroll();final int restoreCount = canvas.save();if (autoScale && scalingRequired) {final float scale = attachInfo.mApplicationScale;canvas.scale(scale, scale);}canvas.translate(-mScrollX, -mScrollY);mPrivateFlags |= PFLAG_DRAWN;if (mAttachInfo == null || !mAttachInfo.mHardwareAccelerated ||mLayerType != LAYER_TYPE_NONE) {mPrivateFlags |= PFLAG_DRAWING_CACHE_VALID;}// Fast path for layouts with no backgroundsif ((mPrivateFlags & PFLAG_SKIP_DRAW) == PFLAG_SKIP_DRAW) {mPrivateFlags &= ~PFLAG_DIRTY_MASK;dispatchDraw(canvas);if (mOverlay != null && !mOverlay.isEmpty()) {mOverlay.getOverlayView().draw(canvas);}} else {draw(canvas);}canvas.restoreToCount(restoreCount);canvas.setBitmap(null);if (attachInfo != null) {// Restore the cached Canvas for our siblingsattachInfo.mCanvas = canvas;}}}

setDrawingCacheBackgroundColor(0xFF0C0C0C);

    /*** {@inheritDoc}*/@Overrideprotected void dispatchDraw(Canvas canvas) {final int count = mChildrenCount;final View[] children = mChildren;int flags = mGroupFlags;// 关键字：FLAG_RUN_ANIMATION，FLAG_ANIMATION_CACHE，cache，buildCacheif ((flags & FLAG_RUN_ANIMATION) != 0 && canAnimate()) {final boolean cache = (mGroupFlags & FLAG_ANIMATION_CACHE) == FLAG_ANIMATION_CACHE;final boolean buildCache = !isHardwareAccelerated();for (int i = 0; i < count; i++) {final View child = children[i];if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE) {final LayoutParams params = child.getLayoutParams();attachLayoutAnimationParameters(child, params, i, count);bindLayoutAnimation(child);if (cache) {child.setDrawingCacheEnabled(true);if (buildCache) {                        child.buildDrawingCache(true);}}}}final LayoutAnimationController controller = mLayoutAnimationController;if (controller.willOverlap()) {mGroupFlags |= FLAG_OPTIMIZE_INVALIDATE;}controller.start();mGroupFlags &= ~FLAG_RUN_ANIMATION;mGroupFlags &= ~FLAG_ANIMATION_DONE;if (cache) {mGroupFlags |= FLAG_CHILDREN_DRAWN_WITH_CACHE;}if (mAnimationListener != null) {mAnimationListener.onAnimationStart(controller.getAnimation());}}int saveCount = 0;final boolean clipToPadding = (flags & CLIP_TO_PADDING_MASK) == CLIP_TO_PADDING_MASK;if (clipToPadding) {saveCount = canvas.save();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 flagmPrivateFlags &= ~PFLAG_DRAW_ANIMATION;mGroupFlags &= ~FLAG_INVALIDATE_REQUIRED;boolean more = false;final long drawingTime = getDrawingTime();if ((flags & FLAG_USE_CHILD_DRAWING_ORDER) == 0) {for (int i = 0; i < count; i++) {final View child = children[i];if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {more |= drawChild(canvas, child, drawingTime);}}} else {for (int i = 0; i < count; i++) {final View child = children[getChildDrawingOrder(count, i)];if ((child.mViewFlags & VISIBILITY_MASK) == VISIBLE || child.getAnimation() != null) {more |= drawChild(canvas, child, drawingTime);}}}// Draw any disappearing views that have animationsif (mDisappearingChildren != null) {final ArrayList<View> disappearingChildren = mDisappearingChildren;final int disappearingCount = disappearingChildren.size() - 1;// Go backwards -- we may delete as animations finishfor (int i = disappearingCount; i >= 0; i--) {final View child = disappearingChildren.get(i);more |= drawChild(canvas, child, drawingTime);}}if (debugDraw()) {onDebugDraw(canvas);}if (clipToPadding) {canvas.restoreToCount(saveCount);}// 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 overmGroupFlags |= FLAG_NOTIFY_ANIMATION_LISTENER;final Runnable end = new Runnable() {public void run() {notifyAnimationListener();}};post(end);}}

boolean draw(Canvas canvas, ViewGroup parent, long drawingTime) {boolean caching;……………final int flags = parent.mGroupFlags;…………..if ((flags & ViewGroup.FLAG_CHILDREN_DRAWN_WITH_CACHE) != 0 ||(flags & ViewGroup.FLAG_ALWAYS_DRAWN_WITH_CACHE) != 0) {caching = true;// Auto-scaled apps are not hw-accelerated, no need to set scaling flag on DisplayListif (mAttachInfo != null) scalingRequired =         mAttachInfo.mScalingRequired;} else {caching = (layerType != LAYER_TYPE_NONE) || hardwareAccelerated;}…………..if (caching) {if (!hardwareAccelerated) {if (layerType != LAYER_TYPE_NONE) {layerType = LAYER_TYPE_SOFTWARE;buildDrawingCache(true);}cache = getDrawingCache(true);} else {switch (layerType) {case LAYER_TYPE_SOFTWARE:if (useDisplayListProperties) {hasDisplayList = canHaveDisplayList();} else {buildDrawingCache(true);cache = getDrawingCache(true);}break;case LAYER_TYPE_HARDWARE:if (useDisplayListProperties) {hasDisplayList = canHaveDisplayList();}break;case LAYER_TYPE_NONE:// Delay getting the display list until animation-driven alpha values are// set up and possibly passed on to the viewhasDisplayList = canHaveDisplayList();break;}}}…………………..}    

    /*** This is where the invalidate() work actually happens. A full invalidate()* causes the drawing cache to be invalidated, but this function can be called with* invalidateCache set to false to skip that invalidation step for cases that do not* need it (for example, a component that remains at the same dimensions with the same* content).** @param invalidateCache Whether the drawing cache for this view should be invalidated as* well. This is usually true for a full invalidate, but may be set to false if the* View's contents or dimensions have not changed.　　　* 指示在视图刷新时，是否也要刷新绘图缓存，对于一个完全的刷新操作，比如视图内容发生了变化，　　　* 或者控件尺寸发生变化了，那么应该设置true，但是如果不是二者任何一个，则应该设置为false。*/void invalidate(boolean invalidateCache) {if (skipInvalidate()) {return;}if ((mPrivateFlags & (PFLAG_DRAWN | PFLAG_HAS_BOUNDS)) == (PFLAG_DRAWN | PFLAG_HAS_BOUNDS) ||(invalidateCache && (mPrivateFlags & PFLAG_DRAWING_CACHE_VALID) == PFLAG_DRAWING_CACHE_VALID) ||(mPrivateFlags & PFLAG_INVALIDATED) != PFLAG_INVALIDATED || isOpaque() != mLastIsOpaque) {mLastIsOpaque = isOpaque();mPrivateFlags &= ~PFLAG_DRAWN;mPrivateFlags |= PFLAG_DIRTY;if (invalidateCache) {mPrivateFlags |= PFLAG_INVALIDATED;mPrivateFlags &= ~PFLAG_DRAWING_CACHE_VALID;}final AttachInfo ai = mAttachInfo;final ViewParent p = mParent;//noinspection PointlessBooleanExpression,ConstantConditionsif (!HardwareRenderer.RENDER_DIRTY_REGIONS) {if (p != null && ai != null && ai.mHardwareAccelerated) {// fast-track for GL-enabled applications; just invalidate the whole hierarchy// with a null dirty rect, which tells the ViewAncestor to redraw everythingp.invalidateChild(this, null);return;}}if (p != null && ai != null) {final Rect r = ai.mTmpInvalRect;r.set(0, 0, mRight - mLeft, mBottom - mTop);// Don't call invalidate -- we don't want to internally scroll// our own boundsp.invalidateChild(this, r);}}}

    /*** Indicates what types of drawing caches should be kept in memory after* they have been created.** @see #getPersistentDrawingCache()* @see #setAnimationCacheEnabled(boolean)** @param drawingCacheToKeep one or a combination of {@link #PERSISTENT_NO_CACHE},*        {@link #PERSISTENT_ANIMATION_CACHE}, {@link #PERSISTENT_SCROLLING_CACHE}*        and {@link #PERSISTENT_ALL_CACHES}*/public void setPersistentDrawingCache(int drawingCacheToKeep) {mPersistentDrawingCache = drawingCacheToKeep & PERSISTENT_ALL_CACHES;}