android运行时权限解决办法（含有申请权限已授权、权限被拒绝、权限勾选不在提示的回调）

最新推荐文章于 2024-03-15 21:25:43 发布

gf771115

最新推荐文章于 2024-03-15 21:25:43 发布

阅读量2.2w

点赞数 5

分类专栏： Android

Android 专栏收录该内容

483 篇文章 4 订阅

订阅专栏

转自：http://blog.csdn.net/u010823943/article/details/54565364

先说明一下：
1、Android运行时权限已经不是新东西了，我始终没在工程中实现。（因为有个方法，就是把targetSdkVersion控制在23 Android 6.0以下，系统为了兼容老客户端还用的以前的权限机制，权限在AndroidManifest申请了就默认同意）
2、这篇文章是我自己要实现这块发现网上的第三方库没有符合我需求的那个点，也许是我没发现，所以仿照RxPermissions原理自己写了一个。或者说从RxPermissions中抽离出关键代码，去掉了Rx语法简单封装了一下，可以回调权限同意、拒绝、勾选不在提示这3个用户操作以及操作了哪些权限（在此向RxPermissions作者致敬）。

借鉴工程：RxPermissions

大家先看看这个库，如果能够满足你的需求，就不用再费时间看后面的文字了。

RxPermissions（点击跳转github工程）

下面开始：

项目截图

代码共3个类
1、PermissionFragment

import android.annotation.TargetApi;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.Fragment;
import android.support.v4.content.ContextCompat;

import java.util.ArrayList;
import java.util.List;

public class PermissionFragment extends Fragment {
    /**
     * 申请权限的requestCode
     */
    private static final int PERMISSIONS_REQUEST_CODE = 1;

    /**
     * 权限监听接口
     */
    private PermissionListener listener;
    public void setListener(PermissionListener listener) {
        this.listener = listener;
    }

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);
    }

    /**
     * 申请权限
     * @param permissions 需要申请的权限
     */
    @TargetApi(Build.VERSION_CODES.M)
    public void requestPermissions(@NonNull String[] permissions) {
        List<String> requestPermissionList = new ArrayList<>();
        //找出所有未授权的权限
        for (String permission : permissions) {
            if (ContextCompat.checkSelfPermission(getContext(), permission) != PackageManager.PERMISSION_GRANTED) {
                requestPermissionList.add(permission);
            }
        }
        if (requestPermissionList.isEmpty()) {
            //已经全部授权
            permissionAllGranted();
        } else {
            //申请授权
            requestPermissions(requestPermissionList.toArray(new String[requestPermissionList.size()]), PERMISSIONS_REQUEST_CODE);
        }
    }

    /**
     * fragment回调处理权限的结果
     * @param requestCode 请求码 要等于申请时候的请求码
     * @param permissions 申请的权限
     * @param grantResults 对应权限的处理结果
     */
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode != PERMISSIONS_REQUEST_CODE) {
            return;
        }

        if (grantResults.length > 0) {
            List<String> deniedPermissionList = new ArrayList<>();
            for (int i = 0; i < grantResults.length; i++) {
                if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
                    deniedPermissionList.add(permissions[i]);
                }
            }

            if (deniedPermissionList.isEmpty()) {
                //已经全部授权
                permissionAllGranted();
            } else {

                //勾选了对话框中”Don’t ask again”的选项, 返回false
                for (String deniedPermission : deniedPermissionList) {
                    boolean flag = shouldShowRequestPermissionRationale(deniedPermission);
                    if (!flag) {
                        //拒绝授权
                        permissionShouldShowRationale(deniedPermissionList);
                        return;
                    }
                }
                //拒绝授权
                permissionHasDenied(deniedPermissionList);

            }


        }

    }


    /**
     * 权限全部已经授权
     */
    private void permissionAllGranted() {
        if (listener != null) {
            listener.onGranted();
        }
    }

    /**
     * 有权限被拒绝
     *
     * @param deniedList 被拒绝的权限
     */
    private void permissionHasDenied(List<String> deniedList) {
        if (listener != null) {
            listener.onDenied(deniedList);
        }
    }

    /**
     * 权限被拒绝并且勾选了不在询问
     *
     * @param deniedList 勾选了不在询问的权限
     */
    private void permissionShouldShowRationale(List<String> deniedList) {
        if (listener != null) {
            listener.onShouldShowRationale(deniedList);
        }
    }
}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

