Time to sync up! Tune in for Google I/O on May 14, 2024. Register now.

Cette page a été traduite par l'API Cloud Translation.

Kotlin Fundamentals 01.3: ressources d'images et compatibilité

Cet atelier de programmation fait partie du cours Android Kotlin Fundamentals. Vous tirerez le meilleur parti de ce cours si vous suivez les ateliers de programmation dans l'ordre. Tous les ateliers de programmation du cours sont répertoriés sur la page de destination des ateliers de programmation Android Kotlin Fundamentals.

Présentation

Dans cet atelier de programmation, vous allez améliorer l'application DiceRoller du dernier atelier de programmation, et apprendre à ajouter et à utiliser des ressources d'image dans votre application. Vous découvrirez également la compatibilité de l'application avec différentes versions d'Android et comment Android Jetpack peut vous aider.

Ce que vous devez déjà savoir

Créer un projet d'application, et l'exécuter sur un émulateur ou un appareil physique
Composants de base d'un projet d'application, y compris le répertoire de ressources (res) et les fichiers de compilation Gradle.
Comment modifier le fichier de mise en page de l'application
Comment rechercher et modifier les objets de vue dans le code de votre application.

Points abordés

Comment ajouter des fichiers aux ressources de votre appli
Utiliser les images dans la mise en page de votre application
Comment trouver les vues plus efficacement dans le code de votre application.
Utiliser des images d'espace réservé dans la conception de votre application avec des espaces de noms XML
Découvrez les niveaux d'API Android pour votre application et les niveaux minimum, ciblé et compilé de l'API.
Comment utiliser les bibliothèques Jetpack dans votre application pour prendre en charge les anciennes versions d'Android

Objectifs de l'atelier

Modifier l'application DiceRoller du dernier atelier de programmation de manière à inclure des images pour la valeur du dé, plutôt qu'un nombre.
Ajoutez des fichiers image aux ressources de votre application.
Mettez à jour la mise en page et le code de l'application afin d'utiliser des images pour la valeur du dé plutôt que pour un nombre.
Modifiez votre code pour trouver des vues plus efficacement.
Mettez à jour votre code pour utiliser une image vide au démarrage de l'application.
Mettez à jour votre application pour utiliser les bibliothèques Android Jetpack pour assurer la rétrocompatibilité avec les anciennes versions d'Android.

Dans cet atelier de programmation, vous allez utiliser l'application DiceRoller que vous avez lancée dans l'atelier de programmation précédent, puis ajouter des images de dés qui changent lorsque l'utilisateur lance le dé. L'application finale DiceRoller ressemble à ceci:

Si vous n'avez pas suivi l'atelier de programmation, vous pouvez le télécharger ici: DiceRoller.

À la fin du dernier atelier de programmation, vous avez eu une application qui met à jour une vue textuelle avec un nombre compris entre 1 et 6 chaque fois que l'utilisateur appuie sur un bouton. Cependant, l'application s'appelle DiceRoller, et non 1-6 générateur de nombres. Ce serait intéressant si l'application s'appelait aux dés. Dans cette tâche, vous allez ajouter des images de dés à votre application. Au lieu de modifier le texte lorsque vous appuyez dessus, vous en changez une pour chaque résultat de lancer.

Étape 1: Ajoutez les images

Ouvrez le projet d'application DiceRoller dans Android Studio s'il n'est pas déjà ouvert. Si vous n'avez pas suivi l'atelier de programmation, vous pouvez le télécharger ici: DiceRoller.
Dans la vue "Project > Android", développez le dossier res, puis drawable.

