Android拍照调用系统相册仿微信封装总结,治疗各种崩溃,图片横竖问题压缩等问题。-更新2016-12-21

项目下载地址：https://github.com/Aiushtha/android-PictureSelector

配置和使用:见gradle

repositories {
    flatDir {
        dirs 'libs'
    }
}

compile 'com.android.support:design:+'
compile 'com.android.support:recyclerview-v7:+'
compile 'com.android.support:appcompat-v7:+'
compile(name: 'circleindicator', ext: 'aar') //照片查看器依赖的包
compile(name: 'photoPicker', ext: 'aar')  //微信拍照的控件
compile(name: 'photoPicker-Packages', ext: 'aar') //拍照的封装

 PictureSelector.create
                        (v.getContext(), Mode.SYSTEM_CAMERA)
                        .setListen(new OnPhotoPickFinsh() {
                            @Override
                            public void onPhotoPick(List list) {
                                tv.setText("");
                                Toast.makeText(getApplicationContext(), "path:" + list.get(0).getPath() + " length:" + list.get(0).length(), Toast.LENGTH_SHORT).show();
                                tv.append("path:" + list.get(0).getPath());
                                tv.append("\nlength:" + new DecimalFormat("#.##").format((1.0d * list.get(0).length() / 1024 / 1024)) + "MB");
                                SimpleImageLoader.displayImage(list.get(0),img);
                            }
                        }).start();

项目简介

最早使用android调用系统拍照然后遇到很多空指针等问题

以及各种android 不同版本Intent取data有时候会空指针之类的api兼容问题

像使用红米note在开了很多应用后，再启动拍照系统，会发生拍照崩溃图片丢失等问题

用微信控件有时拍照有极小概率拍照无效等等奇怪的问题

其原因是因为Activity被回收了，变量变成null，

参考下面一篇博客

http://blog.csdn.net/huyongl1989/article/details/49333953

还有三星手机可能会遇到变量空针

需要在AndroidManifest.xml的Activity里加入

android:configChanges="mcc|mnc|keyboard|keyboardHidden|navigation|orientation|screenSize|fontScale"

如何在Fragment上调用拍照，图片如何压缩

经过一段时间优化，修复了一些坑。我觉得目前的代码比较可靠，总结一下封装后分享出来。

package com.cn.demo.takephoto;

import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.view.View;
import android.widget.ImageView;
import android.widget.TextView;
import android.widget.Toast;

import java.io.File;
import java.text.DecimalFormat;
import java.util.List;

import me.lxz.photopicker.camera.PhotoPickManger;
import me.lxz.photopicker.tools.SimpleImageLoader;

public class SimpleDemoActivity extends AppCompatActivity {

    PhotoPickManger pickManger;
    private View btn;
    private ImageView img;
    private TextView tv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        /**图片加载器*/
        SimpleImageLoader.init(this.getApplicationContext());


        btn = findViewById(R.id.btn);
        img = (ImageView) findViewById(R.id.img);
        tv=(TextView)findViewById(R.id.tv);

        pickManger = new PhotoPickManger("pick",this, savedInstanceState,new PhotoPickManger.OnPhotoPickFinsh() {
            @Override
            public void onPhotoPick(List list) {
                tv.setText("");
                Toast.makeText(getApplicationContext(), "path:" + list.get(0).getPath() + " length:" + list.get(0).length(), Toast.LENGTH_SHORT).show();
                tv.append("path:" + list.get(0).getPath());
                tv.append("\nlength:" + new DecimalFormat("#.##").format((1.0d*list.get(0).length()/1024/1024))+"MB");
                /**是否图片压缩*/
                processImg();

            }
        });
        /**是否在*/
        pickManger.setCut(false);
        pickManger.flushBundle();

        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                pickManger.clearCache();
                pickManger.start(PhotoPickManger.Mode.SYSTEM_CAMERA);
            }
        });


    }
    /**图片压缩*/
    private void processImg() {
        pickManger.doProcessedPhotos(new PhotoPickManger.OnProcessedPhotos() {
            @Override
            public void onProcessed(List list) {
                SimpleImageLoader.displayImage(list.get(0), img);
                tv.append("\nprogress length:" + new DecimalFormat("#.##").format((1.0d*list.get(0).length()/1024/1024))+"MB");
           }
        });
    }



    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        pickManger.onActivityResult(requestCode, resultCode, data);
    }

    @Override
    public void onSaveInstanceState(Bundle savedInstanceState) {
        super.onSaveInstanceState(savedInstanceState);
        pickManger.onSaveInstanceState(savedInstanceState);
    }
}

