Applications pour ANDROID

Cours 05
2022-2023
 Gestion des menus de l’application
• Un menu est un endroit privilégié pour placer certaines
fonctions tout en économisant notre espace dans la fenêtre.
• Par exemple, faire en sorte qu’un menu ouvre la page des
options, ou ramène à la page d'accueil …
• Il existe deux sortes de menu dans Android :
– Le menu d'options, celui qu'on peut ouvrir avec le bouton
"Menu" sur le téléphone (anciennes versions).
– Les menus contextuels, dans Android ils se déroulent dès
lors qu'on effectue un long clic sur un élément de
l'interface graphique.

2
 Gestion des menus de l’application
• Ces deux types de menus peuvent contenir des sous-menus,
qui peuvent contenir des sous-menus, etc...
• La construction des menus peut être effectuée:
– Dynamiquement par programmation.
– Par déclaration dans un fichier XML (méthode à
privilégier).

3
 Menu d'options: Créer un menu
• Chaque activité peut avoir son propre menu.
• La déclaration des menus est effectuée dans une fichier XML
situé dans res/menu.
• Tout d'abord, la racine de ce menu est de type <menu> :
Code : XML
<?xml version="1.0" encoding="utf-8"?>
<menu
xmlns:android="http://schemas.android.com/apk/res/android" >

<!-- Code -->

</menu>

4
 Menu d'options: Créer un menu
• La racine menu accepte des balise:
– <item> pour un élément de menu.
– <menu> pour déclarer un sous-menu : deux niveaux
maximum.
• Les <item> peuvent être personnalisés à l'aide de plusieurs
attributs :
– android:id, Il permet d'identifier de manière unique un <item>.
– android:icon, pour agrémenter votre <item> d'une icône.
– android:title, qui sera son texte dans le menu.
– android:onClick : méthode de l'activité à invoquer.
– Enfin, on peut désactiver par défaut un <item> avec l'attribut
android:enabled="false".
5
 Menu d'options: Créer un menu
• il est possible d'avoir un <item> qui ouvre un sous-menu, et ce
sous-menu sera à traiter comme tout autre menu.
• La syntaxe est celle-ci :
Code : XML
<item>

<menu>

<item/>
<!-- d'autres items -->

<item/>
</menu>

</item> 6
 Menu d'options: Créer un menu
• Exemple de déclaration de menu:
<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android" >
<item android:id="@+id/menu1" android:title="Menu 1">
</item>
<item android:id="@+id/action_settings" android:title="Menu 2">
<menu>
<item android:id="@+id/item1" android:title="Item 1"/>
<item android:id="@+id/item2" android:title="Item 2"/>
</menu>
</item>
</menu>

7
 Menu d'options: Créer un menu
• Les <item> peuvent être modulés avec d'autres attributs,
comme :
– android:checkable auquel on peut mettre true si on
souhaite que l'élément puisse être coché, comme une
CheckBox.
– Si on souhaite qu'il soit coché par défaut, on peut mettre
android:checked à true.

8
 Menu d'options: Créer un menu
• Enfin, La balise <group> permet de regrouper les éléments
d'un menu afin :
– De leur attribuer les mêmes propriétés.
– D'ajouter des cases à cocher, boutons radio aux éléments
du menu.
• Si on veut que tous les éléments du groupe soient des
CheckBox, on peut mettre au groupe l'attribut
android:checkableBehavior="all",
• Si on veut qu'ils soient tous des RadioButton, on peut mettre
l'attribut android:checkableBehavior="single".

9
 Menu d'options: Créer un menu
Code : XML
<menu xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools">

<item android:id="@+id/item1" android:title="item1"/>

<item android:id="@+id/item2" android:title="item2"></item>

<group android:id="@+id/group1" android:checkableBehavior="all">
<item android:id="@+id/item3" android:title="item3"></item>
<item android:id="@+id/item4" android:title="item4"></item>
</group>
<group android:id="@+id/group2" android:enabled="false">
<item android:id="@+id/item5" android:title="item5"></item>
<item android:id="@+id/action_settings" android:title="item6"></item>
</group>
</menu>
10
 Menu d'options: Créer un menu