2 、PermissionListener

import java.util.List;

public interface PermissionListener {
    void onGranted();

    void onDenied(List<String> deniedPermission);

    void onShouldShowRationale(List<String> deniedPermission);
}

 
 1
2
3
4
5
6
7
8
9
10
 
 1
2
3
4
5
6
7
8
9
10

3、PermissionUtil

import android.support.annotation.NonNull;
import android.support.v4.app.FragmentActivity;
import android.support.v4.app.FragmentManager;

public class PermissionUtil {

    private static final String TAG = "PermissionsUtil";

    private PermissionFragment fragment;

    public PermissionUtil(@NonNull FragmentActivity activity) {
        fragment = getPermissionsFragment(activity);
    }

    private PermissionFragment getPermissionsFragment(FragmentActivity activity) {
        PermissionFragment fragment = (PermissionFragment) activity.getSupportFragmentManager().findFragmentByTag(TAG);
        boolean isNewInstance = fragment == null;
        if (isNewInstance) {
            fragment = new PermissionFragment();
            FragmentManager fragmentManager = activity.getSupportFragmentManager();
            fragmentManager
                    .beginTransaction()
                    .add(fragment, TAG)
                    .commit();
            fragmentManager.executePendingTransactions();
        }

        return fragment;
    }

    /**
     * 外部调用申请权限
     * @param permissions 申请的权限
     * @param listener 监听权限接口
     */
    public void requestPermissions(String[] permissions, PermissionListener listener) {
        fragment.setListener(listener);
        fragment.requestPermissions(permissions);

    }

}

 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

用法

        //创建PermissionUtil对象，参数为继承自V4包的 FragmentActivity
        PermissionUtil permissionUtil = new PermissionUtil(MainActivity.this);
        //调用requestPermissions
        permissionUtil.requestPermissions(new String[]{Manifest.permission.CAMERA, Manifest.permission.CALL_PHONE},
                new PermissionListener() {
                    @Override
                    public void onGranted() {
                        //所有权限都已经授权
                        Toast.makeText(MainActivity.this, "所有权限都已授权", Toast.LENGTH_SHORT).show();
                    }

                    @Override
                    public void onDenied(List<String> deniedPermission) {
                        //Toast第一个被拒绝的权限
                        Toast.makeText(MainActivity.this, "拒绝了权限" + deniedPermission.get(0), Toast.LENGTH_LONG).show();

                    }

                    @Override
                    public void onShouldShowRationale(List<String> deniedPermission) {
                        //Toast第一个勾选不在提示的权限
                        Toast.makeText(MainActivity.this, "这个权限" + deniedPermission.get(0)+"勾选了不在提示，要像用户解释为什么需要这权限", Toast.LENGTH_LONG).show();
                    }
                });
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

工程地址:

工程GitHub链接地址

注：
0、大家一定要注意先在AndroidManifest.xml中像以前一样添加好要申请的权限、不然会报错，而且并不是所有的权限都需要去申请授权、只有android认为危险的权限需要这样申请，大家查一下就知道，这里不再敖述。

1、工程中的permissionUtil是个module，可以直接引module到自己的工程使用，也可以在这个module中找到一个classes.jar导入到自己工程直接使用（可以改个名字如permissionUtil.jar），具体路径是permissionUtil/build/intermediates/bundles/release/classes.jar
permissionUtil.jar下载地址

2、创建PermissionUtil对象，参数为继承自v4包的 FragmentActivity，RxPermissions的参数是android原生的FragmentActivity，这是我没使用RxPermissions的一个原因，有人可能使用 v7包中的AppCompatActivity，直接用没问题，因为AppCompatActivity也是v4包FragmentActivity的子类，大家可以自己看下。

