图片的压缩（二次采样）

package com.qianfeng.bitmapdisplay.tasks;

import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.Drawable;
import android.os.AsyncTask;
import android.widget.ImageView;
import com.qianfeng.bitmapdisplay.cache.FileCache;
import com.qianfeng.bitmapdisplay.utils.HttpTools;

import java.lang.ref.WeakReference;

/**
 * Created
 * Author: vhly[FR]
 * Email: vhly@163.com
 * Date: 2015/10/12
 */
public class ImageLoadTask extends AsyncTask<String, Integer, Bitmap> {

    /**
     * 使用弱引用来进行ImageView对象的引用,当UI销毁,任务不再使用ImageView
     */
    private final WeakReference<ImageView> imageViewReference;

    /**
     * 加载的图片，最终显示的宽度
     */
    private int requestWidth;

    private int requestHeight;

    /**
     * 异步任务的构造
     *
     * @param imageView ImageView 需要显示的ImageView
     * @param reqWidth  请求的宽度 0 代表显示原始图像，> 0 将图像缩小
     * @param reqHeight 请求的高度 0 代表显示原始图像，> 0 将图像缩小
     */
    public ImageLoadTask(ImageView imageView, int reqWidth, int reqHeight) {
        imageViewReference = new WeakReference<ImageView>(imageView);

        requestWidth = reqWidth;

        requestHeight = reqHeight;
    }

    @Override
    protected Bitmap doInBackground(String... params) {
        Bitmap ret = null;

        if (params != null && params.length > 0) {

            String url = params[0];

            // 获取 url 对应的文件缓存
            byte[] data = FileCache.getInstance().load(url);

            if (data != null) {
                // TODO 有文件数据,那么不需要联网
            } else {
                // TODO 联网下载图片
                data = HttpTools.doGet(url);
                FileCache.getInstance().save(url, data);
            }

            if (data != null) {


                // 按照原始的图片尺寸，进行Bitmap的生成，
                // 按照Bitmap生成，是按照 图片原始宽高，进行生成，并且每一个像素占用四个字节 也就是 ARGB
                // ret = BitmapFactory.decodeByteArray(data, 0, data.length);


                // 采用二次采样(缩小图片尺寸的方式)

                // 1. 步骤1 获取原始图片的宽高信息，用于进行采样的计算

                // 1.1 创建 Options ，给BitmapFactory 的内部解码器传递参数
                BitmapFactory.Options options = new BitmapFactory.Options();

                // 1.2 设置 inJustDecodeBounds 来控制解码器，只进行图片宽高的获取，不会加载 Bitmap
                //     不占用内存，当使用这个参数，代表 BitmapFactory.decodeXxxx 类似的方法，不会返回 Bitmap
                options.inJustDecodeBounds = true;

                // 解码，使用 Options 参数设置 解码方式
                BitmapFactory.decodeByteArray(data, 0, data.length, options);

                //------------------------------------------

                // 2. 步骤2 根据图片的真实尺寸，与当前需要显示的尺寸，进行计算，生成图片采样率。

                // 2.1

                int picW = options.outWidth;   // 6000
                int picH = options.outHeight;  // 4000

                // 2.2 准备 显示在 手机上的尺寸。 256x128   128x64
                //     尺寸是根据程序需要来设置的。

                // maxWidth, maxHeight
                int reqW = requestWidth;

                int reqH = requestHeight;  // 测试数据

                // 2.3 计算、设置 图片采样率

                options.inSampleSize =
                        calculateInSampleSize(options, reqW, reqH);  // 宽度的 1/32  高度的 1/32

                // 2.4 开放 解码，实际生成Bitmap
                options.inJustDecodeBounds = false;

                // 2.4.1 Bitmap.Config 的说明
                // 要求解码器对于每一个采样的像素，使用 RGB_565 存储方式
                // 一个像素，占用两个 字节；比 ARGB_8888 小了一半。
                // 如果解码器不能够使用指定配置，就自动使用 ARGB_8888
                options.inPreferredConfig = Bitmap.Config.RGB_565;

                // 2.4.2 是一个过时的设置
                options.inPurgeable = true;

                // 2.5 使用设置采样的参数，来进行 解码，获取 Bitmap
                ret = BitmapFactory.decodeByteArray(data, 0, data.length, options);

                // data 需要显示释放
                data = null;

            }
        }

        return ret;
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        if (bitmap != null) {

            // 获取弱引用包含的对象,可能为null
            ImageView imageView = imageViewReference.get();

            if (imageView != null) {
                // 每一个图片都可以包含 AsyncDrawable对象
                // 这个对象用于处理图片错位的
                Drawable drawable = imageView.getDrawable();

                if (drawable != null && drawable instanceof AsyncDrawable) {
                    // 用于检测图片错位

                    AsyncDrawable asyncDrawable = (AsyncDrawable) drawable;

                    ImageLoadTask task = asyncDrawable.getImageLoadTask();

                    // 当前ImageView 内部包含的 AsyncDrawable和当前
                    // 任务是对应的，代表 当前任务可以设置图片
                    if (this == task) {
                        imageView.setImageBitmap(bitmap);
                    }

                } else { // 不用检测 图片错位的情况
                    imageView.setImageBitmap(bitmap);
                }
            }

        }
    }