• Android doit parcourir le fichier XML pour construire le menu.
Pour cela, on doit surcharger la méthode boolean
onCreateOptionsMenu (Menu menu) d'une activité.

public boolean onCreateOptionsMenu(Menu menu) {

// Inflate the menu; this adds items to the action bar if it
is present.
getMenuInflater().inflate(R.menu.main, menu);
return true;
}

11
 Menu d'options: Créer un menu
• On peut aussi construire un menu de manière
programmatique avec la méthode suivante qui s'utilise sur un
Menu :

MenuItem add (int groupId, int objectId, int ordre, CharSequence titre)

Où :
• groupId permet d'indiquer si l'objet appartient à un groupe. Si
ce n'est pas le cas, vous pouvez mettre Menu.NONE.
• objectId est l'identifiant unique de l'objet, vous pouvez aussi
mettre Menu.NONE, mais ce n’est pas recommandé.

12
 Menu d'options: Créer un menu
• ordre permet de définir l'ordre d’apparition dans le menu. Par
défaut, l'ordre respecté est celui du fichier XML ou de l'ajout
avec la méthode add.
– On peut mettre Menu.NONE.
• titre est le titre de l'item.
Exemple: dans la méthode « onCreateOptionsMenu » on ajoute
le code suivant :

menu.add(Menu.NONE, Menu.NONE, 1, "item_par progra");

13
 Menu d'options: Réagir aux clics
• L'identifiant d'un <item> permet de déterminer comment il
réagit aux clics au sein de la méthode :
boolean onOptionsItemSelected (MenuItem item).
• Dans l'exemple précédent, si on veut que cliquer sur le
premier item active les deux items inactifs, on pourrait utiliser
le code suivant :

15
 Menu d'options: Réagir aux clics
private Menu m = null;
@Override
public boolean onCreateOptionsMenu(Menu menu) {
getMenuInflater().inflate(R.menu.main, menu);
m = menu;
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item) {
// Dans le Menu "m", on active tous les items dans le groupe
d'identifiant "R.id.group2"
int id = item.getItemId();
if (id == R.id.item1) {
m.setGroupEnabled(R.id.group2, true);
return true;
}
return super.onOptionsItemSelected(item);
}
} 16
 Menu contextuel
• Un menu contextuel dans Android apparaît lorsque
l'utilisateur effectue un long-clic sur un élément de interface.
– Sur Windows, c'est le menu qui apparaît quand vous faites
un clic droit.
• Ce menu se définit dans la méthode suivante :
void onCreateContextMenu (ContextMenu menu, View vue,
ContextMenu.ContextMenuInfo menuInfo)
• Où :
– menu : est le menu à construire,
– vue : la vue sur laquelle le menu a été appelé,
– menuInfo : indique sur quel élément d'un adaptateur a été
appelé le menu, si on se trouve dans une liste par exemple.
17
 Menu contextuel
• Le menu est détruit puis reconstruit à chaque appel.
• Voici un exemple de construction de menu contextuel de
manière programmatique :
//Notez qu'on utilise Menu.FIRST pour indiquer le premier élément
d'un menu
private final static int MENU_DESACTIVER = Menu.FIRST;
private final static int MENU_retour = Menu.FIRST + 1;
@Override
public void onCreateContextMenu(ContextMenu menu, View v,
ContextMenuInfo menuInfo) {
// TODO Auto-generated method stub
super.onCreateContextMenu(menu, v, menuInfo);
menu.add(Menu.NONE,MENU_DESACTIVER, Menu.NONE,"desactiver");
menu.add(Menu.NONE,MENU_retour, Menu.NONE,"retour");
}
18
 Menu contextuel
