Ajouter des autorisations d'exécution à votre application en Kotlin

1. Bienvenue

Introduction

Les autorisations d'application permettent de fournir un accès à des données et à des fonctionnalités autres que celles fournies par le bac à sable de l'application. Elles contribuent à améliorer la fonctionnalité de votre application en lui permettant d'accéder à Internet, à la position de l'appareil, à l'appareil photo, etc.

Pour utiliser ces fonctionnalités, vous devez demander l'autorisation de l'utilisateur. Cet atelier de programmation vous explique comment ajouter des autorisations d'exécution et comment vérifier si elles sont accordées ou non.

Ce dont vous avez besoin

La dernière version d'Android Studio

Connaissances préalables

Vous connaissez le langage Kotlin, tel qu'enseigné dans la formation Kotlin.
Vous avez des compétences de base en développement Android, telles que celles enseignées dans la formation sur le développement d'applications Android en Kotlin.

Points abordés

Ajouter des autorisations au fichier manifeste Android
Demander des autorisations
Gérer les autorisations acceptées ou refusées
Vérifier si une autorisation a été accordée

Objectifs de l'atelier

Vous créerez une application qui demande l'autorisation d'accéder à un appareil photo. Vous implémenterez la partie "autorisation" de l'application, mais pas la partie "appareil photo".

2. Créer un projet Android Studio

Lancez un nouveau projet Android Studio.
Sélectionnez Empty Activity (Activité vide).

Nommez le projet Autorisations Codelab et définissez le langage Kotlin.

3. Configurer le code

Ajoutez les dernières versions des dépendances suivantes au fichier build.gradle au niveau de l'application. Vous pourrez ainsi utiliser la bibliothèque Activity, que nous aborderons ultérieurement dans cet atelier de programmation.

implementation "androidx.activity:activity-ktx:1.2.2"
implementation "androidx.fragment:fragment-ktx:1.3.2"

Définissez l'option de compilation viewBinding sur "true" dans le bloc Android pour activer ViewBinding.

android {
   ...
   buildFeatures {
       viewBinding true
   }
}

Cliquez ensuite sur le marteau vert pour lancer la compilation. Cette opération génère une classe de liaison appelée ActivityMainBinding que vous utiliserez ultérieurement pour ViewBinding.

Accédez au fichier activity_main.xml et remplacez le code par celui-ci :

<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:tools="http://schemas.android.com/tools"
   android:id="@+id/main_layout"
   android:layout_width="match_parent"
   android:layout_height="match_parent"
   tools:context=".MainActivity">

   <Button
       android:id="@+id/button"
       android:layout_width="wrap_content"
       android:layout_height="wrap_content"
       android:text="Request Permissions"
       android:onClick="onClickRequestPermission"
       app:layout_constraintBottom_toBottomOf="parent"
       app:layout_constraintEnd_toEndOf="parent"
       app:layout_constraintStart_toStartOf="parent"
       app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Ajoutez ces chaînes au fichier strings.xml.

<string name="app_name">Permissions Codelab</string>
<string name="permission_required">Camera access is required to display the camera preview.</string>
<string name="ok">OK</string>
<string name="permission_granted">Permission is granted. You can use the camera now.</string>

Dans MainActivity.kt, au-dessus de la méthode onCreate(), définissez les variables de la mise en page et de ViewBinding.

private lateinit var layout: View
private lateinit var binding: ActivityMainBinding

Remplacez le code de la méthode onCreate() par le code ci-dessous. Ce code initialise la liaison, crée un élément val pour représenter la vue et la définit sur la racine de la liaison, puis définit la mise en page sur l'élément mainLayout de la liaison.

override fun onCreate(savedInstanceState: Bundle?) {
   super.onCreate(savedInstanceState)
   binding = ActivityMainBinding.inflate(layoutInflater)
   val view = binding.root
   layout = binding.mainLayout
   setContentView(view)
}

Au bas du fichier, sous la classe MainActivity, ajoutez une fonction d'extension pour afficher des snackbars tout au long de l'atelier de programmation.

fun View.showSnackbar(
   view: View,
   msg: String,
   length: Int,
   actionMessage: CharSequence?,
   action: (View) -> Unit
) {
   val snackbar = Snackbar.make(view, msg, length)
   if (actionMessage != null) {
       snackbar.setAction(actionMessage) {
           action(this)
       }.show()
   } else {
       snackbar.show()
   }
}

4. Ajouter une autorisation au fichier manifeste

Vous devez d'abord déclarer que l'autorisation sera utilisée dans le fichier Android manifest à l'aide de la balise <uses-permission>.