核心代码：

package me.lxz.photopicker.camera;

import android.app.Activity;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Matrix;
import android.graphics.Paint;
import android.net.Uri;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.provider.MediaStore;
import android.util.Log;
import android.widget.Toast;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Iterator;
import java.util.List;

import me.iwf.photopicker.PhotoPickerActivity;
import me.iwf.photopicker.utils.PhotoPickerIntent;
import me.lxz.photopicker.tools.PictureUtil;


/**
 * 图片选择器
 */
public final class PhotoPickManger {

    public interface OnProcessedPhotos {
        void onProcessed(List list);
    }

    public interface OnPhotoPickFinsh {
        public void onPhotoPick(List list);
    }


    /**
     * 模式
     */
    public enum Mode {
        /**
         * 系统相机
         */SYSTEM_CAMERA,
        /**
         * 系统图库
         */SYSTEM_IMGCAPTRUE,
        /**
         * 类似微信图库
         */AS_WEIXIN_IMGCAPTRUE
    }


    /**
     * 用于区别哪一个图片选择器
     */
    private static String currentPickMangerName;

    /**
     * 测试用
     */
    private boolean isDebugToast = true;

    /**
     * 用于区别其他图片选择器
     */
    private String name;


    public final String SAVE_STATIC_NAME = "save_currentPickMangerName";

    /**
     * 字段保存所已选择的图片
     */
    public final String SAVE_SELECTED_PHOTOS = "save_selected_photos";

    /**
     * 字段保存所拍照已选择的图片
     */
    public final String SAVE_CACHE_CAMERA = "save_cache_camera";

    /**
     * 字段保存所拍照是否选择裁剪
     */
    public final String SAVE_CACHE_IS_CUT = "save_cache_is_cut";


    /**
     * 字段保存待处理图片
     */
    public final String SAVE_CACHE_CUT_QUEUE = "save_cache_cut_queue";


    /**
     * 是否裁剪 只对系统相机和系统相册有效
     */
    private boolean isCut = false;
    /**
     * 是否缩略
     */
    private boolean isOptimize = false;

    /**
     * 设置返回最大图片数 对系统相机和相册调用无效
     * 默认1
     */
    private int returnFileCount = 1;


    private OnPhotoPickFinsh onPhotoPickFinsh;

    private File tempFile;

    private Handler handler = new Handler();

    /**
     * 已经选择的拍照图片
     */
    public ArrayList selectsPhotos = new ArrayList<>();


    private Activity activity;

    /**
     * 用于缓存
     */
    public Bundle bundle;
    /**
     * 系统拍照标示code
     */
    private final int PHOTO_REQUEST_TAKEPHOTO = 1;// 拍照
    /**
     * 系统相册标示code
     */
    private final int PHOTO_REQUEST_GALLERY = 2;// 从相册中选择
    /**
     * 系统照片返回标示code
     */
    private final int PHOTO_REQUEST_CUT = 3;// 结果
    /**
     * 仿微信相册返回code
     */
    public final static int AS_WEIXIN_REQUEST_CODE = 4;

    /**
     * 如果多图待剪切则保存到该队列里
     */
    public ArrayList willCutOfFileQueue = new ArrayList<>();


    /**
     * 图片缓存地址
     */
    public String cacheFilePath = "/img/";

    /**
     * 默认裁剪大小
     */
    public int defaultCutSize = 150;

    /**
     * 至少大于多少的图片进行处理
     */
    public int needProcessFileLength = (int) 0.5 * 1024 * 1024;

