l art du developpement android

Lart du dveloppement

Android

Mark Murphycustomer 27921 at Fri Mar 11 19:19:45 +0100 2011 Proprit de Albiri Sigue

L E

P R O G R A M M E U R

Lart du dveloppement AndroidMark L. Murphy

Traduit par ric Jacoboni, avec la contribution d'Arnaud Farine

Pearson Education France a apport le plus grand soin la ralisation de ce livre an de vous fournir une information complte et able. Cependant, Pearson Education France nassume de responsabilits, ni pour son utilisation, ni pour les contrefaons de brevets ou atteintes aux droits de tierces personnes qui pourraient rsulter de cette utilisation. Les exemples ou les programmes prsents dans cet ouvrage sont fournis pour illustrer les descriptions thoriques. Ils ne sont en aucun cas destins une utilisation commerciale ou professionnelle. Pearson Education France ne pourra en aucun cas tre tenu pour responsable des prjudices ou dommages de quelque nature que ce soit pouvant rsulter de lutilisation de ces exemples ou programmes. Tous les noms de produits ou marques cits dans ce livre sont des marques dposes par leurs propritaires respectifs. Le logo reproduit en page de couverture et sur les ouvertures de chapitres a t cr par Irina Blok pour le compte de Google sous la licence Creative Commons 3.0 Attribution License http://creativecommons.org/licenses/by/3.0/deed.fr.

Publi par Pearson Education France 47 bis, rue des Vinaigriers 75010 PARIS Tl. : 01 72 74 90 00 www.pearson.fr Mise en pages : TyPAO ISBN : 978-2-7440-4094-8 Copyright 2009 Pearson Education France Tous droits rservs

Titre original : Beginning Android

Traduit par ric Jacoboni, avec la contribution d'Arnaud Farine

ISBN original : 978-1-4302-2419-8 Copyright 2009 by Mark L. Murphy All rights reserved dition originale publie par Apress, 2855 Telegraph Avenue, Suite 600, Berkeley, CA 94705 USA

Aucune reprsentation ou reproduction, mme partielle, autre que celles prvues larticle L. 122-5 2 et 3 a) du code de la proprit intellectuelle ne peut tre faite sans lautorisation expresse de Pearson Education France ou, le cas chant, sans le respect des modalits prvues larticle L. 122-10 dudit code. No part of this book shall be reproduced, stored in a retrieval system, or transmitted by any means, electronic, mechanical, photocopying, recording, or otherwise, without written permission from the publisher.

Sommaire

propos de lauteur .............................. Remerciements ....................................... Prface ldition franaise .................. Introduction ............................................ Partie I Concepts de base ................... 1. Tour dhorizon ................................... 2. Structure dun projet ......................... 3. Contenu du manifeste ........................ Partie II Les activits .......................... 4. Cration dun squelette dapplication 5. Utilisation des layouts XML ............. 6. Utilisation des widgets de base ......... 7. Conteneurs ......................................... 8. Widgets de slection ........................... 9. Samuser avec les listes ...................... 10. Utiliser de jolis widgets et de beaux conteneurs .................... 11. Utilisation des menus ....................... 12. Polices de caractres ........................ 13. Intgrer le navigateur de WebKit ...

IX XI XIII 1 3 5 9 13 19 21 29 35 45 65 83 107 129 141 147

14. Afchage de messages surgissant ... 15. Utilisation des threads ..................... 16. Gestion des vnements du cycle de vie dune activit ........................ Partie III Stockage de donnes, services rseaux et API .......................... 17. Utilisation des prfrences .............. 18. Accs aux chiers ............................ 19. Utilisation des ressources ................ 20. Accs et gestion des bases de donnes locales ........................... 21. Tirer le meilleur parti des bibliothques Java .................... 22. Communiquer via Internet ............. Partie IV - Intentions (Intents) ............. 23. Cration de ltres dintentions ....... 24. Lancement dactivits et de sous-activits ........................... 25. Trouver les actions possibles grce lintrospection ............................... 26. Gestion de la rotation ......................

155 161 173

177 179 191 199 217 227 235 241 243 249 259 265

IV

Lart du dveloppement Android

Partie V Fournisseurs de contenus et services .......................... 27. Utilisation dun fournisseur de contenu (content provider) ......... 28. Construction dun fournisseur de contenu ........................................ 29. Demander et exiger des permissions 30. Cration dun service ...................... 31. Appel dun service ........................... 32. Alerter les utilisateurs avec des notications ......................

277 279 287

Partie VI Autres fonctionnalits dAndroid ............................................... 33. Accs aux services de localisation ... 34. Cartographie avec MapView et MapActivity ................................. 35. Gestion des appels tlphoniques ...

319 321 327 337 341 351 363 367

297 303 309 313 36. Recherches avec SearchManager ... 37. Outils de dveloppement ................. 38. Pour aller plus loin .......................... Index .......................................................

Table des matires

propos de lauteur .............................. Remerciements ....................................... Prface ldition franaise .................. Introduction ............................................ Bienvenue ! ......................................... Prrequis ............................................. ditions de ce livre ............................. Termes dutilisation du code source ... Partie I Concepts de base ................... 1. Tour dhorizon ................................... Contenu dun programme Android ..... Fonctionnalits votre disposition ..... 2. Structure dun projet ......................... Contenu de la racine .......................... la sueur de votre front ..................... La suite de lhistoire ........................... Le fruit de votre travail ....................... 3. Contenu du manifeste ........................ Au dbut, il y avait la racine ............... Permissions, instrumentations et applications ..................................... Que fait votre application ? ................. Faire le minimum ................................ Version = contrle ...............................

XI XIII XV 1 1 1 2 2 3 5 6 8 9 9 10 11 11 13 14 14 15 16 17

Partie II Les activits ......................... 4. Cration dun squelette dapplication Terminaux virtuels et cibles ............... Commencer par le dbut ..................... Lactivit ............................................. Dissection de lactivit ....................... Compiler et lancer lactivit ............... 5. Utilisation des layouts XML ............. Quest-ce quun positionnement XML ? Pourquoi utiliser des layouts XML ? .. Contenu dun chier layout ................ Identiants des widgets ...................... Utilisation des widgets dans le code Java ................................ Fin de lhistoire .................................. 6. Utilisation des widgets de base ......... Labels ................................................. Boutons ............................................... Images ................................................ Champs de saisie ................................ Cases cocher .................................... Boutons radio ..................................... Rsum ...............................................

19 21 21 23 24 25 27 29 29 30 31 32 32 33 35 35 36 37 38 40 42 43

VI


7. Conteneurs ......................................... Penser de faon linaire ..................... Tout est relatif .................................... Tabula Rasa ........................................ ScrollView .......................................... 8. Widgets de slection .......................... Sadapter aux circonstances ............... Listes des bons et des mchants ......... Contrle du Spinner ......................... Mettez vos lions en cage .................... Champs : conomisez 35 % de la frappe ! Galeries .............................................. 9. Samuser avec les listes ..................... Premires tapes ................................. Prsentation dynamique ..................... Mieux, plus robuste et plus rapide ..... Crer une liste... ................................. Et la vrier deux fois ................... Adapter dautres adaptateurs .............. 10. Utiliser de jolis widgets et de beaux conteneurs .................... Choisir ................................................ Le temps scoule comme un euve .. Mesurer la progression ....................... Utilisation donglets ........................... Tout faire basculer .............................. Fouiller dans les tiroirs ....................... Autres conteneurs intressants ........... 11. Utilisation des menus ...................... Variantes de menus ............................ Les menus doptions .......................... Menus contextuels ............................. Illustration rapide ............................... Encore de lination ........................... 12. Polices de caractres ....................... Sachez apprcier ce que vous avez .... Le problme des glyphes ................... 13. Intgrer le navigateur de WebKit ......................................... Un navigateur, et en vitesse ! .............

45 46 52 57 61 65 66 67 71 73 77 81 83 83 85 88 94 99 105 107 107 111 112 113 120 125 128 129 130 130 131 132 137 141 141 144 147 147

Chargement immdiat ......................... Navigation au long cours .................... Amuser le client .................................. Rglages, prfrences et options ........ 14. Afchage de messages surgissant ... Les toasts ............................................ Les alertes ........................................... Mise en uvre .................................... 15. Utilisation des threads ..................... Les handlers ........................................ Excution sur place ............................. O est pass le thread de mon interface utilisateur ? ......................................... Dsynchronisation .............................. viter les piges .................................. 16. Gestion des vnements du cycle de vie dune activit .......................... Lactivit de Schroedinger .................. Vie et mort dune activit ................... Partie III Stockage de donnes, services rseaux et API .......................... 17. Utilisation des prfrences ................ Obtenir ce que vous voulez ................. Dnir vos prfrences ....................... Un mot sur le framework .................... Laisser les utilisateurs choisir ............. Ajouter un peu de structure ................ Botes de dialogue .............................. 18. Accs aux chiers ............................. Allons-y ! ............................................ Lire et crire ....................................... 19. Utilisation des ressources ................ Les diffrents types de ressources ...... Thorie des chanes ............................ Vous voulez gagner une image ? ........ Les ressources XML ........................... Valeurs diverses .................................. Grer la diffrence ..............................

150 151 151 153 155 156 156 157 161 162 165 165 166 172 173 174 174

177 179 179 180 180 181 185 187 191 191 195 199 199 200 205 207 210 212

Table des matires

VII

20. Accs et gestion des bases de donnes locales ............................. Prsentation rapide de SQLite ............ Commencer par le dbut ..................... Mettre la table ..................................... Ajouter des donnes ............................ Le retour de vos requtes .................... Des donnes, des donnes, encore des donnes ............................. 21. Tirer le meilleur parti des bibliothques Java ...................... Limites extrieures .............................. Ant et JAR .......................................... Suivre le script .................................... Tout fonctionne... enn, presque ........ Relecture des scripts ........................... 22. Communiquer via Internet ............. REST et relaxation .............................. Partie IV Intentions (Intents) ............ 23. Cration de ltres dintentions ....... Quelle est votre intention ? ................. Dclarer vos intentions ....................... Rcepteurs dintention ........................ Attention la pause ............................ 24. Lancement dactivits et de sous-activits ............................. Activits paires et sous-activits ......... Dmarrage .......................................... Navigation avec onglets ...................... 25. Trouver les actions possibles grce lintrospection ................................ Faites votre choix ................................ Prfrez-vous le menu ? ...................... Demander lentourage ...................... 26. Gestion de la rotation ...................... Philosophie de la destruction .............. Tout est pareil, juste diffrent ............. Il ny a pas de petites conomies ! ......

