1. 首页
  2. Android
  3. Android拍照和裁剪管理

Android拍照和裁剪管理

2019/04/26 17:30:06 发表 2019/04/26 17:30:06 更新 原创 素颜 566 0 0

Android 开发过程中相机拍照和裁剪上传图片功能几乎成了每个APP的必备功能，每次复制粘贴都有好多的代码，今天对拍照和裁剪功能进行整理形成工具类，以后直接调用几行代码快速集成。

[TOC]

1、本文设计到的主页功能点

  • 相机拍照
  • 图片裁剪，可设置裁剪比例
  • 6.0 以上权限问题
  • 7.0 以上 Uri 问题
  • 重复拍照产出是垃圾文件

2、拍照和裁剪的工具类

  2. /**
  3.  * 相机拍照，裁剪
  4.  * Created by mtf on 2019/4/26.
  5.  */
  6. public class TakePictureManager {
  8.     private Activity activity;
  9.     private File tempFile; // 临时存储照片
  10.     private Uri outImageUri;// 相机拍照图片保存地址
  11.     private static final int REQUEST_TAKE_PIC_CODE = 1000; // 请求拍照
  12.     private static final int REQUEST_CROP_PICKER_CODE = 1001; // 裁剪照片
  13.     private static final int CAMERA_PERMISSIONS_REQUEST_CODE = 1005; // 申请相机权限
  15.     private boolean isCrop = false; // 是否需要照片裁剪，默认不需要裁剪
  16.     private boolean aspectXY = false;//设置是否可以修改裁剪框比例，默认不可以修改
  17.     private int aspectX = 100;
  18.     private int aspectY = 101;//经过测试如果裁剪框比例设置成1:1，部分手机出现裁剪框变成圆形而不是正方形
  19.     private int outputX = 600;
  20.     private int outputY = 600;
  23.     PicturePathListner pictureSelectListner;//选择之后照片的回调监听
  25.     public TakePictureManager(Activity activity) {
  26.         this.activity = activity;
  27.     }
  29.     public TakePictureManager(Activity activity, PicturePathListner pictureSelectListner) {
  30.         this.activity = activity;
  31.         this.pictureSelectListner = pictureSelectListner;
  32.     }
  34.     public void setPictureSelectListner(PicturePathListner pictureSelectListner) {
  35.         this.pictureSelectListner = pictureSelectListner;
  36.     }
  38.     /**
  39.      * 照片回调处理
  40.      *
  41.      * @param requestCode
  42.      * @param resultCode
  43.      * @param data
  44.      */
  45.     public void onActivityResult(int requestCode, int resultCode, Intent data) {
  46.         if (resultCode == Activity.RESULT_OK) {
  47.             switch (requestCode) {
  48.                 case REQUEST_TAKE_PIC_CODE:
  49.                     if (isCrop) {
  50.                         cropPicture();
  51.                     } else {
  52.                         this.pictureSelectListner.onPictureSelect(tempFile.getAbsolutePath());// 这里一定不可以用outImageUri.getPath()，因为uri保存的可能不是真实的照片地址，
  53.                     }
  54.                     break;
  55.                 case REQUEST_CROP_PICKER_CODE:
  56.                     this.pictureSelectListner.onPictureSelect(tempFile.getAbsolutePath());
  57.                     break;
  58.             }
  59.         }
  60.     }
  62.     /**
  63.      * 调用摄像头拍照
  64.      */
  65.     public void takePhoto() {
  66.         if (CameraPermission()) { // 判断相机权限
  67.             Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
  68.             // 判断相机是否可以打开
  69.             if (cameraIntent.resolveActivity(activity.getPackageManager()) != null) {
  70.                 tempFile = FileUtils.getNewFile();
  71.                 outImageUri = getUriForFile(tempFile);
  72.                 cameraIntent.putExtra(MediaStore.EXTRA_OUTPUT, outImageUri);
  73.                 activity.startActivityForResult(cameraIntent, REQUEST_TAKE_PIC_CODE);
  74.             }
  75.         }
  76.     }
  78.     /**
  79.      * 裁剪照片
  80.      */
  81.     private void cropPicture() {
  82.         Intent intent = new Intent("com.android.camera.action.CROP");
  83.         // 设置需要裁剪的图片地址
  84.         intent.setDataAndType(outImageUri, "image/*");
  85.         intent.putExtra("crop", "true"); // 这里必须设置为true拍照之后才会进行裁剪操作
  86.         // 1.宽高和比例都不设置时,裁剪框可以自行调整(比例和大小都可以随意调整)
  87.         // 2.只设置裁剪框宽高比(aspect)后,裁剪框比例固定不可调整,只能调整大小
  88.         // 3.裁剪后生成图片宽高(output)的设置和裁剪框无关,只决定最终生成图片大小
  89.         // 4.裁剪框宽高比例(aspect)可以和裁剪后生成图片比例(output)不同,此时, 会以裁剪框的宽为准,
  90.         // 按照裁剪宽高比例生成一个图片,该图和框选部分可能不同,不同的情况可能是截取框选的一部分,
  91.         // 也可能超出框选部分, 向下延伸补足
  92.         // aspectX aspectY 是裁剪框宽高的比例
  93.         if (!aspectXY) {
  94.             intent.putExtra("aspectX", aspectX);
  95.             intent.putExtra("aspectY", aspectY);
  96.         }
  97.         // outputX outputY 是裁剪后生成图片的宽高输出大小
  98.         intent.putExtra("outputX", outputX);
  99.         intent.putExtra("outputY", outputY);
  100.         // return-data为true时,会直接返回bitmap数据,但是大图裁剪时会出现问题,推荐下面为false时的方式
  101.         // return-data为false时,不会返回bitmap,但需要指定一个MediaStore.EXTRA_OUTPUT保存图片uri
  102.         intent.putExtra("return-data", false);
  103.         // return-data为false时,设置输出的uri图片地址
  104.         intent.putExtra(MediaStore.EXTRA_OUTPUT, outImageUri);
  105.         // 图片输出格式
  106.         //intent.putExtra("outputFormat", Bitmap.CompressFormat.JPEG.toString());
  107.         intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);//不加会出现无法加载此图片的错误
  108.         intent.addFlags(Intent.FLAG_GRANT_WRITE_URI_PERMISSION);// 这两句是在7.0以上版本当targeVersion大于23时需要
  109.         activity.startActivityForResult(intent, REQUEST_CROP_PICKER_CODE);
  110.     }
  112.     /**
  113.      * 对Uri 进行处理
  114.      *
  115.      * @param file 返回 兼容处理后的 Uri
  116.      * @return
  117.      */
  118.     private Uri getUriForFile(File file) {
  119.         Uri fileUri;
  120.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) { // Android 7.0系统开始 使用本地真实的Uri路径不安全,使用FileProvider封装共享Uri
  121.             fileUri = FileProvider.getUriForFile(activity, "com.mtf.picturemanage.provider", file); //一定要和 AndroidManifest.xml 中的设置的名字一样
  122.         } else {
  123.             fileUri = Uri.fromFile(file);
  124.         }
  125.         return fileUri;
  126.     }
  128.     /**
  129.      * 判断相机权限，如果没有权限就帮忙申请了
  130.      */
  131.     private Boolean CameraPermission() {
  132.         if (ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED
  133.                 || ContextCompat.checkSelfPermission(activity, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
  134.             if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.CAMERA)) {
  135.                 Toast.makeText(activity, "您已经拒绝过一次,再次拒绝真的不可以拍照啦", Toast.LENGTH_LONG);
  136.             }
  137.             ActivityCompat.requestPermissions(activity, new String[]{Manifest.permission.CAMERA, Manifest.permission.READ_EXTERNAL_STORAGE}, CAMERA_PERMISSIONS_REQUEST_CODE);
  138.             return false;
  139.         } else {//有权限直接调用系统相机拍照
  140.             return true;
  141.         }
  142.     }
  144.     /**
  145.      * 申请相机权限的回调处理
  146.      *
  147.      * @param requestCode
  148.      * @param permissions
  149.      * @param grantResults
  150.      */
  151.     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
  152.         switch (requestCode) {
  153.             case CAMERA_PERMISSIONS_REQUEST_CODE: {//调用系统相机申请拍照权限回调
  154.                 if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
  155.                     takePhoto();
  156.                 } else {
  157.                     Toast.makeText(activity, "请您允许打开相机！！", Toast.LENGTH_LONG);
  158.                 }
  159.                 break;
  160.             }
  161.         }
  162.     }
  164.     /**
  165.      * 设置照片是否支持裁剪，默认为 false 不支持裁剪
  166.      *
  167.      * @param crop
  168.      * @return
  169.      */
  170.     public TakePictureManager setCrop(boolean crop) {
  171.         isCrop = crop;
  172.         return this;
  173.     }
  175.     /**
  176.      * 设置是否可以改变裁剪框的宽高比，默认为 false 不支持修改宽高比例
  177.      *
  178.      * @param aspectXY
  179.      * @return
  180.      */
  181.     public TakePictureManager setAspectXY(boolean aspectXY) {
  182.         this.aspectXY = aspectXY;
  183.         return this;
  184.     }
  186.     /**
  187.      * 设置裁剪框的宽高比例，默认为1*1
  188.      *
  189.      * @param aspectX
  190.      * @param aspectY
  191.      * @return
  192.      */
  193.     public TakePictureManager setAspectXY(int aspectX, int aspectY) {
  194.         this.aspectX = aspectX;
  195.         this.aspectY = aspectY;
  196.         return this;
  197.     }
  199.     /**
  200.      * 设置裁剪后图片的输出大小，默认为1000*1000
  201.      *
  202.      * @param outputX
  203.      * @param outputY
  204.      * @return
  205.      */
  206.     public TakePictureManager setOutputXY(int outputX, int outputY) {
  207.         this.outputX = outputX;
  208.         this.outputY = outputY;
  209.         return this;
  210.     }
  211. }
  213. public interface PicturePathListner {
  214.     void onPictureSelect(String imagePath);//返回图片的路径
  215. }