    /***
     * 构造方法
     *
     * @param name             为图片选择器默认一个别名 用来区别那一个选择器被选择了
     * @param activity
     * @param bundle           当系统内存不足时,重建时取出变量
     * @param onPhotoPickFinsh 图片选择成功时回调
     */
    public PhotoPickManger(String name, Activity activity, Bundle bundle, OnPhotoPickFinsh onPhotoPickFinsh) {
        this.onPhotoPickFinsh = onPhotoPickFinsh;
        this.name = name;
        this.activity = activity;
        this.bundle = bundle;

        if (bundle != null) {
            isCut = bundle.getBoolean(SAVE_CACHE_IS_CUT + "_" + name);
            currentPickMangerName = bundle.getString(SAVE_STATIC_NAME);
            willCutOfFileQueue = (ArrayList) bundle.getSerializable(SAVE_CACHE_CUT_QUEUE + "name");
        }
    }

    /**
     * 处理掉重建时的缓存
     */
    public void flushBundle() {
        if (bundle != null) {
            if (isDebugToast) {
                Toast.makeText(activity, "bundle is refresh", Toast.LENGTH_LONG).show();
            }
            selectsPhotos = (ArrayList) bundle.getSerializable(SAVE_SELECTED_PHOTOS + "_" + name);
            if (selectsPhotos == null) {
                selectsPhotos = new ArrayList<>();
            }
            tempFile = (File) bundle.getSerializable(SAVE_CACHE_CAMERA + "_" + name);
            if (tempFile != null) {
                if (tempFile.exists()) {
                    if (tempFile.length() > 0) {
                        if (!isCut) {
                            selectsPhotos.add(tempFile);
                        } else {
                            startPhotoZoom(Uri.fromFile(tempFile), defaultCutSize);
                        }
                        tempFile = null;
                    } else {
                        tempFile.delete();
                        tempFile = null;
                    }

                }
            }
            bundle.remove(SAVE_CACHE_CAMERA + "_" + name);
            if (!selectsPhotos.isEmpty()) {
                if (onPhotoPickFinsh != null) onPhotoPickFinsh.onPhotoPick(selectsPhotos);
            }

        }
    }

    /**
     * 保存变量
     */
    public void onSaveInstanceState(Bundle savedInstanceState) {
        this.bundle = savedInstanceState;
        if (selectsPhotos != null && !selectsPhotos.isEmpty()) {
            savedInstanceState.putSerializable(SAVE_SELECTED_PHOTOS + "_" + name, selectsPhotos);
        }
        if (tempFile != null) {
            savedInstanceState.putSerializable(SAVE_CACHE_CAMERA + "_" + name, tempFile);
        }
        savedInstanceState.putBoolean(SAVE_CACHE_IS_CUT + "_" + name, isCut);
        savedInstanceState.putSerializable(SAVE_CACHE_CUT_QUEUE + "_" + name, willCutOfFileQueue);
        savedInstanceState.putSerializable(SAVE_STATIC_NAME, currentPickMangerName);
    }

    /**
     * 如果是单一拍照,在拍照前应该清理缓存
     */
    public void clearCache() {
        getSelectsPhotos().clear();
        tempFile = null;
        if (bundle != null) {
            bundle.remove(SAVE_SELECTED_PHOTOS + "_" + name);
            bundle.remove(SAVE_CACHE_CAMERA + "_" + name);
        }


    }

    /**
     * 生成一个临时的缓存文件
     */
    private File getFile() {
        File dir = new File(Environment.getExternalStorageDirectory().getPath()
                + cacheFilePath);
        if (!dir.exists()) {
            dir.mkdirs();
        }
        File file = new File(Environment.getExternalStorageDirectory()
                .getPath() + cacheFilePath, getPhotoFileName());
        return file;
    }

    // 使用系统当前日期加以调整作为照片的名称
    private String getPhotoFileName() {
        Date date = new Date(System.currentTimeMillis());
        SimpleDateFormat dateFormat = new SimpleDateFormat(
                "'IMG'_yyyyMMdd_HHmmss");
        return dateFormat.format(date) + ".jpg";
    }