217 218 219 219 220 221 224 227 228 228 229 233 233 235 236 241 243 244 245 247 247 249 250 250 255 259 260 263 264 265 265 266 270

Rotation maison .................................. Forcer le destin ................................... Tout comprendre ................................. Partie V Fournisseurs de contenus et services ................................................

272 274 276

277

27. Utilisation dun fournisseur de contenu (content provider) .............................. 279 Composantes dune Uri .................... Obtention dun descripteur ................. Cration des requtes ......................... Sadapter aux circonstances ............... Gestion manuelle des curseurs ........... Insertions et suppressions ................... Attention aux BLOB ! ........................ 28. Construction dun fournisseur de contenu ..................... Dabord, une petite dissection ............ Puis un peu de saisie ........................... tape n 1 : crer une classe Provider tape n 2 : fournir une Uri .............. tape n 3 : dclarer les proprits ..... tape n 4 : modier le manifeste ...... Avertissements en cas de modications 29. Demander et exiger des permissions Mre, puis-je ? .................................... Halte ! Qui va l ? ............................... Vos papiers, sil vous plat ! ............... 30. Cration dun service ...................... Service avec classe ............................. Il ne peut en rester quun ! ................. Destine du manifeste ........................ Sauter la clture .................................. 31. Appel dun service ........................... Transmission manuelle ....................... Capture de lintention ......................... 32. Alerter les utilisateurs avec des notications ........................ Types davertissements ....................... Les avertissements en action .............. 280 280 281 282 283 284 285 287 288 288 289 294 295 295 296 297 298 299 301 303 304 305 306 306 309 310 311 313 313 315

VIII


Partie VI Autres fonctionnalits dAndroid ............................................... 33. Accs aux services de localisation ................................... Fournisseurs de localisation : ils savent o vous vous cachez ........... Se trouver soi-mme .......................... Se dplacer ......................................... Est-on dj arriv ? Est-on dj arriv ? Est-on dj arriv ? ............................ Tester... Tester... .................................. 34. Cartographie avec MapView et MapActivity ................................. Termes dutilisation ........................... Empilements ...................................... Les composants essentiels ................. Testez votre contrle .......................... Terrain accident ................................ Couches sur couches ..........................

319 321 322 322 324 325 326 327 328 328 328 330 331 332

Moi et MyLocationOverlay .............. La cl de tout ...................................... 35. Gestion des appels tlphoniques ... Le Manager ......................................... Appeler ............................................... 36. Recherches avec SearchManager ... La chasse est ouverte .......................... Recherches personnelles ..................... Effectuer une recherche ...................... 37. Outils de dveloppement .................

334 335 337 338 338 341 342 343 349 351

Gestion hirarchique ........................... 351 DDMS (Dalvik Debug Monitor Service) 356 Gestion des cartes amovibles .............. 362 38. Pour aller plus loin .......................... Questions avec, parfois, des rponses . Aller la source .................................. Lire les journaux ................................. Index ....................................................... 363 363 364 365 367

propos de lauteur

Mark Murphy est le fondateur de CommonsWare et lauteur de The Busy Coders Guide to Android Development. Son exprience professionnelle va du conseil pour les dveloppements open-source et collaboratifs de trs grosses socits au dveloppement dapplications sur peu prs tout ce qui est plus petit quun mainframe. Il programme depuis plus de vingt-cinq ans et a travaill sur des plates-formes allant du TRS-80 aux derniers modles de terminaux mobiles. En tant quorateur averti, Mark intervient galement sur un grand nombre de sujets dans de nombreuses confrences et sessions de formation internationales. Par ailleurs, Mark est le rdacteur des rubriques "Building Droids" dAndroidGuys et "Android Angle" de NetworkWorld. En dehors de CommonsWare, Mark sintresse beaucoup au rle que joue Internet dans limplication des citoyens dans la politique. ce titre, il publie des articles dans la collection Rebooting America et son blog personnel contient de nombreux articles sur la "dmocratie cooprative".

Remerciements

Je voudrais remercier lquipe dAndroid ; non seulement pour avoir cr un bon produit, mais galement pour laide inestimable quelle fournit dans les groupes Google consacrs ce systme. Merci notamment Romain Guy, Justin Mattson, Dianne Hackborn, Jean-Baptiste Queru, Jeff Sharkey et Xavier Ducrohet. Les icnes utilises dans les exemples de ce livre proviennent du jeu dicnes Nuvola 1.

1. http://www.icon-king.com/?p=15.

Prface ldition franaise

Novembre 2007, Google, le gant amricain de l'Internet annonce qu'il vient de crer un nouveau systme d'exploitation pour appareil mobile. Nomm Android, ce systme est totalement gratuit et open-source, pour les dveloppeurs d'applications, mais galement pour les constructeurs d'appareils mobiles (tlphones, smartphones, MID [Multimedia Interface Device], GPS...). Un an auparavant, Apple avait lanc un pav dans la mare en s'introduisant avec brio dans le march des systmes d'exploitation mobiles, dtenus plus de 50 % par Symbian, grce l'apport de nombreuses fonctionnalits multimdia et de localisation dans une interface utilisateur trs intuitive. Android apporte galement son lot de nouvelles fonctionnalits, mais avec des atouts supplmentaires : gratuit, code ouvert, langage de programmation approuv et connu de millions de dveloppeurs travers le monde. Autour d'une alliance d'une quarantaine de constructeurs, diteurs logiciels et socits spcialises dans les applications mobiles (Open Handset Alliance), Google a de quoi inquiter les systmes d'exploitation propritaires tels que Windows, Palm, Samsung, RIM, Symbian. Certains dveloppeurs ont immdiatement cru Android, ds son annonce par Google, et des blogs, des sites Internet et des tutoriaux ont rapidement vu le jour de par le monde. Ce phnomne a t encourag par un concours de dveloppement l'initiative de Google avec plus de 1 million de dollars de lots. Le but tait bien entendu de faire parler de son nouveau systme : pari russi ! En 4 mois, alors que la documentation de la plateforme tait quasiment inexistante, les juges du concours ont reu pas moins de 1 700 applications ! Ceux qui ont cru en Android ne se sont pas tromps sur son potentiel ni sur celui des nouveaux services mobiles mergents ! Un an plus tard, tous les grands constructeurs de tlphonie mobile annonaient un ou plusieurs smartphones quips de cette plateforme,

XVI


sans compter sur l'arrive de nouveaux constructeurs. Aujourd'hui, le portail de vente de Google ddi aux applications Android (Android Market) dispose d'environ 7 000 applications (alors mme qu'il n'est toujours pas disponible sur tous les continents). Enn, plus d'une vingtaine d'appareils quips d'Android sont attendus avant la n de l'anne 2009 (Sony, Samsung, Motorola, HTC...), et davantage encore en 2010. Mark Murphy, auteur du prsent ouvrage, est l'un de ces dveloppeurs qui a cru Android ds ses premires heures. Prsent sur les groupes de discussions Google, il apportait son aide aux programmeurs en qute d'informations. C'est d'ailleurs dans ce contexte que j'ai fait sa connaissance. Convaincu du potentiel de la plateforme, il s'est attel la rdaction d'un livre de rfrence sur le dveloppement Android. Le faisant voluer au fur et mesure des nouvelles versions (4 en 2008), Mark a rellement construit un ouvrage de qualit. Toutes les bases de la programmation sous Android y sont dcrites, mais pas uniquement. Cet ouvrage regorge d'astuces et de conseils qui vous permettront de pouvoir raliser vos premires applications Android mais aussi, pour des dveloppements avancs, de trouver facilement le bout de code qui vous intresse. Un ouvrage ddi aux dbutants comme aux dveloppeurs plus avancs. Arnaud Farine eXpertise @ndroid http://www.expertiseandroid.com/

Introduction

Bienvenue !Merci de votre intrt pour le dveloppement dapplications Android ! De plus en plus de personnes accdent dsormais aux services Internet via des moyens "non traditionnels" comme les terminaux mobiles, et ce nombre ne peut que crotre. Bien quAndroid soit rcent ses premiers terminaux sont apparus la n de 2008 , il ne fait aucun doute quil se rpandra rapidement grce linuence et limportance de lOpen Handset Alliance. Merci surtout de votre intrt pour ce livre ! Jespre sincrement que vous le trouverez utile, voire divertissant par moments.

PrrequisPour programmer des applications Android, vous devez au moins connatre les bases de Java. En effet, la programmation Android utilise la syntaxe de ce langage, plus une bibliothque de classes sapparentant un sous-ensemble de la bibliothque de Java SE (avec des extensions spciques). Si vous navez jamais programm en Java, initiez-vous ce langage avant de vous plonger dans la programmation Android. Ce livre nexplique pas comment tlcharger ou installer les outils de dveloppement Android, que ce soit le plugin Eclipse ou les outils ddis. Vous trouverez toutes ces informations sur le site web dAndroid1. Tout ce qui est expliqu dans cet ouvrage ne tient pas compte de lenvironnement que vous utilisez et fonctionnera dans tous les cas. Nous vous conseillons de tlcharger, dinstaller et de tester ces outils de dveloppement avant dessayer les exemples de ce livre.1. http://code.google.com/android/index.html.

2


ditions de ce livreCet ouvrage est le fruit dune collaboration entre Apress et CommonsWare. La version que vous tes en train de lire est la traduction de ldition dApress, qui est disponible sous forme imprime ou numrique. De son ct, CommonsWare met continuellement jour le contenu original et le met disposition des membres de son programme Warescription sous le titre The Busy Coders Guide to Android Development. La page http://commonsware.com/apress contient une FAQ concernant ce partenariat avec Apress.

Termes dutilisation du code sourceLe code source des exemples de ce livre est disponible partir du site web de Pearson (www.pearson.fr), sur la page consacre cet ouvrage. Tous les projets Android sont placs sous les termes de la licence Apache 2.01, que nous vous invitons lire avant de rutiliser ces codes.

