LZ-Says：
江湖上流传着这样一首诗：
床前明月光，我会写代码；千山鸟飞绝，我会写代码；
松下问童子，我会写代码；春眠不觉晓，我会写代码；
白日依山尽，我会写代码；红豆生南国，我会写代码；
锄禾日当午，我会写代码；欲穷千里目，我会写代码。
不得不说，开发这一行，是真心不容易，要学习技术，要学习调整心态，要学会和各种无奈心平气和沟通，不容易~
今天突然有点想家了，时间过得真快，就感觉一切好像在昨天，不过回头看，一切不过尔尔~
以前对于Android这边权限真的是一窍不通，偶尔还忘记写这个东西，静下心，真的该好好想想这东西到底是什么情况。
今天写个一个小demo，不出意料。感觉有点无奈。大家一起回顾下这个例子，之后我们针对这个例子，开启今天权限之旅~
来个Demo瞅瞅
1.设置相机权限
uses-permission android:name="android.permission.CAMERA"
2.设置Android兼容版本为23 此处忽略实际调用相机代码。
minSdkVersion 9
targetSdkVersion 23
关于Android版本号这块，特意为大家截个图，方便大家在查阅过程中记一下~
来来来，我们运行看看会有什么结果发生
结果如下：
查看异常如下：
3.将Android兼容版本设置为21
minSdkVersion 9
targetSdkVersion 21
接下来再看看结果：
看到这个，不知道大家有没有在想一个问题，为什么同样是调用相机这简单操作，在兼容Android 系统21以及23后运行结果会发生变化呢？
看看异常，看看问题，还是直接看看官方文档看看这是什么情况吧。
Android 6.0（API 级别 23）除了提供诸多新特性和功能外，还对系统和 API 行为做出了各种变更，而我们今天重点关注权限方面的处理。
Android 6.0引入了一种新的权限模式，也就是我们常说的**"运行时动态申请权限"**。如今，用户可直接在运行时管理应用权限。这种模式让用户能够更好地了解和控制权限，同时为应用开发者精简了安装和自动更新过程。用户可为所安装的各个应用分别授予或撤销权限。
如果应用在清单中列出正常权限（即不会对用户隐私或设备操作造成很大风险的权限），系统会自动授予这些权限。如果应用在其清单中列出危险权限（即可能影响用户隐私或设备正常操作的权限），系统会要求用户明确授予这些权限。Android 发出请求的方式取决于系统版本，而系统版本是应用的目标，具体情况在下面分别进行说明：
• 如果设备运行的是 Android 6.0（API 级别 23）或更高版本，并且应用的 targetSdkVersion 是 23 或更高版本，则应用在运行时向用户请求权限。用户可随时调用权限，因此应用在每次运行时均需检查自身是否具备所需的权限；
• 如果设备运行的是 Android 5.1（API 级别 22）或更低版本，并且应用的 targetSdkVersion 是 22 或更低版本，则系统会在用户安装应用时要求用户授予权限。如果将新权限添加到更新的应用版本，系统会在用户更新应用时要求授予该权限。用户一旦安装应用，撤销权限的唯一方式是卸载应用。
通常，权限失效会导致 SecurityException 被扔回应用。但不能保证每个地方都是这样。例如，sendBroadcast(Intent) 方法在数据传递到每个接收者时会检查权限，在方法调用返回后，即使权限失效，我们也不会收到异常。但在几乎所有情况下，权限失效会记入系统日志。（排除某些特例）
此外，任何应用都可定义并实施自己的权限，因此这不是所有可能权限的详尽列表。So，我们可能在程序运行期间的多个位置实施特定权限，下面为大家简单举几个例子：
• 在调用系统时，防止应用执行某些功能；
• 在启动 Activity 时，防止应用启动其他应用的 Activity；
• 在发送和接收广播时，控制谁可以接收你的广播，谁可以向你发送广播；
• 在访问和操作内容提供程序时；
• 绑定至服务或启动服务。
系统权限分为几个保护级别。需要了解的两个最重要保护级别是正常权限和危险权限：
• 正常权限涵盖应用需要访问其沙盒外部数据或资源，但对用户隐私或其他应用操作风险很小的区域。例如，设置时区的权限就是正常权限。如果应用声明其需要正常权限，系统会自动向应用授予该权限。如需当前正常权限的完整列表，请文章尾部查阅正常权限访问地址链接。
• 危险权限涵盖应用需要涉及用户隐私信息的数据或资源，或者可能对用户存储的数据或其他应用的操作产生影响的区域。例如，能够读取用户的联系人属于危险权限。如果应用声明其需要危险权限，则用户必须明确向应用授予该权限。
所有危险的 Android 系统权限都属于权限组。如果设备运行的是 Android 6.0（API 级别 23），并且应用的targetSdkVersion 是 23 或更高版本，则当用户请求危险权限时系统会发生以下行为：
• 如果应用请求其清单中列出的危险权限，而应用目前在权限组中没有任何权限，则系统会向用户显示一个对话框，描述应用要访问的权限组。对话框不描述该组内的具体权限。 例如，如果应用请求READ_CONTACTS 权限，系统对话框只说明该应用需要访问设备的联系信息。如果用户批准，系统将向应用授予其请求的权限。
• 如果应用请求其清单中列出的危险权限，而应用在同一权限组中已有另一项危险权限，则系统会立即授予该权限，而无需与用户进行任何交互。 例如，如果某应用已经请求并且被授予了 READ_CONTACTS 权限，然后它又请求 WRITE_CONTACTS，系统将立即授予该权限。
任何权限都可属于一个权限组，包括正常权限和应用定义的权限。但权限组仅当权限危险时才影响用户体验。可以忽略正常权限的权限组。
如果设备运行的是 Android 5.1（API 级别 22）或更低版本，并且应用的 targetSdkVersion 是 22 或更低版本，则系统会在安装时要求用户授予权限。再次强调，系统只告诉用户应用需要的权限组，而不告知具体权限。
下面为大家附上危险权限以及危险权限组图：
运行结果图(测试机为红米note4 Android 6.0)：
实现起来步骤如下：
1.设置兼容Android API为21； 2.申请权限 回调中根据状态码处理 授予权限后进行拨打电话
源码如下：
public class HongChengActivity1 extends Activity {
// 打电话权限申请的请求码
private static final int CALL_PHONE_REQUEST_CODE = 0x0011;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_hong_cheng1);
}
public void phoneClick(View view) {
if (ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE)
!= PackageManager.PERMISSION_GRANTED) {
Toast.makeText(this, "申请权限", Toast.LENGTH_SHORT).show();
ActivityCompat.requestPermissions(this,
new String[]{"Manifest.permission.CALL_PHONE"}, CALL_PHONE_REQUEST_CODE);
} else {
callPhone();
}
}
/**
* 拨打电话
**/
private void callPhone() {
Intent intent = new Intent(Intent.ACTION_CALL);
Uri data = Uri.parse("tel:114");
intent.setData(data);
startActivity(intent);
}
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
if (requestCode == CALL_PHONE_REQUEST_CODE) {
if (grantResults != null && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
// Permission Granted
callPhone();
} else {
// Permission Denied
Toast.makeText(this, "权限被拒绝了", Toast.LENGTH_SHORT).show();
}
}
}
}
首先来看下使用其封装的权限管理框架结果，由于测试机短缺，暂时对红米Note4 6.0，以及乐视 6.0.1 进行简单测试，如下：
红米Note4 Android 系统版本：6.0 测试结果如下：
乐视 Android 系统版本：6.0.1 测试结果如下：
 #### 2.确定实现思路以及使用方式 主要中心思想是通过**反射加注解**去对权限进行管理，大家记住~撸码之前，我们要掌握如下俩点：
