android:运行时权限工具类的封装

/**
 * 作者：CnPeng
 * <p>
 * 时间：2017/12/5:下午2:11
 * <p>
 * 说明：动态权限申请工具类 < 当前只在Activity中使用过，无异常。FM 中暂未测试 >
 * <p>
 * 注意，处理权限被拒绝有两种方式，
 * （1）一种是在拒绝之后直接给出提示，提示用户拒绝之后将不能使用XX功能，如果是这种方式的话，就使用一个参数的构造，然后直接判断权限是否全都被允许，
 * 如果全都被允许直接执行相关事件；如果有权限未被允许则申请权限。
 * （2）一种是拒绝之后不给提示，然后下次进入时先检测是否有被拒绝的，如果有则展示dialog，这种情况就需要调用两个参数的构造，并调用
 * showRequestReasonOrHandlePermissionEvent()方法，由该方法决定是否需要展示dialog，如果不需要，则执行外部通过PermissionGrantedFactory
 * 传递的事件。
 */

public class DynamicPermissionTool {
    private Context                  context;
    private PermissionGrantedFactory permissionGrantedFactory;

    public String[] permissions = {Manifest.permission.CAMERA, Manifest.permission.WRITE_EXTERNAL_STORAGE};
    public String[] deniedHints = {"没有相机权限将不能拍照", "没有存储设备的读写权限将不能存储照片到本地"};

    /**
     * 如果不需要判断是否之前被拒绝过，调用该构造
     */
    public DynamicPermissionTool(Context context) {
        this.context = context;
    }

    /**
     * 如果需要判断之前是否被拒绝过，调用该构造，
     *
     * @param context                  context
     * @param permissionGrantedFactory permissionGrantedFactory
     */
    public DynamicPermissionTool(Context context, PermissionGrantedFactory permissionGrantedFactory) {
        this.context = context;
        this.permissionGrantedFactory = permissionGrantedFactory;
    }

    /**
     * 检查单个权限是否已经被允许
     *
     * @param permission 要申请的权限
     */
    public boolean checkCurPermissionStatus(String permission) {
        return PackageManager.PERMISSION_GRANTED == ContextCompat.checkSelfPermission(context, permission);
    }

    /**
     * 检查一组权限的授权状态。
     *
     * @param permissions 权限数组
     * @return 权限的状态数组
     */
    public boolean[] checkCurPermissionsStatus(String[] permissions) {
        if (null != permissions && permissions.length > 0) {
            boolean[] permissionsStatus = new boolean[permissions.length];

            for (int i = 0; i < permissions.length; i++) {
                boolean permissionStatus = checkCurPermissionStatus(permissions[i]);
                permissionsStatus[i] = permissionStatus;
            }
            return permissionsStatus;
        } else {
            throw new IllegalArgumentException("参数不能为空，且必须有元素");
        }
    }

    /**
     * 获取被拒绝的权限
     *
     * @param permissions 要申请的全部权限
     */
    public String[] getDeniedPermissions(String[] permissions) {
        if (null != permissions && permissions.length > 0) {
            List<String> deniedPermissionList = new ArrayList<>();

            boolean[] permissionsStatus = checkCurPermissionsStatus(permissions);
            for (int i = 0; i < permissions.length; i++) {
                if (!permissionsStatus[i]) {
                    deniedPermissionList.add(permissions[i]);
                }
            }

            String[] deniedPermissions = new String[deniedPermissionList.size()];
            return deniedPermissionList.toArray(deniedPermissions);
        } else {
            throw new IllegalArgumentException("参数不能为空，且必须有元素");
        }
    }

    /**
     * 获取被拒绝的权限对应的提示文本数组
     *
     * @param permissions 要申请的全部权限
     * @param hints       权限被拒绝时的提示文本
     */
    public String[] getDeniedHint(String[] permissions, String[] hints) {
        if (null == permissions || null == hints || permissions.length == 0 || hints.length == 0 || permissions
                .length != hints.length) {
            throw new IllegalArgumentException("参数不能为空、必须有元素，且两个参数的长度必须一致");
        } else {
            List<String> deniedHintList = new ArrayList<>();

            boolean[] permissionsStatus = checkCurPermissionsStatus(permissions);
            for (int i = 0; i < permissions.length; i++) {
                if (!permissionsStatus[i]) {
                    deniedHintList.add(hints[i]);
                }
            }

            String[] deniedPermissions = new String[deniedHintList.size()];
            return deniedHintList.toArray(deniedPermissions);
        }
    }

