La connaissance ne signifie pas

seulement savoir que 1+1=2.

Elle est une combinaison de trois
éléments :

1) Le savoir savant : Je sais que

1+1=2 (Théorie)

2) Le savoir-faire : je sais calculer

1+1=2 (Pratique)

3) Le savoir être : Je sais trouver

que 1+1=2 (Ethique)

PROGRAMMATION DES TERMINAUX MOBILES

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 1
FICHE MATIERE
PRE REQUIS

Notions de base sur le Langage C

OBJECTIFS GENERAUX

A la fin de ce module l’étudiant sera capable de :

 Expliquer les généralités sur les terminaux mobiles
 Comprendre les généralités sur le développement des applications pour terminaux
mobiles
 Installation et Configuration d’Android studio
 Comprendre la création des IHM Mobiles
 Être capable de développer des Applications Mobiles

POPULATION

Profil : Brevet de Technicien Supérieur

Option : Génie Logiciel
Niveau : II

EVALUATION

Contrôle continu
Evaluation semestrielle

MOYENS PEDAGOGIQUES

Support de cours
Travaux Pratiques portant sur le développement des applications mobiles
Choix Technologiques : JDK, Android Studio
Connexion Internet obligatoire

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 2
SOMMAIRE
FICHE MATIERE ........................................................................................................................................................ 2
SOMMAIRE ............................................................................................................................................................... 3
Chapitre 1 GENERALITES SUR LES TERMINAUX MOBILES........................................................................................ 7
I) Définition ......................................................................................................................................................... 7
II) Intérêts des terminaux mobiles dans l'entreprise ........................................................................................... 7
III) Les défis à relever avec les terminaux mobiles............................................................................................ 7
IV) Les types de terminaux mobiles .................................................................................................................. 7
Chapitre 2 GENERALITES SUR LE DEVELOPPEMENT DES APPLICATIONS POUR TERMINAUX MOBILES .................. 8
I) Introduction ..................................................................................................................................................... 8
II) Les types d’applications mobiles ..................................................................................................................... 8
1) Les applications web mobiles .......................................................................................................................... 8
2) Les applications natives ................................................................................................................................... 8
3) Les applications hybrides ................................................................................................................................. 9
III) Récapitulatif ................................................................................................................................................. 9
IV) Domaine d’application des applications mobiles ........................................................................................ 9
Chapitre 3 ENVIRONNEMENT DE DEVELOPPEMENT ............................................................................................. 10
1.1. Introduction .................................................................................................................................................... 10
1.1.1. Android ........................................................................................................................................................ 10
1.1.2. Qu’est-ce qu’Android ? ................................................................................................................................ 10
1.1.3. Composants d’Android ................................................................................................................................ 10
1.1.4. Programmation d’applications .................................................................................................................... 10
1.2. SDK Android et Android Studio ....................................................................................................................... 10
1.2.1. SDK Android ................................................................................................................................................. 10
1.2.2. Android Studio ............................................................................................................................................. 10
1.2.3. Choix de la version ....................................................................................................................................... 10
1.2.4. SDK Manager................................................................................................................................................ 11
1.3. Assistant de création d’une tablette virtuelle ................................................................................................ 11
1.3.1. Caractéristiques d’un AVD ........................................................................................................................... 11
1.3.2. Application sur l’AVD ................................................................................................................................... 11
Chapitre 3 NOTIONS DES ACTIVITES ...................................................................................................................... 12
Introduction ........................................................................................................................................................... 12
3.1) Présentation d’une activité............................................................................................................................. 12
3.2) Présentation du cycle de vie d’une activité .................................................................................................... 12
Chapitre 4 CREATION D’INTERFACES UTILISATEUR .............................................................................................. 14
4.1. Applications et activités .................................................................................................................................. 14

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 3
4.1.1. Composition d’une application .................................................................................................................... 14
4.1.2. Création d’un écran ..................................................................................................................................... 14
4.1.3. Structure d’une interface utilisateur ........................................................................................................... 14
4.2. Ressources ...................................................................................................................................................... 15
Toutes les ressources d’une application Android se trouve dans le dossier res ................................................... 15
4.2.1. Identifiant de ressource ............................................................................................................................... 15
4.2.2. Images : [Link] ............................................................................................................................ 15
4.3. Mise en page ................................................................................................................................................... 15
4.3.1. Structure d’une interface Android ............................................................................................................... 15
4.3.2. Arbre des vues ............................................................................................................................................. 16
4.3.3. Paramètres de positionnement ................................................................................................................... 16
4.3.4. Autres paramètres géométriques ................................................................................................................ 16
4.4. Composants d’interface .................................................................................................................................. 16
4.4.1. Vues.............................................................................................................................................................. 16
4.4.2. Textview ....................................................................................................................................................... 17
4.4.3. Button .......................................................................................................................................................... 17
4.4.4. Bascules........................................................................................................................................................ 17
4.4.5. EditText ........................................................................................................................................................ 17
2.4.6. Résumé sur les vues ..................................................................................................................................... 17
Travaux Dirigés....................................................................................................................................................... 18
Exercice 1 ............................................................................................................................................................... 18
Exercice 2 QCM ...................................................................................................................................................... 18
Chapitre 5 : GENERALITES SUR LE LANGAGE JAVA ................................................................................................ 19
1.1) Présentation............................................................................................................................................... 19
1.2) Les caractéristiques.................................................................................................................................... 19
1.3) Notions générales de programmation en JAVA ......................................................................................... 19
1.3.a) Les commentaires .................................................................................................................................. 19
1.3.b) Types de données .................................................................................................................................. 19
1.3.c) Declaration des variables ....................................................................................................................... 20
1.3.d) Chaînes de caractères ............................................................................................................................ 20
1.3.e) Opérateurs ............................................................................................................................................. 20
1.3.f) Structures de contrôle ........................................................................................................................... 21
1.3.g.1) Instructions conditionnelles............................................................................................................... 21
1.3.g.2) Instructions itératives ........................................................................................................................ 21
Chapitre 6 : VIE D’UNE APPLICATION.................................................................................................................... 23
3.1. Applications et activités .................................................................................................................................. 23

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 4
3.1.1. Composition d’une application .................................................................................................................... 23
3.1.2. Déclaration d’une application...................................................................................................................... 23
3.1.3. Démarrage d’une application ...................................................................................................................... 23
3.1.4. Démarrage d’une activité et Intents ............................................................................................................ 23
3.1.5. Lancement d’une activité par programme .................................................................................................. 24
3.1.8. Autorisations d’une application ................................................................................................................... 24
3.2. Applications..................................................................................................................................................... 24
3.2.1. Fonctionnement d’une application.............................................................................................................. 24
3.2.2. Navigation entre activités ............................................................................................................................ 24
3.2.3. Lancement avec ou sans retour ................................................................................................................... 25
3.2.5. Terminaison d’une activité .......................................................................................................................... 26
3.2.6. Méthode onActivityResult ........................................................................................................................... 26
3.2.7. Transport d’informations dans un Intent .................................................................................................... 26
3.2.8. Extraction d’informations d’un Intent ......................................................................................................... 26
3.2.9. Contexte d’application ................................................................................................................................. 27
3.2.10. Définition d’un contexte d’application ...................................................................................................... 27
3.2.11. Définition d’un contexte d’application, fin ................................................................................................ 27
3.4. Vues et activités .............................................................................................................................................. 27
3.4.1. Obtention des vues ...................................................................................................................................... 27
3.4.2. Propriétés des vues ...................................................................................................................................... 28
3.4.3. Actions de l’utilisateur ................................................................................................................................. 28
3.4.4. Définition d’un écouteur .............................................................................................................................. 28
3.4.5. Écouteur privé anonyme.............................................................................................................................. 29
3.4.6. Écouteur privé .............................................................................................................................................. 29
3.4.7. L’activité elle-même en tant qu’écouteur ................................................................................................... 29
3.4.8. Distinction des émetteurs ............................................................................................................................ 30
3.4.9. Événements des vues courantes.................................................................................................................. 30
Chapitre 7 : ERGONOMIE ....................................................................................................................................... 31
6.1. Barre d’action et menus.................................................................................................................................. 31
6.1.1. Barre d’action............................................................................................................................................... 31
6.1.2. Réalisation d’un menu ................................................................................................................................. 31
6.1.3. Spécification d’un menu .............................................................................................................................. 31
6.1.4. Icônes pour les menus ................................................................................................................................. 32
6.1.5. Écouteurs pour les menus ........................................................................................................................... 32
6.1.6. Réactions aux sélections d’items ................................................................................................................. 32
6.1.7. Menus en cascade........................................................................................................................................ 33

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 5
6.1.8. Menus contextuels....................................................................................................................................... 33
6.1.9. Associer un menu contextuel à une vue ...................................................................................................... 33
6.1.10. Callback d’affichage du menu .................................................................................................................... 34
6.1.11. Callback des items du menu ...................................................................................................................... 34
6.1.12. Menu contextuel pour un RecyclerView ................................................................................................... 34
6.1.13. Parenthèse sur les lambda Java ................................................................................................................. 35
6.1.14. Parenthèse sur les lambda Java, fin ........................................................................................................... 35
6.1.15. Menu contextuel pour un RecyclerView, fin ............................................................................................. 35
6.2. Annonces et dialogues .................................................................................................................................... 36
6.2.1. Annonces : toasts ......................................................................................................................................... 36
6.2.2. Annonces personnalisées ............................................................................................................................ 36
6.2.3. Dialogues...................................................................................................................................................... 36
6.2.4. Dialogue d’alerte.......................................................................................................................................... 37
6.2.5. Boutons et affichage d’un dialogue d’alerte................................................................................................ 37
6.2.6. Autres types de dialogues d’alerte .............................................................................................................. 37
6.2.7. Dialogues personnalisés............................................................................................................................... 38
6.2.8. Création d’un dialogue................................................................................................................................. 38
5.2.9. Affichage du dialogue .................................................................................................................................. 38

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 6
Chapitre 1 GENERALITES SUR LES TERMINAUX MOBILES

