Android图片压缩

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.OutputStream;

import android.content.Context;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.Bitmap.CompressFormat;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.provider.MediaStore.Images;
import android.util.Log;

public class ImageCompress
{
    public static final String CONTENT = "content";
    public static final String FILE = "file";

    /**
     * 图片压缩参数
     * 
     * @author Administrator
     * 
     */
    public static class CompressOptions
    {
        public static final int DEFAULT_WIDTH = 400;
        public static final int DEFAULT_HEIGHT = 800;

        public int maxWidth = DEFAULT_WIDTH;
        public int maxHeight = DEFAULT_HEIGHT;
        /**
         * 压缩后图片保存的文件
         */
        public File destFile;
        /**
         * 图片压缩格式,默认为jpg格式
         */
        public CompressFormat imgFormat = CompressFormat.JPEG;

        /**
         * 图片压缩比例 默认为30
         */
        public int quality = 30;

        public Uri uri;
    }

    public Bitmap compressFromUri(Context context, CompressOptions compressOptions)
    {
        // uri指向的文件路径
        String filePath = getFilePath(context, compressOptions.uri);

        if (null == filePath)
        {
            return null;
        }
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;

        Bitmap temp = BitmapFactory.decodeFile(filePath, options);

        int actualWidth = options.outWidth;
        int actualHeight = options.outHeight;

        int desiredWidth = getResizedDimension(compressOptions.maxWidth, compressOptions.maxHeight, actualWidth, actualHeight);
        int desiredHeight = getResizedDimension(compressOptions.maxHeight, compressOptions.maxWidth, actualHeight, actualWidth);

        options.inJustDecodeBounds = false;
        options.inSampleSize = findBestSampleSize(actualWidth, actualHeight, desiredWidth, desiredHeight);

        Bitmap bitmap = null;

        Bitmap destBitmap = BitmapFactory.decodeFile(filePath, options);

        // If necessary, scale down to the maximal acceptable size.
        if (destBitmap.getWidth() > desiredWidth || destBitmap.getHeight() > desiredHeight)
        {
            bitmap = Bitmap.createScaledBitmap(destBitmap, desiredWidth, desiredHeight, true);
            destBitmap.recycle();
        } 
        else
        {
            bitmap = destBitmap;
        }

        // compress file if need
        if (null != compressOptions.destFile)
        {
            compressFile(compressOptions, bitmap);
        }

        return bitmap;
    }

    /**
     * compress file from bitmap with compressOptions
     * 
     * @param compressOptions
     * @param bitmap
     */
    private void compressFile(CompressOptions compressOptions, Bitmap bitmap)
    {
        OutputStream stream = null;
        try
        {
            stream = new FileOutputStream(compressOptions.destFile);
        } 
        catch (FileNotFoundException e)
        {
            Log.e("ImageCompress", e.getMessage());
        }

        bitmap.compress(compressOptions.imgFormat, compressOptions.quality,
                stream);
    }

    private static int findBestSampleSize(int actualWidth, int actualHeight, int desiredWidth, int desiredHeight)
    {
        double wr = (double) actualWidth / desiredWidth;
        double hr = (double) actualHeight / desiredHeight;
        double ratio = Math.min(wr, hr);
        float n = 1.0f;
        while ((n * 2) <= ratio)
        {
            n *= 2;
        }

        return (int) n;
    }

    private static int getResizedDimension(int maxPrimary, int maxSecondary, int actualPrimary, int actualSecondary)
    {
        // If no dominant value at all, just return the actual.
        if (maxPrimary == 0 && maxSecondary == 0)
        {
            return actualPrimary;
        }

        // If primary is unspecified, scale primary to match secondary's scaling
        // ratio.
        if (maxPrimary == 0)
        {
            double ratio = (double) maxSecondary / (double) actualSecondary;
            return (int) (actualPrimary * ratio);
        }

        if (maxSecondary == 0)
        {
            return maxPrimary;
        }

        double ratio = (double) actualSecondary / (double) actualPrimary;
        int resized = maxPrimary;
        if (resized * ratio > maxSecondary)
        {
            resized = (int) (maxSecondary / ratio);
        }
        return resized;
    }

    /**
     * 获取文件的路径
     * 
     * @param scheme
     * @return
     */
    private String getFilePath(Context context, Uri uri)
    {
        String filePath = null;

        if (CONTENT.equalsIgnoreCase(uri.getScheme()))
        {
            Cursor cursor = context.getContentResolver().query(uri, new String[] { Images.Media.DATA }, null, null, null);

            if (null == cursor)
            {
                return null;
            }

            try
            {
                if (cursor.moveToNext())
                {
                    filePath = cursor.getString(cursor.getColumnIndex(Images.Media.DATA));
                }
            } 
            finally
            {
                cursor.close();
            }
        }

        // 从文件中选择
        if (FILE.equalsIgnoreCase(uri.getScheme()))
        {
            filePath = uri.getPath();
        }

        return filePath;
    }
}

 调用方式:

Object srcPath; // 源图片，可以是sdcard文件路径，也可以是图片库的Uri
String dstPath; // 压缩后的保存路径
CompressOptions options = new CompressOptions();
options.destFile = new File(dstPath);
options.maxWidth = 1000;
options.maxHeight = 1280;
options.uri = (srcPath instanceof Uri) ? ((Uri)srcPath) : Uri.fromFile(new File(srcPath.toString()));

Bitmap bitMap = new ImageCompress().compressFromUri(context, options);