1. http://www.apache.org/licenses/LICENSE-2.0.html.

Partie

I

Concepts de baseCHAPITRE 1. CHAPITRE 2. CHAPITRE 3. Tour dhorizon Structure dun projet Contenu du manifeste

1Tour dhorizonLes terminaux Android seront essentiellement des tlphones mobiles, bien quil soit question dutiliser cette technologie sur dautres plates-formes (comme les tablettes PC). Pour les dveloppeurs, ceci a des avantages et des inconvnients. Du ct des avantages, les tlphones Android qui arrivent sur le march sont assez jolis. Si loffre de services Internet pour les mobiles remonte au milieu des annes 1990, avec HDML (Handheld Device Markup Language), ce nest que depuis ces dernires annes que lon dispose de tlphones capables dexploiter pleinement laccs Internet. Grce aux SMS et des produits comme liPhone dApple, les tlphones qui peuvent servir de terminaux Internet deviennent de plus en plus courants. Travailler sur des applications Android permet donc dacqurir une exprience non ngligeable dans une technologie moderne (Android) et dans un segment de march qui crot rapidement (celui des terminaux mobiles pour Internet). Le problme intervient lorsquil sagit de programmer. Quiconque a dj crit des programmes pour des PDA (Personal Digital Assistant) ou des tlphones portables sest heurt aux inconvnients de leur miniaturisation :

Les crans sont sous-dimensionns. Les claviers, quand ils existent, sont minuscules. Les dispositifs de pointage, quand il y en a, sont peu pratiques (qui na pas dj perdu son stylet ?) ou imprcis (les gros doigts se marient mal avec les crans tactiles).

6


La vitesse du processeur et la taille de la mmoire sont ridicules par rapport celles des machines de bureau et des serveurs auxquels nous sommes habitus. On peut utiliser le langage de programmation et le framework de dveloppement que lon souhaite, condition que ce soit celui qua choisi le constructeur du terminal. Etc.

En outre, les applications qui sexcutent sur un tlphone portable doivent grer le fait quil sagit justement dun tlphone. Les utilisateurs sont gnralement assez irrits lorsque leur mobile ne fonctionne pas, et cest la raison pour laquelle la campagne publicitaire "Can you hear me now?" de Verizon a si bien fonctionn ces dernires annes. De mme, ces mmes personnes seront trs mcontentes si votre programme perturbe leur tlphone, pour les raisons suivantes :

Il occupe tellement le processeur quelles ne peuvent plus recevoir dappels. Il ne sintgre pas correctement au systme dexploitation de leur mobile, de sorte que lapplication ne passe pas en arrire-plan lorsquelles reoivent ou doivent effectuer un appel. Il provoque un plantage de leur tlphone cause dune fuite de mmoire.

Le dveloppement de programmes pour un tlphone portable est donc diffrent de lcriture dapplications pour des machines de bureau, du dveloppement de sites web ou de la cration de programmes serveurs. Vous nirez par utiliser des outils et des frameworks diffrents et vos programmes auront des limites auxquelles vous ntes pas habitu. Android essaie de vous faciliter les choses :

Il fournit un langage de programmation connu (Java), avec des bibliothques relativement classiques (certaines API dApache, par exemple), ainsi quun support pour les outils auxquels vous tes peut-tre habitu (Eclipse, notamment). Il vous offre un framework sufsamment rigide et tanche pour que vos programmes sexcutent "correctement" sur le tlphone, sans interfrer avec les autres applications ou le systme dexploitation lui-mme.

Comme vous vous en doutez srement, lessentiel de ce livre sintresse ce framework et la faon dcrire des programmes qui fonctionnent dans son cadre et tirent parti de ses possibilits.

Contenu dun programme AndroidLe dveloppeur dune application classique est "le seul matre bord". Il peut ouvrir la fentre principale de son programme, ses fentres lles les botes de dialogue, par exemple comme il le souhaite. De son point de vue, il est seul au monde ; il tire parti des fonctionnalits du systme dexploitation mais ne soccupe pas des autres programmes

Chapitre 1

Tour dhorizon

7

susceptibles de sexcuter en mme temps que son programme. Sil doit interagir avec dautres applications, il passe gnralement par une API, comme JDBC (ou les frameworks qui reposent sur lui) pour communiquer avec MySQL ou un autre SGBDR. Android utilise les mmes concepts, mais proposs de faon diffrente, avec une structure permettant de mieux protger le fonctionnement des tlphones.

Activity (Activit)La brique de base de linterface utilisateur sappelle activity (activit). Vous pouvez la considrer comme lquivalent Android de la fentre ou de la bote de dialogue dune application classique. Bien que des activits puissent ne pas avoir dinterface utilisateur, un code "invisible" sera dlivr le plus souvent sous la forme de fournisseurs de contenus (content provider) ou de services.

Content providers (fournisseurs de contenus)Les fournisseurs de contenus offrent un niveau dabstraction pour toutes les donnes stockes sur le terminal et accessibles aux diffrentes applications. Le modle de dveloppement Android encourage la mise disposition de ses propres donnes aux autres programmes construire un content provider permet dobtenir ce rsultat tout en gardant un contrle total sur la faon dont on accdera aux donnes.

Intents (intentions)Les intentions sont des messages systme. Elles sont mises par le terminal pour prvenir les applications de la survenue de diffrents vnements, que ce soit une modication matrielle (comme linsertion dune carte SD) ou larrive de donnes (telle la rception dun SMS), en passant par les vnements des applications elles-mmes (votre activit a t lance partir du menu principal du terminal, par exemple). Vous pouvez non seulement rpondre aux intentions, mais galement crer les vtres an de lancer dautres activits ou pour vous prvenir quune situation particulire a lieu (vous pouvez, par exemple, mettre lintention X lorsque lutilisateur est moins de 100 mtres dun emplacement Y).

ServicesLes activits, les fournisseurs de contenus et les rcepteurs dintentions ont une dure de vie limite et peuvent tre teints tout moment. Les services sont en revanche conus pour durer et, si ncessaire, indpendamment de toute activit. Vous pouvez, par exemple, utiliser un service pour vrier les mises jour dun ux RSS ou pour jouer de la musique, mme si lactivit de contrle nest plus en cours dexcution.

8


Fonctionnalits votre dispositionAndroid fournit un certain nombre de fonctionnalits pour vous aider dvelopper des applications.

StockageVous pouvez empaqueter (packager) des chiers de donnes dans une application, pour y stocker ce qui ne changera jamais les icnes ou les chiers daide, par exemple. Vous pouvez galement rserver un petit emplacement sur le terminal lui-mme, pour y stocker une base de donnes ou des chiers contenant des informations ncessaires votre application et saisies par lutilisateur ou rcupres partir dune autre source. Si lutilisateur fournit un espace de stockage comme une carte SD, celui-ci peut galement tre lu et crit en fonction des besoins.

RseauLes terminaux Android sont gnralement conus pour tre utiliss avec Internet, via un support de communication quelconque. Vous pouvez tirer parti de cet accs Internet nimporte quel niveau, des sockets brutes de Java un widget de navigateur web intgr que vous pouvez intgrer dans votre application.

MultimdiaLes terminaux Android permettent denregistrer et de jouer de la musique et de la vido. Bien que les caractristiques spciques varient en fonction des modles, vous pouvez connatre celles qui sont disponibles et tirer parti des fonctionnalits multimdias offertes, que ce soit pour couter de la musique, prendre des photos ou enregistrer des mmos vocaux.

GPSLes fournisseurs de positionnement, comme GPS, permettent dindiquer aux applications o se trouve le terminal. Il vous est alors possible dafcher des cartes ou dutiliser ces donnes gographiques pour retrouver la trace du terminal sil a t vol, par exemple.

Services tlphoniquesvidemment, les terminaux Android sont gnralement des tlphones, ce qui permet vos programmes de passer des appels, denvoyer et de recevoir des SMS et de raliser tout ce que vous tes en droit dattendre dune technologie tlphonique moderne.

2Structure dun projetLe systme de construction dun programme Android est organis sous la forme dune arborescence de rpertoires spcique un projet, exactement comme nimporte quel projet Java. Les dtails, cependant, sont spciques Android et sa prparation de lapplication qui sexcutera sur le terminal ou lmulateur. Voici un rapide tour dhorizon de la structure dun projet, qui vous aidera mieux comprendre les exemples de code utiliss dans ce livre et que vous pouvez tlcharger sur le site web de Pearson, www.pearson.fr, sur la page consacre cet ouvrage.

Contenu de la racineLa cration dun projet Android (avec la commande android create project ou via un environnement de programmation adapt Android) place plusieurs lments dans le rpertoire racine du projet :

AndroidManifest.xml est un chier XML qui dcrit lapplication construire et les composants activits, services, etc. fournis par celle-ci.

10


build.xml est un script Ant1 permettant de compiler lapplication et de linstaller sur le terminal (ce chier nest pas prsent avec un environnement de programmation adapt, tel Eclipse). default.properties et local.properties sont des chiers de proprits utiliss par le script prcdent. bin/ contient lapplication compile. gen/ contient le code source produit par les outils de compilation dAndroid. libs/ contient les chiers JAR extrieurs ncessaires lapplication. src/ contient le code source Java de lapplication. res/ contient les ressources icnes, descriptions des lments de linterface graphique (layouts), etc. empaquetes avec le code Java compil. tests/ contient un projet Android entirement distinct, utilis pour tester celui que vous avez cr. assets/ contient les autres chiers statiques fournis avec lapplication pour son dploiement sur le terminal.

