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

Principes de base d'Android en Kotlin 01.1 : Premiers pas

Cet atelier de programmation fait partie du cours Principes de base d'Android en Kotlin. Vous tirerez pleinement parti de ce cours en suivant les ateliers de programmation dans l'ordre. Tous les ateliers de programmation du cours sont listés sur la page de destination des ateliers de programmation Principes de base d'Android en Kotlin.

Introduction

Dans cet atelier de programmation, vous allez créer et exécuter votre première application Android, HelloWorld, sur un émulateur et sur un appareil physique. Vous verrez également comment se présente un projet Android.

Ce que vous devez déjà savoir

Vous devez comprendre le processus général de développement de logiciels pour les applications orientées objet à l'aide d'un IDE (environnement de développement intégré) tel qu'Android Studio.
Vous devez avoir au moins un an d'expérience en programmation orientée objet, avec au moins une compréhension de Java et de Kotlin.

Points abordés

Vous savez créer une application Android de base dans Android Studio.
Vous savez créer un projet Android à partir d'un modèle.
Découvrez comment trouver les principaux composants d'un projet Android.
Vous savez exécuter une application Android sur un émulateur ou un appareil physique.

Objectifs de l'atelier

Créez un projet Android et une application par défaut nommée HelloWorld.
Créez un émulateur (un appareil virtuel) pour pouvoir exécuter votre application sur votre ordinateur.
Exécutez l'application HelloWorld sur des appareils virtuels et physiques.
Explorez la mise en page du projet.
Explorez le fichier AndroidManifest.xml.

L'application HelloWorld affiche la chaîne "Hello World" sur l'écran d'un appareil virtuel ou physique Android. Voici à quoi ressemble l'application :

Dans cette tâche, vous allez créer un projet d'application pour vérifier qu'Android Studio est correctement installé.

Ouvrez Android Studio si ce n'est pas déjà fait.
Dans la boîte de dialogue principale Bienvenue dans Android Studio, cliquez sur Démarrer un nouveau projet Android Studio.
La boîte de dialogue Choisir votre projet s'affiche. Sélectionnez Empty Activity (Activité vide) comme indiqué ci-dessous, puis cliquez sur Next (Suivant).

