[toc]

RxPermissions 源碼解析

簡介

RxPermissions 是基于 RxJava 開發的用于幫助在Android 6.0 中處理運行時權限檢測的框架。在 Android 6.0 中增加了對危險權限的動態申請，而不是像 Android 6.0 之前的默認全部獲取的方式。

原始動態權限的獲取

如果按照以往的獲取權限方式的話，那么我們獲取權限一般需要有 3 個步驟，第一步是先判斷當前是否已經獲取到該權限了；第 2 步申請對應的權限；第 3 步在 Activity 或者 Fragment 中處理獲取權限的結果。具體的實現步驟如下：

step 1：判斷權限是否已經獲取。

if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                Manifest.permission.CAMERA)) {
            //用于開發者提示用戶權限的用途
        } else {
            //申請權限
        }

step 2:申請權限

ActivityCompat.requestPermissions(MainActivity.this,
                                    new String[]{Manifest.permission.CAMERA},
                                    REQUEST_CAMERA);

step 3:結果處理

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
        @NonNull int[] grantResults) {
    // 判斷請求碼，確定當前申請的權限
    if (requestCode == REQUEST_CAMERA) {
        //判斷權限是否申請通過
        if (grantResults.length == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            //授權成功
        } else {
               //授權失敗
        }
    } else {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
}

RxPermissions 的簡單使用

其實 RxPermissions 的使用方式有兩種

方式 1：

RxPermissions rxPermissions = new RxPermissions(MainActivity.this);
        rxPermissions
                .request(Manifest.permission.READ_EXTERNAL_STORAGE,
                        Manifest.permission.WRITE_EXTERNAL_STORAGE)//這里填寫所需要的權限
                .subscribe(new Consumer<Boolean>() {
                    @Override
                    public void accept(Boolean aBoolean) throws Exception {
                        if (aBoolean) {
                            // 通過
                        }else{
                            // 拒絕
                        }
                    }
                });

方式 2：結合 RxBinding 來使用

RxPermissions rxPermissions = new RxPermissions(MainActivity.this);
// Must be done during an initialization phase like onCreate
RxView.clicks(findViewById(R.id.enableCamera))
    .compose(rxPermissions.ensure(Manifest.permission.CAMERA))
    .subscribe(granted -> {
        // R.id.enableCamera has been clicked
    });

源碼分析

整體介紹

接著我們來對這個 RxPermissions 進行一個源碼的解析，但是打開源碼的時候，我們可以發現，這個庫里面，其實就只有 3 個類：RxPermissions、RxPermissionsFragment、Permission

RxPermissions
- 最主要的實現類，利用 rxjava，為我們提供了方便權限申請的類
RxPermissionsFragment
- 是一個 fragment，主要的動態權限獲取類
Permission
- 定義的權限的 model 類

源碼分析

RxPermissions 實例創建

對于源碼的分析，我們應該先從簡單的使用入手。下面我們可以先看看實例化 RxPermissionsFragment 的時候是做了什么？

    RxPermissionsFragment mRxPermissionsFragment;

    public RxPermissions(@NonNull Activity activity) {
        mRxPermissionsFragment = getRxPermissionsFragment(activity);
    }

我們可以看到，上面的代碼中，實例化 RxPermissionsFragment 的時候，里面先創建了一個 RxPermissionsFragment 的實例。我們再接著看 getRxPermissionsFragment 這個方法的實現。

    private RxPermissionsFragment getRxPermissionsFragment(Activity activity) {
        //  查找 RxPermissionsFragment 是否已經被添加了
        RxPermissionsFragment rxPermissionsFragment = findRxPermissionsFragment(activity);
        boolean isNewInstance = rxPermissionsFragment == null;
        if (isNewInstance) {
            rxPermissionsFragment = new RxPermissionsFragment();
            FragmentManager fragmentManager = activity.getFragmentManager();
            fragmentManager
                    .beginTransaction()
                    .add(rxPermissionsFragment, TAG)
                    .commitAllowingStateLoss();
            fragmentManager.executePendingTransactions();
        }
        return rxPermissionsFragment;
    }

在 getRxPermissionsFragment() 這個方法中，首先是先查找當前是否已經添加了這個 rxPermissionsFragment 的實例，如果已經添加，那么直接返回已經添加的實例，如果沒有添加過的話，那么就重新再創建一個 RxPermissionsFragment 實例并提交；

    private RxPermissionsFragment findRxPermissionsFragment(Activity activity) {
        return (RxPermissionsFragment) activity.getFragmentManager().findFragmentByTag(TAG);
    }

到此，rxPermissionsFragment 的實例化已經完成，接著我們需要看看 request 這個方法中實現了什么。

request 方法

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

    static final Object TRIGGER = new Object();

從上面的代碼中，我們可以看到，request 方法中需要傳入的參數是一個權限的數組，返回值是 Observable<Boolean> 對象。Observable.just(TRIGGER) 是快捷創建一個 Observable 的方式，由于 TRIGGER 是一個空的 Object 對象，所以 TRIGGER 就是一個占位符而已，Observable.just(TRIGGER) 創建的是一個 Observable<Object>,之后通過 compose 將 Observable<Object> 轉化為 Observable<Boolean> 并返回。在 compose 中需要的參數是一個 ObservableTransformer，那么我們接著看 ensure() 這個方法。

ensure(permissions);

public <T> ObservableTransformer<T, Boolean> ensure(final String... permissions) {
        // 創建一個Transformer對象返回
        return new ObservableTransformer<T, Boolean>() {
            @Override
            public ObservableSource<Boolean> apply(Observable<T> o) {
                //request(o, permissions) 方法返回 Observable<Permission> 對象
                return request(o, permissions)
                        // 將 Observable<Permission> 轉換為 Observable<Boolean>，在這里會等待所有的權限都返回了一次性發射數據。
                        .buffer(permissions.length)
                        .flatMap(new Function<List<Permission>, ObservableSource<Boolean>>() {
                            @Override
                            public ObservableSource<Boolean> apply(List<Permission> permissions) throws Exception {
                                // 如果permissions為空那么直接返回Observable.empty();
                                if (permissions.isEmpty()) {
                                    // Occurs during orientation change, when the subject receives onComplete.
                                    // In that case we don't want to propagate that empty list to the
                                    // subscriber, only the onComplete.
                                    return Observable.empty();
                                }
                                // Return true if all permissions are granted.
                                for (Permission p : permissions) {
                                    if (!p.granted) {
                                        return Observable.just(false);
                                    }
                                }
                                return Observable.just(true);
                            }
                        });
            }
        };
    }

在 ensure 的這個方法中，最終會返回的是 ObservableTransformer<T, Boolean> 對象。接著我們看看 ObservableTransformer 的匿名實現類里面的 apply 方法，這里實現的就是將 Observable<Permission> 轉換為 Observable<Boolean> 的操作。我們對 apply 這個方法里面的代碼進行簡化一下。

return request(o,permissions)
    .buffer(permissions.length)
    .flatMap(new Function<List<Permission>, ObservableSource<Boolean>>{});

request() 方法返回 Observable<Permission> 對象
buffer(len) 操作符將一個 Observable<Permission> 變換為 Observable<List<Permission>>，原來的 Observable 正常發射數據，變換產生的 Observable 發射這些數據的緩存集合。buffer 將數據緩存到一個集合當中，然后在適當(比如：所有請求的權限結果都返回了）的時機一起發送。
flatMap() 方法將 Observable<List<Permission>> 轉化為 Observable<Boolean>

request(o, permissions);

    private Observable<Permission> request(final Observable<?> trigger, final String... permissions) {
        if (permissions == null || permissions.length == 0) {
            throw new IllegalArgumentException("RxPermissions.request/requestEach requires at least one input permission");
        }
        return oneOf(trigger, pending(permissions))
                .flatMap(new Function<Object, Observable<Permission>>() {
                    @Override
                    public Observable<Permission> apply(Object o) throws Exception {
                        return requestImplementation(permissions);
                    }
                });
    }

在 request 這個方法里面，其實 oneOf() 和 pending() 方法我們可以忽略的，主要的話，我們應該關注 requestImplementation(final String... permissions) 這個方法，在這個方法里面，主要實現了權限的請求。

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<>();

        // In case of multiple permissions, we create an Observable for each of them.
        // At the end, the observables are combined to have a unique response.
        for (String permission : permissions) {
            mRxPermissionsFragment.log("Requesting permission " + permission);
            if (isGranted(permission)) {
                // Already granted, or not Android M
                // Return a granted Permission object.
                // 權限已經被同意或者不是 Android 6.0 以上版本，創建一個 同意的 Permission 對象。
                list.add(Observable.just(new Permission(permission, true, false)));
                continue;
            }

            if (isRevoked(permission)) {
                // 權限被拒絕，返回一個 拒絕的 Permission 對象。
                list.add(Observable.just(new Permission(permission, false, false)));
                continue;
            }

            PublishSubject<Permission> subject = mRxPermissionsFragment.getSubjectByPermission(permission);
            // 如果 subject 不存在，那么創建一個 subject。
            if (subject == null) {
                unrequestedPermissions.add(permission);
                subject = PublishSubject.create();
                mRxPermissionsFragment.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));
    }

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

    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;
            subject.onNext(new Permission(permissions[i], granted, shouldShowRequestPermissionRationale[i]));
            subject.onComplete();
        }
    }

