Android 6.0+ 动态权限一种清爽的封装过程

最新推荐文章于 2023-04-09 22:07:48 发布

chw天道酬勤

最新推荐文章于 2023-04-09 22:07:48 发布

阅读量164

点赞数

文章标签： android 6.0 动态权限

本文转自“风一样的男人”的博客，原文地址：Android 6.0+ 动态权限一种清爽的封装过程（以及多个权限的处理）

Android 6.0 之前我们申请权限直接在配置文件中配置一下即可，但是6.0之后，谷歌官方将权限分为普通权限和危险权限。对于危险权限来说，我们就需要进行动态设置了。本文主要讲解为什么要进行Android 6.0 动态权限的设置、动态权限的使用、以及一个页面中需要同时申请多个危险权限的情况。非常感谢郭霖大牛的讲解，把平时不太注意的点都讲得很不错。最后，我们采用相对优雅的方式对其进行封装，方便使用。

因为对于危险权限我们需要动态设置，不然应用会崩溃的，首先我们要清楚哪些是危险权限？看下面这张图
这里写图片描述

值得一说的是：同一组的权限不用重复授权，也就是说，同一组的权限只要有一个授权了，那么同一组的其它权限也都就授权了。

当你的应用中用到上面这些权限时，你就需要动态设置了。首先，你需要像以前一样把用到的权限依旧在配置文件中配置一下，然后，在你需要该权限的地方开撸代码进行动态设置了。下面以打电话为例来加以说明

首先，我们需要保证我们得有一台6.0的手机，targetSdkVersion的版本在23或者以上。其中需要注意一点，当我们的应用是升上来的时候，也就是说之前是23以下，现在我们让targetSdkVersion等于23或者以上时，即使不去动态设置这些危险权限，应用依旧不会崩溃掉，对于这种情况，谷歌会默认将所用到的这些危险权限自动授权。也就是说已经授权了，应用肯定不会崩溃啊。

单个权限的处理

按照上面分析的，我们先来一步步实现。首先我们在配置文件中配置打电话的权限

<uses-permission android:name="android.permission.CALL_PHONE"/>

MainActivity

public class MainActivity extends AppCompatActivity {

    private Button btn;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //初始化控件
        iniViews();
    }

    private void iniViews() {
        btn = (Button) findViewById(R.id.btn_call);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                call();
            }
        });
    }

    private void call(){
        try {
            Intent intent = new Intent(Intent.ACTION_CALL);
            Uri uri = Uri.parse("tel:" + "10086");
            intent.setData(uri);
            startActivity(intent);
        }catch (SecurityException e){
            e.printStackTrace();
        }
    }
}

点击打电话，尴尬的情况发生了…

这里写图片描述

接下来就是去动态设置了，在文章最开始展示的那张危险权限表中可以知道，打电话属于危险权限。所以，我们在打电话时，先要判断用户是否授权了打电话功能，如果授权了，则继续打电话的逻辑，用户如果没有授权，会弹出一个对话框。用户可以根据对话框上面提示的同意 / 拒绝来设置权限，用户的这一操作我们可以通过回调在onRequestPermissionsResult()方法中获悉。为了达到向下兼容，我们使用v4兼容库下面的ContextCompat以及ActivityCompat。这样就可以兼容了，我们就不用代码判断版本了。

我们再来看看修改之后的代码

public class MainActivity extends AppCompatActivity {

    private Button btn;
    private static final int PERMISSION_REQUESTCODE = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //初始化控件
        iniViews();
    }

    private void iniViews() {
        btn = (Button) findViewById(R.id.btn_call);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                permission();
            }
        });
    }

    private void permission(){
        if(ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED){
            //没有授权
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CALL_PHONE}, PERMISSION_REQUESTCODE);
        }else{
            //已经授权
            call();
        }
    }

    public void call(){
        try {
            Intent intent = new Intent(Intent.ACTION_CALL);
            Uri uri = Uri.parse("tel:" + "10086");
            intent.setData(uri);
            startActivity(intent);
        }catch (SecurityException e){
            e.printStackTrace();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode){
            case PERMISSION_REQUESTCODE:
                if(grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED){
                    //用户点击了同意授权
                    call();
                }else{
                    //用户拒绝了授权
                    Toast.makeText(this,"权限被拒绝",Toast.LENGTH_SHORT).show();
                }
                break;
            default:
                break;
        }
    }
}

代码比较简单，再来看看效果图

这里写图片描述

细心的你肯定会发现，当我们首次选择了拒绝后，再次点击打电话会出现不再询问选项，如果勾选了此选项，再点击拒绝的话，那么当我们再次执行打电话时，就不会再出现提示的弹窗了。显然这样对用户来说体验并不是很友好，你可以在用户点击拒绝后进行弹窗引导用户去设置中打开此权限等。具体的需求具体对待。这里我们稍微修改下代码，实现刚才所说的效果

