View转换为Bitmap及getDrawingCache

View组件显示的内容可以通过cache机制保存为bitmap, 使用到的api有

void  setDrawingCacheEnabled(boolean flag),
    Bitmap  getDrawingCache(boolean autoScale),
    void  buildDrawingCache(boolean autoScale),
    void  destroyDrawingCache()

• 我们要获取它的cache先要通过setDrawingCacheEnable方法把cache开启，
• 然后再调用getDrawingCache方法就可以获得view的cache图片了。
• buildDrawingCache方法可以不用调用，因为调用getDrawingCache方法时，若果cache没有建立，系统会自动调用buildDrawingCache方法生成cache。若果要更新cache, 必须要调用destoryDrawingCache方法把旧的cache销毁，才能建立新的。
• 当调用setDrawingCacheEnabled方法设置为false, 系统也会自动把原来的cache销毁。

android 为了提高滚动等各方面的绘制速度，可以为每一个view建立一个缓存，使用 View.buildDrawingCache为自己的view 建立相应的缓存， 
这个所谓的缓存，实际上就是一个Bitmap对象。只是 这个 bitmap 对象可以有多种格式而已，如 
     Bitmap.Config.ARGB_8888; 
     Bitmap.Config.ARGB_4444; 
     Bitmap.Config.RGB_565； 
   默认的格式是Bitmap.Config.ARGB_8888.，但大多数嵌入式设备使用的显示格式都是Bitmap.Config.RGB_565. 对于后者， 并没有 
  alpha 值，所以绘制的时候不需要计算alpha合成，速递当让快些。其次，RGB_565可以直接使用优化了的memcopy函数，效率相对高出许多。

view的getDrawingCache获得数据始终为null

setDrawingCacheEnabled

 public void setDrawingCacheEnabled(boolean enabled) {
         setFlags(enabled ? DRAWING_CACHE_ENABLED : 0, DRAWING_CACHE_ENABLED);
     }

DRAWING_CACHE_ENABLED是否支持设置

先看getDrawingCache的源码

   public Bitmap getDrawingCache(boolean autoScale) {
         if ((mViewFlags & WILL_NOT_CACHE_DRAWING) == WILL_NOT_CACHE_DRAWING) {
             return null;
         }
         if ((mViewFlags & DRAWING_CACHE_ENABLED) == DRAWING_CACHE_ENABLED) {
             buildDrawingCache(autoScale);
         }
         return autoScale ? (mDrawingCache == null ? null : mDrawingCache.get()) :
                 (mUnscaledDrawingCache == null ? null : mUnscaledDrawingCache.get());
     }

1) (mViewFlags & WILL_NOT_CACHE_DRAWING) == WILL_NOT_CACHE_DRAWING  这个值为true

2) (mViewFlags & DRAWING_CACHE_ENABLED) == DRAWING_CACHE_ENABLED

如果 false，buildDrawingCache没执行

3) buildDrawingCache执行失败

这些在源码中都可以看到，在获得缓存数据的时候，跟背景色(drawingCacheBackgroundColor),透明度isOpaque，use32BitCache这些有关系，看是细看这些东西都是表面的，是系统在buildDrawingCache的时候，根据View或都系统设置而来的；有些属性是不能更改的；这样一来当一个固定大小的View在不同的设备上生成的图片就可能有所不同，我同事这边存在的问题就是，设置View的固定大小为1360*768，而我View转换为Bitmap及getDrawingCache的设备分辨率为1024*600，而源码里可以看到这样代码：

 if (width <= 0 || height <= 0 ||
                     // Projected bitmap size in bytes
                    (width * height * (opaque && !use32BitCache ? 2 : 4) >
                            ViewConfiguration.get(mContext).getScaledMaximumDrawingCacheSize())) {
                destroyDrawingCache();
                mCachingFailed = true;
                return;
            }  

当我们在buildDrawingCache的时候，系统给了我们默认最大的DrawingCacheSize为屏幕宽*高*4；而我的View的CacheSize大小超过了某些设备默认值，就会导致获得为空；开始想着用反射的方法去改变这些属性，或者设置背景颜色来改变图片质量，这样一来CacheSize大小 就可能会变小，但是这样始终不能达到效果；

最终解决方案：