RxJava 操作符

Observable.just()

just 操作符是將一個對象轉化為 Observable 的操作符。這個對象可以是一個數字、字符串或者是數組對象等，是 RxJava 中快速創建一個 Observable 對象的操作符。如果有 subscriber 訂閱的話，那么會依次調用 onNext() 和 OnComplete() 方法。所以這里只是創建了一個 Observable 對象，方便后續的調用。

compose(Transformer)操作符

compose 操作符是對 Observable 對象的整體轉化。例如：通過 Transformer，我們可以將 Observable<Object> 對象轉換成 Observable<Boolean> 對象了。

    public static ObservableTransformer<String,Boolean> getTransformer(){
        return new ObservableTransformer<String, Boolean>() {
            @Override
            public ObservableSource<Boolean> apply(Observable<String> upstream) {
                return upstream.flatMap(new Function<String, ObservableSource<Boolean>>() {
                    @Override
                    public ObservableSource<Boolean> apply(String s) throws Exception {
                        return Observable.just(true);
                    }
                });
            }
        };
    }


    /**
     * 線程切換
     * @return
     */
    public static <T> ObservableTransformer<T,T> getScheduler(){
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(Observable<T> upstream) {
                return upstream.subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread());
            }
        };
    }

buffer 操作符

buffer 操作符將一個 Observable 變換為另一個，原來的 Observable 正常發射數據，變換產生的 Observable 發射這些數據的緩存集合。buffer將數據緩存到一個集合當中，然后在適當的時機一起發送。
buffer(count) 以列表(List)的形式發射非重疊的緩存，每一個緩存至多包含來自原始Observable的count項數據（最后發射的列表數據可能少于count項）

