Android6.0权限适配

Android6.0引入了新的权限机制，早已有大神对此做过讲解，比如这篇文章：

http://blog.csdn.net/lmj623565791/article/details/50709663

本文对Android权限相关知识做一些其它补充。

一、 获取某个应用的权限清单(Manifest.xml中申请的权限)

private List<String> getAppRegistPermissions(){
List<String> permissionList = new ArrayList<>();
try {
PackageManager pm = getPackageManager();
PackageInfo pack = pm.getPackageInfo(getPackageName(),PackageManager.GET_PERMISSIONS);
String[] permissionStrings = pack.requestedPermissions;
permissionList = Arrays.asList(permissionStrings);
return permissionList;
} catch (PackageManager.NameNotFoundException e) {
e.printStackTrace();
}
return permissionList;
}

二、检查APP是否申请了某项权限

int granted = 0;
//1、android6.0及以上
if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
granted = checkSelfPermission(permission);
}
//2、使用support包中的ContextCompat
granted = ContextCompat.checkSelfPermission(this, permission);

//3、通过PackageManager判断
PackageManager pm = getPackageManager();
granted=pm.checkPermission(permission, getPackageName());

三、适配Android6.0以上

1、在AndroidManifest文件中添加需要的权限。

2、检查权限

private boolean hasPermission(String... permissions) {
for (String permission : permissions) {
int granted = ContextCompat.checkSelfPermission(this, permission);
if(granted == PackageManager.PERMISSION_DENIED){
return false;
}
}
return true;
}

3、申请授权

private void requestPermissions(int reqCode, String... permissions) {
ActivityCompat.requestPermissions(this, permissions, reqCode);
}

4、处理权限申请回调

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
List<String> deniedPermissions = new ArrayList<>();
for(int i=0; i<grantResults.length; i++){
if(grantResults[i] != PackageManager.PERMISSION_GRANTED){
deniedPermissions.add(permissions[i]);
}
}

if(deniedPermissions.size() > 0){
//权限被拒绝
} else {
//权限申请成功
}
}

不过还有个API值得提一下：

// Should we show an explanation?
if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity,
Manifest.permission.READ_CONTACTS))
// Show an expanation to the user *asynchronously* -- don't block
// this thread waiting for the user's response! After the user
// sees the explanation, try again to request the permission.

}

     这个API主要用于给用户一个申请权限的解释，该方法只有在用户在上一次已经拒绝过你的这个权限申请。也就是说，用户已经拒绝一次了，你又弹个授权框，

你需要给用户一个解释，为什么要授权，则使用该方法。

那么将上述几个步骤结合到一起就是：

// Here, thisActivity is the current activity
if (ContextCompat.checkSelfPermission(thisActivity,
Manifest.permission.READ_CONTACTS)
!= PackageManager.PERMISSION_GRANTED) {

// Should we show an explanation?
if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity,
Manifest.permission.READ_CONTACTS)) {

// Show an expanation to the user *asynchronously* -- don't block
// this thread waiting for the user's response! After the user
// sees the explanation, try again to request the permission.

} else {

// No explanation needed, we can request the permission.

ActivityCompat.requestPermissions(thisActivity,
new String[]{Manifest.permission.READ_CONTACTS},
MY_PERMISSIONS_REQUEST_READ_CONTACTS);

// MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
// app-defined int constant. The callback method gets the
// result of the request.
}
}

四、权限封装

从android6.0后可以看出，权限检查、权限申请完全一致，就权限回调处理不太一样，也就是说，如果我们要做封装，难点就在于完成权限申请成功和失败的处理。然而

权限成功和失败的处理和具体业务逻辑绑定的，我们没法预先知道具体方法，这时候反射就排上用场了。在Activity或Fragment中定义我们自己的业务方法，然后在方法上使用定义好的注解来标识，这样我们就可以在申请权限后通过反射Activity或Fragment，拿到标识了权限注解的方法，进行调用。完整代码如下：

1、定义注解

权限申请成功后调用的方法

/**
* 标识权限获取成功
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface PermissionSuccess {
int requestCode();
}

申请被用户拒绝后调用的方法

/**
* 标识权限获取失败
*/
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PermissionFail {
int requestCode();
}

2、权限工具类
public class PermissionUtil {

public static void needPermission(Fragment context, int reqCode, String... permissions) {
checkPermission(context, reqCode, permissions);
}

public static void needPermission(Activity context, int reqCode, String... permissions) {
checkPermission(context, reqCode, permissions);
}

@TargetApi(Build.VERSION_CODES.M)
private static void checkPermission(Object context, int reqCode, String... permissions) {

if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
//6.0以下
executeSuccessResult(context, reqCode);
return;
}
boolean granted = hasPermission(context, permissions);//检查权限
if (granted) {
executeSuccessResult(context, reqCode);
} else {
if (context instanceof Fragment) {
((Fragment) context).requestPermissions(permissions, reqCode);
} else {
((Activity) context).requestPermissions(permissions, reqCode);
}
}
}

private static void executeSuccessResult(Object context, int reqCode) {
Method successMethod = getTargetMethod(context, reqCode, PermissionSuccess.class);
try {
successMethod.invoke(context);
} catch (Exception e) {
e.printStackTrace();
}
}

private static void executeFailResult(Object context, int reqCode) {
Method successMethod = getTargetMethod(context, reqCode, PermissionFail.class);
try {
successMethod.invoke(context);
} catch (Exception e) {
e.printStackTrace();
}
}

private static Method getTargetMethod(Object context, int reqCode, Class annotation) {
Method[] declaredMethods = context.getClass().getDeclaredMethods();
for (Method method : declaredMethods) {
if (!method.isAccessible()) {
method.setAccessible(true); //私有的方法必须强制
}
//判断方法上是否使用了目标注解
boolean annotationPresent = method.isAnnotationPresent(annotation);
if (annotationPresent) {
if (isTargetMethod(method, reqCode, annotation)) { //比较requestCode是否相等
return method;
}
}
}
return null;
}

private static boolean isTargetMethod(Method method, int reqCode, Class cls) {
if (cls.equals(PermissionSuccess.class)) {
return reqCode == method.getAnnotation(PermissionSuccess.class).requestCode();
} else if (cls.equals(PermissionFail.class)) {
return reqCode == method.getAnnotation(PermissionFail.class).requestCode();
}
return false;
}

private static boolean hasPermission(Object context, String... permissions) {
Activity activity = null;
if (context instanceof Fragment) {
activity = ((Fragment) context).getActivity();
} else {
activity = (Activity) context;
}
for (String permission : permissions) {
int granted = ContextCompat.checkSelfPermission(activity, permission);
if (granted == PackageManager.PERMISSION_DENIED) {
return false;
}
}
return true;
}

public static void onRequestPermissionsResult(Fragment context, int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
handlePermissionsResult(context, requestCode, permissions, grantResults);
}

public static void onRequestPermissionsResult(Activity context, int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
handlePermissionsResult(context, requestCode, permissions, grantResults);
}

private static void handlePermissionsResult(Object context, int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
boolean permissionGranted = true;
for (int grant : grantResults) {
if (grant == PackageManager.PERMISSION_DENIED) {
permissionGranted = false;
break;
}
}
if (permissionGranted) {
//获得权限
executeSuccessResult(context, requestCode);
} else {
//权限被用户拒绝
executeFailResult(context, requestCode);
}
}
}


下载完整Demo