Votre application utilise de nombreuses ressources telles que des images et des icônes, des couleurs, des chaînes et des mises en page XML. Toutes ces ressources sont stockées dans le dossier res. Vous devez placer toutes les ressources d'image de votre application dans le dossier drawable. Les icônes de lanceur d'applications se trouvent déjà dans ce dossier drawable.
Double-cliquez sur ic_launcher_background.xml. Notez qu'il s'agit de fichiers XML qui décrivent l'icône comme une image vectorielle. Les vecteurs permettent de tracer vos images dans différentes tailles et résolutions. Il peut être nécessaire d'adapter les images bitmap (au format PNG ou GIF, par exemple) pour différents appareils, ce qui peut entraîner une perte de qualité.
Cliquez sur Preview (Prévisualiser) dans la colonne de droite de l'éditeur XML pour afficher le drawable vectoriel au format visuel.
Téléchargez les images de dés pour votre application depuis DiceImages.zip. Décompressez l'archive. Vous devez disposer d'un dossier de fichiers XML semblable à celui-ci:

Dans Android Studio, cliquez sur le menu déroulant en haut de la vue du projet avec Android, puis choisissez Project (Projet). La capture d'écran ci-dessous montre comment se présente votre application dans le système de fichiers.
Développez DiceRoller > app > src > principal > res > drawable.
Faites glisser tous les fichiers XML du dossier DiceImages vers Android Studio et dans le dossier drawable. Cliquez sur OK.

Revenez au projet Android et notez que les fichiers XML de votre image de dés se trouvent dans le dossier drawable.
Double-cliquez sur dice_1.xml, puis notez le code XML de cette image. Cliquez sur le bouton Prévisualiser pour obtenir un aperçu de ce drawable vectoriel.

Étape 2 : Mettez à jour la mise en page pour utiliser des images

Maintenant que les fichiers d'image figurent dans le dossier res/drawables, vous pouvez y accéder à partir de la mise en page et du code de l'application. Au cours de cette étape, vous allez remplacer la TextView qui affiche les chiffres par une ImageView pour afficher les images.

Ouvrez le fichier de mise en page activity_main.xml s'il n'est pas déjà ouvert. Cliquez sur l'onglet Text (Texte) pour afficher le code XML de la mise en page.
Supprimez l'élément <TextView>.
Ajoutez un élément <ImageView> avec les attributs suivants:

<ImageView
   android:id="@+id/dice_image"
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"
   android:layout_gravity="center_horizontal"
   android:src="@drawable/dice_1" />

Vous utilisez un ImageView pour afficher une image dans votre mise en page. Le seul attribut de cet élément est android:src, pour indiquer la ressource source pour l'image. Dans ce cas, une source d'image @drawable/dice_1 indique qu'Android doit rechercher les ressources drawables (res/drawable) pour l'image nommée dice_1.

Cliquez sur le bouton Aperçu pour prévisualiser la mise en page. Le résultat devrait se présenter comme suit:

Étape 3: Mettez à jour le code

Ouvrez MainActivity. Voici à quoi ressemble la fonction rollDice() jusqu'à présent:

private fun rollDice() {
   val randomInt = Random().nextInt(6) + 1

   val resultText: TextView = findViewById(R.id.result_text)
   resultText.text = randomInt.toString()
}

Notez que la référence à R.id.result_text peut être mise en surbrillance en rouge. Cela signifie que vous avez supprimé le champ TextView de la mise en page et que cet ID n'existe plus.

Supprimez les deux lignes situées à la fin de la fonction qui définissent la variable resultText et définissent sa propriété de texte. Vous n'utilisez plus de TextView dans la mise en page. Vous n'avez donc pas besoin de l'une ou de l'autre.
Utilisez findViewByID() pour obtenir une référence à la nouvelle ImageView dans la mise en page par ID (R.id.dice_image), puis attribuez cette vue à une nouvelle variable diceImage:

val diceImage: ImageView = findViewById(R.id.dice_image)

Ajoutez un bloc when pour choisir une image de dé spécifique en fonction de la valeur de randomInteger:

val drawableResource = when (randomInt) {
   1 -> R.drawable.dice_1
   2 -> R.drawable.dice_2
   3 -> R.drawable.dice_3
   4 -> R.drawable.dice_4
   5 -> R.drawable.dice_5
   else -> R.drawable.dice_6
}

Comme pour les ID, vous pouvez référencer les images de dés dans le dossier drawable avec les valeurs de la classe R. Ici, R.drawable fait référence au dossier drawable de l'application, et dice_1 est une ressource d'image de dé spécifique dans ce dossier.