la sueur de votre frontLors de la cration dun projet Android (avec android create project, par exemple), vous devez fournir le nom de classe ainsi que le chemin complet (paquetage) de lactivit "principale" de lapplication (com.commonsware.android.UneDemo, par exemple). Vous constaterez alors que larborescence src/ de ce projet contient la hirarchie des rpertoires dnis par le paquetage ainsi quun squelette dune sous-classe dActivity reprsentant lactivit principale (src/com/commonsware/android/UneDemo.java). Vous pouvez bien sr modier ce chier et en ajouter dautres larborescence src/ selon les besoins de votre application. La premire fois que vous compilerez le projet (avec ant, par exemple), la chane de production dAndroid crera le chier R.java dans le paquetage de lactivit "principale". Ce chier contient un certain nombre de dnitions de constantes lies aux diffrentes ressources de larborescence res/. Il est dconseill de le modier manuellement : laissez les outils dAndroid sen occuper. Vous rencontrerez de nombreuses rfrences R.java dans les exemples de ce livre (par exemple, on dsignera lidentiant dun layout par R.layout.main).

1. http://ant.apache.org/.

Chapitre 2

Structure dun projet

11

La suite de lhistoireComme on la dj indiqu, larborescence res/ contient les ressources, cest--dire des chiers statiques fournis avec lapplication, soit sous leur forme initiale soit, parfois, sous une forme prtraite. Parmi les sous-rpertoires de res/, citons :

res/drawable/ pour les images (PNG, JPEG, etc.) ; res/layout/ pour les descriptions XML de la composition de linterface graphique ; res/menu/ pour les descriptions XML des menus ; res/raw/ pour les chiers gnraux (un chier CSV contenant les informations dun compte, par exemple) ; res/values/ pour les messages, les dimensions, etc. ; res/xml/ pour les autres chiers XML gnraux que vous souhaitez fournir.

Nous prsenterons tous ces rpertoires, et bien dautres, dans la suite de ce livre, notamment au Chapitre 19.

Le fruit de votre travailLorsque vous compilez un projet (avec ant ou un IDE), le rsultat est plac dans le rpertoire bin/, sous la racine de larborescence du projet :

bin/classes/ contient les classes Java compiles. bin/classes.dex contient lexcutable cr partir de ces classes compiles. bin/votreapp.ap_ (o votreapp est le nom de lapplication) contient les ressources de celle-ci, sous la forme dun chier ZIP. bin/votreapp-debug.apk ou bin/votreapp-unsigned.apk est la vritable application Android.

Le chier .apk est une archive ZIP contenant le chier .dex, la version compile des ressources (resources.arsc), les ventuelles ressources non compiles (celles qui se trouvent sous res/raw/, par exemple) et le chier AndroidManifest.xml. Cette archive est signe : la partie -debug du nom de chier indique quelle la t laide dune cl de dbogage qui fonctionne avec lmulateur alors que -unsigned prcise que lapplication a t construite pour tre dploye (ant release) : larchive APK doit alors tre signe laide de jarsigner et dune cl ofcielle.

3Contenu du manifesteLe point de dpart de toute application Android est son chier manifeste, AndroidManifest.xml, qui se trouve la racine du projet. Cest dans ce chier que lon dclare ce que contiendra lapplication les activits, les services, etc. On y indique galement la faon dont ces composants seront relis au systme Android lui-mme en prcisant, par exemple, lactivit (ou les activits) qui doivent apparatre dans le menu principal du terminal (ce menu est galement appel "lanceur" ou "launcher"). La cration dune application produit automatiquement un manifeste de base. Pour une application simple, qui offre uniquement une activit, ce manifeste automatique conviendra srement ou ncessitera ventuellement quelques modications mineures. En revanche, le manifeste de lapplication de dmonstration Android fournie contient plus de 1 000 lignes. Vos applications se situeront probablement entre ces deux extrmits. La plupart des parties intressantes du manifeste seront dcrites en dtail dans les chapitres consacrs aux fonctionnalits dAndroid qui leur sont associes llment service, par exemple, est dtaill au Chapitre 30. Pour le moment, il vous suft de comprendre le rle de ce chier et la faon dont il est construit.

14


Au dbut, il y avait la racineTous les chiers manifestes ont pour racine un lment manifest : ...

Cet lment comprend la dclaration de lespace de noms android. Curieusement, les manifestes produits nappliquent cet espace quaux attributs, pas aux lments (on crit donc manifest, pas android:manifest). Nous vous conseillons de conserver cette convention, sauf si Android la modie dans une version future.Lessentiel des informations que vous devez fournir cet lment est lattribut package (qui nutilise pas non plus lespace de noms). Cest l que vous pouvez indiquer le nom du paquetage Java qui sera considr comme la "base" de votre application. Dans la suite du chier, vous pourrez alors simplement utiliser le symbole point pour dsigner ce paquetage : si vous devez, par exemple, faire rfrence com.commonsware.android.search.Snicklefritz dans le manifeste de cet exemple, il sufra dcrire .Snicklefritz puisque com.commonsware.android.search est dni comme le paquetage de lapplication.

Info

Permissions, instrumentations et applicationsSous llment manifest, vous trouverez les lments suivants :

Des lments uses-permission indiquant les permissions dont a besoin votre application pour fonctionner correctement (voir Chapitre 19 pour plus de dtails). Des lments permission dclarant les permissions que les activits ou les services peuvent exiger des autres applications pour utiliser les donnes et le code de lapplication (voir galement Chapitre 19). Des lments instrumentation qui indiquent le code qui devrait tre appel pour les vnements systme essentiels, comme le lancement des activits. Ces lments sont utiliss pour la journalisation ou la surveillance. Des lments uses-library pour relier les composants facultatifs dAndroid, comme les services de golocalisation. ventuellement, un lment uses-sdk indiquant la version du SDK Android avec laquelle a t construite lapplication. Un lment application qui dnit le cur de lapplication dcrite par le manifeste.

Chapitre 3

Contenu du manifeste

15

Le manifeste de lexemple qui suit contient des lments uses-permission qui indiquent certaines fonctionnalits du terminal dont lapplication a besoin ici, lapplication doit avoir le droit de dterminer sa position gographique courante. Llment application dcrit les activits, les services et tout ce qui constitue lapplication elle-mme. ...

Que fait votre application ?Le plat de rsistance du chier manifeste est dcrit par les ls de llment application. Par dfaut, la cration dun nouveau projet Android nindique quun seul lment activity :

Cet lment fournit android:name pour la classe qui implmente lactivit, android:label pour le nom afch de lactivit et (souvent) un lment ls intentfilter dcrivant les conditions sous lesquelles cette activit safchera. Llment activity de base congure votre activit pour quelle apparaisse dans le lanceur et que les utilisateurs puissent lexcuter. Comme nous le verrons plus tard, un mme projet peut dnir plusieurs activits.

16


Il peut galement y avoir un ou plusieurs lments receiver dcrivant les non-activits qui devraient se dclencher sous certaines conditions la rception dun SMS, par exemple. On les appelle rcepteurs dintentions (intent receivers) et ils sont dcrits au Chapitre 23. De mme, un ou plusieurs lments provider peuvent tre prsents an dindiquer les fournisseurs de contenus (content providers) les composants qui fournissent les donnes vos activits et, avec votre permission, aux activits dautres applications du terminal. Ces lments enveloppent les bases de donnes ou les autres stockages de donnes en une API unique que toute application peut ensuite utiliser. Nous verrons plus loin comment crer des fournisseurs de contenus et comment utiliser les fournisseurs que vous ou dautres ont crs. Enn, il peut y avoir un ou plusieurs lments service dcrivant les services, cest--dire les parties de code qui peuvent fonctionner indpendamment de toute activit et en permanence. Lexemple classique est celui du lecteur MP3, qui permet de continuer couter de la musique, mme si lutilisateur ouvre dautres activits et que linterface utilisateur nest pas afche au premier plan. La cration et lutilisation des services sont dcrites aux Chapitres 30 et 31.

Faire le minimumAndroid, comme la plupart des systmes dexploitation, est rgulirement amlior, ce qui donne lieu de nouvelles versions du systme. Certains de ces changements affectent le SDK car de nouveaux paramtres, classes ou mthodes apparaissent, qui nexistaient pas dans les versions prcdentes. Pour tre sr que votre application ne sexcutera que pour une version prcise (ou suprieure) dun environnement Android, ajoutez un lment uses-sdk comme ls de llment manifest du chier AndroidManifest.xml. uses-sdk na quun seul attribut, minSdkVersion, qui indique la version minimale du SDK exige par votre application : ...

lheure o ce livre est crit, minSdkVersion peut prendre trois valeurs :

1 pour indiquer le premier SDK dAndroid, la version 1.0 ; 2 pour indiquer la version 1.1 du SDK dAndroid ; 3 pour indiquer la version 1.5.

Chapitre 3

Contenu du manifeste

17

Labsence dun lment uses-sdk revient utiliser 1 comme valeur de minSdkVersion. Cela dit, la boutique Android semble tenir ce que lon indique explicitement la valeur de minSdkVersion : faites en sorte dutiliser un lment uses-sdk si vous comptez distribuer votre programme par ce biais. Si cet lment est prsent, lapplication ne pourra sinstaller que sur les terminaux compatibles. Vous navez pas besoin de prciser la dernire version du SDK mais, si vous en choisissez une plus ancienne, cest vous de vrier que votre application fonctionnera sur toutes les versions avec lesquelles elle prtend tre compatible. Si, par exemple, vous omettez uses-sdk, cela revient annoncer que votre application fonctionnera sur toutes les versions existantes du SDK et vous devrez videmment tester que cest bien le cas.

Version = contrleSi vous comptez distribuer votre application via la boutique Android ou dautres supports, vous devrez srement ajouter les attributs android:versionCode et android:versionName llment manifest an de faciliter le processus de mise jour des applications. android:versionName est une chane lisible reprsentant le nom ou le numro de version de votre application. Vous pouvez, par exemple, utiliser des valeurs comme "3.0" ou "System V", en fonction de vos prfrences. android:versionCode est un entier cens reprsenter le numro de version de lapplication. Le systme lutilise pour savoir si votre version est plus rcente quune autre "rcent" tant dni par "la valeur dandroid:versionCode est plus leve". Pour obtenir cette valeur, vous pouvez convertir le contenu dandroid:versionName en nombre ou simplement incrmenter la valeur chaque nouvelle version.

