AspectJ切面实现Android权限请求框架

最新推荐文章于 2024-08-24 17:22:28 发布
最新推荐文章于 2024-08-24 17:22:28 发布
阅读量361 收藏
点赞数
文章标签： AspectJ实现Android权限请求框架
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24505921/article/details/103187076
版权

实现思路：搭配AspectJ切面思想，对需要请求权限的方法进行拦截修改(Around语法)，Around语法的作用主要是用来修改需要切入的方法以及方法的参数，参照这一便利，我们在定义的切面方法中新启动一个透明主题的activity作一个权限请求的统一处理的界面，搭配

EasyPermissions权限请求框架，这里作为方便，其实完全可以应业务要求自己封装，

我们可以在将请求权限的结果作为方法的参数进行返回。具体代码思路如下：

//权限请求方法注解

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
public @interface PermissionCheck {
    String[] value() default {};

    int requestCode();
}

 

//封装权限请求code 返回结果的bean类

public class PermissionsResult {
    int requestCode;
    int resultCode;
    List<String> permissions;
    List<String> successPermissions;
    List<String> failurePermissions;

    public List<String> getSuccessPermissions() {
        return successPermissions;
    }

    public List<String> getFailurePermissions() {
        return failurePermissions;
    }

    public int getRequestCode() {
        return requestCode;
    }

    public int getResultCode() {
        return resultCode;
    }

    public List<String> getPermissions() {
        return permissions;
    }

    public PermissionsResult(Builder builder) {
        this.requestCode = builder.requestCode;
        this.resultCode = builder.resultCode;
        this.permissions = builder.permissions;
        this.successPermissions = builder.successPermissions;
        this.failurePermissions = builder.failurePermissions;
    }


    public static class Builder{
        int requestCode;
        int resultCode;
        List<String> permissions;
        List<String> successPermissions;
        List<String> failurePermissions;
        public Builder() {
        }

        public Builder setRequestCode(int requestCode) {
            this.requestCode = requestCode;
            return this;
        }

        public Builder setResultCode(int resultCode) {
            this.resultCode = resultCode;
            return this;
        }

        public Builder setPermissions(List<String> permissions) {
            this.permissions = permissions;
            return this;
        }

        public Builder setSuccessPermissions(List<String> successPermissions) {
            this.successPermissions = successPermissions;
            return this;
        }

        public Builder setFailurePermissions(List<String> failurePermissions) {
            this.failurePermissions = failurePermissions;
            return this;
        }

        public PermissionsResult build(){
            return new PermissionsResult(this);
        }
    }


}

//AspectJ类中定义的切面方法

@Around("call(* *(xx.xx.xx.PermissionsResult)) && @annotation(permissionCheck)")
    public Object check(final ProceedingJoinPoint point, PermissionCheck permissionCheck){
        Log.e("---", "进入切面");
        Object target = point.getTarget();
        if(null == target) return null;
        Context context = null;
        if (target instanceof Activity) {
            context = (Context) target;
        } else if (target instanceof Fragment) {
            context = ((Fragment) target).getActivity();
        }else if(target instanceof BaseViewModel){
            context = ((BaseViewModel) target).getApplication();
        }else if(target instanceof SystemHeadCallBack){
//            context = ((SystemHeadCallBack) target).getmContext();
        }else if(target instanceof Service){
            context = ((Service) target).getApplicationContext();
        }

        String[] permissions = permissionCheck.value();
        Object[] objects = new Object[1];
        if (context != null) {
            //做权限是否有的判断
            if (EasyPermissions.hasPermissions(context, permissions)) {
                try {
                    objects[0] = point.proceed(new Object[]{new PermissionsResult.Builder()
                            .setResultCode(1)
                            .setSuccessPermissions(Arrays.asList(permissionCheck.value())).build()});
                } catch (Throwable throwable) {
                    throwable.printStackTrace();
                }
            } else {
                int requestCode = permissionCheck.requestCode();
                PermissionCheckActivity.startPermissionCheckActivity(
                        context, permissions, requestCode , new PermissionBack() {
                            @Override
                            public void permissionsCallBack(PermissionsResult permissionsResult) {
                                int returnRequestCode = permissionsResult.getRequestCode();
                                if(requestCode == returnRequestCode){ //校验
                                    try {
                                        objects[0] = point.proceed(new Object[]{permissionsResult});
                                    } catch (Throwable throwable) {
                                        throwable.printStackTrace();
                                    }
                                }
                            }
                        }
                );

            }

        }
        return objects[0];
    }