例如：緩存 2 個數據之后，再發送數據（調用 buffer(count) 函數）

                Observable.just(1,2,3,4,5,6)
                        .buffer(2)
                        .subscribe(integers -> {
                            Log.i(TAG, "accept size: "+integers.size());
                            for (Integer integer : integers) {
                                Log.i(TAG, "accept: "+integer);
                            }
                        });

輸出結果

2018-12-14 11:16:28.452 28126-28126/com.luwei.lwbaselib I/LwBaseActivity: accept size: 2
2018-12-14 11:16:28.452 28126-28126/com.luwei.lwbaselib I/LwBaseActivity: accept: 1
2018-12-14 11:16:28.453 28126-28126/com.luwei.lwbaselib I/LwBaseActivity: accept: 2
2018-12-14 11:16:28.453 28126-28126/com.luwei.lwbaselib I/LwBaseActivity: accept size: 2
2018-12-14 11:16:28.453 28126-28126/com.luwei.lwbaselib I/LwBaseActivity: accept: 3
2018-12-14 11:16:28.453 28126-28126/com.luwei.lwbaselib I/LwBaseActivity: accept: 4
2018-12-14 11:16:28.453 28126-28126/com.luwei.lwbaselib I/LwBaseActivity: accept size: 2
2018-12-14 11:16:28.453 28126-28126/com.luwei.lwbaselib I/LwBaseActivity: accept: 5
2018-12-14 11:16:28.453 28126-28126/com.luwei.lwbaselib I/LwBaseActivity: accept: 6