I) Définition
Un Terminal mobile est un appareil portable permettant le traitement et l'échange de données. Cela
inclut les Smartphones, les tablettes tactiles.

II) Intérêts des terminaux mobiles dans l'entreprise

Pour beaucoup d’organisation, les bénéfices apportés par les terminaux mobiles touchent pour
l’essentiel à la conduite des affaires. Ces appareils offrent aux collaborateurs plus de flexibilité,
améliorent les workflows, les communications, aidant les utilisateurs à être plus efficaces et plus
productifs. Le tout renforçant la compétitivité des organisations.

 Ces bénéfices sont notamment liés à la possibilité qu’ils donnent aux employés de travailler où et
quand ils en ont besoin, en continuant d’accéder aux ressources de l’entreprise.

 Les processus métiers fluidifiés réduisent aussi la paperasse ; personne n’a à attendre d’imprimer
ou de faxer des documents, ni à conserver des copies papier. Cela réduit l’effort associé à la gestion
de ces systèmes, tout en économisant papier, encre et électricité.

 Les terminaux mobiles peuvent également fluidifier les communications : les travailleurs sont
généralement plus disponibles pour rapidement valider des contenus sensibles, collaborer sur des
documents sur le terrain, répondre à des demandes de ressources ou d’informations, dialoguer sur
les réseaux sociaux, et garder le contact suivant un éventail large de moyens.

III) Les défis à relever avec les terminaux mobiles

Le plus important concerne les risques de sécurité, souvent liés au comportement des utilisateurs.

 Ils peuvent visiter des sites malicieux ;

 Ils peuvent télécharger des maliciels, etc.

Tous les risques ne viennent toutefois pas de l'utilisateur. Les équipes informatiques qui déploient des
applications mobiles sans en tester pleinement la sécurité peuvent mettre en péril l'ensemble de leur
organisation. Ignorer les vulnérabilités des périphériques ou ne pas appliquer les correctifs du système
d'exploitation en temps opportun peut également être à l’origine d’une compromission de
l’environnement.

IV) Les types de terminaux mobiles

Actuellement, les terminaux mobiles utilisés en entreprise se rangent essentiellement dans deux
catégories : Les Smartphones et Les tablettes

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 7
Chapitre 2 GENERALITES SUR LE DEVELOPPEMENT DES APPLICATIONS POUR
TERMINAUX MOBILES

I) Introduction
Intégration du mobile dans sa stratégie digitale est une
Nécessité pour toute entreprise.
Pour intégrer le mobile, il existe 3 solutions :
 Développer une application web Mobile,
 Développer une application native,
 Développer une application hybride.

