Android的权限处理

Android权限处理

Android的权限从Android6.0开始，经过多年的发展，现在到了Android12，对于Android的权限处理也有了很大的改变。我收集了自己在support和androidx的的权限处理

support

/**
 * Create by LZ at 2021/11/18
 */
public class PermissionUtil {
    private Object object; // activity or fragment
    private static OnPermissionResultListener onPermissionResultListener;

    /**
     * ********************* init *********************
     */

    private PermissionUtil(Object object) {
        this.object = object;
    }

    public static PermissionUtil with(Activity activity) {
        return new PermissionUtil(activity);
    }

    public static PermissionUtil with(Fragment fragment) {
        return new PermissionUtil(fragment);
    }

    /**
     * ********************* request *********************
     */
    @TargetApi(value = Build.VERSION_CODES.M)
    public void needPermission(int requestCode, String[] permissions, OnPermissionResultListener permissionResultListener) {
        requestPermissions(object, requestCode, permissions, permissionResultListener);
    }

    public static void needPermission(Activity activity, int requestCode, String[] permissions, OnPermissionResultListener permissionResultListener) {
        requestPermissions(activity, requestCode, permissions, permissionResultListener);
    }

    public static void needPermission(Fragment fragment, int requestCode, String[] permissions, OnPermissionResultListener permissionResultListener) {
        requestPermissions(fragment, requestCode, permissions, permissionResultListener);
    }

    public static void needPermission(Activity activity, int requestCode, String permission, OnPermissionResultListener permissionResultListener) {
        needPermission(activity, requestCode, new String[]{permission}, permissionResultListener);
    }

    public static void needPermission(Fragment fragment, int requestCode, String permission, OnPermissionResultListener permissionResultListener) {
        needPermission(fragment, requestCode, new String[]{permission}, permissionResultListener);
    }

    @TargetApi(value = Build.VERSION_CODES.M)
    private static void requestPermissions(Object object, int requestCode, String[] permissions, OnPermissionResultListener resultListener) {
        onPermissionResultListener = resultListener;
        List deniedPermissions = findDeniedPermissions(getActivity(object), permissions);
        if (deniedPermissions.size() > 0) {
            if (object instanceof Activity) {
                ((Activity) object).requestPermissions(deniedPermissions.toArray(new String[deniedPermissions.size()]), requestCode);
            } else if (object instanceof Fragment) {
                ((Fragment) object).requestPermissions(deniedPermissions.toArray(new String[deniedPermissions.size()]), requestCode);
            } else {
                throw new IllegalArgumentException(object.getClass().getName() + " is not supported");
            }
        } else {
            onPermissionResultListener.requestPermissionResult(requestCode, Arrays.asList(permissions), Collections.emptyList(), Collections.emptyList());
        }
    }

    /**
     * ********************* on result *********************
     */
    public static void onRequestPermissionsResult(Activity activity, int requestCode, String[] permissions, int[] grantResults) {
        requestResult(activity, requestCode, permissions, grantResults);
    }

    public static void onRequestPermissionsResult(Fragment fragment, int requestCode, String[] permissions, int[] grantResults) {
        requestResult(fragment, requestCode, permissions, grantResults);
    }

    private static void requestResult(Object obj, int requestCode, String[] permissions, int[] grantResults) {
        List grantPermissions = new ArrayList<>();
        List deniedPermissions = new ArrayList<>();
        List neverAskPermissions = new ArrayList<>();
        for (int i = 0; i < grantResults.length; i++) {
            if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
                deniedPermissions.add(permissions[i]);
                if (neverAskAgainPermission(getActivity(obj),permissions[i])){
                    neverAskPermissions.add(permissions[i]);
                }
            } else {
                grantPermissions.add(permissions[i]);
            }
        }
        if (onPermissionResultListener != null) {
            onPermissionResultListener.requestPermissionResult(requestCode, grantPermissions, deniedPermissions, neverAskPermissions);
        }
    }

    public interface OnPermissionResultListener {
        void requestPermissionResult(int requestCode, List grantPermissions, List deniedPermissions, List neverAskPermissions);
    }

    public static List getDeniedPermissions(Activity activity, String[] permissions) {
        return findDeniedPermissions(activity, permissions);
    }

    public static List getDeniedPermissions(Fragment fragment, String[] permissions) {
        return findDeniedPermissions(fragment.getActivity(), permissions);
    }

    public static List getNeverAskAgainPermissions(Activity activity, String[] permissions) {
        return findNeverAskAgainPermissions(activity, permissions);
    }

    public static List getNeverAskAgainPermissions(Fragment fragment, String[] permissions) {
        return findNeverAskAgainPermissions(fragment.getActivity(), permissions);
    }

    public static boolean isOverMarshmallow() {
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
    }

    public static Activity getActivity(Object object) {
        if (object instanceof Fragment) {
            return ((Fragment) object).getActivity();
        } else if (object instanceof Activity) {
            return (Activity) object;
        }
        return null;
    }

    @TargetApi(value = Build.VERSION_CODES.M)
    public static List findDeniedPermissions(Activity activity, String... permission) {
        if (!isOverMarshmallow()) {
            return Collections.emptyList();
        }
        List denyPermissions = new ArrayList<>();
        for (String value : permission) {
            if (denyAgainPermission(activity, value)) {
                denyPermissions.add(value);
            }
        }
        return denyPermissions;
    }

    @TargetApi(value = Build.VERSION_CODES.M)
    public static boolean denyAgainPermission(Activity activity, String permission) {
        return activity.checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED;
    }

    @TargetApi(value = Build.VERSION_CODES.M)
    public static boolean neverAskAgainPermission(Activity activity, String permission) {
        return activity.checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED &&
                !activity.shouldShowRequestPermissionRationale(permission);
    }

    @TargetApi(value = Build.VERSION_CODES.M)
    public static List findNeverAskAgainPermissions(Activity activity, String... permission) {
        if (!isOverMarshmallow()) {
            return Collections.emptyList();
        }
        List neverAskAgainPermission = new ArrayList<>();
        for (String value : permission) {
            if (neverAskAgainPermission(activity, value)) {
                neverAskAgainPermission.add(value);
            }
        }
        return neverAskAgainPermission;
    }
}

