TP2 Android

Utilisez un fichier Layout pour votre activité

Une activité, ou Activity, en anglais, est une brique fondamentale d'Android. C'est le point d'entrée de
n'importe quelle application Android.

Une activité a pour rôle principal d'interagir avec l'utilisateur. C'est une classe Java ou Kotlin, qui hérite
obligatoirement de la classe Android Activity ou AppCompatActivity.

Par définition, une activité Android hérite toujours (plus ou moins directement) de la classe Activity. Sur les
versions d'Android un peu plus anciennes, certaines fonctionnalités récentes ne sont pas officiellement
supportées. De ce fait, hériter d'AppCompatActivity permet de corriger ce problème en "émulant" ces
nouvelles fonctionnalités.
Si vous souhaitez avoir deux écrans dans votre application, par exemple un écran de connexion et un
écran de tutoriel, vous aurez généralement deux activités : la première qui gère la partie connexion et la
seconde qui gère l'affichage du tutoriel. Par convention, le nom d'une activité est toujours suffixé
par Activity et écrit en CamelCase. Ainsi, vous nommerez vos activités LoginActivity et TutorialActivity.

Afin de déterminer quels éléments graphiques utiliser et comment les positionner à l'écran, nous
utilisons un fichier layout. Un fichier layout est un fichier XML que l'activité va charger après avoir été
instanciée. Ce fichier XML est toujours stocké dans le répertoire res/layout de votre projet. Par convention,
s'il est lié à une activité, il est toujours suffixé par activity, mais cette fois le tout en minuscules et séparé par
un underscore (_). Ainsi, le fichier layout associé à MainActivity est activity_main.xml.

Construisez l'interface
L'éditeur graphique
Sous Android Studio, naviguez dans l'arborescence du projet et ouvrez le fichier activity_main.xml situé
dans res/layout en double-cliquant dessus.
Par défaut, Android Studio ouvre l'éditeur en mode Design, c'est-à-dire que vous pouvez placer et
configurer les différents éléments graphiques avec votre souris, et générer automatiquement le contenu
XML. Cela semble séduisant, mais nous allons plutôt utiliser le mode Split, permettant d'avoir une meilleure
maîtrise de l'ensemble. Pour ce faire, cliquez sur l'onglet Split en haut à droite de l'écran, et vous verrez
apparaître le contenu XML.

Cliquez sur l'onglet Split pour basculer le layout en mode Text

Le contenu par défaut peut varier suivant les versions d'Android Studio :

<?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:layout_width="match_parent"

android:layout_height="match_parent"

tools:context=".MainActivity">

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:text="Hello World!"

app:layout_constraintBottom_toBottomOf="parent"

app:layout_constraintLeft_toLeftOf="parent"

app:layout_constraintRight_toRightOf="parent"

app:layout_constraintTop_toTopOf="parent" />

</androidx.constraintlayout.widget.ConstraintLayout>

Vous verrez automatiquement apparaître le rendu du contenu XML, c'est-à-dire un écran avec le texte Hello
World!.

Les conteneurs
Pour afficher des éléments à l'écran, il est impératif d'utiliser un conteneur. Un conteneur est un élément
particulier permettant d'organiser les éléments qu'il contient entre eux.

Pour mieux comprendre le principe de conteneur, transposons cela dans le monde réel : imaginez que vous
souhaitiez accrocher au mur vos différentes photos de vacances. Vous allez très probablement acheter un
grand cadre dans lequel vous allez coller ou punaiser toutes vos photos.
Dans le monde virtuel d'Android, vos photos correspondent aux éléments que vous souhaitez montrer à
l'utilisateur (un champ texte ou une zone de saisie), et le grand cadre correspond à un conteneur.

Dans le fichier XML de notre projet, le premier élément XML que nous voyons est du
type androidx.constraintlayout.widget.ConstraintLayout. Cet élément est un conteneur. Android suffixe
toujours le nom des conteneurs par Layout. Dans cet exemple, le conteneur contient un
élément TextView, utilisé pour afficher le texte Hello World!.

Parmi les conteneurs proposés par Android, nous pouvons noter par exemple :

 FrameLayout : permet de positionner les éléments les uns au-dessus des autres ;
 LinearLayout : permet de positionner les éléments les uns à la suite des autres, dans le sens
horizontal ou vertical ;
 RelativeLayout : permet de positionner les éléments les uns par rapport aux autres ;
 ConstraintLayout : comme le RelativeLayout, mais avec des règles de positionnement beaucoup
plus puissantes.

