(转)android 压缩图片大小

无简介

package com.img.util;

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.BitmapFactory;
import android.graphics.Bitmap.CompressFormat;
import android.net.Uri;
import android.os.Environment;
import android.provider.MediaStore.Images;
import android.util.Log;

/**
* 图片压缩工具类
*
* @author Administrator
*
*/
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;
}

}

调用方法：

ImageCompress compress = new ImageCompress();
ImageCompress.CompressOptions options = new ImageCompress.CompressOptions();
options.uri = imgUri;
options.maxWidth=getWindowManager().getDefaultDisplay().getWidth();
options.maxHeight=getWindowManager().getDefaultDisplay().getHeight();
Bitmap bitmap = compress.compressFromUri(this, options);