    /**
     * 获取被拒绝的权限对应的提示文本字符串
     *
     * @param permissions 要申请的全部权限
     * @param hints       权限被拒绝时的提示文本
     */
    public String getDeniedHintStr(String[] permissions, String[] hints) {
        if (null == permissions || null == hints || permissions.length == 0 || hints.length == 0 || permissions
                .length != hints.length) {
            throw new IllegalArgumentException("参数不能为空、必须有元素，且两个参数的长度必须一致");
        } else {
            StringBuilder hintStr = new StringBuilder();
            boolean[] permissionsStatus = checkCurPermissionsStatus(permissions);
            for (int i = 0; i < permissions.length; i++) {
                if (!permissionsStatus[i]) {
                    hintStr.append(hints[i]).append("\n");
                }
            }
            return hintStr.toString();
        }
    }

    /**
     * 是否所有权限都已经被允许
     *
     * @param permissions 申请的权限
     * @return true 全被允许，false 有没有被允许的权限
     */
    public boolean isAllPermissionGranted(String[] permissions) {
        return getDeniedPermissions(permissions).length == 0;
    }

    /**
     * 是否所有权限都已经被允许
     *
     * @param grantResults 权限申请的结果
     * @return true 全被允许，false 有没有被允许的权限
     */
    public boolean isAllPermissionGranted(int[] grantResults) {
        int isAllGranted = PackageManager.PERMISSION_GRANTED;
        for (int grantResult : grantResults) {
            isAllGranted = isAllGranted | grantResult;
        }
        return isAllGranted == 0;
    }

    /**
     * 请求权限
     *
     * @param activity    Activity
     * @param permissions 权限
     * @param requestCode 请求码
     */
    public void requestNecessaryPermissions(Activity activity, String[] permissions, int requestCode) {
        ActivityCompat.requestPermissions(activity, permissions, requestCode);
    }


    /**
     * 检测之前是否已经拒绝过。如果已经拒绝过，那么再次请求权限的时候就需要给出原因
     *
     * @param activity    activity
     * @param permissions 请求的权限
     */
    public boolean shouldShowRequestReason(Activity activity, String[] permissions) {
        boolean showReason = false;
        for (int i = 0; i < permissions.length; i++) {
            showReason = showReason | ActivityCompat.shouldShowRequestPermissionRationale(activity, permissions[i]);
        }
        return showReason;
    }

    /**
     * 展示被拒绝的弹窗
     */
    public void showDeniedDialog(final Context context, String message) {
        AlertDialog.Builder builder = new AlertDialog.Builder(context);
        builder.setTitle("提示");
        builder.setMessage(message);
        builder.setNegativeButton("就不给你权限", null);
        builder.setPositiveButton("我要重新开启权限", new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                openSysSettingPage(context);
            }
        });
        builder.setCancelable(false);
        builder.show();
    }

    /**
     * 打开系统设置界面
     */
    private void openSysSettingPage(Context context) {
        Intent intent = new Intent();
        intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
        Uri uri = Uri.fromParts("package", context.getPackageName(), null);
        intent.setData(uri);
        context.startActivity(intent);
    }

    /**
     * 如果需要判断之前是否被拒绝过，则创建该类的实例，然后将具体的事件处理放在该类的方法中
     */
    public interface PermissionGrantedFactory {
        /**
         * 处理事件或者请求权限：如果权限已经被允许，执行事件，否则请求权限
         */
        void handleEventOrRequestPermission();
    }

    /**
     * 判断是否需要展示为什么二次请求权限，如果不需要执行相应的操作
     * <p>
     * 该方法中首先会检测之前是否被拒绝过，如果已经被拒绝过则展示为什么需要再次申请这个权限，并引导用户去设置中开启权限。
     *
     * @param activity    activity
     * @param permissions 请求的权限
     * @param hints       权限被拒绝时的提示
     */
    public void showRequestReasonOrHandlePermissionEvent(Activity activity, String[] permissions, String[] hints) {
        boolean hadBeanDenied = shouldShowRequestReason(activity, permissions);
        if (hadBeanDenied) {
            showDeniedDialog(activity, getDeniedHintStr(permissions, hints));
        } else {
            if (null != permissionGrantedFactory) {
                permissionGrantedFactory.handleEventOrRequestPermission();
            }
        }
    }
}

