Android

Vous découvrirez dans un premier temps la plate-forme Android, vous
installerez l’environnement de développement et vous créerez sans
attendre votre première application Android. Vous étudierez ensuite comment se construit l’interface utilisateur et prendrez connaissance des
composants applicatifs fondamentaux. Vous apprendrez à développer
des interfaces complexes qui s’adaptent aux écrans des tablettes
et smartphones et à construire vos propres composants réutilisables.
Puis, seront présentées la persistance des données, la programmation
concurrente, la sécurité et la communication réseau. Un chapitre vous
expliquera comment intégrer les réseaux sociaux dans vos applications.
Pour pouvoir proposer des applications les plus qualitatives possibles,
vous découvrirez comment ajouter des traces et tester votre application. Vous serez enfin guidé pas à pas pour publier vos applications vers
les utilisateurs du monde entier.
L’ouvrage se termine en présentant la détermination de la géolocalisation et l’utilisation des capteurs intégrés dans les terminaux Android.
Sont également traités en détail des sujets avancés tels que la création
d’AppWidget, la protection des applications payantes (LVL), les achats
in-app ainsi que les communications NFC. À l’issue de cette lecture,
vous serez capable de développer et publier des applications, de qualité,
natives Android (dans ses différentes versions jusqu’à la 4.4 incluse) pour
Smartphones et Tablettes tactiles.
Enfin, en complément et pour illustrer de façon pratique les propos de l’ouvrage, l’auteur propose en téléchargement sur le site www.editions-eni.fr
Téléchargement
un projet reprenant
toutes .frles notions présentées dans le livre. Interface
www.editions-eni.fr
utilisateur, listes, traitements asynchrones, géolocalisation, NFC, etc. :
tous les modules du projet sont fonctionnels, directement exploitables, et
fournissent une solide structure de base pour vos développements.
Sur www.editions-eni.fr :
bL
e code source de tous les modules du projet.
Sébastien PÉROCHON est le fondateur de
Mobiquité, entreprise spécialisée dans le
développement et la formation au développement d’applications mobiles (Android,
iPhone, iPad). Fort d’une dizaine d’années
d’expérience dans le développement logiciel, la gestion de projet et le management
d’équipe, Sébastien Pérochon est également très impliqué dans les communautés
de développement autour d’Android.
Les chapitres du livre
Avant-propos • L’univers Android • Premiers pas • Découverte de l’interface
utilisateur • Les fondations • Compléter
l’interface utilisateur • Composants applicatifs principaux • La persistance des
données • Construire des interfaces complexes • Concurrence, sécurité et réseau •
Réseaux sociaux • Tracer, déboguer et
tester • Publier une application • Capteurs
et géolocalisation • La technologie NFC •
Fonctionnalités avancées
Pour plus
d’informations :
39 €
Android
Le livre présente l’intégralité du processus de création d’applications, de
la mise en place de l’environnement de développement jusqu’à la publication de l’application, et décrit une large sélection de fonctionnalités
proposées par le système Android.
Développement pour
Smartphones et Tablettes
Véritable guide d’apprentissage, ce livre accompagne le lecteur dans
le développement d’applications Android pour Smartphones et Tablettes tactiles. Il s’adresse aux développeurs disposant d’un minimum
de connaissances sur la programmation orientée objet, le langage Java et
les environnements de développement intégrés type Eclipse ou Android
Studio et couvre toutes les versions d’Android jusqu’à la 4.4 incluse.
Sylvain HEBUTERNE est Architecte Android. Spécialisé dans la programmation
objet depuis 15 ans, il conçoit des applications Android à titre personnel ou pour
le compte d’agences de communication.
Ces projets très diversifiés lui permettent
d’exploiter tout le potentiel de la plate-forme
Android ainsi que les fonctionnalités plus
avancées proposées par la dernière version.
ISBN : 978-2-7460-8926-6
Android - Guide de développement d’applications Java
pour Smartphones et Tablettes
Android
Guide de développement
d’applications Java
pour Smartphones et Tablettes
Sylvain HÉBUTERNE
Sébastien PEROCHON
Table des matières
Les éléments à télécharger sont disponibles à l'adresse suivante : http://www.editions-eni.fr Saisissez la référence ENI de l'ouvrage EI2AND dans la zone de recherche et validez. Cliquez sur le titre du livre puis sur le bouton de téléchargement.
Avant-propos
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2. À qui s'adresse cet ouvrage ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
3. Connaissances nécessaires pour aborder cet ouvrage . . . . . . . . . . . . . 16
4. Objectifs à atteindre . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
5. Téléchargements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6. Informations complémentaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
7. Ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Chapitre 1
L'univers Android
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2. Présentation d'Android. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.1 Open Handset Alliance™ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.2 Historique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.3 Versions d'Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.1 Chronologie des versions . . . . . . . . . . . . . . . . . . . . . . . . . . 24
2.3.2 Répartition des distributions Android . . . . . . . . . . . . . . . 28
2.4 Architecture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3. Environnement de développement . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.1 Pré-requis. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
3.2 Eclipse et plug-in ADT . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4. Installation d’Android Studio . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
1
2
Android
Guide de développement d’applications pour Smartphones et Tablettes
Chapitre 2
Premiers pas
1. Premier projet Android. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
1.1 Création du projet . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
1.2 Exécution de l'application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
1.2.1 Sur l'émulateur Android. . . . . . . . . . . . . . . . . . . . . . . . . . . 52
1.2.2 Sur un appareil Android . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
2. Structure d'un projet Android . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
2.1 Le manifeste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 69
2.1.1 Balise manifest . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
2.1.2 Balise uses-sdk. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
2.1.3 Balise application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
2.2 Les ressources . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
Chapitre 3
Découverte de l'interface utilisateur
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
2. Écrans . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
3. Activités et Layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85
4. Mode programmatique et mode déclaratif . . . . . . . . . . . . . . . . . . . . . 87
5. Vues . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 90
6. Layouts . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 92
6.1 Création en mode déclaratif. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
6.2 Création en mode programmatique . . . . . . . . . . . . . . . . . . . . . . 95
7. Widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
7.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98
Table des matières
7.3 Découverte de quelques widgets . . . . . . . . . . . . . . . . . . . . . . . . . 98
7.3.1 TextView (champ de texte). . . . . . . . . . . . . . . . . . . . . . . . 99
7.3.2 EditText (champ de texte de saisie) . . . . . . . . . . . . . . . . 102
7.3.3 Button (bouton) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
7.3.4 Autres widgets . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 107
Chapitre 4
Les fondations
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 109
2. Intention . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110
2.1 Intention explicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113
2.2 Intention implicite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
2.2.1 Création. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
2.2.2 Filtre d'intention . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
2.3 Intention en attente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 117
3. Activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 118
3.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
3.2 Cycle de vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
3.2.1 onCreate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
3.2.2 onStart. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
3.2.3 onResume . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 123
3.2.4 onPause . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124
3.2.5 onStop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 125
3.2.6 onRestart. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
3.2.7 onDestroy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
3.3 Lancement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
3.4 Sauvegarde et restauration de l'état. . . . . . . . . . . . . . . . . . . . . . 129
3.5 Pile d'activités . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131
3
4
Android
Guide de développement d’applications pour Smartphones et Tablettes
Chapitre 5
Compléter l'interface utilisateur
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
2. Styles et thèmes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 133
3. Menus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
3.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 135
3.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138
3.3 Menu d'activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
3.3.1 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
3.3.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
3.4 Menu contextuel . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141
3.4.1 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
3.4.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
4. Barre d'action . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
4.1 Options de menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
4.2 Icône de l'application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
5. Notifications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
5.1 Toast . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
5.2 Boîte de dialogue. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 147
5.2.1 Tour d'horizon . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
5.2.2 Boîte de dialogue d'alerte . . . . . . . . . . . . . . . . . . . . . . . . . 148
5.3 Barre de notification. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
5.3.1 Création d'une notification . . . . . . . . . . . . . . . . . . . . . . . 154
5.3.2 Envoi d'une notification. . . . . . . . . . . . . . . . . . . . . . . . . . 157
6. Internationalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 158
Table des matières
Chapitre 6
Composants applicatifs principaux
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
2. Fragment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
2.1 Intégration du fragment. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
2.1.1 Mode déclaratif. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
2.1.2 Mode programmatique . . . . . . . . . . . . . . . . . . . . . . . . . . 164
2.2 Fragments et mise en page adaptative . . . . . . . . . . . . . . . . . . . 167
2.3 Cycle de vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
2.3.1 onAttach . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
2.3.2 onCreateView . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
2.3.3 onActivityCreated . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 169
2.3.4 onDestroyView. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
2.3.5 onDetach. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 170
2.4 Sauvegarde et restauration de l'état. . . . . . . . . . . . . . . . . . . . . . 171
2.5 Pile de fragments. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171
3. Service . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 173
3.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 174
3.2 Utilisation directe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 175
3.3 Utilisation en établissant une connexion . . . . . . . . . . . . . . . . . 176
3.4 Cycle de vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 177
3.4.1 onCreate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
3.4.2 onStartCommand. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178
3.4.3 onBind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
3.4.4 onUnbind . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179
3.4.5 onDestroy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
4. Récepteur d'évènements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
4.1 Évènement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181
4.2 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182
4.3 Cycle de vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 183
5
6
Android
Guide de développement d’applications pour Smartphones et Tablettes
5. Liste . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 184
5.1 Implémentation standard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
5.1.1 Layout des éléments de la liste . . . . . . . . . . . . . . . . . . . . 185
5.1.2 Adaptateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
5.1.3 Implémentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 186
5.2 Implémentation spécifique . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
5.2.1 Layout des éléments de la liste . . . . . . . . . . . . . . . . . . . . 190
5.2.2 Adaptateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191
5.3 Sélection d’un élément . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 194
Chapitre 7
La persistance des données
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
2. Fichiers de préférences . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
2.1 Cibler le fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 198
2.2 Lecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 199
2.3 Écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 200
2.4 Suppression . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 202
3. Fichiers . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
3.1 Stockage interne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
3.1.1 Écriture . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
3.1.2 Lecture. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 204
3.1.3 Supprimer un fichier . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
3.2 Stockage externe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 205
3.2.1 Disponibilité du support . . . . . . . . . . . . . . . . . . . . . . . . . 206
3.2.2 Accès et emplacements . . . . . . . . . . . . . . . . . . . . . . . . . . 207
3.2.3 Fichiers communs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
3.3 Fichiers temporaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
3.3.1 Stockage interne . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 209
3.3.2 Stockage externe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
Table des matières
4. Bases de données SQLite . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 211
4.1 Création d'une base de données. . . . . . . . . . . . . . . . . . . . . . . . . 211
4.2 Traitements et requêtes SQL . . . . . . . . . . . . . . . . . . . . . . . . . . . 213
4.2.1 Navigation dans les résultats . . . . . . . . . . . . . . . . . . . . . . 214
4.2.2 Lecture de données . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
4.3 Mises à jour . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 217
5. Fournisseur de contenus. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
5.1 Interface et URI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
5.2 Requêtes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 221
5.3 Ajout d'un enregistrement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 223
5.4 Suppression d'enregistrements . . . . . . . . . . . . . . . . . . . . . . . . . 223
6. Sauvegarde dans les nuages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 224
6.1 Souscrire à l'Android Backup Service. . . . . . . . . . . . . . . . . . . . . 225
6.2 Configuration de la clé . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 227
6.3 Agent de sauvegarde . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 228
6.3.1 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
6.3.2 BackupAgentHelper . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 229
6.4 Gestionnaire de sauvegarde . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
6.4.1 Demander une sauvegarde . . . . . . . . . . . . . . . . . . . . . . . . 233
6.4.2 Tester le service. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 233
Chapitre 8
Construire des interfaces complexes
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 235
2. Créer ses propres composants . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 236
2.1 Surcharger un composant existant . . . . . . . . . . . . . . . . . . . . . . 236
2.1.1 Étendre une classe du package android.widget. . . . . . . . 236
2.1.2 Intégrer le nouveau composant dans un layout . . . . . . . 237
2.1.3 Ajouter des attributs personnalisés . . . . . . . . . . . . . . . . . 238
2.2 Réunir un ensemble de composants . . . . . . . . . . . . . . . . . . . . . 241
7
8
Android
Guide de développement d’applications pour Smartphones et Tablettes
2.3 Construire entièrement un composant. . . . . . . . . . . . . . . . . . . 242
2.3.1 Implémenter onDraw() . . . . . . . . . . . . . . . . . . . . . . . . . . 242
2.3.2 Implémenter onMeasure() . . . . . . . . . . . . . . . . . . . . . . . . 243
2.3.3 Obtenir les dimensions de l'écran . . . . . . . . . . . . . . . . . . 244
3. Utiliser le Navigation Drawer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 245
3.1 Mettre en place le panneau de navigation . . . . . . . . . . . . . . . . 246
3.2 Utiliser le panneau de navigation . . . . . . . . . . . . . . . . . . . . . . . 248
3.2.1 Détecter les évènements d'ouverture/fermeture . . . . . . 249
3.2.2 Navigation Drawer et ActionBar. . . . . . . . . . . . . . . . . . . 250
3.2.3 Intégrer le bouton d'ouverture/fermeture . . . . . . . . . . . 251
3.2.4 Forcer l'ouverture du panneau
au lancement de l'activité. . . . . . . . . . . . . . . . . . . . . . . . . 253
4. Créer des images redimensionnables . . . . . . . . . . . . . . . . . . . . . . . . . 253
4.1 Les images 9-patch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
4.1.1 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 254
4.1.2 Créer des images 9-patch . . . . . . . . . . . . . . . . . . . . . . . . . 256
4.2 Les drawables XML . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 259
4.2.1 Définir une forme en XML . . . . . . . . . . . . . . . . . . . . . . . 259
4.2.2 Modifier la forme initiale . . . . . . . . . . . . . . . . . . . . . . . . . 262
4.2.3 Combiner plusieurs formes . . . . . . . . . . . . . . . . . . . . . . . 267
5. Mise en page complexe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
5.1 Choix du layout . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 268
5.2 Positionnement relatif . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 269
5.3 Chevauchement des vues. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 271
5.4 Un dernier point . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 274
Table des matières
Chapitre 9
Concurrence, sécurité et réseau
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
2. Processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 275
2.1 android:process . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 276
2.2 Partage de processus . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 277
3. Programmation concurrente . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 279
3.1 AsyncTask. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 280
3.2 Thread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
3.2.1 Création. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 284
3.2.2 runOnUIThread . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 285
3.2.3 Communication interthread . . . . . . . . . . . . . . . . . . . . . . 286
4. Sécurité et droits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 289
4.1 Déclaration de droits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 290
4.2 Restriction d'utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 291
5. Réseau . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 292
5.1 Agent utilisateur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 294
5.2 AndroidHttpClient. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 297
Chapitre 10
Réseaux sociaux
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
2. Intégration standard. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
2.1 Sous Android 2.x et 3.x . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 302
2.2 Sous Android 4.x. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
3. Intégration complète . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
3.1 Récupérer les clés d'API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 307
3.1.1 Créer une application Facebook. . . . . . . . . . . . . . . . . . . . 308
3.1.2 Autres réseaux sociaux . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
9
10
Android
Guide de développement d’applications pour Smartphones et Tablettes
3.2 Installer le SDK SocialAuth-Android . . . . . . . . . . . . . . . . . . . . 311
3.2.1 Intégration des bibliothèques dans le projet. . . . . . . . . . 312
3.2.2 Utilisation de l'API . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 312
Chapitre 11
Tracer, déboguer et tester
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
2. Journal d'évènements . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 320
2.1 Consultation des évènements . . . . . . . . . . . . . . . . . . . . . . . . . . 321
2.2 Écriture des évènements. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 324
3. Débogage. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
3.1 Débogage pas à pas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 325
3.2 DDMS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
3.2.1 Vue Devices. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 329
3.2.2 Vue Emulator Control . . . . . . . . . . . . . . . . . . . . . . . . . . . 331
3.2.3 Vue Threads . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 332
3.2.4 Vue Heap. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 333
3.2.5 Vue Allocation Tracker . . . . . . . . . . . . . . . . . . . . . . . . . . 334
3.2.6 Vue File Explorer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
4. Tests unitaires et fonctionnels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 335
4.1 Création d'un projet de tests . . . . . . . . . . . . . . . . . . . . . . . . . . . 336
4.2 Création d'une classe de cas de tests . . . . . . . . . . . . . . . . . . . . . 341
4.2.1 Tester une activité . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
4.2.2 Tester un service. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
4.2.3 Tester un récepteur d'évènements. . . . . . . . . . . . . . . . . . 347
4.3 Exécution des tests . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 347
5. Test du singe. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
Table des matières
Chapitre 12
Publier une application
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353
2. Préliminaires . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
2.1 Version de l'application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
2.1.1 android:versionCode . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
2.1.2 android:versionName . . . . . . . . . . . . . . . . . . . . . . . . . . . . 356
2.2 Filtres pour le marché . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 357
2.2.1 uses-feature . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
2.2.2 uses-configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 359
3. Signature de l'application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
3.1 Compilation en mode débogage . . . . . . . . . . . . . . . . . . . . . . . . 360
3.2 Compilation en mode final . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
3.2.1 Protection du code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 362
3.2.2 Signer l'application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 363
3.2.3 Installer l'application . . . . . . . . . . . . . . . . . . . . . . . . . . . . 367
4. Publication de l'application sur le Play Store . . . . . . . . . . . . . . . . . . 368
4.1 Inscription. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 369
4.2 Publication . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
4.2.1 Fichier .apk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
4.2.2 Fiche Google Play Store . . . . . . . . . . . . . . . . . . . . . . . . . . 380
4.2.3 Tarifs et disponibilité . . . . . . . . . . . . . . . . . . . . . . . . . . . . 382
4.2.4 Coordonnées . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
4.2.5 Accepter. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
4.3 Et après ? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 384
Chapitre 13
Capteurs et géolocalisation
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
2. Fondamentaux . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
3. Détecter un capteur . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
11
12
Android
Guide de développement d’applications pour Smartphones et Tablettes
4. Obtenir les valeurs . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 391
5. Localisation géographique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 394
5.1 Permissions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
5.2 Gestionnaire de localisation. . . . . . . . . . . . . . . . . . . . . . . . . . . . 396
5.3 Récupérer les données de localisation . . . . . . . . . . . . . . . . . . . . 397
5.3.1 En cache . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
5.3.2 Une seule fois . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
5.3.3 Périodiquement. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 401
5.3.4 Stopper les mises à jour . . . . . . . . . . . . . . . . . . . . . . . . . . 402
6. Google Maps . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
6.1 Mise en place. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
6.1.1 Installation du SDK . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
6.1.2 Configuration de l'application . . . . . . . . . . . . . . . . . . . . . 404
6.1.3 Obtenir une clé d'utilisation . . . . . . . . . . . . . . . . . . . . . . 405
6.2 Utilisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 408
6.2.1 Déclaration de la vue . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
6.2.2 MapActivity . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 409
6.2.3 Géolocalisation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 411
Chapitre 14
La technologie NFC
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
2. La technologie NFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 415
2.1 Les scénarios d'utilisation du NFC . . . . . . . . . . . . . . . . . . . . . . 416
2.2 Les tags NFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 416
3. Prise en charge du NFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
3.1 Utiliser avec un émulateur. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 418
3.2 Détecter si l'appareil est compatible NFC. . . . . . . . . . . . . . . . . 419
3.2.1 Filtrer les appareils . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 419
3.2.2 Tester à l'exécution. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
3.2.3 Activation par l'utilisateur . . . . . . . . . . . . . . . . . . . . . . . . 420
Table des matières
4. Découverte d'un tag NFC. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 420
4.1 Prise en charge d'un intent ACTION_NDEF_DISCOVERED. 421
4.2 Prise en charge d'un intent ACTION_TECH_DISCOVERED 423
4.3 Prise en charge d'un intent ACTION_TAG_DISCOVERED. . 425
4.4 Android Application Records. . . . . . . . . . . . . . . . . . . . . . . . . . . 425
4.5 Foreground dispatch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 426
5. Lire un tag NFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 428
5.1 Déterminer le contenu d'un tag NDEF . . . . . . . . . . . . . . . . . . . 429
5.2 Lire une URI . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 430
5.3 Lire une chaîne de caractères . . . . . . . . . . . . . . . . . . . . . . . . . . . 432
5.4 Lire un Type MIME . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 433
5.5 Lire un tag de type TNF_WELL_KNOWN . . . . . . . . . . . . . . . . 433
6. Écrire un tag NFC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434
6.1 Définir un enregistrement NdefRecord avec l'API 9 . . . . . . . . 435
6.1.1 Construire un payload de type texte. . . . . . . . . . . . . . . . 436
6.1.2 Construire un payload de type URI . . . . . . . . . . . . . . . . 437
6.2 Définir un enregistrement NdefRecord avec les API 14 et 16 . 438
Chapitre 15
Fonctionnalités avancées
1. Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
2. App Widget . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 441
2.1 Création. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 442
2.2 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 443
2.3 Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 444
2.4 Cycle de vie . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 446
2.4.1 onEnabled . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
2.4.2 onDisabled . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 447
2.4.3 onUpdate. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
2.4.4 onDeleted . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 448
2.5 RemoteViews . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 449
13
14
Android
Guide de développement d’applications pour Smartphones et Tablettes
2.6 Activité de configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
2.6.1 Déclaration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 452
2.6.2 Création . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 453
3. Protéger les applications payantes. . . . . . . . . . . . . . . . . . . . . . . . . . . 455
3.1 Installation de la LVL . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
3.1.1 Téléchargement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 456
3.1.2 Intégration de la LVL dans le code source. . . . . . . . . . . . 458
3.1.3 Intégration de la LVL en tant que bibliothèque . . . . . . . 458
3.2 Utilisation de la LVL. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
3.2.1 Politique . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 461
3.2.2 Obfuscation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 462
3.2.3 Vérification de la licence . . . . . . . . . . . . . . . . . . . . . . . . . 463
3.3 Tester. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 465
3.3.1 Tester sur un appareil Android . . . . . . . . . . . . . . . . . . . . 470
3.3.2 Tester sur un émulateur. . . . . . . . . . . . . . . . . . . . . . . . . . 470
4. Proposer des achats intégrés. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
4.1 Préparation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 471
4.2 Utilisation du paiement intégré . . . . . . . . . . . . . . . . . . . . . . . . 474
4.2.1 Initier la communication avec le Play Store . . . . . . . . . . 474
4.2.2 Obtenir la liste des produits. . . . . . . . . . . . . . . . . . . . . . . 475
4.2.3 Vérifier qu’un produit a été commandé . . . . . . . . . . . . . 477
4.2.4 Commander un produit . . . . . . . . . . . . . . . . . . . . . . . . . . 478
Index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 481
197
Chapitre 7
La persistance des données
1. Introduction
La pers istance des données
Ce chapitre a pour but de présenter la persistance des données sous Android.
Les données persistantes d'une application sont les données sauvegardées
avant la fermeture de l'application de telle sorte qu'elles puissent être restaurées ultérieurement.
Android propose plusieurs mécanismes permettant de gérer la persistance de
données, selon la nature de ces données. Nous découvrirons les fichiers de préférences, les fichiers standard et les bases de données.
Nous terminerons par les fournisseurs de contenus qui, au-delà de la persistance des données, proposent un mécanisme de partage de données entre les
applications.
2. Fichiers de préférences
Android fournit un framework simple pour sauvegarder et restaurer des données de types primitifs. Ces données sont sauvegardées dans des fichiers au
format XML sous la forme d'associations clés-valeurs. Ces fichiers sont appelés fichiers de préférences.
198
Android
Guide de développement d’applications pour Smartphones et Tablettes
Nous allons étudier dans un premier temps comment cibler un fichier de préférences, puis comment le lire et y écrire des données. Nous terminerons par
décrire comment supprimer toutes ou partie des données de ces fichiers.
Remarque
Le système Android permet d'afficher et de sauvegarder les préférences générales de l'utilisateur. Toute application peut adopter la même fonctionnalité
et le même affichage. La hiérarchie des préférences proposées peut être réalisée directement dans un fichier XML. L'implémentation d'un tel écran de préférences est réalisée en dérivant de la classe PreferenceActivity. Depuis
Android 3.0 (API 11), cette classe fonctionne de concert avec les fragments
de type PreferenceFragment afin de pouvoir, entre autres, afficher côte à
côte les titres des sections et les préférences qu'elles proposent.
2.1 Cibler le fichier
Par défaut, un fichier de préférences est associé à l'activité qui le crée. Ce fichier porte automatiquement le nom qualifié entier de l'activité concernée,
par exemple fr.mondomaine.android.monappli.prefsFic1.xml.
La création et la gestion du fichier de préférences sont réalisées au travers d'un
objet de type SharedPreferences retourné par la méthode getPreferences de la classe Activity.
Syntaxe
public SharedPreferences getPreferences (int mode)
– Context.MODE_PRIVATE : mode privé. C'est le mode par défaut. Le fichier ne peut être lu et écrit que par l'application courante, ou une application partageant le même identifiant utilisateur.
– Context.MODE_WORLD_READABLE : les autres applications peuvent lire
le fichier.
– Context.MODE_WORLD_WRITEABLE : les autres applications peuvent
modifier le fichier.
© Editions ENI - All rights reserved
Cette méthode prend en paramètre le mode d'accès à assigner au fichier lors
de sa création. Les valeurs possibles pour ce paramètre sont :
La persistance des données
Chapitre 7
Exemple
SharedPreferences prefs = getPreferences(Context.MODE_PRIVATE);
Il est également possible de spécifier explicitement un autre nom de fichier.
Cela permet de créer plusieurs fichiers de préférences. Pour cela, il faut utiliser
la méthode getSharedPreferences en spécifiant le nom du fichier en premier paramètre.
Syntaxe
public abstract SharedPreferences getSharedPreferences (String
name, int mode)
Exemple
SharedPreferences prefs =
getSharedPreferences("nomFichierPrefs1.xml",
Context.MODE_PRIVATE);
2.2 Lecture
Les données contenues dans un fichier de préférences sont enregistrées sous
forme d'associations clés-valeurs. Une telle association est composée :
– D'une clé qui est une chaîne de caractères de type String.
– D'une valeur de type primitif : boolean (booléen), float (nombre à virgule flottante), int ou long (entiers) ou String (chaîne de caractères).
Pour lire les données contenues dans un fichier de préférences, on utilise l'objet
de type SharedPreferences récupéré précédemment. On invoque ensuite
certains de ses accesseurs permettant de lire individuellement une donnée selon son type.
Syntaxe
public
public
public
public
public
abstract
abstract
abstract
abstract
abstract
boolean getBoolean (String key, boolean defValue)
float getFloat (String key, float defValue)
int getInt (String key, int defValue)
long getLong (String key, long defValue)
String getString (String key, String defValue)
199
200
Android
Guide de développement d’applications pour Smartphones et Tablettes
Le premier paramètre est le nom de la clé. Le second paramètre est la valeur
par défaut à retourner si la clé n'existe pas.
Exemple
boolean modeWifi = prefs.getBoolean("modeWifi", false);
int compteur = prefs.getInt("compteur", 0);
String commentaire = prefs.getString("commentaire", "");
On peut aussi récupérer toutes les données d'un seul coup en utilisant la méthode getAll.
Syntaxe
public abstract Map<String, ?> getAll ()
Exemple
Map<String, ?> valeurs = prefs.getAll();
Boolean modeWifi = (Boolean)valeurs.get("modeWifi");
La méthode contains de l'objet SharedPreferences permet de vérifier
la présence d'une clé donnée qu'on lui spécifie en paramètre.
Syntaxe
public abstract boolean contains (String key)
Exemple
if (prefs.contains("modeWifi")) {
traitement();
}
L'écriture de données dans un fichier de préférences se fait via un objet de type
SharedPreferences.Editor. Cet objet est retourné par la méthode
edit appelée sur l'objet de type SharedPreferences récupéré précédemment.
Syntaxe
public abstract SharedPreferences.Editor edit ()
© Editions ENI - All rights reserved
2.3 Écriture
201
La persistance des données
Chapitre 7
Exemple
SharedPreferences.Editor editeur = prefs.edit();
L'objet Editor ci-dessus permet de spécifier les nouvelles données ou de modifier les données existantes en les écrasant avec les nouvelles. On invoque ses
méthodes permettant d'écrire individuellement une association clé-valeur. À
l'instar des méthodes de lecture, il existe une méthode d’écriture par type
primitif. Ces méthodes prennent en paramètres le nom de la clé ainsi que la
valeur de la donnée.
Syntaxe
public abstract SharedPreferences.Editor
boolean value)
public abstract SharedPreferences.Editor
float value)
public abstract SharedPreferences.Editor
int value)
public abstract SharedPreferences.Editor
long value)
public abstract SharedPreferences.Editor
String value)
putBoolean (String key,
putFloat (String key,
putInt (String key,
putLong (String key,
putString (String key,
Exemple
editeur.putBoolean("modeWifi", true);
editeur.putInt("compteur", 42);
editeur.putString("commentaire", "Ceci est un commentaire");
L'écriture des données ne sera effectivement réalisée dans le fichier qu'une fois
la méthode commit de l'objet Editor appelée.
Syntaxe
public abstract boolean commit ()
Exemple
editeur.commit();
Remarque
Attention à ne pas oublier d'appeler la méthode commit. Car sans cet appel,
l'objet Editor ne sert à rien ; les modifications qu'il contient n'étant pas enregistrées.
202
Android
Guide de développement d’applications pour Smartphones et Tablettes
2.4 Suppression
La suppression des données contenues dans un fichier de préférences se fait en
utilisant l'objet editeur de type SharedPreferences.Editor comme
pour l'écriture des données.
La méthode remove de l'objet Editor permet de supprimer une association
clé-valeur. On spécifie le nom de la clé en paramètre.
Syntaxe
public abstract SharedPreferences.Editor remove (String key)
Exemple
editeur.remove("modeWifi");
La méthode clear permet de supprimer toutes les données, c'est-à-dire
toutes les associations clés-valeurs.
Syntaxe
public abstract SharedPreferences.Editor clear ()
Exemple
editeur.clear();
Comme pour l'écriture, il faut appeler la méthode commit pour enregistrer les
modifications.
Il est également possible d'enchaîner les modifications puisque les méthodes
de l'objet Editor retournent cet objet.
Exemple
Remarque
Lors de l'appel à la méthode commit, la méthode clear est exécutée en
premier quelle que soit la position de son appel.
On peut donc par exemple réécrire la ligne précédente sans en modifier le
résultat.
© Editions ENI - All rights reserved
editeur.clear().putBoolean("modeWifi", modeWifi).commit();

Download Report