Android图片的压缩与缓存策略

*   On Android 2.3.3 (API level 10) and lower, the backing pixel data for a bitmap is stored in native memory. It is separate from the bitmap itself, which is stored in the Dalvik heap. The pixel data in native memory is not released in a predictable manner, potentially causing an application to briefly exceed its memory limits and crash. From Android 3.0 (API level 11) through Android 7.1 (API level 25), the pixel data is stored on the Dalvik heap along with the associated bitmap. In Android 8.0 (API level 26), and higher, the bitmap pixel data is stored in the native heap.

</div>

一、Bitmap占用内存大小

Android 中提供一下几种Bitmap编码：

二、Bitmap的几种压缩方式

1、质量压缩

在保持像素的前提下通过JEPG、PNG和WEBP图片格式的压缩算法来改变图片的存储大小，这样适合去传递二进制的图片数据，比如分享图片，要传入二进制数据过去，限制在XX kb之内。存在两个特点：

（1）bitmap图片占用的内存大小并不会改变；

（2）bytes.length是随着quality变小而变小的。

/**
 * 一种质量压缩方法
 *
 * @param src           源图片
 * @param maxByteSize   允许最大值字节数
 * @param recycle       是否回收
 * @return              质量压缩压缩过的图片
 */
public static Bitmap compressByQuality(final Bitmap src, final long maxByteSize, final boolean recycle) {
    if (src == null || src.getWidth() == 0 || src.getHeight() == 0 || maxByteSize <= 0) {
        return null;
    }
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    src.compress(Bitmap.CompressFormat.JPEG, 100, baos);
    byte[] bytes;
    if (baos.size() <= maxByteSize) {// 最好质量的不大于最大字节，则返回最佳质量
        bytes = baos.toByteArray();
    } else {
        baos.reset();
        src.compress(Bitmap.CompressFormat.JPEG, 0, baos);
        if (baos.size() >= maxByteSize) { // 最差质量不小于最大字节，则返回最差质量
            bytes = baos.toByteArray();
        } else {
            // 二分法寻找最佳质量
            int st = 0;
            int end = 100;
            int mid = 0;
            while (st < end) {
                mid = (st + end) / 2;
                baos.reset();
                src.compress(Bitmap.CompressFormat.JPEG, mid, baos);
                int len = baos.size();
                if (len == maxByteSize) {
                    break;
                } else if (len > maxByteSize) {
                    end = mid - 1;
                } else {
                    st = mid + 1;
                }
            }
            if (end == mid - 1) {
                baos.reset();
                src.compress(Bitmap.CompressFormat.JPEG, st, baos);
            }
            bytes = baos.toByteArray();
        }
    }
    if (recycle && !src.isRecycled()){
        src.recycle();
    }
    Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
    return bitmap;
}

2、采样压缩

注意：官方文档指出：inSampleSize的取值应该总是2的指数，如1,2,4,8等，如果外界传入的inSampleSize的孩子不为2的指数，那么系统会向下取整并选择一个最接近2的指数代替。

我们需要获取加载图片的宽高信息，然后交给inSampleSize参数选择缩放比缩放。那么如何能先不加载图片却能获取图片的宽高信息，通过inJustDecodeBounds=true，然后加载图片就可以实现只解析图片的宽高信息，并不会真正的加载图片，所以这个操作时轻量级的，当获取了宽高信息，计算出缩放比后，然后再将inJustDecodeBounds=false，再重新加载图片，就可以加载缩小后的图片。

public static Bitmap compressBySampleSize(final Bitmap src, final int maxWidth, final int maxHeight, final boolean recycle) {
    if (src == null || src.getWidth() == 0 || src.getHeight() == 0) {
        return null;
    }
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    src.compress(Bitmap.CompressFormat.JPEG, 100, baos);
    byte[] bytes = baos.toByteArray();
    BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);
    options.inSampleSize = calculateInSampleSize(options, maxWidth, maxHeight);
    options.inJustDecodeBounds = false;
    if (recycle && !src.isRecycled()) {
        src.recycle();
    }
    Bitmap bitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length, options);
    return bitmap;
}

/**
 * 计算获取缩放比例inSampleSize
 */
private static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
    final int height = options.outHeight;
    final int width = options.outWidth;
    int inSampleSize = 1;
    if (height > reqHeight || width > reqWidth) {
        final int heightRatio = Math.round((float) height / (float) reqHeight);
        final int widthRatio = Math.round((float) width / (float) reqWidth);
        inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
    }
    final float totalPixels = width * height;
    final float totalReqPixelsCap = reqWidth * reqHeight * 2;
    while (totalPixels / (inSampleSize * inSampleSize) > totalReqPixelsCap) {
        inSampleSize++;
    }
    return inSampleSize;
}

3、缩放压缩

Android SDK 提供了Matrix类，用来对图像进行缩放、旋转、平移、斜切等操作，同样的这个类也可以运用于bitmap。放缩法压缩使用的是通过矩阵对图片进行裁剪，也是通过缩放图片尺寸，来达到压缩图片的效果，和采样率的原理一样。但是相较于采样压缩，它的优势在于采样率可以取任意值，而不是限制在2的指数，劣势是压缩的对象必须是已经加载到内存中的Bitmap，而不能是存在磁盘中的源文件。