    /**
     * // 调用系统的拍照功能
     */
    private void startCamearPicCut() {
        tempFile = getFile();
        Log.d("test", "start:" + tempFile.exists() + " " + tempFile.length());
        // this.isCutOut = b;
        // 调用系统的拍照功能
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        intent.putExtra("camerasensortype", 2);// 调用前置摄像头
        intent.putExtra("autofocus", true);// 自动对焦
        intent.putExtra("fullScreen", false);// 全屏
        intent.putExtra("showActionIcons", false);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(tempFile));
        activity.startActivityForResult(intent, PHOTO_REQUEST_TAKEPHOTO);
    }

    /**
     * 调用系统的相册
     */
    private void startImageCaptrue() {
        tempFile = getFile();
        Intent intent = new Intent(Intent.ACTION_PICK, null);
        intent.setDataAndType(MediaStore.Images.Media.EXTERNAL_CONTENT_URI,
                "image/*");
        activity.startActivityForResult(intent, PHOTO_REQUEST_GALLERY);
    }


    /**
     * 调用仿微信图库
     */

    private void startAsWeixinImageCaptrue() {
        PhotoPickerIntent intent = new PhotoPickerIntent(activity);
        intent.setPhotoCount(returnFileCount);
        activity.startActivityForResult(intent, AS_WEIXIN_REQUEST_CODE);
    }

    /**
     * 启动
     */

    public void start(Mode mode) {
        currentPickMangerName = this.name;
        switch (mode) {
            case SYSTEM_CAMERA:
                startCamearPicCut();
                break;
            case SYSTEM_IMGCAPTRUE:
                startImageCaptrue();
                break;
            case AS_WEIXIN_IMGCAPTRUE:
                startAsWeixinImageCaptrue();
                break;
        }
    }


    /**
     * 回调onActivityResult事件
     */
    @SuppressWarnings("unused")
    public void onActivityResult(final int requestCode, final int resultCode, final Intent data) {
        if (currentPickMangerName == null) {
            if (bundle != null) {
                currentPickMangerName = bundle.getString(SAVE_STATIC_NAME);
                if (!currentPickMangerName.equals(name)) return;
            }
        } else {
            if (!currentPickMangerName.equals(name)) return;
        }
        try {
            switch (requestCode) {
                case PHOTO_REQUEST_TAKEPHOTO:
                    if (isCut) {
                        startPhotoZoom(Uri.fromFile(tempFile), defaultCutSize); // 裁剪
                    } else {
                        if (tempFile.length() == 0) {
                            tempFile.delete();
                        } else {
                            finish(tempFile);
                        }
                    }
                    return;
                case PHOTO_REQUEST_GALLERY:
                    if (isCut) {
                        if (data != null) {
                            startPhotoZoom(data.getData(), defaultCutSize);
                        }
                    } else {

                        File file = null;
                        try {
                            String path = getRealPathFromURI(data.getData());
                            file = new File(path);

                            if (file == null) return;
                            if (file.length() == 0) {
                                file.delete();
                                return;
                            }
                            finish(file);
                        } catch (Exception e) {
                            // TODO Auto-generated catch block
                            e.printStackTrace();
                        }

                    }
                    return;

                case PHOTO_REQUEST_CUT:
                    if (data != null) {
                        setCutPicToView(data);
                    } else {
                        flushCutPhotos();
                    }
                    return;
                case AS_WEIXIN_REQUEST_CODE:
                    List photos = null;
                    try {
                        if (requestCode == AS_WEIXIN_REQUEST_CODE) {
                            if (data != null) {
                                photos = data.getStringArrayListExtra(PhotoPickerActivity.KEY_SELECTED_PHOTOS);
                                if (!isCut) {

                                    List list = new ArrayList();
                                    if (photos != null && !photos.isEmpty()) {
                                        for (String str : photos) {
                                            list.add(new File(str));
                                        }
                                    } else {
                                        return;
                                    }
                                    finish(list);
                                } else {
                                    if (photos != null && !photos.isEmpty()) {
                                        /**如果只有一张照片可以直接裁剪 否则*/
                                        if (photos.size() == 1) {
                                            for (String str : photos) {
                                                tempFile = getFile();
                                                copyFile(str, tempFile.getAbsolutePath());
                                                startPhotoZoom(Uri.fromFile(tempFile), defaultCutSize); // 裁剪
                                            }
                                        } else {
                                            for (String str : photos) {
                                                willCutOfFileQueue.add(new File(str));
                                            }
                                            tempFile = getFile();
                                            copyFile(willCutOfFileQueue.get(0).getAbsolutePath(), tempFile.getAbsolutePath());
                                            startPhotoZoom(Uri.fromFile(tempFile), defaultCutSize); // 裁剪
                                            willCutOfFileQueue.remove(0);
                                        }
                                    }

                                }
                            }

                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }

                    return;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    /**
     * 如果多图处理裁剪队列
     */
    private void flushCutPhotos() {
        if (willCutOfFileQueue != null && !willCutOfFileQueue.isEmpty()) {
            tempFile = getFile();
            copyFile(willCutOfFileQueue.get(0).getAbsolutePath(), tempFile.getAbsolutePath());
            willCutOfFileQueue.remove(0);
            startPhotoZoom(Uri.fromFile(tempFile), defaultCutSize); // 裁剪
        }
    }

    /**
     * 文件复制
     */
    private void copyFile(String oldPath, String newPath) {
        try {
            int bytesum = 0;
            int byteread = 0;
            File oldfile = new File(oldPath);
            if (oldfile.exists()) {                  //文件存在时
                InputStream inStream = new FileInputStream(oldPath);      //读入原文件
                FileOutputStream fs = new FileOutputStream(newPath);
                byte[] buffer = new byte[1444];
                int length;
                while ((byteread = inStream.read(buffer)) != -1) {
                    bytesum += byteread;            //字节数 文件大小
                    System.out.println(bytesum);
                    fs.write(buffer, 0, byteread);
                }
                inStream.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 对当前已选图片进行压缩
     */
    public void doProcessedPhotos(final OnProcessedPhotos on) {

        if (getSelectsPhotos() != null && !getSelectsPhotos().isEmpty()) {
            new Thread(new Runnable() {
                @Override
                public void run() {
                    for (Iterator it = getSelectsPhotos().iterator(); it.hasNext(); ) {
                        try {
                            File file = it.next();
                            if (file.length() > needProcessFileLength) {
                                final Bitmap bm = PictureUtil.getSmallBitmap(file.getAbsolutePath(), 720, 1200);
                                try {
                                    FileOutputStream fos = new FileOutputStream(file);
                                    bm.compress(Bitmap.CompressFormat.JPEG, 95, fos);
                                } catch (FileNotFoundException e) {
                                    e.printStackTrace();
                                }
                            }
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }
                    handler.post(new Runnable() {
                        @Override
                        public void run() {
                            on.onProcessed(getSelectsPhotos());
                        }
                    });


                }
            }).start();

        }
    }

    /**
     * 图片选择完成并回调
     */
    private void finish(final File file) {
        finish(createFiles(file));
    }

    /**
     * 图片选择完成并回调
     */
    private void finish(final List files) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (Iterator it = files.iterator(); it.hasNext(); ) {
                    File file = it.next();
                    if (!file.exists() || file.length() == 0) {
                        it.remove();
                    } else {
                        changFile(file.getPath());
                    }
                }
                handler.post(new Runnable() {
                    @Override
                    public void run() {
                        selectsPhotos.addAll(files);
                        if (!files.isEmpty()) {
                            if (onPhotoPickFinsh != null) onPhotoPickFinsh.onPhotoPick(files);
                        }
                        tempFile = null;
                        flushCutPhotos();
                    }
                });
            }
        }).start();


    }

    /**
     * 三星手机将横向图片转换为竖向
     */
    public void changFile(String file) {
        BitmapFactory.Options options = new BitmapFactory.Options();

        /**
         * 最关键在此，把options.inJustDecodeBounds = true;
         * 这里再decodeFile()，返回的bitmap为空，但此时调用options.outHeight时，已经包含了图片的高了
         */
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(file, options);
        int width = options.outWidth;
        int height = options.outHeight;
        if (width > height) {

            Bitmap bit = bitmapFromFile(file, width, height);
            bit = adjustPhotoRotation(bit, 1);
            try {
                bit.compress(Bitmap.CompressFormat.PNG,100,new FileOutputStream(file));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 旋转图片
     */
    public Bitmap adjustPhotoRotation(Bitmap bm, int count) {
        int orientationDegree = 90;
        Matrix m = new Matrix();
        for (int i = 0; i < count; i++) {
            m.setRotate(orientationDegree, bm.getWidth(),
                    bm.getHeight());
            float targetX, targetY;
            if (orientationDegree == 90) {
                targetX = bm.getHeight();
                targetY = 0;
            } else {
                targetX = bm.getHeight();
                targetY = bm.getWidth();
            }

            final float[] values = new float[9];
            m.getValues(values);

            float x1 = values[Matrix.MTRANS_X];
            float y1 = values[Matrix.MTRANS_Y];

            m.postTranslate(targetX - x1, targetY - y1);
        }

        Bitmap bm1 = Bitmap.createBitmap(bm.getHeight(), bm.getWidth(),
                Bitmap.Config.ARGB_8888);
        Paint paint = new Paint();
        Canvas canvas = new Canvas(bm1);
        canvas.drawBitmap(bm, m, paint);

        // ���ɵ�bitmap����
        bm.recycle();

        return bm1;
    }

    private List createFiles(File file) {
        List list = new ArrayList<>();
        list.add(file);
        return list;
    }

    /**
     * 根据Uri获得File文件路径
     */
    public String getRealPathFromURI(Uri contentUri) {
        String res = null;
        String[] proj = {MediaStore.Images.Media.DATA};
        Cursor cursor = activity.getContentResolver().query(contentUri, proj,
                null, null, null);
        if (cursor.moveToFirst()) {
            ;
            int column_index = cursor
                    .getColumnIndexOrThrow(MediaStore.Images.Media.DATA);
            res = cursor.getString(column_index);
        }
        cursor.close();
        return res;
    }

    /**
     * 启动裁剪
     */
    private void startPhotoZoom(Uri uri, int size) {
        Log.d("test", uri.toString());
        Intent intent = new Intent("com.android.camera.action.CROP");
        intent.setDataAndType(uri, "image/*");
        // crop为true是设置在开启的intent中设置显示的view可以剪裁
        intent.putExtra("crop", "true");

        // aspectX aspectY 是宽高的比例
        intent.putExtra("aspectX", 1);
        intent.putExtra("aspectY", 1);

        // outputX,outputY 是剪裁图片的宽高
        intent.putExtra("outputX", size);
        intent.putExtra("outputY", size);

        intent.putExtra("return-data", true);
        intent.putExtra("noFaceDetection", true);
        activity.startActivityForResult(intent, PHOTO_REQUEST_CUT);
    }

    // 将进行剪裁后的图片显示到UI界面上
    private void setCutPicToView(Intent picdata) {
        Bundle bundle = picdata.getExtras();
        if (bundle != null) {
            Bitmap photo = bundle.getParcelable("data");
            if (photo != null) {
                FileOutputStream fOut = null;
                try {
                    fOut = new FileOutputStream(tempFile);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
                photo.compress(Bitmap.CompressFormat.JPEG, 100, fOut);
            }
            finish(tempFile);

        }
    }


    /**
     * 获取一个指定大小的bitmap
     *
     * @param reqWidth  目标宽度
     * @param reqHeight 目标高度
     */
    public Bitmap bitmapFromFile(String pathName, int reqWidth,
                                 int reqHeight) {
        if (reqHeight == 0 || reqWidth == 0) {
            return BitmapFactory.decodeFile(pathName);
        } else {
            BitmapFactory.Options options = new BitmapFactory.Options();
            options.inJustDecodeBounds = true;
            BitmapFactory.decodeFile(pathName, options);

            options = calculateInSampleSize(options, reqWidth,
                    reqHeight);
            return BitmapFactory.decodeFile(pathName, options);
        }
    }

    /**
     * 图片压缩处理（使用Options的方法）
     * 

     * 

     * 说明 使用方法：
     * 首先你要将Options的inJustDecodeBounds属性设置为true，BitmapFactory.decode一次图片 。
     * 然后将Options连同期望的宽度和高度一起传递到到本方法中。
     * 之后再使用本方法的返回值做参数调用BitmapFactory.decode创建图片。
     * 

     * 

     * 说明 BitmapFactory创建bitmap会尝试为已经构建的bitmap分配内存
     * ，这时就会很容易导致OOM出现。为此每一种创建方法都提供了一个可选的Options参数
     * ，将这个参数的inJustDecodeBounds属性设置为true就可以让解析方法禁止为bitmap分配内存
     * ，返回值也不再是一个Bitmap对象， 而是null。虽然Bitmap是null了，但是Options的outWidth、
     * outHeight和outMimeType属性都会被赋值。
     *
     * @param reqWidth  目标宽度,这里的宽高只是阀值，实际显示的图片将小于等于这个值
     * @param reqHeight 目标高度,这里的宽高只是阀值，实际显示的图片将小于等于这个值
     */
    public BitmapFactory.Options calculateInSampleSize(
            final BitmapFactory.Options options, final int reqWidth,
            final 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的值，这样可以保证最终图片的宽和高
            // 一定都会大于等于目标的宽和高。
            inSampleSize = heightRatio < widthRatio ? heightRatio
                    : widthRatio;
        }
        // 设置压缩比例
        options.inSampleSize = inSampleSize;
        options.inJustDecodeBounds = false;
        return options;
    }

    public Activity getActivity() {
        return activity;
    }

    public PhotoPickManger setActivity(Activity activity) {
        this.activity = activity;
        return this;
    }


    public boolean isCut() {
        return isCut;
    }

    public PhotoPickManger setIsCut(boolean isCut) {
        this.isCut = isCut;
        return this;
    }

    public boolean isOptimize() {
        return isOptimize;
    }

    public PhotoPickManger setIsOptimize(boolean isOptimize) {
        this.isOptimize = isOptimize;
        return this;
    }

    public int getReturnFileCount() {
        return returnFileCount;
    }

    public PhotoPickManger setReturnFileCount(int returnFileCount) {
        this.returnFileCount = returnFileCount;
        return this;
    }

    public OnPhotoPickFinsh getOnPhotoPickFinsh() {
        return onPhotoPickFinsh;
    }

    public PhotoPickManger setOnPhotoPickFinsh(OnPhotoPickFinsh onPhotoPickFinsh) {
        this.onPhotoPickFinsh = onPhotoPickFinsh;
        return this;
    }

    public boolean isDebugToast() {
        return isDebugToast;
    }

    public PhotoPickManger setDebugToast(boolean isDebugToast) {
        this.isDebugToast = isDebugToast;
        return this;
    }

    public void setCut(boolean isCut) {
        this.isCut = isCut;
    }

    public Bundle getBundle() {
        return bundle;
    }

    public PhotoPickManger setBundle(Bundle bundle) {
        this.bundle = bundle;
        return this;
    }

    public File getTempFile() {
        return tempFile;
    }

    public ArrayList getSelectsPhotos() {
        return selectsPhotos;
    }

    public int getNeedProcessFileLength() {
        return needProcessFileLength;
    }

    public PhotoPickManger setNeedProcessFileLength(int needProcessFileLength) {
        this.needProcessFileLength = needProcessFileLength;
        return this;
    }

    public static String getCurrentPickMangerName() {
        return currentPickMangerName;
    }

    public static void setCurrentPickMangerName(String currentPickMangerName) {
        PhotoPickManger.currentPickMangerName = currentPickMangerName;
    }

    public String getCacheFilePath() {
        return cacheFilePath;
    }

    public PhotoPickManger setCacheFilePath(String cacheFilePath) {
        this.cacheFilePath = cacheFilePath;
        return this;
    }

    public String getName() {
        return name;
    }

    public PhotoPickManger setName(String name) {
        this.name = name;
        return this;
    }

    public PhotoPickManger setTempFile(File tempFile) {
        this.tempFile = tempFile;
        return this;
    }
}