3、文件管理类

  2. /**
  3.  * 文件管理类
  4.  * 
  5.  * Created by mtf on 2019/4/26.
  6.  */
  7. public class FileUtils {
  9.     /**
  10.      * 拍照缓存地址
  11.      */
  12.     public static final String TAKE_PIC_CACHE_PATH = Environment.getExternalStorageDirectory().getAbsolutePath()+ "/picturemanage";
  14.     public static File getNewFile() {
  15.         File dir = new File(TAKE_PIC_CACHE_PATH);
  16.         if (!dir.exists()) {
  17.             dir.mkdir();
  18.         }
  19.         File file = new File(dir, System.currentTimeMillis() + ".jpg");//
  20.         return file;
  21.     }
  23.     /**
  24.      * 删除单个文件
  25.      *
  26.      * @param filePath 被删除文件的文件名
  27.      * @return 文件删除成功返回true，否则返回false
  28.      */
  29.     public static boolean deleteFile(String filePath) {
  30.         File file = new File(filePath);
  31.         if (file.isFile() && file.exists()) {
  32.             return file.delete();
  33.         }
  34.         return false;
  35.     }
  37.     /**
  38.      * 删除文件夹以及目录下的文件
  39.      *
  40.      * @param filePath 被删除目录的文件路径
  41.      * @return 目录删除成功返回true，否则返回false
  42.      */
  43.     public static boolean deleteDirectory(String filePath) {
  44.         boolean flag = false;
  45.         try {
  46.             // 如果filePath不以文件分隔符结尾，自动添加文件分隔符
  47.             if (!filePath.endsWith(File.separator)) {
  48.                 filePath = filePath + File.separator;
  49.             }
  50.             File dirFile = new File(filePath);
  51.             if (!dirFile.exists() || !dirFile.isDirectory()) {
  52.                 return false;
  53.             }
  54.             flag = true;
  55.             File[] files = dirFile.listFiles();
  56.             // 遍历删除文件夹下的所有文件(包括子目录)
  57.             for (int i = 0; i < files.length; i++) {
  58.                 if (files[i].isFile()) {
  59.                     // 删除子文件
  60.                     flag = deleteFile(files[i].getAbsolutePath());
  61.                     if (!flag)
  62.                         break;
  63.                 } else {
  64.                     // 删除子目录
  65.                     flag = deleteDirectory(files[i].getAbsolutePath());
  66.                     if (!flag)
  67.                         break;
  68.                 }
  69.             }
  70.             if (!flag)
  71.                 return false;
  72.             // 删除当前空目录
  73.             return dirFile.delete();
  74.         } catch (Exception e) {
  76.         }
  77.         return false;
  78.     }
  80.     /**
  81.      * 删除文件夹下的文件
  82.      *
  83.      * @param filePath 被删除目录的文件路径
  84.      * @return 目录删除成功返回true，否则返回false
  85.      */
  86.     public static boolean deleteDirectoryFile(String filePath, Context context) {
  87.         boolean flag = false;
  88.         try {
  89.             // 如果filePath不以文件分隔符结尾，自动添加文件分隔符
  90.             if (!filePath.endsWith(File.separator)) {
  91.                 filePath = filePath + File.separator;
  92.             }
  93.             File dirFile = new File(filePath);
  94.             if (!dirFile.exists() || !dirFile.isDirectory()) {
  95.                 return false;
  96.             }
  97.             flag = true;
  98.             File[] files = dirFile.listFiles();
  100.             if (files.length == 0) {
  101.                 return false;
  102.             } else {
  103.                 // 遍历删除文件夹下的所有文件(包括子目录)
  104.                 for (int i = 0; i < files.length; i++) {
  105.                     if (files[i].isFile()) {
  106.                         // 删除子文件
  107.                         flag = deleteFile(files[i].getAbsolutePath());
  109.                         deletePic(files[i].getAbsolutePath(),context);
  110.                         if (!flag)
  111.                             break;
  112.                     } else {
  113.                         // 删除子目录
  114.                         flag = deleteDirectory(files[i].getAbsolutePath());
  115.                         if (!flag)
  116.                             break;
  117.                     }
  118.                 }
  119.             }
  120.         } catch (Exception e) {
  122.         }
  124.         if (!flag)
  125.             return false;
  126.         return flag;
  127.     }
  129.     /**
  130.      * 根据路径删除指定的目录或文件，无论存在与否
  131.      *
  132.      * @param filePath 要删除的目录或文件
  133.      * @return 删除成功返回 true，否则返回 false。
  134.      */
  135.     public static boolean DeleteFolder(String filePath) {
  136.         File file = new File(filePath);
  137.         if (!file.exists()) {
  138.             return false;
  139.         } else {
  140.             if (file.isFile()) {
  141.                 // 为文件时调用删除文件方法
  142.                 return deleteFile(filePath);
  143.             } else {
  144.                 // 为目录时调用删除目录方法
  145.                 return deleteDirectory(filePath);
  146.             }
  147.         }
  148.     }
  150.     private static void deletePic(String path, Context context) {
  151.         if (!TextUtils.isEmpty(path)) {
  152.             Uri uri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
  153.             ContentResolver contentResolver = context.getContentResolver();
  154.             String url = MediaStore.Images.Media.DATA + "='" + path + "'";
  155.             //删除图片
  156.             contentResolver.delete(uri, url, null);
  157.         }
  158.     }
  159. }

