项目中使用View截图分享，RecyclerView截图分享

项目中用到了许多截图分享到第三方的地方，遇到了很多坑，类似：截图失败、获取不到缓存图片、截取RecyclerView长图中ImageView同步加载、长图获取缓存出现OOM等，本次就遇到的所有问题进行汇总，并提交Demo到github。

简单的截图

从网上搜索到的结果，大部分都是 setDrawingCacheEnable(true) ; 然后从缓存中获取到数据 view.getDrawingCache(), 代码如下：

Bitmap cacheBitmap = null;
cacheView.setEnabled(false);
// 首先获取一个View，
View view = getUiView().mActivity.getWindow().getDecorView();
// 设置可以从缓存中获取到数据
view.setDrawingCacheEnabled(true);
// 获取到bitmap
cacheBitmap = view.getDrawingCache();
view.setDrawingCacheEnabled(false);

但是官网中对该使用方法标识已经废弃了：

随着API 11中硬件加速渲染的引入，视图绘制缓存基本上已过时。通过硬件加速，中间缓存层在很大程度上是不必要的，并且很容易导致性能的净损失由于创建和更新图层的成本；所以官网建议我们使用PixelCopy，不过PixelCopy需要传入SurfaceView或者Window，我们可以看看setDrawingCacheEnabled(true) 之后获取getDrawingCache()的源码：

/**
 * private, internal implementation of buildDrawingCache, used to enable tracing
 */
private void buildDrawingCacheImpl(boolean autoScale) {
   
//    ...... 省略部分代码
  // 以下判断当前创建的Bitmap大小是否比系统最大值还大，如果超过则抛出异常
    final int drawingCacheBackgroundColor = mDrawingCacheBackgroundColor;
    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, getClass().getSimpleName() + " not displayed because it is"
                    + " too large to fit into a software layer (or drawing cache), needs "
                    + projectedBitmapSize + " bytes, only "
                    + drawingCacheSize + " available");
        }
        destroyDrawingCache();
        mCachingFailed = true;
        return;
    }
//    ...... 省略部分代码
       // 清除内存数据
       if (bitmap != null) bitmap.recycle();
       try {
            // 创建bitmap
           bitmap = Bitmap.createBitmap(mResources.getDisplayMetrics(),
                   width, height, quality);
           bitmap.setDensity(getResources().getDisplayMetrics().densityDpi);
           
        } catch(OutOfMemoryError e) {
            //    ...... 省略部分代码
        }    
   }

// 创建Canvas
   Canvas canvas;
   if (attachInfo != null) {
       canvas = attachInfo.mCanvas;
       if (canvas == null) {
           canvas = new Canvas();
       }
      // 将bitmap设置到画布中
       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);
   }
//    ...... 省略部分代码

      // 画数据
       draw(canvas);
}

通过以上代码，所以在stackflow中有人总结出：直接通过View创建一个Bitmap，然后设置给Canvas，再通过View的draw方法传入Canvas：

public void setBitmap(View view) {    
    Bitmap bitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.RGB_565);
    Canvas canvas = new Canvas(bitmap);
    view.draw(canvas);
}

当然，上面的两种方法，都是基于View已经被测量出来，显示在界面上，只需要拿到数据即可，大多数情况下，我们需要使用LayoutInflater来获取一个View，这时候我们是获取不到View的宽高的，所以需要我们手动去measure和layout；

从layout中加载的View截图

从View的加载过程我们得知，View要绘制到界面上，需要经历onMeasure()、onLayout()、onDraw()，因为从layout中加载的View，没有执行这几个过程，所以无法得到View的缓存图，必须得要我们手动去执行这几个方法：

public void getViewFromLayout() {
    // 获取到View
    View view = LayoutInflater.from(getUiView().mActivity).inflate(R.layout.view_layout, null, false);
    // 调用measure() 方法，测量View的宽高
    view.measure(View.MeasureSpec.makeMeasureSpec(DensityUtil.getWidth(), View.MeasureSpec.EXACTLY),
                    View.MeasureSpec.makeMeasureSpec(DensityUtil.getHeight(), View.MeasureSpec.EXACTLY));
    //   调用layout() 方法，确定View及其子View的位置
    view.layout(0, 0, view.getMeasuredWidth(), view.getMeasuredHeight());
    Bitmap bitmap = Bitmap.createBitmap(view.getWidth(), view.getHeight(), Bitmap.Config.RGB_565);
    Canvas canvas = new Canvas(bitmap);
    // 绘制出View
    view.draw(canvas);
}