II) Les types d’applications mobiles

1) Les applications web mobiles

 Une application mobile exécutable via le navigateur internet de
Votre Smartphone, appelée aussi WebApp
 L’application est développée avec les technologies web classiques,
(HTML5, CSS3 ou JavaScript) en utilisant la technique de responsive
design qui assure l'organisation des éléments en fonction de la taille de
l'écran.
 La WebMobile est accessible via tous les Smartphones : toute
Marque et système d'exploitation confondus

Limites
 Absence de visibilité des WebApp au sein des magasins de
Téléchargement comme par exemple playstore
 Absence de certaines fonctionnalités quand l’application est fermée comme les notifications
 Pas d’accès à l’application si on est hors-ligne
 Pas d’accès aux applications natives du mobile (GPS, appareil photo…) ;

2) Les applications natives

 Un logiciel développé spécifiquement pour un système
D’exploitation mobile (iOS, Android, Blackberry,
Windows Phone)
 Une application téléchargée depuis un magasin de téléchargement
D’applications mobiles (Play store) puis installée sur le périphérique
 Une application qui peut fonctionner hors-ligne
 Une application qui se base sur les fonctionnalités natives
Du terminal (appareil photo, géo localisation, etc.)

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 8
Limites :
 Développement d’une version appropriée pour chaque plateforme
 Le temps et le coût de développement sont donc multipliés par le nombre de plateformes
 Chaque plateforme possède son langage et nécessite un apprentissage important

3) Les applications hybrides

 Une application développée à partir de langages web
(HTML5, JavaScript, CSS3…)
 Une application qui s’appuie sur des technologies natives mobiles
Pour utiliser certaines fonctionnalités du Smartphone (caméra, GPS, etc.)
Limites
 L’exploitation limitée des fonctionnalités du système
 La compatibilité peut ne pas être optimale sur un grand nombre
de Smartphone

III) Récapitulatif

IV) Domaine d’application des applications mobiles

Les domaines d’application des applications mobiles sont nombreux. Quelques-uns sont :

 Le GPS et les services permettant la localisation ;

 Les opérations bancaires ;
 Des applications médicales mobiles ;
 Les suivis des commandes, l'achat de billets ;
 L’écoute de musiques ou de radios ;
 La visualisation de vidéos ou de chaines de télévision ;
Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT
Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 9
Chapitre 3 ENVIRONNEMENT DE DEVELOPPEMENT
Dans ce cours nous allons découvrir l’environnement de développement Android :
 Le SDK Android et Android Studio
 Création d’une application simple
 Communication avec un émulateur de téléphone.

1.1. Introduction

1.1.1. Android
né en 2004, racheté par Google en 2005, publié en 2007, version 1.5 de nombreuses versions depuis, on
en est à la 10 (septembre 2019). NB : Il y a des codes et noms de versions pour le grand public (ex : 4.1
JellyBean, 6.x Marshmallow, 9.x Pie), et des versions d’API pour les développeurs (API 16, API 23,
API 28).

1.1.2. Qu’est-ce qu’Android ?

Système complet pour smartphones et tablettes

1.1.3. Composants d’Android

Android est une surcouche au-dessus d’un système Linux :

1.1.4. Programmation d’applications

Une application Android est composée de :
 Sources Java (ou Kotlin) compilés pour une machine virtuelle appelée «ART »
 Fichiers appelés ressources qui représente par exemple les images utilisés par l’application.
 Manifeste = description du contenu du logiciel. Il représente, le fichier de configuration de
l’application mobile
Tout cet ensemble est géré à l’aide d’un IDE (environnement de développement) appelé Android
Studio qui s’appuie sur un ensemble logiciel (bibliothèques, outils) appelé SDK Android.

1.2. SDK Android et Android Studio

1.2.1. SDK Android

Le SDK contient :
• les librairies Java pour créer des logiciels
• les outils de mise en boîte des logiciels
• AVD : un émulateur de tablettes pour tester les applications
• des outils de compilation : gradle

1.2.2. Android Studio

Pour le SDK, vous avez le choix, soit de l’installer automatiquement avec Studio, soit de faire une
installation personnalisée. En général, vous pouvez choisir ce que vous voulez ajouter au SDK (version
des librairies, versions des émulateurs de smarphones), à l’aide du SDK Manager.

1.2.3. Choix de la version

Chaque version d’Android, dénotée par son API level, ex: 25, apporte des améliorations et supprime
des dispositifs obsolètes. Toute application exige un certain niveau d’API

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 10
1.2.4. SDK Manager
C’est le gestionnaire du SDK, une application qui permet de choisir les composants à installer et
mettre à jour.

1.3. Assistant de création d’une tablette virtuelle

1.3.1. Caractéristiques d’un AVD

C’est une machine virtuelle, ou un simulateur qui permet de tester les applications Android

1.3.2. Application sur l’AVD

L’apparence change d’une version à l’autre du SDK.

Figure 10: Création d’un AVD

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 11
Chapitre 3 NOTIONS DES ACTIVITES

Introduction
Grace à l’activité nous pouvons afficher des interfaces graphiques et gérer tous les éléments graphiques
existant. Les activités existant sous le dossier Java et ensuite sous le paquetage layout qui existe là-bas

3.1) Présentation d’une activité

Nous avons par exemple ici une classe qui hérite de la classe AppCompaActivity
A l’intérieur de cette classe mainActivity,
 Nous avons la méthode Oncreate () qui est la première méthode du cycle de vie d’une activité.
 Cette méthode Oncreate () est la première méthode qui s’exécute lorsque l’utilisateur a cliqué
par exemple sur une icône de son interface
 Cette méthode Oncreate () est une méthode redéfinit de la classe mère Activity
 A l’intérieur de la méthode Oncreate (), on trouve la méthode SetContentView
([Link]) qui permet d’afficher une activité.
R est un fichier JAVA qui possède toutes les ressources (fichier) du projet, toutes les activités
se trouvent dans le dossier layout

3.2) Présentation du cycle de vie d’une activité

Cette figure ci-dessous illustre le cycle de vie d’une activité

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 12
Dès que l’utilisateur accède à une activité
 La méthode onCreate () sera exécuter
 Quelque seconde après le cycle de vie passe à la deuxième étape qui est le démarrage représenté
