permList = new ArrayList<>(permissions.length);
421 | for (String perm : permissions) {
422 | if (!mPermissions.contains(perm)) {
423 | if (action != null) {
424 | action.onResult(perm, Permissions.NOT_FOUND);
425 | }
426 | } else if (PermissionChecker.checkSelfPermission(activity, perm) != PackageManager.PERMISSION_GRANTED) {
427 | if (ActivityCompat.shouldShowRequestPermissionRationale(activity, perm)) {
428 | if (action != null) {
429 | action.onResult(perm, Permissions.USER_DENIED_FOREVER);
430 | }
431 | } else if (!mPendingRequests.contains(perm)) {
432 | permList.add(perm);
433 | }
434 | } else {
435 | if (action != null) {
436 | action.onResult(perm, Permissions.GRANTED);
437 | }
438 | }
439 | }
440 | return permList;
441 | }
442 |
443 | /**
444 | * Set Log status
445 | *
446 | * @param enableLog Log status value
447 | */
448 | public void setEnableLog(boolean enableLog) {
449 | this.enableLog = enableLog;
450 | }
451 |
452 | /**
453 | * return Log status
454 | *
455 | * @return Log status
456 | */
457 | public boolean isEnableLog() {
458 | return enableLog;
459 | }
460 | }
--------------------------------------------------------------------------------
/simplepermission/src/main/java/com/ykbjson/lib/simplepermission/PermissionsRequestCallback.java:
--------------------------------------------------------------------------------
1 | package com.ykbjson.lib.simplepermission;
2 |
3 | /**
4 | * Description：权限申请结果回调
5 | * Creator：yankebin
6 | * CreatedAt：2018/11/1
7 | */
8 | public interface PermissionsRequestCallback {
9 | /**
10 | * This method is called when a permission that have been
11 | * requested have been granted by the user. In this method
12 | * you should put your permission(s) sensitive code that can
13 | * only be executed with the required permissions.
14 | */
15 | void onGranted(int requestCode, String permission);
16 |
17 | /**
18 | * This method is called when a permission has been denied by
19 | * the user. It provides you with the permission that was denied
20 | * and will be executed on the Looper you pass to the constructor
21 | * of this class, or the Looper that this object was created on.
22 | *
23 | * @param permission the permission that was denied.
24 | */
25 | void onDenied(int requestCode, String permission);
26 |
27 | /**
28 | * This method is called when a permission has been denied by
29 | * the user forever. It provides you with the permission that was denied
30 | * and will be executed on the Looper you pass to the constructor
31 | * of this class, or the Looper that this object was created on.
32 | *
33 | * @param permission the permission that was denied.
34 | */
35 | void onDeniedForever(int requestCode, String permission);
36 |
37 | /**
38 | * This method is called when all permissions has been check complete
39 | * but some permissions denied.
40 | *
41 | * @param deniedPermissions those denied permissions
42 | */
43 | void onFailure(int requestCode, String[] deniedPermissions);
44 |
45 | /**
46 | * This method is called when all permissions has been check complete
47 | * and all permissions granted.
48 | */
49 | void onSuccess(int requestCode);
50 | }
51 |
--------------------------------------------------------------------------------
/simplepermission/src/main/java/com/ykbjson/lib/simplepermission/PermissionsResultAction.java:
--------------------------------------------------------------------------------
1 |
2 | package com.ykbjson.lib.simplepermission;
3 |
4 | import android.content.pm.PackageManager;
5 | import android.os.Looper;
6 | import android.support.annotation.CallSuper;
7 | import android.support.annotation.NonNull;
8 | import android.support.annotation.Nullable;
9 | import android.util.Log;
10 |
11 | import java.util.Collections;
12 | import java.util.HashSet;
13 | import java.util.Set;
14 |
15 | import io.reactivex.Scheduler;
16 | import io.reactivex.android.schedulers.AndroidSchedulers;
17 |
18 | /**
19 | * Desription：This abstract class should be used to create an if/else action that the PermissionsManager
20 | * can execute when the permissions you request are granted or denied. Simple use involves
21 | * creating an anonymous instance of it and passing that instance to the
22 | * requestPermissionsIfNecessaryForResult method. The result will be sent back to you as
23 | * either onGranted (all permissions have been granted), or onDenied (a required permission
24 | * has been denied). Ideally you put your functionality in the onGranted method and notify
25 | * the user what won't work in the onDenied method.
26 | * Creator：yankebin
27 | * CreatedAt：2018/11/7
28 | */
29 | public class PermissionsResultAction {
30 | private final String TAG = getClass().getName();
31 |
32 | private Looper mLooper = Looper.getMainLooper();
33 | private final Set mPermissions = new HashSet<>(1);
34 | private final Set mDeniedPermissions = new HashSet<>(1);
35 |
36 | private final PermissionsRequestCallback mPermissionsRequestCallback;
37 | private final int mRequestCode;
38 |
39 | /**
40 | * Default Constructor
41 | */
42 | public PermissionsResultAction(int requestCode, @Nullable PermissionsRequestCallback permissionsRequestCallback) {
43 | mRequestCode = requestCode;
44 | mPermissionsRequestCallback = permissionsRequestCallback;
45 | }
46 |
47 | /**
48 | * Alternate Constructor. Pass the looper you wish the PermissionsResultAction
49 | * callbacks to be executed on if it is not the current Looper. For instance,
50 | * if you are making a permissions request from a background thread but wish the
51 | * callback to be on the UI thread, use this constructor to specify the UI Looper.
52 | *
53 | * @param looper the looper that the callbacks will be called using.
54 | */
55 | public PermissionsResultAction(int requestCode, @Nullable PermissionsRequestCallback permissionsRequestCallback, @NonNull Looper looper) {
56 | this(requestCode, permissionsRequestCallback);
57 | mLooper = looper;
58 | }
59 |
60 | /**
61 | * This method is called when a permission that have been
62 | * requested have been granted by the user. In this method
63 | * you should put your permission(s) sensitive code that can
64 | * only be executed with the required permissions.
65 | */
66 | public void onGranted(String permission) {
67 | if (null != mPermissionsRequestCallback) {
68 | mPermissionsRequestCallback.onGranted(mRequestCode, permission);
69 | }
70 | }
71 |
72 | /**
73 | * This method is called when a permission has been denied by
74 | * the user. It provides you with the permission that was denied
75 | * and will be executed on the Looper you pass to the constructor
76 | * of this class, or the Looper that this object was created on.
77 | *
78 | * @param permission the permission that was denied.
79 | */
80 | public void onDenied(String permission) {
81 | if (null != mPermissionsRequestCallback) {
82 | mPermissionsRequestCallback.onDenied(mRequestCode, permission);
83 | }
84 | }
85 |
86 | /**
87 | * This method is called when a permission has been denied by
88 | * the user forever. It provides you with the permission that was denied
89 | * and will be executed on the Looper you pass to the constructor
90 | * of this class, or the Looper that this object was created on.
91 | *
92 | * @param permission the permission that was denied.
93 | */
94 | public void onDeniedForever(String permission) {
95 | if (null != mPermissionsRequestCallback) {
96 | mPermissionsRequestCallback.onDeniedForever(mRequestCode, permission);
97 | }
98 | }
99 |
100 | /**
101 | * This method is called when all permissions has been check complete
102 | * but some permissions denied.
103 | *
104 | * @param deniedPermissions those denied permissions
105 | */
106 | public void onFailure(String[] deniedPermissions) {
107 | if (null != mPermissionsRequestCallback) {
108 | mPermissionsRequestCallback.onFailure(mRequestCode, deniedPermissions);
109 | }
110 | }
111 |
112 | /**
113 | * This method is called when all permissions has been check complete
114 | * and all permissions granted.
115 | */
116 | public void onSuccess() {
117 | if (null != mPermissionsRequestCallback) {
118 | mPermissionsRequestCallback.onSuccess(mRequestCode);
119 | }
120 | }
121 |
122 | /**
123 | * This method is used to determine if a permission not
124 | * being present on the current Android platform should
125 | * affect whether the PermissionsResultAction should continue
126 | * listening for events. By default, it returns true and will
127 | * simply ignore the permission that did not exist. Usually this will
128 | * work fine since most new permissions are introduced to
129 | * restrict what was previously allowed without permission.
130 | * If that is not the case for your particular permission you
131 | * request, override this method and return false to result in the
132 | * Action being denied.
133 | *
134 | * @param permission the permission that doesn't exist on this
135 | * Android version
136 | * @return return true if the PermissionsResultAction should
137 | * ignore the lack of the permission and proceed with exection
138 | * or false if the PermissionsResultAction should treat the
139 | * absence of the permission on the API level as a denial.
140 | */
141 | public synchronized boolean shouldIgnorePermissionNotFound(String permission) {
142 | if (PermissionsManager.getInstance().isEnableLog()) {
143 | Log.d(TAG, "Permission not found: " + permission);
144 | }
145 | return true;
146 | }
147 |
148 |
149 | @CallSuper
150 | protected synchronized final boolean onResult(final @NonNull String permission, int result) {
151 | if (result == PackageManager.PERMISSION_GRANTED) {
152 | return onResult(permission, Permissions.GRANTED);
153 | } else {
154 | return onResult(permission, Permissions.DENIED);
155 | }
156 | }
157 |
158 | /**
159 | * This method is called when a particular permission has changed.
160 | * This method will be called for all permissions, so this method determines
161 | * if the permission affects the state or not and whether it can proceed with
162 | * calling onGranted or if onDenied should be called.
163 | *
164 | * @param permission the permission that changed.
165 | * @param result the result for that permission.
166 | * @return this method returns true if its primary action has been completed
167 | * and it should be removed from the data structure holding a reference to it.
168 | */
169 | @CallSuper
170 | protected synchronized final boolean onResult(final @NonNull String permission, Permissions result) {
171 | mPermissions.remove(permission);
172 | boolean onResult = false;
173 | if (result == Permissions.GRANTED) {
174 | getSchedule().scheduleDirect(new Runnable() {
175 | @Override
176 | public void run() {
177 | PermissionsResultAction.this.onGranted(permission);
178 | }
179 | });
180 | } else if (result == Permissions.DENIED) {
181 | getSchedule().scheduleDirect(new Runnable() {
182 | @Override
183 | public void run() {
184 | PermissionsResultAction.this.onDenied(permission);
185 | }
186 | });
187 | } else if (result == Permissions.NOT_FOUND) {
188 | if (shouldIgnorePermissionNotFound(permission)) {
189 | getSchedule().scheduleDirect(new Runnable() {
190 | @Override
191 | public void run() {
192 | PermissionsResultAction.this.onGranted(permission);
193 | }
194 | });
195 | } else {
196 | getSchedule().scheduleDirect(new Runnable() {
197 | @Override
198 | public void run() {
199 | PermissionsResultAction.this.onDenied(permission);
200 | }
201 | });
202 | }
203 | } else if (result == Permissions.USER_DENIED_FOREVER) {
204 | getSchedule().scheduleDirect(new Runnable() {
205 | @Override
206 | public void run() {
207 | PermissionsResultAction.this.onDeniedForever(permission);
208 | }
209 | });
210 | }
211 |
212 | //标记不被通过的权限
213 | if (result == Permissions.DENIED || (result == Permissions.NOT_FOUND && !shouldIgnorePermissionNotFound(permission))) {
214 | mDeniedPermissions.add(permission);
215 | }
216 | if (mPermissions.isEmpty()) {
217 | getSchedule().scheduleDirect(new Runnable() {
218 | @Override
219 | public void run() {
220 | if (mDeniedPermissions.isEmpty()) {
221 | PermissionsResultAction.this.onSuccess();
222 | } else {
223 | final String[] deniedPermissions = (String[]) mDeniedPermissions.toArray(
224 | new String[mDeniedPermissions.size()]);
225 | PermissionsResultAction.this.onFailure(deniedPermissions);
226 | }
227 | //重置不被通过的权限存储
228 | mDeniedPermissions.clear();
229 | }
230 | });
231 | onResult = true;
232 | }
233 | return onResult;
234 | }
235 |
236 | /**
237 | * This method registers the PermissionsResultAction object for the specified permissions
238 | * so that it will know which permissions to look for changes to. The PermissionsResultAction
239 | * will then know to look out for changes to these permissions.
240 | *
241 | * @param perms the permissions to listen for
242 | */
243 | @SuppressWarnings("WeakerAccess")
244 | @CallSuper
245 | protected synchronized final void registerPermissions(@NonNull String[] perms) {
246 | Collections.addAll(mPermissions, perms);
247 | }
248 |
249 | /**
250 | * 获取执行权限回调的线程调度器
251 | *
252 | * @return
253 | */
254 | protected synchronized Scheduler getSchedule() {
255 | return null == mLooper ? AndroidSchedulers.mainThread() : AndroidSchedulers.from(mLooper);
256 | }
257 |
258 | protected int getRequestCode() {
259 | return mRequestCode;
260 | }
261 | }
--------------------------------------------------------------------------------
/simplepermission/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | simplePermission
3 |
4 |
--------------------------------------------------------------------------------
/simplepermission_ano/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 |
--------------------------------------------------------------------------------
/simplepermission_ano/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'java-library'
2 | apply plugin: 'com.novoda.bintray-release'
3 | apply plugin: 'maven'
4 |
5 | //加载资源
6 | Properties properties = new Properties()
7 | InputStream inputStream = project.rootProject.file('local.properties').newDataInputStream();
8 | properties.load(inputStream)
9 |
10 | publish {
11 | bintrayUser = properties.getProperty("bintrayUser")
12 | bintrayKey = properties.getProperty("bintrayKey")
13 | userOrg = 'ykbjson' // bintray注册的用户名
14 | groupId = rootProject.ext.bintray.group
15 | artifactId = 'simplepermission_ano'// bintray创建的package
16 | publishVersion = rootProject.ext.bintray.anoVersion
17 | desc = 'SimplePermission权限申请库注解'
18 | }
19 |
20 | dependencies {
21 | implementation fileTree(dir: 'libs', include: ['*.jar'])
22 | }
23 |
24 | sourceCompatibility = "1.7"
25 | targetCompatibility = "1.7"
26 |
27 |
28 |
29 |
--------------------------------------------------------------------------------
/simplepermission_ano/src/main/java/com/ykbjson/lib/simplepermission/ano/PermissionNotify.java:
--------------------------------------------------------------------------------
1 | package com.ykbjson.lib.simplepermission.ano;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.lang.annotation.Target;
7 |
8 | /**
9 | * Desription：onRequestPermissionsResult方法回调的接收者
10 | * Creator：yankebin
11 | * CreatedAt：2018/10/29
12 | */
13 | @Retention(RetentionPolicy.RUNTIME)
14 | @Target(ElementType.TYPE)
15 | public @interface PermissionNotify {
16 | }
17 |
--------------------------------------------------------------------------------
/simplepermission_ano/src/main/java/com/ykbjson/lib/simplepermission/ano/PermissionRequest.java:
--------------------------------------------------------------------------------
1 | package com.ykbjson.lib.simplepermission.ano;
2 |
3 | import java.lang.annotation.ElementType;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.RetentionPolicy;
6 | import java.lang.annotation.Target;
7 |
8 | /**
9 | * Desription：请求权限的方法注解
10 | * Creator：yankebin
11 | * CreatedAt：2018/10/29
12 | */
13 | @Retention(RetentionPolicy.RUNTIME)
14 | @Target(ElementType.METHOD)
15 | public @interface PermissionRequest {
16 |
17 | /**
18 | * 申请权限的code，在权限回调的时候可以根据code知道哪些权限被授予或拒绝
19 | */
20 | int requestCode() default 0;
21 |
22 | /**
23 | * 要申请的权限数组
24 | */
25 | String[] requestPermissions() default {""};
26 |
27 | /**
28 | * 是否需要在申请成功后再次执行代码逻辑
29 | */
30 | boolean needReCall() default false;
31 | }
32 |
--------------------------------------------------------------------------------