上面的代码比第一种平常的截图就多了两个方法，measure和layout，measure方法需要传入View的宽高，一般设置一个确定的值即可。

RecyclerView截图

网上有很多例子和教程来教大家怎么截取RecyclerView的图片的，但是现在基本上RecyclerView都是有图片的，所以涉及到异步去加载图片；然而，当使用Stack Overflow中代码时，截取到的获取还只是你设置到图片上的加载中的图片，我找了许久，才知道应该用同步的加载图片方法，当所有的图片加载完之后获取到截图；

当然，这些同步加载图片的方法，因为是耗时线程，需要将代码放到异步线程中，然后处理完之后切换到同步线程中，我这里使用了Rxjava2中的defer方法：

// 分享  截图
Observable
        .defer(new Callable<ObservableSource<Bitmap>>() {
            @Override
            public ObservableSource<Bitmap> call() throws Exception {
                return new ObservableSource<Bitmap>() {
                    @Override
                    public void subscribe(Observer<? super Bitmap> observer) {
                        // MVP模式，从p层获取到RecyclerView的截图Bitmap数据
                        observer.onNext(mPresenter.getRecyclerViewScreenSpot(mRecyclerView));
                    }
                };
            }
        })
        .compose(applyAsySchedulers())
        .as(bindLifecycle())
        .subscribe(new Consumer<Bitmap>() {
            @Override
            public void accept(Bitmap bitmap) throws Exception {
                // 拿到结果之后，处理成自己想要的图片，
                mPresenter.getShareSpecimenFile(shareSpecimenBean, bitmap);
            }
        });

defer方法传入了一个Callable，当前执行的代码在异步线程中，compse方法注册在异步中，订阅在主线程中，所以就起到了切换线程的作用；拿到Bitmap之后，因为我这里需要将Bitmap嵌套到另外一个View，分享另外一个从LayoutInflater中加载的View，所以得在主线程中执行：

getRecyclerViewScrrentSpot(mRecyclerView):

@Override
public Bitmap getRecyclerViewScreenSpot(RecyclerView recyclerView) {
    //获取设置的adapter
    LoadMoreWrapper adapter = (LoadMoreWrapper) recyclerView.getAdapter();
    //创建保存截图的bitmap
    Bitmap bigBitmap = null;
    if (adapter != null) {
        //获取item的数量
        int size = adapter.getItemCount();
        //recycler的完整高度 用于创建bitmap时使用
        int height = 0;
        //获取最大可用内存
        final int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        // 使用1/8的缓存
        final int cacheSize = maxMemory / 8;
        //把每个item的绘图缓存存储在LruCache中
        LruCache<String, Bitmap> bitmapCache = new LruCache<>(cacheSize);
        for (int i = 0; i < size; i++) {
            //手动调用创建和绑定ViewHolder方法，
            RecyclerView.ViewHolder holder = 
                          adapter.createViewHolder(recyclerView,  adapter.getItemViewType(i));
            adapter.onBindViewImageSync(holder, i);
            //测量
            holder.itemView.measure(
                    View.MeasureSpec.makeMeasureSpec(recyclerView.getWidth() / 3, 
                                  View.MeasureSpec.EXACTLY), 
                    View.MeasureSpec.makeMeasureSpec(0, View.MeasureSpec.UNSPECIFIED));
            //布局
            holder.itemView.layout(0, 0, 
                                      holder.itemView.getMeasuredWidth(),
                                      holder.itemView.getMeasuredHeight());
            //开启绘图缓存
            holder.itemView.setDrawingCacheEnabled(true);
            holder.itemView.buildDrawingCache();
            Bitmap drawingCache = holder.itemView.getDrawingCache();
            if (drawingCache != null) {
                bitmapCache.put(String.valueOf(i), drawingCache);
            }
            //获取itemView的实际高度并累加
            if ((i + 1) % 3 == 0) {
                height += holder.itemView.getMeasuredHeight() + 
                              DensityUtil.dp2px(holder.itemView.getContext(), 20);
            }
            if ((i + 1) % 3 != 0 && (i + 1) == size) {
                height += holder.itemView.getMeasuredHeight() + 
                              DensityUtil.dp2px(holder.itemView.getContext(), 20);
            }
        }
        //根据计算出的recyclerView高度创建bitmap
        bigBitmap = Bitmap.createBitmap(recyclerView.getMeasuredWidth(), 
                                        height, Bitmap.Config.ARGB_8888);
        //创建一个canvas画板
        Canvas canvas = new Canvas(bigBitmap);
        //当前bitmap的高度
        int top = 0;
        int left = 0;
        //画笔
        Paint paint = new Paint();
        for (int i = 0; i < size; i++) {
            Bitmap bitmap = bitmapCache.get(String.valueOf(i));
            canvas.drawBitmap(bitmap, left, top, paint);
            if ((i + 1) % 3 == 0) {
                left = 0;
                top += bitmap.getHeight() + DensityUtil.dp2px(getUiView(), 20);
            } else {
                left += bitmapCache.get(String.valueOf(i)).getWidth();
            }
        }
    }
    return bigBitmap;
}

