彻底搞懂Android权限请求：RxPermissionsFragment如何优雅处理运行时权限-优快云博客

彻底搞懂Android权限请求：RxPermissionsFragment如何优雅处理运行时权限

【免费下载链接】RxPermissions Android runtime permissions powered by RxJava2 项目地址: https://gitcode.com/gh_mirrors/rx/RxPermissions

你是否还在为Android运行时权限(Runtime Permissions)的复杂逻辑而头疼？是否曾因权限请求代码与业务逻辑纠缠不清而难以维护？本文将深入解析RxPermissions框架的核心组件RxPermissionsFragment，带你了解它如何借助RxJava2的强大能力，将繁琐的权限请求流程转化为简洁优雅的响应式代码。读完本文，你将能够：掌握RxPermissionsFragment的工作原理、理解权限请求的完整生命周期、学会在实际项目中高效使用RxPermissions处理复杂权限场景。

组件定位与核心功能

RxPermissions是一个基于RxJava2的Android运行时权限处理库，其核心设计思想是将权限请求过程转化为可观察的数据流(Observable)，从而实现异步非阻塞的权限管理。在这个框架中，RxPermissionsFragment扮演着至关重要的角色，它是连接Android系统权限API与RxJava响应式编程模型的桥梁。

主要职责

RxPermissionsFragment的核心职责包括：

托管权限请求的生命周期，确保配置变更(如屏幕旋转)时不会丢失权限请求状态
处理Android系统权限回调(onRequestPermissionsResult)
维护权限请求与响应的映射关系
将权限请求结果转换为RxJava的事件流

该组件的源代码位于lib/src/main/java/com/tbruyelle/rxpermissions3/RxPermissionsFragment.java，是整个权限处理逻辑的实际执行者。

与其他组件的关系

RxPermissions框架采用了典型的委托模式，主要包含三个核心类：

RxPermissions: 对外暴露的API入口，提供权限请求的各种方法
RxPermissionsFragment: 实际处理权限请求的组件，隐藏系统API细节
Permission: 封装权限请求结果的数据模型

它们之间的关系可以用以下UML类图表示：

mermaid

RxPermissions作为对外接口，内部持有一个RxPermissionsFragment的延迟加载实例。当调用权限请求方法时，实际的权限请求操作会委托给RxPermissionsFragment执行，后者处理完权限请求后，通过RxJava的PublishSubject将结果发送出去。

初始化与生命周期管理

RxPermissionsFragment的初始化过程巧妙地利用了Android Fragment的特性，确保了权限请求的稳定性和生命周期安全。让我们通过源码来深入了解这一过程。

延迟初始化机制

在RxPermissions的构造函数中，通过getLazySingleton方法创建了一个Lazy类型的RxPermissionsFragment实例：

@NonNull
private Lazy<RxPermissionsFragment> getLazySingleton(@NonNull final FragmentManager fragmentManager) {
    return new Lazy<RxPermissionsFragment>() {
        private RxPermissionsFragment rxPermissionsFragment;
        
        @Override
        public synchronized RxPermissionsFragment get() {
            if (rxPermissionsFragment == null) {
                rxPermissionsFragment = getRxPermissionsFragment(fragmentManager);
            }
            return rxPermissionsFragment;
        }
    };
}

这种延迟初始化(Lazy Initialization)策略确保了RxPermissionsFragment只在真正需要时才会被创建，避免了不必要的资源消耗。同时，通过synchronized关键字保证了线程安全，防止在多线程环境下创建多个实例。

Fragment的添加与管理

getRxPermissionsFragment方法负责查找或创建RxPermissionsFragment实例：

private RxPermissionsFragment getRxPermissionsFragment(@NonNull final FragmentManager fragmentManager) {
    RxPermissionsFragment rxPermissionsFragment = findRxPermissionsFragment(fragmentManager);
    boolean isNewInstance = rxPermissionsFragment == null;
    if (isNewInstance) {
        rxPermissionsFragment = new RxPermissionsFragment();
        fragmentManager
            .beginTransaction()
            .add(rxPermissionsFragment, TAG)
            .commitNow();
    }
    return rxPermissionsFragment;
}

