对Android权限请求的封装，打造简洁好用的requestPermissions

最新推荐文章于 2024-06-18 13:12:47 发布

AntichristM

最新推荐文章于 2024-06-18 13:12:47 发布

阅读量797

点赞数 3

分类专栏： Android 文章标签： android

本文链接：https://blog.csdn.net/u012375207/article/details/72625165

版权

Android 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

示例（种草）

首先我认为看这篇文章的人都应该是会用官方的请求方式的，那么就请先看以下代码，如果觉得有兴趣，再继续往下看：

重写onRequestPermissionsResult

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        //直接把上面三个参数写进来就行了
        AntiPermissionUtils.getInstance().handlePermission( requestCode, permissions, grantResults );
        super.onRequestPermissionsResult( requestCode, permissions, grantResults );
    }

请求一个权限

AntiPermissionUtils.getInstance().requestPermission( this,
                new AntiPermission( Manifest.permission.SEND_SMS, new AntiPermissionListener() {
                    @Override
                    public void success() {
                        //允许
                    }

                    @Override
                    public void failed() {
                        //不允许
                    }

                    @Override
                    public void refuse() {
                        //不再提示
                    }
                } ));

请求两个、三个、N个权限

AntiPermissionUtils.getInstance().requestPermission( this,
                new AntiPermission( Manifest.permission.SEND_SMS, new AntiPermissionListener() {
                    @Override
                    public void success() {
                        //允许
                    }

                    @Override
                    public void failed() {
                        //不允许
                    }

                    @Override
                    public void refuse() {
                        //不再提示
                    }
                } )
                ,new AntiPermission( Manifest.permission.CAMERA, new AntiPermissionListener() {
                    @Override
                    public void success() {
                        //允许
                    }

                    @Override
                    public void failed() {
                        //不允许
                    }

                    @Override
                    public void refuse() {
                        //不再提示
                    }
                } )
                ,new AntiPermission( Manifest.permission.CALL_PHONE, new AntiPermissionListener() {
                    @Override
                    public void success() {
                        //允许
                    }

                    @Override
                    public void failed() {
                        //不允许
                    }

                    @Override
                    public void refuse() {
                        //不再提示
                    }
                } ));

如果觉得这样写的方式还比较简洁好用的话，那么就继续往下看咯。

分析

首先列出权限请求存在的多种情况：

Build.VERSION.SDK_INT < 23
已经授权
未授权
不再提示授权

应该做什么操作

在Build.VERSION.SDK_INT < 23的时候是不用判断权限的
在已经授权这里需要用ContextCompat.checkSelfPermission(Context context, String permission)这个方法来判断的，在判断成功之后不再进行下一步
在上一步判断未授权之后调用请求授权的方法ActivityCompat.requestPermissions(Activity activity, String[] permissions, int requestCode)来请求授权
在onRequestPermissionsResult中判断是否授权和是否不再提示

进行封装

上面说到的那么多东西里面只有activity和permission是都有的，requestCode可以通过permission的hashcode来生成一个。然后还需要做回调，那么还需要一个interface来封装三个回调的操作。

实践

interface

public interface AntiPermissionListener {
    /**
     * 成功
     */
    void success();

    /**
     * 失败
     */
    void failed();

    /**
     * 用户选择了不再提示
     */
    void refuse();
}

JavaBean

需要把permission和interface一一对应的保存起来

public class AntiPermission {
    public AntiPermission(String permissionName, AntiPermissionListener listener) {
        this.permissionName = permissionName;
        this.listener = listener;
    }

    String permissionName;
    AntiPermissionListener listener;
}

工具类

public class AntiPermissionUtils {

    private Map<Integer, Map<String, AntiPermissionListener>> map = new HashMap<>();

    private Map<Integer, Activity> activitys = new HashMap<>();

    private static AntiPermissionUtils instance;

    private AntiPermissionUtils() {
    }

    public static AntiPermissionUtils getInstance() {
        if (instance == null) {
            synchronized (AntiPermission.class) {
                if (instance == null) {
                    instance = new AntiPermissionUtils();
                }
            }
        }
        return instance;
    }

    public void requestPermission(Activity activity, AntiPermission... antiPermissions) {
        if (Build.VERSION.SDK_INT < 23) {
            for (AntiPermission antiPermission : antiPermissions) {
                antiPermission.listener.success();
            }
            return;
        }
        Map<String, AntiPermissionListener> sa = new HashMap<>();
        for (AntiPermission antiPermission : antiPermissions) {
            if (ContextCompat.checkSelfPermission(activity, antiPermission.permissionName) != PackageManager.PERMISSION_GRANTED) {
                sa.put(antiPermission.permissionName, antiPermission.listener);
            } else {
                antiPermission.listener.success();
            }
        }
        if (sa.size() == 0) {
            return;
        }
        int code = activitys.hashCode();
        code = code % 1000 + code / 100000;
        activitys.put(code, activity);
        map.put(code, sa);

        String[] permissionNames = new String[sa.size()];
        Iterator iterator = sa.keySet().iterator();
        int index = 0;
        while (iterator.hasNext() && index < permissionNames.length) {
            permissionNames[index] = (String) iterator.next();
            index++;
        }
        ActivityCompat.requestPermissions(activity, permissionNames,
                code);
    }

    public void handlePermission(int requestCode, String[] permissions, int[] grantResults) {
        if (permissions == null || grantResults == null || permissions.length == 0 || grantResults.length == 0) {
            AntiLog.e(AntiPermissionUtils.class.getSimpleName(), "some arguments is null!");
            return;
        }
        if (!map.containsKey(requestCode)) {
            AntiLog.e(AntiPermissionUtils.class.getSimpleName(), "Permission is not registed!");
            return;
        }
        Map<String, AntiPermissionListener> antiPermissions = map.get(requestCode);
        Activity activity = activitys.get(requestCode);
        for (int i = 0; i < permissions.length; i++) {
            boolean isTip = ActivityCompat.shouldShowRequestPermissionRationale(activity, permissions[i]);
            if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                antiPermissions.get(permissions[i]).success();
            } else {
                if (isTip) {
                    antiPermissions.get(permissions[i]).failed();
                } else {
                    antiPermissions.get(permissions[i]).refuse();
                }
            }
        }
        map.remove(antiPermissions);
        activitys.remove(activity);
    }
}

这里操作都比较简单，就是循环之类的，就不写注释了，能够很轻松的看懂的，然后你就能够简单快捷的进行权限请求了，这种一个项目中用几次的东西，不能浪费太多的时间在上面呀。如果你还想更方便的话，可以再看看我这个library：AntiLib，能够更方便快速的让你开发一个APP。
转载请注明出处：http://blog.csdn.net/u012375207/article/details/72625165