例如：緩存 3 個數據，再發送數據，每次移動 1 步

                Observable.just(1,2,3,4)
                        .buffer(3,1)
                        .subscribe(integers -> {
                            Log.i(TAG, "accept size: "+integers.size());
                            for (Integer integer : integers) {
                                Log.i(TAG, "accept: "+integer);
                            }
                        });

輸出結果

2018-12-14 11:24:31.455 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept size: 3
2018-12-14 11:24:31.455 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept: 1
2018-12-14 11:24:31.455 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept: 2
2018-12-14 11:24:31.455 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept: 3
2018-12-14 11:24:31.455 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept size: 3
2018-12-14 11:24:31.455 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept: 2
2018-12-14 11:24:31.455 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept: 3
2018-12-14 11:24:31.455 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept: 4
2018-12-14 11:24:31.456 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept size: 2
2018-12-14 11:24:31.456 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept: 3
2018-12-14 11:24:31.456 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept: 4
2018-12-14 11:24:31.456 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept size: 1
2018-12-14 11:24:31.456 29164-29164/com.luwei.lwbaselib I/LwBaseActivity: accept: 4

concat 操作符

是接收若干個Observables，發射數據是有序的，不會交叉。

Subject

作為 Observable 和 Observer 之間的橋梁
可以當做 Observable
可以當做 Observer

PublishSubject

繼承至 Subject，它的 Observer 只會接收到 PublishSubject 被訂閱之后發送的數據。示例代碼如下；我們只會接收到 publishSubject3 和 publishSubject4；

                PublishSubject<String> publishSubject = PublishSubject.create();
                publishSubject.onNext("publishSubject1");
                publishSubject.onNext("publishSubject2");
                publishSubject.subscribe(new Consumer<String>() {
                    @Override
                    public void accept(String s) throws Exception {
                        Log.i(TAG, "accept: "+s);
                    }
                });
                publishSubject.onNext("publishSubject3");
                publishSubject.onNext("publishSubject4");

執行結果

2018-12-14 11:33:18.168 29916-29916/com.luwei.lwbaselib I/LwBaseActivity: accept: publishSubject3
2018-12-14 11:33:18.168 29916-29916/com.luwei.lwbaselib I/LwBaseActivity: accept: publishSubject4

舉一反三

可以看到，在 RxPermissions 這個獲取權限的開源框架中，往 Activity 中添加了一個空的 Fragment，這個 fragment 才是用來發起申請權限和處理權限的請求，最后再將結果返回，這樣子就避免了我們發送請求之后，還需要在 onRequestPermissionsResult 中進行處理，并判斷 requestCode 等繁瑣操作。想到這里，我們平時使用 startActivityForResult 時，我們也可以同樣采用這樣的思路來簡化我們的請求。

同樣的，我們采用添加空白的 fragment，來做 startActivityForResult 請求，主要的實現類有 SimpleForResult 和 SimpleOnResultFragment，ActivityResultInfo 是請求 model，接下我們先看代碼。

SimpleForResult


/**
 * @Author: chenjianrun
 * @Time: 2018/12/7
 * @Description:   避免調用 startActivity 時，需要 onActivityResult 處理的類
 */
public class SimpleForResult {
    private static final String TAG = "SimpleForResult";
    private SimpleOnResultFragment mSimpleOnResultFragment;