• Pour écrire des identifiants facilement, la classe Menu
possède une constante Menu.FIRST qui permet de désigner le
premier élément, puis le deuxième en incrémentant, etc.
• La méthode boolean onContextItemSelected (MenuItem
item). est utilisée pour traiter le choix de l'utilisateur.
Exemple : Code Java
@Override
public boolean onContextItemSelected(MenuItem item) {
// TODO Auto-generated method stub
if (item.getItemId() == MENU_DESACTIVER) {
Toast.makeText(this, "Menu contextuel 1 cliqué !",
Toast.LENGTH_SHORT).show();
}
return super.onContextItemSelected(item);
}
19
 Menu contextuel
• Alors, si on veut déclarer qu’une vue possède un menu
contextuel, cela se fait avec la méthode de la classe Activity :
void registerForContextMenu (View vue).

• Désormais, dès que l'utilisateur fera un clic long sur cette vue,
un menu contextuel s'ouvrira…, si nous le définissons !

20
Les boîtes de dialogue
 Les boîtes de dialogue
• Une boîte de dialogue est une petite fenêtre qui passe au premier
plan pour informer l'utilisateur ou lui demander ce qu'il souhaite
faire.
• Par exemple, si je veux quitter mon navigateur, alors que j'ai
plusieurs onglets ouverts, une boîte de dialogue s'ouvrira pour me
demander confirmation, comme le montre la figure suivante.
• On les utilise souvent pour annoncer des erreurs, donner une
information ou indiquer un état d'avancement d'une tâche à l'aide
d'une barre de progression par exemple …

24
 Généralités
• Les boîtes de dialogue d'Android sont dites modales, c'est-à-
dire qu'elles bloquent l’interaction avec l'activité sous-jacente.
• Les boîtes de dialogue héritent de la classe Dialog et on les
trouve dans le package android.app.Dialog.
• Dans un souci d'optimisation, on fera en sorte de ne pas avoir
à créer de nouvelle boîte de dialogue à chaque occasion, mais
plutôt de recycler les anciennes.
• La méthode de callback Dialog onCreateDialog (int id), sera
appelée quand on instancie pour la première fois une boîte de
dialogue.
– Elle prend en argument un entier qui sera l'identifiant de la
boîte.
25
 Généralités
Code : Java
private final static int IDENTIFIANT_BOITE_UN = 0;
private final static int IDENTIFIANT_BOITE_DEUX = 1;
@Override
public Dialog onCreateDialog(int id) {
//En fonction de l'identifiant de la boîte qu'on veut créer
switch(id) {
case IDENTIFIANT_BOITE_UNE :
// On construit la première boîte de dialogue
return BOITE_UNE;
case IDENTIFIANT_BOITE_DEUX :
// On construit la seconde boîte de dialogue
return BOITE_DEUX;
}
return super.onCreateDialog(id);
}
26
 Généralités
• Pour appeler une boîte de dialogue, on utilise la méthode
void showDialog (int id), qui se chargera d'appeler
onCreateDialog(id) en lui passant le même identifiant.
• La boite de dialogue est fermée automatiquement.
– cf. les méthodes dismiss() et cancel().

27
 AlertDialog
• On les utilise à partir du package android.app.AlertDialog. Il
s'agit de la boîte de dialogue la plus polyvalente.
• Typiquement, elle peut afficher un titre, un texte et/ou une
liste d'éléments.
• Une AlertDialog peut contenir jusqu'à trois boutons pour
demander à l'utilisateur ce qu'il souhaite faire,
– Elle peut aussi n'en contenir aucun.
• Pour construire une AlertDialog, on préférera utiliser la classe
AlertDialog.Builder, qui permet de simplifier la construction.
Ce constructeur prend en argument un Context.

29
 AlertDialog