Une Activity est une action unique et ciblée que l'utilisateur peut effectuer. Chaque application doit comporter au moins une activité comme point d'entrée. Considérez cette activité de point d'entrée comme la fonction main() dans d'autres programmes. Une activité est généralement associée à une mise en page qui définit la façon dont les éléments de l'interface utilisateur (UI) s'affichent à l'écran. Android Studio fournit plusieurs Activitymodèles pour vous aider à démarrer.
Dans la boîte de dialogue Configure your project (Configurer votre projet), saisissez "HelloWorld" pour le Nom.
Acceptez le domaine android.example.com par défaut pour Domaine de l'entreprise ou créez un domaine d'entreprise unique. Cette valeur, ajoutée au nom de l'application, constitue le nom du package de votre application. Si vous ne prévoyez pas de publier votre application, acceptez la valeur par défaut. Vous pourrez modifier le nom de package de votre application ultérieurement, mais cela vous demandera plus de travail.
Vérifiez que l'emplacement d'enregistrement par défaut correspond à l'emplacement où vous souhaitez stocker votre application. Si ce n'est pas le cas, remplacez-le par le répertoire de votre choix.
Assurez-vous que le champ Langage contient la valeur "Kotlin".
Assurez-vous que le niveau d'API minimal est API 19 : Android 4.4 (KitKat). Au moment de la rédaction de cet atelier de programmation, Android Studio indiquait qu'avec ce niveau d'API, l'application s'exécuterait sur environ 95,3 % des appareils.
(Vous en apprendrez davantage sur les niveaux d'API minimaux dans un atelier de programmation ultérieur. Pour en savoir plus dès maintenant, cliquez sur M'aider à choisir, ce qui ouvre une fenêtre contenant des informations sur les niveaux d'API.)
Cochez la case Utiliser les artefacts AndroidX.
Laissez toutes les autres cases décochées, puis cliquez sur Terminer. Si votre projet nécessite d'autres composants pour le SDK cible choisi, Android Studio les installe automatiquement, ce qui peut prendre un certain temps. Suivez les instructions et acceptez les options par défaut.

Android Studio crée votre projet, ce qui peut prendre un certain temps. Vous ne devriez obtenir aucune erreur. Si des avertissements s'affichent, ignorez-les.

Dans cette tâche, vous allez explorer le projet HelloWorld dans Android Studio et découvrir les bases du développement avec Android Studio.

Étape 1 : Explorez le volet "Projet"

Si l'onglet Projet n'est pas déjà sélectionné, sélectionnez-le. L'onglet Project (Projet) se trouve dans la colonne d'onglets verticaux sur le côté gauche de la fenêtre Android Studio. Le volet "Projet" s'ouvre.
Pour afficher le projet sous la forme d'une hiérarchie de projet Android standard, sélectionnez Android dans le menu déroulant en haut du volet "Project" (Projet). (Android est la valeur par défaut.) Vous pouvez afficher les fichiers du projet de différentes manières, y compris tels qu'ils apparaissent dans la hiérarchie du système de fichiers. Toutefois, il est plus facile de travailler sur le projet à l'aide de la vue Android.

Étape 2 : Explorez le dossier de l'application

L'ensemble du code et des ressources de votre application se trouve dans le dossier app.

Dans le volet Project > Android (Projet > Android), développez le dossier app. Le dossier app contient quatre sous-dossiers : manifests, java, generatedJava et res.
Développez le dossier java, puis le dossier com.example.android.HelloWorld pour afficher le fichier Kotlin MainActivity.

Le dossier java contient tout le code Kotlin principal d'une application Android. Il existe des raisons historiques pour lesquelles votre code Kotlin apparaît dans le dossier java. Cette convention permet à Kotlin d'interagir de manière fluide avec le code écrit dans le langage de programmation Java, même dans le même projet et la même application.

Les fichiers de classe de votre application sont contenus dans trois sous-dossiers, comme indiqué dans la figure ci-dessus. Le dossier com.example.hello.helloworld (ou le nom de domaine que vous avez spécifié) contient tous les fichiers d'un package d'application. En particulier, la classe MainActivity est le point d'entrée principal de votre application. Vous en apprendrez davantage sur MainActivity dans le prochain atelier de programmation. Les deux autres dossiers du dossier java sont utilisés pour le code lié aux tests, tels que les tests unitaires.

Notez le dossier generatedJava. Ce dossier contient les fichiers générés par Android Studio lors de la compilation de l'application. Ne modifiez rien dans ce dossier, car vos modifications pourraient être remplacées lorsque vous recompilerez l'application. Toutefois, il est utile de connaître ce dossier lorsque vous devez consulter ces fichiers lors du débogage.

Étape 3 : Explorez le dossier "res"

Dans le volet Project > Android (Projet > Android), développez le dossier res.

Le dossier res contient les ressources. Les ressources dans Android sont du contenu statique utilisé dans vos applications. Les ressources incluent des images, des chaînes de texte, des mises en page, des styles et des valeurs telles que des couleurs hexadécimales ou des dimensions standards.

Les applications Android séparent autant que possible le code Kotlin et les ressources. Il est ainsi beaucoup plus facile de trouver toutes les chaînes ou icônes utilisées dans l'UI de l'application. De plus, lorsque vous modifiez l'un de ces fichiers de ressources, la modification prend effet partout où le fichier est utilisé dans l'application.
Dans le dossier res, développez le dossier layout pour afficher le fichier activity_main.xml.

Votre Activity est généralement associé à un fichier de mise en page de l'UI, défini comme un fichier XML dans le répertoire res/layout. Ce fichier de mise en page est généralement nommé d'après son activité. Dans ce cas, le nom de l'activité est MainActivity, donc la mise en page associée est activity_main.

Étape 4 : Explorez le dossier des fichiers manifestes et AndroidManifest.xml

Le dossier manifests contient des fichiers qui fournissent des informations essentielles sur votre application au système Android.

Développez le dossier manifests, puis double-cliquez sur AndroidManifest.xml pour l'ouvrir. Le fichier AndroidManifest.xml inclut les informations dont le système Android a besoin pour exécuter votre application, y compris les activités qui en font partie.
Notez que MainActivity est référencé dans l'élément <activity>. Tout Activity de votre application doit être déclaré dans le fichier manifeste. Voici un exemple pour MainActivity :

<activity android:name=".MainActivity">
   <intent-filter>
       <action android:name="android.intent.action.MAIN"/>

       <category android:name="android.intent.category.LAUNCHER"/>
   </intent-filter>
</activity>

Notez l'élément <intent-filter> à l'intérieur de <activity>. Les éléments <action> et <category> de ce filtre d'intent indiquent à Android où démarrer l'application lorsque l'utilisateur clique sur l'icône du lanceur d'applications. Vous en apprendrez davantage sur les filtres d'intent dans un prochain atelier de programmation.

Le fichier AndroidManifest.xml est également l'endroit où vous définissez les autorisations dont votre application a besoin. Les autorisations incluent la possibilité pour votre application de lire les contacts du téléphone, d'envoyer des données sur Internet ou d'accéder à du matériel tel que l'appareil photo de l'appareil.

Gradle est un système d'automatisation de compilation qui utilise un langage propre au domaine pour décrire la structure, la configuration et les dépendances du projet de l'application. Lorsque vous compilez et exécutez votre application, vous voyez des informations sur le build Gradle en cours d'exécution. Vous verrez également des informations sur le kit de package Android (APK) en cours d'installation. (APK est le format de fichier de package utilisé par le système d'exploitation Android pour distribuer et installer des applications mobiles.)

Explorez le système Gradle :

Développez le dossier Scripts Gradle. Dans le volet Project > Android (Projet > Android), ce dossier contient tous les fichiers dont le système de compilation a besoin.
Recherchez le fichier build.gradle(Project: HelloWorld).

Ce fichier contient les options de configuration communes à tous les modules qui composent votre projet. Chaque projet Android Studio contient un seul fichier de compilation Gradle de premier niveau. Ce fichier définit les dépôts et les dépendances Gradle qui sont communs à tous les modules du projet.
Recherchez le fichier build.gradle(Module:app).

En plus du fichier build.gradle au niveau du projet, chaque module possède son propre fichier build.gradle. Le fichier build.gradle au niveau du module vous permet de configurer les paramètres de compilation de chaque module. (L'application HelloWorld ne comporte qu'un seul module, celui de l'application elle-même.) Ce fichier build.gradle est celui que vous modifiez le plus souvent lorsque vous changez les configurations de compilation au niveau de l'application. Par exemple, vous modifiez ce fichier build.gradle lorsque vous changez le niveau du SDK que votre application prend en charge ou lorsque vous déclarez de nouvelles dépendances dans la section dependencies. Vous en apprendrez davantage sur ces deux éléments dans un prochain atelier de programmation.

Dans cette tâche, vous allez utiliser le gestionnaire d'appareils virtuels Android (AVD) pour créer un appareil virtuel (émulateur). L'appareil virtuel simule la configuration d'un type d'appareil Android particulier. Vous pourrez ensuite utiliser cet appareil virtuel pour exécuter l'application.

Android Emulator est une application indépendante qui possède sa propre configuration système requise. Les appareils virtuels peuvent utiliser beaucoup d'espace disque. Si vous rencontrez des problèmes, consultez Exécuter des applications sur Android Emulator.

Étape 1 : Créez un appareil virtuel Android (AVD)

Pour exécuter un émulateur sur votre ordinateur, vous devez créer une configuration qui décrit l'appareil virtuel.

Dans Android Studio, sélectionnez Outils > AVD Manager ou cliquez sur l'icône AVD Manager dans la barre d'outils. La boîte de dialogue Vos appareils virtuels s'affiche. Si vous avez déjà créé des appareils virtuels, la boîte de dialogue les affiche (comme illustré dans la figure ci-dessous). Sinon, une liste vide s'affiche.
Cliquez sur + Créer un appareil virtuel en bas à gauche de la boîte de dialogue. La boîte de dialogue Select Hardware (Sélectionner le matériel) s'affiche et présente une liste d'appareils matériels préconfigurés. Pour chaque appareil, le tableau fournit une colonne pour la taille d'affichage en diagonale (Taille), la résolution d'écran en pixels (Résolution) et la densité de pixels (Densité).
Sélectionnez un appareil, comme Nexus 5x ou Pixel XL, puis cliquez sur Next (Suivant). La boîte de dialogue System Image (Image système) s'affiche.
Cliquez sur l'onglet Recommended (Recommandé), puis sélectionnez la version du système Android à exécuter sur l'appareil virtuel (par exemple, Pie).

Après avoir choisi une image système, cliquez sur Suivant. La boîte de dialogue Android Virtual Device (AVD) (Appareil virtuel Android) s'ouvre. Vérifiez votre configuration, puis cliquez sur Terminer.

Étape 2 : Exécutez l'application sur l'appareil virtuel

Dans cette tâche, vous allez enfin exécuter votre nouvelle application.

Dans Android Studio, sélectionnez Exécuter > Exécuter l'application ou cliquez sur l'icône Exécuter > Exécuter l'application ou cliquez sur l'icône Exécuter [ICON HERE] dans la barre d'outils. [IMAGEINFO]: ic_run.png, icône d'exécution dans Android Studio" style="width: 24.00px" src="img/6c65750f2ce7f651.png"> dans la barre d'outils. La boîte de dialogue Select Deployment Target (Sélectionner une cible de déploiement) s'affiche et vous avertit qu'aucun appareil n'est disponible. Cet avertissement s'affiche si aucun appareil physique n'est connecté à votre ordinateur de développement ou si vous n'avez pas encore lancé d'appareil virtuel.
Dans la boîte de dialogue Select Deployment Target (Sélectionner une cible de déploiement), sous Available Virtual Devices (Appareils virtuels disponibles), sélectionnez l'appareil virtuel que vous avez créé. Cliquez sur OK.

L'émulateur démarre comme s'il s'agissait d'un appareil physique. La durée de cette opération dépend de la vitesse de votre ordinateur. Votre application est créée. Une fois l'émulateur prêt, Android Studio importe l'APK de l'application dans l'émulateur et l'exécute.

L'application HelloWorld devrait s'afficher, comme illustré dans la figure suivante.

Dans cette tâche, vous allez exécuter votre application sur un appareil mobile physique, tel qu'un téléphone ou une tablette, si vous en avez un. Testez toujours vos applications sur des appareils virtuels et physiques.

Ce qu'il vous faut :

Un appareil Android, comme un téléphone ou une tablette.
Un câble de données USB pour connecter votre appareil Android à votre ordinateur via le port USB
Si vous utilisez un système Linux ou Windows, vous devrez peut-être effectuer des étapes supplémentaires. Consultez la documentation Exécuter des applications sur un appareil. Vous devrez peut-être également installer le pilote USB approprié pour votre appareil. Pour les pilotes USB basés sur Windows, consultez Installer des pilotes USB OEM.

Étape 1 : Activez le débogage USB

Pour autoriser Android Studio à communiquer avec votre appareil Android, vous devez activer le débogage USB dans les options pour les développeurs des paramètres de l'appareil.

Sur Android 4.2 (Jellybean) et versions ultérieures, les paramètres Options pour les développeurs sont masqués par défaut. Pour afficher les options pour les développeurs et activer le débogage USB :

Sur votre appareil, ouvrez Paramètres, recherchez À propos du téléphone, appuyez sur À propos du téléphone, puis appuyez sept fois sur Numéro de version.
Revenez à la page précédente (Paramètres / Système). L'option Options pour les développeurs s'affiche dans la liste. Appuyez sur Options pour les développeurs.
Sélectionnez Débogage USB.

Étape 2 : Exécutez votre application sur l'appareil Android

Vous pouvez maintenant connecter votre appareil et exécuter l'application depuis Android Studio.

Connectez l'appareil Android à votre ordinateur de développement à l'aide d'un câble USB. Une boîte de dialogue devrait s'afficher sur l'appareil et vous demander d'autoriser le débogage USB.
Sélectionnez l'option Always allow (Toujours autoriser) pour mémoriser cet ordinateur. Appuyez sur OK.
Sur votre ordinateur, dans la barre d'outils Android Studio, cliquez sur le bouton Run (Exécuter) . La boîte de dialogue Select Deployment Target (Sélectionner une cible de déploiement) s'ouvre et affiche la liste des émulateurs et des appareils connectés disponibles. Votre appareil physique et les éventuels émulateurs devraient s'afficher.
Sélectionnez votre appareil, puis cliquez sur OK. Android Studio installe et exécute l'application sur votre appareil.

Dépannage

Si Android Studio ne reconnaît pas votre appareil, procédez comme suit :

Débranchez le câble USB, puis rebranchez-le.
Redémarrez Android Studio.

Si votre ordinateur ne détecte toujours pas l'appareil ou le déclare comme "non autorisé", procédez comme suit :

Débranchez le câble USB.
Sur l'appareil, ouvrez Options pour les développeurs dans l'application Paramètres.
Appuyez sur Annuler autorisations pour débog. USB.
Reconnectez l'appareil à votre ordinateur.
Lorsque vous y êtes invité, accordez des autorisations.

Vous devrez peut-être installer le pilote USB approprié pour votre appareil. Consultez Exécuter des applications sur un appareil.

Défi : Maintenant que vous êtes prêt et que vous connaissez le workflow de développement de base, procédez comme suit :

Créez un projet dans Android Studio.
Remplacez le message "Hello World" par "Joyeux anniversaire à " suivi du nom d'une personne dont l'anniversaire est récent.

Pour installer Android Studio, accédez à Android Studio et suivez les instructions pour le télécharger et l'installer.
Pour afficher la hiérarchie Android d'une application dans le volet "Projet", cliquez sur l'onglet Projet dans la colonne d'onglets verticale. Sélectionnez ensuite Android dans le menu déroulant en haut de l'écran.
Lorsque vous devez ajouter de nouvelles dépendances à votre projet ou modifier des versions de dépendances, modifiez le fichier build.gradle(Module:app).
L'ensemble du code et des ressources d'une application se trouve dans les dossiers app et res. Le dossier java inclut des activités, des tests et d'autres composants dans le code source Kotlin ou Java (ou les deux). Le dossier res contient des ressources telles que des mises en page, des chaînes et des images.
Pour ajouter des fonctionnalités, des composants et des autorisations à votre application Android, modifiez le fichier AndroidManifest.xml. Tous les composants de l'application, tels que les activités supplémentaires, doivent être déclarés dans ce fichier XML.
Pour créer un appareil virtuel Android (un émulateur) afin d'exécuter votre application, utilisez AVD Manager.
Pour exécuter votre application sur un appareil Android physique à l'aide d'Android Studio, activez le débogage USB sur l'appareil. Pour ce faire, ouvrez Paramètres > À propos du téléphone, puis appuyez sept fois sur Numéro de version. Ouvrez ensuite Paramètres > Options pour les développeurs, puis sélectionnez Débogage USB.

Cours Udacity :

Développer des applications Android avec Kotlin

Documentation Android Studio :

Autre :

Cette section répertorie les devoirs possibles pour les élèves qui suivent cet atelier de programmation dans le cadre d'un cours animé par un enseignant. Il revient à l'enseignant d'effectuer les opérations suivantes :

Attribuer des devoirs si nécessaire
Indiquer aux élèves comment rendre leurs devoirs
Noter les devoirs

Les enseignants peuvent utiliser ces suggestions autant qu'ils le souhaitent, et ne doivent pas hésiter à attribuer d'autres devoirs aux élèves s'ils le jugent nécessaire.

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

Créer et exécuter une application

Créez un projet Android à partir du modèle vide.
Ouvrez le fichier res/strings.xml.
Remplacez la valeur de la chaîne app_name par "My Dice Roller". Ce nom apparaît dans la barre de titre.
Créez un émulateur pour un appareil, en ciblant la version d'Android de votre choix, puis exécutez l'application. Notez comment le titre de l'application a changé.

Répondre aux questions suivantes

Question 1

Quel est le nom du fichier de mise en page pour l'activité principale ?

MainActivity.java
AndroidManifest.xml
activity_main.xml
build.gradle

Question 2

Quel est le nom de la ressource de chaîne qui spécifie le nom de l'application ?

app_name
xmlns:app
android:name
applicationId

Question 3

Quel outil utilisez-vous pour créer un émulateur ?

Android Device Monitor
AVD Manager
SDK Manager
Éditeur de thème

Envoyer votre application pour qu'elle soit notée

Vérifiez que l'application dispose des éléments suivants :

Un Activity qui affiche "Hello World" à l'écran.
Barre de titre indiquant "My Dice Roller" (Mon lanceur de dés).

Passez à la leçon suivante : 1.2 : Anatomie d'une application de base

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