Android - Semaine 3

Les applications Android

Applications et activités, manifeste

Cycles de vie
Vues, événements et écouteurs

1 / 53
Android - Semaine 3
Applications et activités

Applications et activités

3 / 53 Pierre Nerzic
Android - Semaine 3
Applications et activités

Présentation

Une application est composée d’une ou plusieurs activités. Chacune

gère un écran d’interaction avec l’utilisateur et est définie par une
classe Java.
Les vues d’une activité (boutons, menus, actions) permettent d’aller
sur une autre activité. Le bouton back permet de revenir sur une
précédente activité. C’est la navigation entre activités.
Une application complexe peut aussi contenir :

des services : ce sont des processus qui tournent en arrière-plan,

des fournisseurs de contenu : ils représentent une sorte de base
de données (contacts,. . . ),
des récepteurs d’annonces : pour gérer des messages envoyés
d’une application à une autre (notifications,. . . ).
4 / 53
Android - Semaine 3
Applications et activités

Déclaration d’une application

Le fichier AndroidManifest.xml déclare les éléments d’une

application, avec un ’.’ devant le nom de classe des activités :
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
<application android:icon="@drawable/app_icon.png" ...>
<activity android:name=".MainActivity" ... />
<activity android:name=".ConfigActivity" ... />
<activity android:name=".DessinActivity" ... />
...
</application>
</manifest>

Une activité qui n’est pas déclarée dans le manifeste ne peut pas
être lancée.
5 / 53
Android - Semaine 3
Applications et activités

Démarrage d’une application

L’une des activités est marquée comme étant démarrable de

l’extérieur, grâce à un sous-élément <intent-filter> :
<activity android:name=".MainActivity" ...>
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
<category android:name="android.intent.category.LAUNCHER"/>
</intent-filter>
</activity>

Un <intent-filter> déclare les conditions de démarrage d’une

activité. Celui-ci indique l’activité principale, celle qu’il faut lancer
quand on clique sur son icône.

6 / 53
Android - Semaine 3
Applications et activités

Démarrage d’une activité et Intents

Les activités sont démarrées à l’aide d’intents. Un Intent contient
une demande destinée à une activité, par exemple, composer un
numéro de téléphone ou lancer l’application.

action : spécifie ce que l’Intent demande. Il y en a de très

nombreuses :
VIEW pour afficher quelque chose, EDIT pour modifier une
information, SEARCH. . .
données : selon l’action, ça peut être un numéro de téléphone,
l’identifiant d’une information. . .
catégorie : information supplémentaire sur l’action, par
exemple, ...LAUNCHER pour lancer une application.

Une application a la possibilité de lancer certaines activités d’une

autre application, celles qui ont un intent-filter.
7 / 53
Android - Semaine 3
Applications et activités

Lancement d’une activité par programme

Soit une application contenant deux activités : Activ1 et Activ2.

La première lance la seconde par :
Intent intent = new Intent(this, Activ2.class);
startActivity(intent);

L’instruction startActivity démarre Activ2. Celle-ci se met au

premier plan, tandis que Activ1 se met en sommeil.
Activ1 reviendra au premier plan quand Activ2 se finira ou quand
l’utilisateur appuiera sur back.
Ce bout de code est employé par exemple lorsqu’un bouton, un
menu, etc. est cliqué. Seule contrainte : que ces deux activités
soient déclarées dans AndroidManifest.xml.

8 / 53
Android - Semaine 3
Applications et activités

Autorisations d’une application

Une application doit déclarer les autorisations dont elle a besoin :

accès à internet, caméra, carnet d’adresse, GPS, etc.
Cela se fait en rajoutant des élements dans le manifeste :
<manifest ... >
<uses-permission
android:name="android.permission.INTERNET" />
...
<application .../>
</manifest>

11 / 53
Android - Semaine 3
Applications et activités

Sécurité des applications (pour info)

Chaque application est associée à un UID (compte utilisateur Unix)

unique dans le système. Ce compte les protège les unes des autres.
Il peut être défini dans le fichier AndroidManifest.xml sous forme
d’un nom de package :
<?xml version="1.0" encoding="utf-8"?>
<manifest ...
android:sharedUserId="fr.iutlan.demos">
...
</manifest>

Définir l’attribut android:sharedUserId avec une chaîne

identique à une autre application, et signer les deux applications
avec le même certificat, permet à l’une d’accéder à l’autre.

12 / 53
Android - Semaine 3
Applications

Applications

13 / 53
Android - Semaine 3
Applications

Fonctionnement d’une application

Au début, le système Android lance l’activité qui est marquée

