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;
    }
}

ImageCompress.java

 

 调用方式:

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);