par la méthode onStart ()
 Par la suite le passage s’effectue automatiquement vers onResume () qui signifie que l’activité
est en avant plan. Du coup le cycle de vie s’arrête maintenant.
Lorsque l’activité est en avant plan, l’utilisateur va agir. Ainsi suite à son action, l’activité va passer en
arrière-plan (background). Par exemple si l’utilisateur a cliqué sur un bouton pour passer à une autre
activité, alors l’activité en cours va passer en arrière-plan.
 Dans ce cas-là, elle ne sera plus visible, elle doit passer à la méthode onPause ()
 Puis tant qu’une autre activité va passer en premier plan alors celle qui était en premier plan va
passer à onStop () qui ne veut pas dire que cette activité est invisible. Elle conserve encore les
ressources qu’elle possède
 Au cas où l’utilisateur décide d’accéder à une ressource (par exemple un bouton) de cette
activité, dans ce cas cette activité va passer à onStart ()
 Au cas où l’utilisateur décide de quitter complément le système, dans ce cas-là, elle va passer à
onDestroy () qui veut dire que l’activité est détruite. Dans ce cas-là elle va libérer ces ressources

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 13
Chapitre 4 CREATION D’INTERFACES UTILISATEUR
Le cours explique la création d’interfaces utilisateur :
 Activités
 Relations entre un source Java et des ressources
 Layouts et vues
On ne s’intéresse qu’à la mise en page.

4.1. Applications et activités

4.1.1. Composition d’une application

Une application Android est composée d’un ensemble d’activité.
Chaque activité constitue une Interface Utilisateur
L’interface utilisateur d’une application Android est composée d’écrans. Un écran correspond à une
activité, ex :
 afficher des informations
 éditer des informations
Les dialogues et les pop-ups ne sont pas des activités, ils se superposent temporairement à l’écran
d’une activité.
Android permet de naviguer d’une activité à l’autre, ex :
• une action de l’utilisateur, bouton, menu ou l’application fait aller sur l’écran suivant
• le bouton back ramène sur l’écran précédent.

4.1.2. Création d’un écran

Chaque écran est géré par une instance d’une sous-classe de Activity que vous programmez. Vous
surchargerez sa méthode onCreate selon ce qui doit être affiché sur l’écran :
public class MainActivity extends Activity {
@Override
protected void onCreate (Bundle savedInstanceState) {
[Link] (savedInstanceState);
setContentView ([Link]);
}
}
L’interface est mise en place par setContentView (identifiant de ressource).

4.1.3. Structure d’une interface utilisateur

L’interface d’une activité est composée de vues :
 vues élémentaires : boutons, zones de texte, cases à cocher, etc.
 vues de groupement : elles permettent l’alignement des autres vues
Toutes ces vues sont rassembler dans une palette qui elle-même sont organiser en catégorie (Common,
Text, Buttons, …..)
La figure ci-dessous présente toutes les vues.

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 14
4.2. Ressources

Toutes les ressources d’une application Android se trouve dans le dossier res
Ce dossier res contient trois autres sous dossiers parmi lesquels :

 Drawable : qui contient toutes les images de l’application

 Layout : contient toutes les interfaces graphiques
 Mipmap : contient toutes les icones de l’application

4.2.1. Identifiant de ressource

La méthode setContentView spécifie l’identifiant de l’interface à afficher dans l’écran :
[Link]. C’est un entier, identifiant d’une disposition de vues : un layout.
Le SDK Android (aapt) construit automatiquement une classe statique appelée R.
Elle ne contient que de constantes entières groupées par catégories : id, layout, menu. . . :

4.2.2. Images : [Link]

De la même façon, les images PNG placées dans res/drawable et res/mipmaps-* sont référençables :
<ImageView
android:src="@drawable/velo"
android:contentDescription="@string/mon_velo" />
La notation @drawable/nom référence l’image portant ce nom dans l’un des dossiers.
NB : les dossiers res/mipmaps-* contiennent la même image à des définitions différentes, pour
correspondre à différents téléphones et tablettes. Ex: mipmap-hdpi contient des icônes en 72x72 b
pixels.

4.3. Mise en page

4.3.1. Structure d’une interface Android

Un écran Android de type formulaire est généralement composé de plusieurs vues. Entre autres :
 TextView, ImageView : titre, image
 EditText : texte à saisir
 Button, CheckBox : bouton à cliquer, case à cocher
Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT
Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 15
Ces vues sont alignées à l’aide de groupes sous-classes de ViewGroup, éventuellement imbriqués :
 LinearLayout : positionne ses vues en ligne ou colonne
 RelativeLayout : positionne ses vues l’une par rapport à l’autre
 TableLayout : positionne ses vues sous forme d’un tableau

4.3.2. Arbre des vues

Les groupes et vues forment un arbre :
Voir la figure 17, page 47.

Figure 17: Arbre de vues

4.3.3. Paramètres de positionnement

La plupart des groupes utilisent des paramètres de placement sous forme d’attributs XML. Par
exemple, telle vue à droite de telle autre, telle vue la plus grande possible, telle autre la plus petite.
Ces paramètres sont de deux sortes :
• ceux qui sont demandés pour toutes les vues : android:layout_width et android:layout_height,
• ceux qui sont demandés par le groupe englobant et qui en sont spécifiques, comme
android :layout_weight, android:layout_alignParentBottom, android:layout_centerInParent. .
Paramètres généraux
Toutes les vues doivent spécifier ces deux attributs :
android:layout_width largeur de la vue
android:layout_height hauteur de la vue
• "wrap_content" : la vue est la plus petit possible
• "match_parent" : la vue est la plus grande possible
• "valeurdp" : une taille fixe, ex : "100dp" mais c’est peu recommandé, sauf 0dp pour un cas
particulier,

4.3.4. Autres paramètres géométriques

Il est possible de modifier l’espacement des vues :
Padding espace entre le texte et les bords, géré par chaque vue
Margin espace autour des bords, géré par les groupes

4.4. Composants d’interface

4.4.1. Vues
Android propose un grand nombre de vues, à découvrir en TP :

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 16
Ces vues sont regroupés en plusieurs catégories (Common, Text, Buttons, Widgets, Layout, Containers,
Helpers, Google, Legacy)