PartieLes activitsCHAPITRE 4. CHAPITRE 5. CHAPITRE 6. CHAPITRE 7. CHAPITRE 8. CHAPITRE 9. CHAPITRE 10. CHAPITRE 11. CHAPITRE 12. CHAPITRE 13. CHAPITRE 14. CHAPITRE 15. CHAPITRE 16. Cration dun squelette dapplication Utilisation des layouts XML Utilisation des widgets de base Conteneurs Widgets de slection Samuser avec les listes Utiliser de jolis widgets et de beaux conteneurs Utilisation des menus Polices de caractres Intgrer le navigateur de WebKit Afchage de messages surgissant Utilisation des threads Gestion des vnements du cycle de vie dune activit

II

4Cration dun squelette dapplicationTous les livres consacrs un langage ou un environnement de programmation commencent par prsenter un programme de dmonstration de type "Bonjour tous !" : il permet de montrer que lon peut construire quelque chose tout en restant sufsamment concis pour ne pas noyer le lecteur dans les dtails. Cependant, le programme "Bonjour tous !" classique nest absolument pas interactif (il se contente dcrire ces mots sur la console) et est donc assez peu stimulant. Ce chapitre prsentera donc un projet qui utilisera malgr tout un bouton et lheure courante pour montrer le fonctionnement dune activit Android simple.

Terminaux virtuels et ciblesPour construire les projets, nous supposons que vous avez tlcharg le SDK (et, ventuellement, le plugin ADT dEclipse). Avant de commencer, nous devons prsenter la notion de "cible" car elle risque de vous surprendre et elle est relativement importante dans le processus de dveloppement.

22


Comme son nom lindique, un AVD (Android Virtual Device), est un terminal virtuel par opposition aux vrais terminaux Android comme le G1 ou le Magic de HTC. Les AVD sont utiliss par lmulateur fourni avec le SDK et vous permettent de tester vos programmes avant de les dployer sur les vritables terminaux. Vous devez indiquer lmulateur un terminal virtuel an quil puisse prtendre quil est bien le terminal dcrit par cet AVD.

Cration dun AVDPour crer un AVD, vous pouvez lancer la commande android create avd ou utiliser Eclipse ; dans les deux cas, vous devez indiquer une cible qui prcise la classe de terminaux qui sera simule par lAVD. lheure o cette dition est publie, il existe trois cibles :

une qui dsigne un terminal Android 1.1, comme un G1 HTC de base qui naurait pas t mis jour ; une deuxime qui dsigne un terminal Android 1.5, sans le support de Google Maps ; une troisime qui dsigne un terminal Android 1.5 disposant du support de Google Maps, ce qui est le cas de la majorit des terminaux Android actuels.

Si vous dveloppez des applications utilisant Google Maps, vous devez donc utiliser un ADV ayant la cible 3. Sinon la cible 2 conviendra parfaitement. Actuellement, la plupart des G1 ayant t mis jour avec Android 1.5, la cible 1 nest plus trs utile. Vous pouvez crer autant dAVD que vous le souhaitez du moment que vous avez assez despace disque disponible sur votre environnement de dveloppement : si vous avez besoin dun pour chacune des trois cibles, libre vous ! Noubliez pas, cependant, que linstallation dune application sur un AVD naffecte pas les autres AVD que vous avez crs.

Choix dune cibleLorsque vous crez un projet (avec android create project ou partir dEclipse), vous devez galement indiquer la classe de terminal vise par celui-ci. Les valeurs possibles tant les mmes que ci-dessus, crer un projet avec une cible 3 donne les indications suivantes :

Vous avez besoin dAndroid 1.5. Vous avez besoin de Google Maps.

Lapplication nale ne sinstallera donc pas sur les terminaux qui ne correspondent pas ces critres.

Chapitre 4

Cration dun squelette dapplication

23

Voici quelques rgles pour vous aider grer les cibles :

Demandez-vous ce dont vous avez rellement besoin. Ne crez un projet avec une cible 3 que si vous utilisez Google Maps, notamment. Sinon une cible 2 est prfrable vous exigerez toujours Android 1.5, mais votre application pourra sexcuter sur des terminaux qui ne disposent pas de Google Maps. Testez autant de cibles que possible. Vous pourriez tre tent par la cible 1 pour viser le plus grand nombre de terminaux Android ; cependant, vous devrez alors tester votre application sur un AVD ayant une cible 1 et un AVD ayant une cible 2 (et il serait galement souhaitable de la tester avec un AVD ayant une cible 3, au cas o). Vriez quune nouvelle cible na pas t ajoute par une nouvelle version dAndroid. Il devrait y avoir quelques nouvelles valeurs avec chaque version majeure (2.0 ou 1.6, par exemple), voire pour les versions intermdiaires (1.5r1 ou 1.5r2). Assurez-vous de tester votre application sur ces nouvelles cibles chaque fois que cela est possible car certains peuvent utiliser ces nouvelles versions de terminaux ds quelles sortent. Le fait de tester avec des AVD, quelle que soit la cible, ne peut pas se substituer aux tests sur du vrai matriel. Les AVD sont conus pour vous fournir des "environnements jetables", permettant de tester un grand nombre denvironnements, mme ceux qui nexistent pas encore rellement. Cependant, vous devez mettre votre application lpreuve dau moins un terminal Android. En outre, la vitesse de votre mulateur peut ne pas correspondre celle du terminal selon votre systme, elle peut tre plus rapide ou plus lente.

Commencer par le dbutAvec Android, tout commence par la cration dun projet. En Java classique, vous pouvez, si vous le souhaitez, vous contenter dcrire un programme sous la forme dun unique chier, le compiler avec javac puis lexcuter avec Java. Android est plus complexe mais, pour faciliter les choses, Google a fourni des outils daide la cration dun projet. Si vous utilisez un IDE compatible avec Android, comme Eclipse et le plugin Android (fourni avec le SDK), vous pouvez crer un projet directement partir de cet IDE (menu Fichier > Nouveau > Projet, puis choisissez Android > Android Project). Si vous vous servez doutils non Android, vous pouvez utiliser le script android, qui se trouve dans le rpertoire tools/ de linstallation du SDK en lui indiquant que vous souhaitez crer un projet (create project). Il faut alors lui indiquer la version de la cible, le rpertoire racine du projet, le nom de lactivit et celui du paquetage o tout devra se trouver :

24


android create project \ --target 2 \ --path chemin/vers/mon/projet \ --activity Now \ --package com.commonsware.android.skeleton

Cette commande cre automatiquement les chiers que nous avons dcrits au Chapitre 2 et que nous utiliserons dans le reste de ce chapitre. Vous pouvez galement tlcharger les rpertoires des projets exemples de ce livre sous la forme de chiers ZIP partir du site web de Pearson1. Ces projets sont prts tre utiliss : vous navez donc pas besoin dutiliser android create project lorsque vous aurez dcompress ces exemples.

LactivitLe rpertoire src/ de votre projet contient une arborescence de rpertoires Java classique, cre daprs le paquetage Java que vous avez utilis pour crer le projet (com.commonsware.android.skeleton produit donc src/com/commonsware/android/ skeleton). Dans le rpertoire le plus bas, vous trouverez un chier source nomm Now.java, dans lequel sera stock le code de votre premire activit. Celle-ci sera constitue dun unique bouton qui afchera lheure laquelle on a appuy dessus pour le dernire fois (ou lheure de lancement de lapplication si on na pas encore appuy sur ce bouton). Ouvrez Now.java dans un diteur de texte et copiez-y le code suivant :package com.commonsware.android.skeleton; import android.app.Activity; import android.os.Bundle; import android.view.View; import android.widget.Button; import java.util.Date; public class Now extends Activity implements View.OnClickListener { Button btn; @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); btn = new Button(this); btn.setOnClickListener(this); updateTime(); setContentView(btn); }

1. http://pearson.fr.

Chapitre 4


25

public void onClick(View view) { updateTime(); } private void updateTime() { btn.setText(new Date().toString()); } }

Si vous avez tlcharg les chiers partir du site web de Pearson, vous pouvez vous contenter dutiliser directement le projet Skeleton/Now. Examinons maintenant chacune des parties de ce code.

Dissection de lactivitLa dclaration de paquetage doit tre identique celle que vous avez utilise pour crer le projet. Comme pour tout projet Java, vous devez importer les classes auxquelles vous faites rfrence. La plupart de celles qui sont spciques Android se trouvent dans le paquetage android :package com.commonsware.android.skeleton; import android.app.Activity; import android.os.Bundle; import android.view.View; import android.widget.Button; import java.util.Date;