private static Bitmap scale(final Bitmap src, final float scaleWidth, final float scaleHeight, final boolean recycle) {
    if (src == null || src.getWidth() == 0 || src.getHeight() == 0) {
        return null;
    }
    Matrix matrix = new Matrix();
    matrix.setScale(scaleWidth, scaleHeight);
    Bitmap ret = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, true);
    if (recycle && !src.isRecycled()) {
        src.recycle();
    }
    return ret;
}

三、Bitmap内存的复用

我们常说的图片三级缓存：内存缓存、硬盘缓存、网络缓存。

//1.初始化LruCache.
        int maxMemory = (int) (Runtime.getRuntime().maxMemory() / 1024);
        int cacheSize = maxMemory / 8;
        mCache = new LruCache<Integer,Bitmap>(cacheSize){
            @Override
            protected int sizeOf(Integer key, Bitmap value) {
                return value.getRowBytes() * value.getHeight() / 1024;
            }
        };

    }

    //2.从Cache中获取数据
    public Bitmap getDataFromCache(int key) {
        if (mCache.size() != 0) {
            return mCache.get(key);
        }
        return null;
    }

    //3.将数据存储到Cache中
    public void putDataToCache(int key, Bitmap bitmap) {
        if (getDataFromCache(key) == null) {
            mCache.put(key,bitmap);
        }
    }

磁盘缓存所使用的算法为DiskLruCache，它的使用比内存缓存要复杂一点，但是还是离不开上面的3步，初始化，查找和添加。DiskLruCache的创建是DiskLruCache.open()来创建，其中会传入4个参数，第一个参数表示磁盘缓存所要存储的路径，一般来说，如果外部设备存在，那么存储路径放置在 /storage/emulated/0/Android/data/package_name/cache 中；反之就放置在 /data/data/package_name/cache 这个目录下。存储路径可以根据自己的实际要求进行制定，值得注意的是，如果缓存路径选择SD卡上的缓存目录，即 /storage/emulated/0/Android/data/package_name/cache，那么当应用被卸载时，该目录也会被删除。

//初始化DiskLruCache。
        File directory = getFile(this,"DiskCache");
        if (!directory.exists()) {
            directory.mkdirs();
        }
        try {
            mDiskLruCache = DiskLruCache.open(directory, 1, 1, DISK_MAX_SIZE);
        } catch (IOException e) {
            e.printStackTrace();
        }

