Android Academy · Leçon

Autorisations et demandes à l’exécution

Déclarez et demandez les autorisations dangereuses à l’exécution avec ActivityResultContracts, affichez des boîtes de dialogue explicatives et gérez les refus permanents.

Autorisations et demandes à l’exécution est une leçon Android Academy gratuite sur CoddyKit. Ceci est la leçon 7 sur 7. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Android Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Android Academy comprend 7 leçons au total.

Présentation des autorisations Android

Les applications Android doivent déclarer les fonctionnalités de l'appareil dont elles ont besoin. Les autorisations protègent la confidentialité des utilisateurs :

Autorisations normales — faible risque, accordées automatiquement (INTERNET, VIBRATE)
Autorisations dangereuses — donnent accès à des données sensibles et doivent être demandées lors de l'exécution (CAMERA, LOCATION, accès aux contacts)
Autorisations de signature — réservées aux applications signées avec le même certificat

Déclaration dans le manifeste

Toutes les autorisations doivent d’abord être déclarées dans AndroidManifest.xml :

<!-- AndroidManifest.xml -->
<manifest ...>

    <!-- Normal: granted automatically -->
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.VIBRATE" />

    <!-- Dangerous: must request at runtime -->
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.READ_CONTACTS" />

    <application ...>
        ...
    </application>
</manifest>

Vérifier si l’autorisation est accordée

Avant d’utiliser une fonctionnalité dangereuse, vérifiez toujours si l’autorisation est déjà accordée :

import androidx.core.content.ContextCompat
import android.content.pm.PackageManager

fun isCameraPermissionGranted(): Boolean {
    return ContextCompat.checkSelfPermission(
        this,   // Context
        android.Manifest.permission.CAMERA
    ) == PackageManager.PERMISSION_GRANTED
}

Demander une autorisation avec ActivityResultLauncher

Utilisez ActivityResultContracts.RequestPermission() — la méthode moderne (sans onRequestPermissionsResult obsolète) :

class CameraActivity : AppCompatActivity() {

    private val requestCameraPermission = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { isGranted ->
        if (isGranted) {
            openCamera()
        } else {
            showPermissionDeniedMessage()
        }
    }

    fun onTakePhotoClick(view: View) {
        if (isCameraPermissionGranted()) {
            openCamera()
        } else {
            requestCameraPermission.launch(android.Manifest.permission.CAMERA)
        }
    }
}

Plusieurs autorisations à la fois

Demandez plusieurs autorisations avec RequestMultiplePermissions :

private val requestMultiple = registerForActivityResult(
    ActivityResultContracts.RequestMultiplePermissions()
) { permissions ->
    val cameraGranted   = permissions[android.Manifest.permission.CAMERA] ?: false
    val locationGranted = permissions[android.Manifest.permission.ACCESS_FINE_LOCATION] ?: false

    if (cameraGranted && locationGranted) {
        startFeature()
    } else {
        showWhichPermissionsDenied(cameraGranted, locationGranted)
    }
}

fun requestPermissions() {
    requestMultiple.launch(arrayOf(
        android.Manifest.permission.CAMERA,
        android.Manifest.permission.ACCESS_FINE_LOCATION
    ))
}

Justification : quand expliquer pourquoi

shouldShowRequestPermissionRationale() renvoie true lorsque l’utilisateur a précédemment refusé l’autorisation. Affichez une explication avant de la demander à nouveau :

fun requestCameraWithRationale() {
    when {
        isCameraPermissionGranted() -> {
            openCamera()
        }
        shouldShowRequestPermissionRationale(android.Manifest.permission.CAMERA) -> {
            // Explain why we need it, then request
            AlertDialog.Builder(this)
                .setTitle("Camera needed")
                .setMessage("We use the camera to take profile photos.")
                .setPositiveButton("OK") { _, _ ->
                    requestCameraPermission.launch(android.Manifest.permission.CAMERA)
                }
                .show()
        }
        else -> {
            requestCameraPermission.launch(android.Manifest.permission.CAMERA)
        }
    }
}

