Add API to watch permission state

permissions/build.gradle.kts

@@ -35,7 +35,7 @@ android {
 }
 
 dependencies {
-    implementation(libs.kotlin.stdlib)
+    implementation(libs.bundles.kotlin)
     implementation(libs.androidx.core)
     implementation(libs.androidx.appcompat)
 

permissions/src/main/java/de/mm20/launcher2/permissions/PermissionsManager.kt

@@ -3,6 +3,7 @@ package de.mm20.launcher2.permissions
 import android.Manifest
 import android.content.Context
 import android.content.Intent
+import android.content.pm.PackageManager
 import android.net.Uri
 import android.os.Build
 import android.os.Environment
@@ -11,11 +12,26 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.core.app.ActivityCompat
 import de.mm20.launcher2.ktx.checkPermission
 import de.mm20.launcher2.ktx.isAtLeastApiLevel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
 
 interface PermissionsManager {
     fun requestPermission(context: AppCompatActivity, permissionGroup: PermissionGroup)
 
-    fun checkPermission(permissionGroup: PermissionGroup): Boolean
+    /**
+     * Check if this permission is granted right now without receiving further updates
+     * about the granted state.
+     * @return true if the given permission group is fully granted
+     */
+    fun checkPermissionOnce(permissionGroup: PermissionGroup): Boolean
+
+    fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    )
+
+    fun hasPermission(permissionGroup: PermissionGroup): Flow<Boolean>
 }
 
 enum class PermissionGroup {
@@ -27,18 +43,43 @@ enum class PermissionGroup {
 
 class PermissionsManagerImpl(
     private val context: Context
-): PermissionsManager {
+) : PermissionsManager {
+
+    private val calendarPermissionState = MutableStateFlow(
+        checkPermissionOnce(PermissionGroup.Calendar)
+    )
+    private val contactsPermissionState = MutableStateFlow(
+        checkPermissionOnce(PermissionGroup.Contacts)
+    )
+    private val externalStoragePermissionState = MutableStateFlow(
+        checkPermissionOnce(PermissionGroup.ExternalStorage)
+    )
+    private val locationPermissionState = MutableStateFlow(
+        checkPermissionOnce(PermissionGroup.Location)
+    )
 
     override fun requestPermission(activity: AppCompatActivity, permissionGroup: PermissionGroup) {
         when (permissionGroup) {
             PermissionGroup.Calendar -> {
-                ActivityCompat.requestPermissions(activity, calendarPermissions, permissionGroup.ordinal)
+                ActivityCompat.requestPermissions(
+                    activity,
+                    calendarPermissions,
+                    permissionGroup.ordinal
+                )
             }
             PermissionGroup.Location -> {
-                ActivityCompat.requestPermissions(activity, locationPermissions, permissionGroup.ordinal)
+                ActivityCompat.requestPermissions(
+                    activity,
+                    locationPermissions,
+                    permissionGroup.ordinal
+                )
             }
             PermissionGroup.Contacts -> {
-                ActivityCompat.requestPermissions(activity, contactPermissions, permissionGroup.ordinal)
+                ActivityCompat.requestPermissions(
+                    activity,
+                    contactPermissions,
+                    permissionGroup.ordinal
+                )
             }
             PermissionGroup.ExternalStorage -> {
                 if (isAtLeastApiLevel(Build.VERSION_CODES.R)) {
@@ -58,7 +99,7 @@ class PermissionsManagerImpl(
         }
     }
 
-    override fun checkPermission(permissionGroup: PermissionGroup): Boolean {
+    override fun checkPermissionOnce(permissionGroup: PermissionGroup): Boolean {
         return when (permissionGroup) {
             PermissionGroup.Calendar -> {
                 calendarPermissions.all { context.checkPermission(it) }
@@ -76,7 +117,30 @@ class PermissionsManagerImpl(
                     externalStoragePermissions.all { context.checkPermission(it) }
                 }
             }
-            else -> false
+        }
+    }
+
+    override fun hasPermission(permissionGroup: PermissionGroup): Flow<Boolean> {
+        return when (permissionGroup) {
+            PermissionGroup.Calendar -> calendarPermissionState
+            PermissionGroup.Location -> locationPermissionState
+            PermissionGroup.Contacts -> contactsPermissionState
+            PermissionGroup.ExternalStorage -> externalStoragePermissionState
+        }
+    }
+
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<out String>,
+        grantResults: IntArray
+    ) {
+        val permissionGroup = PermissionGroup.values().getOrNull(requestCode) ?: return
+        val granted = grantResults.all { it == PackageManager.PERMISSION_GRANTED }
+        when (permissionGroup) {
+            PermissionGroup.Calendar -> calendarPermissionState.value = granted
+            PermissionGroup.Location -> locationPermissionState.value = granted
+            PermissionGroup.Contacts -> contactsPermissionState.value = granted
+            PermissionGroup.ExternalStorage -> externalStoragePermissionState.value = granted
         }
     }