Android 图片压缩

package com.tal.wisroom.common;

import android.app.Activity;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.media.ExifInterface;
import android.os.Environment;
import android.util.Log;

import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;

/**

• Created by mengnan on 2017/9/20.
  */
  public class ImageUtils {

  private static String TAG = “ImageUtils”;
  /** 首先默认个文件保存路径 */
  private static final String SAVE_PIC_PATH= Environment.getExternalStorageState().equalsIgnoreCase(Environment.MEDIA_MOUNTED) ? Environment.getExternalStorageDirectory().getAbsolutePath() : “/mnt/sdcard”;//保存到SD卡
  public static final String SAVE_REAL_PATH = SAVE_PIC_PATH+ “/carrent/savePic”;//保存的确切位置

  Activity context;

  private ImageUtils(Activity context){
  this.context = context;
  }

  /**

  • 质量压缩方法

  • @param image

  • @return
    */
    public static Bitmap compressImage(Bitmap image) {

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    if(image != null && !image.isRecycled()){
    image.compress(Bitmap.CompressFormat.JPEG, 80, baos);// 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
    }

    int options = 90;

    while (baos.toByteArray().length / 1024 > 100) { // 循环判断如果压缩后图片是否大于100kb,大于继续压缩
    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数据生成图片

// image.recycle();
return bitmap;
}

/**
 * 图片按比例大小压缩方法
 *
 * @param srcPath （根据路径获取图片并压缩）
 * @return
 */
public static Bitmap getimage(String srcPath) {

    BitmapFactory.Options newOpts = new BitmapFactory.Options();
    // 开始读入图片，此时把options.inJustDecodeBounds 设回true了
    newOpts.inJustDecodeBounds = true;
    Bitmap bitmap = BitmapFactory.decodeFile(srcPath, newOpts);// 此时返回bm为空

    newOpts.inJustDecodeBounds = false;
    int w = newOpts.outWidth;
    int h = newOpts.outHeight;
    // 现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
    float hh = 800f;// 这里设置高度为800f
    float ww = 480f;// 这里设置宽度为480f
    // 缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
    int be = 1;// be=1表示不缩放
    if (w > h && w > ww) {// 如果宽度大的话根据宽度固定大小缩放
        be = (int) (newOpts.outWidth / ww);
    } else if (w < h && h > hh) {// 如果高度高的话根据宽度固定大小缩放
        be = (int) (newOpts.outHeight / hh);
    }
    if (be <= 0)
        be = 1;
    newOpts.inSampleSize = be;// 设置缩放比例
    // 重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
    bitmap = BitmapFactory.decodeFile(srcPath, newOpts);
    return compressImage(bitmap);// 压缩好比例大小后再进行质量压缩
}
/**
 * 获取本地图片并指定高度和宽度
 */
public static Bitmap getNativeImage(String imagePath)
{
    BitmapFactory.Options options = new BitmapFactory.Options();
    options.inJustDecodeBounds = true;

// 获取这个图片的宽和高
Bitmap myBitmap = BitmapFactory.decodeFile(imagePath, options); //此时返回myBitmap为空
//计算缩放比
int be = (int)(options.outHeight / (float)200);
int ys = options.outHeight % 200;//求余数
float fe = ys / (float)200;
if (fe >= 0.5)
be = be + 1;
if (be <= 0)
be = 1;
options.inSampleSize = be;
//重新读入图片，注意这次要把options.inJustDecodeBounds 设为 false
options.inJustDecodeBounds = false;
myBitmap = BitmapFactory.decodeFile(imagePath, options);
return myBitmap;
}
public static Bitmap getBitmapFromPath(String path) {

    if (!new File(path).exists()) {
        System.err.println("getBitmapFromPath: file not exists");
        return null;
    }
    byte[] buf = new byte[1024 * 1024];// 1M
    Bitmap bitmap = null;
    try {
        FileInputStream fis = new FileInputStream(path);
        int len = fis.read(buf, 0, buf.length);
        bitmap = BitmapFactory.decodeByteArray(buf, 0, len);
        if (bitmap == null) {
            System.out.println("len= " + len);
            System.err
                    .println("path: " + path + "  could not be decode!!!");
        }
    } catch (Exception e) {
        e.printStackTrace();

    }
    return bitmap;
}

/**
 * 图片按比例大小压缩方法
 *
 * @param image （根据Bitmap图片压缩）
 * @return
 */
public static Bitmap compressScale(Bitmap image) {

    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    image.compress(Bitmap.CompressFormat.JPEG, 100, baos);

    // 判断如果图片大于1M,进行压缩避免在生成图片（BitmapFactory.decodeStream）时溢出
    if (baos.toByteArray().length / 1024 > 1024) {
        baos.reset();// 重置baos即清空baos
        image.compress(Bitmap.CompressFormat.JPEG, 80, baos);// 这里压缩50%，把压缩后的数据存放到baos中
    }
    ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
    BitmapFactory.Options newOpts = new BitmapFactory.Options();
    // 开始读入图片，此时把options.inJustDecodeBounds 设回true了
    newOpts.inJustDecodeBounds = true;
    Bitmap bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);
    newOpts.inJustDecodeBounds = false;
    int w = newOpts.outWidth;
    int h = newOpts.outHeight;
    Log.i(TAG, w + "---------------" + h);
    // 现在主流手机比较多是800*480分辨率，所以高和宽我们设置为
    // float hh = 800f;// 这里设置高度为800f
    // float ww = 480f;// 这里设置宽度为480f
    float hh = 512f;
    float ww = 512f;
    // 缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可
    int be = 1;// be=1表示不缩放
    if (w > h && w > ww) {// 如果宽度大的话根据宽度固定大小缩放
        be = (int) (newOpts.outWidth / ww);
    } else if (w < h && h > hh) { // 如果高度高的话根据高度固定大小缩放
        be = (int) (newOpts.outHeight / hh);
    }
    if (be <= 0)
        be = 1;
    newOpts.inSampleSize = be; // 设置缩放比例
    // newOpts.inPreferredConfig = Config.RGB_565;//降低图片从ARGB888到RGB565

    // 重新读入图片，注意此时已经把options.inJustDecodeBounds 设回false了
    isBm = new ByteArrayInputStream(baos.toByteArray());
    bitmap = BitmapFactory.decodeStream(isBm, null, newOpts);

    return compressImage(bitmap);// 压缩好比例大小后再进行质量压缩

    //return bitmap;
}
public static File saveFile(String pa, Bitmap bm, String fileName, String path) throws IOException {


    String subForder = path;
    File foder = new File(subForder);
    if (!foder.exists()) {
        foder.mkdirs();
    }
    /**
     * 获取图片的旋转角度，有些系统把拍照的图片旋转了，有的没有旋转
     */
    int degree = readPictureDegree(pa);
    Log.e("degree",degree+"###");

// /**
// * 把图片旋转为正的方向
// */
bm = rotaingImageView(degree, bm);
File myCaptureFile = new File(subForder, fileName);
if (!myCaptureFile.exists()) {
myCaptureFile.createNewFile();
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(myCaptureFile));
bm.compress(Bitmap.CompressFormat.JPEG, 80, bos);
bos.flush();
bos.close();
}
int degree1 = readPictureDegree(myCaptureFile.getAbsolutePath());
Log.e(“Image”,degree1+"");
return myCaptureFile;
}

/**
 * 把batmap 转file
 * @param bitmap
 * @param filepath
 */
public static File saveBitmapFile(Bitmap bitmap, String filepath){
    File file=new File(filepath);//将要保存图片的路径
    try {
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(file));
        bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos);
        bos.flush();
        bos.close();
    } catch (IOException e) {
        e.printStackTrace();
    }
    return file;
}

/* 旋转图片
 * @param angle
 * @param bitmap
 * @return Bitmap
 */
public static Bitmap rotaingImageView(int angle , Bitmap bitmap) {
    //旋转图片 动作
    Matrix matrix = new Matrix();;
    matrix.postRotate(angle);
    System.out.println("angle2=" + angle);
    // 创建新的图片
    Bitmap resizedBitmap = Bitmap.createBitmap(bitmap, 0, 0,
            bitmap.getWidth(), bitmap.getHeight(), matrix, true);
    return resizedBitmap;
}
/**
 * 读取图片属性：旋转的角度
 * @param path 图片绝对路径
 * @return degree旋转的角度
 */
public 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;
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
    return degree;
}

}