4.4.2. Textview
Le plus simple, il affiche un texte statique, comme un titre. Son libellé est dans l’attribut
On peut le changer dynamiquement :
TextView tvTitre = findViewById([Link]);
[Link]("blablabla");

4.4.3. Button
L’une des vues les plus utiles est le Button :
<Button
android:id="@+id/btn_ok"
android:text="@string/ok"
... />

4.4.4. Bascules
Les CheckBox sont des cases à cocher :

4.4.5. EditText
Un EditText permet de saisir un texte :
L’attribut android:inputType spécifie le type de texte : adresse, téléphone, etc. Ça définit le clavier
qui est proposé pour la saisie.
Lire la référence Android pour connaître toutes les possibilités.

2.4.6. Résumé sur les vues

Éléments de formulaire
– TextView : affiche une chaîne
– EditText : permet la saisie d'une chaîne (propriété inputType pour le type d'entrée attendu)
– Button : bouton cliquable, variante de type interrupteur avec ToggleButton
– CheckBox : case à cocher
– RadioButton : bouton radio regroupable dans un RadioGroup
– CheckedTextView : chaîne cochable (implante Checkable)
– ProgressBar : barre de progression (horizontale, circulaire), variante avec étoiles de notation avec
RatingBar
– SeekBar : barre de réglage
– SearchView : champ de recherche avec proposition de suggestions
Éléments multimédias
– ImageView : affichage d'une ressource image
– ImageButton : bouton avec image
– VideoView : affichage contrôlable de vidéo

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 17
Travaux Dirigés

Exercice 1
1.) Qu’est-ce que Android ?
2.) Quelles sont les constituants d’une application Android ?
3.) Donner la syntaxe de déclaration d’une fonction sur Android Studio
4.) Que signifie SDK et de quoi est-il constitué ?
5.) Enumérer les avantages des terminaux mobiles
6.) Qu’est-ce que le gradle ?
7.) Que signifie AVD et à quoi sert t-il ?
8.) De quoi est constitué la partie visuelle d’une application Android ?
9.) En quoi consiste une activité
10.) Que fait la méthode setContentView ()
11.) Enumérer trois exemple de vue d’une interface Android
12.) Enumérer les types d’application mobile
13.) Enumérer les domaines d’application des terminaux mobiles

Exercice 2 QCM
1. Pour Android, un AVD est :
a. le pilote qui gère l'audio et la vidéo
b. un émulateur de smartphone
c. une bibliothèque avancée pour construire des interfaces utilisateur
d. un débugger de code

2. L'interface graphique d'une activité a été définie dans un fichier [Link] mis dans le répertoire
res\layout. Pour qu'une activité ait cette interface graphique il faut écrire le code :
a. setContentView("/res/layout/[Link]");
b. setContentView("\res\layout\[Link]");
c. setContentView([Link]);
d. setGUI("[Link]");

3. Dans le fichier [Link] ci-dessus est déclaré <Button ... android:id="@+id/mon_bouton ... />"
Pour repérer ce composant graphique Button dans le code Java de l'activité qui a chargé ce fichier
[Link], il faut écrire :
a. Button bt = (Button) findViewbyId([Link].mon_bouton);
b. Button bt = (Button) findViewbyId([Link].mon_bouton);
c. Button bt = (Button) findViewbyId([Link].mon_bouton);
d. Button bt = (Button) getGUIComponent("mon_bouton");

4. Le fichier [Link] d'une application Android

a. décrit en xml l'interface graphique de l'application Android
b. décrit la configuration de l'application Android (demande de permission d'accès à internet,
déclaration des activity, etc.)
c. décrit les redirections à effectuer lorsqu'une erreur d'exécution se produit

d. peut-être omis pour certaines Android apps

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 18
Chapitre 5 : GENERALITES SUR LE LANGAGE JAVA

1.1) Présentation
Le langage Java est un langage généraliste de programmation synthétisant les principaux langages
existants lors de sa création en 1995 par Sun Microsystems.
Il permet une programmation orientée-objet et reprend une syntaxe très proche de celle du langage C.

1.2) Les caractéristiques

Java possède un certain nombre de caractéristiques qui ont largement contribué à son énorme succès :
 Java est interprétée
 Java est portable
 Java est orienté objet
 Java est fortement typé
 Java assure la gestion de la mémoire

1.3) Notions générales de programmation en JAVA

1.3.a) Les commentaires

Les commentaires (non traités par le compilateur) se situent entre les symboles “/*” et “*/”
ou commencent par le symbole “//” en se terminant à la fin de la ligne
int a ; // ce commentaire tient sur une ligne
int b ;
ou
/*Ce commentaire nécessite
2 lignes*/

1.3.b) Types de données

Le tableau 2 .1 liste l’ensemble des types primitifs de données de Java.
A l’inverse du langage C, Java est un langage très rigoureux sur le typage des données. Il est interdit
d’affecter à une variable la valeur d’une variable d’un type différent si cette seconde variable n’est pas
explicitement transformée. Par exemple :

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 19
 1.3.c) Declaration des variables
int a ;
double b = 5.0 ;
a=b;
est interdit et doit être écrit de la manière suivante :
int a ;
double b = 5.0 ;
a = (int)b ;

1.3.d) Chaînes de caractères

. On utilise une classe particulière, nommée String, fournie dans le package [Link].
● on peut utiliser l’opérateur + pour concaténer deux chaînes de caractères :
String s1 =” hello”;
String s2 = ”world” ;
String s3 = s1 + ” ” + s2 ; //Après ces instructions s3 vaut ”hello world”

1.3.e) Opérateurs
On distingue trois types d’opérateur parmi lesquels les opérateurs arithmétiques, de comparaison et
logique Ces opérateurs seront présentés dans le tableau ci-dessous :
Table 2.2 – Opérateurs Java

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 20
Légende
► <ari> valeur arithmétique
► <boo> valeur booléenne
► <cla> classe
► <ent> valeur entière
► <ins> instruction
► <str> chaîne de caractères (String)
► <val> valeur quelconque
► <var> variable

1.3.f) Structures de contrôle

Les structures de contrôle permettent d’exécuter un bloc d’instructions soit plusieurs fois
(instructions itératives) soit selon la valeur d’une expression (instructions conditionnelles ou de choix
multiple). Dans tous ces cas, un bloc d’instruction est
● soit une instruction unique ;
● soit une suite d’instructions commençant par une accolade ouvrante “{” et se terminant
par une accolade fermante “}”.