Parfois, l'autorisation que vous demandez est également soumise à d'autres conditions. Dans ce cas, vous ne pouvez utiliser une application d'appareil photo que si l'appareil en est équipé. C'est pourquoi vous devez également ajouter la balise <uses-feature> au fichier manifeste.

Dans le fichier AndroidManifest.xml, ajoutez l'autorisation d'accéder à l'appareil photo au-dessus de la balise <application>.

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

5. Créer un lanceur d'autorisations

Dans MainActivity.kt, créez un élément val appelé requestPermissionLauncher et copiez-y ce code. Les points ci-dessous détaillent le contenu du code.

private val requestPermissionLauncher =
   registerForActivityResult(
       ActivityResultContracts.RequestPermission()
   ) { isGranted: Boolean ->
       if (isGranted) {
           Log.i("Permission: ", "Granted")
       } else {
           Log.i("Permission: ", "Denied")
       }
   }

Définissez requestPermissionLauncher sur registerForActivityResult et transmettez ActivityResultContracts.RequestPermission().

private val requestPermissionLauncher =
   registerForActivityResult(
       ActivityResultContracts.RequestPermission())

Ajoutez un rappel pour gérer le cas où l'autorisation est accordée ou non. Dans ce cas, nous journalisons le résultat.

{ isGranted: Boolean ->
       if (isGranted) {
           Log.i("Permission: ", "Granted")
       } else {
           Log.i("Permission: ", "Denied")
       }
}

6. Demander une autorisation

Créez une fonction appelée onClickRequestPermission(view: View) et copiez-y ce code. Les points suivants détaillent le contenu du code.

fun onClickRequestPermission(view: View) {
   when {
       ContextCompat.checkSelfPermission(
           this,
           Manifest.permission.CAMERA
       ) == PackageManager.PERMISSION_GRANTED -> {
           layout.showSnackbar(
               view,
               getString(R.string.permission_granted),
               Snackbar.LENGTH_INDEFINITE,
               null
           ) {}
       }

       ActivityCompat.shouldShowRequestPermissionRationale(
           this,
           Manifest.permission.CAMERA
       ) -> {
           layout.showSnackbar(
               view,
               getString(R.string.permission_required),
               Snackbar.LENGTH_INDEFINITE,
               getString(R.string.ok)
           ) {
               requestPermissionLauncher.launch(
                   Manifest.permission.CAMERA
               )
           }
       }

       else -> {
           requestPermissionLauncher.launch(
               Manifest.permission.CAMERA
           )
       }
   }
}

Configurez une instruction when couvrant les trois cas suivants : l'autorisation est déjà accordée, l'application estime qu'elle doit expliquer pourquoi une autorisation est demandée, et l'autorisation n'a pas encore été demandée.

when {
   ContextCompat.checkSelfPermission(
       this,
       Manifest.permission.CAMERA
   ) == PackageManager.PERMISSION_GRANTED -> {

   }

   ActivityCompat.shouldShowRequestPermissionRationale(
       this,
       Manifest.permission.CAMERA
   ) -> {

   }

   else -> {

   }
}

Si l'autorisation est accordée, affichez un snackbar qui annonce cet état de fait.

ContextCompat.checkSelfPermission(
   this,
   Manifest.permission.CAMERA
) == PackageManager.PERMISSION_GRANTED -> {
   layout.showSnackbar(
       view,
       getString(R.string.permission_granted),
       Snackbar.LENGTH_INDEFINITE,
       null
   ) {}
}

Si shouldShowRequestPermissionRationale() renvoie la valeur "true", l'interface utilisateur décrit plus en détail la raison pour laquelle la fonctionnalité a besoin de cette autorisation. Elle permet également à l'utilisateur d'accepter ou de refuser l'autorisation à partir de l'interface utilisateur.

ActivityCompat.shouldShowRequestPermissionRationale(
   this,
   Manifest.permission.CAMERA
) -> {
   layout.showSnackbar(
       view,
       getString(R.string.permission_required),
       Snackbar.LENGTH_INDEFINITE,
       getString(R.string.ok)
   ) {
       requestPermissionLauncher.launch(
           Manifest.permission.CAMERA
       )
   }
}

Sinon, demandez l'autorisation.

else -> {
   requestPermissionLauncher.launch(
       Manifest.permission.CAMERA
   )
}

7. Résumé

Et voilà ! Cet atelier de programmation vous a expliqué comment ajouter des autorisations d'exécution. Il peut s'appliquer aux autorisations concernant la localisation, le réseau, le contenu multimédia, etc.

Pour consulter le code final et en savoir plus, reportez-vous à la documentation.