1. DÉVELOPPEMENT MOBILE
Enseignante: Mme Haïfa Chorfi Sayari
Institut Supérieur des Etudes Technologiques
NIVEAU : 3ÈME ANNÉE LICENCE APPLIQUÉE DSI
CHAPITRE 2: CONCEPTS DE BASE
2. Notions fondamentales
2
Une application Android est un assemblage de
composants liés grâce à un fichier de
configuration.
Quels sont ces composants?
Comment le fichier de configuration de
l’application les décrit?
Comment tous les composants interagissent
entre eux?
3. Notions fondamentales
3
Différents concepts fondamentaux sont à préciser :
les vues et contrôles (et leur mise en page),
les activités,
les ressources,
le fichier de configuration appelé également manifeste.
4. Exemples d’applications
4
Application de premier plan
Utilisable quand elle est visible et mise en pause lorsqu’elle ne l’est pas.
Jeu
Application d’arrière plan
Interaction limitée en dehors de sa configuration.
Filtrage d’appel, réponse automatique aux SMS.
Application intermittente
Interactive par moment, l’essentiel de sa tâche est en arrière-plan.
Lecteur de musique.
Widget
Composant visuel interactif que les utilisateurs peuvent ajouter à leur écran
d’accueil
Affichage de l’heure, prévision météo
5. Activité
5
Une activité peut être assimilée à un écran structuré par un
ensemble de vues et de contrôles composant son interface de
façon logique : elle est composée d’une hiérarchie de vues
contenant elles-mêmes d’autres vues.
Une application comportant plusieurs écrans, possédera donc
autant d’activités.
6. Vues
6
Les vues sont les éléments de l’interface graphique que
l’utilisateur voit et sur lesquels il pourra agir. Les vues
contiennent des composants, organisés selon diverses mises
en page (les uns à la suite des autres, en grille…).
7. Contrôles
7
Les contrôles (boutons, champs de saisie, case à cocher, etc.)
sont eux-mêmes un sous-ensemble des vues. Ils ont besoin
d’accéder aux textes et aux images qu’ils affichent.
Exemple : un bouton représentant un téléphone aura besoin
de l’image du téléphone correspondante.
Ces textes et ces images seront puisés dans les fichiers
ressources de l’application.
8. Ressources
8
Les ressources telles que les images, les dispositions de
l’interface graphique, etc. nécessaires à l’application.
9. Fichier de configuration
9
À côté de ces éléments, se trouve un fichier XML : le fichier de
configuration de l’application. C’est un fichier indispensable à
chaque application qui décrit entre autres :
Le point d’entrée de votre application (quel code doit être
exécuté au démarrage de l’application) ;
Quels composants constituent ce programme ;
Les permissions nécessaires à l’exécution du programme
(accès à Internet, accès à l’appareil photo...).
13. Composants applicatifs - Activité
13
L’activité (Activity) représente le bloc de base d’une
application. Elle correspond à la partie présentation de
l’application et fonctionne par le biais de vues qui affichent des
interfaces graphiques et répondent aux actions utilisateur.
Exemple :
Une activité pour afficher une image avec un titre
Une activité pour choisir un contact
Une activité pour écrire un message
14. Composants applicatifs - Service
14
Le service est un composant qui fonctionne en tâche de fond,
de manière invisible. Il ne possède pas d’interface. Ses
principales utilisations sont la mise à jour de sources de données
ainsi que d’activités visibles et le déclenchement de
notifications.
Exemple :
Lecture de musique
Collecte de données affichables dans une activité
Suivi GPS
Vérification de mise à jour
15. Composants applicatifs - fournisseur
de contenu
15
Le fournisseur de contenu (Content Provider) permet de
gérer et de partager des informations. Un même fournisseur
permet d’accéder à des données au sein d’une application et
entre applications.
16. Composants applicatifs - Gadget
16
Le gadget (Widget) est un composant graphique qui s’installe
sur le bureau Android.
Exemple :
Le calendrier qui affiche de l’information
Le lecteur audio qui permet de contrôler la lecture de fichiers
17. Composants d’interaction
17
Ces éléments permettent l’interaction entre les différents
composants du système, entre les applications installées
sur l’appareil ou avec l’utilisateur.
18. Composants d’interaction - Intention
18
L’objet Intent (intentions): Une intention est un message
système qu’on peut qualifier d’évènement.
Il est émis par le terminal pour prévenir les applications de la
survenue d’évènements (cas des évènements systèmes :
Insertion d’une carte SD, Réception d’un SMS) ou par tout
autre application (cas des évènements applicatifs : Le logiciel X
démarre, L’utilisateur arrive à Paris).
19. Composants d’interaction - Récepteur
d’Intents
19
Récepteur d’Intents : il permet à une application d’être à
l’écoute des autres afin de répondre aux objets Intent qui lui
sont destinés et qui sont envoyés par d’autres composants
applicatifs.
20. Composants d’interaction - Notification
20
Notification : permet de notifier l'utilisateur de la survenue
d'événements.
21. Manifest de l'application
21
Chaque application Android nécessite un fichier de
configuration : AndroidManifest.xml.
Ce fichier est placé dans le répertoire de base du projet, à sa
racine.
Il décrit le contexte de l’application, les activités, les services,
les récepteurs d’Intents (Broadcast receivers), les fournisseurs
de contenu et les permissions.
22. Manifest de l'application
22
Structure du fichierAndroidManifest.xml :
<?xml version="1.0" encoding="utf-8"?>
<manifest>
<uses-permission />
<permission />
<permission-tree />
<permission-group />
<instrumentation />
<uses-sdk />
<uses-configuration />
<uses-feature />
<supports-screens />
Les permissions (la connexion
réseau, la localisation de
l’appareil, les droits d’écriture sur
la carte mémoire...) qui seront
déclarées ici seront un prérequis
pour l’application.
23. Manifest de l'application
23
<application>
<activity>
<intent-filter>
<action />
<category />
<data />
</intent-filter>
<meta-data />
</activity>
Un manifeste contient un seul et unique noeud
application qui en revanche contient des noeuds
concernant la définition d’activités, de services…
Déclare une activité présentée à
l’utilisateur.
24. Manifest de l'application
24
<service>
<intent-filter> . . .
</intent-filter>
<meta-data/>
</service>
<receiver>
<intent-filter> . . .
</intent-filter>
<meta-data />
</receiver>
Déclare un composant de
l’application en tant que service. Pas
question d’interface graphique, tout
se déroulera en tâche de fond de
votre application.
Déclare un récepteur d’objets Intent.
Cet élément permet à l’application de
recevoir ces objets alors qu’ils sont
diffusés par d’autres applications ou
par le système.
25. Manifest de l'application
25
<provider>
<grant-uri-permission />
<path-permission />
<meta-data />
</provider>
<uses-library />
</application>
</manifest>
Déclare un fournisseur de
contenu qui permettra
d’accéder aux données gérées
par l’application.
26. Ressources
26
Les ressources sont des fichiers externes qui sont utilisés par le
code et liés à votre application au moment de sa construction.
Le répertoire res contient toutes les ressources :
drawable-hdpi (images en haute définition)
drawable-ldpi (images en basse définition)
drawable-mdpi (images en moyenne définition)
layout (description en XML des interfaces)
values (définitions en XML de constantes : chaînes, tableaux,
valeurs numériques …)
anim (description en XML d’animations)
menus (description en XML de menus pour l’application)
xml (fichiers XML utilisés directement par l’application)
raw (tous les autres types de ressources : sons, vidéos, …)
28. Ressources
28
Toutes ces ressources sont placées, converties ou non, dans un
fichier de type APK qui constituera le programme distribuable
de votre application.
De plus, Android crée une classe nommée R qui sera utilisée
pour se référer aux ressources dans le code.
29. Ressources - Utilisation des ressources
29
Les ressources que vous créez ou qu’Android propose peuvent
être utilisées directement dans votre application ou être
référencées dans d’autres ressources.
Les ressources sont accessibles et utilisées depuis le code grâce à
la classe statique R. Cette classe est automatiquement générée en
fonction des ressources présentes dans votre projet au moment
de la compilation et de la construction de l’application.
30. Ressources - Utilisation des ressources
30
Exemple de classe R générée automatiquement
package com.eyrolles.android.exemples;
public final class R {
public static final class string {
public static final int bienvenue=0x7f040000;
public static final int texte_bouton_quitter=0x7f040001;};
public static final class layout {
public static final int ecran_de_demarrage=0x7f030001; };
public static final class drawable {
public static final int image_android=0x7f020000;};
};
31. Ressources - Utilisation des ressources
31
Pour utiliser une ressource, il suffit donc de connaître son type
et son identifiant. La syntaxe est alors la suivante :
R.type_de_ressource.nom_ressource
Exemple :
R.string.email
R.color.bleu_transparent
R.drawable.image_accueil
R.dimen.taille_text
setContentView(R.layout.ecran_de_demarrage);
// Fixe la mise en page d’une activité
32. Ressources - Utilisation des ressources
32
Si vous voulez manipuler des instances :
1. Il faut les extraire de la table grâce aux méthodes de la classe
Ressources :
Resources res = getResources();
2. Ensuite, on peut utiliser les méthodes qui, avec un identifiant
donné, renvoient une instance du type demandé avec la
valeur extraite de la table, telles que
o boolean getBoolean(int)
o int getInteger(int)
o int[] getArray(int)
o String[] getStringArray(int)
o int getColor(int)
o float getDimention(int)
o Drawable getDrawable(int)
33. Ressources - Utilisation des ressources
33
Exemple:
Resources res = getResources();
//Récupération du message à partir du fichier de ressources
strings.xml
String message = res.getString(R.string.bienvenue);
//Remplissage du tableau à partir du fichier arrays.xml
String T[] =
this.getResources().getStringArray(R.array.couleurs);
34. Ressources - Création des ressources
Valeurs Simples
34
Il est possible de déclarer des chaînes de caractères, des
dimensions, des couleurs, des tableaux (de chaînes de caractères
ou d’entiers) comme valeurs simples.
Par convention on sépare les ressources en regroupant les
mêmes types dans un fichier au nom explicite.
Exemple :
res/values/strings.xml pour regrouper toutes les chaînes
de caractères.
res/values/array.xml pour définir des tableaux.
35. Ressources - Création des ressources
Valeurs Simples
35
1. Chaînes de caractères et texte formaté
Les chaînes de caractères avec un format optionnel peuvent être
utilisées comme ressources.
Leur syntaxe est la suivante :
<string
name=nom_chaine>valeur_de_la_chaine</string>.
Exemple :
<resources>
<string name="app_name">TP1</string>
<string name="menu_principal">Menu Principal</string>
</resources>
36. Ressources - Création des ressources
Valeurs Simples
36
1. Chaînes de caractères et texte formaté
Utilisation des chaînes de caractères :
• Java : R.string.le_nom
• XML : @[package:]string/un_nom
Possibilité d’utiliser les balises HTML <b>, <i> et <u>
<string name= "ex1"> Un texte <b>mis en gras</b></string>
Cas particulier des guillemets ou apostrophes
<string name= "ex2">Voici l’application de ce conseil</string>
37. Ressources - Création des ressources
Valeurs Simples
37
2. Tableaux
Il faut utiliser la balise array.
Exemple :
<array name="tableau_entiers">
<item>1765</item>
<item>3</item>
</array>
La balise array n’exige pas que les éléments soient de même type
: le tableau peut être hétérogène.
38. Ressources - Création des ressources
Valeurs Simples
38
2. Tableaux
Un tableau de chaine de caractères est une ressource simple qui
est référencée en utilisant la valeur fournie dans l’attribut name
(et pas le nom du fichier XML).
Exemple :
<resources>
<string-array name="planets_array">
<item>Mercury</item>
<item>Venus</item>
<item>Mars</item>
</string-array>
</resources>
39. Ressources - Création des ressources
Valeurs Simples
39
3. Couleurs
Une couleur définit une valeur RVB (rouge, vert et bleu) et une
transparence. Cette couleur peut être utilisée à de multiples
endroits comme pour définir la couleur d’un texte. Il existe
différents formats dont la syntaxe globale est la suivante :
<color name=nom_couleur>valeur_de_la_couleur</color>
Les différents formats d’une couleur sont les suivants :
• #RGB (Rouge-Vert-Bleu/valeur hexadécimale sur 1 caractère [0,16])
• #ARGB (Alpha (transparence)-Rouge-Vert-Bleu)
• #RRGGBB (Rouge-Vert-Bleu/valeur hexadécimale sur 2 caractères
[0,255])
• #AARRGGBB
40. Ressources - Création des ressources
Valeurs Simples
40
3. Couleurs
Exemple :
<resources>
<color name="bleu_transparent">#50ff00FF</color>
</resources>
Utilisation des couleurs (exemple avec la déclaration de la
couleur bleu_transparent) :
• Java : R.color.bleu_transparent
• XML : @[package:]color/bleu_transparent
41. Ressources - Création des ressources
Valeurs Simples
41
4. Unité de mesure
Les dimensions sont la plupart du temps référencées dans les styles et
les mises en page.
Une dimension est spécifiée par un nombre suivi d’une unité de
mesure.
Les unités prises en charge par Android: px (pixels), in (pouces), mm
(millimètres), pt (point), dp (independant-density pixel), sp (scale
independant pixel)
Exemple:
<resources>
<dimen name="largeur_bouton">100px</dimen>
<dimen name="taille_texte">5sp</dimen>
</resources>
42. Ressources - Création des ressources
Images
42
Android prend en charge les fichiers bitmap sous différents
formats avec une préférence bien affirmée dans la
documentation pour le format PNG. Il est cependant possible
d’utiliser le format JPEG ou le format GIF (qui est déconseillé
par la documentation).
Utilisation des images de type bitmap :
• Java : R.drawable.fichier_bitmap
• XML : @[package:]drawable/fichier_bitmap
43. Ressources - Création des ressources
Autres ressources
43
Les menus : les menus de l’application peuvent être définis
comme ressources XML.
La mise en page (layouts ou encore gabarits) : les mises en pages
définies dans les fichiers de ressources XML permettent de
découper la couche présentation en évitant de construire la mise
en page d’une interface graphique dans le code.
Exemple :
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent" >
……
</LinearLayout>
44. 44
Remarque :
Il est possible de définir différents types de ressources dans un même fichier
Exemple :
<?xml version="1.0" encoding="utf-8"?> _
<resources> _
<string name="nom_application">Suivi des SMS</string>
<color name="couleur_des_boutons">#FFAABBCC</color>
<array name="tableau_entiers">
<item>1765</item>
<item>3</item>
</array>
<dimen name="taille_texte">5sp</dimen>
</resources>
45. Exercice
45
1. Quel est le type de ressource qui permet
de stocker les noms des pays ?
2. Quel est le nom du fichier de ressources?
3. Ajouter les noms de pays à ce fichier.
4. En se basant sur la classe R, récupérer la
liste de pays dans une structure de
données.
L’interface suivante contient un widget de sélection
permettant d’afficher une liste de pays.
46. Exercice
46
5. On suppose que chaque pays est présenté
par une image (exemple: australie.png).
a. Dans quel répertoire sont stockées ces
images?
b. Modifier le fichier de ressources
correspondant pour pourvoir référencer ces
ressources images.
L’interface suivante contient un widget de sélection
permettant d’afficher une liste de pays.
47. Activité
47
Une activité peut être assimilée à un écran qu’une application
propose à son utilisateur.
Pour chaque écran de votre application, vous devrez donc créer
une activité.
La transition entre deux écrans correspond au lancement d’une
activité ou au retour sur une activité placée en arrière-plan.
.
48. Activité
48
Une activité est composée de deux volets :
la logique de l’activité et la gestion du cycle de vie de
l’activité qui sont implémentés en Java dans une classe
héritant de Activity
l’interface graphique, qui pourra être définie soit dans le
code de l’activité soit de façon plus générale dans un fichier
XML placé dans les ressources de l’application.
49. Activité
49
Syntaxe minimal pour créer une première activité :
import android.app.Activity;
import android.os.Bundle;
public class ActiviteSimple extends Activity {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
}
50. Cycle de vie d’une activité
50
Les applications Android ont un fonctionnement particulier :
elles réagissent à des changements d’états imposés par le
système (démarrage, pause, reprise, arrêt...).
Les états principaux d’une activité sont les suivants :
Active (running) : Quand l’activité est au premier plan et
reçoit les actions utilisateur.
Suspendue (Paused) : Quand elle est toujours visible mais n’a
pas le focus (autre activité transparente par-dessus ou activité
ne prenant pas tout l’écran).
Arrêtée (Stopped) : Quand elle n’est plus visible.
52. Cycle de vie d’une activité
52
onCreate() : Appelée lorsque l’activité est créée. Permet de
restaurer l’état de l’interface utilisateur grâce au paramètre
savedInstanceState.
onDestroy() : Appelée lorsque que l’activité a fini son cycle de
vie. C’est ici qu’on place le code de libération de mémoire,
fermeture de fichiers et autres opérations de "nettoyage".
onStart() : Appelée lorsque l’activité démarre. Permet
d’initialiser les contrôles.
onStop() : Appelée lorsque l’activité passe en arrière plan.
Libérez les écouteurs, arrêtez les threads, votre activité peut
disparaître de la mémoire.
onRestart() : Appelée lorsque l’activité sort de son état de
veille.
53. Cycle de vie d’une activité
53
onPause() : Appelée lorsque que l’activité est suspendue.
Stoppez les actions qui consomment des ressources. L’activité va
passer en arrière-plan.
onResume() : Appelée après le démarrage ou une pause.
Relancez les opérations arrêtées (threads). Mettez à jour
l’application et vérifiez vos écouteurs.
onSaveInstanceState() : Appelée lorsque l’activité termine
son cycle visible. Sauvez les données importantes.
onRestoreInstanceState() : Appelée après onCreate. Les
données sont rechargées et l’interface utilisateur est *restaurée
dans le bon état.
55. Cycle de vie d’une activité
55
Le cycle de vie d’une activité fait appel aux méthodes relatives à
chaque étape de sa vie.
Il informe ainsi le développeur sur la suite des événements et le
travail qu’il doit accomplir.
56. Cycle de vie d’une activité
56
Syntaxe d’une activité :
public class MainActivity extends Activity {
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);}
protected void onDestroy() {
super.onDestroy(); }
protected void onPause() {
super.onPause(); }
protected void onResume() {
super.onResume(); }
57. Cycle de vie d’une activité
57
protected void onStart() {
super.onStart(); }
protected void onStop() {
super.onStop(); } }
58. Cycle de vie d’une activité
58
L'objet Bundle passé en paramètre de la méthode onCreate permet
de restaurer les valeurs des interfaces d'une activité qui a été déchargée
de la mémoire. En effet, lorsque l'on appuie par exemple sur la touche
Home, en revenant sur le bureau, Android peut être amené à déchargé
les éléments graphiques de la mémoire pour gagner des ressources. Si
l'on rebascule sur l'application (appui long sur Home), l'application
peut avoir perdu les valeurs saisies dans les zones de texte.
Si une zone de texte n'a pas d'identifiant, Android ne pourra pas la
sauver et elle ne pourra pas être restaurée à partir de l'objet Bundle.
Si l'application est complètement détruite (tuée), rien n'est restauré.