RxPermission源码解析

RxPermission是一个Android处理权限的工具类，可以方便的和RxJava结合发起权限请求。这个库和其他权限请求工具的区别在于，可以不用处理的权限请求的结果回调onRequestPermissionsResult()方法，我们来通过源码解析来看下是如何实现的。

使用方式：

1、可以调用RxPermissions的request()方法，该方法返回一个Observable对象，代表请求权限的结果。该方法可以同时请求多个权限，当所有权限都被允许后结果为true;如果有一个权限被禁止，则回调结果为false。

    RxPermissions rxPermissions = new RxPermissions(this);
    rxPermissions.request(permission.WRITE_EXTERNAL_STORAGE, permission.CAMERA)
        .subscribe(new Consumer<Boolean>() {
            @Override
            public void accept(Boolean aBoolean) throws Exception {
                if(aBoolean){
                    //permission granted
                }
            }
        });

如果要获取请求的每个权限的结果，可以使用requestEach()方法。该方法的回调会被调用多次，回调的Permission表示每个权限请求的结果。

    rxPermissions.requestEach(Manifest.permission.WRITE_EXTERNAL_STORAGE, permission.CAMERA)
        .subscribe(new Consumer<Permission>() {
            @Override
            public void accept(Permission permission) throws Exception {
    			//check permission
            }
        });

