項目需求討論 — 手把手帶你寫RxPermission

首先既然是Rx系列，前提是會Rxjava相關的基本知識,若是沒有Rxjava的相關知識，請補好Rxjava相關知識再來看。

關於權限申請的基礎前面也寫過相應的文章：

項目需求討論 - 動態權限申請分析及相關第三方庫源碼分析

一天，產品經理走過來掃了掃個人電腦上的支付寶收款碼，打了一筆錢給我後，跟我說了幾個需求：

1. 一天作一個視頻功能
2. 半天作一個界面
3. 四天作一個日曆控件

好比第一個任務，你以爲你是確定作不完的，咱們就直接告訴產品經理不可能，第二個能夠完成，直接給確定回覆，第三個任務你可能要評估一下，說晚點再告訴產品經理，給他答覆能不能作這個控件。

三個任務的三個答覆咱們就這麼寫：

1.創建需求的答覆對象：

public class TaskAnswer {

    private String taskName;//需求名字
    private Boolean taskResult;//需求結果

    public TaskAnswer(String taskName, Boolean taskResult) {
        this.taskName = taskName;
        this.taskResult = taskResult;
    }
    
    public String getTaskName() {
        return taskName;
    }

    public boolean isTaskResult() {
        return taskResult;
    }
}
複製代碼

2. 創建答覆的給產品經理（創建Observable）

發送答覆給產品經理：

TaskAnswer answer1 = new TaskAnswer("第一個需求",false);
TaskAnswer answer2 = new TaskAnswer("第二個需求",true);

Observable<TaskAnswer> task1 = Observable.just(answer1);
Observable<TaskAnswer> task2 = Observable.just(answer2);
PublishSubject<TaskAnswer> task3 = PublishSubject.create();
複製代碼

由於前面二個咱們是已經知道告終果，第三個咱們須要考慮晚點再經過task3.onNext(new TaskAnswer("第三個需求",(true/false)))來給產品經理答覆。

咱們知道咱們須要先走到產品經理那裏，告訴他目前三個需求的結果，不可能走過去先說第一個不行，而後回到本身位子上，而後再走過去告訴他第二個能夠，而後再回來，而後再去告訴他第三個看狀況，後面給結果。確定是一次性走過去告訴他三個需求的初步結果：

String[] taskList = {"第一個需求","第二個需求","第三個需求"};

final PublishSubject<TaskAnswer> taskPub = PublishSubject.create();

//咱們把三個需求對應的Observable放在一個List中
List<Observable<TaskAnswer>> list = new ArrayList<>();
for (String task : taskList){
    TaskAnswer answer;
    if(task.equals("第一個需求")){
        answer = new TaskAnswer(task,false);
        //由於咱們知道了第一個需求不能完成，直接立刻告訴產品經理，因此直接Observable.just就能夠
        Observable<TaskAnswer> taskOb = Observable.just(answer);
        list.add(taskOb);
        continue;
    }

    if(task.equals("第二個需求")){
        answer = new TaskAnswer(task,true);
        //由於咱們知道了第二個需求能完成，直接立刻告訴產品經理，因此直接Observable.just就能夠
        Observable<TaskAnswer> taskOb = Observable.just(answer);
        list.add(taskOb);
        continue;
    }
    
    //這是第三個需求，由於是要晚點再告訴產品經理，因此它是PublishSubject
    list.add(taskPub);
}

//咱們使用concat操做符把三個需求Observable連在一塊兒變成一個
Observable<List<TaskAnswer>> total = Observable.concat(Observable.fromIterable(list)).buffer(3);

複製代碼

3. 產品經理針對答覆作出相應處理（訂閱Observable）

咱們能夠看到，咱們已經能夠把第一次狀況反饋給了產品經理,但這裏能夠有二種狀況發生（主要看你跟產品經理關係鐵不鐵）：

1. 若是你跟產品經理的關係特別鐵，產品經理說：此次的任務是有點急，並且難度也特別大，因此你沒能按時沒完成也沒關係，咱們那時候具體一個個來看，哪幾個完成了，哪幾個沒完成，日程上面對這幾個需求有記錄就行。

