🔀 Merge pull request #514 from vinceglb/codex/android-camera-permission-issue

vinceglb · web-flow · commit e2f28234d246 · 2026-02-23T14:07:16.000+01:00
Fix Android camera permission handling for camera picker
diff --git a/docs/dialogs/camera-picker.mdx b/docs/dialogs/camera-picker.mdx
@@ -30,6 +30,17 @@ Button(onClick = { launcher.launch() }) {
 
 The captured media file is automatically saved to the specified location (or cache directory by default). If you need to keep the file permanently, make sure to copy it to a permanent storage location.
 
+## Android camera permission behavior
+
+On Android, camera capture is launched with `ACTION_IMAGE_CAPTURE`.
+If your app declares `android.permission.CAMERA`, FileKit checks runtime permission before launching the camera:
+
+- If camera permission is already granted, FileKit opens the camera as usual.
+- If camera permission is not granted, FileKit requests it first.
+- If the user denies the permission, FileKit returns `null` (same as cancel) and does not crash.
+
+If your app only launches the external camera app through this picker, you usually do not need to declare `android.permission.CAMERA`.
+
 ## Camera type
 
 You can specify the type of media to capture using the `type` parameter:
diff --git a/filekit-dialogs-compose/src/androidHostTest/kotlin/io/github/vinceglb/filekit/dialogs/compose/AndroidComposePickerReliabilityTest.kt b/filekit-dialogs-compose/src/androidHostTest/kotlin/io/github/vinceglb/filekit/dialogs/compose/AndroidComposePickerReliabilityTest.kt
@@ -54,6 +54,59 @@ class AndroidComposePickerReliabilityTest {
         assertNull(result)
     }
 
+    @Test
+    fun CameraPermission_denied_returnsNullResult() {
+        val resolution = resolveCameraPermissionResult(
+            permissionGranted = false,
+            pendingDestinationUri = "content://example.provider/camera/photo.jpg",
+        )
+
+        assertIs<CameraPermissionResolution.ReturnNullResult>(resolution)
+    }
+
+    @Test
+    fun CameraPermission_grantedWithPendingUri_requestsCameraLaunch() {
+        val resolution = resolveCameraPermissionResult(
+            permissionGranted = true,
+            pendingDestinationUri = "content://example.provider/camera/photo.jpg",
+        )
+
+        val launch = assertIs<CameraPermissionResolution.LaunchCamera>(resolution)
+        assertEquals("content://example.provider/camera/photo.jpg", launch.uri.toString())
+    }
+
+    @Test
+    fun CameraPermission_grantedWithoutPendingUri_returnsNoOp() {
+        val resolution = resolveCameraPermissionResult(
+            permissionGranted = true,
+            pendingDestinationUri = null,
+        )
+
+        assertIs<CameraPermissionResolution.NoOp>(resolution)
+    }
+
+    @Test
+    fun CameraLaunchSafely_whenSecurityException_returnsFalse() {
+        val launched = launchCameraSafely(Uri.parse("content://example.provider/camera/photo.jpg")) {
+            throw SecurityException("camera permission denied")
+        }
+
+        assertFalse(launched)
+    }
+
+    @Test
+    fun CameraLaunchSafely_whenNoError_returnsTrue() {
+        val expectedUri = Uri.parse("content://example.provider/camera/photo.jpg")
+        var launchedUri: Uri? = null
+
+        val launched = launchCameraSafely(expectedUri) { uri ->
+            launchedUri = uri
+        }
+
+        assertTrue(launched)
+        assertEquals(expectedUri, launchedUri)
+    }
+
     @Test
     fun PickerResult_singleModeWhenCancelled_emitsNullResult() {
         val consumed = mutableListOf<Any?>()
diff --git a/filekit-dialogs-compose/src/androidMain/kotlin/io/github/vinceglb/filekit/dialogs/compose/FileKitCompose.android.kt b/filekit-dialogs-compose/src/androidMain/kotlin/io/github/vinceglb/filekit/dialogs/compose/FileKitCompose.android.kt
@@ -2,6 +2,7 @@
 
 package io.github.vinceglb.filekit.dialogs.compose
 
+import android.Manifest
 import android.content.Context
 import android.content.Intent
 import android.net.Uri
@@ -21,11 +22,14 @@ import androidx.compose.runtime.remember
 import androidx.compose.runtime.rememberUpdatedState
 import androidx.compose.runtime.saveable.rememberSaveable
 import androidx.compose.runtime.setValue
+import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.platform.LocalInspectionMode
 import androidx.core.net.toUri
 import io.github.vinceglb.filekit.FileKit
 import io.github.vinceglb.filekit.PlatformFile
+import io.github.vinceglb.filekit.dialogs.FileKitAndroidCameraPermissionInternal
 import io.github.vinceglb.filekit.dialogs.FileKitAndroidDialogsInternal
+import io.github.vinceglb.filekit.dialogs.FileKitCameraFacing
 import io.github.vinceglb.filekit.dialogs.FileKitDialogSettings
 import io.github.vinceglb.filekit.dialogs.FileKitMode
 import io.github.vinceglb.filekit.dialogs.FileKitOpenCameraSettings
@@ -280,6 +284,10 @@ public actual fun rememberCameraPickerLauncher(
     // Store the destination file URI string to survive process death.
     // If the user launches again before a callback, latest launch wins.
     var pendingDestinationUri by rememberSaveable { mutableStateOf<String?>(null) }
+    var pendingCameraFacingName by rememberSaveable { mutableStateOf(FileKitCameraFacing.System.name) }
+    var hasPendingPermissionRequest by rememberSaveable { mutableStateOf(false) }
+
+    val context = LocalContext.current
 
     // Updated callback
     val currentOnResult by rememberUpdatedState(onResult)
@@ -294,22 +302,104 @@ public actual fun rememberCameraPickerLauncher(
         currentOnResult(resolveCameraResult(success, pendingUri))
     }
 
+    val permissionLauncher =
+        rememberLauncherForActivityResult(ActivityResultContracts.RequestPermission()) { permissionGranted ->
+            if (!hasPendingPermissionRequest) return@rememberLauncherForActivityResult
+            hasPendingPermissionRequest = false
+
+            when (
+                val resolution = resolveCameraPermissionResult(
+                    permissionGranted = permissionGranted,
+                    pendingDestinationUri = pendingDestinationUri,
+                )
+            ) {
+                CameraPermissionResolution.NoOp -> {
+                    Unit
+                }
+
+                CameraPermissionResolution.ReturnNullResult -> {
+                    pendingDestinationUri = null
+                    currentOnResult(null)
+                }
+
+                is CameraPermissionResolution.LaunchCamera -> {
+                    val cameraFacing = runCatching {
+                        FileKitCameraFacing.valueOf(pendingCameraFacingName)
+                    }.getOrDefault(FileKitCameraFacing.System)
+
+                    contract.setCameraFacing(cameraFacing)
+                    val isLaunched = launchCameraSafely(
+                        uri = resolution.uri,
+                        launch = launcher::launch,
+                    )
+                    if (!isLaunched) {
+                        pendingDestinationUri = null
+                        currentOnResult(null)
+                    }
+                }
+            }
+        }
+
     // Return the PhotoResultLauncher wrapper
-    return remember(launcher, contract) {
-        PhotoResultLauncher { type, cameraFacing, destinationFile ->
+    return remember(launcher, permissionLauncher, contract, context) {
+        PhotoResultLauncher { _, cameraFacing, destinationFile ->
             // Store the destination URI for retrieval after potential activity recreation
             val uri = destinationFile.toAndroidUri(openCameraSettings.authority)
             pendingDestinationUri = uri.toString()
+            pendingCameraFacingName = cameraFacing.name
+
+            if (FileKitAndroidCameraPermissionInternal.needsRuntimeCameraPermission(context)) {
+                hasPendingPermissionRequest = true
+                permissionLauncher.launch(Manifest.permission.CAMERA)
+                return@PhotoResultLauncher
+            }
 
             // Set the camera facing on the contract before launching
             contract.setCameraFacing(cameraFacing)
 
             // Launch the camera
-            launcher.launch(uri)
+            val isLaunched = launchCameraSafely(
+                uri = uri,
+                launch = launcher::launch,
+            )
+            if (!isLaunched) {
+                pendingDestinationUri = null
+                currentOnResult(null)
+            }
         }
     }
 }
 
+internal sealed interface CameraPermissionResolution {
+    data object NoOp : CameraPermissionResolution
+
+    data object ReturnNullResult : CameraPermissionResolution
+
+    data class LaunchCamera(
+        val uri: Uri,
+    ) : CameraPermissionResolution
+}
+
+internal fun resolveCameraPermissionResult(
+    permissionGranted: Boolean,
+    pendingDestinationUri: String?,
+): CameraPermissionResolution {
+    if (!permissionGranted) return CameraPermissionResolution.ReturnNullResult
+
+    val pendingUri = pendingDestinationUri ?: return CameraPermissionResolution.NoOp
+    return CameraPermissionResolution.LaunchCamera(pendingUri.toUri())
+}
+
+internal fun launchCameraSafely(
+    uri: Uri,
+    launch: (Uri) -> Unit,
+): Boolean = try {
+    launch(uri)
+    true
+} catch (_: SecurityException) {
+    false
+}
+
 internal fun resolveCameraResult(
     success: Boolean,
     pendingDestinationUri: String?,
diff --git a/filekit-dialogs/build.gradle.kts b/filekit-dialogs/build.gradle.kts
@@ -20,6 +20,10 @@ kotlin {
             implementation(libs.androidx.activity.ktx)
         }
 
+        androidHostTest.dependencies {
+            implementation(libs.test.android.robolectric)
+        }
+
         jvmMain.dependencies {
             implementation(libs.jna)
             implementation(libs.jna.platform)
diff --git a/filekit-dialogs/src/androidHostTest/kotlin/io/github/vinceglb/filekit/dialogs/AndroidCameraPermissionTest.kt b/filekit-dialogs/src/androidHostTest/kotlin/io/github/vinceglb/filekit/dialogs/AndroidCameraPermissionTest.kt
@@ -0,0 +1,55 @@
+@file:Suppress("ktlint:standard:function-naming", "TestFunctionName")
+@file:OptIn(io.github.vinceglb.filekit.dialogs.FileKitDialogsInternalApi::class)
+
+package io.github.vinceglb.filekit.dialogs
+
+import android.os.Build
+import kotlin.test.Test
+import kotlin.test.assertFalse
+import kotlin.test.assertTrue
+
+class AndroidCameraPermissionTest {
+    @Test
+    fun CameraPermission_sdkBelowM_doesNotRequestRuntimePermission() {
+        val shouldRequest = FileKitAndroidCameraPermissionInternal.shouldRequestRuntimeCameraPermission(
+            apiLevel = Build.VERSION_CODES.LOLLIPOP_MR1,
+            isCameraPermissionDeclared = true,
+            isCameraPermissionGranted = false,
+        )
+
+        assertFalse(shouldRequest)
+    }
+
+    @Test
+    fun CameraPermission_declaredAndDenied_requestsRuntimePermission() {
+        val shouldRequest = FileKitAndroidCameraPermissionInternal.shouldRequestRuntimeCameraPermission(
+            apiLevel = Build.VERSION_CODES.M,
+            isCameraPermissionDeclared = true,
+            isCameraPermissionGranted = false,
+        )
+
+        assertTrue(shouldRequest)
+    }
+
+    @Test
+    fun CameraPermission_notDeclared_doesNotRequestRuntimePermission() {
+        val shouldRequest = FileKitAndroidCameraPermissionInternal.shouldRequestRuntimeCameraPermission(
+            apiLevel = Build.VERSION_CODES.UPSIDE_DOWN_CAKE,
+            isCameraPermissionDeclared = false,
+            isCameraPermissionGranted = false,
+        )
+
+        assertFalse(shouldRequest)
+    }
+
+    @Test
+    fun CameraPermission_declaredAndGranted_doesNotRequestRuntimePermission() {
+        val shouldRequest = FileKitAndroidCameraPermissionInternal.shouldRequestRuntimeCameraPermission(
+            apiLevel = Build.VERSION_CODES.UPSIDE_DOWN_CAKE,
+            isCameraPermissionDeclared = true,
+            isCameraPermissionGranted = true,
+        )
+
+        assertFalse(shouldRequest)
+    }
+}
diff --git a/filekit-dialogs/src/androidMain/kotlin/io/github/vinceglb/filekit/dialogs/FileKit.android.kt b/filekit-dialogs/src/androidMain/kotlin/io/github/vinceglb/filekit/dialogs/FileKit.android.kt
@@ -2,13 +2,16 @@
 
 package io.github.vinceglb.filekit.dialogs
 
+import android.Manifest
 import android.content.ClipData
 import android.content.Context
 import android.content.Intent
 import android.content.Intent.ACTION_VIEW
 import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
 import android.content.Intent.FLAG_GRANT_READ_URI_PERMISSION
+import android.content.pm.PackageManager
 import android.net.Uri
+import android.os.Build
 import androidx.activity.ComponentActivity
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.ActivityResultRegistry
@@ -116,16 +119,75 @@ public actual suspend fun FileKit.openCameraPicker(
     openCameraSettings: FileKitOpenCameraSettings,
 ): PlatformFile? {
     val registry = FileKit.registry
+    if (!FileKitAndroidCameraPermissionInternal.requestCameraPermissionIfNeeded(registry, context)) {
+        return null
+    }
+
     val contract = TakePictureWithCameraFacing(cameraFacing)
     val uri = destinationFile.toAndroidUri(openCameraSettings.authority)
-    val isSaved = awaitActivityResult(
-        registry = registry,
-        contract = contract,
-        input = uri,
-    )
+    val isSaved = try {
+        awaitActivityResult(
+            registry = registry,
+            contract = contract,
+            input = uri,
+        )
+    } catch (_: SecurityException) {
+        return null
+    }
     return if (isSaved) destinationFile else null
 }
 
+@FileKitDialogsInternalApi
+public object FileKitAndroidCameraPermissionInternal {
+    public fun isPermissionDeclared(
+        context: Context,
+        permission: String,
+    ): Boolean {
+        val requestedPermissions = runCatching {
+            @Suppress("DEPRECATION")
+            context.packageManager
+                .getPackageInfo(context.packageName, PackageManager.GET_PERMISSIONS)
+                .requestedPermissions
+                .orEmpty()
+        }.getOrElse {
+            return false
+        }
+
+        return requestedPermissions.contains(permission)
+    }
+
+    public fun needsRuntimeCameraPermission(context: Context): Boolean {
+        val cameraPermissionGranted =
+            context.checkSelfPermission(Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED
+        return shouldRequestRuntimeCameraPermission(
+            apiLevel = Build.VERSION.SDK_INT,
+            isCameraPermissionDeclared = isPermissionDeclared(context, Manifest.permission.CAMERA),
+            isCameraPermissionGranted = cameraPermissionGranted,
+        )
+    }
+
+    public fun shouldRequestRuntimeCameraPermission(
+        apiLevel: Int,
+        isCameraPermissionDeclared: Boolean,
+        isCameraPermissionGranted: Boolean,
+    ): Boolean = apiLevel >= Build.VERSION_CODES.M && isCameraPermissionDeclared && !isCameraPermissionGranted
+
+    public suspend fun requestCameraPermissionIfNeeded(
+        registry: ActivityResultRegistry,
+        context: Context,
+    ): Boolean {
+        if (!needsRuntimeCameraPermission(context)) {
+            return true
+        }
+
+        return awaitActivityResult(
+            registry = registry,
+            contract = ActivityResultContracts.RequestPermission(),
+            input = Manifest.permission.CAMERA,
+        )
+    }
+}
+
 /**
  * Contract for taking a picture with camera facing support.
  *
diff --git a/sample/androidApp/src/main/AndroidManifest.xml b/sample/androidApp/src/main/AndroidManifest.xml