Refus permanent — rediriger vers les paramètres

Si l’utilisateur appuie sur « Ne plus demander », shouldShowRequestPermissionRationale renvoie false et vous ne pouvez plus demander l’autorisation. Redirigez-le vers les paramètres de l’application :

fun openAppSettings() {
    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
        data = Uri.fromParts("package", packageName, null)
    }
    startActivity(intent)
}

Autorisation de localisation

La localisation comporte deux niveaux : choisissez celui qui convient à votre cas d’utilisation :

ACCESS_COARSE_LOCATION — précision au niveau de la ville (WiFi/antennes-relais)
ACCESS_FINE_LOCATION — précision GPS
ACCESS_BACKGROUND_LOCATION — requise séparément sur Android 10 et versions ultérieures pour accéder à la localisation en arrière-plan

Exemple complet d’autorisation de caméra

Flux complet combinant vérification → justification → demande :

class PhotoActivity : AppCompatActivity() {

    private val cameraLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { granted ->
        if (granted) openCamera() else showDenied()
    }

    private fun handleCameraClick() {
        val permission = android.Manifest.permission.CAMERA
        when {
            ContextCompat.checkSelfPermission(this, permission) ==
                    PackageManager.PERMISSION_GRANTED -> openCamera()
            shouldShowRequestPermissionRationale(permission) ->
                showRationaleDialog()
            else -> cameraLauncher.launch(permission)
        }
    }

    private fun showDenied() {
        Snackbar.make(binding.root, "Camera permission required", Snackbar.LENGTH_LONG)
            .setAction("Settings") { openAppSettings() }.show()
    }
}

Bonnes pratiques pour les autorisations

Règles essentielles pour une expérience fluide avec les autorisations :

Demandez les autorisations uniquement lorsque cela est nécessaire (pas au lancement de l’application)
Demandez uniquement les autorisations minimales requises
Gérez toujours le refus avec élégance
Ne redemandez pas l’autorisation après « Ne plus demander »
Expliquez pourquoi avant la boîte de dialogue système, et non après le refus

Autorisations multimédias détaillées sur Android 13 et versions ultérieures

Depuis Android 13 (API 33), READ_EXTERNAL_STORAGE est divisé en autorisations détaillées :

READ_MEDIA_IMAGES
READ_MEDIA_VIDEO
READ_MEDIA_AUDIO

Vérifiez toujours Build.VERSION.SDK_INT et demandez l’autorisation adaptée à la version de l’OS.

Vérification rapide

Quand devez-vous afficher une boîte de dialogue de justification avant de demander une autorisation dangereuse ?

Récapitulatif : autorisations

Bien gérer les autorisations à l’exécution :

Les déclarer dans AndroidManifest.xml
Les vérifier avec ContextCompat.checkSelfPermission()
Les demander via registerForActivityResult(RequestPermission())
Afficher une justification lorsque shouldShowRequestPermissionRationale() vaut true
En cas de refus permanent, guider les utilisateurs vers les paramètres
Ne jamais demander les autorisations avant que l’utilisateur en ait besoin

Ensuite : enregistrer les données localement avec DataStore.

Questions Fréquemment Posées

La leçon « Autorisations et demandes à l’exécution » est-elle gratuite ?

Oui — le texte complet de « Autorisations et demandes à l’exécution » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Android Academy, passe à CoddyKit PRO. Le cours Android Academy comprend 7 leçons au total.

Qu'est-ce que j'apprendrai dans « Autorisations et demandes à l’exécution » ?

Déclarez et demandez les autorisations dangereuses à l’exécution avec ActivityResultContracts, affichez des boîtes de dialogue explicatives et gérez les refus permanents. Tu pratiques Android Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Android Academy ?

Aucune expérience préalable n'est requise. Android Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 7 sur 7.

Combien de temps prend la leçon « Autorisations et demandes à l’exécution » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Android Academy ?

Oui. Chaque leçon Android Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Android Academy