private void permission(){
        if(ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED){
            if(ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CALL_PHONE)){
                //当拒绝了授权后，为提升用户体验，可以以弹窗的方式引导用户到设置中去进行设置
                new AlertDialog.Builder(MainActivity.this)
                        .setMessage("需要开启权限才能使用此功能")
                        .setPositiveButton("设置", new DialogInterface.OnClickListener() {
                            @Override
                            public void onClick(DialogInterface dialog, int which) {
                                //引导用户到设置中去进行设置
                                Intent intent = new Intent();
                                intent.setAction("android.settings.APPLICATION_DETAILS_SETTINGS");
                                intent.setData(Uri.fromParts("package", getPackageName(), null));
                                startActivity(intent);

                            }
                        })
                        .setNegativeButton("取消", null)
                        .create()
                        .show();
            }else{
                //没有授权
                ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CALL_PHONE}, PERMISSION_REQUESTCODE);
            }
        }else{
            //已经授权
            call();
        }
    }

效果图

这里写图片描述

接下来我们来处理多个权限的情况

多个权限的处理

比较优雅的写法是，我们创建一个List集合，用于存放用户没有授权的权限。当我们拒绝其中的某一个权限时，再次点击申请时，弹出的对话框中只会出现被用户拒绝的权限申请，用户已经授权过的则不再显示。看下代码

public class MainActivity extends AppCompatActivity {

    private Button btn;
    private static final int PERMISSION_REQUESTCODE = 1;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //初始化控件
        iniViews();
    }

    private void iniViews() {
        btn = (Button) findViewById(R.id.btn_call);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                permission();
            }
        });
    }

    private void permission(){
        List<String> permissionLists = new ArrayList<>();
        if(ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED){
            permissionLists.add(Manifest.permission.CALL_PHONE);
        }
        if(ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED){
            permissionLists.add(Manifest.permission.CAMERA);
        }

        if(!permissionLists.isEmpty()){//说明肯定有拒绝的权限
            ActivityCompat.requestPermissions(this, permissionLists.toArray(new String[permissionLists.size()]), PERMISSION_REQUESTCODE);
        }else{
            Toast.makeText(this, "权限都授权了，可以搞事情了", Toast.LENGTH_SHORT).show();
        }
    }

    public void call(){
        try {
            Intent intent = new Intent(Intent.ACTION_CALL);
            Uri uri = Uri.parse("tel:" + "10086");
            intent.setData(uri);
            startActivity(intent);
        }catch (SecurityException e){
            e.printStackTrace();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode){
            case PERMISSION_REQUESTCODE:
                if(grantResults.length > 0){
                    for(int grantResult : grantResults){
                        if(grantResult != PackageManager.PERMISSION_GRANTED){
                            Toast.makeText(this, "某一个权限被拒绝了", Toast.LENGTH_SHORT).show();
                            return;
                        }
                    }
                    //其他逻辑(这里当权限都同意的话就执行打电话逻辑)
                    call();
                }
                break;
            default:
                break;
        }
    }
}

来张效果图

这里写图片描述

接下来，我们开始对其进行封装处理

对权限进行封装，让使用变得更加简洁

假如，我们有好几个页面都需要动态申请权限，那么我们岂不是要每个页面都写这些类似的代码。显然，我们可以将这些相似代码抽出来封装到我们的BaseActivity中。这样，使用起来就清爽多了

下面直接给出BaseActivity中的代码

/**
 * 封装动态权限
 */
public class BaseActivity extends AppCompatActivity{

    private PermissionListener mListener;
    private static final int PERMISSION_REQUESTCODE = 100;

    @Override
    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);

    }

    public void requestRunPermisssion(String[] permissions, PermissionListener listener){
        mListener = listener;
        List<String> permissionLists = new ArrayList<>();
        for(String permission : permissions){
            if(ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED){
                permissionLists.add(permission);
            }
        }

        if(!permissionLists.isEmpty()){
            ActivityCompat.requestPermissions(this, permissionLists.toArray(new String[permissionLists.size()]), PERMISSION_REQUESTCODE);
        }else{
            //表示全都授权了
            mListener.onGranted();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        switch (requestCode){
            case PERMISSION_REQUESTCODE:
                if(grantResults.length > 0){
                    //存放没授权的权限
                    List<String> deniedPermissions = new ArrayList<>();
                    for(int i = 0; i < grantResults.length; i++){
                        int grantResult = grantResults[i];
                        String permission = permissions[i];
                        if(grantResult != PackageManager.PERMISSION_GRANTED){
                            deniedPermissions.add(permission);
                        }
                    }
                    if(deniedPermissions.isEmpty()){
                        //说明都授权了
                        mListener.onGranted();
                    }else{
                        mListener.onDenied(deniedPermissions);
                    }
                }
                break;
            default:
                break;
        }
    }
}