首先要明确操作流程，简单如下： 1. 判断当前系统版本是否小于6.0，如果小于，直接通过反射去获取方法直接执行操作（可以理解为直接拨打电话），由于我们不知道要执行哪儿个方法，所以我们只能通过注解的方式去给方法设置Tag，之后通过反射去执行这个方法； 2. 如果当前设备系统版本大于等于6.0，判断权限是否被用户授予。首先获取用户拒绝的权限，校验返回的权限组，如果返回权限组中有用户拒绝的权限，我们直接开启申请权限，否则直接通过反射执行该方法。
针对以上俩点，我们进行逐个细化，随便编码实现。
关于使用，我们有Build模式以及链式方式，红橙说，链式方式比较有逼格，So，秒懂？
首先我们需要定义一个Helper类，这个类的主要作用就是提供方法去让我们进行链式调用。那么我们现在想想，我们应该去传什么参数好呢？
-
当前调用的Activity or Fragment，这个是不可缺少的吧，关于这块，我们直接设定为一个Object；
-
请求肯定会有一个请求码，不然我怎么去区分你到底是要干嘛？所以，定义一个requestCode；
-
最后一个参数当然是请求的权限组了呗，所以我们定义一个String[]数组去接收请求的权限数组，顺便捎带着把我们这个调用类初始化下。
相关代码如下：
// 需要反射的类
private Object mObject;
// 请求码
private int mRequestCode;
// 请求权限数组
private String[] mRequestPermission;
private PermissionHelper(Object object) {
this.mObject = object;
}
既然我们是通过链式调用，我们必须要提供一个入口，而这个入口又必须支持Activity或者Fragment，如下：
// 链式传参
/**
* 兼容Activity
*
* @param activity
* @return
*/
public static PermissionHelper with(Activity activity) {
return new PermissionHelper(activity);
}
/**
* 兼容 Fragment
*
* @param fragment
* @return
*/
public static PermissionHelper with(Fragment fragment) {
return new PermissionHelper(fragment);
}
兼容了主入口，下面我们要对开始设定的参数进行初始化，话说你不给我入口，我怎么用，怎么传参呢，别急，继续往下看：
/**
* 添加请求码
*
* @param requestCode
* @return
*/
public PermissionHelper requestCode(int requestCode) {
this.mRequestCode = requestCode;
return this;
}
/**
* 添加请求权限数组
*
* @param permissions
* @return
*/
public PermissionHelper requestPermission(String... permissions) {
this.mRequestPermission = permissions;
return this;
}
刚才说了，我们首先要去判断当前设备是不是6.0，你整个4.4的设备过来，问我动态请求权限，那不是闹呢~！
为了避免一个类中代码太多，抽取工具类，暂定为PermissionUtils。而这个工具类又不能被别人轻易地实例化，那我们直接禁止实例化，也就是禁止使用new的方式去创建，这时候你会问了，不让我new，那让我怎么办？别急往下一步步看：
private PermissionUtils() {
throw new UnsupportedOperationException("不能被实例化");
}
/**
* 判断当前系统版本是否大于等于6.0
*
* @return
*/
public static boolean isOverMarshmallow() {
return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
}
刚刚我们说，如果当前设备是6.0以下，我们判断它已经获取到权限(显而易见有成功就有失败)，但是我们对执行的方法不确定，只能采用注解方式给方法设置Tag，然后通过反射去执行，如下。
定义成功注解类：
/**
* Created by HLQ on 2017/6/13
*/
@Target(ElementType.METHOD) // 放在什么位置 METHOD 放在方法上 FIELD 放在属性上 TYPE 放在类上
@Retention(RetentionPolicy.RUNTIME) // 编译时检测 or 运行时检测
public @interface PermissionSucceed {
// 注解的作用就是在反射的时候做一个标记 一般配合类的反射使用
// 请求码
public int requestCode();
}
定义失败注解类：
/**
* Created by HLQ on 2017/6/13
*/
@Target(ElementType.METHOD) // 放在什么位置 METHOD 放在方法上 FIELD 放在属性上 TYPE 放在类上
@Retention(RetentionPolicy.RUNTIME) // 编译时检测 or 运行时检测
public @interface PermissionFail {
// 注解的作用就是在反射的时候做一个标记 一般配合类的反射使用
// 请求码
public int requestCode();
}
在Helper中编写请求方法，顺便实现：
/**
* 判断权限以及请求权限
*/
public void request() {
// 判断当前系统版本是否大于等于6.0
if (!PermissionUtils.isOverMarshmallow()) {
// 小于6.0 直接执行方法 通过反射去获取
// 对执行的方法不确定 只能采用注解方式给方法设置Tag 通过反射去执行
PermissionUtils.executeSucceedMethod(mObject, mRequestCode);
return;
}
// 大于等于6.0 判断权限是否授予
// 获取用户拒绝的权限 检测权限
List<String> deniedPermissions = PermissionUtils.getDeniedPermissions(mObject, mRequestPermission);
// 权限被授予 反射获取执行方法
if (deniedPermissions.size() == 0) {
// 用户授予请求权限
PermissionUtils.executeSucceedMethod(mObject, mRequestCode);
} else {
// 权限被拒绝 申请权限
ActivityCompat.requestPermissions(PermissionUtils.getActivity(mObject), deniedPermissions.toArray(new String[deniedPermissions.size()]), mRequestCode);
}
}
在Util中实现成功以及失败的方法：
/**
* 执行成功
*
* @param mClass
* @param requestCode
*/
public static void executeSucceedMethod(Object reflectObject, int requestCode) {
// 获取class中所有方法去
Method[] methods = reflectObject.getClass().getDeclaredMethods();
// 遍历找到设置Tag的方法
for (Method method : methods) {
// Log.e("HLQ_Struggle", "找到的方法：" + method + "");
// 获取该方法上面有没有设置成功的Tag
PermissionSucceed succeedMethod = method.getAnnotation(PermissionSucceed.class);
if (succeedMethod != null) {
// 代表该方法设置Tag
// 判断请求码是否一致
int methodCode = succeedMethod.requestCode();
if (methodCode == requestCode) {
// 找到方法 通过反射执行该方法
Log.e("HLQ_Struggle", "找到了该方法：" + method);
executeMethod(reflectObject, method);
}
}
}
}
/**
* 执行失败
*
* @param object
* @param requestCode
*/
public static void executeFailMethod(Object reflectObject, int requestCode) {
// 获取class中所有方法去
Method[] methods = reflectObject.getClass().getDeclaredMethods();
// 遍历找到设置Tag的方法
for (Method method : methods) {
Log.e("HLQ_Struggle", method + "");
// 获取该方法上面有没有设置失败的Tag
PermissionFail faildMethod = method.getAnnotation(PermissionFail.class);
if (faildMethod != null) {
// 代表该方法设置Tag
// 判断请求码是否一致
int methodCode = faildMethod.requestCode();
if (methodCode == requestCode) {
// 找到方法 通过反射执行该方法
Log.e("HLQ_Struggle", "找到了失败的方法：" + method);
executeMethod(reflectObject, method);
}
}
}
}
紧接着，通过反射指定该方法：
/**
* 反射执行方法
*
* @param reflectObject
* @param method
*/
private static void executeMethod(Object reflectObject, Method method) {
// 反射执行方法 该方法所属类
try {
// 允许执行私有方法
method.setAccessible(true);
method.invoke(reflectObject, new Object[]{});
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
当前设备大于等于6.0，我们直接读取用户拒绝的权限：
/**
* 获取用户拒绝权限组
*
* @param mObject Activity Fragment
* @param mRequestPermission
* @return
*/
public static List<String> getDeniedPermissions(Object object, String[] requestPermissions) {
List<String> deniedPermissions = new ArrayList<>();
for (String requestPermission : requestPermissions) {
// 将用户拒绝的权限添加集合
if (ContextCompat.checkSelfPermission(getActivity(object), requestPermission) == PackageManager.PERMISSION_DENIED) {
deniedPermissions.add(requestPermission);
}
}
return deniedPermissions;
}
/**
* 获取Context
*
* @param mObject
* @return
*/
public static Activity getActivity(Object mObject) {
if (mObject instanceof Activity) {
return (Activity) mObject;
}
if (mObject instanceof Fragment) {
return ((Fragment) mObject).getActivity();
}
return null;
}
下面，我们直接在权限回调中处理返回结果即可：
/**
* 处理权限回调
*
* @param requestCode 申请权限Code码
* @param permissions 申请的权限数组
* @param grantResults
*/
public static void requestPermissionsResult(Object object, int requestCode, String[] permissions) {
// 再次获取用户拒绝的权限
List<String> deniedPermissions = PermissionUtils.getDeniedPermissions(object, permissions);
if (deniedPermissions.size() == 0) {
// 用户已授权申请的权限
PermissionUtils.executeSucceedMethod(object, requestCode);
} else {
// 申请的权限中 有用户不同意的
PermissionUtils.executeFailMethod(object, requestCode);
}
}
同样，我们也需要对外提供一个入口，方便他人直接调用：
/**
* 请求权限
*
* @param activity
* @param requestCode
* @param permissions
*/
public static void requestPermission(Activity activity, int requestCode, String[] permissions) {
PermissionHelper.with(activity).requestCode(requestCode).requestPermission(permissions).request();
}
到这里，关于Android 6.0运行时动态申请权限封装框架已完毕，那么我们该如何使用呢？看下面提供的一个小demo：
/**
* 权限管理简单处理 create by heliquan at 2017年6月13日
*/
public class HongChengActivity2 extends Activity {
private static final int CALL_PHONR_REQUEST_CODE = 0x0011;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_hong_cheng1);
findViewById(R.id.id_call).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
PermissionHelper.with(HongChengActivity2.this).requestCode(CALL_PHONR_REQUEST_CODE).requestPermission(Manifest.permission.CALL_PHONE).request();
}
});
}
/**
* 拨打电话
**/
@PermissionSucceed(requestCode = CALL_PHONR_REQUEST_CODE)
public void callPhone() {
Intent intent = new Intent(Intent.ACTION_CALL);
Uri data = Uri.parse("tel:114");
intent.setData(data);
startActivity(intent);
}
@PermissionFail(requestCode = CALL_PHONR_REQUEST_CODE)
private void callPhoneFail() {
Toast.makeText(this, "您拒绝了拨打电话", Toast.LENGTH_SHORT).show();
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
Log.e("HLQ_Struggle", "=====================>CALL_PHONR_REQUEST_CODE：" + CALL_PHONR_REQUEST_CODE);
Log.e("HLQ_Struggle", "=====================>请求码：" + requestCode);
PermissionHelper.requestPermissionsResult(this, requestCode, permissions);
}
}
这里不得不吐槽小米，有时候拒绝权限，它自动设置为以后不再提醒，恶心要死~！！！
RxPermissions是帮助开发者简化requestPermissions()相关的处理。
（1） 开发者不用担心Android运行环境的版本，如果系统是Android 6.0之前的版本，RxPermissions返回的结果是，app请求的每个权限都被允许（granted）。RxPermissions内部已经对Android版本进行了判断：
boolean isMarshmallow() {
return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M;
}
public boolean isGranted(String permission) {
// 如果是Android 6.0 （Api 23）之前，则权限被允许使用。
return !isMarshmallow() || mRxPermissionsFragment.isGranted(permission);
}
（2） 将权限申请的代码（requestPermissions()）和请求结果的代码（onRequestPermissionsResult()）放在一起管理，避免了代码的分散。
（3） RxPermissions具备Rx（RxJava）的特性，例如可以使用链式操作，可以执行filter操作，transform操作等等。
顺便在这里提一下：
RxPermissions是基于RxJava的，RxJava现在有2个大版本，一个RxJava 1.x（通常说RxJava），另一个是RxJava2。所以RxPermissions有2个版本，分别支持RxJava和RxJava2。
参考 https://github.com/tbruyelle/RxPermissions 中的README。
（1） minSdkVersion必须 >= 11。
（2） 使用RxPermissions申请权限，必须在Activity.onCreate()或者View.onFinishInflate()中处理。不能在onResume()中处理，因为onResume()在App的生命周期中可能执行的很频繁。如果在请求权限的时候，App重新启动了（例如屏幕旋转导致的App关闭再重新创建），那么用户的选择（允许 或者 拒绝）将无法发给App。 更多讨论，请参考：tbruyelle/RxPermissions#69
1.导入依赖库
compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
compile 'io.reactivex.rxjava2:rxjava:2.0.5'
compile 'com.tbruyelle.rxpermissions2:rxpermissions:0.9.3@aar'
2.在点击事件中请求
findViewById(R.id.id_rx).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
RxPermissions rxPermission = new RxPermissions(RxPermissionsActivity.this);
rxPermission
.requestEach(
Manifest.permission.CAMERA)
.subscribe(new Consumer<Permission>() {
@Override
public void accept(Permission permission) throws Exception {
if (permission.granted) {
// 用户已经同意该权限
Toast.makeText(RxPermissionsActivity.this, "成功~", Toast.LENGTH_SHORT).show();
Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
startActivity(intent);
} else if (permission.shouldShowRequestPermissionRationale) {
// 用户拒绝了该权限，没有选中『不再询问』（Never ask again）,那么下次再次启动时，还会提示请求权限的对话框
Toast.makeText(RxPermissionsActivity.this, "拒绝~", Toast.LENGTH_SHORT).show();
} else {
// 用户拒绝了该权限，并且选中『不再询问』
Toast.makeText(RxPermissionsActivity.this, "不在询问~", Toast.LENGTH_SHORT).show();
}
}
});
}
});
当然还有一种办法就是直接在首页进行申请应用所需要的权限，如下：
/**
* 请求权限
*/
private void requestPermissions() {
RxPermissions rxPermissions = new RxPermissions(self);
rxPermissions.requestEach(
Manifest.permission.ACCESS_COARSE_LOCATION, // 用于进行网络定位
Manifest.permission.ACCESS_FINE_LOCATION, // 用于访问GPS定位
Manifest.permission.CAMERA // 拍照
).subscribe(new Consumer<Permission>() {
@Override
public void accept(Permission permission) throws Exception {
if (permission.granted) { // 用户授予该权限 让我们尽情浪去吧
} else if (permission.shouldShowRequestPermissionRationale) { // 用户拒绝了该权限，没有选中『不再询问』（Never ask again）,那么下次再次启动时，还会提示请求权限的对话框
} else { // 用户拒绝了该权限，并且选中『不再询问』
}
}
});
}
以上俩种方式大家可随意选择~
用一句话简单概括就是：基于注释的API来处理运行时权限。
-
100％无反射；
-
支持特殊权限；
-
支持小米 在这里只能呵呵了 这小米 不过不得不佩服人家的工程师~
PermissionsDispatcher仅引入了几个注释，保持其通用的API简洁，具体如下：
对此，官方为我们提供了一个小例子，结合上图查看代码后，我们来实际coding~
@RuntimePermissions
public class MainActivity extends AppCompatActivity {
@NeedsPermission(Manifest.permission.CAMERA)
void showCamera() {
getSupportFragmentManager().beginTransaction()
.replace(R.id.sample_content_fragment, CameraPreviewFragment.newInstance())
.addToBackStack("camera")
.commitAllowingStateLoss();
}
@OnShowRationale(Manifest.permission.CAMERA)
void showRationaleForCamera(final PermissionRequest request) {
new AlertDialog.Builder(this)
.setMessage(R.string.permission_camera_rationale)
.setPositiveButton(R.string.button_allow, (dialog, button) -> request.proceed())
.setNegativeButton(R.string.button_deny, (dialog, button) -> request.cancel())
.show();
}
@OnPermissionDenied(Manifest.permission.CAMERA)
void showDeniedForCamera() {
Toast.makeText(this, R.string.permission_camera_denied, Toast.LENGTH_SHORT).show();
}
@OnNeverAskAgain(Manifest.permission.CAMERA)
void showNeverAskForCamera() {
Toast.makeText(this, R.string.permission_camera_neverask, Toast.LENGTH_SHORT).show();
}
}
编译时，PermissionsDispatcher为我们Activity（[活动名称] + PermissionsDispatcher）生成一个类，我们可以使用该类来安全地访问这些受权限保护的方法，而我们唯一要做的就是将权限处理委托委托给这个帮助类，那么接下来我们一起来看看官方提供的小例子。
// This file was generated by PermissionsDispatcher. Do not modify!
package permissions.dispatcher.sample;
import android.support.v4.app.ActivityCompat;
import permissions.dispatcher.PermissionRequest;
import permissions.dispatcher.PermissionUtils;
import java.lang.ref.WeakReference;
final class MainActivityPermissionsDispatcher {
private static final int REQUEST_SHOWCAMERA = 0;
private static final String[] PERMISSION_SHOWCAMERA = new String[] {"android.permission.CAMERA"};
private MainActivityPermissionsDispatcher() {
}
static void showCameraWithCheck(MainActivity target) {
if (PermissionUtils.hasSelfPermissions(target, PERMISSION_SHOWCAMERA)) {
target.showCamera();
} else {
if (PermissionUtils.shouldShowRequestPermissionRationale(target, PERMISSION_SHOWCAMERA)) {
target.showRationaleForCamera(new ShowCameraPermissionRequest(target));
} else {
ActivityCompat.requestPermissions(target, PERMISSION_SHOWCAMERA, REQUEST_SHOWCAMERA);
}
}
}
static void onRequestPermissionsResult(MainActivity target, int requestCode, int[] grantResults) {
switch (requestCode) {
case REQUEST_SHOWCAMERA:
if (PermissionUtils.verifyPermissions(grantResults)) {
target.showCamera();
} else {
if (!PermissionUtils.shouldShowRequestPermissionRationale(target, PERMISSION_SHOWCAMERA)) {
target.onCameraNeverAskAgain();
} else {
target.onCameraDenied();
}
}
break;
default:
break;
}
}
private static final class ShowCameraPermissionRequest implements PermissionRequest {
private final WeakReference<MainActivity> weakTarget;
private ShowCameraPermissionRequest(MainActivity target) {
this.weakTarget = new WeakReference<MainActivity>(target);
}
@Override
public void proceed() {
MainActivity target = weakTarget.get();
if (target == null) return;
ActivityCompat.requestPermissions(target, PERMISSION_SHOWCAMERA, REQUEST_SHOWCAMERA);
}
@Override
public void cancel() {
MainActivity target = weakTarget.get();
if (target == null) return;
target.onCameraDenied();
}
}
}
1.老规矩 查看运行结果：测试设备为乐视
1-1 用户拒绝
1-2 用户允许
2.添加依赖
compile 'com.github.hotchemi:permissionsdispatcher:2.3.2'
annotationProcessor 'com.github.hotchemi:permissionsdispatcher-processor:2.3.2'
3.编写基础类
package cn.hlq.androidrightsmanagement.permissionsdispatcher;
import android.Manifest;
import android.app.Activity;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.v7.app.AlertDialog;
import android.view.View;
import android.widget.Toast;
import cn.hlq.androidrightsmanagement.R;
import permissions.dispatcher.NeedsPermission;
import permissions.dispatcher.OnNeverAskAgain;
import permissions.dispatcher.OnPermissionDenied;
import permissions.dispatcher.OnShowRationale;
import permissions.dispatcher.PermissionRequest;
import permissions.dispatcher.RuntimePermissions;
/**
* permissionsdispatcher简单使用 create by heliquan at 2017年6月18日
*/
@RuntimePermissions // 标记需要运行时判断的类(用于动态生成代理类)
public class DispatcherActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_permissions_dispatcher);
findViewById(R.id.id_c).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
}
});
}
@NeedsPermission(Manifest.permission.CAMERA)
// 标记需要检查权限的方法
void showToast() {
startActivityForResult(new Intent("android.media.action.IMAGE_CAPTURE"), 200);
}
@OnShowRationale(Manifest.permission.CAMERA)
// 授权提示回调
void showRationale(final PermissionRequest request) {
new AlertDialog.Builder(this).setMessage("不给权限你试试~")
.setPositiveButton("确定", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
request.proceed();//请求权限
}
})
.setNegativeButton("取消", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
request.cancel();
}
})
.setCancelable(false)
.show();
}
@OnPermissionDenied(Manifest.permission.CAMERA)
// 授权被拒绝回调
void denied() {
Toast.makeText(this, "丫的，不给我权限！", Toast.LENGTH_SHORT).show();
}
@OnNeverAskAgain(Manifest.permission.CAMERA)
// 授权被拒绝并不再提醒回调
void neverAskAgain() {
Toast.makeText(this, "丫的，还点击不再询问，fuck！", Toast.LENGTH_SHORT).show();
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
}
}
4.Make Project
还记得我们上面说的编译后结果吗？回顾一下吧~
编译时，PermissionsDispatcher为我们Activity（[活动名称] + PermissionsDispatcher）生成一个类，我们可以使用该类来安全地访问这些受权限保护的方法，而我们唯一要做的就是将权限处理委托委托给这个帮助类，那么接下来我们一起来看看官方提供的小例子。
So 基于此项目，编译后生成DispatcherActivityPermissionsDispatcher类，我们会基于此类进行权限处理
生成后，我们修改下代码，如下：
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_permissions_dispatcher);
findViewById(R.id.id_c).setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
DispatcherActivityPermissionsDispatcher.showToastWithCheck(DispatcherActivity.this);
}
});
}
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
super.onRequestPermissionsResult(requestCode, permissions, grantResults);
DispatcherActivityPermissionsDispatcher.onRequestPermissionsResult(this, requestCode, grantResults);
}
MD，搞这个搞得是真恶心，一开始库依赖不上，接下来网上各种搜索结果又不是很完善，好到搞出来了。
- 谷歌官方地址：https://developer.android.google.cn/about/versions/marshmallow/android-6.0-changes.html#behavior-runtime-permissions；
- 谷歌官方权限说明：https://developer.android.google.cn/reference/android/Manifest.permission.html；
- 正常权限：https://developer.android.google.cn/guide/topics/permissions/normal-permissions.html；
- 红橙Darren简书地址：http://www.jianshu.com/u/35083fcb7747；
- HongChengDarren CSDN地址：http://blog.csdn.net/z240336124；
- RxPermissions地址：https://github.com/tbruyelle/RxPermissions；
- Abracadabra地址： http://blog.csdn.net/u013553529/article/details/68948971；
- PermissionsDispatcher开源库地址:https://github.com/hotchemi/PermissionsDispatcher
感谢如上各位，前人栽树，后人乘凉，Thanks