    public SimpleForResult(AppCompatActivity activity) {
        mSimpleOnResultFragment = getOnResultFragment(activity.getSupportFragmentManager());
    }

    public SimpleForResult(Fragment fragment){
        mSimpleOnResultFragment = getOnResultFragment(fragment.getChildFragmentManager());
    }

    private SimpleOnResultFragment getOnResultFragment(FragmentManager fragmentManager) {
        SimpleOnResultFragment simpleOnResultFragment = findSimpleOnResultFragment(fragmentManager);
        if (simpleOnResultFragment == null) {
            simpleOnResultFragment = new SimpleOnResultFragment();
            fragmentManager
                    .beginTransaction()
                    .add(simpleOnResultFragment, TAG)
                    .commitAllowingStateLoss();
            fragmentManager.executePendingTransactions();
        }
        return simpleOnResultFragment;
    }

    private SimpleOnResultFragment findSimpleOnResultFragment(FragmentManager fragmentManager) {
        return (SimpleOnResultFragment) fragmentManager.findFragmentByTag(TAG);
    }

    public Observable<ActivityResultInfo> startForResult(Intent intent) {
        return mSimpleOnResultFragment.startForResult(intent);
    }

    public Observable<ActivityResultInfo> startForResult(Class<?> clazz) {
        Intent intent = new Intent(mSimpleOnResultFragment.getActivity(), clazz);
        return startForResult(intent);
    }

    public void startForResult(Intent intent, Callback callback) {
        mSimpleOnResultFragment.startForResult(intent, callback);
    }

    public void startForResult(Class<?> clazz, Callback callback) {
        Intent intent = new Intent(mSimpleOnResultFragment.getActivity(), clazz);
        startForResult(intent, callback);
    }

    public interface Callback {
        void onActivityResult(int requestCode, int resultCode, Intent data);
    }
}

SimpleOnResultFragment


/**
 * @Author: chenjianrun
 * @Time: 2018/12/7
 * @Description:    真正調用 startActivity 和處理 onActivityResult 的類。
 */
public class SimpleOnResultFragment extends Fragment {
    private static Map<Integer, PublishSubject<ActivityResultInfo>> mSubjects = new HashMap<>();
    private static Map<Integer, SimpleForResult.Callback> mCallbacks = new HashMap<>();

    public SimpleOnResultFragment() {
    }

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

    public Observable<ActivityResultInfo> startForResult(final Intent intent) {
        int requestCode = generateRequestCode();
        PublishSubject<ActivityResultInfo> subject = PublishSubject.create();
        mSubjects.put(requestCode, subject);
        startActivityForResult(intent, requestCode);
        return subject;
    }

    public void startForResult(Intent intent, SimpleForResult.Callback callback) {
        int requestCode = generateRequestCode();
        mCallbacks.put(requestCode, callback);
        startActivityForResult(intent, requestCode);
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        //rxjava方式的處理
        PublishSubject<ActivityResultInfo> subject = mSubjects.remove(requestCode);
        if (subject != null) {
            subject.onNext(new ActivityResultInfo(requestCode, resultCode, data));
            subject.onComplete();
        }

        //callback方式的處理
        SimpleForResult.Callback callback = mCallbacks.remove(requestCode);
        if (callback != null) {
            callback.onActivityResult(requestCode, resultCode, data);
        }
    }

    private int generateRequestCode(){
        Random random = new Random();
        for (;;){
            int code = random.nextInt(65536);
            if (!mSubjects.containsKey(code) && !mCallbacks.containsKey(code)){
                return code;
            }
        }
    }
}

ActivityResultInfo

package com.luwei.util.forresult;

import android.content.Intent;

/**
 * @Author: chenjianrun
 * @Time: 2018/12/7
 * @Description:
 */
public class ActivityResultInfo {
    private int requestCode;
    private int resultCode;
    private Intent data;

    public ActivityResultInfo(int requestCode, int resultCode, Intent data) {
        this.requestCode = requestCode;
        this.resultCode = resultCode;
        this.data = data;
    }

