相机照相以及处理图片的压缩

Posted 2020-08-02 mclmdream

我们知道在app处理图片是经常会出现oom,原因就是我们在处理图片的时候图片所占的内存太大导致的，这里就介绍怎么去结局图片占内存过大的方法，当然，也是为了自己以后使用能方便些。
这篇文章也是在网上看了很多大牛的文章之后自己整理出来的，希望有错的地方大家提出来，一起学习一起进步。
首先我们介绍下相机的使用：
大致有三种：
1. 缩略图
2. 获得原始的拍照文件
3. 获取Gallery里面的图片
第一种： 缩略图

 Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        startActivityForResult(intent, 1);

第二种：获得原始的拍照文件

 public void OriginalImageView(View view) {
        File file = createImageFile();
        outputFileUri = Uri.fromFile(file);
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
        startActivityForResult(intent, 2);
    }

第三种：获取Gallery里面的图片

 public void GalleryImageView(View view) {
        Intent intent = new Intent(Intent.ACTION_PICK);
        intent.setType("image/*");
        intent.setAction(Intent.ACTION_GET_CONTENT);
        startActivityForResult(intent, 3);
    }

上面只是简单介绍照相，下面是所有的代码：

public class MainActivity extends AppCompatActivity {
    private ImageView imageview;
    private Uri outputFileUri;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        imageview = (ImageView) findViewById(R.id.imageview);
    }

    /**
     * 缩略图
     */
    public void PriviewImageView(View view) {
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        startActivityForResult(intent, 1);
    }

    /**
     * 获得原始的拍照文件
     */
    public void OriginalImageView(View view) {
        File file = createImageFile();
        outputFileUri = Uri.fromFile(file);

        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, outputFileUri);
        startActivityForResult(intent, 2);

    }

    /**
     * 获取Gallery里面的图片
     */
    public void GalleryImageView(View view) {
        Intent intent = new Intent(Intent.ACTION_PICK);
        intent.setType("image/*");
        intent.setAction(Intent.ACTION_GET_CONTENT);
        startActivityForResult(intent, 3);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (requestCode != RESULT_OK) {
            if (requestCode == 1) {/**缩略图*/
                Bitmap bitmap = data.getExtras().getParcelable("data");
                imageview.setImageBitmap(bitmap);
            } else if (requestCode == 2) { /**获得原始的拍照文件*/
                Toast.makeText(MainActivity.this, "成功", Toast.LENGTH_SHORT).show();

                try {
                    Bitmap bitmap = MediaStore.Images.Media.getBitmap(this.getContentResolver(), outputFileUri);
                    imageview.setImageBitmap(bitmap);
                } catch (IOException e) {
                    e.printStackTrace();
                }

            } else if (requestCode == 3) {/**获取Gallery里面的图片*/
                Toast.makeText(MainActivity.this, data.getData().toString(), Toast.LENGTH_SHORT).show();
                getRealPathFromURI(data.getData());/**获取图片真实路径*/
            }
        }
    }

    public static File createImageFile() {
        String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
        String imageFileName = "JPEG_" + timeStamp + "_";
        try {
            File image = File.createTempFile(imageFileName, ".jpg", Environment.getExternalStorageDirectory());
            return image;
        } catch (IOException e) {
            return null;
        }
    }

    private String getRealPathFromURI(Uri contentURI) {
        String result;
        Cursor cursor = getContentResolver().query(contentURI, null, null, null, null);
        if (cursor == null) {
            result = contentURI.getPath();
        } else {
            cursor.moveToFirst();
            int idx = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DATA);
            result = cursor.getString(idx);
            cursor.close();
        }
        return result;
    }

}

其次，在处理图片之前，我们应该了解BitMap和BitmapFactory的一些常用方法，在这里我简单介绍几种常用的。
BitMap:
1.计算图片像素的方法是 bitmap.getWidth()和bitmap.getHeight();
2.bitmap.getByteCount() 是计算它的像素所占用的内存,(bitmap.getWidth()*bitmap.getHeight()*4=bitmap.getByteCount());
3.compress(Bitmap.CompressFormat.JPEG, 100, os),第一个参数是图片的类型，第二个参数是指图片质量（设置为30时是指图片质量被压缩了百分之70，最大100，最小0），第三个参数是指图片流。