Mettez à jour la source du ImageView avec la méthode setImageResource() et la référence à l'image du dé ainsi que vous venez de trouver.

diceImage.setImageResource(drawableResource)

Compilez et exécutez l'application. Maintenant, lorsque vous cliquez sur le bouton Roul, l'image doit se mettre à jour avec l'image appropriée.

Tout fonctionne avec votre application, mais il ne suffit pas d'avoir du code pour le développer. Vous devez également comprendre comment créer des applications performantes et performantes. Cela signifie que vos applications devraient fonctionner correctement, même si votre utilisateur n'a pas l'appareil Android le plus cher ou la meilleure connectivité réseau. Vos applications devraient continuer à fonctionner correctement lorsque vous ajoutez d'autres fonctionnalités. Votre code doit être lisible et bien organisé.

Dans cette tâche, vous allez découvrir comment optimiser votre application.

Ouvrez MainActivity si ce n'est pas déjà fait. Dans la méthode rollDice(), notez la déclaration de la variable diceImage:

val diceImage : ImageView = findViewById(R.id.dice_image)

rollDice() étant le gestionnaire de clics du bouton Roll, chaque fois que l'utilisateur appuie sur ce bouton, votre application appelle findViewById() et obtient une autre référence à ce ImageView. Idéalement, vous devriez réduire le nombre d'appels à findViewById(), car c'est le système Android qui effectue la recherche dans l'ensemble de la hiérarchie des vues à chaque fois, et cette opération est coûteuse.

Dans une petite application comme celle-ci, ce n'est pas un gros problème. Si vous exécutez une application plus compliquée sur un téléphone plus lent, l'appel continu de findViewById() risque de ralentir votre application. Il est préférable d'appeler findViewById() une seule fois et de stocker l'objet View dans un champ. Si vous conservez la référence ImageView dans un champ, le système peut accéder directement à View à tout moment, ce qui améliore les performances.

En haut de la classe, avant onCreate(), créez un champ pour contenir le ImageView.

var diceImage : ImageView? = null

Idéalement, vous devriez initialiser cette variable ici lorsqu'elle sera déclarée ou dans un constructeur, mais que les activités Android n'utilisent pas de constructeurs. En fait, les vues de la mise en page ne sont pas du tout accessibles aux objets en mémoire tant qu'ils n'ont pas été gonflés dans la méthode onCreate(), par l'appel de setContentView(). Sans cela, vous ne pourrez pas initialiser la variable diceImage.

Une option consiste à définir la variable diceImage comme pouvant être nulle, comme dans cet exemple. Définissez-le sur null lors de sa déclaration, puis attribuez-le au ImageView réel dans onCreate() avec findViewById(). Cette opération complique toutefois votre code, car vous devez maintenant vérifier la valeur null chaque fois que vous souhaitez utiliser diceImage. Il existe une meilleure solution.

Modifiez la déclaration diceImage pour utiliser le mot clé lateinit, puis supprimez l'attribution null:

lateinit var diceImage : ImageView

Le mot clé lateinit promet le compilateur Kotlin que la variable sera initialisée avant que le code n'appelle des opérations. Nous n'avons donc pas besoin d'initialiser la variable dans null ici, et nous pouvons la traiter comme une variable ne pouvant pas être vide lorsque nous l'utilisons. Il est recommandé d'utiliser lateinit avec des champs qui contiennent uniquement des vues.

Dans onCreate(), après la méthode setContentView(), utilisez findViewById() pour obtenir ImageView.

diceImage = findViewById(R.id.dice_image)

Supprimez l'ancienne ligne dans rollDice() qui déclare et obtient ImageView. Vous avez remplacé cette ligne par la déclaration de champ précédemment.

val diceImage : ImageView = findViewById(R.id.dice_image)

Exécutez à nouveau l'application pour vérifier qu'elle fonctionne toujours comme prévu.