这里有几个关键实现细节值得注意：

使用特定TAG("RxPermissions")查找已存在的Fragment实例，避免重复创建
采用add而非replace方法添加Fragment，确保Fragment不会被意外移除
使用commitNow()而非commit()方法，确保Fragment立即被添加并初始化

最重要的是，RxPermissionsFragment在其onCreate方法中设置了setRetainInstance(true)：

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setRetainInstance(true);
}

这个设置保证了当宿主Activity因配置变更(如屏幕旋转)重建时，RxPermissionsFragment实例不会被销毁，而是会被保留并重新附加到新的Activity实例上。这一特性对于维护权限请求的状态至关重要，避免了配置变更导致权限请求丢失的问题。

与Activity生命周期的关联

RxPermissionsFragment通过getActivity()方法获取宿主Activity，并在需要检查权限状态时使用：

@TargetApi(Build.VERSION_CODES.M)
boolean isGranted(String permission) {
    final FragmentActivity fragmentActivity = getActivity();
    if (fragmentActivity == null) {
        throw new IllegalStateException("This fragment must be attached to an activity.");
    }
    return fragmentActivity.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED;
}

这里有一个重要的状态检查：如果fragmentActivity为null，会抛出IllegalStateException异常。这提醒我们，在使用RxPermissions时，必须确保在Activity或Fragment的生命周期内调用相关方法，避免在脱离Activity上下文的环境中使用。

权限请求的完整流程

RxPermissionsFragment处理权限请求的完整流程可以分为四个阶段：请求发起、系统交互、结果处理和事件分发。每个阶段都有其独特的实现细节和设计考量。

请求发起阶段

当调用RxPermissions的request或ensure方法时，最终会进入requestImplementation方法：

@TargetApi(Build.VERSION_CODES.M)
private Observable<Permission> requestImplementation(final String... permissions) {
    List<Observable<Permission>> list = new ArrayList<>(permissions.length);
    List<String> unrequestedPermissions = new ArrayList<>();
    
    for (String permission : permissions) {
        if (isGranted(permission)) {
            // 已授予权限，直接返回 granted 结果
            list.add(Observable.just(new Permission(permission, true, false)));
            continue;
        }
        
        if (isRevoked(permission)) {
            // 被策略撤销的权限，返回 denied 结果
            list.add(Observable.just(new Permission(permission, false, false)));
            continue;
        }
        
        PublishSubject<Permission> subject = mRxPermissionsFragment.get().getSubjectByPermission(permission);
        if (subject == null) {
            // 新的权限请求，创建 subject 并加入待请求列表
            unrequestedPermissions.add(permission);
            subject = PublishSubject.create();
            mRxPermissionsFragment.get().setSubjectForPermission(permission, subject);
        }
        list.add(subject);
    }
    
    if (!unrequestedPermissions.isEmpty()) {
        String[] unrequestedPermissionsArray = unrequestedPermissions.toArray(new String[0]);
        requestPermissionsFromFragment(unrequestedPermissionsArray);
    }
    return Observable.concat(Observable.fromIterable(list));
}

这段代码展示了RxPermissions的智能请求机制：

权限状态检查：对于已授予的权限，直接发送granted=true的Permission对象
权限撤销检查：对于被系统策略撤销的权限，直接发送granted=false的Permission对象
新权限请求：对于需要请求的权限，创建PublishSubject并存储，等待结果返回

这种设计确保了只有真正需要用户交互的权限才会发起系统请求，减少了不必要的用户交互。

系统交互阶段

当确定需要向用户请求权限后，RxPermissionsFragment会调用requestPermissions方法：

@TargetApi(Build.VERSION_CODES.M)
void requestPermissions(@NonNull String[] permissions) {
    requestPermissions(permissions, PERMISSIONS_REQUEST_CODE);
}

这会触发Android系统的权限请求对话框，等待用户做出选择。这里使用了固定的请求码PERMISSIONS_REQUEST_CODE=42，因为RxPermissionsFragment是专门用于处理权限请求的，不需要区分多个不同的请求。