3、被拒绝或勾选了不再提示的回调方法中，参数是对应操作的权限List, onDenied(List deniedPermission) 参数是所有被拒绝授权的权限，onShouldShowRationale(List deniedPermission)参数是所有被勾选了不再提示的的权限,而RxPermissions没有回调这些权限，这是我没使用RxPermissions的另一原因。（也许是我不认真，没找到）

实现原理

很简单，我们知道v4包中的FragmentActivity 实现了有关权限申请授权的接口

public class FragmentActivity extends BaseFragmentActivityJB implements
        ActivityCompat.OnRequestPermissionsResultCallback,
        ActivityCompatApi23.RequestPermissionsRequestCodeValidator {

//代码省略

    /**
     * Called by Fragment.requestPermissions() to implement its behavior.
     */
    void requestPermissionsFromFragment(Fragment fragment, String[] permissions,
            int requestCode) {
        if (requestCode == -1) {
            ActivityCompat.requestPermissions(this, permissions, requestCode);
            return;
        }
        checkForValidRequestCode(requestCode);
        try {
            mRequestedPermissionsFromFragment = true;
            int requestIndex = allocateRequestIndex(fragment);
            ActivityCompat.requestPermissions(this, permissions,
                    ((requestIndex + 1) << 16) + (requestCode & 0xffff));
        } finally {
            mRequestedPermissionsFromFragment = false;
        }
    }

 @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
            @NonNull int[] grantResults) {
        int index = (requestCode >> 16) & 0xffff;
        if (index != 0) {
            index--;

            String who = mPendingFragmentActivityResults.get(index);
            mPendingFragmentActivityResults.remove(index);
            if (who == null) {
                Log.w(TAG, "Activity result delivered for unknown Fragment.");
                return;
            }
            Fragment frag = mFragments.findFragmentByWho(who);
            if (frag == null) {
                Log.w(TAG, "Activity result no fragment exists for who: " + who);
            } else {
                frag.onRequestPermissionsResult(requestCode & 0xffff, permissions, grantResults);
            }
        }
    }


//代码省略


}
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

大家注意这句话”Called by Fragment.requestPermissions() to implement its behavior.”简单翻译为：调用Fragment.requestPermissions()方法来实现它的行为。说明了Fragment中也存在权限相关的函数：

 //申请权限
 public final void requestPermissions(@NonNull String[] permissions, int requestCode) {
        if (mHost == null) {
            throw new IllegalStateException("Fragment " + this + " not attached to Activity");
        }
        mHost.onRequestPermissionsFromFragment(this, permissions, requestCode);
    }

//回调权限申请结果
 public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
            @NonNull int[] grantResults) {
        /* callback - do nothing */
    }
 
 1
2
3
4
5
6
7
8
9
10
11
12
13
 
 1
2
3
4
5
6
7
8
9
10
11
12
13

这里就不在深入讨论requestPermissions方法调用的mHost.onRequestPermissionsFromFragment(this, permissions, requestCode); 大家已经猜到了吧，原理就是在FragmentActivity中可以添加不占位置的Fragment，利用Fragment中的requestPermissions方法去申请权限授权，利用Fragment中的onRequestPermissionsResult方法来获取授权结果。这两个方法参数在上面已经标注。不在啰嗦了。

转载注明来源 http://blog.csdn.net/u010823943/article/details/54565364，谢谢

最后希望对大家有所用。

gf771115

关注

5
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
android运行时权限解决办法（含有申请权限已授权、权限被拒绝、权限勾选不在提示的回调）

转自：http://blog.csdn.net/u010823943/article/details/54565364先说明一下： 1、Android运行时权限已经不是新东西了，我始终没在工程中实现。（因为有个方法，就是把targetSdkVersion控制在23 Android 6.0以下，系统为了兼容老客户端还用的以前的权限机制，权限在AndroidManifest申请了就
复制链接

扫一扫