android全版本权限请求框架

kotlin vs java

市面上有很多开源框架用于6.0权限请求处理，但是各种框架使用下来，还是感觉不爽，累赘，不直观。本文介绍的实现方案我认为是使用最简单，侵入最低的方式。

$\color{blue}{首先}$ 介绍一下使用方式，竟然说简单，那就先看看使用怎么个效果先，直接上代码：

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    @Permission(permissions = {Manifest.permission.WRITE_EXTERNAL_STORAGE, Manifest.permission.READ_EXTERNAL_STORAGE}, requestCode = 100)
    public void requestPermission(View view) {
        Toast.makeText(this, "权限请求成功", Toast.LENGTH_LONG).show();
    }

    @PermissionCancel
    public void requestPermissionCancel() {
        Toast.makeText(this, "权限请求取消", Toast.LENGTH_LONG).show();
    }

    @PermissionDenied
    public void requestPermissionDenied() {
        Toast.makeText(this, "权限请求被拒绝", Toast.LENGTH_LONG).show();
    }
}

如上代码，只需要在我们处理权限请求的结果方法上面做相应的注解就完事儿。
@Permission:这个注解是我们关键注解，必须存在的，它有两个作用，第一：注解切入点，只有被注解了的方法才会在方法执行时进行权限请求判断处理，包含两个参数，一看就明白的，一个permissions我们需要请求的权限数组，requestCode权限请求时的code;第二：作为我们请求成功的执行方案。
@PermissionCancel:被注解的方法将在用户拒绝权限请求并且不再提示的时候触发。
@PermissionDenied:被注解的方法将在用户拒绝权限请求并且下次请求权限会再次触发。

$\color{blue}{然后}$ 我们进入思路分析：

根据上面的使用方式，我们可以清晰的分析出我们最终的方案肯定会从注解入手，会在我们触发@Permission:注解的方法的时候去对方法执行前后做一个判断，看是否获取权限，如果没有则请求权限，已经获取就让方法继续执行。然而我们知道权限请求我们是通过activity发起的，这个时候为了使我们代码侵入性最小，那我们就不能使用继承方式去添加发起权限请求的代码，说好三个注解搞定，就不能多写一行其他代码在项目里面。分析这两个点之后我们首先得考虑怎么对方法进行运行前后监听，以往我们不难想到用动态代理，确实这是我们android常规的方式，前面文章也有一篇文章ASM框架实现字节码插桩的方式也可以监听到我们方法前后，但是今天用一种新方案AspectJ，其实他的原理和ASM原理差不多，都是在我们编译的时候去做处理。当然，我们要获取注解，对注解做处理肯定也逃不掉反射，通过反射的方式获取注解参数，那接下来我们就按照上面说的这几点来写代码：

public class PermissionActivity extends AppCompatActivity {

    private String[] permissions;
    private int requestCode = REQUEST_CODE_DEFALUT;
    private static PermissionCallback callback;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        View view = new View(this);
        view.setBackgroundColor(ContextCompat.getColor(this, android.R.color.transparent));
        setContentView(view);
        //获取权限和code
        Bundle intent = getIntent().getExtras();
        if (intent == null) {
            return;
        }
        if (intent.containsKey(KEY_PERMISSION)) {
            permissions = intent.getStringArray(KEY_PERMISSION);
        }
        if (intent.containsKey(KEY_PERMISSION_CODE)) {
            requestCode = intent.getInt(KEY_PERMISSION_CODE, REQUEST_CODE_DEFALUT);
        }
        if ((permissions == null || permissions.length == 0) && requestCode < 0) {
            finish();
            return;
        }
        //判断是否已经请求，已经请求成功不再重复请求
        if (permissions != null && PermissionUtils.hasPermissionRequest(this, permissions)) {
            callback.permissionSucess();
            finish();
        }
        //发起权限请求
        if (permissions != null) {
            ActivityCompat.requestPermissions(this, permissions, requestCode);
        }
    }


    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (PermissionUtils.requestPermissionSuccess(grantResults)) {
            callback.permissionSucess();
        } else if (PermissionUtils.shouldShowRequestPermissionRationale(this, permissions)) {
            callback.permissionDenied();
        } else {
            callback.permissionCancel();
        }
        finish();
    }

    @Override
    public void finish() {
        super.finish();
        //去除关闭动画
        overridePendingTransition(0, 0);
    }

    public static void permission(Context context, String[] permissions, int requestCode, PermissionCallback listener) {
        callback = listener;
        Intent intent = new Intent(context, PermissionActivity.class);
        Bundle bundle = new Bundle();
        intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
        bundle.putStringArray(KEY_PERMISSION, permissions);
        bundle.putInt(KEY_PERMISSION_CODE, requestCode);
        intent.putExtras(bundle);
        context.startActivity(intent);
        //todo 去除启动动画，当fragment启动的时候未解决
        if (context instanceof Activity) {
            Activity activity = (Activity) context;
            activity.overridePendingTransition(0, 0);
        }
    }
}

以上代码主要做了几件事：

一个全新的activity用于处理权限请求，此activity设置全透明，取消所有启动和关闭动画；
创建监听，用于回调权限请求结果，成功，拒绝，取消；
通过Intent方式获取权限参数；

/**
 * @Description:权限请求和允许
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Permission {
    String[] permissions();

    int requestCode() default REQUEST_CODE_DEFALUT;
}

/**
 * @Description:权限取消并且不再提示 拒绝
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PermissionCancel {
    int requestCode() default REQUEST_CODE_DEFALUT;
}

/**
 * @Description:权限取消并且不再提示 拒绝
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface PermissionCancel {
    int requestCode() default REQUEST_CODE_DEFALUT;
}

public interface PermissionCallback {
    void permissionSucess();

    void permissionCancel();

    void permissionDenied();
}

以上代码主要做了几件事：

创建我们的回调接口；
创建使用的三个注解类文件；

/**
 * @Description:编译时期Aspect api会在编译同时通过@Aspect处理该类
 * @Auther: wangqi
 * CreateTime: 2020/8/25.
 */
@Aspect
public class PermissionAspect {
//注解含义，代表监听被com.kylin.annotationpermission.permission.annotation.Permission类文件并且@annotation(permission)是注解所注解的方法做拦截
    @Pointcut("execution(@com.kylin.annotationpermission.permission.annotation.Permission * *(..)) && @annotation(permission)")
    public void AccessPoint(Permission permission) {
    }

    @Around("AccessPoint(permission)")
    public void ApproachMethod(final ProceedingJoinPoint point, Permission permission) throws Throwable {
        final Context context;
        final Object object = point.getThis();
        if (object instanceof Context) {
            context = (Context) object;
        } else if (object instanceof Fragment) {
            context = ((Fragment) object).getContext();
        } else {
            point.proceed();
            return;
        }

        PermissionActivity.permission(context, permission.permissions(), permission.requestCode(), new PermissionCallback() {
            @Override
            public void permissionSucess() {
                try {
                    point.proceed();//方法继续执行
                } catch (Throwable throwable) {
                    throwable.printStackTrace();
                }
            }

            @Override
            public void permissionCancel() {
                PermissionUtils.invokeAnnotation(object, PermissionCancel.class);
            }

            @Override
            public void permissionDenied() {
                PermissionUtils.invokeAnnotation(object, PermissionDenied.class);
                PermissionUtils.startAndroidSettings(context);
            }
        });
    }
}

以上代码主要做了几件事：

使用AspectJ创建文件，该文件需注意，该文件需要被@aspect注解，提供切入点方法，处理切入点方法。
拦截到方法之后对启动权限请求界面，通过权限处理结果作出响应。