Il est trop tôt pour utiliser le ConstraintLayout, nous allons donc le remplacer par LinearLayout, beaucoup
plus simple. Pour ce faire, remplacez la balise
XML androidx.constraintlayout.widget.ConstraintLayout par LinearLayout, puis supprimez tout ce qui
se rattache au tag app. Vous devez obtenir le résultat suivant :
De façon littérale, nous venons d'écrire :

Les attributs
Occupation de l'espace
Chaque balise XML possède plusieurs attributs. Au minimum, les deux attributs fondamentaux
sont layout_width et layout_height. Ils permettent de déterminer comment afficher un élément au sein de
son conteneur. Les trois valeurs possibles sont :

 match_parent : l'élément doit s'étendre le plus possible afin d'occuper le maximum d'espace
disponible offert par son parent (vous pourriez voir apparaître de temps en temps fill_parent au
détour d'un tutorial ou d'un site web : c'est un attribut obsolète, ancêtre de match_parent) ;
 wrap_content : l'élément doit prendre le moins d'espace possible et n'occuper que la place
nécessaire à l'affichage de son contenu ;
 0dp : la taille de l’élément est définie par ses contraintes (nous verrons comment contraindre un
élément plus tard avec le ConstraintLayout).
L'élément TextView varie en fonction des attributs d'occupation de l'espace

Gravitation
La notion de gravitation peut s'appliquer à un élément ou à son contenu. Elle permet de déterminer
comment positionner un élément par rapport à son conteneur, ou comment positionner le contenu d'un
élément, par exemple le titre d'un bouton.

Pour définir le positionnement d'un élément, c'est l'attribut android:layout_gravity qu'il faut utiliser. Les
valeurs possibles sont nombreuses : left ou start, right ou end, center, center_vertical, center_horizontal,
etc.

Pour définir le positionnement d'un titre au sein d'un bouton ou d'un champ texte, par exemple, c'est
l'attribut android:gravity qu'il faut utiliser. Les valeurs possibles sont identiques à l'attribut layout_gravity.

Pour bien saisir la différence, regardez le résultat produit selon les valeurs utilisées :
Définissez le positionnement d'un élément grâce à l'attribut android:layout_gravity
Texte
Nous allons remplacer le texte de l'élément TextView afin d'accueillir convenablement l'utilisateur. Il vous
suffit pour cela de remplacer la valeur de l'élément android:text, par exemple : "Bienvenue dans TopQuiz.
Quel est votre prénom ?". Le texte dans le rendu à droite doit automatiquement se mettre à jour.
Marge
Vous constatez que le texte de l'élément TextView est collé en haut à gauche de son conteneur, ce qui
n'est pas l'idéal. Pour le décoller légèrement du bord, il est nécessaire d'ajouter
l'attribut android:layout_margin, permettant de préciser une grandeur de marge. La valeur se mesure
en dp, pour density-independent pixels. Par exemple, en précisant une valeur de 8 dp, vous verrez
l'élément s'éloigner des bords. Si vous ne souhaitez modifier qu'une seule marge, vous pouvez utiliser les
versions suffixées
suivantes : layout_marginTop, layout_marginBottom, layout_marginStart ou layout_marginEnd.

Utiliser l'unité de mesure dp permet de s'affranchir des incohérences d'affichage suivant la résolution des
téléphones. Dit autrement, imaginez que vous définissiez un élément qui fasse 20 pixels de haut. Sur un
téléphone dont l'écran fait 100 pixels de haut (si si, je vous assure, cela existait dans les années 80),
l'élément occuperait 20 % de l'espace, alors que son affichage n'occuperait que 2 % d'espace sur un
téléphone récent. L'élément serait donc illisible.
Padding
Le padding (ou rembourrage, en français), consiste à ajouter de l'espace entre le contenu d'un élément et
les bords de cet élément.
 Le padding consiste à ajouter
de l'espace entre le contenu d'un élément et les bords de cet élément
En ajoutant une marge et du rembourrage à l'élément TextView de votre projet, vous devez obtenir le
résultat suivant (seul l'élément TextView est présenté) :

<TextView

android:layout_width="wrap_content"

android:layout_height="wrap_content"
 android:layout_margin="16dp"

android:padding="8dp"

android:text="Welcome! What's your name?" />

Vous aurez sûrement remarqué que les valeurs de margins et paddings sont des multiples de 4 (8 dp,
16 dp). Les composants Android sont conçus pour être affichés sur une grille de 4 dp, vous permettant
d’avoir un beau rendu sans être un UI designer !

Voilà, vous en savez suffisamment sur la mise en page des éléments, nous allons maintenant étudier les
éléments de contrôle pour interagir avec l'utilisateur.

Les éléments de contrôle

Zone de saisie
Pour que l'utilisateur puisse taper son prénom, il faut lui présenter un élément lui permettant de saisir du
texte. Sous Android, c'est l'élément EditText qui porte ce rôle. Pour ce faire, toujours dans le
fichier activity_main.xml, ajoutez un élément EditText.

Dès que vous commencez à saisir le chevron et les premières lettres, Android Studio vous propose
automatiquement tous les choix possibles. Dès que vous voyez apparaître EditText, sélectionnez-le et
appuyez sur la touche Entrée ou la touche de tabulation.

Android Studio vous ajoute ensuite automatiquement les attributs layout_width et layout_height. Il vous
positionne également le curseur sur la première valeur. Commencez à saisir les premières lettres
de match_parent et complétez automatiquement en appuyant sur Entrée ou Tabulation. Passez à la ligne
layout_height automatiquement avec Tabulation ou Entrée, et mettez cette fois wrap_content comme
valeur. Enfin, appuyez sur Entrée ou Tabulation pour “sortir” des guillemets, et fermez l’élément XML avec
la touche /. Android Studio s’occupe de rajouter le chevron manquant, c'est magique !

Toutefois, le champ de saisie est comprimé entre le texte et le bord droit de l'écran. Il aurait été plus
judicieux qu'il soit positionné en dessous de l'élément TextView, n'est-ce pas ? Si vous vous en souvenez,
nous avons dit que le conteneur LinearLayout permettait de positionner les éléments les uns à la suite des
autres. Par défaut, ce positionnement s'effectue horizontalement.

Pour changer ce comportement, il vous suffit d'ajouter l'attribut orientation à l'élément LinearLayout, avec
la valeur "vertical" (de la même façon, vous pouvez simplement saisir les premières lettres, et Android
Studio se chargera de compléter l'ensemble pour vous).

Tout comme pour le champ texte, nous pouvons ajouter une marge afin d'éviter que la zone de saisie ne
soit trop proche des bords, par exemple à gauche et à droite.

Il est également possible d'ajouter un indice à l'aide de l'attribut android:hint. Cet indice apparaît dans le
champ texte pour apporter une information à l'utilisateur, puis disparaît dès qu'il commence à saisir du
texte.

Vous devez obtenir le résultat suivant (seul l'élément EditText est présenté) :

<EditText

android:layout_width="match_parent"

android:layout_height="wrap_content"

android:layout_marginStart="16dp"

android:layout_marginEnd="16dp"

android:hint="Please type your name" />

Bouton
Comme pour l'élément TextView, l'attribut à utiliser pour spécifier le titre est android:text. Nous décidons
de nommer le bouton "Let's play ». Voici le résultat :

<Button

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_gravity="center_horizontal"

android:layout_margin="16dp"

android:text="Let's play" />

Affichez l'interface
La classe MainActivity a été créée automatiquement par Android Studio lors de la création du projet,
lorsque nous avons choisi le modèle Empty Activity. La seule méthode implémentée est la suivante :

@Override

protected void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

setContentView(R.layout.activity_main);

}
La méthode onCreate() est appelée lorsque l'activité est créée (nous verrons plus en détail le cycle de vie
d'une activité à la fin de ce cours). La ligne qui nous intéresse ici est la ligne n° 4 : la
méthode setContentView() permet de déterminer quel fichier layout utiliser.

Le fichier layout à utiliser est précisé avec une syntaxe particulière : R.layout.nom_du_fichier (sans
l'extension XML). Petite explication : lors de la compilation du projet, Android Studio génère une classe
Java appelée R (pour Resources), qui contient l'ensemble des identifiants de toutes les ressources du
projet. Ces ressources peuvent être des fichiers layout, des chaînes de caractères, etc. Nous verrons à
quoi ressemble cette classe après avoir compilé le projet.

Petite astuce : vous pouvez naviguer facilement dans le code source en utilisant la souris et en cliquant sur
une méthode, une classe ou un paramètre. Pour ce faire, positionnez le curseur sur le mot-clé qui vous
intéresse, maintenez la touche ⌘ enfoncée sur Mac, ou la touche CTRL sous Windows, et faites un clic
gauche. Essayez dans le fichier MainActivity.java en cliquant
sur AppCompatActivity, setContentView ou activity_main !

Référencez les éléments graphiques

Déclaration des variables
Pour rappel, nous avons trois éléments graphiques dans notre interface :

 le texte d'accueil ;
 le champ de saisie du prénom ;
 le bouton de validation.
Afin de pouvoir interagir avec ces éléments, il est nécessaire de les référencer dans le code. Commençons
par ajouter dans la classe MainActivity les trois variables correspondantes :

private TextView mGreetingTextView;

private EditText mNameEditText;

private Button mPlayButton;

Lorsque vous commencerez à saisir un type (par exemple TextView), vous constaterez qu'il apparaît en
rouge. Pourquoi ? Parce que ce type est inconnu : il faut importer la classe où ce type est défini. Par
exemple, pour le type TextView, il faut importer la classe TextView située dans le
package android.widget, en saisissant la ligne suivante en haut du fichier :

import android.widget.TextView;
Heureusement, Android Studio est là pour vous prêter main-forte : dès qu'il détecte la saisie d'un type
inconnu (il faut toujours se méfier des types inconnus, mes parents me l'ont toujours dit), il vous propose
d'importer automatiquement la classe correspondante en appuyant sur ALT + Entrée. Ainsi, le type devient
connu et vos parents sont rassurés.

importez
automatiquement la classe correspondante en appuyant sur ALT + Entrée
Par convention, il est fréquent en Java, et notamment sur Android, de préfixer les attributs avec la
lettre m (pour member en anglais). Cela permet d'un coup d'œil, en lisant le code, de savoir qu'une variable
correspond à une donnée membre. De même, les variables statiques sont préfixées par la lettre s. Vous
pourrez trouver davantage d'informations ici.
Identification des éléments graphiques
Il manque néanmoins une petite chose dans le fichier layout : imaginez que vous ayez cinq éléments
TextView les uns à la suite des autres. Comment les distinguer ? En leur ajoutant un identifiant, bien sûr !
Pour cela, l'attribut à utiliser est android:id, et sa valeur doit être "@+id/votre_identifiant". Notez bien que
l'identifiant doit toujours être préfixé par "@+id/". Par exemple :

<TextView

android:id="@+id/main_textview_greeting"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_margin="16dp"

android:padding="8dp"

android:text="Welcome! What's your name?" />

<EditText

android:id="@+id/main_edittext_name"

android:layout_width="match_parent"

android:layout_height="wrap_content"
 android:layout_marginStart="16dp"

android:layout_marginEnd="16dp"

android:hint="Please type your name" />

<Button

android:id="@+id/main_button_play"

android:layout_width="wrap_content"

android:layout_height="wrap_content"

android:layout_gravity="center_horizontal"

android:layout_margin="16dp"

android:text="Let's play" />

Vous êtes libre d'utiliser le nom d'identifiant que vous souhaitez, mais attention : un identifiant doit être
unique au niveau du projet, ce qui signifie que vous ne pouvez pas utiliser le même identifiant dans deux
fichiers séparés. Pour pallier cette limitation, je vous propose d'utiliser la convention de nommage suivante :
préfixez par le nom du fichier, puis ajoutez son type, et enfin suffixez par une description si besoin.
Branchement des variables
Voilà, nous pouvons maintenant référencer les trois éléments graphiques qui nous intéressent dans le
code. La méthode à utiliser pour cela est findViewById(). Elle prend en paramètre l'identifiant de la vue qui
nous intéresse, et renvoie la vue correspondante. Comme pour le fichier layout, la syntaxe à utiliser pour le
paramètre est spécifique : il faut préciser R.id.identifiant_de_vue.

Voici l'exemple de code que vous pouvez ajouter dans la méthode onCreate() :

mGreetingTextView = findViewById(R.id.main_textview_greeting);

mNameEditText = findViewById(R.id.main_edittext_name);

mPlayButton = findViewById(R.id.main_button_play);
Nos trois éléments graphiques sont référencés.
Gérer les actions de l’utilisateur

Les deux actions les plus importantes à implémenter sont les suivantes :

1. Vérifier la saisie du nom de l'utilisateur.

2. Détecter le clic sur le bouton pour démarrer le jeu.
Vérifiez la saisie de l’utilisateur
Il faut s'assurer que l'utilisateur ait saisi son prénom avant d'aller plus loin. Pour l'empêcher d'aller plus loin,
la façon la plus simple consiste à désactiver le bouton de démarrage de jeu au lancement de l'application,
puis de l'activer lorsqu'il a saisi son prénom. Tout d'abord, ajoutez la ligne suivante dans la
méthode onCreate() :

mPlayButton.setEnabled(false);
Elle permet de désactiver le bouton de l'interface. Assurez-vous d'ajouter cette ligne après l’initialisation de
la variable mPlayButton, sinon vous appellerez la méthode setEnabled() sur un objet non défini, ce qui va
naturellement faire planter l'application.

Ensuite, il faut pouvoir être notifié lorsque l'utilisateur commence à saisir du texte dans le
champ EditText correspondant. Pour ce faire, nous allons appeler la
méthode addTextChangedListener() sur l'instance d'EditText, en utilisant une implémentation d'interface
sous forme de classe anonyme.

Voici le code que vous allez ajouter dans onCreate(), à la suite du code existant :

mNameEditText.addTextChangedListener(new TextWatcher() {

@Override

public void beforeTextChanged(CharSequence s, int start, int count, int after) {

@Override

public void onTextChanged(CharSequence s, int start, int before, int count) {

@Override

public void afterTextChanged(Editable s) {

// This is where we'll check the user input

});
Afin de vous éviter de tout taper, Android Studio vous proposera des suggestions lorsque vous
commencerez à taper addText... vous pourrez alors appuyer sur la touche de tabulation ou Entrée pour
compléter automatiquement.

D'autre part, lorsque vous commencerez à saisir ce qu'il y a après entre les parenthèses, arrêtez-vous
après avoir tapé le T de TextWatcher : Android Studio va gentiment vous proposer d'implémenter
automatiquement l'interface associée. Appuyez sur Tabulation ou Entrée et là, miracle !

Android vous propose d'implémenter automatiquement l'interface associée

La méthode qui va nous intéresser est celle à la fin : afterTextChanged.

Si vous constatez que les méthodes générées par Android Studio possèdent des signatures
étranges (telle que celle ci-dessous avec i1), c'est qu'il vous manque le code source d'Android.

beforeTextChanged(CharSequence charSequence, int i1, int i2, int i3)

En effet, lorsque vous demandez à Android Studio d'implémenter l'interface pour vous, il va
analyser le code source de l'interface pour récupérer les méthodes à implémenter, et récupérer
les noms des paramètres correspondants. Si le code source n'est pas installé, il va générer des
noms sans aucun sens pour le développeur.
Pour installer le code source, rendez-vous dans les préférences d'Android (raccourci ⌘ +
virgule sous Mac, ou CTRL + ALT + S sous Windows) puis dans la section Appearance
& Behavior > System Settings > Android SDK, ou lancez directement le SDK Manager
depuis l'IDE :
Ensuite, dans l'onglet SDK Platforms, cochez la case Android 11.0 (R) (ou le numéro
correspondant à votre version), puis appuyez sur le bouton Apply.
À chaque fois que l'utilisateur saisira une lettre, la méthode afterTextChanged sera appelée. Cela nous
permettra de déterminer si l'utilisateur a commencé à saisir son prénom, et ainsi activer le bouton de
démarrage de jeu. La logique à appliquer est donc simple : si au moins une lettre a été saisie, alors le
bouton doit être actif (bon, je suis d'accord avec vous, un prénom d'une seule lettre, c'est assez rare. Sauf
pour Q dans James Bond, mais je ne vous garantis pas qu'il utilisera l'application).

Ajoutez simplement la ligne suivante, et cela fera parfaitement l'affaire :

mPlayButton.setEnabled(!s.toString().isEmpty());
Détectez le clic sur le bouton
Une fois le bouton activé, l'utilisateur peut cliquer dessus pour lancer le jeu (nous verrons cela dans la
partie suivante). Pour détecter que l'utilisateur a cliqué sur le bouton, il est nécessaire d'implémenter
un listener. Le principe est identique à la gestion de la saisie présentée au-dessus. Il faut pour cela appeler
la méthode setOnClickListener() sur l'objet mPlayButton, puis implémenter l'interface OnClickListener de
la méthode View, comme ceci :

mPlayButton.setOnClickListener(new View.OnClickListener() {

@Override

public void onClick(View v) {

// The user just clicked

});

La méthode onClick() est appelée chaque fois que l'utilisateur appuie sur le bouton. C'est l'endroit idéal
pour démarrer le jeu, ce que nous verrons dans les chapitres suivants.
Lancez l'application sur l'émulateur ou sur un
équipement réel
Vous avez saisi du code, c'est super, mais concrètement, cela donne quoi ? Ce chapitre vous présente
comment lancer votre application. Vous avez le choix : soit sur un émulateur si vous ne possédez pas
Android, soit sur votre téléphone (ou tablette) si vous en possédez un (ou une).

Utiliser l'émulateur offre l'avantage de générer facilement différentes configurations, avec des tailles d'écran
différentes, une mémoire vive limitée ou une ancienne version d'Android, par exemple. Après, rien ne vaut
un test sur un équipement réel, afin de s'assurer que l'expérience utilisateur soit la meilleure possible.

Lancez l'émulateur
Pour lancer l'application, il suffit de cliquer sur le bouton de lecture vert situé dans la barre de l'IDE :

Cliquez sur le bouton de lecture en vert pour lancer l'émulateur

Ensuite, la fenêtre suivante s'affiche :

Une fenêtre s'ouvre lorsque vous

lancez l'émulateur
Création d'un équipement virtuel
Afin de pouvoir lancer l'application sur l'émulateur, il est nécessaire de créer un équipement virtuel. Un
équipement virtuel correspond à l'association d'un type d'équipement (la partie matérielle) avec une version
d'Android (la partie logicielle). Pour cela, cliquez sur le bouton AVD Manager.
Cliquez sur l'AVD Manager pour créer un équipement virtuel

L’AVD Manager vous permet de gérer vos émulateurs. Pour le moment, c’est un peu vide… On va y
remédier ! Cliquez sur le bouton Create Virtual Device.
Sélectionnez le type d'équipement sur lequel vous allez tester votre application

Dans la partie gauche de la fenêtre, vous pouvez sélectionner le type d'équipement. Dans notre cas, ce
sera Phone, mais à l'avenir vous pourrez choisir Tablet si vous souhaitez tester l'application sur une
tablette.
La partie du milieu liste l'ensemble des équipements disponibles. Chaque équipement possède des
caractéristiques matérielles spécifiques (taille de l'écran, résolution, mémoire disponible, etc.). Si un jour
vous souhaitez émuler un équipement très spécifique (avec un écran très grand ou peu de mémoire), vous
pourrez le créer en cliquant sur le bouton New Hardware Profile. Pour notre besoin, vous pouvez
sélectionner le Pixel 4, qui fera parfaitement l'affaire. Cliquez ensuite sur le bouton Next.

Sélectionnez les caractéristiques matérielles de votre équipement : Pixel 4 et cliquez sur Next

L'image système correspond à la version d'Android à installer sur l'équipement virtuel. Je vous conseille de
rester dans l'onglet Recommended dans un premier temps. Il est possible que vous deviez installer une
image système pour pouvoir aller plus loin : cliquez pour cela sur le lien Download à côté de l'image que
vous souhaitez installer.
Cliquez sur le lien Download pour installer une image système

L'écran Component Installer s'affiche ensuite, le temps de télécharger les fichiers nécessaires. À la fin de
l'installation, cliquez sur le bouton Finish.

De retour sur l'écran System Image, cliquez sur le bouton Next pour arriver sur l'écran Android Virtual
Device Manager (AVD Manager). Cet écran vous permet de vérifier la configuration de votre appareil
virtuel, voire d'en changer certains paramètres. Pour l'instant, je vous conseille de conserver les paramètres
par défaut. Cliquez sur Finish.

Lancement
Vous devez maintenant voir apparaître votre nouvel équipement virtuel dans la fenêtre de l’Android Virtual
Device Manager. L’émulateur est sélectionné automatiquement, vous pouvez donc lancer l’application !
1 : l'émulateur est sélectionné automatiquement, 2 : vous pouvez lancer l'application

Sélectionnez l'équipement puis cliquez sur OK. Normalement, l'émulateur devrait se lancer, et après le
chargement d'Android, vous devriez voir apparaître la fenêtre suivante :
L'application est lancée sur l'émulateur ! Une barre d'outil à droite vous permet de modifier certains
paramètres.
La barre d'outils sur le côté droit de l'émulateur vous permet de modifier certains paramètres. Ils sont tous
assez explicites. Soyez curieux, testez chacun d'eux ! Vous pouvez même cliquer sur les trois petits points
en bas pour afficher davantage de paramètres.

En lançant l'application sur l'émulateur, le focus est fait par défaut sur le premier champ de saisie : vous
devriez voir le curseur positionné et clignoter sur le champ de saisie du prénom. Vous pouvez directement
utiliser le clavier de votre ordinateur pour saisir votre prénom (si vous souhaitez faire s'afficher le clavier
virtuel du téléphone, il vous suffit de cliquer sur le champ de saisie avec votre souris).

Ensuite vous pouvez passer automatiquement à l'élément suivant (en l'occurrence le bouton) en appuyant
sur la touche de tabulation et en appuyant sur la touche Entrée pour simuler le clic sur le bouton. Vous
devriez voir le bouton s'animer. Il ne se passe rien d'autre, c'est normal, car nous ne l'avons pas encore
développé. Cette technique de navigation à partir du clavier est très pratique pour tester un formulaire, par
exemple.

Lancement
Si l'application est déjà lancée sur l'émulateur, arrêtez-la en cliquant sur le bouton Stop (carré rouge situé
sur la barre d'outils d'Android Studio).

Arrêtez l'application en cliquant sur le bouton Stop

Ensuite, cliquez sur le menu déroulant portant le nom de votre émulateur (pour ma part, c’est Pixel 4 API
30). Vous devriez voir apparaître la fenêtre suivante, qui vous permet de choisir entre un lancement de
l'application sur l'émulateur ou sur votre équipement réel (sur le screenshot, HTC HTC_M10h).
Sélectionnez votre équipement puis cliquez sur le bouton “Play” !
Cliquez sur le menu déroulant pour sélectionner le mode de lancement de votre application
Cette activité permettra d'afficher le contenu du jeu. Elle sera démarrée par la première activité lorsque
l'utilisateur cliquera sur le bouton de lancement du jeu.

Vous vous demandez sûrement comment fonctionne le jeu ! C'est une demande légitime. C'est très simple :
TopQuiz va poser une série de quatre questions à l'utilisateur, choisies aléatoirement dans une banque de
plusieurs questions. Pour chaque question, il aura le choix entre quatre réponses possibles. Par exemple :
Visualisez l'aperçu de notre superbe application
Configuration de la nouvelle activité
Création des fichiers
Pour rappel, une activité est généralement composée d'une classe Java et de son fichier layout associé.
Positionnez-vous dans l'arborescence de votre projet, au niveau du répertoire dans lequel est contenue la
classe MainActivity créée précédemment. Faites un clic droit dessus, puis sélectionnez l'option New >
Activity > Empty Activity.
Dans l'arborescence, allez dans New > Activity > Empty Activity pour créer votre fichier layout
Une nouvelle fenêtre s'affiche, vous permettant de configurer le nom de l'activité et de son fichier layout.
Sachant que cette activité va gérer le jeu, nous l'appellerons logiquement GameActivity. Laissez cochée la
case Generate Layout File : le nom du fichier layout généré doit être game_activity. Cliquez sur le
bouton Finish.

Configurez le nom de l'activité et de son fichier layout

Création du layout
L'interface de cette nouvelle activité va contenir les éléments suivants :

 l'intitulé de la question posée à l'utilisateur ;

 les quatre réponses possibles, chacune représentée par un bouton.
Pour ce faire, ouvrez le fichier activity_game.xml situé dans le répertoire res/layout, puis modifiez le code
comme suit :

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout

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

xmlns:tools="http://schemas.android.com/tools"

android:layout_width="match_parent"

android:layout_height="match_parent"

android:orientation="vertical"

android:padding="8dp">

<TextView

android:id="@+id/game_activity_textview_question"

android:layout_width="match_parent"

android:layout_height="0dp"

android:layout_margin="8dp"

android:layout_weight="4"

android:background="@color/teal_700"

android:gravity="center"

android:textColor="@color/white"

android:textSize="18sp"

android:textStyle="bold"

tools:text="Question?" />

<Button

android:id="@+id/game_activity_button_1"

android:layout_width="wrap_content"

android:layout_height="0dp"

android:layout_gravity="center_horizontal"

android:layout_margin="8dp"

android:layout_weight="1"

android:padding="16dp"

android:textSize="20sp"
 tools:text="Answer1" />

<Button

android:id="@+id/game_activity_button_2"

android:layout_width="wrap_content"

android:layout_height="0dp"

android:layout_gravity="center_horizontal"

android:layout_margin="8dp"

android:layout_weight="1"

android:padding="16dp"

android:textSize="20sp"

tools:text="Answer2" />

<Button

android:id="@+id/game_activity_button_3"

android:layout_width="wrap_content"

android:layout_height="0dp"

android:layout_gravity="center_horizontal"

android:layout_margin="8dp"

android:layout_weight="1"

android:padding="16dp"

android:textSize="20sp"

tools:text="Answer3" />

<Button

android:id="@+id/game_activity_button_4"

android:layout_width="wrap_content"

android:layout_height="0dp"

android:layout_gravity="center_horizontal"

android:layout_margin="8dp"
 android:layout_weight="1"

android:padding="16dp"

android:textSize="20sp"

tools:text="Answer4" />

</LinearLayout>

Vous devez déjà être familier avec certains attributs, tels que les marges, le texte à afficher ou les
identifiants assignés aux éléments. Notez bien que les identifiants sont obligatoires, ce sont eux qui
permettront de référencer les éléments depuis le code, et de les mettre à jour dynamiquement. Néanmoins,
d'autres doivent vous interpeller.

L'attribut android:textSize permet d'indiquer une taille spécifique pour la police. L'unité à utiliser est
le sp (alors que c'est le dp pour les distances, rappelez-vous). N'hésitez pas à vous référer à cette page du
Material Design pour avoir les idées plus claires.

L'attribut android:textColor permet de spécifier quelle police de couleur utiliser, pour un champ texte ou un
bouton.

Pour attribuer une couleur à un élément, vous avez le choix entre trois valeurs possibles :

 une valeur hexadécimale, par exemple #990000FF pour un bleu légèrement transparent ;
 une ressource définie au niveau d'Android, par exemple @android:color/white ;
 une ressource définie au niveau de votre projet, par exemple @color/colorPrimary. Vous trouverez
la valeur correspondant à cette ressource dans le fichier colors.xml situé dans le
répertoire res/values.
Plus de précisions sur cette page.
L'attribut android:background prend le même paramètre que textColor, mais permet pour sa part de
préciser la couleur d'arrière-plan de la majorité des éléments (bouton, champ texte, layout, etc.).

L'attribut android:textStyle permet de préciser le style à utiliser pour une police. Vous avez le choix
entre bold (gras), italic (italique) ou normal, la valeur par défaut.

Enfin, le dernier attribut très important est android:layout_weight. C'est un attribut spécifique aux enfants
d'un LinearLayout. Il permet de préciser le poids d'un élément par rapport aux autres. Je m'explique. Si
vous assignez un poids identique pour tous les éléments (par exemple 1), tous ces éléments auront la
même taille. Si vous assignez un poids égal à 2 à l'un des éléments, alors sa taille sera deux fois plus
importante que celle des autres. Essayez de faire varier le poids de l'élément TextView du code ci-dessus.

Lorsque vous utilisez l'attribut layout_weight pour un élément donné, vous devez impérativement spécifier
une hauteur ou une largeur égale à 0 dp, suivant l'orientation. Plus précisément, si l'orientation est
verticale, la hauteur doit être égale à 0 dp. Si l'orientation est horizontale, la largeur doit être égale à 0 dp.
Le résultat produit doit être identique à la capture ci-dessous. Amusez-vous à modifier les différents
attributs pour donner un style qui vous est propre !
L'interface de la nouvelle activité que vous devriez obtenir

Branchement des widgets

Maintenant que les éléments sont définis dans l'interface, il est nécessaire de les référencer dans le code.
Sachant que vous devenez des experts Android, cela ne devrait pas vous poser de problème ! Un petit
coup de pouce pour les plus étourdis :

 déclarez une variable membre privée pour chaque élément que vous souhaitez référencer (vous
devriez avoir une variable de type TextView et quatre de type Button) ;
 dans la méthode onCreate, branchez chaque widget en utilisant la méthode findViewById().
Lancement de la nouvelle activité
C'est bien beau tout ça, mais comment lancer cette nouvelle activité ? En cliquant sur le bouton Let's
Play de l'écran d'accueil ! Certes, mais cela ne vous avance guère.

Rappelez-vous : nous avions commencé à implémenter la méthode onClick dans la classe MainActivity.
Cette méthode est appelée à chaque fois que l'utilisateur appuie sur le bouton. Et c'est à cet endroit précis
que nous allons démarrer notre nouvelle activité.

Pour démarrer une activité, Android propose la méthode startActivity(). Cette méthode propose plusieurs
signatures. Celle qui nous intéresse est la suivante (c'est la plus simple) :

public void startActivity(Intent intent)

Cette méthode permet de communiquer avec le système d'exploitation Android en lui demandant de
démarrer une activité donnée. Pour préciser quelle activité lancer, un objet spécifique est utilisé : Intent.
Lorsque la méthode startActivity() est appelée, l'objet interne Android ActivityManager inspecte le
contenu de l'objet Intent et démarre l'activité correspondante.
Lorsque la méthode startActivity() est appelée, l'objet interne Android ActivityManager inspecte le contenu
de l'objet Intent et démarre l'activité correspondante.

L'objet Intent, quant à lui, peut être créé de différentes façons. Parmi les nombreux constructeurs de la
classe Intent, celui qui nous intéresse est le suivant :

public Intent(Context packageContext, Class<?> cls)

Le premier paramètre correspond au contexte de l'application. Pour faire simple, cela correspond à l'activité
appelante (car la classe Activity hérite de la classe Context). Le second paramètre correspond à la classe
de l'activité à démarrer.

Je vous l'accorde, cela peut sembler bien compliqué pour démarrer une simple activité. Mais dans les faits,
cela se traduit simplement par les deux lignes suivantes :

Intent gameActivityIntent = new Intent(MainActivity.this, GameActivity.class);

startActivity(gameActivityIntent);
Ajoutez ces deux lignes dans la méthode onClick, lancez l'application, cliquez sur le bouton, et vous devez
voir apparaître la nouvelle activité. Pour revenir à l'activité précédente, utilisez le bouton de retour Android
en bas à gauche de l'écran.

Lorsque vous avez créé l'activité GameActivity, Android Studio a automatiquement mis à jour le
fichier AndroidManifest.xml situé dans le répertoire app/manifests, en ajoutant une entrée de type activity.
Cette entrée est indispensable, car elle permet à Android de retrouver la classe correspondant à l'activité
que vous souhaitez démarrer. Essayez de supprimer cette entrée puis de relancer l'application : plantage
assuré !