Notez bien que toutes les classes de Java SE ne sont pas utilisables par les programmes Android. Consultez le guide de rfrence des classes Android1 pour savoir celles qui sont disponibles et celles qui ne le sont pas. Les activits sont des classes publiques hrites de la classe de base android.app.Activity. Ici, lactivit contient un bouton (btn) :public class Now extends Activity implements View.OnClickListener { Button btn;

Info

Un bouton, comme vous pouvez le constater daprs le nom du paquetage, est un widget Android. Les widgets sont des lments dinterface graphique que vous pouvez utiliser dans une application.

1. http://code.google.com/android/reference/packages.html.

26


Pour rester simple, nous voulons capturer tous les clics de bouton dans lactivit ellemme : cest la raison pour laquelle la classe de notre activit implmente galement OnClickListener.@Override public void onCreate(Bundle icicle) { super.onCreate(icicle); btn = new Button(this); btn.setOnClickListener(this); updateTime(); setContentView(btn); }

La mthode onCreate() est appele lorsque lactivit est lance. La premire chose faire est dtablir un chanage vers la superclasse an de raliser linitialisation de lactivit Android de base. Nous crons ensuite linstance du bouton (avec new Button(this)) et demandons denvoyer tous les clics sur ce bouton linstance de lactivit (avec setOnClickListener()). Nous appelons ensuite la mthode prive updateTime() (qui sera prsente plus loin), puis nous congurons la vue du contenu de lactivit pour que ce soit le bouton lui-mme (avec setContentView()).Tous les widgets drivent de la classe de base View. Bien que lon construise gnralement linterface graphique partir dune hirarchie de vues, nous nutiliserons ici quune seule vue.

Info

Nous prsenterons ce Bundle icicle magique au Chapitre 16. Pour linstant, considrons-le comme un gestionnaire opaque, que toutes les activits reoivent lors de leur cration.public void onClick(View view) { updateTime(); }

Avec Swing, un clic sur un JButton dclenche un ActionEvent qui est transmis lActionListener congur pour ce bouton. Avec Android, en revanche, un clic sur un bouton provoque lappel de la mthode onClick() sur linstance OnClickListener congure pour le bouton. Lcouteur reoit la vue qui a dclench le clic (ici, il sagit du bouton). Dans notre cas, nous nous contentons dappeler la mthode prive updateTime() :private void updateTime() { btn.setText(new Date().toString()); }

Chapitre 4


27

Louverture de lactivit (onCreate()) ou un clic sur le bouton (onClick()) doit provoquer la mise jour du label du bouton avec la date courante. On utilise pour cela la mthode setText(), qui fonctionne exactement comme avec les JButton de Swing.

Compiler et lancer lactivitPour compiler lactivit, utilisez loutil de cration de paquetage Android intgr votre IDE ou lancez ant debug depuis le rpertoire racine de votre projet. Puis lancez lactivit en suivant les tapes suivantes : 1. Lancez lmulateur (avec tools/emulator dans votre installation du SDK Android), pour obtenir une gure analogue celle de la Figure 4.1. Noubliez pas de prciser un AVD avec loption -avd.Figure 4.1 Lcran daccueil dAndroid.

2. Installez le paquetage (avec tools/adb install /racine/projet/bin/Now-debug .apk). 3. Consultez la liste des applications installes sur lmulateur et recherchez celle qui sappelle Now (voir Figure 4.2). 4. Ouvrez cette application. Vous devriez voir apparatre un cran dactivit comme celui de la Figure 4.3.

28


Figure 4.2 Le lanceur dapplications dAndroid.

Figure 4.3 Dmonstration de lactivit Now.

En cliquant sur le bouton en dautres termes, quasiment nimporte o sur lcran du tlphone , lheure courante safchera sur le label du bouton. Vous remarquerez que ce label est centr horizontalement et verticalement car cest le style par dfaut. Nous verrons au Chapitre 6 que nous pouvons videmment contrler ce formatage. Une fois repu de cette technologie poustouante des boutons, vous pouvez cliquer sur le bouton de retour en arrire de lmulateur pour revenir au lanceur.

5Utilisation des layouts XMLBien quil soit techniquement possible de crer et dattacher des composants widgets une activit en utilisant uniquement du code Java comme nous lavons fait au Chapitre 4, on prfre gnralement employer un chier de positionnement (layout) cod en XML. Linstanciation dynamique des widgets est rserve aux scnarios plus complexes, o les widgets ne sont pas connus au moment de la compilation (lorsquil faut, par exemple, remplir une colonne de boutons radio en fonction de donnes rcupres sur Internet). Examinons maintenant ce code XML pour savoir comment sont agences les vues des activits Android lorsque lon utilise cette approche.

Quest-ce quun positionnement XML ?Comme son nom lindique, un positionnement XML est une spcication des relations existant entre les composants widgets et avec leurs conteneurs (voir Chapitre 7) exprime sous la forme dun document XML. Plus prcisment, Android considre les layouts XML comme des ressources stockes dans le rpertoire res/layout du projet.

30


Chaque chier XML contient une arborescence dlments prcisant le layout des widgets et les conteneurs qui composent une View. Les attributs de ces lments sont des proprits qui dcrivent laspect dun widget ou le comportement dun conteneur. Un lment Button avec un attribut android:textStyle = "bold", par exemple, signie que le texte apparaissant sur ce bouton sera en gras. Loutil aapt du SDK dAndroid utilise ces layouts ; il est appel automatiquement par la chane de production du projet (que ce soit via Eclipse ou par le traitement du chier build.xml de Ant). Cest aapt qui produit le chier source R.java du projet, qui vous permet daccder directement aux layouts et leurs composants widgets depuis votre code Java, comme nous le verrons bientt.

Pourquoi utiliser des layouts XML ?La plupart de ce qui peut tre fait avec des chiers de positionnement XML peut galement tre ralis avec du code Java. Vous pourriez, par exemple, utiliser setTypeface() pour quun bouton afche son texte en gras au lieu dutiliser une proprit dans un chier XML. Ces chiers sajoutant tous ceux que vous devez dj grer, il faut donc quil y ait une bonne raison de les utiliser. La principale est probablement le fait quils permettent de crer des outils de dnition des vues : le constructeur dinterfaces graphiques dun IDE comme Eclipse ou un assistant ddi la cration des interfaces graphiques dAndroid, comme DroidDraw 1, par exemple. Ces logiciels pourraient, en principe, produire du code Java au lieu dun document XML, mais il est bien plus simple de relire la dnition dune interface graphique an de la modier lorsque cette dnition est exprime dans un format structur comme XML au lieu dtre code dans un langage de programmation. En outre, sparer ces dnitions XML du code Java rduit les risques quune modication du code source perturbe lapplication. XML est un bon compromis entre les besoins des concepteurs doutils et ceux des programmeurs. En outre, lutilisation de XML pour la dnition des interfaces graphiques est devenue monnaie courante. XAML2 de Microsoft, Flex3 dAdobe et XUL4 de Mozilla utilisent toutes une approche quivalente de celle dAndroid : placer les dtails des positionnements dans un chier XML en permettant de les manipuler partir des codes sources ( laide de JavaScript pour XUL, par exemple). De nombreux frameworks graphiques moins connus, comme ZK5, utilisent galement XML pour la dnition de leurs vues. Bien que1. 2. 3. 4. 5.

http://droiddraw.org/. http://windowssdk.msdn.microsoft.com/en-us/library/ms752059.aspx . http://www.adobe.com/products/ex/. http://www.mozilla.org/projects/xul/. http://www.zkoss.org/.

Chapitre 5

Utilisation des layouts XML

31

"suivre le troupeau" ne soit pas toujours le meilleur choix, cette politique a lavantage de faciliter la transition vers Android partir dun autre langage de description des vues reposant sur XML.

Contenu dun chier layoutVoici le bouton de lapplication du chapitre prcdent, converti en un chier XML que vous trouverez dans le rpertoire chap5/Layouts/NowRedux de larchive des codes sources, tlchargeable sur le site www.pearson.fr, sur la page ddie cet ouvrage. Pour faciliter la recherche des codes des exemples, cette archive est dcoupe selon les chapitres du livre.

Ici, le nom de llment XML est celui de la classe du widget, Button. Ce dernier tant fourni par Android, il suft dutiliser simplement son nom de classe. Dans le cas dun widget personnalis, driv dandroid.view.View, il faudrait utiliser un nom pleinement quali, contenant le nom du paquetage (com.commonsware.android.MonWidget, par exemple). Llment racine doit dclarer lespace de noms XML dAndroid :xmlns:android="http://schemas.android.com/apk/res/android"

Tous les autres lments sont des ls de la racine et hritent de cette dclaration. Comme lon souhaite pouvoir faire rfrence ce bouton partir de notre code Java, il faut lui associer un identiant avec lattribut android:id. Nous expliquerons plus prcisment ce mcanisme plus loin dans ce chapitre. Les autres attributs sont les proprits de cette instance de Button :

android:text prcise le texte qui sera afch au dpart sur le bouton (ici, il sagit dune chane vide). android:layout_width et android:layout_height prcisent que la largeur et la hauteur du bouton rempliront le "parent", cest--dire ici lcran entier ces attributs seront prsents plus en dtail au Chapitre 7.

Ce widget tant le seul contenu de notre activit, nous navons besoin que de cet lment. Les vues plus complexes ncessitent une arborescence dlments, an de reprsenter les widgets et les conteneurs qui contrlent leur positionnement. Dans la suite de ce livre, nous utiliserons des positionnements XML chaque fois que cela est ncessaire : vous

32


trouverez donc des dizaines dexemples plus complexes que vous pourrez utiliser comme point de dpart pour vos propres projets.

Identiants des widgetsDe nombreux widgets et conteneurs ne peuvent apparatre que dans le chier de positionnement et ne seront pas utiliss par votre code Java. Le plus souvent, un label statique (TextView), par exemple, na besoin dtre dans le chier XML que pour indiquer lemplacement o il doit apparatre dans linterface. Ce type dlment na donc pas besoin dun attribut android:id pour lui donner un nom. En revanche, tous les lments dont vous avez besoin dans votre source Java doivent possder cet attribut. La convention consiste utiliser le format @+id/nom_unique comme valeur didentiant, o nom_unique reprsente le nom local du widget, qui doit tre unique. Dans lexemple de la section prcdente, lidentiant du widget Button tait @+id/button. Android utilise galement quelques valeurs android:id spciques, de la forme @android:id/.... Nous les rencontrerons dans diffrents chapitres de ce livre, notamment aux Chapitres 8 et 10.

Utilisation des widgets dans le code JavaUne fois que vous avez douloureusement congur les widgets et les conteneurs dans un chier de positionnement XML nomm main.xml et que vous lavez plac dans le rpertoire res/layout, vous navez plus qu ajouter une seule instruction dans la mthode onCreate() de votre activit pour pouvoir utiliser ce positionnement :setContentView(R.layout.main);

Il sagit du mme appel setContentView() que nous avions utilis prcdemment en lui passant une instance dune sous-classe de View (un Button). La vue construite partir de notre chier XML est dsormais accessible partir de la classe R. Tous les positionnements dnis se trouvent sous R.layout, indiqus par le nom de base du chier R.layout.main dsigne donc main.xml. Pour accder nos widgets, nous utilisons ensuite la mthode findViewById(), en lui passant lidentiant numrique du widget concern. Cet identiant a t produit par Android dans la classe R et est de la forme R.id.qquechose (o qquechose est le widget que vous recherchez). Ces widgets sont des sous-classes de View, exactement comme linstance de Button que nous avions cre au Chapitre 4.

Chapitre 5

Utilisation des layouts XML

33

Fin de lhistoireDans le premier exemple Now, le texte du bouton afchait lheure laquelle on avait appuy dessus pour la dernire fois (ou lheure laquelle lactivit avait t lance). Lessentiel du code fonctionne encore, mme dans cette nouvelle version (que nous appellerons NowRedux). Cependant, au lieu dinstancier le bouton dans la mthode onCreate(), nous faisons rfrence celui qui est dcrit dans lagencement XML :package com.commonsware.android.layouts; import android.app.Activity; import android.os.Bundle; import android.view.View; import android.widget.Button; import java.util.Date; public class NowRedux extends Activity implements View.OnClickListener { Button btn; @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.main); btn=(Button)findViewById(R.id.button); btn.setOnClickListener(this); updateTime(); } public void onClick(View view) { updateTime(); } private void updateTime() { btn.setText(new Date().toString()); } }