action=MAIN et catégorie=LAUNCHER dans AndroidManifest.xml.
Ensuite, d’autres activités peuvent être démarrées. Chacune se met
« devant » les autres comme sur une pile. Deux cas sont possibles :

La précédente activité se termine, on ne revient pas dedans.

Par exemple, une activité où on tape son login et son mot de
passe lance l’activité principale et se termine.
La précédente activité attend la fin de la nouvelle car elle lui
demande un résultat en retour.
Exemple : une activité de type liste d’items lance une activité
pour éditer un item quand on clique longuement dessus, mais
attend la fin de l’édition pour rafraîchir la liste.

14 / 53
Android - Semaine 3
Applications

Navigation entre activités

Voici un schéma (Google) illustrant les possibilités de navigation
parmi plusieurs activités.

15 / 53
Android - Semaine 3
Applications

Lancement avec ou sans retour

Rappel, pour lancer Activ2 à partir de Activ1 :

Intent intent = new Intent(this, Activ2.class);
startActivity(intent);

On peut demander la terminaison de this après lancement de

Activ2 ainsi :
Intent intent = new Intent(this, Activ2.class);
startActivity(intent);
finish();

finish() fait terminer l’activité courante. L’utilisateur ne pourra

pas faire back dessus, car elle disparaît de la pile.

16 / 53
Android - Semaine 3
Applications

Lancement avec attente de résultat

Le lancement d’une activité avec attente de résultat est plus

complexe. Il faut définir un code d’appel RequestCode fourni au
lancement.
private static final int APPEL_ACTIV2 = 1;
Intent intent = new Intent(this, Activ2.class);
startActivityForResult(intent, APPEL_ACTIV2);

Ce code identifie l’activité lancée, afin de savoir plus tard que c’est
d’elle qu’on revient. Par exemple, on pourrait lancer au choix
plusieurs activités : édition, copie, suppression d’informations. Il
faut pouvoir les distinguer au retour.

17 / 53
Android - Semaine 3
Applications

Lancement avec attente, suite

Ensuite, il faut définir une méthode callback qui est appelée

lorsqu’on revient dans notre activité :
@Override
protected void onActivityResult(
int requestCode, int resultCode, Intent data)
{
// uti a fait back
if (resultCode == Activity.RESULT_CANCELED) return;
// selon le code d'appel
switch (requestCode) {
case APPEL_ACTIV2: // on revient de Activ2
...
}
}

18 / 53
Android - Semaine 3
Applications

Terminaison d’une activité

L’activité lancée par la première peut se terminer pour deux raisons :

Volontairement, en appelant la méthode finish() :

setResult(RESULT_OK);
finish();

À cause du bouton « back » du téléphone, son action revient à

faire ceci :
setResult(RESULT_CANCELED);
finish();