    /**
     * 计算图片二次采样的采样率，使用获取图片宽高之后的 Options 作为第一个参数；
     * 并且，通过请求的 宽度、高度尺寸，进行采样率的计算；
     *
     * @param options
     * @param reqWidth  请求的宽度
     * @param reqHeight 请求的高度
     * @return int 采样率
     */
    public static int calculateInSampleSize(
            BitmapFactory.Options options, int reqWidth, int reqHeight) {
        // Raw height and width of image
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        // 当请求的宽度、高度 > 0 时候，进行缩放，
        // 否则，图片不进行缩放；
        if (reqWidth > 0 && reqHeight > 0) {
            if (height > reqHeight || width > reqWidth) {

                final int halfHeight = height / 2;
                final int halfWidth = width / 2;

                // Calculate the largest inSampleSize value that is a power of 2 and keeps both
                // height and width larger than the requested height and width.
                while ((halfHeight / inSampleSize) >= reqHeight
                        && (halfWidth / inSampleSize) >= reqWidth) {
                    inSampleSize *= 2;
                }
            }
        }

        return inSampleSize;
    }

}

上面的是  比较正规具体的压缩方式  decodeByteArray

下边的是比较快捷的方式   decodeFile

private void resizePhoto() {
BitmapFactory.Options options = new BitmapFactory.Options();
options.inJustDecodeBounds = true;  //此属性为true的时候  只把bitmap的宽和高加载出来  并不把图片加载到内存

BitmapFactory.decodeFile(mcurrentPhotoPath, options);

double ratio = Math.max(options.outWidth*1.0d/1024 , options.outHeight*1.0d/1024);

options.inSampleSize = (int)Math.ceil(ratio);

options.inJustDecodeBounds = false;  //此属性为false的时候  把图片加载到内存

mphotoImage = BitmapFactory.decodeFile(mcurrentPhotoPath, options);
}

上边主要是对图片大小的压缩  下边是对质量的压缩

//质量压缩    这种方式的压缩 是针对压缩到磁盘的file文件会变小  但是加载在内存的bitmap大小是不会变的
//上边的尺寸压缩  是针对加载到内存的Bitmap是会变小的，但是磁盘上的file大小是不会变的  只是读取时候按照小的 比例 去读取而已

    public static Bitmap compressImage(Bitmap image, int size) {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        image.compress(Bitmap.CompressFormat.JPEG, 100, baos);//质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
        int options = 100;
        while ( baos.toByteArray().length / 1024>50) {   //循环判断如果压缩后图片是否大于50kb,大于继续压缩       
            baos.reset();//重置baos即清空baos
            image.compress(Bitmap.CompressFormat.JPEG, options, baos);//这里压缩options%，把压缩后的数据存放到baos中
            options -= 10;//每次都减少10
        }
        ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());//把压缩后的数据baos存放到ByteArrayInputStream中
        Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, null);//把ByteArrayInputStream数据生成图片
        return bitmap;
    }