/**
 * 作者：CnPeng
 * <p>
 * 时间：2017/12/1:上午10:36
 * <p>
 * 说明：调用系统相机执行拍照操作
 * 主要知识点：
 * 1、调用系统相机执行拍照
 * 2、动态权限申请
 * 3、刷新相册
 * 4、开启APP对应的设置界面
 * 5、使用 FileProvider 解决7.0及以后系统中使用 Uri.fromUri() 获取URI之后调用相机崩溃的情况
 * 6、getExternalCacheDir()获取当前APP对应的缓存目录，使用该方式不用申请读写SD的权限
 * <p>
 * 注意：
 * 不同品牌的手机对拍照处理不一样，个别手机中即便我们没有指定存储路径，也会存储照片到默认的地址中。如：Galaxy Note4 调用系统相机执行拍照时，
 * 如果么有指定照片存储路径，则会存储在 DCIM/Camera 目录下，此时，即便不调用 刷新相册的方法，也会执行刷新操作。V3
 * 
 * 171205 封装动态权限请求工具类
 */
public class TakePhotoActivity extends AppCompatActivity {

    private ActivityTakephotoBinding binding;
    private File                     file;
    private       String takePhotoMode          = "";
    private final String MODE_TAKE_AND_SAVE     = "takePhotoAndSaveToLocal";
    private final String MODE_TAKE_AND_NOT_SAVE = "takePhotoAndNotSaveToLocal";
    private final int    REQUEST_CODE1          = 0;    //申请权限时的请求码
    private DynamicPermissionTool                          permissionTool;
    private DynamicPermissionTool.PermissionGrantedFactory factory;

    @Override
    protected void onCreate(
            @Nullable
                    Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        binding = DataBindingUtil.setContentView(this, R.layout.activity_takephoto);

        //permissionTool = new DynamicPermissionTool(TakePhotoActivity.this);

        factory = new DynamicPermissionTool.PermissionGrantedFactory() {
            @Override
            public void handleEventOrRequestPermission() {
                takePhotoOrRequestPermission();
            }
        };
        permissionTool = new DynamicPermissionTool(TakePhotoActivity.this, factory);

        initTakePhotoBtEvent();
    }