• Un objet de type AlertDialog.Builder connaît les méthodes
suivantes :
– AlertDialog.Builder setCancelable (boolean cancelable) : si le
paramètre cancelable vaut true, alors on pourra sortir de la
boîte grâce au bouton retour de l’appareil.
– AlertDialog.Builder setIcon (Drawable icon): Permet d'ajouter
une icône à la boîte de dialogue.
– AlertDialog.Builder setTitle (String title) : Permet d'ajouter un
titre.
– AlertDialog.Builder setMessage (String message) : Permet
d'ajouter un message.
– AlertDialog.Builder setView (View view) ou le paramètre view
doit être une vue (voir AlertDialog personnalisée).
30
 AlertDialog
• On peut ensuite ajouter des boutons avec les méthodes
suivantes :
– AlertDialog.Builder setPositiveButton (text,
DialogInterface.OnClickListener listener), avec text qui doit être
une ressource de type String ou une String, et listener qui
définira que faire en cas de clic. Ce bouton se trouvera tout à
gauche.
– AlertDialog.Builder setNeutralButton (text,
DialogInterface.OnClickListener listener). Ce bouton se trouvera
entre les deux autres boutons.
– AlertDialog.Builder setNegativeButton (text,
DialogInterface.OnClickListener listener). Ce bouton se trouvera
tout à droite.
31
 AlertDialog
Code : Java
AlertDialog.Builder dialog1 = new AlertDialog.Builder(this);
dialog1.setMessage("Voulez vous quitter cette application ?");
dialog1.setPositiveButton("Oui", new DialogInterface.OnClickListener() {

@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
Toast.makeText(MainActivity.this, "fermeture en
cour!", Toast.LENGTH_SHORT).show();
}
});
dialog1.setNegativeButton("Non", null);
dialog1.setCancelable(false);
return dialog1.create();

32
 AlertDialog personnalisée
• De la même façon qu'on fait une interface graphique pour
une activité, on peut créer un fichier XML pour définir la mise
en page d’une boîte de dialogue.
Exemple:
• Le layout de base est décrit dans le fichier custom_alert.xml.
• Dans le code de création du AlertDialog il faut ajouter le
layout créé.

33
 AlertDialog personnalisée
Exemple: le fichier custom_alert.xml
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="vertical"
android:padding="15dip" >
<TextView
android:id="@+id/TextView1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Entrer quelque chose ci-dessous :" />
<EditText
android:id="@+id/EditText1"
android:layout_width="fill_parent"
android:layout_height="wrap_content" />
</LinearLayout> 34
 AlertDialog personnalisée
Exemple: le code java
LayoutInflater inflater = LayoutInflater.from(this);
final View customView = inflater.inflate(R.layout.custom_alert, null);
AlertDialog.Builder dialog2 = new AlertDialog.Builder(this);
dialog2.setView(customView);
dialog2.setTitle("Modifiez la valeur");
dialog2.setIcon(android.R.drawable.ic_dialog_alert);
dialog2.setPositiveButton("OK", new DialogInterface.OnClickListener() {
@Override
public void onClick(DialogInterface dialog, int which) {
EditText tv = (EditText) customView.findViewById(R.id.EditText1);
Toast.makeText(MainActivity.this, tv.getText(),
Toast.LENGTH_SHORT).show();
}
});
dialog2.setNegativeButton("Cancel", null);
return dialog2.create();

35
 AlertDialog avec choix
• L'objectif est de créer un boite avec une liste de choix

36
 AlertDialog avec choix
Code : Java
final CharSequence langages[] = {"C/C++","Java","Python","PHP"};
AlertDialog.Builder dialog3 = new AlertDialog.Builder(this);
dialog3.setTitle("Choix du langage");
dialog3.setItems(langages, new DialogInterface.OnClickListener() {

@Override
public void onClick(DialogInterface dialog, int which) {
// TODO Auto-generated method stub
Toast.makeText(MainActivity.this, "Vous avez
choisi: " + langages[which], Toast.LENGTH_SHORT).show();
}
});
return dialog3.create();

37
 Sources de ce cours

• Créez des applications pour Android :

https://openclassrooms.com/courses/creez-des-applications-
pour-android