结果处理阶段

用户做出选择后，系统会调用Fragment的onRequestPermissionsResult方法：

@TargetApi(Build.VERSION_CODES.M)
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    
    if (requestCode != PERMISSIONS_REQUEST_CODE) return;
    
    boolean[] shouldShowRequestPermissionRationale = new boolean[permissions.length];
    for (int i = 0; i < permissions.length; i++) {
        shouldShowRequestPermissionRationale[i] = shouldShowRequestPermissionRationale(permissions[i]);
    }
    
    onRequestPermissionsResult(permissions, grantResults, shouldShowRequestPermissionRationale);
}

在这个方法中，RxPermissionsFragment首先检查请求码，确保只处理自己发起的权限请求。然后调用shouldShowRequestPermissionRationale方法获取是否需要向用户解释权限用途的标志，最后将完整的权限结果传递给另一个重载的onRequestPermissionsResult方法进行处理。

事件分发阶段

最终的权限结果处理在onRequestPermissionsResult方法中完成：

void onRequestPermissionsResult(String[] permissions, int[] grantResults, boolean[] shouldShowRequestPermissionRationale) {
    for (int i = 0, size = permissions.length; i < size; i++) {
        log("onRequestPermissionsResult  " + permissions[i]);
        // 查找对应的 subject
        PublishSubject<Permission> subject = mSubjects.get(permissions[i]);
        if (subject == null) {
            Log.e(RxPermissions.TAG, "未找到对应的权限请求");
            return;
        }
        mSubjects.remove(permissions[i]);
        boolean granted = grantResults[i] == PackageManager.PERMISSION_GRANTED;
        // 发送结果并完成
        subject.onNext(new Permission(permissions[i], granted, shouldShowRequestPermissionRationale[i]));
        subject.onComplete();
    }
}

这里的逻辑非常清晰：

遍历所有权限结果
查找之前创建的PublishSubject
从缓存中移除该subject(清理资源)
创建Permission对象并发送(onNext)
标记事件流完成(onComplete)

通过这种方式，RxPermissionsFragment将Android系统的回调式API转换为了RxJava的响应式数据流，使得权限请求结果可以像其他数据流一样被订阅和处理。

实际应用与最佳实践

了解了RxPermissionsFragment的工作原理后，让我们看看如何在实际项目中应用这些知识来处理各种权限场景。RxPermissions提供了灵活的API，可以满足不同复杂度的权限需求。

基本权限请求

最常见的场景是请求单个或多个权限，并根据是否全部授予来决定后续操作。使用RxPermissions可以这样实现：

RxPermissions rxPermissions = new RxPermissions(this);

// 请求相机权限
rxPermissions.request(Manifest.permission.CAMERA)
    .subscribe(granted -> {
        if (granted) {
            // 权限已授予，打开相机
            openCamera();
        } else {
            // 权限被拒绝，显示提示
            showPermissionDeniedTip();
        }
    });

这段代码展示了RxPermissions的基本用法：创建RxPermissions实例，调用request方法，然后订阅结果。这种方式适用于简单场景，但在实际项目中，我们通常需要更精细的控制。

分别处理多个权限

当请求多个权限时，有时需要知道每个权限的具体授予情况。这时可以使用requestEach方法：

rxPermissions.requestEach(
    Manifest.permission.CAMERA,
    Manifest.permission.READ_EXTERNAL_STORAGE,
    Manifest.permission.WRITE_EXTERNAL_STORAGE
)
.subscribe(permission -> {
    if (permission.granted) {
        // 某个权限被授予
        Log.d("Permission", permission.name + " granted");
    } else if (permission.shouldShowRequestPermissionRationale) {
        // 用户拒绝了权限，但未勾选"不再询问"
        showRationaleDialog(permission.name);
    } else {
        // 用户拒绝并勾选了"不再询问"，需要引导用户到设置页面
        showGoToSettingsTip(permission.name);
    }
});