Dans ces deux cas, on revient dans l’activité appelante (sauf si

elle-même avait fait finish().
19 / 53
Android - Semaine 3
Applications

Méthode onActivityResult
Quand on revient dans l’activité appelante, Android lui fait exécuter
cette méthode :
onActivityResult(int requestCode, int resultCode,
Intent data)

requestCode est le code d’appel de

startActivityForResult
resultCode vaut soit RESULT_CANCELED soit RESULT_OK,
voir le transparent précédent
data est fourni par l’activité appelée et qui vient de se
terminer.

Ces deux dernières viennent d’un appel à setResult(resultCode,

data)

20 / 53
Android - Semaine 3
Applications

Transport d’informations dans un Intent

Les Intent servent aussi à transporter des informations d’une

activité à l’autre : les extras.
Voici comment placer des données dans un Intent :
Intent intent =
new Intent(this, DeleteInfoActivity.class);
intent.putExtra("idInfo", idInfo);
intent.putExtra("hiddencopy", hiddencopy);
startActivity(intent);

putExtra(nom, valeur) rajoute un couple (nom, valeur) dans

l’intent. La valeur doit être sérialisable : nombres, chaînes et
structures simples.

21 / 53
Android - Semaine 3
Applications

Extraction d’informations d’un Intent

Ces instructions récupèrent les données d’un Intent :

Intent intent = getIntent();
Integer idInfo = intent.getIntExtra("idInfo", -1);
bool hidden = intent.getBooleanExtra("hiddencopy", false);

getIntent() retourne l’Intent qui a démarré cette activité.

getTypeExtra(nom, valeur par défaut) retourne la valeur de
ce nom si elle en fait partie, la valeur par défaut sinon.

Il est très recommandé de placer les chaînes dans des constantes,

dans la classe appelée :
public static final String EXTRA_IDINFO = "idInfo";
public static final String EXTRA_HIDDEN = "hiddencopy";

22 / 53
Android - Semaine 3
Applications

Contexte d’application

Pour finir sur les applications, il faut savoir qu’il y a un objet global
vivant pendant tout le fonctionnement d’une application : le
contexte d’application. Voici comment le récupérer :
Application context = this.getApplicationContext();

Par défaut, c’est un objet neutre ne contenant que des informations

Android.
Il est possible de le sous-classer afin de stocker des variables globales
de l’application.

23 / 53
Android - Semaine 3
Applications

Définition d’un contexte d’application

Pour commencer, dériver une sous-classe de Application :

public class MonApplication extends Application
{
// variable globale de l'application
private int varglob;

public int getVarGlob() { return varglob; }

// initialisation du contexte
@Override public void onCreate() {
super.onCreate();
varglob = 3;
}
}

24 / 53
Android - Semaine 3
Applications

Définition d’un contexte d’application, suite

Ensuite, la déclarer dans AndroidManifest.xml, dans l’attribut

android:name de l’élément <application>, mettre un point
devant :
<manifest xmlns:android="..." ...>
<application android:name=".MonApplication"
android:icon="@drawable/icon"
android:label="@string/app_name">
...

25 / 53
Android - Semaine 3
Applications

Définition d’un contexte d’application, fin

Enfin, l’utiliser dans n’importe laquelle des activités :

// récupérer le contexte d'application
MonApplication context =
(MonApplication) this.getApplicationContext();

// utiliser la variable globale

... context.getVarGlob() ...

Remarquez la conversion de type du contexte.

26 / 53
Android - Semaine 3
Activités

Activités

27 / 53
Android - Semaine 3
Activités

Présentation

Voyons maintenant comment fonctionnent les activités.

Démarrage (à cause d’un Intent)

Apparition/masquage sur écran
Terminaison

Une activité se trouve dans l’un de ces états :

active (resumed) : elle est sur le devant, l’utilisateur peut jouer

avec,
en pause (paused) : partiellement cachée et inactive, car une
autre activité est venue devant,
stoppée (stopped) : totalement invisible et inactive, ses
variables sont préservées mais elle ne tourne plus.

28 / 53
Android - Semaine 3
Activités

Cycle de vie d’une activité

Ce diagramme résume les changement d’états d’une activité :

29 / 53
Android - Semaine 3
Activités

Événements de changement d’état

La classe Activity reçoit des événements de la part du système

Android, ça appelle des fonctions appelées callbacks.
Exemples :

onCreate Un Intent arrive dans l’application, il déclenche la

création d’une activité, dont l’interface.
onPause Le système prévient l’activité qu’une autre activité est
passée devant, il faut enregistrer les informations au
cas où l’utilisateur ne revienne pas.

30 / 53
Android - Semaine 3
Activités

Squelette d’activité

public class EditActivity extends Activity

{
@Override
public void onCreate(Bundle savedInstanceState) {
// obligatoire
super.onCreate(savedInstanceState);

// met en place les vues de cette activité

setContentView(R.layout.edit_activity);
}
}

@Override signifie que cette méthode remplace celle héritée de la

superclasse. Il faut quand même l’appeler sur super en premier.
31 / 53
Android - Semaine 3
Activités

Terminaison d’une activité

Voici la prise en compte de la terminaison définitive d’une activité,

avec la fermeture d’une base de données :
@Override
public void onDestroy() {
// obligatoire
super.onDestroy();

// fermer la base
db.close();
}

32 / 53
Android - Semaine 3
Activités

Pause d’une activité

Cela arrive quand une nouvelle activité passe devant, exemple : un

appel téléphonique. Il faut libérer les ressources qui consomment de
l’énergie (animations, GPS. . . ).
@Override public void onPause() {
super.onPause();
// arrêter les animations sur l'écran
...
}
@Override public void onResume() {
super.onResume();
// démarrer les animations
...
}

33 / 53
Android - Semaine 3
Activités

Arrêt d’une activité

Cela se produit quand l’utilisateur change d’application dans le

sélecteur d’applications, ou qu’il change d’activité dans votre
application. Cette activité n’est plus visible et doit enregistrer ses
données.
Il y a deux méthodes concernées :

protected void onStop() : l’application est arrêtée, libérer

les ressources,
protected void onStart() : l’application démarre, allouer
les ressources.

Il faut comprendre que les utilisateurs peuvent changer d’application

à tout moment. La votre doit être capable de résister à ça.

34 / 53
Android - Semaine 3
Activités

Enregistrement de valeurs d’une exécution à l’autre

Il est possible de sauver des informations d’un lancement à l’autre

de l’application (certains cas comme la rotation de l’écran ou une
interruption par une autre activité), dans un Bundle. C’est un
container de données quelconques, sous forme de couples (“nom”,
valeur).
static final String ETAT_SCORE = "ScoreJoueur"; // nom
private int mScoreJoueur = 0; // valeur

@Override
public void onSaveInstanceState(Bundle etat) {
// enregistrer l'état courant
etat.putInt(ETAT_SCORE, mScoreJoueur);
super.onSaveInstanceState(etat);
}

35 / 53
Android - Semaine 3
Activités

Restaurer l’état au lancement

La méthode onRestoreInstanceState reçoit un paramètre de
type Bundle (comme onCreate, mais dans cette dernière, il peut
être null). Il contient l’état précédemment sauvé.
@Override
protected void onRestoreInstanceState(Bundle etat) {
super.onRestoreInstanceState(etat);
// restaurer l'état précédent
mScoreJoueur = etat.getInt(ETAT_SCORE);
}

Ces deux méthodes sont appelées automatiquement (sorte

d’écouteurs), sauf si l’utilisateur tue l’application. Cela permet de
reprendre l’activité là où elle en était.

36 / 53
Android - Semaine 3
Vues et activités

Vues et activités

37 / 53
Android - Semaine 3
Vues et activités

Obtention des vues

La méthode setContentView charge une mise en page (layout) sur

l’écran. Ensuite l’activité peut avoir besoin d’accéder aux vues, par
exemple lire la chaîne saisie dans un texte. Pour cela, il faut obtenir
l’objet Java correspondant.
EditText nom = findViewById(R.id.edt_nom);

Cette méthode cherche la vue qui possède cet identifiant dans le

layout de l’activité. Si cette vue n’existe pas (mauvais identifiant,
ou pas créée), la fonction retourne null.
Un mauvais identifiant peut être la raison d’un bug. Cela peut
arriver quand on se trompe de layout pour la vue. C’est néanmoins
surveillé par Android Studio.

38 / 53
Android - Semaine 3
Vues et activités

Obtention des vues, suite

Pour éviter les problèmes de typage et de vues absentes d’un layout,

il existe un dispositif appelé ViewBindings. Ce sont des classes qui
sont générées automatiquement à partir de chaque layout et dont
les variables membres sont les différentes vues.
Par exemple, soit un layout appelé activity_main.xml :
<LinearLayout ...>

<TextView android:id="@+id/titre" .../>

<Button android:id="@+id/btnOk" .../>

</LinearLayout>

39 / 53
Android - Semaine 3
Vues et activités

Obtention des vues, suite

Cela fait générer une classe appelée ActivityMainBinding.java

et contenant à peu près ceci :

public final class ActivityMainBinding implements ViewBinding

{
private final LinearLayout rootView; // voir getRoot()
public final Button btnOk;
public final TextView titre;

Chaque vue du layout xml possédant un identifiant est reliée à une

variable membre publique dans cette classe, et la vue racine est
accessible par getRoot().
Une méthode statique inflate instancie les différentes vues et la
vue racine peut être fournie à setContentView.
40 / 53
Android - Semaine 3
Vues et activités

Mode d’emploi des ViewBindings

Dans une activité, faire ceci :

public final class MainActivity extends Activity
{
private ActivityMainBinding ui; // ui = interface uti.

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
ui = ActivityMainBinding.inflate(getLayoutInflater());
setContentView(ui.getRoot());

// exemple d'emploi
ui.titre.setText("super cool !");
}

41 / 53
Android - Semaine 3
Vues et activités

Génération des ViewBindings

Il faut rajouter ceci dans app/build.gradle :

plugins {
id 'com.android.application'
}
android {
compileSdkVersion ...
buildToolsVersion "..."
defaultConfig {
...
}
buildFeatures {
viewBinding = true // génération des ViewBindings
}

42 / 53
Android - Semaine 3
Vues et activités

Propriétés des vues

La plupart des vues ont des setters et getters Java pour leurs
propriétés XML. Par exemple TextView.
En XML :
<TextView android:id="@+id/titre"
android:lines="2"
android:text="@string/debut" />

En Java :
TextView tvTitre = ui.titre;
tvTitre.setLines(2);
tvTitre.setText(R.string.debut);

Consulter leur documentation pour les propriétés, qui sont

extrêmement nombreuses.
43 / 53
Android - Semaine 3
Vues et activités

Actions de l’utilisateur

Prenons l’exemple de ce Button. Lorsque l’utilisateur appuie dessus,

ça appelle automatiquement la méthode onValider de l’activité
grâce à l’attribut onClick="onValider".
<Button
android:onClick="onValider"
android:id="@+id/btnValider"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/valider"/>

Il faut définir la méthode onValider dans l’activité :

public void onValider(View btn) {
...
}

44 / 53
Android - Semaine 3
Vues et activités

Définition d’un écouteur

Il y a une autre manière de définir une réponse à un clic : un
écouteur (listener), comme un EventHandler dans JavaFX. Un
écouteur est une instance de classe implémentant l’interface
View.OnClickListener qui possède la méthode public void
onClick(View v).
Cela peut être :
une classe privée anonyme,
une classe privée ou publique dans l’activité,
l’activité elle-même.
Dans tous les cas, on fournit cette instance en paramètre à la
méthode setOnClickListener du bouton :
Button btn = ui.btnValider;
btn.setOnClickListener(ecouteur);
45 / 53
Android - Semaine 3
Vues et activités

Écouteur privé anonyme

Il s’agit d’une classe qui est définie à la volée, lors de l’appel à

setOnClickListener. Elle ne contient qu’une seule méthode.

Button btn = ui.btnValider;

btn.setOnClickListener(
new View.OnClickListener() {
public void onClick(View btn) {
// faire quelque chose
}
});

Dans la méthode onClick, il faut employer la syntaxe

MonActivity.this pour manipuler les variables et méthodes de
l’activité sous-jacente.

46 / 53
Android - Semaine 3
Vues et activités

Écouteur privé anonyme, suite

Il est intéressant de transformer cet écouteur en expression lambda.

C’est une écriture plus compacte qu’on retrouve également en
JavaScript, et très largement employée en Kotlin.
Button btn = ui.btnValider;
btn.setOnClickListener((View btn) -> {
// faire quelque chose
});

Une lambda est une fonction sans nom écrite ainsi :

(paramètres avec ou sans types) -> expression
(paramètres avec ou sans types) -> { corps }

Cette transformation de l’écouteur est possible parce que l’interface

View.OnClickListener ne possède qu’une seule méthode.
47 / 53
Android - Semaine 3
Vues et activités

Écouteur privé

Cela consiste à définir une classe privée dans l’activité ; cette classe
implémente l’interface OnClickListener ; et à en fournir une
instance en tant qu’écouteur.

private class EcBtnValider implements View.OnClickListener {

public void onClick(View btn) {
// faire quelque chose
}
};
public void onCreate(...) {
...
Button btn = ui.btnValider;
btn.setOnClickListener(new EcBtnValider());
}

48 / 53
Android - Semaine 3
Vues et activités

L’activité elle-même en tant qu’écouteur

Il suffit de mentionner this comme écouteur et d’indiquer qu’elle

implémente l’interface OnClickListener.

public class EditActivity extends Activity

implements View.OnClickListener {
public void onCreate(...) {
...
Button btn = ui.btnValider;
btn.setOnClickListener(this);
}
public void onClick(View btn) {
// faire quelque chose
}

Ici, par contre, tous les boutons appelleront la même méthode.

49 / 53
Android - Semaine 3
Vues et activités

Distinction des émetteurs

Dans le cas où le même écouteur est employé pour plusieurs vues, il

faut les distinguer en se basant sur leur identitifiant obtenu avec
getId() :

public void onClick(View v) {

switch (v.getId()) {
case R.id.btn_valider:
...
break;
case R.id.btn_effacer:
...
break;
}
}

50 / 53
Android - Semaine 3
Vues et activités

Écouteur référence de méthode

Il y a une dernière façon très pratique d’associer un écouteur, avec

une référence de méthode, c’est à dire son nom précédé de l’objet
qui la définit :
public void onCreate(...) {
...
Button btn = ui.btnValider;
btn.setOnClickListener(this::onBtnClicked);
}

private void onBtnClicked(View btn) {

// faire quelque chose
}

La syntaxe this::nom_methode est une simplification de

l’expression lambda (params) -> nom_methode(params)
51 / 53
Android - Semaine 3
Vues et activités

Événements des vues courantes

Vous devrez étudier la documentation. Voici quelques exemples :

Button : onClick lorsqu’on appuie sur le bouton,

Spinner : OnItemSelected quand on choisit un élément,
RatingBar : OnRatingBarChange quand on modifie la note,
etc.

Heureusement, dans le cas de formulaires, les actions sont

majoritairement basées sur des boutons.

52 / 53