//透明主题的activity

public class PermissionCheckActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

    public static PermissionBack permissionBack;
    int requestCode;

    public static void startPermissionCheckActivity(Context context, String[] permissions,
                                                    int requestCode,
                                                    PermissionBack back){
        Intent intent = new Intent(context, PermissionCheckActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP);
        Bundle bundle = new Bundle();
        bundle.putStringArray("permissions", permissions);
        bundle.putInt("requestCode", requestCode);
        intent.putExtras(bundle);
        permissionBack = back;
        context.startActivity(intent);
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {

        getWindow().addFlags(WindowManager.LayoutParams.FLAG_TRANSLUCENT_STATUS | WindowManager.LayoutParams.FLAG_FULLSCREEN);
        StatusBarCompat.translucentStatusBar(this, true, false, getResources().getColor(R.color.transparent_00000000));
        super.onCreate(savedInstanceState);
        Intent intent = getIntent();
        Bundle extras = intent.getExtras();
        if (null == extras) return;
        requestCode = Objects.requireNonNull(extras).getInt("requestCode");
        String[] permissions = extras.getStringArray("permissions");
        if (permissions == null || permissions.length <= 0) {
            finish();
        } else {
            //首次会直接请求权限，如果之前权限请求拒绝过 那么就弹提示开启权限的框 确定之后再去请求权限
            EasyPermissions.requestPermissions(this, getString(R.string.post_message_albums_permission), requestCode, permissions);

        }
    }

    /**
     *
     */
    @Override
    public void onPermissionsGranted(int requestCode, List<String> perms) {

    }

    /**
     * dialog的取消按钮也会回调这个方法
     */
    @Override
    public void onPermissionsDenied(int requestCode, List<String> perms) {
        finish();
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
        if(grantResults.length <= 0){
            return;
        }
        boolean isSuccess  = true;
        List<String> perms = new ArrayList<>();
        List<String> successPermissions = new ArrayList<>();
        List<String> failurePermissions = new ArrayList<>();
        for (int i = 0;i < grantResults.length;i++){
            if(grantResults[i] == -1){ // -1表示该权限是被拒绝了的
                Log.e("--onRequestPermission", permissions[i] + "授权失败");
                failurePermissions.add(permissions[i]);
                isSuccess = false;
            }else {
                successPermissions.add(permissions[i]);
                Log.e("--onRequestPermission", permissions[i] + "授权成功");
            }
            perms.add(permissions[i]);
        }
        permissionBack.permissionsCallBack(new PermissionsResult.Builder()
                .setRequestCode(requestCode)
                .setPermissions(perms)
                .setSuccessPermissions(successPermissions)
                .setFailurePermissions(failurePermissions)
                .setResultCode(isSuccess ? 1 : 0).build());
        finish();
    }

在透明Activity中将权限请求结果进行回调到切面方法中，调用

point.proceed(new Object[]{permissionsResult});将权限请求结果的值作为参数传入到proceed方法.

具体使用：
 

@PermissionCheck(value = {
        Manifest.permission.ACCESS_FINE_LOCATION}, requestCode = 10000)
public Object check(PermissionsResult result){
    if(null == result){
        return "1";
    }
    int resultCode = result.getResultCode();
    // TODO: 2019/11/14 根据返回的值来确定做什么逻辑
    Log.e("--check权限返回code", resultCode + "");
    return "2";
}

在需要作权限请求的位置 直接调用 check(null);参数可以随意传，因为编译代码时AspectJ会重新对该方法进行改造。具体原理涉及到字节码改造了，不作详细说明，因为我也了解不深 哈哈哈哈。

 

 

 

 

梦想家-TSM
关注
Android组件化开发实战：封装权限管理请求框架，挥泪整理面经
Java进阶营的博客
04-11 837
最近看到群里看到一个女生，讲述了她从开始选择Android，经过非常努力的学习和挣扎，然而最后面对当前的环境却不得不放弃。看完以后真的非常替她感觉惋惜，如果早几年入行可能结果会比现在好很多，但可惜，这就是现实。 这是一个做精品的时代了，不是当年出个产品就能拉投资骗点击的时代了。精品需要的是更专业的人才，也就是对APP开发人员的素质要求会更高，这个市场会回归一个正常的节奏，拿多少钱就是看能力，看产品。 @version 1.0 @team 美奇软件开发工作室 @date 2020/11/23 .
Android 使用AspectJ实现权限申请和埋点上传
zxy_de_android的博客
06-26 798
一 Android 使用AspectJ 1.1 Android中使用@AspectJ来编写代码。 它在代码的编译期间扫描目标程序，根据切点（@PointCut）匹配,将开发者编写的Aspect程序编织（Weave）到目标程序的.class文件中，对目标程序作了重构（重构单位是JoinPoint），目的就是建立目标程序与Aspect程序的连接（获得执行的对象、方法、参数等上下文信息），从而达到AOP的目的。 1.2 Gradle 配置 1.在工程的 build.gradle中配置 clas
Android权限管理新纪元：AspectJX项目教程
gitblog_00468的博客
08-20 287
Android权限管理新纪元：AspectJX项目教程 android_permission_aspectjxA AOP library that process Android M permissions with aspectjx.项目地址:https://gitcode.com/gh_mirrors/an/android_permission_aspectjx 项目介绍 AspectJX是...
android权限请求框架
gf6873的博客
11-03 2882
封装的权限请求框架，自己练手使用这一个中有两套框架使用方法不同，可按需使用。 github入口. 此文主要说明如何引用及使用方法 How to To get a Git project into your build: Step 1. Add the JitPack repository to your build file gradle maven sbt leiningen Add it in...
Android 权限申请框架Android-UsesPermission
qq_33209777的博客
01-19 2126
安卓权限申请封装处理框架。测试支持4.0+。项目源于正式处理Android权限问题时，没找到简单、能满足被拒绝权限自动会到系统设置处理的框架，按自己的编程习惯造一个熟悉的轮子还是蛮好的。第一次使用Android Studio，还是Eclipse敲代码爽。来自一个（独爱HTML+CSS来构建用户界面的）Android很早入门的新手。 项目用到了XXPermissions中的权限列表、国产手机权限设置页面跳转列表，借鉴了其中的权限结果onRequestPermissionsResult的接收方式。 Gi.
XXPermissions:Android 权限请求框架，已适配 Android 11
05-12
权限请求框架 码云地址： 博文地址： 点击此处 进行演示或者测试 另外想对 Android 6.0 权限需要深入了解的，可以看这篇文章 集成步骤 在项目根目录下的 build.gradle 文件中加入 buildscript { ...... } allprojects { repositories { // JitPack 远程仓库：https://jitpack.io maven { url 'https://jitpack.io' } } } 在项目 app 模块下的 build.gradle 文件中加入 android { // 支持 JDK 1.8 compileOptions { targetCompatibility JavaVersion.VERSION_1_8 sou
Android基于注解的6.0权限动态请求框架详解
08-27
JPermission是一个轻量级的框架，它利用了AspectJ库实现面向切面编程（AOP），允许开发者通过在方法上添加注解来请求权限。以下是对这个框架的详细介绍： 1. **注解使用**： - 在需要请求权限的方法上添加`@...
AOP面向切面编程之AspectJ实现权限申请框架
qq_41672484的博客
03-18 274
一、AOP简介 1.1 AOP是啥 AOP(Aspect Oriented Programming)：面向切面编程。 1.2 如何运作的 将业务逻辑中与类不相关的通用功能切面式的提取分离出来，让多个类共享一个行为，一旦这个行为发生改变，不必修改类，而只需要修改这个行为即可。 1.3 优缺点 相较于传统的OOP（面向对象编程）技术性能更优。 二、AspectJ 2.1 简介 AspectJ是一个实现了AOP的框架，它扩展了Java语言。AspectJ定义了AOP语法，它有一个专门的编译器用来生成遵守Java
Android 采用AOP方式封装6.0权限管理的方法
01-20
AspectJ作为AOP的一种实现，提供Pointcut（切点表达式）定义注入点，Advice（通知）控制何时和如何插入代码，以及Aspect（切面）将切点和通知结合。\n\n以下是一个简化的流程示意图：\n\n在这个模型中，AOP解析注解...
permissionDemo.zip
12-31
AspectJ是一种面向切面编程（AOP）的工具，它允许开发者将关注点分离，比如日志、事务管理或如本例中的权限处理，从核心业务逻辑中抽离出来。通过在代码中添加注解，AspectJ可以在编译时或者运行时自动插入相应的...
Android-Jet-AOP一个AndroidAOP框架
08-13
Android-Jet-AOP便是一个专为Android平台设计的AOP框架，它借助注解和AspectJ技术，使得在Android应用中实现AOP变得简单易行。 ### 一、面向切面编程（AOP） AOP的核心理念是将程序中的关注点分离，关注点可以理解...
Android 动态权限 申请 检测处理框架
07-30
一个十分简单的权限工具类。只需一个方法，便可以实现权限的授权，不同版本的兼容，以及回调的正确处理了。 对原有项目尽可能小的改动，方便已有项目的接入。使用方法示例如下： /*需要动态请求相机权限*/ GPermisson.with(mContext).permisson(GPermisson.GROP_CAMERA.permissions).callback(new PermissionCallback() { @Override public void onPermissionGranted() { //授权访问 } @Override public void onPermissionReject(ArrayList rejects, ArrayList rationals) { if (rejects.size() > 0) { //用户拒绝授权，需要去设置里面重新打开才能使用 } else { //这里拒绝了授权但是没有选择每次都拒绝，需要告知用户不授权没法使用该功能 } } }).request();
Android AOP框架AspectJ使用详解
08-28
本篇文章主要介绍了Android AOP框架AspectJ使用详解，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
android权限获取框架,Android 6.0权限申请框架
weixin_39671374的博客
06-02 314
Android 6.0权限申请框架最新版本请查看GitHuballprojects {repositories {...maven { url 'https://jitpack.io' }}}dependencies {compile 'com.github.Thor-jelly:MyPermission:v1.0.1'}Android 6.0权限申请框架搭建有不足之处请联系745661590@q...
Android 权限申请框架介绍
09-03 1592
step1: 在app工程 配置如下代码 implementation 'pub.devrel:easypermissions:2.0.0' step2: 在Activity 中 implements EasyPermissions.PermissionCallbacks 中重写下面两个方法 @Override public void onPermissionsGranted(int requestCode, List<String> perms) { } @Overrid.
Android动态权限申请框架
h461415832的博客
11-19 1391
XmPermissions 项目介绍 Android动态权限申请框架 Github地址：https://github.com/lhm0603/XmPermissionsProject 使用说明 XmPermissions 支持 Android 5.0及更高版本，在 Android6.0之前的权限申请默认直接允许。 开始使用 引入 XmPermissions 使用 Android Studio 或者其他 Gradle 构建项目 dependencies { //其他依赖 implementation
android 申请权限 好用框架
最新发布
qq_23911165的博客
08-24 144
下面是java kotlin用法。
Android 权限请求
郭宝的博客
04-24 420
注意事项： 1、在通过代码动态请求之前，必须先在AndroidManifest.xml 中静态请求，否则并不会出现请求对话框请求权限
AOP框架AspectJ的使用（Android）
u010375903的博客
07-21 518
Table of Contents     AOP框架AspectJ的使用（Android） 一、什么是AOP 二、AspectJ 三、在Android项目中使用AspectJ 3.1 配置AspectJ 3.2 自定义注解 3.3 用@Aspect标注切面 3.4 在切面类中定义PointCut（切入点） 3.5 在切面类中定义Advance(通知) 3.6 对方法使用该...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值