androidx

/**
 * 权限工具类
 * 可以先检查之后再申请
 * androidx的权限进行了调整
 */
public class PermissionHelper {

    private static Object object;

    private PermissionHelper(Object object) {
        this.object = object;
    }

    public static PermissionHelper with(AppCompatActivity activity) {
        return new PermissionHelper(activity);
    }

    public static PermissionHelper with(Fragment fragment) {
        return new PermissionHelper(fragment);
    }

    /**
     * 权限检查的回调
     */
    public interface CheckCallBack {
        void onHasPermission();

        void notHasPermission(List list);
    }

    /**
     * 检查单个权限
     *
     * @param permission
     * @param checkCallBack
     */
    public void checkPermission(String permission, CheckCallBack checkCallBack) {
        List permissionList = new ArrayList<>();
        permissionList.add(permission);
        checkPermissions(getActivity(object), permissionList, checkCallBack);
    }

    /**
     * 检查多个权限
     *
     * @param permissions
     * @param checkCallBack
     */
    public void checkPermissions(Context context, List permissions, CheckCallBack checkCallBack) {
        if (context != null && isOverMarshmallow()) {
            List denyList = isPermissionsGranted(context, permissions);
            if (null == denyList || denyList.isEmpty()) {
                checkCallBack.onHasPermission();
            } else {
                checkCallBack.notHasPermission(denyList);
            }
        } else {
            checkCallBack.onHasPermission();
        }
    }

    /**
     * @param permissions 未授权的权限集合
     * @return
     */
    private List isPermissionsGranted(Context context, List permissions) {
        if (null == permissions || permissions.isEmpty()) {
            return null;
        }
        List denyPermissions = new ArrayList<>();
        for (String permission : permissions) {
            if (!isPermissionGranted(context, permission)) {
                denyPermissions.add(permission);
            }
        }
        return denyPermissions;
    }

    /**
     * 权限申请结果
     */
    public interface ResultCallBack {
        /**
         * 已全部允许
         */
        void onGrandPermission();

        /**
         * 已全部拒绝
         */
        void onDenyPermission();

        /**
         * @param denyPermissions     已拒绝的权限集合
         * @param doNotAskPermissions 不再询问的权限集合
         */
        void onPermissionResult(List denyPermissions, List doNotAskPermissions);
    }

    private FragmentActivity getActivity(Object object) {
        if (object instanceof Fragment) {
            return ((Fragment) object).getActivity();
        } else if (object instanceof AppCompatActivity) {
            return (AppCompatActivity) object;
        }
        return null;
    }


    /**
     * Activity的单个权限申请
     *
     * @param permission
     */
    public void requestPermissions(String permission, ResultCallBack resultCallBack) {
        FragmentActivity activity = getActivity(object);
        if (activity != null) {
            activity.registerForActivityResult(new ActivityResultContracts.RequestPermission(), new ActivityResultCallback() {

                @Override
                public void onActivityResult(Boolean result) {
                    if (result) {
                        resultCallBack.onGrandPermission();
                    } else {
                        if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
                            List doNotAskPermissions = new ArrayList<>();
                            doNotAskPermissions.add(permission);
                            resultCallBack.onPermissionResult(null, Collections.unmodifiableList(doNotAskPermissions));
                        } else {
                            resultCallBack.onDenyPermission();
                        }
                    }
                }
            }).launch(permission);
        }
    }


    /**
     * Activity的集合权限的权限申请
     *
     * @param permissions
     */
    public void requestPermissions(String[] permissions, ResultCallBack resultCallBack) {
        FragmentActivity activity = getActivity(object);
        if (activity != null) {
            activity.registerForActivityResult(new ActivityResultContracts.RequestMultiplePermissions(), new ActivityResultCallback>() {
                @Override
                public void onActivityResult(Map result) {
                    Iterator> iterator = result.entrySet().iterator();
                    List grandPermission = new ArrayList<>();
                    List doNotAskPermissions = new ArrayList<>();
                    List denyPermission = new ArrayList<>();
                    while (iterator.hasNext()) {
                        Map.Entry entry = iterator.next();
                        if (entry.getValue()) {
                            grandPermission.add(entry.getKey());
                        } else {
                            if (ActivityCompat.shouldShowRequestPermissionRationale(activity, entry.getKey())) {
                                doNotAskPermissions.add(entry.getKey());
                            } else {
                                denyPermission.add(entry.getKey());
                            }
                        }
                    }
                    if (denyPermission.isEmpty() && doNotAskPermissions.isEmpty()) {//全部同意
                        resultCallBack.onGrandPermission();
                    } else {
                        if (doNotAskPermissions.size() > 0) {
                            resultCallBack.onPermissionResult(denyPermission, doNotAskPermissions);
                        } else {//全部拒绝
                            resultCallBack.onDenyPermission();
                        }
                    }
                }
            }).launch(permissions);
        }
    }

    /**
     * 是否可以申请权限
     *
     * @return
     */
    private boolean isOverMarshmallow() {
        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
    }

    /**
     * 检测权限
     *
     * @param permission true：已授权； false：未授权
     * @return
     */
    private boolean isPermissionGranted(Context context, @NonNull String permission) {
        return ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED;
    }
}