首先科普下图片压缩的基础知识
在 Android 平台上，默认提供的压缩有三种方式：质量压缩和两种尺寸压缩，邻近采样以及双线性采样。下面我们简单介绍下者三种压缩方式都是如何使用的：
在实际使用过程中，我们通常会结合三种压缩方式使用，一般使用的步骤如下，
1、使用邻近采样对原始的图片进行采样，将图片控制到比目标尺寸稍大的大小，防止 OOM；
2、使用双线性采样对图片的尺寸进行压缩，控制图片的尺寸为目标的大小；
3、对上述两个步骤之后得到的图片 Bitmap 进行质量压缩，并将其输出到磁盘上。
- 1.1 质量压缩
所谓的质量压缩就是下面的这行代码，它是 Bitmap 的方法。当我们得到了 Bitmap 的时候，即可使用这个方法来实现质量压缩。它一般位于我们所有压缩方法的最后一步。
Bitmapcompress(CompressFormat format, int quality, OutputStream stream)
该方法接受三个参数，其含义分别如下：
format：枚举，有三个选项 JPEG, PNG 和 WEBP，表示图片的格式；
quality：图片的质量，取值在 [0,100] 之间，表示图片质量，越大，图片的质量越高；
stream：一个输出流，通常是我们压缩结果输出的文件的流
- 1.2 邻近采样
邻近采样基于临近点插值算法，用像素代替周围的像素。
邻近采样的核心代码只有下面三行，
BitmapFactory.Options options = new BitmapFactory.Options();
options.inSampleSize = 1;
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.blue_red, options);
邻近采样核心的地方在于 inSampleSize 的计算。它通常是我们使用的压缩算法的第一步。
我们可以通过设置 inSampleSize 来得到原始图片采样之后的结果，而不是将原始的图片全部加载到内存中，以防止 OOM。
标准使用姿势如下：
// 获取原始图片的尺寸
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;
options.inSampleSize = 1;
BitmapFactory.decodeStream(srcImg.open(), null, options);
this.srcWidth = options.outWidth;
this.srcHeight = options.outHeight;
// 进行图片加载，此时会将图片加载到内存中
options.inJustDecodeBounds = false;
options.inSampleSize = calInSampleSize();
Bitmap bitmap = BitmapFactory.decodeStream(srcImg.open(), null, options);
这里主要分成两个步骤，它们各自的含义是：
先通过设置 Options 的 inJustDecodeBounds 为 true，来加载图片，以得到图片的尺寸信息。此时图片不会被加载到内存中，所以不会造成 OOM，同时我们可以通过 Options 得到原图的尺寸信息。
根据上一步中得到的图片的尺寸信息，计算一个 inSampleSize，然后将 inJustDecodeBounds 设置为 false，以加载采样之后的图片到内存中。
关于 inSampleSize 需要简单说明一下：
inSampleSize 代表压缩后的图像一个像素点代表了原来的几个像素点，例如 inSampleSize 为 4，则压缩后的图像的宽高是原来的 1/4，像素点数是原来的 1/16，inSampleSize 一般会选择 2 的指数，如果不是 2 的指数，内部计算的时候也会向 2 的指数靠近。
所以，实际使用过程中，我们会通过明确指定 inSampleSize 为 2 的指数，来避免内部计算导致的不确定性。
- 1.3 双线性采样
近采样可以对图片的尺寸进行有效的控制，但是它存在几个问题。比如，当我需要把图片的宽度压缩到 1200 左右的时候，如果原始的图片的宽度压是 3200，那么我只能通过设置 inSampleSize 将采样率设置为 2 来将其压缩到 1600. 此时图片的尺寸比我们的要求要大。
就是说，邻近采样无法对图片的尺寸进行更加精准的控制。如果需要对图片尺寸进行更加精准的控制，那么就需要使用双线性压缩了。
双线性采样采用双线性插值算法，相比邻近采样简单粗暴的选择一个像素点代替其他像素点，双线性采样参考源像素相应位置周围 2x2 个点的值，根据相对位置取对应的权重，经过计算得到目标图像。
它在 Android 中的使用也比较简单，
Bitmap bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.blue_red);
Matrix matrix = new Matrix();
matrix.setScale(0.5f, 0.5f);
Bitmap sclaedBitmap = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth()/2, bitmap.getHeight()/2, matrix, true);
也就是对得到的 Bitmap 应用 createBitmap() 进行处理，并传入 Matrix 指定图片尺寸放缩的比例。该方法返回的 Bitmap 就是双线性压缩之后的结果。
异步调用
Luban内部采用IO线程进行图片压缩，外部调用只需设置好结果监听即可：
Luban.with(this)
.load(photos) // 传人要压缩的图片列表
.ignoreBy(100) // 忽略不压缩图片的大小
.setTargetDir(getPath()) // 设置压缩后文件存储位置
.setCompressListener(new OnCompressListener() { //设置回调
@Override
public void onStart() {
// TODO 压缩开始前调用，可以在方法内启动 loading UI
}
@Override
public void onSuccess(File file) {
// TODO 压缩成功后调用，返回压缩后的图片文件
}
@Override
public void onError(Throwable e) {
// TODO 当压缩过程出现问题时调用
}
}).launch(); //启动压缩
同步调用
同步方法请尽量避免在主线程调用以免阻塞主线程，下面以rxJava调用为例
Flowable.just(photos)
.observeOn(Schedulers.io())
.map(new Function<List<String>, List<File>>() {
@Override public List<File> apply(@NonNull List<String> list) throws Exception {
// 同步方法直接返回压缩后的文件
return Luban.with(MainActivity.this).load(list).get();
}
})
.observeOn(AndroidSchedulers.mainThread())
.subscribe();
源码分析
第一步：Luban.with()
public static Builder with(Context context) {
return new Builder(context);
}
public static class Builder {
private Context context;//上下文对象
private String mTargetDir;//压缩后图片存放位置
private List<String> mPaths;//多个文件的list
private int mLeastCompressSize = 100;//忽略100kb以下的图片，不压缩
private OnCompressListener mCompressListener;//回调方法
Builder(Context context) {
this.context = context;
this.mPaths = new ArrayList<>();
}
private Luban build() {
return new Luban(this);
}
}
private Luban(Builder builder) {
this.mPaths = builder.mPaths;
this.mTargetDir = builder.mTargetDir;
this.mCompressListener = builder.mCompressListener;
this.mLeastCompressSize = builder.mLeastCompressSize;
mHandler = new Handler(Looper.getMainLooper(), this);
}
这里是一个静态的with方法，返回值是Builder，他这里使用的是建造者模式。什么是建造者模式呢其实说白了，就是在创建对象的时候，减少初始化数据的代码，怎么理解呢？我们接着往下看。我们点到Builder里面看到如下代码：
第二步：load()
点击去看到源码为
public Builder load(final File file) {
mStreamProviders.add(new InputStreamProvider() {
@Override
public InputStream open() throws IOException {
return new FileInputStream(file);
}
@Override
public String getPath() {
return file.getAbsolutePath();
}
});
return this;
}
-----------------------------------------------------------------------------------
public Builder load(final String string) {
mStreamProviders.add(new InputStreamProvider() {
@Override
public InputStream open() throws IOException {
return new FileInputStream(string);
}
@Override
public String getPath() {
return string;
}
});
return this;
}
------------------------------------------------------------------------------
public <T> Builder load(List<T> list) {
for (T src : list) {
if (src instanceof String) {
load((String) src);
} else if (src instanceof File) {
load((File) src);
} else if (src instanceof Uri) {
load((Uri) src);
} else {
throw new IllegalArgumentException("Incoming data type exception, it must be String, File, Uri or Bitmap");
}
}
return this;
}
这里，我们会看到三个重载方法，一个传文件，他会获取到文件的绝对路径存进去，实际上还是存的字符串，中间那个存的是字符串，最后面那个传String类型的list，最终会遍历list，还是存在了mStreamProviders 的集合里面
第三步：ignoreBy() 和 setTargetDir()，setCompressListener（）
点击去看到源码为
//图像低于size 不做压缩处理
public Builder ignoreBy(int size) {
this.mLeastCompressSize = size;
return this;
}
//设置压缩后的存储路径
public Builder setTargetDir(String targetDir) {
this.mTargetDir = targetDir;
return this;
}
//设置监听 压缩方法的回调
public Builder setCompressListener(OnCompressListener listener) {
this.mCompressListener = listener;
return this;
}
第五步：launch()
点击去看到源码为
/**
* begin compress image with asynchronous
*/
public void launch() {
build().launch(context);
}
启动异步压缩线程，看源码我们可以知道里面采用的是AsyncTask 来作为异步任务，不熟悉AsyncTask 的可以看看我这篇文章AsyncTask源码解析
/**
* start asynchronous compress thread
*/
private void launch(final Context context) {
if (mStreamProviders == null || mStreamProviders.size() == 0 && mCompressListener != null) {
mCompressListener.onError(new NullPointerException("image file cannot be null"));
}
//首先，他这个是用的迭代器，循环遍历，遍历一个就移除一个
Iterator<InputStreamProvider> iterator = mStreamProviders.iterator();
while (iterator.hasNext()) {
final InputStreamProvider path = iterator.next();
//开始执行压缩任务
AsyncTask.SERIAL_EXECUTOR.execute(new Runnable() {
@Override
public void run() {
try {
mHandler.sendMessage(mHandler.obtainMessage(MSG_COMPRESS_START));
//开始压缩
File result = compress(context, path);
// 然后就是通过handler发消息调用
mHandler.sendMessage(mHandler.obtainMessage(MSG_COMPRESS_SUCCESS, result));
} catch (IOException e) {
mHandler.sendMessage(mHandler.obtainMessage(MSG_COMPRESS_ERROR, e));
}
}
});
//移除
iterator.remove();
}
}
接着我们来看开始压缩的方法
private File compress(Context context, InputStreamProvider path) throws IOException {
File result;
File outFile = getImageCacheFile(context, Checker.SINGLE.extSuffix(path));
if (mRenameListener != null) {
String filename = mRenameListener.rename(path.getPath());
outFile = getImageCustomFile(context, filename);
}
if (mCompressionPredicate != null) {
if (mCompressionPredicate.apply(path.getPath())
&& Checker.SINGLE.needCompress(mLeastCompressSize, path.getPath())) {
result = new Engine(path, outFile, focusAlpha).compress();
} else {
result = new File(path.getPath());
}
} else {
//他整体是一个三目运算符，我们点needCompress()方法看一下
result = Checker.SINGLE.needCompress(mLeastCompressSize, path.getPath()) ?
new Engine(path, outFile, focusAlpha).compress() :
new File(path.getPath());
}
return result;
}
--------------------------------------------------------------------------
boolean needCompress(int leastCompressSize, String path) {
if (leastCompressSize > 0) {
File source = new File(path);
return source.exists() && source.length() > (leastCompressSize << 10);
}
return true;
}
needCompress() 这个方法就是用来判断，你给定路径的图片大小和你规定的忽略文件大小比较，他这里先做了你给定的最小值判断，要大于0，不大于0就返回ture。然后做了文件是否存在的判断，如果文件不存在，就返回fals。最后，给定文件大小是不是小于等于最小值左移10位的值，小于就返回false。
然后，如果返回的是true，就去压缩，如果，返回的是false，就直接返回file文件。压缩的方法点进去：
new Engine(path, outFile, focusAlpha).compress() :
接着我们来看Engine 类，它的类注释就是：用于操作，开始压缩，管理活动，缓存资源的类。他这里传原文件，也就是你需要压缩的图片，还有一个就是目标文件，也就是你压缩之后，要保存的文件。
一切准备就绪，真正的压缩方法请看下面
File compress() throws IOException {
BitmapFactory.Options options = new BitmapFactory.Options();
//邻近采样压缩
options.inSampleSize = computeSize();
Bitmap tagBitmap = BitmapFactory.decodeStream(srcImg.open(), null, options);
ByteArrayOutputStream stream = new ByteArrayOutputStream();
if (Checker.SINGLE.isJPG(srcImg.open())) {
tagBitmap = rotatingImage(tagBitmap, Checker.SINGLE.getOrientation(srcImg.open()));
}
//质量压缩，注意这里质量quality 传的是60 ，quality：图片的质量，取值在 [0,100] 之间，表示图片质量，越大，图片的质量越高；
tagBitmap.compress(focusAlpha ?
Bitmap.CompressFormat.PNG : Bitmap.CompressFormat.JPEG, 60, stream);
tagBitmap.recycle();
FileOutputStream fos = new FileOutputStream(tagImg);
fos.write(stream.toByteArray());
fos.flush();
fos.close();
stream.close();
return tagImg;
}
整个最核心的就是Launch方法
- 首先，他这个是用的迭代器，循环遍历，遍历一个就移除一个
- 然后就是通过handler发消息调用
- 具体压缩代码
鲁班最核心的压缩算法，本人学艺不精，复制了github上的，哪位大神精通，可以指教下。
- 判断图片比例值，是否处于以下区间内；
[1, 0.5625) 即图片处于 [1:1 ~ 9:16) 比例范围内
[0.5625, 0.5) 即图片处于 [9:16 ~ 1:2) 比例范围内
[0.5, 0) 即图片处于 [1:2 ~ 1:∞) 比例范围内
判断图片最长边是否过边界值；
[1, 0.5625) 边界值为：1664 * n（n=1）, 4990 * n（n=2）, 1280 * pow(2, n-1)（n≥3）
[0.5625, 0.5) 边界值为：1280 * pow(2, n-1)（n≥1）
[0.5, 0) 边界值为：1280 * pow(2, n-1)（n≥1）计算压缩图片实际边长值，以第2步计算结果为准，超过某个边界值则：width / pow(2, n-1)，height/pow(2, n-1)
计算压缩图片的实际文件大小，以第2、3步结果为准，图片比例越大则文件越大。
size = (newW * newH) / (width * height) * m；
[1, 0.5625) 则 width & height 对应 1664，4990，1280 * n（n≥3），m 对应 150，300，300；
[0.5625, 0.5) 则 width = 1440，height = 2560, m = 200；
[0.5, 0) 则 width = 1280，height = 1280 / scale，m = 500；注：scale为比例值判断第4步的size是否过小
[1, 0.5625) 则最小 size 对应 60，60，100
[0.5625, 0.5) 则最小 size 都为 100
[0.5, 0) 则最小 size 都为 100
将前面求到的值压缩图片 width, height, size 传入压缩流程，压缩图片直到满足以上数值