private void addDataToDisk(String url) {
        //采用url的md5值作为key。
        String key = hashKeyFromUrl(url);
        try {
            DiskLruCache.Editor editor = mDiskLruCache.edit(key);
            if (editor != null) {
                OutputStream outputStream = editor.newOutputStream(0);
                if (downloadDataFromNet(url, outputStream)) {
                    //提交至缓存
                    editor.commit();
                } else {
                    //回退整个操作
                    editor.abort();
                }
                mDiskLruCache.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

private String hashKeyFromUrl(String url) {
        String cacheKey;
        try {
            final MessageDigest digest = MessageDigest.getInstance("MD5");
            digest.update(url.getBytes());

            cacheKey = bytesToHexString(digest.digest());

        } catch (NoSuchAlgorithmException e) {
            cacheKey = String.valueOf(url.hashCode());
        }

        return cacheKey;
    }

private String bytesToHexString(byte[] bytes) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < bytes.length; i++) {
            String hex = Integer.toHexString(0xFF & bytes[i]);
            if (hex.length() == 1) {
                sb.append('0');
            }
            sb.append(hex);
        }

        return sb.toString();
    }

DiskLruCache的添加是通过Editor来完成，而查找是由DiskLruCache.Snapshot来完成的。首先通过url获取到当前文件的key值，初始化Snapshot后获取一个文件输入流，最后通过该文件输入流来解析出当前缓存的文件。

private Bitmap getDataFromDisk(String url) {
        Bitmap bitmap = null;
        String key = hashKeyFromUrl(url);
        try {
            DiskLruCache.Snapshot snapshot = mDiskLruCache.get(key);
            if (snapshot != null) {
                FileInputStream inputStream = (FileInputStream) snapshot.getInputStream(0);
                return BitmapFactory.decodeStream(inputStream);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }

五、主流的开源图片加载框架

 Picasso 收到加载及显示图片的任务，创建 Request 并将它交给 Dispatcher，Dispatcher 分发任务到具体 RequestHandler，任务通过 MemoryCache 及 Handler(数据获取接口) 获取图片，图片获取成功后通过 PicassoDrawable 显示到 Target 中。

注：Dispatcher 负责分发和处理 Action，包括提交、暂停、继续、取消、网络状态变化、重试等等。

2、Glide设计与流程分析

Glide是一个高效、开源、 Android设备上的媒体管理框架，Glide具有获取、解码和展示视频剧照、图片、动画等功能，它还有灵活的API，这些API使开发者能够将Glide应用在几乎任何网络协议栈里。创建Glide的主要目的有两个，一个是实现平滑的图片列表滚动效果（滚动流畅），另一个是支持远程图片的获取、大小调整和展示。简单的讲就是 Glide 收到加载及显示资源的任务，创建 Request 并将它交给RequestManager（任务管理器），Request 启动 Engine（数据获取引擎） 去数据源获取资源(通过 Fetcher（数据获取器） )，获取到后 Transformation（图片处理） 处理后交给 Target（目标）。

特点

• GIF动画的解码：通过调用Glide.with(context).load(“图片路径“)方法，GIF动画图片可以自动显示为动画效果。如果想有更多的控制，还可以使用Glide.with(context).load(“图片路径“).asBitmap()方法加载静态图片，使用Glide.with(context).load(“图片路径“).asGif()方法加载动画图片
• 本地视频剧照的解码：通过调用Glide.with(context).load(“视频路径“)方法，Glide能够支持Android设备中的所有视频剧照的加载和展示
• 缩略图的支持：为了减少在同一个view组件里同时加载多张图片的时间，可以调用Glide.with(context).load(“图片路径“).thumbnail(“缩略比例“).into(“view组件“)方法加载一个缩略图，还可以控制thumbnail()中的参数的大小，以控制显示不同比例大小的缩略图
• Activity生命周期的集成：当Activity暂停和重启时，Glide能够做到智能的暂停和重新开始请求，并且当Android设备的连接状态变化时，所有失败的请求能够自动重新请求
• 转码的支持：Glide的toBytes() 和transcode() 两个方法可以用来获取、解码和变换背景图片，并且transcode() 方法还能够改变图片的样式
• 动画的支持：新增支持图片的淡入淡出动画效果（调用crossFade()方法）和查看动画的属性的功能
• OkHttp和Volley的支持：默认选择HttpUrlConnection作为网络协议栈，还可以选择OkHttp和Volley作为网络协议栈
• 其他功能：如在图片加载过程中，使用Drawables对象作为占位符、图片请求的优化、图片的宽度和高度可重新设定、缩略图和原图的缓存等功能

3、Picasso 与 Glide对比

1）缓存方式不同

4）需要引用库的大小

Fresco与前面2者的差异较大，而且相对比较复杂，但是它可以说是综合了前面两个开源图片框架的有点，如果对图片要求比较高的应用，推荐使用它。

5、三大开源图片框架总结

public final class GlideBuilder {
  ...
  private GlideExecutor sourceExecutor; //加载源文件的线程池，包括网络加载
  private GlideExecutor diskCacheExecutor; //加载硬盘缓存的线程池
  ...
  private GlideExecutor animationExecutor; //动画线程池

    class EngineJob<R> implements DecodeJob.Callback<R>,Poolable {
	  private static final EngineResourceFactory DEFAULT_FACTORY = new EngineResourceFactory();
	  //创建Handler
	  private static final Handler MAIN_THREAD_HANDLER =
	      new Handler(Looper.getMainLooper(), new MainThreadCallback());

Glide 默认内存缓存用的也是LruCache，只不过并没有用Android SDK中的LruCache，不过内部同样是基于LinkHashMap，所以原理是一样的。

// -> GlideBuilder#build
if (memoryCache == null) {
  memoryCache = new LruResourceCache(memorySizeCalculator.getMemoryCacheSize());
}

    public class LruCache<K, V> {
	// 数据最终存在 LinkedHashMap 中
    private final LinkedHashMap<K, V> map;
	...
	public LruCache(int maxSize) {
        if (maxSize <= 0) {
            throw new IllegalArgumentException("maxSize <= 0");
        }
        this.maxSize = maxSize;
		// 创建一个LinkedHashMap，accessOrder 传true
        this.map = new LinkedHashMap<K, V>(0, 0.75f, true);
    }

LinkedHashMapEntry继承 HashMapEntry，添加before和after变量，所以是一个双向链表结构，还添加了addBefore和remove 方法，用于新增和删除链表节点。

LinkHashMap 的 put方法和get方法最后会调用trimToSize方法，LruCache 重写trimToSize方法，判断内存如果超过一定大小，则移除最老的数据。

	// DiskLruCache 内部也是用LinkedHashMap
	private final LinkedHashMap<String, Entry> lruEntries =
      	new LinkedHashMap<String, Entry>(0, 0.75f, true);
	...

    public synchronized boolean remove(String key) throws IOException {
	    checkNotClosed();
	    validateKey(key);
	    Entry entry = lruEntries.get(key);
	    if (entry == null || entry.currentEditor != null) {
	      return false;
	    }

            //一个key可能对应多个value，hash冲突的情况
	    for (int i = 0; i < valueCount; i++) {
	      File file = entry.getCleanFile(i);
            //通过 file.delete() 删除缓存文件，删除失败则抛异常
	      if (file.exists() && !file.delete()) {
	        throw new IOException("failed to delete " + file);
	      }
	      size -= entry.lengths[i];
	      entry.lengths[i] = 0;
	    }
	    ...
	    return true;
  }

private final class Entry {
    private final String key;

    private final long[] lengths;

    private boolean readable;

    private Editor currentEditor;

    private long sequenceNumber;
	...
}