Permission Requests in Android with Jetpack Compose

With the advent of Jetpack Compose, Android UI development has become more intuitive and streamlined. However, certain tasks, such as requesting permissions, still require developers to understand the underlying mechanisms that operate outside the realm of Compose. This blog post will walk you through how to effectively manage permission requests in your Jetpack Compose applications.

Why Permissions Matter

Permissions are crucial in Android applications to access device features like the camera, location, or contacts. Properly handling permissions ensures that your app functions smoothly while respecting user privacy and maintaining a positive user experience.

Understanding the Basics

In traditional Android development, permission requests were handled through activities and fragments, typically involving callbacks to handle user responses. With Jetpack Compose, we shift towards a more declarative paradigm, but we still need to interact with the Android system to request permissions.

Setting Up Your Project

Before diving into permission requests, ensure your project is set up for Jetpack Compose:

1. Add Dependencies:

Ensure that your build.gradle file includes the necessary Jetpack Compose dependencies:

dependencies {
    implementation("androidx.activity:activity-compose:1.6.0")
    implementation("androidx.compose.ui:ui:1.4.3")
    implementation("androidx.compose.material:material:1.4.3")
    implementation("androidx.compose.ui:ui-tooling-preview:1.4.3")
    implementation("androidx.lifecycle:lifecycle-runtime-ktx:2.6.0")
    implementation("androidx.lifecycle:lifecycle-viewmodel-compose:2.6.0")
}

2. Update Android Manifest:

Declare the necessary permissions in your AndroidManifest.xml file:

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

Requesting Permissions in Jetpack Compose

Using rememberLauncherForActivityResult

Jetpack Compose provides a convenient way to launch activities and handle results using rememberLauncherForActivityResult. This mechanism can be used for permission requests as well.

Here’s a step-by-step guide to requesting permissions using Compose:

1. Create a Permission Request Launcher:

Use rememberLauncherForActivityResult to create a launcher that will handle the permission request:

@Composable
fun RequestPermissionExample() {
    val context = LocalContext.current
    val permissionLauncher = rememberLauncherForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { isGranted ->
        if (isGranted) {
            Toast.makeText(context, "Permission Granted", Toast.LENGTH_SHORT).show()
        } else {
            Toast.makeText(context, "Permission Denied", Toast.LENGTH_SHORT).show()
        }
    }

    Column(
        modifier = Modifier.fillMaxSize(),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        Button(onClick = { permissionLauncher.launch(Manifest.permission.CAMERA) }) {
            Text("Request Camera Permission")
        }
    }
}

2. Handling Permission Results:

In the lambda provided to rememberLauncherForActivityResult, you can handle the result of the permission request. This example uses a Toast message to inform the user of the permission status.

Requesting Multiple Permissions

If your application needs multiple permissions simultaneously, you can use ActivityResultContracts.RequestMultiplePermissions.

@Composable
fun RequestMultiplePermissionsExample() {
    val context = LocalContext.current
    val multiplePermissionsLauncher = rememberLauncherForActivityResult(
        ActivityResultContracts.RequestMultiplePermissions()
    ) { permissions ->
        permissions.entries.forEach {
            val permission = it.key
            val isGranted = it.value
            if (isGranted) {
                Toast.makeText(context, "$permission Granted", Toast.LENGTH_SHORT).show()
            } else {
                Toast.makeText(context, "$permission Denied", Toast.LENGTH_SHORT).show()
            }
        }
    }

    Column(
        modifier = Modifier.fillMaxSize(),
        horizontalAlignment = Alignment.CenterHorizontally,
        verticalArrangement = Arrangement.Center
    ) {
        Button(
            onClick = {
                multiplePermissionsLauncher.launch(
                    arrayOf(
                        Manifest.permission.CAMERA,
                        Manifest.permission.ACCESS_FINE_LOCATION
                    )
                )
            }
        ) {
            Text("Request Camera and Location Permissions")
        }
    }
}

Best Practices

1. Explain the Need for Permissions: Always inform users why your app requires certain permissions. This can be done through an educational UI component before the request.
2. Handle Denied Permissions Gracefully: If a user denies permission, ensure your app degrades gracefully and offers alternative paths where possible.
3. Respect User Decisions: Once a user denies permission, avoid repeatedly asking for it unless it’s critical for the app’s functionality.
4. Check Permission Status: Always check the current permission status before requesting. This helps avoid unnecessary requests.

fun isPermissionGranted(context: Context, permission: String): Boolean {
    return ContextCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED
}