    private void initTakePhotoBtEvent() {

        binding.btTakePhoto.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                takePhotoMode = MODE_TAKE_AND_SAVE;
                //handlePermissonEvent();
                permissionTool.showRequestReasonOrHandlePermissionEvent(TakePhotoActivity.this, permissionTool
                        .permissions, permissionTool.deniedHints);
            }
        });
        binding.btTakePhoto2.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                takePhotoMode = MODE_TAKE_AND_NOT_SAVE;
                //handlePermissonEvent();
                permissionTool.showRequestReasonOrHandlePermissionEvent(TakePhotoActivity.this, permissionTool
                        .permissions, permissionTool.deniedHints);
            }
        });
    }

    private void takePhotoOrRequestPermission() {
        boolean isAllGranted = permissionTool.isAllPermissionGranted(permissionTool.permissions);

        if (isAllGranted) {
            openSysCameraView();
        } else {
            String[] deniedPermissions = permissionTool.getDeniedPermissions(permissionTool.permissions);
            permissionTool.requestNecessaryPermissions(TakePhotoActivity.this, deniedPermissions, REQUEST_CODE1);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           @NonNull
                                                   String[] permissions,
                                           @NonNull
                                                   int[] grantResults) {
        switch (requestCode) {
            case REQUEST_CODE1:
                boolean isAllGranted = permissionTool.isAllPermissionGranted(grantResults);
                if (isAllGranted) {
                    openSysCameraView();
                } else {
                    //factory 不为空表示在执行点击事件时会先检测是否有权限被拒绝了，如果有则dialog的展示就放在检测完之后处理，所以此处不用重复展示
                    if (null == factory) {
                        String hint = permissionTool.getDeniedHintStr(permissionTool.permissions, permissionTool
                                .deniedHints);
                        permissionTool.showDeniedDialog(TakePhotoActivity.this, hint);
                    }
                }
                break;
            default:
                break;
        }
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }

    /**
     * 调用系统相机执行拍照
     * <p>
     * 这里使用的 getExternalCacheDir() 是系统为每个APP单独分配的缓存空间，返回一个绝对路径，API19以后使用该路径不需要申请权限，API19之前需
     * 要申请。该路径只对当前APP可用，其他APP不可访问，也就是说，如果我们将照片存储在这个路径，系统的媒体扫描器也无法检测到该路径的内容，也就无法
     * 实现 相册/图库 内容的刷新。APP卸载则该目录清空。getExternalFilesDir() 与此相同
     * <p>
     * If you saved your photo to the directory provided by getExternalFilesDir(), the media scanner cannot access the
     * files because they are private to your app.
     */
    private void openSysCameraView() {
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

        if (MODE_TAKE_AND_SAVE.equals(takePhotoMode)) {
            //如果是拍照并存储，则需要指定在本地的存储路径，并需要获取拍照之后的结果
            //file = new File(getExternalCacheDir(), System.currentTimeMillis() + "temp.jpg");
            // file = new File(getExternalFilesDir(Environment.DIRECTORY_PICTURES), System.currentTimeMillis() + "temp" 
            //         + ".jpg");

            file = new File(Environment.getExternalStoragePublicDirectory(DIRECTORY_PICTURES), System
                    .currentTimeMillis() + "temp.jpg");
            Uri photoURI;
            photoURI = getPhotoUri(file);

            intent.putExtra(MediaStore.EXTRA_OUTPUT, photoURI);
        }
        startActivityForResult(intent, Activity.DEFAULT_KEYS_DIALER);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        if (Activity.RESULT_OK == resultCode) {
            //读取存储在本地的图片作为背景，这个图的清晰度会比较高
            if (MODE_TAKE_AND_SAVE.equals(takePhotoMode)) {
                Uri photoUri = getPhotoUri(file);
                try {
                    Drawable drawable = Drawable.createFromStream(getContentResolver().openInputStream(photoUri), "");
                    binding.parentLayout.setBackground(drawable);
                } catch (FileNotFoundException e) {
                    e.printStackTrace();
                }
                updateGallery(photoUri);
            } else {
                //相机拍照后会返回一个intent给onActivityResult。 intent的extra部分包含一个编码过的Bitmap缩略图,但这个Bitmap会比较模糊
                Bundle bundle = data.getExtras();
                if (null != bundle) {
                    Bitmap bitmap = (Bitmap) bundle.get("data");
                    Drawable drawable = new BitmapDrawable(bitmap);
                    binding.parentLayout.setBackground(drawable);
                }
            }
        }
        //模式使用完之后记得要重置
        takePhotoMode = "";
    }


    /**
     * 发送广播更新相册，不更新的话，在相册中将无法查看到截取的图片
     * If you saved your photo to the directory provided by getExternalFilesDir(), the media scanner cannot access the
     * files because they are private to your app.
     */
    private void updateGallery(Uri photoURI) {
        Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE, photoURI);
        sendBroadcast(intent);
    }

    private Uri getPhotoUri(File file) {
        Uri photoURI;
        if (Build.VERSION.SDK_INT > 21) {
            photoURI = FileProvider.getUriForFile(getApplicationContext(), BuildConfig.APPLICATION_ID + "" + "" + "" 
                    + ".fileprovider", file);
            //  Uri photoURI = FileProvider.getUriForFile(TakePhotoActivity.this,getPackageName()+ 
            // "" + ".fileprovider", file);     //这种方式也可以获取URI
        } else {
            photoURI = Uri.fromFile(file);
        }
        return photoURI;
    }
}