4、图片处理类

  2. /**
  3.  * 图片裁剪压缩工具
  4.  * Created by mtf on 2019/4/26.
  5.  */
  6. public class ImageUtil {
  8.     /**
  9.      * 根据路径获得图片信息并按比例压缩，返回bitmap
  10.      */
  11.     public static Bitmap getSmallBitmap(String filePath, int width, int height) {
  12.         final BitmapFactory.Options options = new BitmapFactory.Options();
  13.         options.inJustDecodeBounds = true;// 只解析图片边沿，获取宽高
  14.         BitmapFactory.decodeFile(filePath, options);
  15.         if (width == 0) {
  16.             width = options.outWidth;
  17.             height = options.outHeight;
  18.         }
  19.         // 计算缩放比
  20.         options.inSampleSize = calculateInSampleSize(options, width, height);
  21.         // 完整解析图片返回bitmap
  22.         options.inJustDecodeBounds = false;
  23.         return BitmapFactory.decodeFile(filePath, options);
  24.     }
  26.     /**
  27.      * 计算缩放比
  28.      *
  29.      * @param options
  30.      * @param reqWidth
  31.      * @param reqHeight
  32.      * @return
  33.      */
  34.     private static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
  35.         final int height = options.outHeight;
  36.         final int width = options.outWidth;
  37.         int inSampleSize = 1;
  38.         if (height > reqHeight || width > reqWidth) {
  39.             final int halfHeight = height / 2;
  40.             final int halfWidth = width / 2;
  41.             while ((halfHeight / inSampleSize) > reqHeight && (halfWidth / inSampleSize) > reqWidth) {
  42.                 inSampleSize *= 2;
  43.             }
  44.         }
  45.         return inSampleSize;
  46.     }
  49.     /**
  50.      * 质量压缩
  51.      *
  52.      * @param image
  53.      * @param size
  54.      * @param imageType
  55.      * @return
  56.      */
  57.     public static byte[] compressImage(Bitmap image, int size, String imageType) {
  58.         try {
  59.             ByteArrayOutputStream baos = new ByteArrayOutputStream();
  60.             if (imageType.equalsIgnoreCase("png")) {
  61.                 image.compress(Bitmap.CompressFormat.PNG, 100, baos);
  62.             } else {
  63.                 image.compress(Bitmap.CompressFormat.JPEG, 100, baos);// 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
  64.             }
  65.             int options = 100;
  66.             while (baos.toByteArray().length / 1024 > size) { // 循环判断如果压缩后图片是否大于100kb,大于继续压缩
  67.                 baos.reset();// 重置baos即清空baos
  68.                 if (imageType.equalsIgnoreCase("png")) {
  69.                     image.compress(Bitmap.CompressFormat.PNG, options, baos);
  70.                 } else {
  71.                     image.compress(Bitmap.CompressFormat.JPEG, options, baos);// 这里压缩options%，把压缩后的数据存放到baos中
  72.                 }
  73.                 options -= 10;// 每次都减少10
  74.             }
  75.             return baos.toByteArray();
  76.         } catch (Exception e) {
  77.             return null;
  78.         }
  79.     }
  81.     public static String getImagePath(Context context, Uri uri, String selection) {
  82.         String path = null;
  83.         // 通过Uri和selection来获取真实的图片路径
  84.         Cursor cursor = context.getContentResolver().query(uri, null, selection, null, null);
  85.         if (cursor != null) {
  86.             if (cursor.moveToFirst()) {
  87.                 path = cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA));
  88.             }
  89.             cursor.close();
  90.         }
  91.         return path;
  92.     }
  94.     public static String getFilePathByUri(Context context, Uri uri) {
  95.         String imagePath = null;
  96.         if (context == null || uri == null) {
  97.             return imagePath;
  98.         }
  99.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
  100.             if (DocumentsContract.isDocumentUri(context, uri)) {
  101.                 // 如果是document类型的Uri，则通过document id处理
  102.                 String docId = DocumentsContract.getDocumentId(uri);
  103.                 if ("com.android.providers.media.documents".equals(uri.getAuthority())) {
  104.                     String id = docId.split(":")[1]; // 解析出数字格式的id
  105.                     String selection = MediaStore.Images.Media._ID + "=" + id;
  106.                     imagePath = getImagePath(context, MediaStore.Images.Media.EXTERNAL_CONTENT_URI, selection);
  107.                 } else if ("com.android.providers.downloads.documents".equals(uri.getAuthority())) {
  108.                     Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(docId));
  109.                     imagePath = getImagePath(context, contentUri, null);
  110.                 }
  111.             } else if ("content".equalsIgnoreCase(uri.getScheme())) {
  112.                 // 如果是content类型的Uri，则使用普通方式处理
  113.                 imagePath = getImagePath(context, uri, null);
  114.             } else if ("file".equalsIgnoreCase(uri.getScheme())) {
  115.                 // 如果是file类型的Uri，直接获取图片路径即可
  116.                 imagePath = uri.getPath();
  117.             }
  118.         } else {
  119.             if ("content".equalsIgnoreCase(uri.getScheme())) {
  120.                 // 如果是content类型的Uri，则使用普通方式处理
  121.                 imagePath = getImagePath(context, uri, null);
  122.             } else if ("file".equalsIgnoreCase(uri.getScheme())) {
  123.                 // 如果是file类型的Uri，直接获取图片路径即可
  124.                 imagePath = uri.getPath();
  125.             }
  126.         }
  127.         return imagePath;
  128.     }
  129. }