我们定义的处理已授权、以及未授权的回调接口

/**
 * 已授权、未授权的接口回调
 */
public interface PermissionListener {

    void onGranted();//已授权

    void onDenied(List<String> deniedPermission);//未授权

}

再看看我们的MainActivity是如何调用的。只需要继承我们的BaseActivity即可

public class MainActivity extends BaseActivity {

    private Button btn;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //初始化控件
        iniViews();
    }

    private void iniViews() {
        btn = (Button) findViewById(R.id.btn_call);
        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                permission();
            }
        });
    }

    private void permission(){
        requestRunPermisssion(new String[]{Manifest.permission.CALL_PHONE, Manifest.permission.CAMERA}, new PermissionListener() {
            @Override
            public void onGranted() {
                //表示所有权限都授权了
                Toast.makeText(MainActivity.this, "所有权限都授权了，可以搞事情了", Toast.LENGTH_SHORT).show();
                //我们可以执行打电话的逻辑
                call();
            }

            @Override
            public void onDenied(List<String> deniedPermission) {
                for(String permission : deniedPermission){
                    Toast.makeText(MainActivity.this, "被拒绝的权限：" + permission, Toast.LENGTH_SHORT).show();
                }
            }
        });
    }

    public void call(){
        try {
            Intent intent = new Intent(Intent.ACTION_CALL);
            Uri uri = Uri.parse("tel:" + "10086");
            intent.setData(uri);
            startActivity(intent);
        }catch (SecurityException e){
            e.printStackTrace();
        }
    }

}

最后再来张效果图

这里写图片描述

上面的封装是针对Activity页面的，如果我们想在其他类中也是用此权限封装的方法，我们可以这么干，修改BaseActivity中的代码

public class BaseActivity extends AppCompatActivity{

    private static PermissionListener mListener;
    private static final int PERMISSION_REQUESTCODE = 100;

    @Override
    public void onCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
        super.onCreate(savedInstanceState, persistentState);

        ActivityUtil.addActivity(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        ActivityUtil.removeActivity(this);
    }

    public static void requestRunPermisssion(String[] permissions, PermissionListener listener){
        Activity topActivity = ActivityUtil.getTopActivity();
        if(topActivity == null){
            return;
        }
        mListener = listener;
        List<String> permissionLists = new ArrayList<>();
        for(String permission : permissions){
            if(ContextCompat.checkSelfPermission(topActivity, permission) != PackageManager.PERMISSION_GRANTED){
                permissionLists.add(permission);
            }
        }

        if(!permissionLists.isEmpty()){
            ActivityCompat.requestPermissions(topActivity, permissionLists.toArray(new String[permissionLists.size()]), PERMISSION_REQUESTCODE);
        }else{
            //表示全都授权了
            mListener.onGranted();
        }
    }

Activity的管理工具类

/**
 * 管理Activity的工具类
 */
public class ActivityUtil {

    private static List<Activity> activityList = new ArrayList<>();

    public static void addActivity(Activity activity){
        activityList.add(activity);
    }

    public static void removeActivity(Activity activity){
        activityList.remove(activity);
    }

    public static Activity getTopActivity(){
        if(activityList.isEmpty()){
            return null;
        }else{
            return activityList.get(activityList.size() - 1);
        }
    }
}

在其他类中调用的话直接通过BaseActivity.requestRunPermisssion()即可。然而这种方式下，如果activity被意外销毁了，就会导致内存溢出等问题。如果想避免这种问题，我们可以使用上面的介绍，只在activity页面中使用即可。如果既想能在其他类中使用，又想尽量没有别的错误，我们可以到github上找一些写的不错的第三方框架。用起来也十分方便

最后非常感谢郭霖大神，郭大牛还推荐了一个比较不错的管理权限的第三方框架RxPermissions，另外还有PermissionsDispatcher

chw天道酬勤

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Android 6.0+ 动态权限一种清爽的封装过程

本文转自“风一样的男人”的博客，原文地址：Android 6.0+ 动态权限一种清爽的封装过程（以及多个权限的处理）Android 6.0 之前我们申请权限直接在配置文件中配置一下即可，但是6.0之后，谷歌官方将权限分为普通权限和危险权限。对于危险权限来说，我们就需要进行动态设置了。本文主要讲解为什么要进行Android 6.0 动态权限的设置、动态权限的使用、以及一个页面中需要同时申请多个...
复制链接

扫一扫