上面的代码是模板代码，网上搜基本上都是这样的写法；目的是为了解决OOM的问题，所以这里模拟了Adapter加载数据的情况，让它在后台执行加载数据，需要注意的是，在measure和layout的时候，需要根据你布局的实际情况来测量和布局，我这里的是GridLayoutManager，所以每次测量的时候都是一行三列，实际逻辑还是得跟你的界面来；

在获取到RecyclerView的holder之后，调用了adapter.onBindViewImageSync(holder, i)；这是我自定义的一个同步获取方法，目的是同步加载ImageView的图片，其他的数据都是和onBindView()重载的方法一样，我这里使用的是Glide加载图片，4.x的标本和3.x标本不同，基本上使用还是差不多的：

try {
    File file = Glide.with(this)
            .load(sampleListBean.getImgUrl())
            .downloadOnly(100, 100)
            .get(5, TimeUnit.SECONDS);
    Bitmap bitmap = BitmapFactory.decodeFile(file.getAbsolutePath());
    ivPlant.setImageBitmap(bitmap);
    L.d("图片加载成功！ ==== " + position + "   " + bitmap.toString());
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
} catch (TimeoutException e) {
    e.printStackTrace();
}

当然，这里有耗时操作，在截图的时候，需要弹出提示框加载；

截图完之后，因为项目需求美观，分享出去的图片并不是一张赤裸裸的长图，需要制作一张精美的图片，但是当RecyclerView得数据很多时，我使用了getDrawingCache() 时，获取到的数据为空，报错信息：

 Log.w(VIEW_LOG_TAG, getClass().getSimpleName() + " not displayed because it is"
                    + " too large to fit into a software layer (or drawing cache), needs "
                    + projectedBitmapSize + " bytes, only "
                    + drawingCacheSize + " available");

这是getDrawingCache()方法中判断当前创建缓存图片大小和系统最大图片大小，超过最大时报错，所以，我修改成Canvas之后便可以了；随后将制作的图片保存到本地：

File file = FileUtils.getInstance().getOwnCacheDirectory(getUiView(), Constants.PLANT_CACHE_DIR);
File takePhotoFile = new File(file, "specimenShare.png");
FileOutputStream fout = null;
try {
    fout = new FileOutputStream(takePhotoFile);
} catch (FileNotFoundException e) {
    e.printStackTrace();
}
bitmap.compress(Bitmap.CompressFormat.PNG, 100, fout);

通过保存后的文件，便可以分享到QQ、微信了！

Github代码

总结

getDrawingCache() 方法已经过时，谷歌推荐使用PixelCopy中的API使用，目前我没有试过，有使用过的朋友方便提交代码？
可以使用Canvas来解决OOM的问题
异步线程中同步加载图片方法
RecyclerView截图需要判断当前LayoutManager