Ch2. Développement mobile

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

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?

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.

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

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.

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

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.

Ressources
8
 Les ressources telles que les images, les dispositions de
l’interface graphique, etc. nécessaires à l’application.

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

11
Activités
Gadgets
Récepteurs
d’Intent
ServicesNotifications
Objets
Intent
Fournisseurs
de contenus
Composants d’une
applicationAndroid
Composants d’une application Android

Composants d’une application
12
Activités
Gadgets /Widgets
Services
Fournisseurs de contenus Notifications
Récepteurs d’intentions
Objets Intent
Composants applicatifs Eléments d’interaction

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

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

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.

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

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.

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

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.

Composants d’interaction - Notification
20
 Notification : permet de notifier l'utilisateur de la survenue
d'événements.

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

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, …)

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.

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
 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
 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
 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
 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);

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.

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>

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 , et 
<string name= "ex1"> Un texte mis en gras</string>
 Cas particulier des guillemets ou apostrophes
<string name= "ex2">Voici l’application de ce conseil</string>

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.

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>

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

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

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>

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

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
 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>

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.

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.

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

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.

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);
}
}

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.

Cycle de vie d’une application
51

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

Cycle de vie d’une application
54

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
 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
protected void onStart() {
super.onStart(); }
protected void onStop() {
super.onStop(); } }

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

Ch2. Développement mobile

Contenu connexe

Tendances

Similaire à Ch2. Développement mobile

Ch2. Développement mobile