2、一般开发中，通常是点击某个按钮后才请求权限，如果使用了RxBinding库处理UI事件，可以很方便的和RxPermissions一起进行权限请求。

    RxView.clicks(findViewById(R.id.enableCamera))
        // Ask for permissions when button is clicked
        .compose(rxPermissions.ensureEach(permission.CAMERA))
        .subscribe(new Consumer<Permission>() {
            @Override
            public void accept(Permission permission) {
                Log.i(TAG, "Permission result " + permission);
                if (permission.granted) {
    
                } 
            });

RxPermissions提供ensure(),ensureEach()和ensureEachCombined()方法，这些方法会返回一个ObservableTransformer<T, Permission>对象，结合RxJava中的compose操作符，可以将View事件转换为一个权限请求。

ensure()方法类似request()方法，结果回调的参数为Boolean类型，请求的全部权限都成功时为true，否则为false。

ensureEach()方法类似requestEach()方法，请求多个权限时，结果回调会被调用多次，可以获取到每个权限的请求结果。

ensureEachCombined()方法会结果会回调一次，回调的参数为Permission类型，这个permission参数和requestEach()的不太一样，在这个permission对象中会包含所有请求的名字，并且所有权限都成功的话，permission的granted属性会为true，否则为false。

源码解析

从RxPermissions的构造方法开始

    public RxPermissions(@NonNull final FragmentActivity activity) {
        mRxPermissionsFragment = getLazySingleton(activity.getSupportFragmentManager());
    }
    
    public RxPermissions(@NonNull final Fragment fragment) {
        mRxPermissionsFragment = getLazySingleton(fragment.getChildFragmentManager());
    }

RxPermissions针对Activity和Fragment提供了两个构造方法，最终都是获取FragmentManager再调用getLazySingleton()方法。getLazeSingleton方法的源码如下：

    @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对象，在lazy的对象的get()方法中创建了一个fragment对象并保存下来。Lazy是一个实现懒加载的工具类，在第一次调用get()方法时，会执行创建操作，并且将创建的对象保存下来。

    @FunctionalInterface
    public interface Lazy<V> {
        V get();
    }

创建RxPermissions对象后，便可以进行权限请求，先看RxPermissions的request()方法

    public Observable<Boolean> request(final String... permissions) {
        return Observable.just(TRIGGER).compose(ensure(permissions));
    }

TRIGGER是一个Object对象，用于开始请求，并且兼容RxBinding相关的操作。

     static final Object TRIGGER = new Object();

request()方法内部实际上是调用了ensure(),看下ensure()的代码

    public <T> ObservableTransformer<T, Boolean> ensure(final String... permissions) {
        return new ObservableTransformer<T, Boolean>() {
            @Override
            public ObservableSource<Boolean> apply(Observable<T> o) {
                return request(o, permissions)
                    // Transform Observable<Permission> to Observable<Boolean>
                    .buffer(permissions.length)
                    .flatMap(new Function<List<Permission>, ObservableSource<Boolean>>() {
                        @Override
                        public ObservableSource<Boolean> apply(List<Permission> permissions) {
                            if (permissions.isEmpty()) {
                                return Observable.empty();
                            }
                            for (Permission p : permissions) {
                                if (!p.granted) {
                                    return Observable.just(false);
                                }
                            }
                            return Observable.just(true);
                        }
                    });
            }
        };
    }

ensure()方法中创建了个一个RxJava中的ObservableTransformer对象，将一个泛型T类型的Observable装换成一个ObservableSource对象，ObservableSource是Observable的父类型，这个Boolean类型代表请求权限的结果。

在ObservableTransformer的apply()方法中,调用了request(final Observable<?> trigger, final String... permissions)方法，然后使用buffer操作符缓存所有的请求结果，在flatMap操作符中将结果转换为Boolean类型，如果所有的权限都授权成功则返回true,否则返回false。

在request(final Observable<?> trigger, final String... permissions)方法中有调用了requestImplementation()方法

    private Observable<Permission> requestImplementation(final String... permissions) {
        List<Observable<Permission>> list = new ArrayList<>(permissions.length);
        List<String> unrequestedPermissions = new ArrayList<>();
        
        for (String permission : permissions) {
            mRxPermissionsFragment.get().log("Requesting permission " + permission);
            if (isGranted(permission)) {
                list.add(Observable.just(new Permission(permission, true, false)));
                continue;
            }
            if (isRevoked(permission)) {
                list.add(Observable.just(new Permission(permission, false, false)));
                continue;
            }
            
            PublishSubject<Permission> subject = mRxPermissionsFragment.get().getSubjectByPermission(permission);
            // Create a new subject if not exists
            if (subject == null) {
                unrequestedPermissions.add(permission);
                subject = PublishSubject.create();
                mRxPermissionsFragment.get().setSubjectForPermission(permission, subject);
            }
            list.add(subject);
        }
        
        if (!unrequestedPermissions.isEmpty()) {
            String[] unrequestedPermissionsArray = unrequestedPermissions.toArray(new String[unrequestedPermissions.size()]);
            requestPermissionsFromFragment(unrequestedPermissionsArray);
        }
        return Observable.concat(Observable.fromIterable(list));
    }

在这个方法中，会创建两个列表，list为List<Observable>类型，包含每个权限的请求；unrequestedPermissions为List类型，表示需要发起请求的权限。

这里首先会遍历需要请求的所有权限，如果已经该权限已经被授予，则创建一个granted字段为true的Permission对象加入到list中；如果权限被撤回，则创建一个granted字段为false的Permission对象加入list中。如果该权限没有被授予也没有被撤回，就去请求权限。

具体的方式是调用RxPermissionsFragment对象的getSubjectByPermission()方法获取一个PublishSubject对象，Subject是一种既可以作为Observable也可以作为Observer的对象，集成自Observable类，并实现了Observer接口。如果获取到subject对象，表示该权限正在被请求；如果返回null，表示该权限未被请求，会创建一个新的PublishSubject对象，并调用setSubjectForPermission方法保存下来，同时将该权限保存在unrequestedPermissions列表中。

如果unrequestedPermissions不为空，表示存在需要请求的权限，会调用requestPermissionsFromFragment()去请求权限。

最后，使用fromIterable和concat操作符将结果转换为Observable类型。

接下来看requestPermissionsFromFragment()方法

    void requestPermissionsFromFragment(String[] permissions) {
        mRxPermissionsFragment.get().log("requestPermissionsFromFragment " + TextUtils.join(", ", permissions));
        mRxPermissionsFragment.get().requestPermissions(permissions);
    }

打印日志后调用的RxPermissionsFragemnt的requestPermissions方法。而RxPermissionsFragemnt的requestPermissions方法直接发起了权限请求。在RxPermissionsFragemnt的void onRequestPermissionsResult() 回调中处理请求的结果。

    void onRequestPermissionsResult(String permissions[], int[] grantResults, boolean[] shouldShowRequestPermissionRationale) {
        for (int i = 0, size = permissions.length; i < size; i++) {
            PublishSubject<Permission> subject = mSubjects.get(permissions[i]);
            if (subject == null) {
                // No subject found
                return;
            }
            mSubjects.remove(permissions[i]);
            boolean granted = grantResults[i] == PackageManager.PERMISSION_GRANTED;
            subject.onNext(new Permission(permissions[i], granted, shouldShowRequestPermissionRationale[i]));
            subject.onComplete();
        }
    }

在回调中会找到每个权限对应的subject对象，创建一个Permission对象保存权限的结果，通过subject将结果发送出去。

再回到ensure()方法，权限请求结果发射后，会这里收到回调。

    public <T> ObservableTransformer<T, Boolean> ensure(final String... permissions) {
        return new ObservableTransformer<T, Boolean>() {
            @Override
            public ObservableSource<Boolean> apply(Observable<T> o) {
                return request(o, permissions)
                    // Transform Observable<Permission> to Observable<Boolean>
                    .buffer(permissions.length)
                    .flatMap(new Function<List<Permission>, ObservableSource<Boolean>>() {
                        @Override
                        public ObservableSource<Boolean> apply(List<Permission> permissions) {
                            if (permissions.isEmpty()) {
                                return Observable.empty();
                            }
                            for (Permission p : permissions) {
                                if (!p.granted) {
                                    return Observable.just(false);
                                }
                            }
                            return Observable.just(true);
                        }
                    });
            }
        };
    }

如上所述，ensure方法会将权限的请求结果转换为Boolean类型。

同样的，与request()对应的requestEach()方法在内部会调用ensureEach()方法，我们来看下ensureEach()的实现

    public <T> ObservableTransformer<T, Permission> ensureEach(final String... permissions) {
        return new ObservableTransformer<T, Permission>() {
            @Override
            public ObservableSource<Permission> apply(Observable<T> o) {
                return request(o, permissions);
            }
        };
    }

ensureEach()同样是创建了一个ObservableTransformer对象，与ensure()不同的是将Observable转换为ObservableSource对象。在下游可以接收到每个权限的结果，并做相应的处理。

除了ensure()和ensureEach()方法外，RxPermissions还提供了一个ensureEachCombined()方法，实现如下

    public <T> ObservableTransformer<T, Permission> ensureEachCombined(final String... permissions) {
        return new ObservableTransformer<T, Permission>() {
            @Override
            public ObservableSource<Permission> apply(Observable<T> o) {
                return request(o, permissions)
                    .buffer(permissions.length)
                    .flatMap(new Function<List<Permission>, ObservableSource<Permission>>() {
                        @Override
                        public ObservableSource<Permission> apply(List<Permission> permissions) {
                            if (permissions.isEmpty()) {
                                return Observable.empty();
                            }
                            return Observable.just(new Permission(permissions));
                        }
                    });
            }
        };
    }

该方法与ensure方法类似，同样会对请求的结果进行处理，只是是将所有的结果转换为一个Permission对象，而不是一个Boolean值。Permission类有一个Permission(List permissions)构造函数，在一个Permission对象中存贮多个权限的结果

    public Permission(List<Permission> permissions) {
        name = combineName(permissions);
        granted = combineGranted(permissions);
        shouldShowRequestPermissionRationale = combineShouldShowRequestPermissionRationale(permissions);
    }

combineName()方法会多个权限的名称通过“,”连接成一个字符串；combineGranted()方法当所有权限都授予时会返回ture，否则返回false；combineShouldShowRequestPermissionRationale()方法则当任意一个权限的shouldShowRequestPermissionRationale为ture时返回ture，否则返回false。下面是combineName()的源码

    private String combineName(List<Permission> permissions) {
        return Observable.fromIterable(permissions)
            .map(new Function<Permission, String>() {
                @Override
                public String apply(Permission permission) throws Exception {
                    return permission.name;
                }
            }).collectInto(new StringBuilder(), new BiConsumer<StringBuilder, String>() {
            @Override
            public void accept(StringBuilder s, String s2) throws Exception {
                if (s.length() == 0) {
                    s.append(s2);
                } else {
                    s.append(", ").append(s2);
                }
            }
        }).blockingGet().toString();
    }

总结

RxPermissions通过在Activity添加一个fragment来请求权限和处理权限的结果，避免单独再处理onRequestPermissionsResult回调。并提供request和ensure等一系列方法，可以和RxJava,RxBinding方便的结合在一起。