Actuellement, vous utilisez dice_1 comme image initiale du dé. À la place, vous voulez n'afficher aucune image tant que le dé n'est pas lancé pour la première fois. Pour ce faire, plusieurs méthodes s'offrent à vous.

Ouvrez activity_layout.xml dans l'onglet Text.
Dans l'élément <ImageView>, définissez l'attribut android:src sur "@drawable/empty_dice" :

android:src="@drawable/empty_dice"

L'image empty_dice est l'une des images que vous avez téléchargées et ajoutées au dossier drawable. C'est la même taille que les autres dés, mais il est vide. Cette image sera celle qui s'affichera au premier démarrage de l'application.

Cliquez sur l'onglet Design. L'image du dé est vide, mais elle n'est pas non plus visible dans l'aperçu.

Il est assez fréquent que le contenu d'une conception soit défini de manière dynamique au moment de l'exécution. Par exemple, toute application qui récupère des données sur Internet doit probablement démarrer avec un écran vide. Toutefois, cette étape est utile lorsque vous concevez une application destinée à disposer de données d'espace réservé afin d'identifier l'organisation.
Dans activity_layout.xml, copiez la ligne android:src et collez-en une deuxième. Remplacez le mot "android" par "tools"", de sorte que vos deux attributs se présentent comme suit:

android:src="@drawable/empty_dice" 
tools:src="@drawable/empty_dice" />

Vous avez modifié l'espace de noms XML de cet attribut pour le remplacer par l'espace de noms par défaut android par l'espace de noms tools. L'espace de noms tools permet de définir du contenu réservé qui ne sera utilisé que dans l'aperçu ou dans l'éditeur de conception dans Android Studio. Les attributs qui utilisent l'espace de noms tools sont supprimés lors de la compilation de l'application.

Les espaces de noms permettent de résoudre les ambiguïtés lorsque des attributs portent le même nom. Par exemple, ces deux attributs de la balise <ImageView> portent le même nom (src), mais l'espace de noms est différent.

Examinez l'élément <LinearLayout> à la racine du fichier de mise en page, puis notez les deux espaces de noms définis ici.

<LinearLayout
   xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   ...

Remplacez l'attribut tools:src de la balise ImageView par dice_1 au lieu de empty_dice :

android:src="@drawable/empty_dice" 
tools:src="@drawable/dice_1" />

Notez que l'image dice_1 est maintenant en tant qu'image d'espace réservé dans l'aperçu.

Compilez et exécutez l'application. Notez que l'image du dé est vide dans l'application jusqu'à ce que vous cliquiez dessus ou que vous cliquiez dessus.

L'un des grands avantages du développement pour Android est le nombre d'appareils sur lesquels votre code peut être exécuté, du Nexus One au Pixel, en passant par les facteurs de forme tels que les tablettes, les Pixelbooks, les montres, les téléviseurs et les voitures.

Lorsque vous écrivez pour Android, vous n'avez pas besoin d'applications complètement distinctes pour chacun de ces appareils. Même les applications qui s'exécutent sur des facteurs de forme radicalement différents, comme les montres et les téléviseurs, peuvent partager du code. Cependant, il existe des contraintes et des stratégies de compatibilité que vous devez prendre en compte pour cela.

Dans cette tâche, vous allez apprendre à cibler votre application pour des niveaux d'API Android (versions) spécifiques, et à utiliser les bibliothèques Android Jetpack pour prendre en charge les appareils plus anciens.

Étape 1: Explorez les niveaux d'API

Dans l'atelier de programmation précédent, vous avez indiqué le niveau d'API Android spécifique de votre application que vous avez créé pour votre projet. Le système d'exploitation Android possède des numéros de version différents qui s'intitulent "Délices" dans l'ordre alphabétique. Chaque version d'OS intègre de nouvelles fonctionnalités. Par exemple, Android Oreo est fourni avec les applications Picture-in-picture, tandis qu'Android Pie présente les tranches d'application. Les niveaux d'API correspondent aux versions d'Android. Par exemple, l'API 19 correspond à Android 4.4 (KitKat).