BitmapFactory:
1.BitmapFactory.Options使用这个对象去处理图片的属性;
2.inJustDecodeBounds如果是true的话只会返回图片的宽和高;
3.inSampleSize是指设置缩放比例,设置为2时变为原来的1/2(这里的1/2值得是宽和高分别是原图的1/2,所以图片是被压缩了4倍);
4.BitmapFactory.decodeFile(path，options),这个方法的path是图片的路径,options就是BitmapFactory.Options的对象。
5.BitmapFactory.decodeFile(path),返回的是这个路径下图片的Bitmap;
6.BitmapFactory.decodeStream(is, null, options),这个方法is是图片的流，null 是指位图，我们可以设置为nullm,options就是BitmapFactory.Options的对象。
7.BitmapFactory.decodeStream(is),将is转化为BitMap对象;

图片压缩有两种方法，一种是质量压缩(（不改变图片的尺寸）)，一种是尺寸压缩(像素上的压缩也成采样率压缩)。

测试图片在压缩前和压缩后的大小：
FileInputStream fs = new FileInputStream(pathName);
System.out.println(“图片的大小==”+fs.available());
测试图片所占内存大小：
Bitmap bm = BitmapFactory.decodeFile(pathName);;
System.out.println(“内存的大小==”+bm.getByteCount());
System.out.println(“内存大小的另一种求法==”+bm.getWidth() * bm.getHeight()*4 );

1. 质量压缩
   质量压缩不会减少图片对内存的使用，但是开发app的程序员都知道我们会尽量为用户减少流量，或者将图片保存到本地时进行压缩，所以使用质量压缩会减少图片的大小，这样上传图片时速度快（因为图片变小了），用户体验就会好。
   下面就是方法：

     FileInputStream fs = new FileInputStream(pathName);  
     System.out.println("图片压缩前的大小=="+fs.available()); 

     public static Bitmap CompressBitmap(Bitmap bitmap){  
            System.out.println("质量压缩前内存="+bitmap.getByteCount());  
            ByteArrayOutputStream bo=new  ByteArrayOutputStream();  
            //通过这里改变压缩类型，其有不同的结果  
            bitmap.compress(Bitmap.CompressFormat.JPEG, 70, bo); //注意：不要讲jpg格式的图片压缩成png格式的图片，如果设置成png的话图片可能会变大，但是内存不会发生变化
            ByteArrayInputStream bi=new ByteArrayInputStream(bo.toByteArray());  
            System.out.println("图片压缩后的大小="+bi.available());  
            Bitmap  bitmap=BitmapFactory.decodeStream(bis);  
            System.out.println("质量压缩后内存="+bitmap.getByteCount());  
      return bitmap;  
    }        

通过实现我们得出图片压缩前和压缩后的大小确实变了，压缩后的比压缩前的小，但是图片的内存使用没有变。

但是，它不会减少图片的像素。它是在保持像素的前提下改变图片的位深及透明度等，来达到压缩图片的目的。进过它压缩的图片文件大小会有改变，但是导入成bitmap后占得内存是不变的。因为要保持像素不变，所以它就无法无限压缩，到达一个值之后就不会继续变小了。显然这个方法并不适用与缩略图，其实也不适用于想通过压缩图片减少内存的适用，仅仅适用于想在保证图片质量的同时减少文件大小的情况而已
例如：

//最开始使用这个来进行压缩，但是始终压缩不到32k这么小
public void Example(){
ByteArrayOutputStream baos = new ByteArrayOutputStream();
　　image.compress(Bitmap.CompressFormat.JPEG, 100 , baos);
　　int options = 100 ;
　　while ( baos.toByteArray().length / 1024 > 32 ) {
　　baos.reset();
　　image.compress(Bitmap.CompressFormat.JPEG, options, baos);
　　options -= 10 ;
　　}
　　ByteArrayInputStream isBm = new ByteArrayInputStream(baos.toByteArray());
　　Bitmap bitmap = BitmapFactory.decodeStream(isBm, null , null );
}

2.尺寸压缩（也成采样率压缩）
尺寸压缩会改变图片所占内存的大小，也就是解决我们在加载图片时有时候会出现的OOM。
第一种： 根据图片路径，下面就是方法：

 public static Bitmap CompressBitmapSizePath(String imagePath){
        Bitmap bitmap = BitmapFactory.decodeFile(pathName); 
        System.out.println("内存压缩前=="+bitmap.getByteCount());   

        BitmapFactory.Options options = new BitmapFactory.Options();  
        options.inJustDecodeBounds = true; //设置成true我们我是为了得到图片的宽高，这个方法返回的Bitmap对象为空，减少内存的消耗
        Bitmap bitmap = BitmapFactory.decodeFile(imagePath,options);  // 这个方法返回的bitmap 为空，因为options.inJustDecodeBounds设置为true
        options.inJustDecodeBounds = false;  
        options.inSampleSize = 2; //原来的1/2 
        bitmap = BitmapFactory.decodeFile(imagePath,options);  
        System.out.println("内存压缩后=="+bitmap.getByteCount()); 
        return bitmap;  
    }