La premire diffrence est quau lieu de crer la vue dans le code Java nous faisons rfrence au chier XML de positionnement (avec setContentView(R.layout.main)). Le chier source R.java sera mis jour lorsque le projet sera recompil, an dinclure une rfrence au chier de positionnement (main.xml du rpertoire res/layout). La seconde diffrence est quil faut retrouver linstance de notre bouton en appelant la mthode findViewById(). Comme lidentiant de ce bouton est @+id/button, nous pouvons dsigner son identiant numrique par R.id.button. Il reste ensuite mettre en place lcouteur dvnement et congurer son label.

34


La Figure 5.1 montre que le rsultat est le mme que celui de lexemple Now prcdent.Figure 5.1 Lactivit NowRedux.

6Utilisation des widgets de baseChaque kit de dveloppement graphique possde des widgets de base : champs de saisie, labels, boutons, etc. Celui dAndroid ny fait pas exception et leur tude fournit une bonne introduction au fonctionnement des widgets dans les activits Android.

LabelsLe label (TextView pour Android) est le widget le plus simple. Comme dans la plupart des kits de dveloppement, les labels sont des chanes de textes non modiables par les utilisateurs. Ils servent gnralement identier les widgets qui leur sont adjacents ("Nom : ", par exemple, plac ct dun champ de saisie). En Java, un label est une instance de la classe TextView. Cependant, ils seront le plus souvent crs dans les chiers layout XML en ajoutant un lment TextView dot dune proprit android:text pour dnir le texte qui lui est associ. Si vous devez changer des labels en fonction dun certain critre linternationalisation, par exemple , vous pouvez utiliser la place une rfrence de ressource dans le code XML, comme nous

36


lexpliquerons au Chapitre 9. Un lment TextView possde de nombreux autres attributs, notamment :

android:typeface pour dnir le type de la police du label (monospace, par exemple) ; android:textStyle pour indiquer si le texte doit tre en gras (bold), en italique (italic) ou les deux (bold_italic) ; android:textColor pour dnir la couleur du texte du label, au format RGB hexadcimal (#FF0000 pour un texte rouge, par exemple).

Voici le contenu du chier de positionnement du projet Basic/Label :

Comme le montre la Figure 6.1, ce chier seul, avec le squelette Java fourni par la chane de production dAndroid (android create project), produira lapplication voulue.Figure 6.1 Lapplication LabelDemo.

BoutonsNous avons dj utilis le widget Button au Chapitre 4. Button tant une sous-classe de TextView, tout ce qui a t dit dans la section prcdente concernant le formatage du texte sapplique galement au texte dun bouton.

Chapitre 6

Utilisation des widgets de base

37

ImagesAndroid dispose de deux widgets permettant dintgrer des images dans les activits : ImageView et ImageButton. Comme leur nom lindique, il sagit, respectivement, des quivalents images de TextView et Button. Chacun deux possde un attribut android:src permettant de prciser limage utilise. Cet attribut dsigne gnralement une ressource graphique (voir le chapitre consacr aux ressources). Vous pouvez galement congurer le contenu de limage en utilisant une URI dun fournisseur de contenu, via un appel setImageURI(). ImageButton, une sous-classe dImageView, lui ajoute les comportements dun Button standard pour rpondre aux clics et autres actions. Examinons, par exemple, le contenu du chier main.xml du projet Basic/ImageView :

Le rsultat, qui utilise simplement lactivit produite automatiquement, est prsent la Figure 6.2.Figure 6.2 Lapplication ImageViewDemo.

38


Champs de saisieOutre les boutons et les labels, les champs de saisie forment le troisime pilier de la plupart des outils de dveloppement graphiques. Avec Android, ils sont reprsents par le widget EditText, qui est une sous-classe de TextView, dj vue pour les labels. En plus des proprits standard de TextView (android:textStyle, par exemple), EditText possde de nombreuses autres proprits ddies la construction des champs. Parmi elles, citons :

android:autoText pour indiquer si le champ doit fournir une correction automatique de lorthographe. android:capitalize pour demander que le champ mette automatiquement en majuscule la premire lettre de son contenu. android:digits pour indiquer que le champ nacceptera que certains chiffres. android:singleLine pour indiquer si la saisie ne seffectue que sur une seule ou plusieurs lignes (autrement dit, vous place-t-il sur le widget suivant ou ajoutet-il une nouvelle ligne ?).

Outre ces proprits, vous pouvez congurer les champs pour quils utilisent des mthodes de saisie spcialises, avec les attributs android:numeric pour imposer une saisie uniquement numrique, android:password pour masquer la saisie dun mot de passe et android:phoneNumber pour la saisie des numros de tlphone. Pour crer une mthode de saisie particulire (an, par exemple, de saisir des codes postaux ou des numros de scurit sociale), il faut implmenter linterface InputMethod puis congurer le champ pour quil utilise cette mthode, laide de lattribut android:inputMethod. Voici, par exemple, la description dun EditText tir du projet Basic/Field :

Vous remarquerez que la valeur dandroid:singleLine est false, ce qui signie que les utilisateurs pourront saisir plusieurs lignes de texte dans ce champ. Le chier FieldDemo.java de ce projet remplit le champ de saisie avec un peu de prose :package com.commonsware.android.basic; import android.app.Activity; import android.os.Bundle;

Chapitre 6


39

import android.widget.EditText; public class FieldDemo extends Activity { @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.main); EditText fld=(EditText)findViewById(R.id.field); fld.setText("Publie sous les termes de la licence Apache 2.0 " + "(la \"Licence\") ; pour utiliser ce fichier " + "vous devez respecter la Licence dont vous pouvez " + "obtenir une copie a lURL " + "http://www.apache.org/licenses/LICENSE-2.0"); } }

La Figure 6.3 montre le rsultat obtenu.Figure 6.3 Lapplication FieldDemo.

Info

Lmulateur dAndroid nautorise quune seule application dun mme paquetage Java dans le lanceur (application Launcher). Comme tous les exemples de ce chapitre appartiennent au paquetage com.commonsware.android.basic, il napparatra quun seul exemple la fois dans le lanceur.

Certains champs offrent une compltion automatique an de permettre lutilisateur dentrer des informations sans taper lintgralit du texte. Avec Android, ces champs sont des widgets AutoCompleteTextView ; ils seront prsents au Chapitre 8.

40


Cases cocherLa case cocher classique peut tre dans deux tats : coche ou dcoche. Un clic sur la case inverse son tat pour indiquer un choix ("Livrer ma commande en urgence", par exemple). Le widget CheckBox dAndroid permet dobtenir ce comportement. Comme il drive de la classe TextView, les proprits de celles-ci comme android:textColor permettent galement de formater ce widget. Dans votre code Java, vous pouvez utiliser les mthodes suivantes :

isChecked() pour savoir si la case est coche ; setChecked() pour forcer la case dans ltat coch ou dcoch ; toggle() pour inverser ltat de la case, comme si lutilisateur avait cliqu dessus.

Vous pouvez galement enregistrer un objet couteur (il sagira, ici, dune instance dOnCheckedChangeListener) pour tre prvenu des changements dtat de la case. Voici la dclaration XML dune case cocher, tire du projet Basic/CheckBox :

Le chier CheckBoxDemo.java correspondant rcupre cette case cocher et congure son comportement :public class CheckBoxDemo extends Activity implements CompoundButton.OnCheckedChangeListener { CheckBox cb; @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.main); cb=(CheckBox)findViewById(R.id.check); cb.setOnCheckedChangeListener(this); } public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) { if (isChecked) { cb.setText("Cette case est cochee"); } else { cb.setText("Cette case est decochee"); } } }

Chapitre 6


41

Vous remarquerez que cest lactivit qui sert dcouteur pour les changements dtat de la case cocher (avec cb.setOnCheckedChangeListener(this)) car elle implmente linterface OnCheckedChangeListener. La mthode de rappel de lcouteur est onCheckedChanged() : elle reoit la case qui a chang dtat et son nouvel tat. Ici, on se contente de modier le texte de la case pour reter son tat courant. Cliquer sur la case modie donc immdiatement son texte, comme le montrent les Figures 6.4 et 6.5.Figure 6.4 Lapplication CheckBoxDemo avec la case dcoche.

Figure 6.5 La mme application avec la case coche.

42


Boutons radioComme dans les autres outils de dveloppement, les boutons radio dAndroid ont deux tats, telles les cases cocher, mais peuvent tre regroups de sorte quun seul bouton radio puisse tre coch par groupe un instant donn. Comme CheckBox, RadioButton hrite de la classe CompoundButton, qui drive ellemme de TextView. Toutes les proprits standard de TextView pour la police, le style, la couleur, etc. sappliquent donc galement aux boutons radio. Vous pouvez par consquent appeler isChecked() sur un RadioButton pour savoir sil est coch, toggle() pour le slectionner, etc. exactement comme avec une CheckBox. La plupart du temps, les widgets RadioButton sont placs dans un conteneur RadioGroup qui permet de lier les tats des boutons quil regroupe an quun seul puisse tre slectionn un instant donn. En affectant un identiant android:id au RadioGroup dans le chier de description XML, ce groupe devient accessible au code Java, qui peut alors lui appliquer les mthodes suivantes :

check() pour tester un bouton radio partir de son identiant (avec groupe.check (R.id.radio1)) ; clearCheck() pour dcocher tous les boutons du groupe ; getCheckedRadioButtonId() pour obtenir lidentiant du bouton radio actuellement coch (cette mthode renvoie 1 si aucun bouton nest coch).

Voici, par exemple, une description XML dun groupe de boutons radio, tire de lexemple Basic/RadioButton :

Chapitre 6


43

La Figure 6.6 montre le rsultat obtenu en utilisant le projet Java de base, fourni par Android.Figure 6.6 Lapplication RadioButtonDemo.

