如何在ViewModel中检查是否已授予权限？

Question

我需要请求通讯录权限，并在应用程序启动时进行请求，在ViewModel部分，我需要调用需要权限的方法。 我需要检查用户是否授予权限，然后调用该方法，但是要检查权限，我需要访问Activity。但是在我的ViewModel中，我没有对Activity的引用，也不想要有，请问我该如何解决这个问题？

- I.S

---

在ViewModel部分，我需要调用一个需要权限的方法。在我看来，这是一个架构缺陷。如果一个ViewModel正在处理比Bitmap复杂得多的任何内容，那么它的职责就不正确。 - CommonsWare

@CommonsWare 在ViewModel中，我调用getContacts()方法或任何其他需要权限的方法。如果检查到权限未被授予，则不会调用该方法。我不知道在哪里组织检查部分，因为在ViewModel中我不想引用Activity。 - I.S

在ViewModel中，我调用getContacts()方法或任何其他我需要拥有权限的方法。在我看来，应该在ViewModel之外的某个地方调用ViewModel上的setContacts()方法。ViewModel只应该是一个简单的POJO对象。 - CommonsWare

::耸肩::我不同意那里展示的样例，正是因为你在这里提出的问题。某种演示者或控制器——能够访问活动的东西——负责获取受保护的数据。理想情况下，在请求权限之前不会启动整个UI，这将完全消除这个问题。 - CommonsWare

我同意@A.A.I.A.的观点，即权限不应该需要活动。我正在尝试查询MediaStore，并且它需要READ_EXTERNAL-STORAGE。查询有关歌曲的MediaStore信息是来自系统服务的域级数据查询，甚至在我的看法中低于ViewModel层。我想要一个域级别的查询来完成这项工作，而这个层次甚至不应该知道活动的存在，更不用说访问它了。我正在使用RxKotlin，因此希望此查询的结果对ViewModel可观察，最终传递到Fragment/UI层。 - Jim Leask

Answer 1

我刚遇到了这个问题，并决定使用LiveData来解决。

核心概念：

• ViewModel拥有一个LiveData，用于请求所需的权限

• ViewModel有一个方法（本质上是回调），用于返回是否授予权限

SomeViewModel.kt：

class SomeViewModel : ViewModel() {
    val permissionRequest = MutableLiveData<String>()

    fun onPermissionResult(permission: String, granted: Boolean) {
        TODO("whatever you need to do")
    }
}

FragmentOrActivity.kt

class FragmentOrActivity : FragmentOrActivity() {
    private viewModel: SomeViewModel by lazy {
        ViewModelProviders.of(this).get(SomeViewModel::class.java)
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        ......
        viewModel.permissionRequest.observe(this, Observer { permission -> 
            TODO("ask for permission, and then call viewModel.onPermissionResult aftwewards")
        })
        ......
    }
}

- Louis Tsai

---

你如何触发请求权限和更改“permissionRequest”对象？ - Starwave

Answer 2

我已经重新制定了解决方案。 PermissionRequester 对象是您需要的一切，可以从至少具有应用程序上下文的任何地方请求权限。 它使用其助手 PermissionRequestActivity 来完成此工作。

@Parcelize
class PermissionResult(val permission: String, val state: State) : Parcelable
enum class State { GRANTED, DENIED_TEMPORARILY, DENIED_PERMANENTLY }
typealias Cancellable = () -> Unit
private const val PERMISSIONS_ARGUMENT_KEY = "PERMISSIONS_ARGUMENT_KEY"
private const val REQUEST_CODE_ARGUMENT_KEY = "REQUEST_CODE_ARGUMENT_KEY"

object PermissionRequester {
    private val callbackMap = ConcurrentHashMap<Int, (List<PermissionResult>) -> Unit>(1)
    private var requestCode = 256
    get() {
        requestCode = field--
        return if (field < 0) 255 else field
    }

    fun requestPermissions(context: Context, vararg permissions: String, callback: (List<PermissionResult>) -> Unit): Cancellable {
        val intent = Intent(context, PermissionRequestActivity::class.java)
                .putExtra(PERMISSIONS_ARGUMENT_KEY, permissions)
                .putExtra(REQUEST_CODE_ARGUMENT_KEY, requestCode)
                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
        context.startActivity(intent)
        callbackMap[requestCode] = callback
        return { callbackMap.remove(requestCode) }
    }

    internal fun onPermissionResult(responses: List<PermissionResult>, requestCode: Int) {
        callbackMap[requestCode]?.invoke(responses)
        callbackMap.remove(requestCode)
    }
}

class PermissionRequestActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (savedInstanceState == null) {
            requestPermissions()
        }
    }

    private fun requestPermissions() {
        val permissions = intent?.getStringArrayExtra(PERMISSIONS_ARGUMENT_KEY) ?: arrayOf()
        val requestCode = intent?.getIntExtra(REQUEST_CODE_ARGUMENT_KEY, -1) ?: -1
        when {
            permissions.isNotEmpty() && requestCode != -1 -> ActivityCompat.requestPermissions(this, permissions, requestCode)
            else -> finishWithResult()
        }
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)

        val permissionResults = grantResults.zip(permissions).map { (grantResult, permission) ->
            val state =  when {
                grantResult == PackageManager.PERMISSION_GRANTED -> State.GRANTED
                ActivityCompat.shouldShowRequestPermissionRationale(this, permission) -> State.DENIED_TEMPORARILY
                else -> State.DENIED_PERMANENTLY
            }
            PermissionResult(permission, state)
        }

        finishWithResult(permissionResults)
    }

    private fun finishWithResult(permissionResult: List<PermissionResult> = listOf()) {
        val requestCode = intent?.getIntExtra(REQUEST_CODE_ARGUMENT_KEY, -1) ?: -1
        PermissionRequester.onPermissionResult(permissionResult, requestCode)
        finish()
    }
}

使用方法：

class MyViewModel(application: Application) : AndroidViewModel(application) {

    private val cancelRequest: Cancellable = requestPermission()

    private fun requestPermission(): Cancellable {
        return PermissionRequester.requestPermissions(getApplication(), "android.permission.SEND_SMS") {
            if (it.firstOrNull()?.state == State.GRANTED) {
                Toast.makeText(getApplication(), "GRANTED", Toast.LENGTH_LONG).show()
            } else {
                Toast.makeText(getApplication(), "DENIED", Toast.LENGTH_LONG).show()
            }
        }
    }

    override fun onCleared() {
        super.onCleared()
        cancelRequest()
    }
}

- user1185087

---

如果我的权限请求需要显示权限原理的对话框，我该如何在ViewModel中实现这段代码？ - LCZ

这绝对是最好的解决方案！你只是忘了提到需要在AppManifest上注册PermissionRequestActivity。 - Machado

在ViewModel中使用Toast是一个好的做法吗？ - Zeeshan

Answer 3

我做了类似这样的事情：

创建一个抽象类，它扩展了 AndroidViewModel，从而使您可以访问应用程序上下文：

abstract class BaseViewModel(application: Application) : AndroidViewModel(application), CoroutineScope {

    private val job = Job()

    override val coroutineContext: CoroutineContext
        get() = job + Dispatchers.Main

    override fun onCleared() {
        super.onCleared()
        job.cancel()
    }
}

现在，通过扩展BaseViewModel类来创建你的视图模型，这样你就可以访问应用程序上下文

class AdminViewModel(application: Application) : BaseViewModel(application) {
    .....
}

现在，您始终可以访问一个上下文，以便获取资源。

- Jo Momma