Markdown版本笔记
我的GitHub首页
我的博客
我的微信
我的邮箱
bqt20094
RxJava RxPermissions 动态权限 简介 原理 案例 MD
GitHub
Demo地址
目录
目录
基本使用步骤
注意事项和优点
API
测试案例
原理
构造方法
request 方法
申请权限的方法
申请结果回调方法
基本使用步骤
RxPermissions是基于 RxJava 开发的用于帮助在 Android 6.0 中处理运行时权限检测的框架。
1、配置
allprojects {
repositories {
maven { url 'https://jitpack.io' }
}
}
implementation 'com.github.tbruyelle:rxpermissions:0.10.2'
2、创建 RxPermissions 实例
final RxPermissions rxPermissions = new RxPermissions(this); // where this is an Activity or Fragment instance
注意：this 参数可以是 FragmentActivity 或 Fragment。如果你在 fragment 中使用 RxPermissions，你应该传递 fragment 实例作为构造函数参数而不是 fragment.getActivity()，否则你可能抛出异常 java.lang.IllegalStateException: FragmentManager is already executing[执行]
3、请求权限，必须在初始化阶段比如 onCreate 中调用
// Must be done during an initialization phase like onCreate
rxPermissions.request(Manifest.permission.CAMERA)
.subscribe(granted -> {
if (granted) { // Always true pre-M
// I can control the camera now
} else {
// Oups permission denied
}
});
If you need to trigger触发 the permission request from a specific event特定事件, you need to setup your event as an observable inside an initialization phase初始化阶段.
RxView.clicks(view)
.compose(new RxPermissions(this).ensure(Manifest.permission.CAMERA))
.subscribe(granted -> Toast.makeText(this, granted ? "已赋予权限" : "已拒绝权限", Toast.LENGTH_SHORT).show());
注意事项和优点
注意：
如上所述，由于您的应用程序可能在权限请求期间重新启动，因此请求必须在初始化阶段完成。这可能是 Activity.onCreate 或View.onFinishInflate，但不能在 onResume 等 pausing 方法中，因为由于您请求的 activity 在权限请求期间被框架暂停了，因此您可能会创建一个无限的请求循环。
如果没有，并且如果您的应用程序在权限请求期间重新启动了（例如，由于配置更改），则用户的响应将永远不会发送给订阅者。
你可以在这里找到更多相关细节。
优点
- 不需要担心框架的版本。 如果sdk是 pre-M，则观察者将自动接收授予的结果。
- 您不需要拆分权限请求和结果处理之间的代码。目前，如果没有这个库，你必须在一个地方请求权限，并在 Activity.onRequestPermissionsResult() 中处理结果。
- 所有RX提供的转换、过滤、链接[transformation, filter, chaining]......
API
构造方法
RxPermissions(FragmentActivity activity) //不可以是普通 Activity ，因为他的原理是通过 FragmentManager 操作 Fragment 实现的
RxPermissions(Fragment fragment)
请求权限
Observable<Boolean> request(String... permissions)
<T> ObservableTransformer<T, Boolean> ensure(final String... permissions) //与 compose 操作符一起使用
观察详细的结果
Observable<Permission> requestEach(String... permissions) //申请了多少个权限就回调多少次，相当于 flatMap 的效果
Observable<Permission> requestEachCombined(String... permissions) //只回调一次，回调对象的的属性值是多个原始对象的组合值
<T> ObservableTransformer<T, Permission> ensureEach(final String... permissions)
<T> ObservableTransformer<T, Permission> ensureEachCombined(final String... permissions)
其他方法
boolean isGranted(String permission) //是否已赋予权限
void setLogging(boolean logging)
Observable<Boolean> shouldShowRequestPermissionRationale(Activity activity, String... permissions)
测试案例
入口Activity
public class RxPermissionsActivity extends ListActivity {
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
String[] array = {"最简单实用的案例，request",
"和 RxView 一起使用，compose + ensure",
"一次请求多个权限",
"观察详细的结果，requestEach、ensureEach",
"观察详细的结果，requestEachCombined 和 ensureEachCombined",
"shouldShowRequestPermissionRationale 和 isGranted 的使用 ",};
setListAdapter(new ArrayAdapter<>(this, android.R.layout.simple_list_item_1, Arrays.asList(array)));
}
@Override
protected void onListItemClick(ListView l, View v, int position, long id) {
Intent intent = new Intent(this, RxPermissionsFragmentActivity.class);
intent.putExtra("type", position);
startActivity(intent);
}
}
FragmentActivity
public class RxPermissionsFragmentActivity extends FragmentActivity {
private TextView view;
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
view = new TextView(this);
view.setBackgroundColor(0xff00ff00);
setContentView(view);
int type = getIntent().getIntExtra("type", 0);
init(type);
}
private void init(int type) {
switch (type) {
case 0:
new RxPermissions(this)
.request(Manifest.permission.WRITE_EXTERNAL_STORAGE)
.subscribe(granted -> {
if (granted) { //在 Android M(6.0) 之前始终为true
Toast.makeText(this, "已赋予权限", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(this, "已拒绝权限", Toast.LENGTH_SHORT).show();
}
});
break;
case 1:
RxView.clicks(view)
.compose(new RxPermissions(this).ensure(Manifest.permission.CAMERA))
.subscribe(granted -> Toast.makeText(this, granted ? "已赋予权限" : "已拒绝权限", Toast.LENGTH_SHORT).show());
break;
case 2:
new RxPermissions(this)
.request(Manifest.permission.CALL_PHONE, Manifest.permission.SEND_SMS)//只有所有权限都赋予了才会回调成功
.subscribe(granted -> Toast.makeText(this, granted ? "已赋予权限" : "已拒绝权限", Toast.LENGTH_SHORT).show());
RxView.clicks(view)
.compose(new RxPermissions(this).ensure(Manifest.permission.CALL_PHONE, Manifest.permission.SEND_SMS))
.subscribe(granted -> Toast.makeText(this, granted ? "已赋予权限" : "已拒绝权限", Toast.LENGTH_SHORT).show());
break;
case 3:
RxView.clicks(view)
.compose(new RxPermissions(this).ensureEach(Manifest.permission.CALL_PHONE, Manifest.permission.SEND_SMS))
.subscribe(permission -> {//申请了多少个权限就回调多少次，相当于 flatMap 的效果
if (permission.granted) {
Toast.makeText(this, "已赋予权限：" + permission.name, Toast.LENGTH_SHORT).show();
} else if (permission.shouldShowRequestPermissionRationale) { //拒绝了权限，但是没有勾选"ask never again"
Toast.makeText(this, "已拒绝权限：" + permission.name + " ，但可以继续申请", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(this, "已拒绝权限：" + permission.name + " ，并且不会再显示", Toast.LENGTH_SHORT).show();
}
});
break;
case 4:
RxView.clicks(view)
.compose(new RxPermissions(this).ensureEachCombined(Manifest.permission.CALL_PHONE, Manifest.permission.SEND_SMS))
.subscribe(permission -> {//只回调一次，回调的 permission 的属性值是多个原始 permission 的组合值
if (permission.granted) {
Toast.makeText(this, "已赋予全部所需的权限：" + permission.name, Toast.LENGTH_SHORT).show();
} else if (permission.shouldShowRequestPermissionRationale) { //拒绝了权限，但是没有勾选"ask never again"
Toast.makeText(this, "有权限被拒绝：" + permission.name + " ，但可以继续申请", Toast.LENGTH_SHORT).show();
} else {
Toast.makeText(this, "有权限被拒绝：" + permission.name + " ，并且不会再显示", Toast.LENGTH_SHORT).show();
}
});
break;
case 5:
boolean isGranted = new RxPermissions(this).isGranted(Manifest.permission.CAMERA);
Toast.makeText(this, "是否已赋予权限：" + isGranted, Toast.LENGTH_SHORT).show();
new RxPermissions(this)
.shouldShowRequestPermissionRationale(this, Manifest.permission.CALL_PHONE, Manifest.permission.SEND_SMS)
.subscribe(granted -> Toast.makeText(this, granted ? "全部权限已授权，或有权限被拒绝但可以继续申请" :
"有权限被拒绝，并且不会再显示", Toast.LENGTH_SHORT).show());
break;
default:
break;
}
}
}
原理
RxPermissions 就包含4个类，很明显 BuildConfig 与原理没任何关系，所以真正有用的是 Permission、RxPermissions、RxPermissionsFragment这三个：
Permission 是定义权限的 model类，用来存放权限名称以及是否获取权限的信息：
public class Permission {
public final String name;
public final boolean granted;
public final boolean shouldShowRequestPermissionRationale;
}
RxPermissions 就是最主要的类了，我们根据一个基本使用案例分析一下调用流程：
new RxPermissions(this)
.request(Manifest.permission.CALL_PHONE, Manifest.permission.SEND_SMS)//只有所有权限都赋予了才会回调成功
.subscribe(granted -> Toast.makeText(this, granted ? "已赋予权限" : "已拒绝权限", Toast.LENGTH_SHORT).show());
构造方法
首先看构造方法的具体逻辑：
public RxPermissions(@NonNull FragmentActivity activity) {
this.mRxPermissionsFragment = this.getLazySingleton(activity.getSupportFragmentManager());
}
public RxPermissions(@NonNull Fragment fragment) {
this.mRxPermissionsFragment = this.getLazySingleton(fragment.getChildFragmentManager());
}
在构造方法中初始化了成员 RxPermissionsFragment：
@NonNull
private RxPermissions.Lazy<RxPermissionsFragment> getLazySingleton(@NonNull final FragmentManager fragmentManager) {
return new RxPermissions.Lazy<RxPermissionsFragment>() {
private RxPermissionsFragment rxPermissionsFragment;
public synchronized RxPermissionsFragment get() {
if (this.rxPermissionsFragment == null) this.rxPermissionsFragment = RxPermissions.this.getRxPermissionsFragment(fragmentManager);
return this.rxPermissionsFragment;
}
};
}
可以看到，其维护的是一个单例，如果已经存在则直接返回，否则通过 getRxPermissionsFragment 方法获取：
static final String TAG = RxPermissions.class.getSimpleName();
private RxPermissionsFragment getRxPermissionsFragment(@NonNull FragmentManager fragmentManager) {
RxPermissionsFragment rxPermissionsFragment = this.findRxPermissionsFragment(fragmentManager);
boolean isNewInstance = rxPermissionsFragment == null;
if (isNewInstance) {
rxPermissionsFragment = new RxPermissionsFragment();
fragmentManager.beginTransaction().add(rxPermissionsFragment, TAG).commitNow();
}
return rxPermissionsFragment;
}
里面的逻辑很简单，如果已经存在则直接返回，否则如果是新创建的，则通过 FragmentManager 将其 add 到当前 FragmentActivity 或 Fragment 中。
判断是否已存在的逻辑同样是通过 FragmentManager 来判断的：
private RxPermissionsFragment findRxPermissionsFragment(@NonNull FragmentManager fragmentManager) {
return (RxPermissionsFragment)fragmentManager.findFragmentByTag(TAG);
}
request 方法
再看看请求权限的具体逻辑：
public Observable<Boolean> request(String... permissions) {
return Observable.just(TRIGGER).compose(this.ensure(permissions)); //【static final Object TRIGGER = new Object();】
}
首先，利用 just 方法创建Observable对象，接下来会调用 compose 方法，compose 的参数的作用是将一个类型的 Observable 对象转换成另外一个类型的Observable对象，同时也可以对自身对象的一些重复操作进行封装，避免重复编写代码。我们看到，compose 方法中调用了我们可能用到的另一个方法 ensure ：
public <T> ObservableTransformer<T, Boolean> ensure(final String... permissions) {
return new ObservableTransformer<T, Boolean>() {
public ObservableSource<Boolean> apply(Observable<T> o) {
return RxPermissions.this
.request(o, permissions) //核心步骤
.buffer(permissions.length)
.flatMap(new Function<List<Permission>, ObservableSource<Boolean>>() { /* 转换操作 */});
}
};
}
上面代码的作用是传入一个 Observable 对象，然后转换成一个 Observable 对象，同时 ensure 方法传入了 permissions 权限申请列表，在转换开始前，需要根据 permissions 权限列表去申请权限，具体操作在 request 方法中，下面看看 request 的实现：
private Observable<Permission> request(Observable<?> trigger, final String... permissions) {
if (permissions != null && permissions.length != 0) {
return this.oneOf(trigger, this.pending(permissions)).flatMap(new Function<Object, Observable<Permission>>() {
public Observable<Permission> apply(Object o) {
return RxPermissions.this.requestImplementation(permissions); //核心步骤
}
});
} else throw new IllegalArgumentException("RxPermissions.request/requestEach requires at least one input permission");
}
通过上面代码可以看出，首先会判断申请权限列表是否为空，如果为空就会抛出异常，然后通过 oneOf 方法和 pending 方法来创建合并 Observable 对象，下面看一下这两个方法
private Observable<?> oneOf(Observable<?> trigger, Observable<?> pending) {
return trigger == null ? Observable.just(TRIGGER) : Observable.merge(trigger, pending);
}
private Observable<?> pending(String... permissions) {
String[] var2 = permissions;
int var3 = permissions.length;
for(int var4 = 0; var4 < var3; ++var4) {
String p = var2[var4];
if (!((RxPermissionsFragment)this.mRxPermissionsFragment.get()).containsByPermission(p)) {
return Observable.empty();
}
}
return Observable.just(TRIGGER);
}
private Map<String, PublishSubject<Permission>> mSubjects = new HashMap();
public boolean containsByPermission(@NonNull String permission) {
return this.mSubjects.containsKey(permission);
}
从以上的两个方法的代码可以看出，pending 主要是判断权限申请列表中是否全部都在 Fragment 中的 mSubjects 集合中：如果有一个不在集合中，则返回 Observable.empty()，如果已经全部在集合中，则返回Observable.just(TRIGGER)。然后在 oneOf 方法中根据 trigger 是否为 null 来判断是哪种返回。
这两个方法在我看来最终并没有起到实际的作用，因为具体的请求权限是在 requestImplementation(permissions) 方法中实现的，而通过以上两个方法得到的 Observable 对象最终在 flatMap 操作转换时并不会用到它们的对象，而是直接根据权限申请列表 permissions 作为参数，直接调用 requestImplementation 方法进行权限的实际请求，所以接下来主要看看 requestImplementation 方法的具体实现：
@TargetApi(23)
private Observable<Permission> requestImplementation(String... permissions) {
List<Observable<Permission>> list = new ArrayList(permissions.length); //保存所有已经处理过的权限
List<String> unrequestedPermissions = new ArrayList();//保存所有需要申请的权限
String[] unrequestedPermissionsArray = permissions;
int var5 = permissions.length;
for (int var6 = 0; var6 < var5; ++var6) { //循环权限申请列表
String permission = unrequestedPermissionsArray[var6];
((RxPermissionsFragment) this.mRxPermissionsFragment.get()).log("Requesting permission " + permission);
if (this.isGranted(permission)) {
list.add(Observable.just(new Permission(permission, true, false))); //如果权限已经具有，则直接保存到集合中
} else if (this.isRevoked(permission)) {
list.add(Observable.just(new Permission(permission, false, false))); //如果权限被拒绝，则将其作为申请被拒绝的权限保存到集合中
} else {
PublishSubject<Permission> subject = ((RxPermissionsFragment) this.mRxPermissionsFragment.get()).getSubjectByPermission(permission);
if (subject == null) { // 先查询 map 中是否已经存在了该 subject，如果还未存在，则创建一个 PublishSubject 对象，并保存起来
unrequestedPermissions.add(permission); //此为需要申请的权限
subject = PublishSubject.create();
((RxPermissionsFragment) this.mRxPermissionsFragment.get()).setSubjectForPermission(permission, subject); //保存到 map 中
}
list.add(subject);//将新创建的需要申请的权限保存到集合中
}
}
if (!unrequestedPermissions.isEmpty()) { //在循环结束之后，如果有未申请的权限，则进行权限的申请操作
unrequestedPermissionsArray = (String[]) unrequestedPermissions.toArray(new String[unrequestedPermissions.size()]);
this.requestPermissionsFromFragment(unrequestedPermissionsArray); //权限的申请操作
}
return Observable.concat(Observable.fromIterable(list));
}
上面的就是进行权限申请的具体代码，主要的操作就是定义一个集合保存保存一次申请的所有权限，无论这个权限是否已经申请，还是被撤销，还是未申请，最终都会保存到list这个集合中，这样，我们在后续的操作中，才可以进行转换。同时，定义另外一个集合，用于保存未申请的权限，然后在循环结束之后进行未申请权限的申请。
申请权限的方法
上面分析道，在遍历所有申请的权限状态结束后，调用 requestPermissionsFromFragment 进行未申请权限的申请，下面我们看一下具体流程。
@TargetApi(23)
void requestPermissionsFromFragment(String[] permissions) {
((RxPermissionsFragment)this.mRxPermissionsFragment.get()).requestPermissions(permissions);
}
其实就是调用了 RxPermissionsFragment 中的 requestPermissions 方法，所以我们进到该方法看看：
@TargetApi(23)
void requestPermissions(@NonNull String[] permissions) {
this.requestPermissions(permissions, PERMISSIONS_REQUEST_CODE);
}
可以看到，该方法并没有进行什么特别操作，就是申请权限，那么既然申请了权限了，是否申请成功的处理应该在回调中，所以我们看看回调的处理
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++) { //循环遍历，看权限是否被永久拒绝了
//调用Fragment中的**方法获取权限申请结果，如果被点击了不再在提醒，并且拒绝权限时，则会返回 false，否则返回 true
shouldShowRequestPermissionRationale[i] = this.shouldShowRequestPermissionRationale(permissions[i]);
}
// 调用 Fragment 中的调用重载方法
this.onRequestPermissionsResult(permissions, grantResults, shouldShowRequestPermissionRationale);//【核心中的核心】
}
主要是创建了一个 boolean 数组，用于保存判断权限申请的状态。如果权限被申请过，并且用户在对话框中点击了“不在提醒”选项，这个时候调用 Fragment 中的shouldShowRequestPermissionRationale 方法会返回false，代表说这个权限被拒绝，我们可以根据这个结果再给用户做一些提示性的工作。
最后看最核心的部分：onRequestPermissionsResult
@Override
void onRequestPermissionsResult(String permissions[], int[] grantResults, boolean[] shouldShowRequestPermissionRationale) {
for (int i = 0, size = permissions.length; i < size; i++) { //循环权限列表
// 查询 mSubjects 集合中是否存在代表该 permission 的 PublishSubject 对象
PublishSubject<Permission> subject = (PublishSubject)this.mSubjects.get(permissions[i]);
if (subject == null) return; // 如果没有，则直接返回
this.mSubjects.remove(permissions[i]); //将集合中的 permission 的 PublishSubject 对象进行移除
boolean granted = grantResults[i] == PackageManager.PERMISSION_GRANTED; //判断是否申请成功
subject.onNext(new Permission(permissions[i], granted, shouldShowRequestPermissionRationale[i])); //返回相应的对象
subject.onCompleted();
}
}
首先判断在 mSubjects 集合中是否已经存在了该 permission 的 PublishSubject 对象，如果没有，则直接返回，代表出错。其实这里的对象在RxPermissions 的 requestImplementation() 中已经通过 mRxPermissionsFragment.setSubjectForPermission(permission, subject) 语句进行赋值了，所以一定会是存在的。
接着 mSubjects 集合将该 permission 的 PublishSubjects 对象移除，这是为什么呢？这个要看 RxPermissions#requestImplementation() 中的实现，在该方法中会 PublishSubject<Permission> subject = mRxPermissionsFragment.getSubjectByPermission(permission); 这个语句出现，这个语句代表说，如果权限未申请过，也未被撤销，那么就直接在 RxPermissionsFragment 的 mSubjects 集合中查找是否存在该 permission 的 PublishSubject 对象，如果有，就直接通过 list.add(subject) 这个语句保存到集合中了，那么这样被拒绝的权限，下次将不会被重新申请，所以需要移除，之后就是发射数据，发送时间结束标识了。
申请结果回调方法
分析完了 RxPermissionsFragment 中的权限申请的操作，我们就需要回到 Rxpermissions#request() 方法中，在该方法的 flatMap 的回调方法中返回了 Observable 对象，因此这个方法的任务完成。
return RxPermissions.this.request(o, permissions)
.buffer(permissions.length)
.flatMap(new Function<List<Permission>, ObservableSource<Boolean>>() {...}
接着再往回看，在ensure()方法中，我们可以看到在该方法中调用了request()方法之后，接着调用了buffer(permissions.length)方法，那么这个buffer()的作用是什么呢？它的作为是为了将一个序列的 Observable 对象转换成 Observable 对象(flatMap的逆操作)。为什么要转换呢？因为 requestImplementation() 方法中的返回值为 Observable.concat(Observable.from(list))，这代表说这是一个 Observable 对象序列，所以需要通过 buffer 方法进行转换。
接着就是使用 flatMap 操作符转换成 Observable 对象：
@Override
public ObservableSource<Boolean> apply(List<Permission> permissionsx) {
...
return Observable.just(false); //我们可以根据实际需要进行自己的处理
}
}
这里就是返回给我们的最终结果了，整个流程也就到此结束。
2018-8-30