total.flatMap(new Function<List<TaskAnswer>, ObservableSource<TaskAnswer>>() {
            @Override
            public ObservableSource<TaskAnswer> apply(@NonNull List<TaskAnswer> taskAnswers) throws Exception {
                return Observable.fromIterable(taskAnswers);
            }
        }).subscribe(new Consumer<TaskAnswer>() {
            @Override
            public void accept(TaskAnswer taskAnswer) throws Exception {
                Log.v("dyp","名字："+taskAnswer.getTaskName()+",結果："+taskAnswer.isTaskResult());
            }
        });
複製代碼

2. 若是產品經理跟你的關係不是很鐵， 他威脅你：你必定要就這幾天把我提的需求都作出來，否則只要一個沒完成，就記你這個月的任務沒有按時完成，會計入到考覈中。

total.flatMap(new Function<List<TaskAnswer>, ObservableSource<Boolean>>() {
            @Override
            public ObservableSource<Boolean> apply(@NonNull List<TaskAnswer> taskAnswers) throws Exception {
                if(taskAnswers.isEmpty()){
                    return Observable.empty();
                }
                for (TaskAnswer answer : taskAnswers){
                    if(!answer.isTaskResult()){
                        return Observable.just(false);
                    }
                }
                return Observable.just(true);
            }
        });
複製代碼

咱們能夠看到，咱們遍歷了三個需求，只要有一個需求的結果不是true,咱們就直接返回了Observable.just(false);,只有當三個需求的答覆結果都是true，纔會返回Observable.just(true);。 這時候產品經理只須要：

Observable.just(false/true)
    .subscribe(new Consumer<Boolean>() {
        @Override
        public void accept(Boolean aBoolean) throws Exception {
            if(aBoolean){
                Toast.makeText(this, "不錯麼，小夥子，需求都完成了。", Toast.LENGTH_SHORT).show();
            }else{
                Toast.makeText(this, "你死定了，獎金啥的都別期望了。", Toast.LENGTH_SHORT).show();
            }
        }
    });
複製代碼

4. 最後一個需求通過考慮事後告訴產品經理最終答案

這時候產品經理也已經跟咱們對接了，咱們還記不記得咱們的第三個需求是不能立刻告訴產品經理的，因此咱們通過N分鐘的思考後，決定告訴產品經理，這個需求貌似能夠按時完成。

//咱們使用第三個需求的PublishSubject對象來發送結果給產品經理
taskPub.onNext(new TaskAnswer("第三個需求",true));
taskPub.onComplete();
複製代碼

這時候產品經理那裏就會收到（假設咱們跟產品經理是很鐵的那種關係）：

V: 名字：第一個需求,結果：false
V: 名字：第二個需求,結果：true
V: 名字：第三個需求,結果：true
複製代碼

正式起航

對其，初步的知識點咱們已經講完了。咱們來看下咱們的權限申請跟上訴這個故事的相同點：

產品經理給程序員提需求

手機APP向系統提權限

沒錯，基本如出一轍，惟一不一樣的地方就是圖中藍色那一塊：

產品經理提需求	手機APP提權限
腦子想了一會，調用了onNext和onComplete回覆。	跳出彈框，讓用戶點擊，而後再調用onNext和onComplete回覆。

因此咱們目前把RxPermission功能進行劃分：

RxPermission文件分塊

• Permission.java：權限對象
• RxPermissions.java :裏面對權限進行分組（分紅已經肯定告終果的，還有沒有肯定結果須要詢問的），而且生成Observable，
• RxPermissionsFragment.java:也就是圖片藍色的內容，對於那些尚未肯定結果的權限進行彈框詢問，等用戶點擊了，而後再調用onNext,onComplete等進行通知。

咱們須要先按照咱們上面提過的產品經理的故事同樣，把三個需求分紅已經肯定告終果的和還須要思考一會的。咱們這裏也要把權限也先分組分好（也就是在RxPermissions.java中）：

