Jetpack Compose – Gestion des Permissions et Intégration avec Android

Par smanaf, 13 mars, 2025
JC

Aujourd'hui on se retrouve dans le 6ème article pour parler des gestions des permissions et intégration avec android. La gestion des permissions reste un aspect crucial, surtout pour accéder à des fonctionnalités sensibles comme la caméra ou la localisation. Cet article explique comment intégrer la gestion des permissions dans Jetpack Compose, en utilisant les API modernes d'Android.

Pourquoi gérer les permissions ?

Depuis Android 6.0 (API 23), les permissions sensibles doivent être demandées au moment de l'exécution. Cela inclut des permissions telles que l'accès à la caméra, à la localisation et au stockage. Jetpack Compose ne gère pas les permissions nativement, mais l'API ActivityResultContracts permet une gestion simplifiée et déclarative dans Compose.

Demander une permission spécifique

Jetpack Compose utilise ActivityResultContracts.RequestPermission() pour demander une permission spécifique. Voici un exemple de demande d'accès à la caméra :

@Composable
fun PermissionScreen() {
    val context = LocalContext.current
    val permission = Manifest.permission.CAMERA
    val launcher = rememberLauncherForActivityResult(
        contract = ActivityResultContracts.RequestPermission()
    ) { isGranted: Boolean ->
        val message = if (isGranted) "Permission accordée" else "Permission refusée"
        Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
    }

    Column(
        modifier = Modifier.fillMaxSize(),
        verticalArrangement = Arrangement.Center,
        horizontalAlignment = Alignment.CenterHorizontally
    ) {
        Button(onClick = { launcher.launch(permission) }) {
            Text("Demander la permission de la caméra")
        }
    }
}

Ce code affiche un bouton qui, lorsqu'il est cliqué, demande la permission d'accéder à la caméra. Si l'utilisateur accepte ou refuse, un message Toast apparaît pour l'informer.

Demander plusieurs permissions

Il est également possible de demander plusieurs permissions simultanément grâce à ActivityResultContracts.RequestMultiplePermissions(). Cela est utile pour des fonctionnalités qui nécessitent plusieurs accès, par exemple, à la caméra et à la localisation.

val permissionsLauncher = rememberLauncherForActivityResult(
    contract = ActivityResultContracts.RequestMultiplePermissions()
) { permissions ->
    val allGranted = permissions.values.all { it }
    val message = if (allGranted) "Toutes les permissions sont accordées" else "Certaines permissions ont été refusées"
    Toast.makeText(context, message, Toast.LENGTH_SHORT).show()
}

Vérification de l'état des permissions

Avant de demander une permission, il est important de vérifier si elle a déjà été accordée. Utilise ContextCompat.checkSelfPermission() pour effectuer cette vérification. Cela permet d'éviter de redemander une permission déjà obtenue.

if (ContextCompat.checkSelfPermission(context, Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED) {
    // La permission est déjà accordée
} else {
    // Demande la permission
    launcher.launch(Manifest.permission.CAMERA)
}

Gérer le refus de permission

Dans certains cas, l'utilisateur peut refuser une permission. Android propose une méthode pour expliquer pourquoi la permission est nécessaire. Si l'utilisateur refuse, vous pouvez afficher une explication avec shouldShowRequestPermissionRationale().

if (shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {
    AlertDialog(
        onDismissRequest = { /* Close dialog */ },
        title = { Text("Permission nécessaire") },
        text = { Text("Cette permission est requise pour accéder à la caméra.") },
        confirmButton = {
            Button(onClick = { launcher.launch(Manifest.permission.CAMERA) }) {
                Text("Accepter")
            }
        }
    )
} else {
    launcher.launch(Manifest.permission.CAMERA)
}

Importations nécessaires Pour faire fonctionner correctement les exemples de code, voici les importations nécessaires :

import android.Manifest
import android.content.pm.PackageManager
import android.widget.Toast
import androidx.activity.result.contract.ActivityResultContracts
import androidx.compose.foundation.layout.*
import androidx.compose.material3.Button
import androidx.compose.material3.Text
import androidx.compose.runtime.*
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.tooling.preview.Preview
import androidx.core.content.ContextCompat
import androidx.compose.ui.unit.dp
import androidx.compose.material3.AlertDialog
import androidx.compose.material3.Button
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.res.fontResource
import androidx.activity.compose.rememberLauncherForActivityResult
import androidx.compose.ui.platform.LocalContext

Dépendances à ajouter N'oublie pas d'ajouter la dépendance suivante dans ton fichier build.gradle pour gérer les permissions avec Jetpack Compose :

dependencies {
    implementation "com.google.accompanist:accompanist-permissions:0.31.1-alpha"
}

Déclaration des permissions dans le manifeste

Pour que ton application fonctionne correctement, n'oublie pas de déclarer les permissions nécessaires dans le fichier AndroidManifest.xml :

<!-- Déclare la permission d'accès à la caméra de l'appareil -->
<uses-permission android:name="android.permission.CAMERA" />

<!-- Déclare la permission d'accès à la localisation précise -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />

<!-- Déclare la permission d'accès à la localisation approximative -->
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />

<!-- Déclare que l'application utilise le matériel de la caméra -->
<uses-feature android:name="android.hardware.camera" android:required="false" />

Conclusion

En combinant Jetpack Compose avec l'API ActivityResultContracts, la gestion des permissions devient plus simple et fluide. Grâce à cette approche déclarative, vous pouvez créer des interfaces réactives et modernes tout en respectant les bonnes pratiques de gestion des permissions dans Android.

Sources

Étiquettes

Commentaires