En raison de plusieurs facteurs, y compris la compatibilité du matériel avec le système d'exploitation, si les utilisateurs choisissent de mettre à jour leurs appareils ou si les fabricants acceptent différents niveaux d'OS, les utilisateurs se retrouvent inévitablement avec des appareils équipés de différentes versions.

Lorsque vous créez votre projet d'application, vous spécifiez le niveau d'API minimal accepté par votre application. Autrement dit, vous devez spécifier la version d'Android la plus ancienne compatible avec votre application. Votre application dispose également d'un niveau de compilation et d'un niveau ciblé. Chacun de ces niveaux est un paramètre de configuration dans vos fichiers de compilation Gradle.

Développez le dossier Gradle Scripts (Scripts Gradle), puis ouvrez le fichier build.gradle (Module: app).

Ce fichier définit les paramètres et les dépendances de compilation spécifiques au module d'application. Le fichier build.gradle (projet: DiceRoller) définit les paramètres de compilation pour le projet dans son ensemble. Dans de nombreux cas, votre module d'application est le seul module de votre projet. Cette division peut donc sembler arbitraire. Toutefois, si votre application devient plus complexe et que vous la divisez en plusieurs parties, ou si votre application est compatible avec des plates-formes comme Android Watch, vous pouvez rencontrer différents modules dans le même projet.
Examinez la section android en haut du fichier build.gradle. L'exemple ci-dessous n'est pas l'intégralité de la section, mais il contient ce qui vous intéresse le plus pour cet atelier de programmation.