查看系统buildDrawingCache方法可以看到：

 public void buildDrawingCache(boolean autoScale) {
　　　　　　　//如果没有buildDrawingCache，则执行
         if ((mPrivateFlags & DRAWING_CACHE_VALID) == 0 || (autoScale ?
                 (mDrawingCache == null || mDrawingCache.get() == null) :
                 (mUnscaledDrawingCache == null || mUnscaledDrawingCache.get() == null))) {

             if (ViewDebug.TRACE_HIERARCHY) {
                 ViewDebug.trace(this, ViewDebug.HierarchyTraceType.BUILD_CACHE);
             }
             if (Config.DEBUG && ViewDebug.profileDrawing) {
                 EventLog.writeEvent(60002, hashCode());
             }

             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;
             final boolean opaque = drawingCacheBackgroundColor != 0 || isOpaque();
             final boolean translucentWindow = attachInfo != null && attachInfo.mTranslucentWindow;
 　　           //不满足这些条件不执行

             if (width <= 0 || height <= 0 ||
                      // Projected bitmap size in bytes
                     (width * height * (opaque && !translucentWindow ? 2 : 4) >
                  ViewConfiguration.get(mContext).getScaledMaximumDrawingCacheSize())) {
                 destroyDrawingCache();
                 return;
             }

             boolean clear = true;
             Bitmap bitmap = autoScale ? (mDrawingCache == null ? null : mDrawingCache.get()) :
                     (mUnscaledDrawingCache == null ? null : mUnscaledDrawingCache.get());

             if (bitmap == null || bitmap.getWidth() != width || bitmap.getHeight() != height) {
                 Bitmap.Config quality;
                 if (!opaque) {
                     switch (mViewFlags & DRAWING_CACHE_QUALITY_MASK) {
                         case DRAWING_CACHE_QUALITY_AUTO:
                             quality = Bitmap.Config.ARGB_8888;
                             break;
                         case DRAWING_CACHE_QUALITY_LOW:
                             quality = Bitmap.Config.ARGB_4444;
                             break;
                         case DRAWING_CACHE_QUALITY_HIGH:
                             quality = Bitmap.Config.ARGB_8888;
                             break;
                         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 = translucentWindow ? Bitmap.Config.ARGB_8888 : Bitmap.Config.RGB_565;
                 }

                 // Try to cleanup memory
                 if (bitmap != null) bitmap.recycle();

                 try {
                     bitmap = Bitmap.createBitmap(width, height, quality);
                     bitmap.setDensity(getResources().getDisplayMetrics().densityDpi);
                     if (autoScale) {
                         mDrawingCache = new SoftReference<Bitmap>(bitmap);
                     } else {
                         mUnscaledDrawingCache = new SoftReference<Bitmap>(bitmap);
                     }
                     if (opaque && translucentWindow) 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 hierarchy
                     if (autoScale) {
                         mDrawingCache = null;
                     } else {
                         mUnscaledDrawingCache = null;
                     }
                     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 happen
                 canvas = 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 |= DRAWN;
             mPrivateFlags |= DRAWING_CACHE_VALID;

             // Fast path for layouts with no backgrounds
             if ((mPrivateFlags & SKIP_DRAW) == SKIP_DRAW) {
                 if (ViewDebug.TRACE_HIERARCHY) {
                     ViewDebug.trace(this, ViewDebug.HierarchyTraceType.DRAW);
                 }
                 mPrivateFlags &= ~DIRTY_MASK;
                 dispatchDraw(canvas);
             } else {
                 draw(canvas);
             }

             canvas.restoreToCount(restoreCount);

             if (attachInfo != null) {
                 // Restore the cached Canvas for our siblings
                 attachInfo.mCanvas = canvas;
             }
         }
     }

安卓提供了方法，这个方法没有提供一个外部访问方法

  /**
      * Create a snapshot of the view into a bitmap.  We should probably make
      * some form of this public, but should think about the API.
      */
     Bitmap createSnapshot(Bitmap.Config quality, int backgroundColor, boolean skipChildren) {
         int width = mRight - mLeft;
         int height = mBottom - mTop;

         final AttachInfo attachInfo = mAttachInfo;
         final float scale = attachInfo != null ? attachInfo.mApplicationScale : 1.0f;
         width = (int) ((width * scale) + 0.5f);
         height = (int) ((height * scale) + 0.5f);

         Bitmap bitmap = Bitmap.createBitmap(width > 0 ? width : 1, height > 0 ? height : 1, quality);
         if (bitmap == null) {
             throw new OutOfMemoryError();
         }

         bitmap.setDensity(getResources().getDisplayMetrics().densityDpi);

         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
             // things would happen (invisible views, corrupted drawings, etc.)
             attachInfo.mCanvas = null;
         } else {
             // This case should hopefully never or seldom happen
             canvas = new Canvas(bitmap);
         }

         if ((backgroundColor & 0xff000000) != 0) {
             bitmap.eraseColor(backgroundColor);
         }

         computeScroll();
         final int restoreCount = canvas.save();
         canvas.scale(scale, scale);
         canvas.translate(-mScrollX, -mScrollY);

         // Temporarily remove the dirty mask
         int flags = mPrivateFlags;
         mPrivateFlags &= ~DIRTY_MASK;

         // Fast path for layouts with no backgrounds
         if ((mPrivateFlags & SKIP_DRAW) == SKIP_DRAW) {
             dispatchDraw(canvas);
         } else {
             draw(canvas);
         }

         mPrivateFlags = flags;

         canvas.restoreToCount(restoreCount);

         if (attachInfo != null) {
             // Restore the cached Canvas for our siblings
             attachInfo.mCanvas = canvas;
         }

         return bitmap;
     }

    public static Bitmap getViewBitmap(View v) {
        v.clearFocus();
        v.setPressed(false);
        boolean willNotCache = v.willNotCacheDrawing();
        v.setWillNotCacheDrawing(false);
        // Reset the drawing cache background color to fully transparent
        // for the duration of this operation
        int color = v.getDrawingCacheBackgroundColor();
        v.setDrawingCacheBackgroundColor(0);
        if (color != 0) {
            v.destroyDrawingCache();
        }
        v.buildDrawingCache();
        Bitmap cacheBitmap = v.getDrawingCache();
        if (cacheBitmap == null) {
            return null;
        }
        Bitmap bitmap = Bitmap.createBitmap(cacheBitmap);
        v.destroyDrawingCache();
        v.setWillNotCacheDrawing(willNotCache);
        v.setDrawingCacheBackgroundColor(color);
        return bitmap;
    }