    public int getRequestCode() {
        return requestCode;
    }

    public void setRequestCode(int requestCode) {
        this.requestCode = requestCode;
    }

    public ActivityResultInfo(int resultCode, Intent data) {
        this.resultCode = resultCode;
        this.data = data;
    }

    public int getResultCode() {
        return resultCode;
    }

    public void setResultCode(int resultCode) {
        this.resultCode = resultCode;
    }

    public Intent getData() {
        return data;
    }

    public void setData(Intent data) {
        this.data = data;
    }
}

簡單使用示例

簡單的 Activity 調用

// 簡化調用 startActivityForResult 及避免在 onActivityResult 中處理繁瑣的結果
                SimpleForResult simpleForResult = new SimpleForResult(this);
                simpleForResult.startForResult(ToastActivity.class)
                        .subscribe((resultInfo) -> {
                            if (resultInfo.getData() != null) {
                                ToastUtils.showLong(resultInfo.getData().getStringExtra("result"));
                            }
                        });

調用攝像頭

    /**
     * 打開攝像頭
     */
    private void openCamera() {
        try {
            mTmpFile = FileUtils.createTmpFile(this);
        } catch (IOException e) {
            e.printStackTrace();
        }
        simpleForResult.startForResult(getOpenCameraIntent(this, mTmpFile))
                .subscribe((resultInfo -> {
                    if (resultInfo.getResultCode() == RESULT_OK) {
                        mHeadUrl = mTmpFile.getAbsolutePath();
                        ImageLoaderUtils.loadCircleImage(this, ivHeader, mHeadUrl);
                        // 裁剪(如果沒有要求可裁剪，也可以不要）
                        startPictureZoom(mTmpFile);
                    }
                }));
    }


    /**
     * 獲取打開照相機的 intent，適配 Android 7.0
     * @param activity
     * @param mTmpFile
     * @return
     */
    public static Intent getOpenCameraIntent(Activity activity,File mTmpFile){
        Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
        if (intent.resolveActivity(activity.getPackageManager()) != null) {
            if (mTmpFile != null && mTmpFile.exists()) {
                if (Build.VERSION.SDK_INT >= 24) {
                    // 適配 Android 7.0
                    intent.putExtra(MediaStore.EXTRA_OUTPUT,
                            FileProvider.getUriForFile(activity, activity.getPackageName()+".provider",mTmpFile));
                } else {
                    intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(mTmpFile));
                }
            } else {
                Toast.makeText(activity, me.nereo.image_selector.R.string.error_image_not_exist, Toast.LENGTH_SHORT).show();
            }
        } else {
            Toast.makeText(activity, me.nereo.image_selector.R.string.msg_no_camera, Toast.LENGTH_SHORT).show();
        }
        return intent;
    }

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

RxPermissions 源碼解析之舉一反三

RxPermissions 源碼解析之舉一反三

RxPermissions 源碼解析

簡介

原始動態權限的獲取

RxPermissions 的簡單使用

源碼分析

整體介紹

源碼分析

RxPermissions 實例創建

request 方法

ensure(permissions);

request(o, permissions);

requestImplementation

onRequestPermissionsResult()

RxJava 操作符

Observable.just()

compose(Transformer)操作符

buffer 操作符

concat 操作符

Subject

PublishSubject

舉一反三

SimpleForResult

SimpleOnResultFragment

ActivityResultInfo

簡單使用示例

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

RxPermissions 源碼解析之舉一反三

RxPermissions 源碼解析

簡介

原始動態權限的獲取

RxPermissions 的簡單使用

源碼分析

整體介紹

源碼分析

RxPermissions 實例創建

request 方法

ensure(permissions);

request(o, permissions);

requestImplementation

onRequestPermissionsResult()

RxJava 操作符

Observable.just()

compose(Transformer)操作符

buffer 操作符

concat 操作符

Subject

PublishSubject

舉一反三

SimpleForResult

SimpleOnResultFragment

ActivityResultInfo

簡單使用示例

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频