Android

Éléments de base
ISSAT Mateur
Chaker Ben Mahmoud
Mars 2023
 Introduction
2

 Android est un système d’exploitation Open

Source basé sur un noyau Linux
 Il est conçu pour Smartphones, Tablettes,
téléviseurs, . . .
 Initialement développé par une startup du même

nom, rachetée par Google en 2005

 En 2008, le gPhone est lancé aux États-Unis

dans un partenariat entre Google et T-mobile

 Introduction
3

 Android tire partie des particularités des Smartphones :

 interface homme machine adapté (tactile, widget)
 divers modes : vibreur, sonnerie, silencieux, alarme
 notifications (d'applications, d'emails, de SMS, d'appels en instance)
 de boussole, accéléromètre, GPS
 divers capteurs (gyroscope, gravité, accélération linéaire, baromètre)
 NFC (Near field communication) basé sur RFID (radio-frequency identification)
 téléphonie (GSM) et réseau EDGE, 3G, LTE (4G)
 En plus de ce qu'on peut avoir sur un ordinateur : navigateur, bibliothèques
graphiques 2D, 3D (Open GL), base de données (SQLite), applications de rendu
multimédia (audio, vidéo, image) de divers formats, réseau Bluetooth et Wi-Fi,
caméra,…
 Stratégie et rentabilité d’Android
4

 Revenus basés sur la vente d’applications et l’intégration

de la publicité
 Stratégie de développement :
 Basée sur l’Open Source
 Un «store» de plusieurs milliers applications « Play Store »

 Des mises à jours régulières et faciles d’installation

 Un système ouvert pour facilité sa diffusion et son adaptation

sur différents matériels.
 Stratégie et rentabilité d’Android
5
 Historique (1/5)
6

Version
Version Nom de code Date de sortie %
API
4.1.x 9 juillet 2012 16 0,2 %
4.2.x Jelly Bean 13 novembre 2012 17 0,3 %
4.3 24 juillet 2013 18 0,1 %
4.4 KitKat 31 octobre 2013 19 1,4 %
5.0 3 novembre 2014 21 0,7 %
Lollipop
5.1 9 mars 2015 22 3,2 %
6.0 Marshmallow 8 octobre 2015 23 5,1 %
 Historique (2/5)
7

Nom de Version
Version Date de sortie %
code API
7.0 22 août 2016 24 3,4 %
Nougat
7.1 4 octobre 2016 25 2,9 %
8.0 21 août 2017 26 4%
Oreo
8.1 6 décembre 2017 27 9,7 %
9 Pie 1er décembre 2018 28 18,2 %
10 Android 10 3 septembre 2019 29 26,5 %
11 Android 11 8 septembre 2020 30 24,3 %
 Qu’est-ce qu’un programme Android ?
8

 Android offre un framework riche mais suffisamment rigide et étanche :

 Du XML pour les interfaces
 Les activités : briques de base d’une application présentant une vues pour les users
 Les services : il s'agit d'une activité tâche de fond sans vue associée
 Les fournisseurs de contenus : abstraction de données
 Les intentions (intents) : interagir avec le système

 Android permet d’accéder des fonctionnalités avancées de l’appareil :

 Stockage (base de données, support externe)
 Réseau (Wifi, Bluetooth, 2G, 3G, 4G, . . . )
 Multimédia (lecture audio, photo, caméra)
 GPS (géolocation des applications par différents moyens)
 Services de téléphonie (appels, SMS)
 Architecture
9
10 Environnement de développement

Development Tools

Android Studio + SDK Android

avec
AVD : Android Virtual Device
 Environnement de développement
11

L'environnement JAVA pour PC

 Le JDK (version 15 ou 17)

 [Link]

Le Bundle
 Android Studio
 [Link]
 Environnement de développement
12

Téléchargement et installation de JDK

 Environnement de développement
13

Téléchargement et installation de Android Studio

 Le SDK d’Android
14

 l'Android SDK (Software Development Kit) amène des outils

 un environnement de développement
 une machine virtuelle Java adaptée : la Dalvik virtual machine
 un environnement debugueur DDMS (Dalvik Debug Monitor Service)
utilisant adb (Android Debug Bridge)
 un environnement de construction d'application Android aapt
(Android Asset Packaging Tool)
 des émulateurs de téléphones ou de tablettes AVD (Android Virtual
Device)
 et une énorme API
(voir à [Link]
 Android Development Tools : AVD
15

 L’émulateur Android permet de simuler plusieurs

terminaux
 Informations nécessaires à la configuration d’un AVD :
 Une version cible du SDK
 Des informations sur le stockage (mémoire, carte SD)

 Résolution de l’appareil choisi

 AVD Android studio
16
 AVD Android studio
17
 Terminal virtuel
18
 Environnement sous Android Studio
19
 Android Runtime : Compilation
20

 Deux passages :
 .JAVA vers .CLASS
 Concaténation des .CLASS en .DEX

 Une application c'est :

 Lebytecode DEX
 des ressources (images, sons...)

 Le tout regroupe dans un package .APK

21

Développement des
applications sous Android
 Les composants d’une application Android
22

Composants applicatifs
 activités

Une activité correspond à un écran

graphique Une activité hérite de la classe

Activity

 L’activité décrit l’interface graphique ET

les interactions avec l’utilisateur
Une application est constituée de plusieurs
écrans ( plusieurs activités)
 Fragments

Fragment ou portion d’une interface

graphique Permet de rendre modulaire les

vues
Un fragment peut être réutilisé dans
plusieurs écrans (différentes ‘activity’)
 Les composants d’une application Android
23
Composants applicatifs
 services

Processus d’arrière plan sans 'User Supervision batterie
 Cours de Bourse
Interface' Mise à jour des données et des
Lecteur MP3

activités Notifications

 fournisseurs de contenu
 Sources de données
partageables
Contact
Agenda Personnalisé

 widget
 composant graphique qui s’installe sur le bureau
Android
Calendrier
Meteo
 Les composants d’une application Android
24

Éléments d’interaction
 Intent
 Diffusion de messages systèmes interapplications
 Les messages peuvent être explicites ou implicites (‘action
resolver’)

 Broadcast Receiver
 Récepteurs d’Intents
 Enregistrement d’un Receiver auprès d’une activité = écoute de certains
 Intents Principe du design pattern Observer
– Un émetteur: Observable -> signale l’évément
– Un récepteur : Observer -> en écoute de l’événement et + action
spécifique sur événement

 Notifications
 une notification signale une information à l’utilisateur sans interrompre
ses actions en cours
 Création d’un projet
25
 Création d’un projet
26
 Structure d’un projet Android-Studio
27

 Manifest : décrit les propriétés

de l’application
 Code java : contient les fichiers
source
 res : contient les ressources
(images, descriptions
d’interfaces, valeurs)
 Organisé en sous dossiers par
types
 Scripts Gradle : Gestion des
projets
 [Link]
28

 [Link]
 Décrit les composants de l’application
 Un point d’entrée potentiel dans l’application
 Une application peut lancer un composant différent (pas de main)
 Quatre types de composants : activités (activities), services (services),
fournisseurs de contenu (content providers), récepteurs de diffusion
(broadcast receivers)
 Décrit les permissions requises par l’application : accès a l’Internet, lecture-
écriture dans la liste de contacts, géo-localisation, . . .
 Décrit les besoins matériels et logiciels de l’application : appareil photo,
Bluetooth, écran multitouche, . . .
 [Link]
29

<manifest xmlns:android>
<application
android:allowBackup="true" android:dataExtractionRules="@xml/data_extraction_rules"
android:fullBackupContent="@xml/backup_rules" android:icon="@mipmap/ic_launcher"
android:label="@string/app_name" android:roundIcon="@mipmap/ic_launcher_round"
android:supportsRtl="true"
android:theme="@style/[Link]"
tools:targetApi="31">

<activity android:name=".MainActivity" android:exported="true" >

<intent-filter>
<action android:name="[Link]" />
<category android:name="[Link]" />
</intent-filter>
<meta-data android:name="[Link].lib_name" android:value="" />
</activity>

</application>
</manifest>
 [Link]
30

 Manifest : Nom du paquetage, Versions, SDK

 Application : Nom, Icône, Eléments constituant l’application (activités, services, …)
 Permissions : Accès aux capteurs, Accès au réseau, Accès à la téléphonie,…
 Instrumentation (pour les tests)
 Les ressources
31

 Application embarquée tout doit être dans le fichier .apk téléchargé

 Le répertoire res contient toutes les ressources qui seront mises dans
le apk :
 drawable (images)
 layout (description en XML des interfaces)
 values (définitions en XML de constantes : chaînes, tableaux, valeurs
numériques …)
 mipmap (les icones de l’application)
 xml (fichiers XML utilisés directement par l’application)
 Les ressources
32

 Les ressources de type valeur sont décrites dans des

fichiers XML ayant la forme suivante :
<?xml version="1.0 “ encoding= “utf-8 “?>
<resources>
<color name= "coulfond“>#AA7B03</color>
<integer name= “limite”>567</integer>
<integer-array name= “codes_postaux“>
<item>64100</item>
<item>33000</item>
</integer-array>
<string name= “mon_titre”>Un titre</string>
<string-array name= “planetes“>
<item>Mercure</item>
<item>Venus</item> Les noms (identificateurs)
</string-array>
servent a les désigner :
<bool name=“actif“>true</bool>
<dimen name “taille“>55px</dimen>
• Dans d’autres fichiers XML
</resources> • Dans le code
 Les ressources: La classe R
33

 C’est une classe générée par Eclipse qui permet à l’application

d’accéder aux ressources
 Elle contient des classes internes dont les noms correspondent aux
types de ressources (id, drawable, layout …)
 Elle est constituée à partir des fichiers placés dans les sous
répertoires du répertoire res
 Une propriété est créée pour :
 Chaque image placé dans drawable
 Chaque identificateur défini dans des fichiers XML (objets d’interface,
constantes)
 Chaque fichier placé dans les répertoires xml , raw …
 Utilisation des ressources
34

 Référencement d’une ressource dans un fichier xml. La forme

générale est : "@type/identificateur"
Par exemple : @string/machaine
Fait référence à une chaine contenue dans un fichier XML placé
dans le répertoire res/values et définie comme suit :
<resources>
<string name="machaine">Contenu de cette chaine</string>
</resources>

 Référencement d’une ressource dans le code. La forme générale

est : [Link]
Par exemple :
[Link] Fait référence à la même chaine
 La classe Resources
35

 Permet l’accès aux ressources répertoriées dans R

 On obtient une instance de cette classe par getResources() de l’activité
 Principales méthodes de la classe Resources (le paramètre est un identifiant
défini dans R de la forme [Link]) :
 boolean getBoolean(int)
 int getInteger(int)
 int[] getArray(int)
 String getString(int)
 String[] getStringArray(int)
 int getColor(int)
 float getDimension(int)
 Drawable getDrawable(int)
 Exemple :
String titre = getResources().getString([Link].ma_chaine);
 Accès aux ressources dans l’application
36

 Mise en place de l’interface principale

setContentView([Link].nom_du_fichier_xml);
 Accès direct à une valeur ou à une ressource :

String titre = getResources().getString([Link].texte_titre);

Drawable monImage =
getResources().getDrawable([Link].nom_de_l_image)
 Les composants d’une application Android
37

 Une activité = un programme + une interface

 Un service = un programme sans interface
 Une application =
 Une activité principale
 Eventuellement une ou plusieurs activités secondaires

 Eventuellement un ou plusieurs services

 Eventuellement un ou plusieurs écouteurs d’intentions diffusées

 Eventuellement un ou plusieurs fournisseurs de contenu

 Les activités
38

 Classe qui hérite de Activity ou d’une classe dérivée de Activity

(par exemple de MapActivity pour utiliser Google maps, ListActivity
ou TabActivity pour des interfaces particulières)
 On surcharge certaines méthodes qui sont appelées par Android
pour définir le comportement :
 onCreate lors de la création
 onDestroy lorsque l’activité se termine
 onStart lorsque l’activité démarre ou redémarre
 onPause lorsque l’activité n’est plus en premier plan
 onResume lorsque l’activité revient en premier plan
 onStop lorsque l’activité n’est plus visible
 onRestart lorsque l’activité redevient visible
 Les activités
39
40 Les interfaces

Les Layouts
 Qu'est-ce que Layout ?
41

 Une Layout Android est une classe qui permet

d'organiser la façon dont ses enfants apparaissent sur
l'écran.
 Tout ce qui est une View (ou hérite de View) peut être un
enfant d'une Layout.
 Toutes les Layouts héritent de ViewGroup (qui hérite
de View) afin que vous puissiez imbriquer les mises en
page.
 Vous pouvez également créer votre Layout personnalisée
en créant une classe qui hérite de ViewGroup.
Les types des Layouts
 Les Layouts
43

 View est la classe de base des composants de

l'interface utilisateur tels que TextView, Button,
EditText, etc.
 Une ou plusieurs View peuvent être regroupées dans
un ViewGroup.
 Un ViewGroup fournit la mise en page Android dans
laquelle nous pouvons ordonner l'apparence et la
séquence des vues.
 Des exemples de ViewGroup sont LinearLayout,
FrameLayout, RelativeLayout, ConstraintLayout etc.
 La classe View
44

Attributs principaux
 Orientation

Sens de placement des vues dans un conteneur

android:orientation = vertical | horizontal
 Taille
 Surface prise par la vue
 android:layout_width = ??px | fill_parent | wrap_content
 android:layout_height = ??px | fill_parent | wrap_content
 Gravité
 Alignement d'une vue dans son conteneur
 android:layout_gravity = left | center_horizontal | top | bottom | right
 Types de Layout Android
45

 Android fournit les ViewGroups :

 LinearLayout : aligne tous les enfants dans une seule
direction, verticalement ou horizontalement
 RelativeLayout : qui affiche les vues enfants dans des
positions relatives
 AbsoluteLayout : permet de spécifier l'emplacement
exact des vues et widgets enfants
 TableLayout : est une vue qui regroupe ses vues
enfants en lignes et colonnes
 FrameLayout : est un espace réservé à l'écran qui est
utilisé pour afficher une seule vue
 Types de Layout Android
46

 ListView : est un groupe de vues qui affiche une

liste d'éléments déroulants
 GridView : affiche les éléments dans une grille de
défilement bidimensionnelle. Les éléments de la
grille proviennent du ListAdapter associé à cette
vue
 Attributs d’une Layout Android
47

 android:id : Il s'agit de l'ID qui identifie de manière unique la vue

 android:layout_width : C'est la largeur de la vue
 android:layout_height : C'est la hauteur de la vue
 android:layout_margin : Il s'agit de l'espace supplémentaire en dehors de la vue.
 android:layout_padding : Il s'agit de l'espace supplémentaire à l'intérieur de la vue
 android:layout_gravity : Cela spécifie comment les vues enfants sont positionnées
 android:layout_weight : Cela spécifie la quantité d'espace supplémentaire dans
la vue qui doit être allouée à la vue
 android:layout_x : Cela spécifie la coordonnée x de la vue
 android:layout_y : Cela spécifie la coordonnée y de la vue
 LinearLayout
48

 LinearLayout est un ViewGroup qui organise

les View enfant dans une seule direction,
verticalement ou horizontalement.
 RelativeLayout
49

 RelativeLayout est une mise en page dans

laquelle nous pouvons organiser les
vues/widgets en fonction de la position des
autres vues/widgets.
 Il est indépendant de la vue horizontale et
verticale et nous pouvons l’arranger selon sa
satisfaction.
 RelativeLayout
50
 LinearLayout vs RelativeLayout
51

DispositionLinéaire Disposition relative

Nous pouvons ajuster les vues et les widgets Nous pouvons ajuster les vues et les widgets
de manière linéaire, c’est-à-dire en fonction de sa satisfaction.
horizontalement et verticalement.
L’attribut layout_weight dans la disposition Divers attributs tels
linéaire est utilisé pour spécifier la taille que : layout_toRightOf, layout_toLeftOf,
égale ou spécifique du widget et de la vue layout_below, layout_alignParentTop,
particuliers à l’aide de l’attribut suivant. layout_top, layout_alignParentLeft,
android:layout_weight = ‘0’ layout_alignParentRight sont utilisés pour
Ici, le poids est spécifié à 0 afin de donner spécifier la position de chaque vue et
une taille ou un espace égal à chaque vue widget.
ou widget.
Il est utile lorsque nous organisons les vues C’est utile lorsque nous organisons les vues
de manière linéaire de manière relative.
 ConstraintLayout
52

 Le ConstraintLayout permet de créer des vues

complexes avec une hiérarchie de vue plate (sans
créer de groupe de vue imbriqué), cela permet
d’améliorer considérablement les performances les
fichiers de vues que vous créez.
 Il permet aussi de positionner et de dimensionner
des widgets d’une manière flexible
 Il est similaire au RelativeLayout en ce sens ou les
widgets sont positionner par rapport aux widgets
frère ou par rapport au container parent.
 TableLayout
53

 TableLayout organise les View qu'il contient

sous forme de tables.
 TableLayout contient un ou
plusieurs TableRow
 Chaque TableRow est une ligne dans le
tableau,
 Les View enfant peuvent être placées dans
une cellule ou dans une cellule fusionnée à
partir de cellules consécutives d'une ligne..
 TableLayout
54
 GridLayout
55

 GridLayout utilise une grille de lignes infiniment fines

pour séparer sa zone de dessin en: des lignes, des
colonnes.
 À l'aide des spécifications de ligne et de colonne, vous
pouvez spécifier comment les lignes et les colonnes
sont requises et comment les éléments doivent être
orientés.
 Pour ce faire, vous pouvez utiliser les paramètres de
disposition rowSpec et columnSpec.
 GridLayout
56

<GridLayout android:rowCount="2" android:columnCount="2" >

<ImageView android:layout_height="90dp"
android:layout_width="130dp"
android:src="@drawable/image_1" />
<ImageView android:layout_height="90dp"
android:layout_width="130dp"
android:src="@drawable/image_2" />
<ImageView android:layout_height="90dp"
android:layout_width="130dp"
android:src="@drawable/image_3" />
<ImageView android:layout_height="90dp"
android:layout_width="130dp"
android:src="@drawable/image_4" />
</GridLayout>
 Gérer les Boutons
57

<Button
android:id="@+id/button"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Button"
/>
 Gérer le clic bouton
58

Button b1= findViewById([Link].button1);

[Link](new [Link]() {
@Override
public void onClick(View view) {

/** Votre code ici ***/

}
});
 Evénements généraux
59

 Tous les éléments d’interface (conteneurs et widgets) possèdent

les méthodes suivantes :
 Événements spécifiques
60


EditText et TextView
 Les labels de texte : TextView
61

 En XML
<TextView
android:id="@+id/textview1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!" />

 Utilisation
TextView a = findViewById([Link].textview1);
[Link]("Salem");
Les labels de texte : TextView
 Des mises en formes pour les TextView
 android:textSize => taille du text
 android:textStyle => style du text

 android:textAlignment => alignement du text

 android:textColor => couleur du text

 Les labels de texte : TextView
Exemple XML

android:layout_marginTop="100px"
android:layout_marginBottom="50px"
android:text="TextView"
android:textAlignment="center"
android:textColor="#AE2828"
android:textSize="34sp"
android:textStyle="bold"
 EditText (XML)
64

<EditText
android:id="@+id/editText1"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:inputType="textPersonName"
android:text="Name" />

 Quelques valeurs courantes de android:inputType:

• textPersonName, textUri, textEmailAddress, textPassword,
textVisiblePassword, number, phone, date, time, textMultiLine
 EditText (JAVA)
65

 Comment récupérer ou modifier un editText

EditText e1 = findViewById ([Link].editText1);

// Set Text:
[Link]("New Text");

// Get Text
String text = [Link]().toString();
 EditText (JAVA)
66

 Evènement lors de changement du text

EditText e1=findViewById([Link].e1);

[Link](new TextWatcher() {
@Override
public void afterTextChanged (CharSequence charSequence, int i, int i1, int i2) {

/** Votre code ici ***/

}
});
 Les images
67

 En XML
<ImageView android:id="@+id/logoenig"
android:src="@drawable/enig"
android:layout_width="100px"
android:layout_height="wrap_content"
android:layout_gravity="center_horizontal" >
</ImageView>

 Par la programmation
ImageView image = new ImageView(this);
[Link]([Link]);
[Link](image);
 Les Spinner (liste déroulante) (1/4)
68
 Les Spinner (liste déroulante) (2/4)
69

1er Méthode : Remplissage Statique

Et dans le fichier [Link] :

 Les Spinner (liste déroulante) (3/4)
70

2ème Méthode : Remplissage Dynamique

<Spinner
android:id="@+id/spinner1"
android:layout_width="wrap_content"
android:layout_height="wrap_content " />
 Code Java
String[] items={"GCR", "GEA", "GCP"};

Spinner spinner1 = findViewById([Link].spinner1);

ArrayAdapter<String> adpt=new
ArrayAdapter<String>(this,[Link].simple_spinner_item,items);

[Link]([Link].simple_spinner_dropdown_item);

[Link](adpt);
 Les Spinner (liste déroulante) (4/4)
71

 Gestion des événements des Spinner

[Link](new [Link]() {

@Override
public void onItemSelected(AdapterView<?> adapterView, View view, int i, long l) {
spin=[Link](i).toString();
}

@Override
public void onNothingSelected(AdapterView<?> adapterView) {

});
 Case à cocher : CheckBox (1/3)
72

<CheckBox
android:id="@+id/chkIos"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="IPhone" />

<CheckBox
android:id="@+id/chkAndroid"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Android"
android:checked="true" />

<CheckBox
android:id="@+id/chkWindows"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Windows Phone" />
 Case à cocher : CheckBox (2/3)
73

CheckBox chkIos = findViewById([Link]);

CheckBox chkAndroid = findViewById([Link]);
CheckBox chkWindows = findViewById([Link]);

[Link](new [Link](){
@Override
public void onCheckedChanged(CompoundButton buttonView,
boolean isChecked) {
if (isChecked) {
// Iphone sélectionné
}
else {
// Iphone non sélectionné
}
}
});
 Case à cocher : CheckBox (3/3)

 Pour récupérer une liste des valeurs (String) des checkbox

sélectionnées :
List<CheckBox> list=new ArrayList<>();

[Link](findViewById([Link].checkBox1));
[Link](findViewById([Link].checkBox2));
[Link](findViewById([Link].checkBox3));

ArrayList<String> valeurs=new ArrayList<String>();

for (CheckBox c : list) {
if ([Link]()) {
[Link]([Link]().toString());
}
}
 Bouton radio (1/3)
75

<RadioGroup
android:id="@+id/gr1"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:orientation="vertical">

<RadioButton android:id="@+id/r1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="CGR" />

<RadioButton android:id="@+id/r2"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="GEA" />

</RadioGroup>
Bouton radio (2/3)

RadioGroup g1=findViewById([Link].gr1);

int idradio = [Link]();

String s="";
if(idradio ==[Link].r1){
s="GCR111";
} else if(idradio ==[Link].r2){
s="GCR222";
}
 Bouton radio (3/3)
77

RadioGroup aa = findViewById([Link].gr1);

[Link](new [Link]() {

@Override
public void onCheckedChanged(RadioGroup radioGroup,int i) {
if (i == [Link].r1) {
[Link](getApplicationContext(), "choice: GCR",
Toast.LENGTH_SHORT).show();
} else if (i == [Link].r2) {
[Link](getApplicationContext(), "choice: GEA",
Toast.LENGTH_SHORT).show();

}
}
});
 Les Toasts
78

[Link](getApplicationContext(), “texte” , Toast.LENGTH_LONG).show();

 Les menus (1/5)
79

 Ajouter le dossier menu aux ressources

 Les menus (2/5)
80

 Sélectionner le type menu

 Les menus (3/5)
81

 On crée maintenant le fichier [Link]

 Les menus (4/5)
82

 Exemple d’un fichier [Link]

<menu xmlns:android="[Link]
<item
android:id="@+id/deps"
android:title="Listes des Dépatements"/>
<item
android:id="@+id/etds"
android:title="Listes des Etudiants "/>
<item
android:id="@+id/mats"
android:title="Listes des Matières"/>
<item
android:id="@+id/exit"
android:title="exit"/>
</menu>
 Les menus (5/5)
83

 Integer le menu dans l’application (MainActivity)

public boolean onCreateOptionsMenu(Menu menu)
{
getMenuInflater().inflate([Link].menu1, menu);
return true;
}

public boolean onOptionsItemSelected(MenuItem item)

{
switch ([Link]()) {
case [Link]:
Intent int1= new Intent(getApplicationContext(), [Link]);
startActivity(int1);
return true;
case [Link]:
finish();
return (true);
}
return ([Link](item));
}
 Les menus (5)
84
 Boite de dialogue (1/2)
85

[Link] build = new [Link]([Link]);

[Link]("ENIG");
[Link]("Voulez vous continuer ? ");

[Link](false);
[Link]("Oui",null);

AlertDialog dialog = [Link]();

[Link]();
 Boite de dialogue (2/2)
86

 Avec un traitement (Si oui ou non)

[Link] build = new [Link]([Link]);

[Link]("ENIG");
[Link]("Voulez vous continuer ? ");

[Link]("Oui", new [Link]() {

public void onClick(DialogInterface dialog, int id) {
// User clicked OK button
}
});
[Link]("Non", new [Link]() {
public void onClick(DialogInterface dialog, int id) {
// User cancelled the dialog
}
});
AlertDialog dialog = [Link]();
[Link]();
 Communication entres les activités (1/2)
87

Intent it1 = new Intent (getApplicationContext(), [Link]);

startActivity (it1);
 Communication entres les activités (1/4)
88

 Envoi des valeurs d’une activité à une autre activité

Button bok = findViewById ([Link].envoie1);
bok. setOnClickListener (new [Link]() {
@Override
public void onClick(View v) {
Intent it1 = new Intent (getApplicationContext(), actv_cible.class);
[Link]("dept", "GCR");
[Link]("niv", "1ere");
startActivity(it1);
}
});
 Communication entres les activités (2/4)
89

 Récupération des valeurs dans l’activité cible

Bundle bundle = getIntent().getExtras();

String a1= [Link]("dept");
String a2= [Link]("niv");
Communication entres les activités (3/4)

 Pour envoyer une liste d'éléments dans un intent sous Android, vous
pouvez utiliser la méthode putStringArrayListExtra(String name,
ArrayList<String> value) de l'objet Intent.
 Cette méthode permet d'ajouter une liste de chaînes de
caractères à l'intent sous le nom donné en argument.
 Exemple :
ArrayList<String> valeurs = new ArrayList<String>();
Intent it1 = new Intent (getApplicationContext(), [Link]);
[Link]("niv", valeurs);
startActivity(it1);

 Et pour récupérer la liste :

ArrayList<String> names = getIntent().getStringArrayListExtra("niv");
 Communication entres les activités (4/4)

 Vous avez d'autres possibilités pour passer une liste d'objets

entre activités telles que :

 utiliser la méthode putParcelableArrayListExtra(String

name, ArrayList<T> value) pour envoyer une liste d'objets
implémentant l'interface Parcelable,

 utiliser la méthode putSerializableExtra(String name,

Serializable value) pour envoyer une liste d'objets
implémentant l'interface Serializable

 utiliser GSON pour convertir votre liste en chaine de

caractère JSON, et la passer avec putExtra
 ListView (1/2)

 Remplir un ListView avec une liste des données

// on crée un vecteur des données à afficher
Vector<String> liste_data= new Vector<String>();
liste_data.add("Produit1"); liste_data.add("Produit 2"); liste_data.add("Produit 2");

// on remplit la ListView avec la data chargée

ListView lv = findViewById([Link].liste1);

ArrayAdapter<String> adapter = new ArrayAdapter<String>

(this,[Link].simple_list_item_1, [Link].text1, liste_data);

[Link](adapter);
 ListView (2/2)

 Faire un traitement sur un élément sectionné de la liste

ListView lv = findViewById([Link].liste1);

[Link](new [Link]() {
@Override
public void onItemClick(AdapterView<?> adapterView, View view, int i, long l) {
//On récupère l’item dans un String
String item = (String) [Link]().getItem(i);

/*
Ici votre traitement sur l’élément sectionné
*/
}
});
Eléments de base – Android