1.3.g.1) Instructions conditionnelles

Syntaxe:
if (condition){
bloc Inst1; }
else {
bloc Inst 2; }
Exemple :
if (a == b) {
a = 50 ;
b=0;
} else {
a=a-1;
}

1.3.g.2) Instructions itératives

Les instructions itératives permettent d’exécuter plusieurs fois un bloc d’instructions, et ce, jusqu’à ce
qu’une condition donnée soit fausse. Les types d’instructions itératives sont les suivantes :
boucle while, boucle do ….. while et la boucle for
► Syntaxe de la boucle while :
while (condition){
bloc inst;
}
Exemple :
while (a != b) a++ ;

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 21
Syntaxe de la boucle for :
for (<init>;<condition>;<instr_post_itération>){
bloc inst;
}

Exemple :

for (int i = 0, j = 49 ; (i < 25) && (j >= 25); i++, j--) {

if (tab[i] > tab[j]) {
int tampon = tab[j];
}
}

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 22
Chapitre 6 : VIE D’UNE APPLICATION
Le cours de cette semaine concerne la vie d’une application :
 Applications et activités, manifeste
 Cycles de vie
 Vues, événements et écouteurs

3.1. Applications et activités

3.1.1. Composition d’une application

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.
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,
 des récepteurs d’annonces : pour gérer des événements globaux envoyés par le système à toutes
les applications.

3.1.2. Déclaration d’une application

Le fichier [Link] déclare les éléments d’une application, avec un ’.’ devant le nom de
classe
<?xml version="1.0" encoding="utf-8"?>
<manifest ... >
<application android:icon="@drawable/app_icon.png" ...>
<activity android:name=".MainActivity"
... />
<activity android:name=".EditActivity"
... />
...
</application>
</manifest>

3.1.3. Démarrage d’une application

L’une des activités est marquée comme démarrable de l’extérieur :
<activity android:name=".MainActivity" ...>
<intent-filter>
<action android:name="[Link]"/>
<category android:name="[Link]"/>
</intent-filter>
</activity>
Un <intent-filter> déclare les conditions de démarrage d’une activité, ici il dit que c’est l’activité
principale.

3.1.4. 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.

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 23
• 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.

3.1.5. 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, [Link]);
startActivity(intent);
L’instruction startActivity démarre Activ2. Celle-ci se met devant Activ1 qui se met alors en sommeil.
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 [Link].

3.1.8. 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 éléments dans le manifeste :
<manifest ... >
<uses-permission
android:name="[Link]" />
...
<application .../>
</manifest>
Consulter cette page pour la liste des permissions existantes.
NB: les premières activités que vous créerez n’auront besoin d’aucune permission.

3.2. Applications

3.2.1. 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 [Link].
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.

3.2.2. Navigation entre activités

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

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 24
Voir la figure 20 situé en dessous.

3.2.3. Lancement avec ou sans retour

Rappel, pour lancer Activ2 à partir de Activ1 :
Intent intent = new Intent(this, [Link]);
startActivity(intent);
On peut demander la terminaison de this après lancement de Activ2 ainsi :
Intent intent = new Intent(this, [Link]);
startActivity(intent);
finish();
finish() fait terminer l’activité courante.
L’utilisateur ne pourra pas faire back dessus, car elle disparaît de la pile.

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.
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)

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 25
{
// uti a fait back
if (resultCode == Activity.RESULT_CANCELED) return;
// selon le code d'appel
switch (requestCode) {
case APPEL_ACTIV2: // on revient de Activ2
...
}
}

3.2.5. 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().

3.2.6. 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)

3.2.7. 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, [Link]);
[Link]("idInfo", idInfo);
[Link]("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.

3.2.8. Extraction d’informations d’un Intent

Ces instructions récupèrent les données d’un Intent :
Intent intent = getIntent();
Integer idInfo = [Link]("idInfo", -1);
bool hidden = [Link]("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

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 26
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";

3.2.9. 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 = [Link]();
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.

3.2.10. 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() {
[Link]();
varglob = 3;
}
}
Ensuite, la déclarer dans [Link], 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">
...

3.2.11. 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) [Link]();
// utiliser la variable globale
... [Link]() ...
Remarquez la conversion de type du contexte.

3.4. Vues et activités

3.4.1. Obtention des vues

La méthode setContentView charge une mise en page (layout) sur l’écran. Ensuite l’activité peut
Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT
Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 27
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([Link].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.

3.4.2. 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 = findViewById([Link]);
[Link](2);
[Link]([Link]);
Consulter leur documentation pour les propriétés, qui sont extrêmement nombreuses.

3.4.3. 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/btn_valider"
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) {
...
}

3.4.4. 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
[Link] 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
Button btn = findViewById([Link].btn_valider);

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 28
[Link](ecouteur);

3.4.5. É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 = findViewById([Link].btn_valider);
[Link](
new [Link]() {
public void onClick(View btn) {
// faire quelque chose
}
});
Dans la méthode onClick, il faut employer la syntaxe [Link] pour manipuler les variables
et méthodes de l’activité sous-jacente.
Sur les dernières versions d’AndroidStudio, cet écouteur est transforme en lambda. C’est une écriture
plus compacte qu’on retrouve également en JavaScript, et très largement employée en Kotlin.
Button btn = findViewById ([Link].btn_valider);
[Link]((btn) -> {
// faire quelque chose
});
Cette transformation est possible parce que l’interface [Link] ne possède qu’une seule
méthode.

3.4.6. É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 [Link] {
public void onClick(View btn) {
// faire quelque chose
}
};
public void onCreate(...) {
...
Button btn = findViewById ([Link].btn_valider);
[Link] (new EcBtnValider());
}

3.4.7. 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 [Link] {
public void onCreate(...) {
...
Button btn = findViewById([Link].btn_valider);
Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT
Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 29
[Link](this);
}
public void onClick (View btn) {
// faire quelque chose
}
Ici, par contre, tous les boutons appelleront la même méthode.

3.4.8. 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 ([Link]()) {
case [Link].btn_valider:
...
break;
case [Link].btn_effacer:
...
break;
}
}