@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) {
        mRxPermissionsFragment.log("Requesting permission " + permission);
        
        //若是已經處於贊成狀態就把這個權限對象給放入list中。
        if (isGranted(permission)) {
            // Already granted, or not Android M
            // Return a granted Permission object.
            list.add(Observable.just(new Permission(permission, true, false)));
            continue;
        }

        //若是已經處於拒絕狀態就把這個權限對象放入list中
        if (isRevoked(permission)) {
            // Revoked by a policy, return a denied Permission object.
            list.add(Observable.just(new Permission(permission, false, false)));
            continue;
        }

        /*
        就跟咱們產品經理的故事裏面同樣，咱們要對還不肯定結果的需求，
        創建一個PublishSubject，而後計入到unrequestedPermissions列表中用來傳遞給Fragment，
        同時也加入到中的list列表中。
        */
        PublishSubject<Permission> subject = mRxPermissionsFragment.getSubjectByPermission(permission);
        // Create a new subject if not exists
        if (subject == null) {
            unrequestedPermissions.add(permission);
            subject = PublishSubject.create();
            //把PublishSubject存入fragment中，等會方便肯定好結果後調用
            mRxPermissionsFragment.setSubjectForPermission(permission, subject);
        }
        list.add(subject);
    }
    
    /*
    這裏就是把帶詢問列表的全部內容都送到RxPermissionsFragment.java中，
    而後在fragment中會針對這個列表裏面的每一個權限，去調用系統方法進行詢問，
    而後根據不一樣的結果去onNext和onComplete通知。
    */
    if (!unrequestedPermissions.isEmpty()) {
        
        String[] unrequestedPermissionsArray = unrequestedPermissions.toArray(new String[unrequestedPermissions.size()]);
        //把list轉換成String[]再傳入到fragment中。
        requestPermissionsFromFragment(unrequestedPermissionsArray);
    }
    
    //這裏跟產品經理的故事裏面同樣，咱們會把全部的權限都放在一個Observable裏面。
    return Observable.concat(Observable.fromIterable(list));
}
複製代碼

而後剩下的就是具體的fragment中處理的事情：

@TargetApi(Build.VERSION_CODES.M)
void requestPermissionsFromFragment(String[] permissions) {
    mRxPermissionsFragment.log("requestPermissionsFromFragment " + TextUtils.join(", ", permissions));
    
    //調用系統方法，對傳入的須要詢問的權限進行彈框申請，讓用戶來決定
    mRxPermissionsFragment.requestPermissions(permissions);
}
複製代碼

當用戶進行點擊贊成或者拒絕的時候，系統會自動回調：

@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);
}


void onRequestPermissionsResult(String permissions[], int[] grantResults, boolean[] shouldShowRequestPermissionRationale) {

    //根據進行詢問的權限來進行遍歷
    for (int i = 0, size = permissions.length; i < size; i++) {
        log("onRequestPermissionsResult " + permissions[i]);
        // Find the corresponding subject
        PublishSubject<Permission> subject = mSubjects.get(permissions[i]);
        if (subject == null) {
            // No subject found
            Log.e(RxPermissions.TAG, "RxPermissions.onRequestPermissionsResult invoked but didn't find the corresponding permission request.");
            return;
        }
        
        mSubjects.remove(permissions[i]);
        
        //獲取反饋的結果，用戶是贊成仍是拒絕
        boolean granted = grantResults[i] == PackageManager.PERMISSION_GRANTED;
        
        //而後發送結果，onNext(new Permissinon.....)
        subject.onNext(new Permission(permissions[i], granted, shouldShowRequestPermissionRationale[i]));
        
        //而後調用onComplete()進行結束
        subject.onComplete();
    }
}
複製代碼

還記不記得咱們跟產品經理的關係鐵與不鐵，還有不一樣的處理，就是都成功還算任務完成，或者分批告訴你每一個需求的評估結果。RxPermission在RxPermission.java中也有這二種狀況，分別對應了：request 和 requestEach方法。

最後咱們就能夠在Activity中安心的使用：

//你跟產品經理關係很差的時候，一個完成不了就算輸：
rxPermissions.request(Manifest.permission.CAMERA,
        Manifest.permission.READ_PHONE_STATE)
        .subscribe(new Consumer<Boolean>() {
        @Override
        public void accept(@io.reactivex.annotations.NonNull Boolean aBoolean) throws Exception {
            
            
        }
});

//你跟產品經理關係不錯。只要反饋每一個具體的狀況便可
rxPermissions.requestEach(Manifest.permission.CAMERA,
        Manifest.permission.READ_PHONE_STATE)
        .subscribe(new Consumer<Permission>() {
        @Override
        public void accept(@io.reactivex.annotations.NonNull Permission permission) throws Exception {

        }
});
複製代碼

結尾

以圖片結尾，沒錯。這是個看臉的時代，還好我長的帥氣。(^▽^)