这种方式可以分别处理每个权限的不同状态，提供更友好的用户体验。Permission类的三个属性name、granted和shouldShowRequestPermissionRationale提供了完整的权限状态信息。

与业务逻辑分离

RxPermissions的一大优势是可以通过compose操作符将权限请求逻辑与业务逻辑分离：

// 定义一个获取用户信息的Observable
Observable<UserInfo> getUserInfoObservable() {
    return Observable.create(emitter -> {
        // 执行网络请求获取用户信息
        UserInfo userInfo = apiService.getUserInfo();
        emitter.onNext(userInfo);
        emitter.onComplete();
    });
}

// 使用compose操作符结合权限请求
getUserInfoObservable()
    .compose(rxPermissions.ensure(Manifest.permission.INTERNET))
    .subscribe(userInfo -> {
        // 成功获取用户信息
        updateUI(userInfo);
    }, error -> {
        // 处理错误
        handleError(error);
    });

通过这种方式，业务逻辑(getUserInfoObservable)不需要知道权限请求的细节，实现了关注点分离，使代码更加清晰和可维护。

结合UI事件

在实际应用中，权限请求通常由用户操作触发，如点击按钮。RxPermissions可以很自然地与UI事件结合：

// RxBinding库将View的点击事件转换为Observable
RxView.clicks(findViewById(R.id.btn_take_photo))
    .compose(rxPermissions.ensure(Manifest.permission.CAMERA))
    .subscribe(granted -> {
        if (granted) {
            // 用户点击按钮且权限已授予，打开相机
            openCamera();
        }
    });

这种方式将点击事件、权限请求和业务逻辑串联起来，形成一个完整的响应式链条，代码简洁而富有表现力。

权限请求流程优化

基于对RxPermissionsFragment工作原理的理解，我们可以总结出以下权限请求的最佳实践：

权限分组请求：按照功能模块分组请求权限，避免一次性请求过多权限
合理的权限解释：当shouldShowRequestPermissionRationale为true时，向用户解释为什么需要该权限
优雅处理拒绝场景：对于必须的权限，引导用户到设置页面开启
避免重复请求：利用RxPermissions的缓存机制，避免对同一权限的重复请求
及时取消订阅：在Activity/Fragment的onDestroy中取消订阅，避免内存泄漏

遵循这些最佳实践，可以显著提升应用的用户体验和稳定性。

总结与进阶

RxPermissionsFragment通过巧妙的设计，将Android复杂的运行时权限请求转化为简洁的响应式编程模型。它的核心价值在于：

生命周期管理：利用Fragment的特性确保权限请求在配置变更时不丢失
响应式转换：将系统回调API转换为RxJava事件流，简化异步处理
状态缓存：智能管理权限状态，避免不必要的用户交互
结果封装：提供完整的权限状态信息，便于精细控制

通过深入理解RxPermissionsFragment的工作机制，我们不仅能够更好地使用RxPermissions库，还能从中学习到如何将Android系统API与响应式编程模型相结合的设计思想。

对于希望进一步深入的开发者，可以研究以下进阶主题：

源码解析：深入阅读RxPermissions.java和RxPermissionsFragment.java的完整实现
测试策略：学习如何测试权限请求逻辑，可参考项目中的RxPermissionsTest.java
自定义扩展：基于RxPermissions的设计思想，实现适合特定业务需求的权限管理组件

RxPermissions框架虽然小巧，但其中蕴含的设计智慧值得我们借鉴。它展示了如何通过合理的架构设计，将复杂的系统API封装成易用、优雅且健壮的库，这正是优秀开源项目的价值所在。

最后，建议通过项目的sample模块查看完整的示例代码，实际运行并调试，以加深对RxPermissions工作原理的理解。掌握了RxPermissions，你将能够轻松应对Android权限管理的各种挑战，编写出更加健壮和用户友好的应用。

【免费下载链接】RxPermissions Android runtime permissions powered by RxJava2 项目地址: https://gitcode.com/gh_mirrors/rx/RxPermissions

创作声明：本文部分内容由AI辅助生成（AIGC），仅供参考