5、图片管理类

  2. /**
  3.  * 图片裁剪压缩工具
  4.  * Created by mtf on 2019/4/26.
  5.  */
  6. public class ImageUtil {
  8.     /**
  9.      * 根据路径获得图片信息并按比例压缩，返回bitmap
  10.      */
  11.     public static Bitmap getSmallBitmap(String filePath, int width, int height) {
  12.         final BitmapFactory.Options options = new BitmapFactory.Options();
  13.         options.inJustDecodeBounds = true;// 只解析图片边沿，获取宽高
  14.         BitmapFactory.decodeFile(filePath, options);
  15.         if (width == 0) {
  16.             width = options.outWidth;
  17.             height = options.outHeight;
  18.         }
  19.         // 计算缩放比
  20.         options.inSampleSize = calculateInSampleSize(options, width, height);
  21.         // 完整解析图片返回bitmap
  22.         options.inJustDecodeBounds = false;
  23.         return BitmapFactory.decodeFile(filePath, options);
  24.     }
  26.     /**
  27.      * 计算缩放比
  28.      *
  29.      * @param options
  30.      * @param reqWidth
  31.      * @param reqHeight
  32.      * @return
  33.      */
  34.     private static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
  35.         final int height = options.outHeight;
  36.         final int width = options.outWidth;
  37.         int inSampleSize = 1;
  38.         if (height > reqHeight || width > reqWidth) {
  39.             final int halfHeight = height / 2;
  40.             final int halfWidth = width / 2;
  41.             while ((halfHeight / inSampleSize) > reqHeight && (halfWidth / inSampleSize) > reqWidth) {
  42.                 inSampleSize *= 2;
  43.             }
  44.         }
  45.         return inSampleSize;
  46.     }
  49.     /**
  50.      * 质量压缩
  51.      *
  52.      * @param image
  53.      * @param size
  54.      * @param imageType
  55.      * @return
  56.      */
  57.     public static byte[] compressImage(Bitmap image, int size, String imageType) {
  58.         try {
  59.             ByteArrayOutputStream baos = new ByteArrayOutputStream();
  60.             if (imageType.equalsIgnoreCase("png")) {
  61.                 image.compress(Bitmap.CompressFormat.PNG, 100, baos);
  62.             } else {
  63.                 image.compress(Bitmap.CompressFormat.JPEG, 100, baos);// 质量压缩方法，这里100表示不压缩，把压缩后的数据存放到baos中
  64.             }
  65.             int options = 100;
  66.             while (baos.toByteArray().length / 1024 > size) { // 循环判断如果压缩后图片是否大于100kb,大于继续压缩
  67.                 baos.reset();// 重置baos即清空baos
  68.                 if (imageType.equalsIgnoreCase("png")) {
  69.                     image.compress(Bitmap.CompressFormat.PNG, options, baos);
  70.                 } else {
  71.                     image.compress(Bitmap.CompressFormat.JPEG, options, baos);// 这里压缩options%，把压缩后的数据存放到baos中
  72.                 }
  73.                 options -= 10;// 每次都减少10
  74.             }
  75.             return baos.toByteArray();
  76.         } catch (Exception e) {
  77.             return null;
  78.         }
  79.     }
  81.     public static String getImagePath(Context context, Uri uri, String selection) {
  82.         String path = null;
  83.         // 通过Uri和selection来获取真实的图片路径
  84.         Cursor cursor = context.getContentResolver().query(uri, null, selection, null, null);
  85.         if (cursor != null) {
  86.             if (cursor.moveToFirst()) {
  87.                 path = cursor.getString(cursor.getColumnIndex(MediaStore.Images.Media.DATA));
  88.             }
  89.             cursor.close();
  90.         }
  91.         return path;
  92.     }
  94.     public static String getFilePathByUri(Context context, Uri uri) {
  95.         String imagePath = null;
  96.         if (context == null || uri == null) {
  97.             return imagePath;
  98.         }
  99.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT) {
  100.             if (DocumentsContract.isDocumentUri(context, uri)) {
  101.                 // 如果是document类型的Uri，则通过document id处理
  102.                 String docId = DocumentsContract.getDocumentId(uri);
  103.                 if ("com.android.providers.media.documents".equals(uri.getAuthority())) {
  104.                     String id = docId.split(":")[1]; // 解析出数字格式的id
  105.                     String selection = MediaStore.Images.Media._ID + "=" + id;
  106.                     imagePath = getImagePath(context, MediaStore.Images.Media.EXTERNAL_CONTENT_URI, selection);
  107.                 } else if ("com.android.providers.downloads.documents".equals(uri.getAuthority())) {
  108.                     Uri contentUri = ContentUris.withAppendedId(Uri.parse("content://downloads/public_downloads"), Long.valueOf(docId));
  109.                     imagePath = getImagePath(context, contentUri, null);
  110.                 }
  111.             } else if ("content".equalsIgnoreCase(uri.getScheme())) {
  112.                 // 如果是content类型的Uri，则使用普通方式处理
  113.                 imagePath = getImagePath(context, uri, null);
  114.             } else if ("file".equalsIgnoreCase(uri.getScheme())) {
  115.                 // 如果是file类型的Uri，直接获取图片路径即可
  116.                 imagePath = uri.getPath();
  117.             }
  118.         } else {
  119.             if ("content".equalsIgnoreCase(uri.getScheme())) {
  120.                 // 如果是content类型的Uri，则使用普通方式处理
  121.                 imagePath = getImagePath(context, uri, null);
  122.             } else if ("file".equalsIgnoreCase(uri.getScheme())) {
  123.                 // 如果是file类型的Uri，直接获取图片路径即可
  124.                 imagePath = uri.getPath();
  125.             }
  126.         }
  127.         return imagePath;
  128.     }
  129. }

