前言
以前对于Android这边权限真的是一窍不通,偶尔还忘记写这个东西,静下心,真的该好好想想这东西到底是什么情况。
今天写个一个小demo,不出意料。感觉有点无奈。大家一起回顾下这个例子,之后我们针对这个例子,开启今天权限之旅~
Permission Study(权限有关知识学习)
1.小例子开启权限之旅~
来个Demo瞅瞅
1.设置相机权限
uses-permission android:name="android.permission.CAMERA"
2.设置Android兼容版本为23 此处忽略实际调用相机代码。
minSdkVersion 9 targetSdkVersion 23
关于Android版本号这块,特意为大家截个图,方便大家在查阅过程中记一下~
<center>
来来来,我们运行看看会有什么结果发生
结果如下:
<center>
查看异常如下:
<center>
3.将Android兼容版本设置为21
minSdkVersion 9 targetSdkVersion 21
接下来再看看结果:
<center>
看到这个,不知道大家有没有在想一个问题,为什么同样是调用相机这简单操作,在兼容Android 系统21以及23后运行结果会发生变化呢?
看看异常,看看问题,还是直接看看官方文档看看这是什么情况吧。
2.Android 6.0新特性(只针对权限管理部分)
Android 6.0(API 级别 23)除了提供诸多新特性和功能外,还对系统和 API 行为做出了各种变更,而我们今天重点关注权限方面的处理。
Android 6.0引入了一种新的权限模式,也就是我们常说的"运行时动态申请权限"。如今,用户可直接在运行时管理应用权限。这种模式让用户能够更好地了解和控制权限,同时为应用开发者精简了安装和自动更新过程。用户可为所安装的各个应用分别授予或撤销权限。
如果应用在清单中列出正常权限(即不会对用户隐私或设备操作造成很大风险的权限),系统会自动授予这些权限。如果应用在其清单中列出危险权限(即可能影响用户隐私或设备正常操作的权限),系统会要求用户明确授予这些权限。Android 发出请求的方式取决于系统版本,而系统版本是应用的目标,具体情况在下面分别进行说明:
• 如果设备运行的是 Android 6.0(API 级别 23)或更高版本,并且应用的 targetSdkVersion 是 23 或更高版本,则应用在运行时向用户请求权限。<font color=#FF0000>用户可随时调用权限</font>,因此应用在每次运行时均需检查自身是否具备所需的权限;
• 如果设备运行的是 Android 5.1(API 级别 22)或更低版本,并且应用的 targetSdkVersion 是 22 或更低版本,则系统会在用户安装应用时要求用户授予权限。如果将新权限添加到更新的应用版本,系统会在用户更新应用时要求授予该权限。<font color=#FF0000>用户一旦安装应用,撤销权限的唯一方式是卸载应用。
3.Permission 简单了解
通常,权限失效会导致 SecurityException 被扔回应用。但不能保证每个地方都是这样。例如,sendBroadcast(Intent) 方法在数据传递到每个接收者时会检查权限,在方法调用返回后,即使权限失效,我们也不会收到异常。但在几乎所有情况下,权限失效会记入系统日志。(排除某些特例)
此外,任何应用都可定义并实施自己的权限,因此这不是所有可能权限的详尽列表。So,我们可能在程序运行期间的多个位置实施特定权限,下面为大家简单举几个例子:
• 在调用系统时,防止应用执行某些功能;
• 在启动 Activity 时,防止应用启动其他应用的 Activity;
• 在发送和接收广播时,控制谁可以接收你的广播,谁可以向你发送广播;
• 在访问和操作内容提供程序时;
• 绑定至服务或启动服务。
4.Permission 分类 (正常权限 or 危险权限)
系统权限分为几个保护级别。需要了解的两个最重要保护级别是正常权限和危险权限:
• 正常权限涵盖应用需要访问其沙盒外部数据或资源,但对用户隐私或其他应用操作风险很小的区域。例如,设置时区的权限就是正常权限。如果应用声明其需要正常权限,系统会自动向应用授予该权限。如需当前正常权限的完整列表,请文章尾部查阅正常权限访问地址链接。
• 危险权限涵盖应用需要涉及用户隐私信息的数据或资源,或者可能对用户存储的数据或其他应用的操作产生影响的区域。例如,能够读取用户的联系人属于危险权限。如果应用声明其需要危险权限,则用户必须明确向应用授予该权限。
5.Permission Group
所有危险的 Android 系统权限都属于权限组。如果设备运行的是 Android 6.0(API 级别 23),并且应用的targetSdkVersion 是 23 或更高版本,则当用户请求危险权限时系统会发生以下行为:
• <font color=#FF0000>如果应用请求其清单中列出的危险权限,而应用目前在权限组中没有任何权限,则系统会向用户显示一个对话框,描述应用要访问的权限组。对话框不描述该组内的具体权限。</font> 例如,如果应用请求READ_CONTACTS 权限,系统对话框只说明该应用需要访问设备的联系信息。如果用户批准,系统将向应用授予其请求的权限。
• <font color=#FF0000>如果应用请求其清单中列出的危险权限,而应用在同一权限组中已有另一项危险权限,则系统会立即授予该权限,而无需与用户进行任何交互。</font> 例如,如果某应用已经请求并且被授予了 READ_CONTACTS 权限,然后它又请求 WRITE_CONTACTS,系统将立即授予该权限。
<font color=#FF0000>任何权限都可属于一个权限组,包括正常权限和应用定义的权限。但权限组仅当权限危险时才影响用户体验。可以忽略正常权限的权限组。
如果设备运行的是 Android 5.1(API 级别 22)或更低版本,并且应用的 targetSdkVersion 是 22 或更低版本,则系统会在安装时要求用户授予权限。<font color=#FF0000>再次强调,系统只告诉用户应用需要的权限组,而不告知具体权限。
下面为大家附上危险权限以及危险权限组图:
<center>
Permission Solve(解决权限问题)
红橙Darren 案例1
运行结果图(测试机为红米note4 Android 6.0):
<center>
实现起来步骤如下:
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();
}
}
}
}
红橙Darren 权限管理框架
1.眼见为实 查验运行结果
首先来看下使用其封装的权限管理框架结果,由于测试机短缺,暂时对红米Note4 6.0,以及乐视 6.0.1 进行简单测试,如下:
红米Note4 Android 系统版本:6.0 测试结果如下:
<center>
乐视 Android 系统版本:6.0.1 测试结果如下:
<center>
2.确定实现思路以及使用方式
主要中心思想是通过反射加注解去对权限进行管理,大家记住~
撸码之前,我们要掌握如下俩点:
首先要明确操作流程,简单如下:
<font color=#FF0000>1. 判断当前系统版本是否小于6.0,如果小于,直接通过反射去获取方法直接执行操作(可以理解为直接拨打电话),由于我们不知道要执行哪儿个方法,所以我们只能通过注解的方式去给方法设置Tag,之后通过反射去执行这个方法;
-
如果当前设备系统版本大于等于6.0,判断权限是否被用户授予。首先获取用户拒绝的权限,校验返回的权限组,如果返回权限组中有用户拒绝的权限,我们直接开启申请权限,否则直接通过反射执行该方法。
针对以上俩点,我们进行逐个细化,随便编码实现。
关于使用,我们有Build模式以及链式方式,红橙说,链式方式比较有逼格,So,秒懂?
3. 撸码实现
首先我们需要定义一个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使用
老规矩 上运行结果
<center>
这里不得不吐槽小米,有时候拒绝权限,它自动设置为以后不再提醒,恶心要死~!!!
RxPermissions简介
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。 更多讨论,请参考:https://github.com/tbruyelle/RxPermissions/issues/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 { // 用户拒绝了该权限,并且选中『不再询问』
}
}
});
}
以上俩种方式大家可随意选择~
PermissionsDispatcher使用
简介
用一句话简单概括就是:<font color=#FF0000>基于注释的API来处理运行时权限。
优势
-
100%无反射;
-
支持特殊权限;
-
支持小米 <font color=#FF0000>在这里只能呵呵了 这小米 不过不得不佩服人家的工程师~
注释含义
PermissionsDispatcher仅引入了几个注释,保持其通用的API简洁,具体如下:
<center>
对此,官方为我们提供了一个小例子,结合上图查看代码后,我们来实际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 用户拒绝
<center>
1-2 用户允许
<center>
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,搞这个搞得是真恶心,一开始库依赖不上,接下来网上各种搜索结果又不是很完善,好到搞出来了。