开发中会有用户头像上传的需求，为了节省流量，一般上传接口都会限制图片大小，比如1M。但是随着手机像素越来越高，这个限制很容易达到，所以需要客户端在上传图片进行压缩操作。

先说一下思路：主要是等比缩小图片文件，辅之使用Bitmap#compress进行压缩。
①第一步根据文件路径创建File对象，然后判断File对象的大小，如果大于1M，就开始压缩操作；
②接着通过BitmapFactory.Options获取图片文件的宽高，先把图片宽高减半；然后根据缩小后的宽高创建新的Bitmap对象，这里通过Canvas将图像数据写到新的Bitmap中；接着利用Bitmap#compress方法将新Bitmap的数据写入到ByteArrayOutputStream中。
③接着判断ByteArrayOutputStream的size大小，如果还是超出目标大小，就继续将图片的宽高减半，重复执行步骤②。
④压缩完毕后将ByteArrayOutputStream写入到文件中即可。

话不多说，直接上代码：

/**
 * 压缩图片到目标大小以下
 *
 * @param file
 * @param targetSize
 */
public void compressBmpFileToTargetSize(File file, long targetSize) {
    Log.d(TAG, String.format("compressBmpFileToTargetSize start file.length():%d", file.length()));
    if (file.length() > targetSize) {
        // 每次宽高各缩小一半
        int ratio = 2;
        // 获取图片原始宽高
        BitmapFactory.Options options = new BitmapFactory.Options();
        Bitmap bitmap = BitmapFactory.decodeFile(file.getAbsolutePath(), options);
        int targetWidth = options.outWidth / ratio;
        int targetHeight = options.outHeight / ratio;

        // 压缩图片到对应尺寸
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        int quality = 100;
        Bitmap result = generateScaledBmp(bitmap, targetWidth, targetHeight, baos, quality);

        // 计数保护，防止次数太多太耗时。
        int count = 0;
        while (baos.size() > targetSize && count <= 10) {
            targetWidth /= ratio;
            targetHeight /= ratio;
            count++;

            // 重置，不然会累加
            baos.reset();
            result = generateScaledBmp(result, targetWidth, targetHeight, baos, quality);
        }
        try {
            FileOutputStream fos = new FileOutputStream(file);
            fos.write(baos.toByteArray());
            fos.flush();
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    Log.d(TAG, String.format("compressBmpFileToTargetSize end file.length():%d", file.length()));
}

/**
 * 图片缩小一半
 *
 * @param srcBmp
 * @param targetWidth
 * @param targetHeight
 * @param baos
 * @param quality
 * @return
 */
private Bitmap generateScaledBmp(Bitmap srcBmp, int targetWidth, int targetHeight, ByteArrayOutputStream baos, int quality) {
    Bitmap result = Bitmap.createBitmap(targetWidth, targetHeight, Bitmap.Config.ARGB_8888);
    Canvas canvas = new Canvas(result);
    Rect rect = new Rect(0, 0, result.getWidth(), result.getHeight());
    canvas.drawBitmap(srcBmp, null, rect, null);
    if (!srcBmp.isRecycled()) {
        srcBmp.recycle();
    }
    result.compress(Bitmap.CompressFormat.JPEG, quality, baos);
    return result;
}

需要注意的是，第一次将图片文件的宽高减半，通过Bitmap#compress方法将新Bitmap的数据写入到ByteArrayOutputStream中后，此时ByteArrayOutputStream中的数据已经大幅减少了，减少的幅度是不好控制的，不会是刚好小于1M，这里只是选取了一个比较有效的方式。

当然了，压缩操作是需要放在子线程的，具体代码如下：

Observable.create(new ObservableOnSubscribe<String>() {
    @Override
    public void subscribe(ObservableEmitter<String> emitter) throws Exception {
        try {
            File f = new File(avatarFileUrl);
            compressBmpFileToTargetSize(f, 1024 * 1024);
            emitter.onNext(avatarFileUrl);
            emitter.onComplete();
        } catch (Exception e) {
            e.printStackTrace();
            emitter.onError(new Throwable("获取图片失败"));
        }
    }
})
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Observer<String>() {
            @Override
            public void onSubscribe(Disposable d) {
                compositeDisposable.add(d);
            }

            @Override
            public void onNext(String s) {
                // 上传头像到服务器
            }

            @Override
            public void onError(Throwable e) {
                ToastUtil.show(mContext, e.getMessage());
            }

            @Override
            public void onComplete() {
            }
        });

最后别忘了处理下RxJava的内存泄漏：

@Override
protected void onDestroy() {
    super.onDestroy();
    compositeDisposable.dispose();
}

当然了，这里没有提供图片文件路径的兼容处理、读写权限的处理等，这些需要读者自己去实现。