6、7.0以上Provider设置

1.在AndroidManifest.xml中声明一个条目
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <manifest xmlns:android="http://schemas.android.com/apk/res/android"
  3.     package="com.mtf.picturemanage">
  4.     <uses-feature android:name="android.hardware.camera" />
  5.     <!--相机权限-->
  6.     <uses-permission android:name="android.permission.CAMERA" />
  7.     <!--写入SD卡的权限：保存相机拍照后的照片-->
  8.     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
  9.     <!--读取SD卡的权限:打开相册选取图片所必须的权限-->
  10.     <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
  12.     <application
  13.         ...>
  14.         ...
  16.         <provider
  17.             android:name="android.support.v4.content.FileProvider"
  18.             android:authorities="com.mtf.picturemanage.provider"
  19.             android:exported="false"
  20.             android:grantUriPermissions="true">
  21.             <meta-data
  22.                 android:name="android.support.FILE_PROVIDER_PATHS"
  23.                 android:resource="@xml/filepaths" />
  24.         </provider>
  25.     </application>
  27. </manifest>
2、指定想分享的目录。在res目录下新建一个xml目录，在xml目录下面新建一个xml文件。我新建的文件名叫filepaths.xml
  1. <?xml version="1.0" encoding="utf-8"?>
  2. <paths>
  3.     <!-- 注意 name 的名称设置不可以相同，否则会报错-->
  4.     <!--代表外部存储区域的根目录下的文件 Environment.getExternalStorageDirectory()/DCIM/camerademo目录-->
  5.     <external-path name="hm_DCIM" path="DCIM/camera" />
  6.     <!--代表外部存储区域的根目录下的文件 Environment.getExternalStorageDirectory()/Pictures/camerademo目录-->
  7.     <external-path name="hm_Pictures" path="Pictures/camera" />
  8.     <!--代表app 私有的存储区域 Context.getFilesDir()目录下的images目录 /data/user/0/com.hm.camerademo/files/images-->
  9.     <files-path name="hm_private_files" path="images" />
  10.     <!--代表app 私有的存储区域 Context.getCacheDir()目录下的images目录 /data/user/0/com.hm.camerademo/cache/images-->
  11.     <cache-path name="hm_private_cache" path="images" />
  12.     <!--代表app 外部存储区域根目录下的文件 Context.getExternalFilesDir(Environment.DIRECTORY_PICTURES)目录下的Pictures目录-->
  13.     <!--/storage/emulated/0/Android/data/com.hm.camerademo/files/Pictures-->
  14.     <external-files-path name="hm_external_files" path="." />
  15.     <!--代表app 外部存储区域根目录下的文件 Context.getExternalCacheDir目录下的images目录-->
  16.     <!--/storage/emulated/0/Android/data/com.hm.camerademo/cache/images-->
  17.     <external-cache-path name="hm_external_cache" path="." />
  18.     <root-path name="honjane" path="" />
  19. </paths>

