RxPermisson2 用法翻译

最新推荐文章于 2022-05-17 15:47:31 发布

瑞逸

最新推荐文章于 2022-05-17 15:47:31 发布

阅读量468

点赞数

分类专栏： android_实战文章标签： android rxpermission

本文链接：https://blog.csdn.net/rui_yi/article/details/79636762

版权

android_实战专栏收录该内容

20 篇文章 0 订阅

订阅专栏

To use this library your minSdkVersion must be >= 11. （最低版本>=11）

dependencies {
    compile 'com.tbruyelle.rxpermissions2:rxpermissions:0.9.5@aar'
}

Usage

Create a RxPermissions instance : (创建一个PxPermissions 实体)

RxPermissions rxPermissions = new RxPermissions(this); // where this is an Activity instance （this 是一个activity实体）

Example : request the CAMERA permission (with Retrolambda for brevity, but not required)

// 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.

You can use JakeWharton/RxBinding to turn your view to an observable (not included in the library).

Example :

// Must be done during an initialization phase like onCreate  (声明时机必须像onCreate)
RxView.clicks(findViewById(R.id.enableCamera))
    .compose(rxPermissions.ensure(Manifest.permission.CAMERA))
    .subscribe(granted -> {
        // R.id.enableCamera has been clicked
    });

If multiple permissions at the same time, the result is combined : （如果多个权限，得到的结果是合并的）

rxPermissions
    .request(Manifest.permission.CAMERA,
             Manifest.permission.READ_PHONE_STATE)
    .subscribe(granted -> {
        if (granted) {
           // All requested permissions are granted （所有权限都得到授权）
        } else {
           // At least one permission is denied （至少存在一个拒绝）
        }
    });

You can also observe a detailed result with requestEach or ensureEach : （可以使用requestEach或者ensureEach 得到详细结果）

rxPermissions
    .requestEach(Manifest.permission.CAMERA,
             Manifest.permission.READ_PHONE_STATE)
    .subscribe(permission -> { // will emit 2 Permission objects （会发射两个结果）
        if (permission.granted) {
           // `permission.name` is granted ! （.name 得到权限名称， 得到授权）
        } else if (permission.shouldShowRequestPermissionRationale) {
           // Denied permission without ask never again （拒绝授权，未勾选不再询问）
        } else {
           // Denied permission with ask never again （拒绝授权， 勾选不再询问）
           // Need to go to the settings （需求去设置开启）
        }
    });

You can also get combined detailed result with requestEachCombined or ensureEachCombined : (可以使用requestEachCombined 或者 ensureEachCombined 得到合并后的详细结果

rxPermissions
    .requestEachCombined(Manifest.permission.CAMERA,
             Manifest.permission.READ_PHONE_STATE)
    .subscribe(permission -> { // will emit 1 Permission object （仅仅发送一个结果）
        if (permission.granted) {
           // All permissions are granted ! （都得到授权）
        } else if (permission.shouldShowRequestPermissionRationale)
           // At least one denied permission without ask never again （至少一个未得到授权 并 都未勾选不再询问）
        } else {
           // At least one denied permission with ask never again （至少存在一个 未得到授权，并勾选不再询问）
           // Need to go to the settings （需要去设置开启）
        }
    });

todo : 如果requestEachCombined  拒绝,permission是否可以明确指出是具体哪个permission，待求证

求证结果，多个权限请求时，合并一个结果时源码

 public Permission(List<Permission> permissions) { permission 是请求权限集，仅仅检查后更新其granted,showldShowRequestPermissonR..属性
        this.name = this.combineName(permissions);
        this.granted = this.combineGranted(permissions).booleanValue();
        this.shouldShowRequestPermissionRationale = this.combineShouldShowRequestPermissionRationale(permissions).booleanValue();
    }

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

            }
        }).blockingGet()).toString();
    }

    private Boolean combineGranted(List<Permission> permissions) {
        return (Boolean)Observable.fromIterable(permissions).all(new Predicate<Permission>() {
            public boolean test(Permission permission) throws Exception {
                return permission.granted;
            }
        }).blockingGet();
    }

    private Boolean combineShouldShowRequestPermissionRationale(List<Permission> permissions) {
        return (Boolean)Observable.fromIterable(permissions).any(new Predicate<Permission>() {
            public boolean test(Permission permission) throws Exception {
                return permission.shouldShowRequestPermissionRationale;
            }
        }).blockingGet();
    }