Objectifs de ouvrage
Le nouveau système d’exploitation de Google pour les téléphones portables et les nouvelles tablettes est là. Sa réputation est solide, il envahit le monde de la téléphonie, il est ouvert et offre des outils de développement Java au monde des programmeurs. Il ouvre les portes du développement mobile à tous les développeurs objets avec un coût minime pour la montée en compétence. Une seule question se pose : Êtes-vous prêts ?
L’objectif de ce livre est très clair : vous permettre en un temps record d’être autonome en programmation Android. Si vous êtes un programmeur Java (débutant ou confirmé), le but est que vous soyez autonomes en moins de 10 jours. C’est cet objectif qui est l’origine de ce livre, permettre aux collaborateurs de mon entreprise de monter en compétence sur cette technologie avec rapidité et efficience. Vous serez alors à même de concevoir une application, de l’implémenter, de la tester, de l’internationaliser et de la livrer à votre client.
Vous serez aussi capable de connaître et comprendre quelles sont les considérations à avoir lorsque l’on a à charge une application Android en tant que professionnel de l’informatique. Quelle est la stratégie de tests à utiliser ? Comment signer son application ? Comment la déployer ? Comment mettre en place la gestion du cycle de vie de l’application ? Comment implémenter l’intégration continue ?
Cet ouvrage axe sa réflexion sur deux choses qui sont primordiales :
- le savoir faire
- le savoir concevoir
Concernant le savoir faire, celui-ci est acquis au travers de projets Android dont le code est
- épuré de toute considération fonctionnelle,
- extrêmement précis (un projet pour une combo-box, un projet pour un web kit, un projet pour …) qui n’explique que le concept associé à l’exemple,
- très commenté et très clair.
Un paragraphe explique les points clefs de compréhension, le code termine l’explication détaillée du concept. Ce savoir-faire vous permettra de mettre en place toutes les problématiques qui se posent à vous. Mais comme tout, parfois, sur des sujets complexes qui mériteraient un ouvrage pour eux seuls, nous ne donnons que les points d’entrée car il serait trop long de tout réexpliquer, vous laissant continuer l’exploration seuls.
Concernant le savoir-concevoir, ce livre explique les points clefs de la structuration d’une application Android. Il vous présente les éléments qui forment la voute du système et vous explique comment construire une application qui respecte ces principes et en tire partie de la manière la plus efficace possible. Chacun des ces concepts est mis en évidence par un projet Android dont le code a pour unique vocation de présenter le plus clairement possible ce dit concept.
Concernant la lecture de ce livre, il m’apparaît plus raisonnable d’effectuer une première lecture rapide, sans s’appesantir sur chaque concept, de manière à posséder une vision globale sur la programmation Android. Ensuite, le lecteur se référera aux chapitres précis qui l’intéresse et dont il souhaite mettre le concept en pratique. La vision globale lui permettant d’avoir en tête l’ensemble des considérations qu’une application Android doit prendre en compte, il pourra alors acquérir son savoir faire sur des exemples précis et récupérer le code fourni pour le mettre en place. Quand sa montée en compétence sera effective, ce livre restera à ses côtés lors des développements d’applications, lui servant de référence, tant pour le code que pour les concepts associés.
Contenu
Ce livre se scinde en quatre parties distinctes.
Une première partie est destinée aux développeurs et leur permet d’effectuer rapidement des applications avec les éléments graphiques. Cette partie décrit et explique comment utiliser ces composants et structurer son application. On y trouve donc la description des composants usuels, la gestion du clavier, la gestion des menus, la manipulation des polices de caractère, le navigateur web Kit et enfin les messages surgissants. Cette partie permet d’effectuer les développements dont la plupart des développeurs ont envie et besoin : les IHMs.
Une seconde partie étant plus destinée aux développeurs / concepteurs / architectes, elle explique comment :
- Gérer les traitements associés aux activités (avec la mise en place de threads).
- Gérer le cycle de vie d’une activité.
- Utiliser le système évènementiel d’Android avec les Intentions.
- Comment gérer ses ressources (fichiers images, texte, couleurs, thèmes).
- Comment définir et utiliser une base de données.
- Comment utiliser et définir un ContentReceiver et son homologue, le ContentProvider.
- Comment utiliser et définir un service.
Cette seconde partie est orientée développement dans le milieu de l’entreprise. Elle s’intéresse à expliquer comment structurer une application Android, à respecter les contraintes d’un tel projet.
La troisième partie se focalise sur le « comment faire pour » :
- Communiquer avec internet.
- Utiliser le protocole http pour faire transiter des objets entre un serveur de servlets et votre application.
- Utiliser d’autres services et donc demander des permissions.
- Utiliser la géolocalisation et le géocodage.
- Gérer les SMS et effectuer des appels téléphoniques.
- Utiliser les fichiers multimédia.
- Utiliser et gérer le Bluetooth, les réseaux et le wifi.
- Et enfin comment dialoguer avec les capteurs.
Cette partie est donc plus orienté sur comment communiquer avec le système. Elle s’adresse à des développeurs/concepteurs/architectes qui ont besoin d’utiliser des services déjà existant de la plateforme.
La dernière partie est orientée cycle de vie d’une application Android. Un chapitre de ce livre se consacre à la stratégie de tests à mettre en place. En effet, pour les projets Android, elle est une problématique complexe au vue de la diversité des appareils et des versions des systèmes d’exploitation. Un second chapitre explique comment construire votre application et la déployer. La construction et le déploiement de l’application sont elles aussi spécifiques aux applications Android et il est nécessaire de connaître et comprendre les étapes à suivre. Le KeyStore est un point clef de compréhension de ce processus. Puis un long chapitre se consacre à la mise en place de la gestion du cycle de vie de l’application au moyen de Maven. Cette gestion apportera à votre projet structure, sérénité et maintenabilité. Mais la mise en place de Maven sur un projet Android est subtile. L’objectif de ce livre est de vous présenter l’ensemble des petits détails à mettre en place pour que vos compilations, vos tests et vos déploiements se passent en toute sérénité. Ce livre vous présentera les problèmes rencontrés et leur solutions associées pour atteindre vos objectifs sans perdre ni votre temps ni votre sang froid. Enfin, le dernier chapitre se consacre à la mise en place de l’intégration continue au moyen d’Hudson et à l’automatisation du passage de vos tests sur un ensemble d’émulateurs Android différents
Audience
Ce livre est destiné à plusieurs types de lecteurs distincts et apportera à chacun d’eux les informations qui lui permettront d’atteindre ses objectifs. Le point commun de tous ces lecteurs étant leur envie de créer des programmes Android, que ce soit de manière professionnelle ou amateur, que ce soit en tant que simple développeur ou en tant qu’architecte.
Tout d’abord, le développeur amateur trouvera son bonheur au travers d’exemples et d’explications simples qui lui permettront de mettre en place rapidement ses premières applications. La première partie de ce livre explique comment mettre en place des écrans pour Android. La plupart des développeurs amateurs auront à cœur d’approfondir cette partie et de devenir des programmeurs graphiques efficients. Ils pourront alors, au travers d’exemple de code, greffer à leurs IHMs des composants spécifiques et ainsi enrichir leurs applications rapidement et à moindre effort. Ces composants sont :
- Internet
- Utilisation du bus HTTP
- Utilisation de MapView
- Utilisation de GeoCoder
- Effectuer des appels téléphoniques
- Envoyer Recevoir des SMS
- Lire un fichier Audio
- Lire/Enregistrer une Vidéo, une Photo
- Utiliser le Bluetooth
- Gérer les connections Réseau (GPRS, 3G, wifi)
- Dialoguer avec les capteurs: Accéléromètre, Boussole, Champ magnétique, température,…
Le second type de lecteur est le développeur objet qui au sein d’un projet d’entreprise aura besoin de rapidement comprendre l’ensemble de la structure d’une application Android, de construire des IHMs, des services, d’utiliser les bases de données et d’en implémenter, de mettre en place des bus de communication http, de gérer les ressources et leur internationalisation,… Il aura une vision claire et concise de l’ensemble du système et pourra rapidement mettre en place chacun des composants qui lui sont demandés dans le respect des règles de codage Android et surtout de sa philosophie. Cet ouvrage permet d’avoir l’ensemble des réponses aux préoccupations liées aux applications d’entreprise :
- La gestion du clavier
- La gestion des polices de caractère
- La gestion des threads
- La gestion des évènements du cycle de vie
- La gestion des intentions (Intents) et des filtres d’intentions
- La gestion des permissions
- La gestion des ressources:
- Fichiers de ressources (l’internationalisation et l’arbre de devices), les styles, les thèmes,…
- Fichiers externes et fichier internes
- Les préférences
- La gestion de base de données SQLite
- Les tests et l’industrialisation du développement
Le troisième type de lecteur est l’architecte, le concepteur ou l’avant vente. Celui-ci aura une vision globale du système et saura agencer les composants entre eux. Au travers de l’ouvrage, il se construira une vision de haut niveau du système qui lui permettra de définir l’architecture de nouvelles applications Android, de connaitre l’ensemble des services disponibles de la plateforme et d’associer un chiffrage à ses œuvres.
Enfin, le dernier type de lecteur est celui qui a à charge tout ou partie de la gestion d’un projet Android (chef de projet, responsable technique, architecte, développeur expérimenté). Un objectif de cet ouvrage étant la mise en place de l’environnement de développement, au sens large, il est important que ceux qui en ont la charge prennent connaissance des milles et unes embuches qu’ils rencontreront. Arriver à l’automatisation des tests et des builds sur un serveur d’intégration continue pour vos projets Android est un parcours semé d’obstacles pour lequel il vaut mieux avoir un guide. Ce livre sera votre guide le plus complet et le plus détaillé.
Par contre quelque soit la catégorie de lecteur dans laquelle vous vous placez, il est préférable que vous ayez un minimum de connaissance sur les deux sujets suivants :
- Programmation objet, la connaissance de Java étant un plus.
- Utilisation d’Eclipse (installation, mise en place d’un espace de travail,…).
Si vous n’avez aucune connaissance sur ces deux sujets et que vous êtes vraiment motivés par la programmation Android, ce livre est aussi pour vous. Vous pourrez commencer à montée en compétence sur ces sujets, mais cela vous demandera plus de travail et d’effort. Par contre quel plaisir cela sera de voir votre première application sur l’AndroidStore ou tout simplement sur votre téléphone portable.
Sommaire
Android a quick course ............................................................................................................................. 6
1 Introduction ................................................................................................................................................ 9
1.1 Audience de ce livre ............................................................................................................................ 10
1.2 Contenu de ce livre ............................................................................................................................. 11
1.3 Structure de ce livre ............................................................................................................................. 13
1.4 Convention ............................................................................................................................................ 13
1.5 Votre espace de travail ....................................................................................................................... 14
1.6 Codes sources et exemples. ............................................................................................................ 14
Graphic Users Interfaces ........................................................................................................................ 15
2 Notions fondamentales ......................................................................................................................... 15
2.1 Une application Android...................................................................................................................... 15
2.2 La structure d’un projet ....................................................................................................................... 16
3 Les IHMs des Activités ........................................................................................................................... 17
3.1 Utilisation des layouts XML ................................................................................................................ 17
3.2 Les conteneurs .................................................................................................................................... 18
3.3 Les widgets élémentaires ................................................................................................................. 19
3.4 Les widgets de sélections ................................................................................................................. 23
3.5 Les conteneurs et widgets évolués ................................................................................................. 27
3.6 Méthodes de saisie : Clavier physique ou logiciel ....................................................................... 37
3.7 Les menus ........................................................................................................................................... 39
3.8 Polices de caractère ........................................................................................................................... 45
3.9 Intégrer le navigateur WebKit à une activité : le widget WebView .............................................. 46
3.10 Messages surgissants : Toast et AlertDialog ............................................................................. 47
4 Le fichier manifest.xml et le fichier des layouts ................................................................................ 48
4.1 Le fichier des layouts .......................................................................................................................... 48
Le coeur du système ................................................................................................................................ 49
5 Gérer les activités .................................................................................................................................... 49
5.1 Les Threads .......................................................................................................................................... 49
5.2 Gestion des évènements du cycle de vie d’une activité ............................................................... 55
5.3 Filtres d’intentions ................................................................................................................................ 58
5.4 La rotation .............................................................................................................................................. 70
6 Les ressources ........................................................................................................................................ 70
6.1 Fichiers de ressources ....................................................................................................................... 70
6.2 Gestion des préférences .................................................................................................................... 81
6.3 Bases de données locales ................................................................................................................ 84
6.4 Les fichiers ............................................................................................................................................ 99
7 Mon application est un ContentProvider (fournisseur de contenu) ............................................. 104
7.1 Utilisation d’un ContentProvider ..................................................................................................... 104
7.2 Définition d’un ContentProvider ...................................................................................................... 110
8 Mon application est un Service ........................................................................................................... 120
8.1 Utilisation d’un service ...................................................................................................................... 121
8.2 Création d’un service ......................................................................................................................... 123
9 Le fichier manifest.xml .......................................................................................................................... 125
Communiquer avec le système ............................................................................................................ 127
10 Communiquer avec l’extérieur de l’activité ..................................................................................... 127
10.1 Internet ............................................................................................................................................... 127
10.2 Les permissions ............................................................................................................................. 137
10.3 La géo-localisation ......................................................................................................................... 139
10.4 MapView et MapActivity ................................................................................................................... 143
10.5 Gestion des appels téléphoniques et des SMS........................................................................ 148
10.6 Les fichiers Multimédia et l’appareil photo................................................................................. 155
10.7 Gérer le Bluetooth, les réseaux et le wifi .................................................................................... 159
10.8 Dialoguer avec les capteurs ......................................................................................................... 180
Cycle de vie d’un projet Android .......................................................................................................... 187
11 Installer l’espace de travail .............................................................................................................. 187
11.1 Téléchargements ........................................................................................................................... 187
11.2 Mise en place d’Eclipse ................................................................................................................ 188
12 Tester votre application .................................................................................................................... 190
12.1 Tester les appareils cibles de votre application ...................................................................... 191
12.2 Mise en place du projet de test ................................................................................................... 192
12.3 Tester une activité .......................................................................................................................... 192
12.4 Tester une ContentProvider ......................................................................................................... 197
12.5 Tester un service ........................................................................................................................... 201
12.6 Monkey et MonkeyRunner ............................................................................................................ 203
12.7 Maven et Hudson pour automatiser les tests ......................................................................... 204
13 Ajouter des Jars à votre application .............................................................................................. 204
14 Construire et déployer votre application ....................................................................................... 204
14.1 Signer son application ................................................................................................................. 205
14.2 Déployer son application ............................................................................................................. 206
14.3 Retrouver sa clef pour MapView ................................................................................................. 207
15 Maven et Intégration continue ......................................................................................................... 208
15.1 Maven ............................................................................................................................................... 208
15.2 Synthèse Android-Maven : le Pom Android ultime .................................................................. 236
15.3 Hudson ou l’automatisation des tests ...................................................................................... 250
Table des matières exhaustive ......................................................................................................... 264
Index ........................................................................................................................................................ 276
Bibliographie........................................................................................................................................... 277
16 Livres .................................................................................................................................................. 277
17 Référence internet: .......................................................................................................................... 277
Remarque
Cet ouvrage réunit, au sein d'un même document, les livres "Android, A Quick Course" et "Android, An Enterprise Edition Vision" permettant au lecteur d'avoir dans un même document la totalité des préoccupations liées à la mise en place de projets Android, de la montée en compétence en tant que développeur à la gestion du cycle de vie du projet.