android {
   compileSdkVersion 28
   defaultConfig {
       applicationId "com.example.android.diceroller"
       minSdkVersion 19
       targetSdkVersion 28
       versionCode 1
       versionName "1.0"
   }

Examinez le paramètre compileSdkVersion.

compileSdkVersion 28

Ce paramètre spécifie le niveau d'API Android que Gradle doit utiliser pour compiler votre application. Il s'agit de la version la plus récente d'Android compatible avec votre application. Autrement dit, votre application peut utiliser les fonctionnalités d'API incluses dans ces niveaux. Dans le cas présent, votre application est compatible avec l'API 28, qui correspond à Android 9 (Pie).

Examinez le paramètre targetSdkVersion, qui se trouve dans la section defaultConfig:

targetSdkVersion 28

Cette valeur correspond à l'API la plus récente pour laquelle vous avez testé votre application. Dans la plupart des cas, il s'agit de la même valeur que compileSdkVersion.

Examinez le paramètre minSdkVersion.

minSdkVersion 19

Ce paramètre est le plus important des trois, car il détermine la version la plus ancienne d'Android sur laquelle votre application sera exécutée. Les appareils fonctionnant sous ce système d'exploitation ne peuvent pas du tout exécuter votre application.

Il peut s'avérer difficile de choisir le niveau d'API minimal pour votre application. Si vous définissez un niveau d'API trop faible, vous manquerez les fonctionnalités plus récentes du système d'exploitation Android. Définissez-la trop haut, et votre application risque de ne s'exécuter que sur des appareils plus récents.

Lorsque vous configurez votre projet et que vous arrivez à l'endroit où vous définissez le niveau minimal d'API pour votre application, cliquez sur M'aider à choisir pour afficher la boîte de dialogue Distribution des versions de l'API. La boîte de dialogue indique le nombre d'appareils utilisant différents niveaux du système d'exploitation, ainsi que les fonctionnalités qui ont été ajoutées ou modifiées dans les niveaux du système d'exploitation. Vous pouvez également consulter les notes de version d'Android et le tableau de bord qui contiennent des informations supplémentaires sur les implications de différents niveaux d'API.

Étape 2: Explorez la compatibilité

Écrire à différents niveaux d'API Android est un défi courant pour les développeurs d'applications. L'équipe du framework Android a donc beaucoup travaillé pour vous aider.

En 2011, l'équipe a lancé la première bibliothèque d'assistance, développée par Google, proposant des classes rétrocompatibles et des fonctions utiles. En 2018, Google a annoncé Android Jetpack, un ensemble de bibliothèques contenant de nombreuses fonctions et classes de la bibliothèque de support, tout en étoffant la bibliothèque de support.

Ouvrez MainActivity.
Notez que votre classe MainActivity s'étend à partir de Activity, mais de AppCompatActivity.

class MainActivity : AppCompatActivity() { 
...

AppCompatActivity est une classe de compatibilité qui garantit que votre activité reste identique sur différents niveaux de plate-forme.

Cliquez sur le symbole + à côté de la ligne commençant par import pour développer les importations de votre classe. Notez que la classe AppCompatActivity est importée à partir du package androidx.appcompat.app. L'espace de noms des bibliothèques Android Jetpack est le suivant : androidx.
Ouvrez build.gradle (Module: app) et faites défiler la page jusqu'à la section des dépendances.

dependencies {
   implementation fileTree(dir: 'libs', include: ['*.jar'])
   implementation"org.jetbrains.kotlin:kotlin-stdlib-jdk7:$kotlin_version"
   implementation 'androidx.appcompat:appcompat:1.0.0-beta01'
   implementation 'androidx.core:core-ktx:1.0.1'
   implementation 'androidx.constraintlayout:constraintlayout:1.1.2'
   testImplementation 'junit:junit:4.12'
   androidTestImplementation 'androidx.test:runner:1.1.0-alpha4'
   androidTestImplementation 
        'androidx.test.espresso:espresso-core:3.1.0-alpha4'
}

Notez la dépendance à la bibliothèque appcompat, qui fait partie de androidx et contient la classe AppCompatActivity.

Étape 3: Ajouter une compatibilité pour les drawable vectoriels

Vous allez utiliser vos nouvelles connaissances sur les espaces de noms, Gradle et la compatibilité pour effectuer un dernier ajustement de votre application afin d'optimiser sa taille sur les anciennes plates-formes.

Développez le dossier res, puis la section drawable. Double-cliquez sur l'une des images de dé.

Comme vous l'avez appris précédemment, toutes les images de dés sont en fait des fichiers XML qui définissent les couleurs et les formes des dés. Ces types de fichiers sont appelés des objets drawables vectoriels. Ce qu'il y a de intéressant entre les graphismes vectoriels et les formats d'image bitmap comme ceux au format PNG, c'est qu'ils peuvent évoluer sans perdre la qualité. De plus, un drawable vectoriel est généralement un fichier beaucoup plus petit que la même image au format bitmap.

Il est important de noter qu'il est compatible avec l'API 21 et les versions ultérieures. Toutefois, le SDK minimal associé à votre application est défini sur l'API 19. Si vous avez testé votre application sur un appareil ou un émulateur API 19, vous constaterez qu'elle semble se développer et s'exécuter correctement. Comment cela fonctionne-t-il ?

Lorsque vous compilez l'application, le processus de compilation Gradle génère un fichier PNG à partir de chacun des fichiers vectoriels, et ces fichiers PNG sont utilisés sur tous les appareils Android de version inférieure à 21. Ces fichiers PNG supplémentaires augmentent la taille de votre application. Elles sont inutilement volumineuses, car elles ralentissent les téléchargements et occupent davantage d'appareils. Les applications volumineuses ont également plus de chances d'être désinstallées, et les utilisateurs ne pourront pas les télécharger ni les annuler.

La bonne nouvelle, c'est qu'il existe une bibliothèque de compatibilité Android X pour les drawable vectoriels jusqu'au niveau 7 de l'API.
Ouvrez build.gradle (Module: app). Ajoutez la ligne suivante à la section defaultConfig:

vectorDrawables.useSupportLibrary = true

Cliquez sur le bouton Sync Now (Synchroniser). Chaque fois qu'un fichier build.gradle est modifié, vous devez synchroniser les fichiers de compilation avec le projet.
Ouvrez le fichier de mise en page main_activity.xml. Ajoutez cet espace de noms à la balise racine <LinearLayout>, sous l'espace de noms tools:

xmlns:app="http://schemas.android.com/apk/res-auto"

L'espace de noms app sert aux attributs qui proviennent de votre code personnalisé ou de bibliothèques, et non du framework Android de base.

Remplacez l'attribut android:src de l'élément <ImageView> par app:srcCompat.

app:srcCompat="@drawable/empty_dice"

L'attribut app:srcCompat utilise la bibliothèque Android X afin d'assurer la compatibilité avec les drawable vectoriels dans les anciennes versions d'Android, jusqu'au niveau d'API 7.

Créez et exécutez votre application. Vous n' verrez rien de nouveau à l'écran, mais votre application n'a plus besoin d'utiliser les fichiers PNG générés pour les images de dés. Peu importe où elles s'exécutent, ce qui réduit le nombre d'images de votre application.

Projet Android Studio: DiceRollerFinal

Défi:modifiez l'application DiceRoller pour avoir deux dés. Lorsque l'utilisateur appuie sur le bouton Roll, chaque dé

Conseil : Créez une fonction privée pour obtenir une image drawable aléatoire et renvoyer un entier pour la ressource drawable. Utilisez cette fonction pour chacune des images de dé.

private fun getRandomDiceImage() : Int { ... }

Code de la solution d'authentification à la programmation

Projet Android Studio: DiceRollerFinal-challenge

Ressources de l'application:

Les ressources de votre application peuvent inclure des images et des icônes, des couleurs standards utilisées dans l'application, des chaînes et des mises en page XML. Toutes ces ressources sont stockées dans le dossier res.
Vous devez placer toutes les ressources d'image de votre application dans le dossier des ressources drawable.

Utiliser des drawables vectoriels dans les vues d'image:

Les drawables vectoriels sont des images décrites au format XML. Les drawables vectoriels sont plus flexibles que les images bitmap (comme les fichiers PNG), car ils peuvent être ajustés à n'importe quelle taille ou résolution.
Pour ajouter un drawable à la mise en page de votre application, utilisez un élément <ImageView>. La source de l'image se trouve dans l'attribut android:src. Pour faire référence au dossier de ressources drawable, utilisez @drawable, par exemple "@drawable/image_name".
Utilisez la vue ImageView dans votre code MainActivity pour l'image. Vous pouvez utiliser setImageResource() pour remplacer l'image de la vue par une autre ressource. Utilisez R.drawable pour faire référence à des drawables spécifiques, par exemple setImageResource(R.drawable.image_name).

Le mot clé lateinit:

Pour réduire le nombre d'appels à findViewById() dans votre code, déclarez les champs contenant ces vues et initialisez les champs dans onCreate(). Utilisez le mot clé lateinit pour ce champ afin d'éviter de le déclarer comme pouvant être nul.

L'espace de noms tools pour les attributs de conception:

Utilisez l'attribut tools:src dans l'élément <ImageView> de votre mise en page pour afficher une image uniquement dans l'éditeur de conception ou d'aperçu Android Studio. Vous pouvez ensuite utiliser une image vide pour android:src dans l'application finale.
Utilisez l'espace de noms tools dans le fichier de mise en page Android pour créer du contenu d'espace réservé ou des conseils de mise en page dans Android Studio. Les données déclarées par les attributs tools ne sont pas utilisées dans l'application finale.

Niveaux d'API:

Chaque système d'exploitation Android est doté d'un nom et d'un numéro de version officiels (par exemple, Android 9.0 & Pie") et d'un niveau d'API (API 28). Utilisez les niveaux d'API dans les fichiers Gradle de votre application pour indiquer les versions d'Android compatibles avec votre application.
Le paramètre compileSdkVersion du fichier build.gradle spécifie le niveau d'API Android que Gradle doit utiliser pour compiler votre application.
Le paramètre targetSdkVersion spécifie le niveau d'API le plus récent pour lequel vous avez testé votre application. Dans de nombreux cas, ce paramètre a la même valeur que compileSdkVersion.
Le paramètre minSdkVersion spécifie le niveau d'API le plus ancien sur lequel votre application peut être exécutée.

Android Jetpack:

Android Jetpack est un ensemble de bibliothèques développées par Google qui propose des classes rétrocompatibles et des fonctions utiles pour les anciennes versions d'Android. Jetpack remplace l'ensemble de bibliothèques précédemment appelées "Bibliothèque d'assistance Android".
Les classes importées à partir du package androidx font référence aux bibliothèques Jetpack. Les dépendances à Jetpack dans votre fichier build.gradle commencent également par androidx.

Compatibilité ascendante pour les drawables vectoriels:

Les objets drawable vectoriels ne sont compatibles de manière native qu'avec les versions d'Android supérieures à l'API 21. Dans les anciennes versions, Gradle génère des images PNG pour ces drawable lorsque votre application est créée.
Vous pouvez spécifier que la bibliothèque Android Support doit être utilisée pour les drawable vectoriels dans les anciennes versions de l'API avec le paramètre de configuration vectorDrawables.useSupportLibrary = true dans le fichier build.gradle.
Une fois la bibliothèque de support activée pour les drawables vectoriels, utilisez l'attribut app:srcCompat dans l'élément <ImageView> (au lieu de android:src) pour spécifier la source drawable vectoriel pour cette image.

L'espace de noms app:

L'espace de noms app dans votre fichier de mise en page XML correspond aux attributs qui proviennent de votre code personnalisé ou de bibliothèques, et non du framework Android de base.

Cours Udacity:

Développer des applications Android avec Kotlin

Documentation pour les développeurs Android:

Autre :

Cette section répertorie les devoirs possibles pour les élèves qui effectuent cet atelier de programmation dans le cadre d'un cours animé par un enseignant. C'est à l'enseignant de procéder comme suit:

Si nécessaire, rendez-les.
Communiquez aux élèves comment rendre leurs devoirs.
Notez les devoirs.

Les enseignants peuvent utiliser ces suggestions autant qu'ils le souhaitent, et ils n'ont pas besoin d'attribuer les devoirs de leur choix.

Si vous suivez vous-même cet atelier de programmation, n'hésitez pas à utiliser ces devoirs pour tester vos connaissances.

Modifier une application

Ajoutez un bouton Clear (Effacer) à l'application DiceRoller qui rétablit l'image du dé sur l'image vide.

Répondez à ces questions.

Question 1

Quel attribut <ImageView> indique une image source qui ne doit être utilisée que dans Android Studio ?

android:srcCompat
app:src
tools:src
tools:sourceImage

Question 2

Quelle méthode modifie la ressource d'image d'un ImageView dans le code Kotlin ? xmx

setImageResource()
setImageURI()
setImage()
setImageRes()

Question 3

Que signifie le mot clé lateinit dans une déclaration de variable en code Kotlin ?

La variable n'est jamais initialisée.
La variable n'est initialisée qu'au moment de l'exécution de l'application.
La variable est automatiquement initialisée sur null.
La variable sera initialisée ultérieurement. Promis !

Question 4

Quelle configuration Gradle indique le niveau d'API le plus récent avec lequel votre application a été testée ?

minSdkVersion
compileSdkVersion
targetSdkVersion
testSdkVersion

Question 5

Votre code contient une ligne d'importation commençant par androidx. Qu'est-ce que cela signifie ?

La classe fait partie des bibliothèques Android Jetpack.
La classe se trouve dans une bibliothèque externe qui sera chargée de manière dynamique lors de l'exécution de l'application.
Le cours est "supplémentaire" et facultatif.
La classe fait partie de la compatibilité XML d'Android.

Envoyer votre appli pour qu'elle soit notée

Assurez-vous que l'application:

La mise en page de l'application doit inclure une vue d'image et deux boutons.
Le code de l'application doit définir deux gestionnaires de clics, un pour chaque bouton.
Le gestionnaire de clics du bouton Clear doit définir l'image du dé sur R.drawable.empty_dice.

Démarrez la leçon suivante : 1.4: Apprenez à vous aider.

Pour obtenir des liens vers d'autres ateliers de programmation dans ce cours, consultez la page de destination des ateliers de programmation Android Kotlin Fundamentals.