第二种：根据流，下面就是方法：

public static Bitmap CompressBitmapSizeIs(Context context, int resId){  
       BitmapFactory.Options opt = new BitmapFactory.Options();  
       opt.inPreferredConfig = Bitmap.Config.RGB_565;   
       opt.inPurgeable = true;  
       opt.inInputShareable = true;  
       opt.inSampleSize = 2;
       //获取资源图片  
       InputStream is = context.getResources().openRawResource(resId);  
       return BitmapFactory.decodeStream(is,null,opt);  
   }  

第三中：根据Bitmap,以下就是方法：

 public Bitmap CompressBitmapSizeBitMap(Bitmap image, float pixelW, float pixelH) {  
        ByteArrayOutputStream os = new ByteArrayOutputStream();  
        image.compress(Bitmap.CompressFormat.JPEG, 100, os);  
        if( os.toByteArray().length / 1024>1024) {//判断如果图片大于1M,进行压缩避免在生成图片（BitmapFactory.decodeStream）时溢出      
            os.reset();//重置baos即清空baos    
            image.compress(Bitmap.CompressFormat.JPEG, 50, os);//这里压缩50%，把压缩后的数据存放到baos中    
        }    
        ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());    
        BitmapFactory.Options newOpts = new BitmapFactory.Options();    
        //开始读入图片，此时把options.inJustDecodeBounds 设回true了    
        newOpts.inJustDecodeBounds = true;  
        newOpts.inPreferredConfig = Config.RGB_565;  
        Bitmap bitmap = BitmapFactory.decodeStream(is, null, newOpts);    
        newOpts.inJustDecodeBounds = false;    
        int w = newOpts.outWidth;    
        int h = newOpts.outHeight;    
        float hh = pixelH;// 设置高度为240f时，可以明显看到图片缩小了  
        float ww = pixelW;// 设置宽度为120f，可以明显看到图片缩小了  
        //缩放比。由于是固定比例缩放，只用高或者宽其中一个数据进行计算即可    
        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了    
        is = new ByteArrayInputStream(os.toByteArray());    
        bitmap = BitmapFactory.decodeStream(is, null, newOpts);  
        //压缩好比例大小后再进行质量压缩  
//      return compress(bitmap, maxSize); // 这里再进行质量压缩的意义不大，反而耗资源，删除  
        return bitmap;  
    }  

使用中可以根据自己的需要自己选择，最后给大家提供一个完美的压缩图片尺寸的方法，也是我在网上找到的：

//根据路径获得突破并压缩返回bitmap用于显示
    public static Bitmap getSmallBitmap(String filePath,int reqWidth, int reqHeight) {
        final BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;  //只返回图片的大小信息
        BitmapFactory.decodeFile(filePath, options);
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeFile(filePath, options);
    }


//计算图片的缩放值
    public static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
        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);
            inSampleSize = heightRatio < widthRatio ? heightRatio : widthRatio;
        }
        return inSampleSize;
    }

最后，使用完BitMap是我们一般要:
bmp.recycle() ; //回收图片所占的内存
system.gc() //提醒系统及时回收 ，回收内存。
另外，一般不要不要使用setImageBitmap或setImageResource或BitmapFactory.decodeResource来设置一张大图，因为这些函数在完成decode后，最终都是通过java层的createBitmap来完成的，需要消耗更多内存，以下提供一个优化方法（也就是尺寸压缩中的第二个方法，只是一个优化）：

public static Bitmap readBitMap(Context context, int resId){  
       BitmapFactory.Options opt = new BitmapFactory.Options();  
       opt.inPreferredConfig = Bitmap.Config.RGB_565;   
       opt.inPurgeable = true;  
       opt.inInputShareable = true;  
       opt.inSampleSize = 2;
       //获取资源图片  
       InputStream is = context.getResources().openRawResource(resId);  
       return BitmapFactory.decodeStream(is,null,opt);  
   }