动态权限的使用以及RxPermissions源码分析

基本使用

Android6.0之后，增加了动态权限配置，目的在于用户可以自由的选择自己是否给予app权限，就算没有给予某个权限，也不影响其他功能的使用，不至于令用户无法安装

接下来先看一下基本的使用，代码如下：

// 检测是否授予了CALL_PHONE这个权限
if (ContextCompat.checkSelfPermission(MainActivity@ this, Manifest.permission.CALL_PHONE) != PackageManager.PERMISSION_GRANTED) {
    // 还未授予，则申请权限
    ActivityCompat.requestPermissions(MainActivity@ this, arrayOf(Manifest.permission.CALL_PHONE), 0x111)
} else {
    // 已经授予，则进行相关操作
    call()
}

// 该方法是申请权限后的回调方法
override fun onRequestPermissionsResult(requestCode: Int, permissions: Array, grantResults: IntArray) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults)
    when (requestCode) {
        // 请求码对应
        0x111 -> {
            // 判断申请权限是否成功
            if (grantResults.size > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // 成功申请，执行相关操作
                call()
            } else {
                // 申请失败，提示用户
                Toast.makeText(this, "您拒绝了该权限", Toast.LENGTH_SHORT).show()
            }
        }
        else -> {

        }
    }
}

// 权限申请成功后的相关操作
private fun call() {
    try {
        val intent = Intent(Intent.ACTION_CALL)
        intent.setData(Uri.parse("tel:10086"))
        startActivity(intent)
    } catch (e: SecurityException) {
        e.printStackTrace()
    }
}

以上是申请权限的基本操作，操作的方式其实类似于startActivityForResult()这种启动Activity的方法，也是会有具体的回调方法，但是如果每次都需要这样写，未免太过于繁琐，所以一般情况都需要对其进行封装，而RxPermissions这个库就对其进行了很好的封装，下面就使用RxPermissions进行实现

使用之前需要在项目中添加相关依赖

implementation 'com.tbruyelle.rxpermissions:rxpermissions:0.9.4@aar'

下面是详细实现代码

// 定义一个RxPermission对象
private lateinit var mRxPermission:RxPermissions

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.activity_main)
    // 创建Permission对象
    mRxPermission = RxPermissions(this)
    // 申请权限
    mRxPermission.request(Manifest.permission.CALL_PHONE).subscribe(object :Action1{
        override fun call(t: Boolean?) {
            // 回调之后的操作
            if (t!!){
                call()
            }else{
                Toast.makeText(this@MainActivity, "您拒绝了该权限", Toast.LENGTH_SHORT).show()                  }
            }
    })

相比一开始的代码，利用RxPermissions写的简洁了很多，也无需重写onRequestPermissionsResult()方法，这就是使用了该库的好处，节省了我们的代码量，也使代码变得更加清晰有条理，那么它是怎么做到的呢，下面就对其源码进行解读

1、其实，RxPermission采用的方式是利用了一个隐形的Fragment来请求权限，然后在回调中用RxJava进行数据的组装和转化，最后变成了布尔类型的数据回调回来，下面是具体的分析

// 创建RxPermissions的对象
mRxPermission = RxPermissions(this)

// 定义RxPermissions的对象
RxPermissionsFragment mRxPermissionsFragment;

// RxPermissions的构造方法
public RxPermissions(@NonNull Activity activity) {
    // 获取Fragment的实例
    mRxPermissionsFragment = getRxPermissionsFragment(activity);
}

// 获取Fragment的方法
private RxPermissionsFragment getRxPermissionsFragment(Activity activity) {
    // 查询是否已经存在了该Fragment，这样是为了让该Fragment只有一个实例
    RxPermissionsFragment rxPermissionsFragment = findRxPermissionsFragment(activity);
    boolean isNewInstance = rxPermissionsFragment == null;
    // 如果还没有存在，则创建Fragment，并添加到Activity中
    if (isNewInstance) {
        rxPermissionsFragment = new RxPermissionsFragment();
        FragmentManager fragmentManager = activity.getFragmentManager();
        fragmentManager
            .beginTransaction()
            .add(rxPermissionsFragment, TAG)
            .commitAllowingStateLoss();
        fragmentManager.executePendingTransactions();
    }
    return rxPermissionsFragment;
}

// 利用tag去找是否已经有该Fragment的实例
private RxPermissionsFragment findRxPermissionsFragment(Activity activity) {
    return (RxPermissionsFragment) activity.getFragmentManager().findFragmentByTag(TAG);
}

通过以上的代码可以知道，在创建RxPermissions的对象中，其实就是获取Fragment的实例而已，既然这样，我们就需要到这个Fragment的实现中，看它在被创建的时候做了什么事情

// Fragment的构造方法
public RxPermissionsFragment() {
}

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // 禁止横竖屏切换时的Fragment的重建
    setRetainInstance(true);
}

可以看到，在Fragment被创建时，并没有重写onCreateView()方法，来进行布局文件的加载，只是重写了onCreate()方法，然后禁止了横竖屏Fragment的重建，这就代表说，这个Fragment是一个没有布局的隐形Fragment，不会在屏幕上展示出来，但是这个Fragment却是关键，权限的申请与申请结果的回调都是在Fragment中完成的，这样，我们才不需要为申请结果重写回调方法

2、接下来是具体的请求

mRxPermission.request(Manifest.permission.CALL_PHONE).subscribe(object :Action1{
    override fun call(t: Boolean?) {
        if (t!!){
            call()
        }else{
            Toast.makeText(this@MainActivity, "您拒绝了该权限", Toast.LENGTH_SHORT).show()
        }
    }

})

上面的代码主要是调用RxPermissions对象中的request()方法，然后该方法会返回一个Observable，下面看具体的request()方法代码

@SuppressWarnings({"WeakerAccess", "unused"})
public Observable request(final String... permissions) {
    return Observable.just(null).compose(ensure(permissions));
}

首先，利用just(null)方法创建Observable对象
接下来会调用compose()方法。compose()的参数就为Observable.Transformer对象，该对象的作用是将一个类型的Observable对象转换成另外一个类型的Observable对象，同时也可以对自身对象的一些重复操作进行封装，避免重复编写代码

public Observable.Transformer ensure(final String... permissions) {
    return new Observable.Transformer() {
        @Override
        public Observable call(Observable