Android图片处理-图片压缩处理

这里先重复温习一下上一篇，调用相册获取图片：

/***
* 这个是调用android内置的intent，来过滤图片文件 ，同时也可以过滤其他的
*/
Intent intent = new Intent();
intent.setType("image/*");
intent.setAction(Intent.ACTION_GET_CONTENT);
startActivityForResult(intent, 1);

获取选择的图片：

if (resultCode == Activity.RESULT_OK) {           
            Uri uri = data.getData();
            try {
                String[] pojo = { MediaStore.Images.Media.DATA };
 
                Cursor cursor = managedQuery(uri, pojo, null, null, null);
                if (cursor != null) {
                    ContentResolver cr = this.getContentResolver();
                    int colunm_index = cursor
                            .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
                    cursor.moveToFirst();
                    String path = cursor.getString(colunm_index);
                    /***
                     * 这里加这样一个判断主要是为了第三方的软件选择，比如：使用第三方的文件管理器的话，你选择的文件就不一定是图片了，
                     * 这样的话，我们判断文件的后缀名 如果是图片格式的话，那么才可以
                     */
                    if (path.endsWith("jpg") || path.endsWith("png")) {
                        picPath = path;
                        Bitmap bitmap = PictureUtil.getSmallBitmap(picPath,480,320,50);
                        //        
                        imageShow.setImageBitmap(bitmap);
                        //这里更新发布分享按键的可点出状态
                        btnSubmit.setEnabled(true);
                    
                    } else {
                        alert();
                    }
                } else {
                    alert();
                } 
            } catch (Exception e) {
            }
        }

压缩处理类：

/**
 * @Description 调用系统拍照或进入图库中选择照片,再进行裁剪,压缩.
 * @author chq
 */
public class PictureUtil {
    //加载并显示一副图像对内存使用情况有显著的影响，Android提供了一个名为BitmapFactory 的实用程序类，该程序提供了一系列的静态方法，允许通过各种来源加载Bitmap图像。针对我们的需求，将从文件加载图像，并在最初的活动中显示它。幸运的是，BitmapFactory中的可用方法将会调用BitmapFactory.Options类，这使得我们能够定义如何将Bitmap读入内存。具体而言，当加载图像时，可以设置BitmapFactory应该使用的采样大小。在BitmapFactory.Options中指定inSampleSize参数。例如，将inSampleSize
    //= 8时，产生一幅图的大小是原始大小的1/8。要注意的是首先应将BitmapFactoryOptions.inJustDecodeBounds变量设置为true,这将通知BitmapFactory类只需返回该图像的范围，而无需尝试解码图像本身。最后将BitmapFactory.Options.inJustDecodeBounds设置为false，最后对其进行真正的解码。
    /**
     * 
     * @param picPath
     * @param reqWidth
     * @param reqHeight
     * @param compress
     * @return
     */
    public static Bitmap getSmallBitmap(String picPath,int reqWidth,int reqHeight,int compress) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;   
        BitmapFactory.decodeFile(picPath, options);  //options中将获得图片一些信息
        options.inSampleSize = calulateInSampleSize(options, reqWidth, reqHeight);
        options.inJustDecodeBounds = false;  
        
        Bitmap bitmap = BitmapFactory.decodeFile(picPath, options);
        if (bitmap == null) {
            return null;
        }
        int degree = readPictureDegree(picPath);
        bitmap = rotateBitmap(bitmap, degree);
        ByteArrayOutputStream baos = null;
        try {
            baos = new ByteArrayOutputStream();
            //压缩图片质量
            bitmap.compress(Bitmap.CompressFormat.JPEG,compress, baos);
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                if(baos != null) {
                    baos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return bitmap;
    }
    
    private static int calulateInSampleSize(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;
        
        if(height>reqHeight || width>reqWidth) {
            final int heightRatio = Math.round((float)height / (float)reqHeight);
            final int widthRatio = Math.round((float)width / (float)reqWidth);
            // Choose the smallest ratio as inSampleSize value, this will
            // guarantee
            // a final image with both dimensions larger than or equal to the
            // requested height and width.
            inSampleSize = heightRatio < widthRatio ? widthRatio : heightRatio;
        }
        return inSampleSize;
    }
    
    /**
     * 读取图片旋转处理
     * @param path
     * @return
     */
    private static int readPictureDegree(String path) {
        int degree = 0;
        try {
            ExifInterface exifInterface = new ExifInterface(path);
            int orientation = exifInterface.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
            switch (orientation) {
            case ExifInterface.ORIENTATION_ROTATE_90:
                degree = 90;
                break;
            case ExifInterface.ORIENTATION_ROTATE_180:
                degree = 180;
                break;
            case ExifInterface.ORIENTATION_ROTATE_270:
                degree = 270;
                break;
            default:
                break;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return degree;
    }
    /**
     * 图片旋转处理
     * @param bitmap
     * @param rotate
     * @return
     */
    private static Bitmap rotateBitmap(Bitmap bitmap,int rotate) {
        if(bitmap == null) {
            return null;
        }
        int w = bitmap.getWidth();
        int h = bitmap.getHeight();
        Matrix mtx = new Matrix();
        mtx.postRotate(rotate);
        return Bitmap.createBitmap(bitmap,0,0,w,h,mtx,true);
    }        
}