7、简单使用实例

  1. public class MainActivity extends AppCompatActivity {
  3.     private Button btCarmera;
  4.     private ImageView ivPhoto;
  6.     TakePictureManager selectPictureManager;
  8.     @Override
  9.     protected void onCreate(Bundle savedInstanceState) {
  10.         super.onCreate(savedInstanceState);
  11.         setContentView(R.layout.activity_main);
  13.         btCarmera = findViewById(R.id.bt_carmera);
  14.         ivPhoto = findViewById(R.id.iv_photo);
  16.         selectPictureManager = new TakePictureManager(this)
  17.                 .setCrop(true);//设置是否需要裁剪，默认不裁剪
  19.         //点击按钮进行拍照
  20.         btCarmera.setOnClickListener(new View.OnClickListener() {
  21.             @Override
  22.             public void onClick(View v) {
  23.                 selectPictureManager.takePhoto();
  24.             }
  25.         });
  27.         selectPictureManager.setPictureSelectListner(new PicturePathListner() {
  28.             @Override
  29.             public void onPictureSelect(String imagePath) {
  30.                 // 这里对照片进行了按比例压缩，根据项目需要可能还会进行质量压缩
  31.                 ivPhoto.setImageBitmap(ImageUtil.getSmallBitmap(imagePath, 358, 441));
  32.             }
  33.         });
  35.     }
  37.     @Override
  38.     public void onActivityResult(int requestCode, int resultCode, Intent data) {
  39.         super.onActivityResult(requestCode, resultCode, data);
  40.         selectPictureManager.onActivityResult(requestCode, resultCode, data);
  41.     }
  43.     @Override
  44.     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
  45.         super.onRequestPermissionsResult(requestCode, permissions, grantResults);
  46.         selectPictureManager.onRequestPermissionsResult(requestCode, permissions, grantResults);
  47.     }
  49.     /**
  50.      * 退出时，删除临时图片
  51.      */
  52.     @Override
  53.     protected void onDestroy() {
  54.         super.onDestroy();
  55.         FileUtils.DeleteFolder(FileUtils.TAKE_PIC_CACHE_PATH);
  56.         System.gc();
  57.     }
  58. }

（完）