Vous remarquerez que, au dpart, aucun bouton du groupe nest coch. Pour que lapplication slectionne lun de ces boutons ds son lancement, il faut appeler soit la mthode setChecked() sur le RadioButton concern, soit la mthode check() sur le RadioGroup partir de la mthode onCreate() de lactivit.

RsumTous les widgets que nous venons de prsenter drivent de la classe View et hritent donc dun ensemble de proprits et de mthodes supplmentaires par rapport celles que nous avons dj dcrites.

Proprits utilesParmi les proprits les plus utiles de View, citons :

Le contrle de la squence de focus : android:nextFocusDown ; android:nextFocusLeft ; android:nextFocusRight ; android:nextFocusUp.

44


android:visibility, qui contrle la visibilit initiale du widget. android:background, qui permet de fournir au widget une couleur de fond au format RGB (#00FF00 pour vert, par exemple).

Mthodes utilesLa mthode setEnabled() permet de basculer entre ltat actif et inactif du widget, alors que isEnabled() permet de tester si un widget est actif. On utilise souvent ces deux mthodes pour dsactiver certains widgets en fonction de choix effectus laide de CheckBox ou de RadioButton. La mthode requestFocus() donne le focus un widget et isFocused() permet de tester sil a le focus. En utilisant les mthodes voques plus haut, on peut donc donner le focus un widget prcis aprs une opration de dsactivation. Les mthodes suivantes permettent de parcourir une arborescence de widgets et de conteneurs composant la vue gnrale dune activit :

getParent() renvoie le widget ou le conteneur parent. findViewById() permet de retrouver un widget ls daprs son identiant. getRootView() renvoie la racine de larborescence (celle que vous avez fournie lactivit via un appel setContentView()).

7ConteneursLes conteneurs permettent de disposer un ensemble de widgets (et, ventuellement, des conteneurs ls) pour obtenir la prsentation de votre choix. Si, par exemple, vous prfrez placer les labels gauche et les champs de saisie droite, vous aurez besoin dun conteneur. Si vous voulez que les boutons OK et Annuler soient lun ct de lautre, en bas droite du formulaire, vous aurez galement besoin dun conteneur. Dun point de vue purement XML, si vous manipulez plusieurs widgets (le cas des RadioButton dans un RadioGroup est particulier), vous devrez utiliser un conteneur an de disposer dun lment racine dans lequel les placer. La plupart des kits de dveloppement graphiques utilisent des gestionnaires de disposition des widgets (layout managers) qui sont, le plus souvent, organiss sous forme de conteneurs. Java Swing, par exemple, dispose du gestionnaire BoxLayout, qui est utilis avec certains conteneurs (comme Box). Dautres kits de dveloppement, comme XUL et Flex, sen tiennent strictement au modle des botes, qui permet de crer nimporte quelle disposition via une combinaison adquate de botes imbriques. Avec LinearLayout, Android offre galement un modle de disposition en botes, mais il fournit aussi un grand nombre de conteneurs autorisant dautres systmes de composition. Dans ce chapitre, nous tudierons trois conteneurs parmi les plus courants : LinearLayout (le modle des botes), RelativeLayout (un modle de positionnement relatif) et TableLayout (le modle en grille) ; nous prsenterons galement ScrollView, un conteneur conu pour faciliter la mise en place des conteneurs avec barres de dlement. Le chapitre suivant prsentera dautres conteneurs plus sotriques.

46


Penser de faon linaireComme on la dj mentionn, LinearLayout est un modle reposant sur des botes les widgets ou les conteneurs ls sont aligns en colonnes ou en lignes, les uns aprs les autres, exactement comme avec FlowLayout en Java Swing, et vbox et hbox en Flex et XUL. Avec Flex et XUL, la bote est lunit essentielle de disposition des widgets. Avec Android, vous pouvez utiliser LinearLayout exactement de la mme faon, en vous passant des autres conteneurs. Obtenir la disposition que vous souhaitez revient alors principalement identier les imbrications et les proprits des diffrentes botes leur alignement par rapport aux autres botes, par exemple.

Concepts et propritsPour congurer un LinearLayout, vous pouvez agir sur cinq paramtres : lorientation, le modle de remplissage, le poids, la gravit et le remplissage.

OrientationLorientation prcise si le LinearLayout reprsente une ligne ou une colonne. Il suft dajouter la proprit android:orientation llment LinearLayout du chier XML en xant sa valeur horizontal pour une ligne ou vertical pour une colonne. Cette orientation peut tre modie en cours dexcution en appelant la mthode setOrientation()et en lui fournissant en paramtre la constante HORIZONTAL ou VERTICAL.

Modle de remplissageSupposons que nous ayons une ligne de widgets une paire de boutons radio, par exemple. Ces widgets ont une taille "naturelle" reposant sur celle de leur texte. Ces tailles combines ne correspondent srement pas la largeur de lcran du terminal Android notamment parce que les tailles des crans varient en fonction des modles. Il faut donc savoir que faire de lespace restant. Pour rsoudre ce problme, tous les widgets dun LinearLayout doivent fournir une valeur pour les proprits android:layout_width et android:layout_height. Ces valeurs peuvent sexprimer de trois faons diffrentes :

Une dimension prcise, comme 125 px, pour indiquer que le widget devra occuper exactement 125 pixels. wrap_content, pour demander que le widget occupe sa place naturelle sauf sil est trop gros, auquel cas Android coupera le texte entre les mots pour quil puisse tenir. fill_parent, pour demander que le widget occupe tout lespace disponible de son conteneur aprs que les autres widgets eurent t placs.

Chapitre 7

Conteneurs

47

Les valeurs les plus utilises sont les deux dernires, car elles sont indpendantes de la taille de lcran ; Android peut donc ajuster la disposition pour quelle tienne dans lespace disponible.

PoidsQue se passera-t-il si deux widgets doivent se partager lespace disponible ? Supposons, par exemple, que nous ayons deux champs de saisie multilignes en colonne et que nous voulions quils occupent tout lespace disponible de la colonne aprs le placement de tous les autres widgets. Pour ce faire, en plus dinitialiser android:layout_width (pour les lignes) ou android:layout_height (pour les colonnes) avec fill_parent, il faut galement donner android:layout_weight, une valeur qui indique la proportion despace libre qui sera affecte au widget. Si cette valeur est la mme pour les deux widgets (1, par exemple), lespace libre sera partag quitablement entre eux. Si la valeur est 1 pour un widget et 2 pour lautre, le second utilisera deux fois plus despace libre que le premier, etc.

GravitPar dfaut, les widgets salignent partir de la gauche et du haut. Si vous crez une ligne avec un LinearLayout horizontal, cette ligne commencera donc se remplir partir du bord gauche de lcran. Si ce nest pas ce que vous souhaitez, vous devez indiquer une gravit laide de la proprit android:layout_gravity dun widget (ou en appelant la mthode setGravity() sur celui-ci) an dindiquer au widget et son conteneur comment laligner par rapport lcran. Pour une colonne de widgets, les gravits les plus courantes sont left, center_horizontal et right pour, respectivement, aligner les widgets gauche, au centre ou droite. Pour une ligne, le comportement par dfaut consiste placer les widgets de sorte que leur texte soit align sur la ligne de base (la ligne invisible sur laquelle les lettres semblent reposer), mais il est possible de prciser une gravit center_vertical pour centrer verticalement les widgets dans la ligne.

RemplissageLes widgets sont, par dfaut, serrs les uns contre les autres. Vous pouvez augmenter lespace intercalaire laide de la proprit android:padding (ou en appelant la mthode setPadding() de lobjet Java correspondant au widget). La valeur de remplissage prcise lespace situ entre le contour de la "cellule" du widget et son contenu rel. Elle est analogue aux marges dun document dans un traitement de texte

48


la taille de page peut tre de 21 29,7 cm, mais des marges de 2 cm connent le texte dans une surface de 19 27,7 cm. La proprit android:padding permet de prciser le mme remplissage pour les quatre cts du widget ; son contenu tant alors centr dans la zone qui reste. Pour utiliser des valeurs diffrentes en fonction des cts, utilisez les proprits android:paddingLeft, android:paddingRight, android:paddingTop et android:paddingBottom (voir Figure 7.1).Figure 7.1 Relations entre un widget, sa cellule et ses valeurs de remplissage.

La valeur de ces proprits est une dimension, comme 5px pour demander un remplissage de 5 pixels.

ExempleVoici le chier de description XML de lexemple Containers/Linear, qui montre les proprits de llment LinearLayout :

Vous remarquerez que le conteneur LinearLayout enveloppe deux RadioGroup. RadioGroup tant une sous-classe de LinearLayout, notre exemple revient donc imbriquer des conteneurs LinearLayout. Le premier lment RadioGroup congure une ligne (android:orientation = "horizontal") de widgets RadioButton. Il utilise un remplissage de 5 pixels sur ses quatre cts, an de le sparer de lautre RadioGroup. Sa largeur et sa hauteur valent toutes les deux wrap_content pour que les boutons radio noccupent que lespace dont ils ont besoin. Le deuxime RadioGroup est une colonne (android:orientation = "vertical") de trois RadioButton. Il utilise galement un remplissage de 5 pixels sur tous ses cts et sa hauteur est "naturelle" (android:layout_height = "wrap_content"). Cependant, sa proprit android:layout_width vaut fill_parent, ce qui signie que la colonne de boutons radio "rclamera" toute la largeur de lcran. Pour ajuster ces valeurs en cours dexcution en fonction de la saisie de lutilisateur, il faut utiliser un peu de code Java :package com.commonsware.android.containers; import android.app.Activity; import android.os.Bundle; import android.view.Gravity;

50


import android.text.TextWatcher; import android.widget.LinearLayout; import android.widget.RadioGroup; import android.widget.EditText; public class LinearLayoutDemo extends Activity implements RadioGroup.OnCheckedChangeListener { RadioGroup orientation; RadioGroup gravity; @Override public void onCreate(Bundle icicle) { super.onCreate(icicle); setContentView(R.layout.main); orientation=(RadioGroup)findViewById(R.id.orientation); orientation.setOnC

l art du developpement android

Documents