3.4.9. É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.

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 30
Chapitre 7 : ERGONOMIE
Le cours de cette semaine concerne l’ergonomie d’une application Android.
 Menus et barre d’action
 Popup-up : messages et dialogues
 Activités et fragments
 Préférences (pour info)
 Bibliothèque support (pour info)

6.1. Barre d’action et menus

6.1.1. Barre d’action

La barre d’action contient l’icône d’application (1), quelques items de menu (2) et un bouton pour avoir
les autres menus (3).

6.1.2. Réalisation d’un menu

Avant Android 3.0 (API 11), les actions d’une application étaient lancées avec un bouton de menu,
mécanique. Depuis, elles sont déclenchées par la barre d’action. C’est presque la même chose.
Le principe général : un menu est une liste d’items qui apparaît soit quand on appuie sur le bouton
menu, soit sur la barre d’action. Certains de ces items sont présents en permanence dans la barre
d’action. La sélection d’un item déclenche une callback.
Docs Android sur la barre d’action et sur les menus
Il faut définir :
• un fichier res/menu/nom_du_menu.xml,
• des thèmes pour afficher soit la barre d’action, soit des menus,

Figure 29: Icônes de menus

• deux callbacks pour gérer les menus : création et activation.

6.1.3. Spécification d’un menu

Créer res/menu/nom_du_menu.xml :
<menu xmlns:android="..." >
<item android:id="@+id/menu_creer"
android:icon="@drawable/ic_menu_creer"

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 31
 android:showAsAction="ifRoom"
android:title="@string/menu_creer"/>
<item android:id="@+id/menu_chercher" ... />
...
</menu>
L’attribut showAsAction vaut "always", "ifRoom" ou "never" selon la visibilité qu’on souhaite dans la
barre d’action. Cet attribut est à modifier en app:showAsAction si on utilise la bibliothèque support
(appcompat, devenue androidx récemment, voir la fin du cours).

6.1.4. Icônes pour les menus

Android distribue gratuitement un grand jeu d’icônes pour les menus, dans les deux styles
MaterialDesign : HoloDark et HoloLight.
Consulter la page Downloads pour des téléchargements gratuits de toutes sortes de modèles et feuilles
de styles. Téléchargez Action Bar Icon Pack pour améliorer vos applications.

6.1.5. Écouteurs pour les menus

Il faut programmer deux méthodes. L’une affiche le menu, l’autre réagit quand l’utilisateur sélectionne
un item. Voici la première :
@Override
public boolean onCreateOptionsMenu(Menu menu)
{
// ajouter mes items de menu
getMenuInflater().inflate([Link].nom_du_menu, menu);

return [Link](menu);
}
Cette méthode rajoute les items du menu défini dans le XML.
Un MenuInflater est un lecteur/traducteur de fichier XML en vues ; sa méthode inflate crée les
vues.

6.1.6. Réactions aux sélections d’items

Voici la seconde callback, c’est un aiguillage selon l’item choisi :
@Override
public boolean onOptionsItemSelected(MenuItem item) {
switch ([Link]()) {
case [Link].menu_creer:
...
return true;
case [Link].menu_chercher:
...
return true;
default: return [Link](item);
}
}

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 32
6.1.7. Menus en cascade
Définir deux niveaux quand la barre d’action est trop petite :
<menu xmlns:android="..." >
<item android:id="@+id/menu_item1" ... />
<item android:id="@+id/menu_item2" ... />
<item android:id="@+id/menu_more"
android:icon="@drawable/ic_action_overflow"
android:showAsAction="always"
android:title="@string/menu_more">
<menu>
<item android:id="@+id/menu_item3" ... />
<item android:id="@+id/menu_item4" ... />
</menu>
</item>
</menu>

6.1.8. Menus contextuels

Voir la figure 30, page 93.

Figure 30: MenuContextuel

Ces menus apparaissent lors un clic long sur un élément de liste. Le principe est le même que pour
les menus normaux :
• Attribuer un écouteur à l’événement onCreateContextMenu. Cet événement correspond à un clic long
et au lieu d’appeler la callback du clic long, ça fait apparaître le menu.
• Définir la callback de l’écouteur : elle expanse un layout de menu.
• Définir la callback des items du menu.

6.1.9. Associer un menu contextuel à une vue

Cela se passe par exemple dans la méthode onCreate d’une activité :
@Override
protected void onCreate(Bundle savedInstanceState)
{
[Link](savedInstanceState);
setContentView([Link]);
ListView lv = findViewById([Link]);
registerForContextMenu(lv);
...
Au lieu de registerForContextMenu(lv), on peut aussi faire :
[Link](this);

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 33
6.1.10. Callback d’affichage du menu
Un clic long sur un élément de la liste déclenche cette méthode :
@Override
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo)
{
[Link](menu, v, menuInfo);
getMenuInflater().inflate([Link].main_context, menu);
}
Son rôle est d’expanser (inflate) le menu res/menu/main_context.xml.

6.1.11. Callback des items du menu

Pour finir, si l’utilisateur choisit un item du menu :
public boolean onContextItemSelected(MenuItem item) {
AdapterContextMenuInfo info = (ACMI...) [Link]();
switch ([Link]()) {
case [Link]:
onMenuEditer([Link]); // identifiant de l'élément
return true;
case [Link]:
onMenuSupprimer([Link]);
return true;
}
return false;
}
L’objet AdapterContextMenuInfo info permet d’avoir l’identifiant de ce qui est sélectionné.

6.1.12. Menu contextuel pour un RecyclerView

Dans le cas d’un RecyclerView, c’est un peu plus compliqué car le menu ne se déclenche pas. Il faut
ajouter un écouteur à l’adaptateur :
public class PlaneteAdapter extends [Link]<...> {
...
[Link] mMenuListener;
public void setMenuListener(
[Link] listener) {
mMenuListener = listener;
}
Cet écouteur est affecté lors de la création de l’adaptateur, et en général, c’est l’activité.
La suite est dans le ViewHolder, voir le cours précédent :
class PlaneteView extends [Link] {
...findViews()...setItem()...onCreateViewHolder()...
@Override
public void onBindViewHolder(final PlaneteView h, final int pos){
// définir un écouteur pour les clics longs avec une lambda

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 34
[Link](view -> {
setClickedPosition(pos);
return false;
});
// définir un écouteur pour le menu contextuel (clic long)
[Link](mMenuListener);
}

6.1.13. Parenthèse sur les lambda Java

Une expression lambda est une sorte d’objet-méthode sans nom, par exemple un écouteur anonyme
sur un bouton. Au lieu d’écrire ceci :
[Link](
new [Link]() {
public void onClick(View v) {
// faire quelque chose
}
});
Java 8 permet de simplifier en :
[Link](v -> {
// faire quelque chose
});

6.1.14. Parenthèse sur les lambda Java, fin

On ne laisse que les noms des paramètres, sans parenthèses s’il est seul, et le corps. On peut même
supprimer les {} s’il n’y a qu’une seule instruction.
La syntaxe lambda, paramètre -> instruction ou (paramètres) -> { instructions; } est possible lorsqu’il
s’agit de la seule méthode d’une interface :
public classe View ... {
public interface OnClickListener {
void onClick(View v);
}
Dans ce cas, on peut créer un objet anonyme, qui consiste uniquement en un appel à onClick.

6.1.15. Menu contextuel pour un RecyclerView, fin

Enfin, on modifie l’écouteur du menu dans l’activité :
@Override
public boolean onContextItemSelected(MenuItem item)
{
int position = [Link]();
switch ([Link]()) {
...
}
return false;
}

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 35
Figure 31 : Toast
NB : ce n’est encore pas une bonne solution quand les items ont un identifiant et non une position, voir
le TP sur Realm.

6.2. Annonces et dialogues

6.2.1. Annonces : toasts

Un « toast » est un message apparaissant en bas d’écran pendant un instant, par exemple pour
confirmer la réalisation d’une action. Un toast n’affiche aucun bouton et n’est pas actif.
Voici comment l’afficher avec une ressource chaîne :
[Link] (getContext(),[Link].item_supprime, Toast.LENGTH_SHORT).show();
La durée d’affichage peut être allongée avec LENGTH_LONG.

6.2.2. Annonces personnalisées

Il est possible de personnaliser une annonce. Il faut seulement définir un layout dans
res/layout/toast_perso.xml. La racine de ce layout doit avoir un identifiant, ex : toast_perso_id qui est
mentionné dans la création :
// expanser le layout du toast
LayoutInflater inflater = getLayoutInflater();
View layout = [Link]([Link].toast_perso,
(ViewGroup) findViewById([Link].toast_perso_id));
// créer le toast et l'afficher
Toast toast = new Toast(getApplicationContext());
[Link] (Toast.LENGTH_LONG);
[Link] (layout);
[Link]();

6.2.3. Dialogues
Un dialogue est une petite fenêtre qui apparaît au-dessus d’un écran pour afficher ou demander quelque
chose d’urgent à l’utilisateur, par exemple une confirmation.
Voir la figure 32, page 97.
Il existe plusieurs sortes de dialogues :
 Dialogues d’alerte
 Dialogues généraux

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 36
Figure 32 : Dialogue d’alerte

6.2.4. Dialogue d’alerte

Un dialogue d’alerte AlertDialog affiche un texte et un à trois boutons au choix : ok, annuler, oui,
non, aide. . .
Un dialogue d’alerte est construit à l’aide d’une classe nommée [Link].
Le principe est de créer un builder et c’est lui qui crée le dialogue.
Voici le début :
// import [Link];
[Link] builder = new [Link](this);
[Link]("Suppression");
[Link]([Link].ic_dialog_alert);
[Link]("Vous confirmez la suppression ?");
Ensuite, on rajoute les boutons et leurs écouteurs.

6.2.5. Boutons et affichage d’un dialogue d’alerte

Le builder permet de rajouter toutes sortes de boutons : oui/non, ok/annuler. . . Cela se fait avec des
fonctions comme celle-ci. On peut associer un écouteur (anonyme privé ou . . . ) ou aucun.
// rajouter un bouton "oui" qui supprime vraiment
[Link]([Link],
// écouteur écrit sous la forme d'une lambda
(dialog, idbtn) -> {
SupprimerElement(idElement);
});
// rajouter un bouton "non" qui ne fait rien
[Link]([Link], null);
// affichage du dialogue
[Link]();

6.2.6. Autres types de dialogues d’alerte

Dans un dialogue d’alerte, au lieu de boutons, il est possible d’afficher une liste de propositions
prédéfinies. Pour cela :
• Définir une ressource de type tableau de chaînes res/values/[Link] :

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 37
Figure 33: Dialogue perso
<resources>
<string-array name="notes">
<item>Nul</item>
<item>Ça le fait</item>
<item>Trop cool</item>
</string-array>
</resources>
• Appeler la méthode [Link]([Link], écouteur). L’écouteur est presque le même que
pour un clic, sauf qu’il reçoit le numéro du choix en 2e paramètre idBtn.
Dans ce cas, ne pas appeler [Link] car ils sont exclusifs. C’est soit une liste, soit un
message.

6.2.7. Dialogues personnalisés

Lorsqu’il faut demander une information plus complexe à l’utilisateur, mais sans que ça nécessite une
activité à part entière, il faut faire appel à un dialogue personnalisé.

6.2.8. Création d’un dialogue

Il faut définir le layout du dialogue incluant tous les textes, sauf le titre, et au moins un bouton pour
valider, sachant qu’on peut fermer le dialogue avec le bouton back.
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="..." ...>
<TextView android:id="@+id/dlg_titre" .../>
<EditText android:id="@+id/dlg_libelle" .../>
<Button android:id="@+id/dlg_btn_valider" ... />
</LinearLayout>
Ensuite cela ressemble à ce qu’on fait dans onCreate d’une activité : setView avec le layout et des
setOnClickListener pour attribuer une action aux boutons.

5.2.9. Affichage du dialogue

// créer le dialogue (final car utilisé dans les écouteurs)
final Dialog dialog = new Dialog(this);
[Link]([Link].edit_dialog);
[Link]("Création d'un type");
// bouton valider
Button btnValider = [Link]([Link].dlg_btn_valider);
[Link](v -> {
Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT
Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 38
// récupérer et traiter les infos
...
// ne surtout pas oublier de fermer le dialogue
[Link]();
}
});
// afficher le dialogue
[Link]();

Par Serge DOUMI Ingénieur Génie Logiciel & Expert IT

Certifié : ITIL V3, SQL, CCNA et Oracle
Web : [Link]
Page 39