Développement sous Android
Chapitres traités
Architecture générale d'AndroidAndroid est une plateforme ouverte pour le développement de mobiles (smartphones). C'est la première plateforme pour appareils mobiles qui soit réellement ouverte et complète avec tout le logiciel nécessaire au fonctionnement d'un téléphone mobile mais sans les obstacles propriétaires qui ont entravé l'innovation sur ces derniers.
Le nom Android est le nom donné à la pile applicative conçue par Google et spécialement optimisée pour les appareils contraints.
Les terminaux mobiles étant sévèrement contraints par leur faible puissance de calcul, une autonomie en énergie réduite, des mécanismes de saisie limités (surface d'affichage faible, interfaçage entre l'homme et la machine peu évolué, etc.) ou des capacités mémoires restreintes, Android s'avère parfaitement conçu pour cette utilisation.
Aujourd'hui, Android est principalement utilisé dans les téléphones portables. Ceci dit, la philosophie du système d'exploitation étant de s'abstraire au maximum du matériel sur lequel il tourne (type de processeur, taille d'écran, capteurs, etc.), il se retrouve dans des environnements totalement variés : les téléphones mobiles bien sûr, mais également les tablettes, les netbooks, les GPS, les lecteurs multimédias ou mêmes les télévisions, boxes internet et autres appareils mobiles.
Pour programmer des applications Android, vous devez au moins connaître les bases de Java. En effet, la programmation Android utilise la syntaxe de ce langage, plus une bibliothèque de classes s'apparentant à un sous-ensemble de la bibliothèque de Java SE (avec des extensions spécifiques). Si vous n'avez jamais programmé en Java, initiez-vous à ce langage avant de vous plonger dans la programmation Android.
Architecture générale d'Android
Contrairement à une idée reçue (probablement due à l'utilisation du terme abusif "Android" pour désigner le framework), cette pile logicielle n'est pas seulement composée d'applications et d'un framework de développement. Android est en réalité un ensemble de technologies, qui prennent leur départ depuis le système d'exploitation pour finir dans les applications disponibles pour les utilisateurs. Présenté simplement, Android est une combinaison de trois composants :
1. Un système d'exploitation open-source libre pour les appareils mobiles.
2. Une plateforme de développement open-source pour la création d'applications pour mobiles.
3. Des équipements, en particulier des téléphones portables, exécutant le système d'exploitation Android ainsi que les applications développées pour lui.
Plus précisément, Android est constitué de plusieurs parties dépendantes et nécessaires.
1. Un modèle de conception matérielle de référence décrivant les capacités nécessaires à un appareil mobile pour supporter la pile logicielle.
2. Un système d'exploitation Linux assurant l'interface de bas-niveau avec le matériel, la gestion de la mémoire et le contrôle des processus, le tout optimisé pour les appareils mobiles.
3. Des bibliothèques open-source pour le développement d'application, comme SQLite, Webkit, OpenGL ainsi qu'un gestionnaire de médias.
4. Un moteur d'exécution et d'hébergement des applications d'Android incluant la machine virtuelle Dalvik et les bibliothèques de base fournissant les fonctionnalités spécifiques à Android. Ce moteur est conçu avec un soucis de compacité et d'efficacité pour un usage sur des appareils mobiles.
5. Un framework applicatif qui expose de façon agnostique les services du système à la couche applicative, comme le Window Manager (gestionnaire de fenêtrage) et le Location Manager (gestionnaire de géolocalisation), les Content Providers (gestionnaires de contenu), la téléphonie et les capteurs.
6. Un framework pour l'interface utilisateur utilisé pour héberger et lancer les applications.
7. Des applications préinstallées et faisant partie de la pile.
8. Un kit de développement logiciel utilisé pour créer les applications et comprenant des outils, des plugins et de la documentation.
Les applications
Android est fourni avec un ensemble de programmes de base (également nommés applications natives) permettant d'accéder à des fonctionnalités comme les courriels, les SMS, le téléphone, le calendrier, les photos, les cartes géographiques, le Web, etc.
Ces applications sont développées à l'aide du langage de programmation Java. Pour l'utilisateur final, c'est la seule couche accessible et visible. Il est bien sûr possible d'installer des applications tierces de provenance variées : Android Market, site Internet et, bien sûr, directement par le biais de votre ordinateur (sujet de notre étude).
La composition exacte des applications disponibles sur les nouveaux téléphones Android peut varier selon les fabriquants ou les opérateurs. Le fait qu'Android soit open-source signifie que les opérateurs peuvent personnaliser l'interface utilisateur et les applications fournies avec l'appareil Android.
Il est important de noter que, pour les appareils compatibles, la plateforme sous-jacente et le SDK restent cohérents entre les variations des fabriquants ou des opérateurs. L'apparence de l'interface utilisateur peut varier mais vos applications fonctionnereont de la même façon sur tous les appareils Android.
Les bibliothèques
En interne, Android inclut un ensemble de bibliothèques C et C++ utilisées par de nombreux composants de la plateforme Android. Ces bibliothèques sont en réalité accessibles au développeur par l'intermédiaire de framework Android.
En effet, le framework Android effectue, de façon interne, des appels à des fonctions C/C++ beaucoup plus rapides à exécuter que des méthodes Java standard.
La technologie Java Native Interface (JNI) permet d'effectuer des échanges entre le code Java et le code C et C++.
Le framework et le SDK d'Android
Android permet aux développeur de créer leurs propres applications. Pour ce faire; les programmeurs ont accès aux mêmes API que celles utilisées par les applications natives d'Android. C'est à ce niveau de l'architecture que nous allons travailler lors de cette étude. L'intérêt principal d'Android comme environnement de développement réside dans les API fournies.
En tant que plateforme neutre, Android vous donne la possibilité de créer des applications qui seront intégrées au téléphone autant que celles fournies nativement. La liste qui suit met en lumière les fonctionnalités d'Android les plus notables.
1. Aucun frais de licence, distribution ou développement et aucun processus d'approbation préalable à la distribution d'applications.
2. Accès au matériel WI-FI.
3. Réseaux GSM, EDGE et 3G pour la téléphonie et le transfert de données, vous permettant de passer ou de recevoir des appels ou des SMS et d'envoyer ou de recevoir des données sur les réseaux mobiles.
4. API complètes pour les services de géolocalisation comme le GPS.
5. Contrôle complet du matériel multimédia, y compris la lecture et l'enregistrement vidéo ou sonore.
6. API pour l'utilisation des capteurs comme l'accéléromètre et la boussole.
7. Bibliothèque Bluetooth pour le transfert de données local.
8. Passage de message par IPC.
9. Partage des données stockées.
10. Applications et processus en arrière-plan.
11. Widgets d'écran d'accueil, Live Folders (dossiers dynamiques) et Live Wallpaper (papier peint dynamique).
12. Possibilté d'intégrer les résultats de recherche d'une application dans le système de recherche.
13. Nagigateur open-source HTML5 basé sur Webkit.
14. Support complet des applications intégrant une interaction utilisateur par le biais de cartes géographiques.
15. Graphiques s'appuyant sur l'accélération matérielle et optimisés pour les mobiles, incluant une bibliothèque de graphisme 2D ainsi que le support des graphismes 3D avec OpenGL ES 2.0.
16. Bibliothèques multimédias pour l'exécution et l'enregistrement de différents formats audio et vidéo ou d'images fixes.
17. Framework applicatif encourageant la réutilisation de composants et le remplacement des applications natives.
Accès au matériel, y compris appareil photo, GPS et accéléromètre
Android comprend des bibliothèques d'API simplifiant le développement relatif aux composants matériels. Ceci grantit que vous n'aurez pas besoin de créer des implémentations spécifiques de votre logiciel pour des appariels différents et que vous pourrez donc créer des applications Android fonctionnant sur n'importe quel appareil supportant la pile logicielle Android.
Le SDK Android inclut des API pour le matériel de géolocalisation (comme le GPS), l'appareil photo, les composants audio, les connexions réseau, le WI-FI, Bluetooth, les accéléromètres, l'écran tactile et la gestion de l'alimentation.
Service natifs Google Maps de géocodage et géolocalisation
Le support natif des cartes permet de créer un éventail d'applications s'appuyant sur la mobilité des appareils Android. Android permet la création d'activités incluant des cartes interactives Google au sein de l'interface utilisateur avec un accès complet à ces cartes, contrôlables par programme et supportant les annotations grâce aux bibliothèques graphiques complètes d'Android.
Les services de géolocalisation Android gèrent des technologies comme le GPS ou la technologie GSM cellulaire Google pour déterminer la position courante de l'appareil. Ces services s'abstraient de la technologie spécifique de localisation plutôt que choisir une technologie particulière. Ils impliquent également que vos applications basées sur la géolocalisation fonctionneront quelle que soit la technologie supportée par le télephone.
Afin de combiner cartes et géolocalisation, Android inclut une API de géocodage et de géocodage inverse permettant de déterminer des coordonnées géographiques à partir d'une adresse et inversement.
Services d'arriere-plan
Android supporte les applications et services s'exécutant de façon invisible en tâche de fond. Les appareils modernes sont par nature des appareils multifonctions.
Cependant, leurs écrans de taille limités font qu'une seule application peut généralement être visible à un moment donné.
Les services d'arrière-plan permettent de créer des composants applicatifs invisibles exécutant des traitements automatiques sans action de l'utilisateur.
L'exécution en tâche de fond autorise vos applications à être pilotées par des événements et à supporter des mises à jour régulières, ce qui est parfait pour surveiller des scores de jeux, pour générer des alertes de géolocalisation ou pour donner la priorité à des appels entrants ou à des SMS afin de les visualiser.
Base de données SQLite pour le stockage et l'extraction de données
Un stockage et une extraction de données rapides et efficace sont essentiels sur des appareils dont la capacité de stockage est limitée du fait de leur nature compacte.
Android fournit une base de données relationnelle légère à chaque application utilisant SQLite. Vos applications peuvent tirer profit de ce moteur de base de données pour stocker des données de manière sûre et efficace.
Par défaut, la base de données de chaque application est confinée, ce qui signifie que son contenu n'est accessible qu'à l'application qui l'a créée, mais les Content Providers fournissent un mécanisme permettant de gérer le partage de cette base.
Données partagées et communication interapplications
Android inclut trois techniques permettant de transmettre des informations depuis vos applicatiosn afin de les utiliser ailleurs : les Notifications, les Intents et les Content Providers.
1. Les Notifications sont les moyen standard par lesquels un appareil mobile alerte traditionnellement les utilisateurs. A l'aide de l'API, vous pourrez déclencher des alertes sonores, provoquer une vibration ou faire clignoter la diode de l'appareil ainsi que contrôler les icônes de notification de la barre de statut.
2. Les Intents fournissent un mécanisme de passage de message dans et entre des applications. Vous pourrez à l'aide d'Intents diffuser l'action souhaitée (émission d'un appel ou l'édition d'un contact par exemple) au sein du système afin que d'autres applicationsla prennent en charge.
3. Les Content providers donnent un accès contrôlé aux bases de données privées de vos applications. Les données stockées par les applications natives, comme le gestionnaire de contacts, sont exposées comme des Content providers et vous pouvez donc créer vos propres applications pour lire et modifier ces données.
Utilisation des widgets, des Live Folders et du Live Wallpaper pour améliorer l'écran d'accueil
Les widgets, les Live Folders et le Live Wallpaper permettent de créer des composants applicatifs dynamiques ouvrant une fenêtre vers vos applications ou offrant une information utile et opportune directement sur l'écran d'accueil.
Si vous donnez la possibilité aux utilisateurs d'interagir avec vos applications directement depuis l'écran d'accueil, ils pourront accéder instantanément à des informations intéressantes sans pour autant devoir ouvrir une application qui sera ainsi accessible par un raccourci dynamique.
Support multimédia étendu et graphiques 2D/3D
De pus grands écrans ainsi que des affichages lumineux et en haute résolution ont permis de transformer les mobiles en dispositifs multimédias. Pour vous permettre de tirer parti au maximum du matériel disponible, Android fournit des bibliothèques graphiques pour les dessins 2D ainsi que les graphiques 3D avec OpenGL.
Android offre également des bibliothèques complètes de gestion des images fixes, des vidéos et des fichiers audio, y compris les formats MPEG4, H.264, MP3, AAC, AMR, JPG, PNG et GIF.
Mémoire optimisée et gestion des processus
La gestion de la mémoire et des processus sous Android est quelque peu inhabituelle. Tout comme Java et .NET, Android utilise son propre moteur d'exécution et sa propre machine virtuelle pour gérer la mémoire d'une application. Mais contrairement à ces deux framework, le moteur d'exécution d'Android gère également les durées de vie des processus.
Android garantit la réactivité des applications en stoppant et en tuant les processus lorsqu'il est nécessaire de libérer des ressources pour les applications de priorité plus élevée.
Dans ce contexte, la plus haute priorité est donnée à l'application avec laquelle l'utilisateur est en train d'interagir. S'assurer que vos applications sont prêtes pour une fin d'exécution rapide tout en restant capable de réagir, et les mettre à jour ou les redémarrer en arrière-plan si nécessaire, est à prendre attentivement en compte dans un environnement qui ne permet pas à celles-ci de contrôler leur propre durée de vie.
Le moteur d'exécution d'Android - La machine virtuelle Dalvik
Chaque application Android tourne dans son propre processus et avec sa propre instance de machine virtuelle Dalvik. Dalvik est une implémentation de machine virtuelle ayant été conçue pour optimiser l'exécution multiple de machines virtuelles. Elle exécute du bytecode qui lui est dédié : le bytecode dex.
Cette particularité d'Android en fait un système unique, loin des systèmes Linux traditionnels que beaucoup avaient pu rencontrer auparavant. L'un des éléments clés d'Android est constitué par cette machine virtuelle Dalvik. Au lieu d'utiliser une JVM classique comme Java ME (Java Mobile Edition), Android utilise sa propre VM spécifique, conçue pour garantir que des instances multiples seront efficacement exécutées sur un appareil.
La machine Dalvik utilise le noyau Linux sous-jacent de l'appareil pour gérer les fonctionnalités de bas-niveau y compris la sécurité, le threading et la gestion de processus et de la mémoire.
Il est également possible d'écrire des applications en C/C++ exécutées directement par le système d'exploitation Linux. Bien que vous puissiez le faire, ce ne sera pas nécessaire dans la plupart des cas. Si la vitesse et l'efficacité de C/C++ sont requises pour votre application, Android fournit maintenant un kit de développement natif (NDK). Ce NDK est conçu pour vous permettre de créer des bibliothèques C++ à l'aide des bibliothèques libc et libm et vus donner un accès natif à OpenGL.
Tous les matériels et services système Android sont gérés à l'aide de Dalvik. En utilisant une machine virtuelle pour exécuter une application, les développeurs ont accès à une couche d'abstraction qui garantit qu'ils n'auront jamais à se préoccuper d'une implémentation matérielle particulière.
La machine virtuelle Dalvik exécute des fichiers exécutables Dalvik, un format optimisé pour garantir une empreinte mémoire minimale. Vous créerez des exécutables .dex en transformant des classes Java compilées à l'aide des outils fournis dans le SDK.
Outils de développement
Après toutes ces considérations théoriques, je vous propose maintenant de connaître tous les outils nécessaires à l'élaboration des différents projets que nous allons mettre en oeuvre sous Android. Pour réaliser tous ces projets vous avez besoin :
1. SDK Android : http://developer.android.com/sdk/index.html : Ce SDK inclut toutes les bibliothèques Android, la documentation complète ainsi que d'excellents exemples d'applications. Il inclut également des outils d'aide à l'écriture et au débogage d'applications comme L'Android Emulator pour exécuter vos projets et le DDMS (Dalvik Debug Monitoring Service) pour vous aider à les déboguer.
2. JDK Java SE : http://java.sun.com/javase/downloads/index.jsp : Le code Android est écrit en Java et les bibliothèques Android incluent la plupart des caractéristiques des API de Java de base. Avant qu'ils ne puissent s'exécuter, vos projets devront cependant être traduits en bytecode Dalvik. Vous profitez donc des bénéfices de Java, alors que vos applications sont exécutées par une machine virtuelle optimisée pour les appareils mobiles.
3. Netbeans : http://netbeans.org/downloads/index.html : A moins que vous ne soyez masochiste, vous utiliserez un IDE Java pour simplifier vos développements. C'est très souvent Eclipse qui est sité en premier lieu. Pour ma part, je préfère largement utiliser Netbeans.
développements. C'est très souvent Eclipse qui est sité en premier lieu. Pour ma part, je préfère largement utiliser Netbeans.
4. Plugin Netbeans : http://kenai.com/projects/nbandroid/downloads : Le plugin nbandroid pour Netbeans simplifie vos développements Android en intégrant les outils de développement y compris l'émulateur et le convertisseur .class-to-.dex directement dans l'IDE. Bien que le plugin nbandroid ne soit pas indispensable, il simplifie et accélère la création, les tests et le débogage de vos applications. Si vous n'avez pas Internet, voici la version 1.7 de ce plugin.
Les applications Android étant exécutées par la machine virtuelle Dalvik, vous pourrez les écrire sur n'importe quelle plateforme supportant les outils de développement, c'est-à-dire : Linux, Mac OS X et Windows.
Installation du SDK
Le SDK Android est complètement ouvert. Il n'y a aucun frais de téléchragement ou d'utilisation des API et Google ne facture ni ne contrôle la distribution de vos programmes sur Android Marquet.
Le SDK se présente sous la forme d'un fichier ZIP contenant uniquement la dernière version des outils de développement Android. Pour Windows, il est maintenant préférable de télécharger directement l'installateur avec l'extension .exe. Pour les autres plateformes, installez-le en décompressant le fichier dans un nouveau dossier. Notez l'emplacement, vous en aurez besoin plus tard.
Afin de gérer au mieux la variété des versions des systèmes d'exploitation, de SDK et de terminaux, un outil, Android SDK and AVD Manager, a été mis en place.
Ce petit utilitaire permet de récupérer les différentes entités nécessaires au développement sur Android :
Effectivement, avant de pouvoir commencer à développer, vous devez ajouter au moins une plateforme SDK grâce à ce petit utilitaire. Exécutez sous Windows l'exécutable SDK Setup ou sous Mac OS ou Linux l'exécutable android, situé dans le sous-dossier tools. Sélectionnez dans la partie gauche Available packages puis dans la partie droit Sites, packages and archives les versions de plateforme SDK que vous suohitez installer.
Les plateformes sélectionnées seront téléchargées dans le dossier d'installation de votre SDK. Elles contiendront les bibliothèques d'API, la documentation et plusieurs exemples d'applications.
Android Virtual Device et Emulator Android
L'AVD (Android Virtual Device) est utilisé pour simuler les versions de logiciel et les spécifications de matériels disponibles sur différents appareils. Vous pouvez ainsi tester votre application sur plusieurs plateformes matérielles sans avoir à acheter les téléphones correspondants.
Le SDK Android n'inclut aucun appareil virtuel préconfiguré et vous devrez en créer au moins un avant de pouvoir acheter les téléphones correspondant.
Nous l'avons déjà vu, Android cible un très large ensemble de terminaux. Afin de gérer au mieux cette diversité, Google a développé un système permettant d'émuler un large panel de terminaux. Un AVD est, en réalité, un terminal virtuel disposant de plusieurs propriétés qui lui sont propres : taille d'écran, version du système, présence ou non d'une carte SD, etc.
Lorsque l'émulateur démarre, il utilise un AVD et s'adapte aux différentes propriétés de ce dernier. Lorsque nous débutons le développement sur Android, il peut être nécessaire de créer plusieurs AVD (notamment pour les développeurs ne disposant pas de terminal Android.
L'émulateur est le parfait outil de test et de débogage de vos applications. Il est une implémentation de la machine virtuelle Dalvik, faisant de celle-ci une plateforme exécutant les applications Android comme le ferait n'importe quel téléphone Android. Etant découplé de tout matériel, c'est une excellente base de test de vos applications.
L'émulateur n'implémente pas encore toutes les caractéristiques des matériels mobiles supportées par Android. Ne sont pas disponibles : l'appareil photo, le vibreur, les diodes, les appels téléphoniques réels, l'accéléromètre, les connexions USB, l'enregistrement audio et le niveau de charge de la batterie.
Installation du plugin de Netbeans
Pour développer nos applications Android, nous allons nous servir de l'IDE Netbeans. Afin que cet environnement de développement soit capable de générer automatiquement des projets pour Android, il est nécessaire d'installer le plugin correspondant, nommé nbandroid.
Ce plugin est en rélité une archive ZIP qu'il suffit de décompresser à l'endroit voulu. Cette archive dispose d'un certain nombre de fichiers de type nbm qui sont interprété par Netbeans comme un ensemble de plugins :
1. Pour ajouter le plugin nbandroid, il suffit de sélectionner la rubrique Plug-ins du menu Outils :
2. Dans la boîte de dialogue correspondante, choisissez l'onglet Téléchargés et cliquez sur le bouton Ajouter des Plug-ins. Spécifiez ensuite le répertoire où se situe la décompression de l'archive nbandroid-1.7.zip :
Création et lancement d'un projet Android sous Netbeans
Une fois que le plugin est correctement installé, vous pouvez maintenant construire de nouveaux projets prévus spécifiquement pour Android et de les exécuter directement sur le vrai téléphone ou avec l'émulateur en choisissant l'AVD qui vous intéresse. Voici la procédure à suivre :
1. Cliquez sur l'icône habituelle correspondant à la création d'un nouveau projet et sélectionnez le type de projet :
2. Dans la deuxième étape de cette boîte de dialogue, vous devez spécifier le nom de votre projet, de l'activité (voir au chapitre suivant), la version du système d'exploitation utilisé par votre mobile.
Attention, le nom du paquetage est particulier puisqu'il correspond à l'identifiant de votre application. Cet identifiant doit être unique, notamment si vous souhaitez envoyer votre application sur l'Android Marquet. Il est de coutume de représenter le paquetage de base sous la forme code_pays.nom_de_société.nom_du_produit.
3. Il suffit de compléter le code source de votre activité, de générer vos layout, etc.
4. Une fois que votre projet est constitué, vous pouvez l'exécuter soit directement sur votre mobile ou de prendre la version émulée :
5. Pour que votre mobile accepte le déploiement de votre application, il faut le régler en conséquence. Pour cela, dans le menu Paramètres, sélectionner successivement Applications suivi de Développement et cocher ensuite toutes les cases concernées.
Contenu d'un programme Android
Le développeur d'une application classique est "le seul maître à bord". Il peut ouvrir la fenêtre principale de son programme, ses fenêtres filles, les boîtes de dialogue,
comme il le souhaite. De son point de vue, il est seul au monde ; il tire parti des fonctionnalités du système d'exploitation mais ne s'occupe pas des autres programmes susceptibles de s'exécuter en même temps que son programme. S'il doit interagir avec d'autres applications, il passe généralement par une API, comme JDBC ou via des sockets.
Android utilise les mêmes concepts, mais proposés de façon différente, avec une structure permettant de mieux protéger le fonctionnement des téléphones. Les applications Android sont constituées de composant à fort couplage, liés par un manifeste d'applications qui décrit chacun d'eux et comment ils interagissent ainsi que les métadonnées de l'application, y compris ses exigences en matière de plateforme et de matériel. Les septs composants suivants sont les briques de vos applications :
1. Les activités : Activites : Ce sont les briques de base de l'interface utilisateur. Vous pouvez considérer une activité comme l'équivalent Android de la fenêtre ou de la boîte de dialogue d'une application classique. Bien que les activités puissent ne pas avoir d'interface utilisateur, un code "invisible" sera délivré le plus souvent sous la forme de fournisseur de contenus (content provider) ou de service.
C'est la généralement la couche présentation de votre application. Chaque écran est une extension de la classe Activity. Les activités utilisent les Views pour former les interfaces utilisateur graphiques qui afficheront l'information et répondront aux actions.
2. Les fournisseurs de contenu : Content Providers : Ils offrent un niveau d'abstraction pour toutes les données stockées sur le terminal et accessibles aux différentes applications.
Sources de données partageable. Les fournisseurs de contenu servent à gérer et à partager les bases de données des applications. Ils sont le moyen privilégié de partager des données entre applications. Cela signifie que vous pouvez configurer vos propres fournisseurs de contenu pour autoriser l'accès à d'autres applications et utiliser ceux qu'elles exposent. Les appareils Android comptent plusieurs fournisseurs de contenu natifs qui exposent les bases de données très utiles comme les médias ou les contacts.
3. Les services : Les activités et les fournisseurs de contenus ont une durée de vie limitée et peuvent être éteints à tout moment. Les services sont en revanche conçus pour durer et, si nécessaire, indépendamment de toute activité. Vous pouvez, par exemple, utiliser un service pour vérifier les mises à jour d'un flux RSS ou pour jouer de la musique, même si l'activité de contrôle n'est plus en cours d'exécution.
Travailleurs de l'ombre. Ces composants tournent en arrière-plan, mettent à jour vos sources de données ainsi que les activités visibles et déclenchent des notifications. Ils servent à exécuter des traitements continus même lorsque les activités de vos applications ne sont pas actives ou visibles.
4. Les intensions : Intents : Ce sont des messages système émis par le terminal pour prévénir les applications de la survenue de différents événements, que ce soit une modification matérielle (comme l'insertion d'une carte SD) ou l'arrivée de données (telle la réception d'un SMS), en passant par les événements des applications elles-mêmes (votre activité a été lancée à partir du menu principal du terminal, par exemple). Vous pouvez non seulement répondre aux intensions, mais également créer les vôtres afin de lancer d'autres activités ou pour vous prévenir qu'une situation particulière a lieu (vous pouvez, par exemple, émettre l'intension X lorsque l'utilisateur est à moins de 100 mètres d'un emplacement Y).
Framework de communication interapplications. Les intensions servent à diffuser des messages au sein du système ou à destination d'une activité ou d'un service cible, indiquant l'intension d'exécuter une action. Le système détermine alors la ou les cibles qui effectuerons l'action.
5. Les consommateurs de messages : Broadcast Receivers : Consommateurs des messages diffusés par les intensions. Si vous créez et enregistrer un Broadcast Receiver, votre application pourra écouter les diffusions des intensions répondant à certains critères spécifiques de filtre. Les consommateurs de messages démarreront automatiquement votre application pour répondre à une intension entrant et sont donc parfait pour créer des applications basées sur des événements.
6. Composants d'application visuels : Widgets : Les composants d'applications visuels peuvent ajoutés à l'écran d'accueil. Les widgets, qui sont une variant particulière des consommateurs de messages, permettent de créer des composants interactifs et dynamiques incorporables dans l'écran d'accueil.
7. Les notifications : Framework de notifications aux utilisateurs. Les notifications permettent d'envoyer un signal aux utilisateurs sans dérober le focus ni interrompre leurs activités en cours. Elles sont le moyen privilégié d'attirer l'attention de l'uilisateur à partir d'un service ou d'un consommateur de messages.
Lorsqu'un appareil reçoit par exemple un message texte ou un appel entrant, il vous alerte en clignotant, en émettant un son, en affichant une icône ou un message. Vous pouvez déclencher les mêmes événements depuis vos applications à l'aide des notifications.
En découplant les composants applicatifs, vous pourrez par exemple partager et échanger les fournisseurs de contenu, les services et mêmes les activitées avec d'autres applications, les vôtres comme celles de tiers.
Permissions
Certaines opérations sont réalisables à condition d'en obtenir la permission. Ces actions sont de plusieurs formes :
1. opérations pouvant entraîner un surcoût (connexion, échnage de données, envoi de SMS par exemple) ;
2. utilisation de données personnelles (accès à vos contacts, à votre compte Google, exploitation de vos informations linguistiques entre autres) ; 3. accès au matériel du téléphone (prise de clichés, écriture sur la carte mémoire ... ).
Si vous utilisez les fonctionnalités liées à de telles permissions, vous devrez déclarer leur utilisationdans le fichier de configuration qui décrit l'application. A l'installation de votre application, l'utilisateur disposera d'un récapitulatif de toutes les permissions demandées poiur que l'application fonctionne. Il pourra alors choisir de continuer ou d'interrompre l'installation en connaissance de cause.
Création et structure d'un projet Android
Après toutes ces considérations techniques, nous allons maintenant rentrer dans le vif du sujet et développer une application Android. Bien entendu, pour notre première application, nous allons réaliser une activité rudimentaire qui consiste à afficher un simple bouton dont l'intitulé change après chaque clic et qui indique l'heure actuelle du jour.
Structure d'un projet
Le système de construction d'un programme Android est organisé sous la forme d'une arborescence de répertoires associé au projet, exactement comme n'importe quel projet Java. Les détails, cependant, sont spécifiques à Android. Lorsque vous créez un projet Android, plusieurs éléments sont placés dans le répertoire racine du projet :
1. AndroidManifest.xml : est un fichier XML qui décrit l'application à construire et les composants la constituant - activités, services, etc.
2. build.xml : est un script Ant permettant de compiler l'application et de l'installer sur le terminal.
3. default.properties et local.properties : sont les fichiers de propriétés utilisés durant la phase de compilation en respectant le script précédent.
4. assets : répertoire qui contient toutes les ressources brutes (raw bytes) ne nécessitant aucun traitement par Android. A la différence des ressources placées dans le répertoire res, les ressources brutes seront accessibles grâce à un flux de données et non grâce à la classe R décrite plus loin.
5. bin : répertoire qui contient l'ensemble de l'application compilée.
6. gen : répertoire qui contient les sources automatiquement produit par les outils de compilation d'Android afin d'assister le développeur. Si vous supprimer un fichier dans ce répertoire, les outils d'Android s'empresseront aussitôt de le régénérer.
Attention, si le projet contient des erreurs ne permettant pas de compilation, aucun fichier ne sera généré. Par conséquent, si effectivement vous ne trouvez pas pas la bonne version de fichier ou s'il n'est pas généré automatiquement, vérifiez bien que l'ensemble du projet compile correctement.
7. libs : répertoire qui contient les bibliothèques tierces qui sont nécessaires à l'application.
8. src : répertoire qui contient l'ensemble des sources du projet. C'est essentiellement dans ce répertoire que vous allez ajouter et modifier le code source de l'application.
9. res : répertoire qui contient les ressources telles que les images, les icônes, les dispositions de l'interface graphique (layouts), etc. Ces ressources seront assemblées avec le code Java compilé et seront accessibles au moyen d'une classe R également autogénérée.
Tout cela parait bien compliqué, mais dans la pratique, c'est très simple. Nous allons nous renseigner progressivement sur chacun de ces points. Sachez toutefois que grâce à Netbeans et son plugin pour Android, tous ces éléments sont automatiquement générés avec des valeurs par défaut. Dans notre premier projet, seule l'activité est à modifier.
Nous allons mettre en place notre projet à l'aide de Netbeans. Nous nommons ce projet Heure, sachant que vous devez spécifier le paquetage suivant les critères que nous avons évoqué plus haut, donc ici fr.manu.heure.
Lorsque vous créez un nouveau projet, vous constaterez alors que l'arborescence src contient le hiérarchie des répertoires définis par le paquetage
ainsi que le squelette de la classe que vous avez choisi, qui est une sous-classe d'Activity représentant l'activité principale de votre application, comme ci-dessous :
(exemple de squelette) fr.manu.heure.NouvelleActivité
package fr.manu.heure;
import android.app.Activity;
import android.os.Bundle;
public class NouvelleActivité extends Activity { /** Called when the activity is first created. */
@Override
public void onCreate(Bundle icicle) { super.onCreate(icicle);
// ToDo add your GUI initialization code here }
}
Vous pouvez bien sûr modifier ce fichier, comme nous l'avons fait dans l'image globale du projet, et même en ajouter d'autres à l'arborescence src selon les besoins de votre application.
La première fois que vous compilerez le projet, la chaîne de production d'Android créera automatiquement le fichier R.java dans le paquetage de l'activité "principale". Ce fichier contient un certain nombre de définitions de constantes liées aux différentes ressources mise en oeuvre dans l'arborescence res.
fr.manu.heure.R.java
/* AUTO-GENERATED FILE. DO NOT MODIFY.
*
* This class was automatically generated by the * aapt tool from the resource data it found. It * should not be modified by hand.
*/
package fr.manu.heure;
public final class R {
public static final class attr { }
public static final class drawable { public static final int icon=0x7f020000;
}
public static final class layout {
public static final int main=0x7f030000;
}
public static final class string {
public static final int app_name=0x7f040000;
} }
Lors de nos différents projets, nous rencontrerons de nombreuses références à cette classe particulière. Par exemple, nous désignerons l'identifiant de la couche présentation principale (la vue) d'un projet à l'aide de l'écriture suivant : R.layout.main. Attention, comme cela est précisé dans le source, ne modifier pas R.java vous même, laissez les outils d'Android le faire pour vous.
Les ressources
Comme nous l'avons déjà indiqué, le répertoire res contient les ressources, c'est-à-dire des fichiers statiques fournis avec l'application, soit sous forme initiale soit, parfois, sous une forme prétraitée. Parmi les sous-répertoire de res, citons :
1. res/drawable : ce dossier contient l'ensemble des ressources graphiques mise en oeuvre dans le cadre de votre projet, des images (PNG, JPEG, etc.) ou des vidéos.
2. res/layout : ce dossier contient les fichiers décrivant la composition des interfaces (les vues) de l'application, décrites en format XML . 3. res/menu : ce dossier contient la description XML des menus de l'application.
4. res/raw : ce dossier contient les ressources autres que celles décrites ci-dessus qui seront empaquetées sans aucun traitement spécifique.
5. res/values : ce dossier contient des messages, des dimensions, les couleurs, etc. prédéfinis qui sont très facile de modifier par la suite. Cela permet de découpler le code principal des différents réglages et interventions utltérieures possibles.
6. res/xml : ce dossier contient les autres fichiers XML généraux que vous souhaitez soumettre.
Nous présenterons l'utilité de ces différents répertoires, et bien d'autres, dans la suite de cette étude. Ces différentes ressources sont pris en compte grâce à la classe R que nous venons de décrire au moyen d'une référence particulière à chacune d'entre elle.
Résultat de la compilation
Lorsque vous compilez un projet, le résultat est placé dans le répertoire bin, sous la racine de l'arborescence du projet :
1. bin/classes : contient toutes les classes Java compilées de votre application.
2. bin/classes.dex : contient l'exécutable créé à partir de ces classes compilées. C'est cet exécutable qui est lancé à partir de la machine virtuelle Dalvik.
3. bin/votre_application.ap_ : contient les ressources complètes de votre application, sous la forme d'un fichier ZIP.
4. bin/votre_application-debug.apk ou bin/votre_application-unsigned.apk : est la véritable application Android déployable sur votre mobile.
Le fichier .apk est une archive ZIP contenant le fichier .dex, la version compilée des ressources (resources.arsc), les éventuelles ressources non compilées (celles qui se trouvent sous res/raw, par exemple) et le fichier AndroidManifest.xml. Cette archive est signée : la partie - debug du nom du fichier indique qu'elle l'a été à l'aide d'une clé de débogage qui fonctionne avec l'émulateur alors que -unsigned précise que l'application a été construite pour être déployée : l'archive APK doit alors être signée à l'aide de jarsigner et d'une clé officielle.
Constitution d'une application Android
Nous venons de passer pas mal de temps sur la structure d'un projet Android découvert notamment au travers de Netbeans. Nous allons définir maintenant et résumer une partie de nos connaissances sur ce qu'est une application Android.
Une application Android est un assemblage de composants liés grâce à un fichier de configuration. Nous allons découvrir chaque pièce de notre puzzle applicatif, comment le fichier de configuration de l'application la décrit et comment toutes les pièces interagissent entre elles. Avant de rentrer dans le détail d'une application Android et de son projet associé, nous allons revenir sur différents concepts fondamentaux :
1. Les activités : une activité peut être assimilé à un écran structuré par un ensemble de vues et de contrôles composant son interface de façon logique
; elle est composée d'une hiérarchie de vues contenant elles-mêmes d'autres vues. Une activité est, par exemple, un formulaire d'ajout de contacts ou encore un plan Google Maps sur lequel vous ajoutez de l'information. Une application comportant plusieurs écrans, possèdera donc autant d'activités.
2. Les vues (et leur mise en page) : Les vues sont les éléments de l'interface graphique que l'utilisateur voit et sur lesquels il pourra agir. Les vues contiennent des composants, organisés selon diverses mises en page (les uns à la suite des autres, en grille ...).
3. Les contrôles : les contrôles (boutons, champs de saisie, case à cocher, etc.) sont eux-même un sous-ensemble des vues. Ils ont besoin d'accéder aux textes et aux images qu'ils affichent (par exemple, un bouton représentant un téléphone aura besoin de l'image du téléphone correspondante). Ces textes et ces images seront puisés dans les fichiers ressources de l'application.
4. Les ressources : Comme nous l'avons déjà indiqué, le répertoire res contient les ressources, c'est-à-dire des fichiers statiques fournis avec l'application.
5. Le fichier de configuration appelé également manifeste : A côté de tous ces éléments, se trouve un fichier XML qui sert à la configuration de l'application. Ce fichier est indispensable à chaque application qui décrit : le point d'entrée de votre application (quel code doit être exécuté au démarrage de l'application), quels composants constituent ce programme, les permissions nécessaires à l'exécution du programme (accès à Internet, accès à l'appareil photo, etc.).
Contenu du manifeste
Le point de départ de toute application Android est son fichier manifeste, AndroidManifeste.xml, qui se trouve directement dans la racine du projet. C'est dans ce fichier que nous déclarons ce que contiendra l'application - les activités, les services, etc.
Nous y distinguons également la façon dont ces composants seront reliés au système Android lui-même en précisant, par exemple, l'activité (ou les activités) qui doivent apparaître dans le menu principal du terminal. Ce menu est également appelé "lanceur" (launcher).
La création d'une application produit automatiquement un manifeste de base. Pour une application simple, qui offre uniquement une seule activité, ce manifeste automatique conviendra sûrement ou nécessitera éventuellement quelques modifications mineures.
AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="fr.manu.heure"
android:versionCode="1"
android:versionName="1.0">
<application android:label="@string/app_name" android:icon="@drawable/icon">
<activity android:name="MainActivity"
android:label="@string/app_name">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
1. Tous les fichiers manifestes ont pour racine <manifest>. Comme d'habitude, cet élément comprend la déclaration d'un espace de nom, ici, logiquement, android.
2. L'essentiel des informations que vous devez fournir à cet élément est l'attribut package, ici fr.manu.heure. C'est là que vous pouvez indiquer le nom du paquetage Java qui sera considéré comme la base de votre application. Ce qui est intéressant par cette démarche, c'est que dans la suite de votre fichier, vous pourrez alors simplement utiliser le symbole point pour désigner ce paquetage : si vous devez par exemple faire référence à fr.manu.heure.Heure dans le manifeste, il suffira d'écrire .Heure puisque fr.manu.heure est défini comme le paquetage de l'application.
3. Sous l'élément <manifest>, vous trouverez les éléments suivants :
<uses-permission> indiquant les permissions dont a besoin votre application pour fonctionner correctement :
<uses-permission android:name="android.permission.ACCESS_GPS" />
<permission> déclarant les permissions que les activités ou les services peuvent exiger des autres appplications pour utiliser les données et le code de l'application.
<instrumentation> qui indique le code qui devrait être appelé pour les événements systèmes essentiels, comme le lancement des activités. Ces éléments sont utilisés pour la journalisation ou la surveillance.
<uses-library> pour relier les composants facultatifs d'Android, comme les services de géolocalisation.
<uses-sdk> indiquant la version du SDK Android avec laquelle a été construite l'application.
<application> qui définit le coeur de l'application décrite par le manifeste.
Le plat de résistance du fichier manifeste est décrit par le fils de l'élément <application>. Par défaut, la création d'un nouveau projet Android n'indique qu'un seul élément <activity>.
1. Cet élément <activity> fournit l'attribut android:name pour la classe qui implémente l'activité, l'attribut android:label pour le nom affiché de l'activité et souvent, un élément fils <indent-filter> décrivant les conditions sous lesquelles cette activité s'affichera.
2. L'élément <activity> de base configure votre activité pour qu'elle apparaisse dans le lanceur sous forme d'une icône afin que les utilisateurs puissent l'exécuter simplement. Comme nous le verrons plus tard, un même projet peut définir plusieurs activités.
3. Il peut y avoir plusieurs éléments <provider> indiquant les fournisseurs de contenus (content providers) - les composants qui fournissent les données à vos activités et, avec votre permission, aux activités d'autres applications du terminal. Ces éléments encapsulent les bases de données ou les autres
à vos activités et, avec votre permission, aux activités d'autres applications du terminal. Ces éléments encapsulent les bases de données ou les autres stockages de données en une API unique que toute application peut ensuite utiliser.
4. Enfin, il peut y avoir un ou plusieurs éléments <service> décrivant les services, c'est-à-dire les parties de code qui peuvent fonctionner indépendamment de toute activité et en permanence. L'exemple classique est celui du lecteur MP3, qui permet de continuer à écouter de la musique, même si l'utilisateur ouvre d'autres activités et que l'interface utilisateur n'est pas affichée au premier plan (sujet traité ultérieurement).
Android, comme la plupart des systèmes d'exploitation, est régulièrement amélioré, ce qui donne lieu à de nouvelles versions du système. Certains de ces changements affectent le SDK car de nouveaux paramètres, classes ou méthodes apparaissent, qui n'existaient pas dans les versions précédentes.
1. Pour être sûr que votre application ne s'exécutera que pour une version précise (ou supérieure) d'un environnement Android, ajoutez un élément
<uses-sdk> comme fils de l'élément racine <manifest> du fichier AndroidManifest.xml. <uses-sdk> dispose de l'attribut minSdkVersion, indiquant la version minimale du SDK exigée par votre application.
2. Si vous omettez <uses-sdk>, cela revient à annoncer que votre application fonctionnera sur toutes les versions existantes du SDK et vous devrez évidemment tester que c'est bien le cas.
Si vous compter distribuer votre application via la boutique Android ou d'autres supports, vous devrez sûrement ajouter les attributs android:versionCode et android:versionName à l'élément <manifest> afin de faciliter le processus de mise à jour des applications.
1. android:versionName : est une chaîne de caractères lisible représentant le nom ou le numéro de version de votre application. Vous pouvez, par exemple, utiliser des valeurs comme "3.0", "System V", "5000" ou "3.1" en fonction de vos préférences.
2. android:versionCode : est un entier censé représenter le numéro de version de l'application. Le système l'utilise pour savoir si votre version est la plus récente qu'une autre - "plus récent" étant défini par "la valeur d'android:versionCode est plus élévée". Pour obtenir cette valeur, vous pouvez convertir le contenu d'android:versionName en nombre ou simplement incrémenter la valeur à chaque nouvelle version.
Après toutes ces petites considérations techniques, voici les petites modifications que nous pouvons éventuellement apporter sur le manifeste de base généré automatiquement par Netbeans :
AndroidManifest.xml
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="fr.manu.heure"
android:versionCode="1"
android:versionName="1.0">
<uses-sdk android:minSdkVersion="2" />
<application android:label="Heure" android:icon="@drawable/icon">
<activity android:name=".Heure" android:label="Heure">
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
</manifest>
Qu'est-ce qu'une activité Android ?
Nous avons passé pas mal de temps à décrire toute l'infrastructure d'une application Android. Nous allons maintenant rentrer dans le vif du sujet en décrivant comment créer notre propre activité, ce qui sera très souvent le cas dans les différentes applications que vous allez développer.
Une activité, comme nous l'avons déjà décrit, peut être assimilée à un écran qu'une application propose à son utilisateur. L'activité permet ainsi à l'utilisateur d'interagir avec l'application. Comme expliqué précédemment, plusieurs activités peuvent composer une même application. Pour chaque écran de votre application, vous devrez donc créer une activité.
Il est préconisé de n'avoir qu'une interface visuelle par activité afin de faciliter la cinématique de l'application. En effet, la gestion du passage d'une activité à l'autre se voit ainsi mieux maîtrisée lors de l'évolution du cycle de vie de l'activité. La transition entre deux écrans correspond au lancement d'une activité ou au retour sur une activité placée en arrière plan.
Une activité est composée de deux volets :
1. La logique de l'activité et la gestion du cycle de vie de l'activité qui sont implémentés en Java dans une classe héritant de Activity.
2. L'interface utilisateur, qui pourra être définie soit dans le code de l'activité soit de façon plus générale dans un fichier XML placé dans les ressources de l'application.
Cycle de vie d'une activité
Tout ce que nous avons vu en parlant du cycle de vie d'une application, au tout début de notre étude, notamment sur la gestion des processus en fonction des resssources, a un impact direct sur les activités et notamment sur leur cycle de vie.
Comme le montre le diagramme UML suivant, une activité possède des méthodes de rappel (callback) appelées tout au long de son cycle de vie. Ces méthodes permettent de définir des passages d'un état à l'autre de l'activité par rapport à l'évolution des ressources et du comportement du système et de l'utilisateur. Le développeur peut ainsi définir des comportements particuliers à chaque état de celle-ci.
1. L'activité démarre : la méthode onCreate() est appelée.
2. L'activité est active (démarrée) : activité visible qui détient le focus et attend les entrées utilisateur. C'est l'appel à la méthode onResume(), à la création ou à la reprise après la pause qui permet à l'activité d'être dans cet état. Elle est ensuite mise en pause quand une autre activité devient active grâce à la méthode onPause().
3. Activité suspendue (en pause) : activité au moins en partie visible à l'écran mais qui ne détient pas le focus. La méthode onPause() est invoquée pour entrer dans cet état et les méthodes onResume() ou onStop() permettent d'en sortir.
4. Activité arrêtée : pendant l'utilisation d'une activité, l'utilisateur presse la touche Accueil, ou bien l'application téléphone, qualifiée comme prioritaire, interrompt l'activité en cours et prend en compte l'appel entrant. L'activité est arrêtée par l'appel de la méthode onStop(). Le développeur détermine l'impact sur l'interface utilisateur, par exemple la mise en pause d'une animation puisque l'activité n'est plus visible.
5. L'activité redémarre : une fois l'appel téléphonique terminé, le système réveille l'activité précédemment mise en pause en appelant successivement les méthodes onRestart() et onStart().
6. Destruction de l'activité : si l'activité reste trop longtemps en pause, le système a besoin de mémoire, il détruit l'activité au moyen de la méthode onDestroy().
7. Activité partiellement visible : les méthodes onPause() et onResume() rajoutent un état à l'activité, puisqu'ils interviennent dans le cas d'activité partiellement visibles, mais qui n'ont pas le focus. La méthode onPause() implique également que la vie de cette application n'est plus une priorité du système. Donc, si celui-ci a besoin de mémoire, l'activité peut être fermée. Ainsi, il est préférable, lorsque nous utilisons cette méthode, de sauvegarder l'état de l'activité dans le cas où l'utilisateur souhaiterait y revenir avec la touche Accueil.
Vous avez ci-dessous un cas d'école qui permet de bien maîtriser toutes ces méthodes de rappel. Deux nouvelles peuvent être utilisées afin de sauvegarder et de restaurer automatiquement des données importantes.
(ensemble des méthodes de rappel) fr.manu.heure.NouvelleActivité
import android.app.Activity;
import android.os.Bundle;
public class NouvelleActivité extends Activity { /**
* Appelée lorsque l'activitée est créée.
* Permet de restaurer l'état de l'interface utilisateur * grâce au paramètre icicle.
*/
@Override
public void onCreate(Bundle icicle) { super.onCreate(icicle);
// Placez votre code ici }
/**
* Appelée lorsque l'activité a fini son cycle de vie.
* C'est ici que nous placerons notre code de libération de mémoire, * fermeture de fichiers et autres opérations de nettoyage.
*/
@Override
protected void onDestroy() { super.onDestroy();
// Placez votre code ici }
/**
* Appelée lorsque l'activité démarre. Permet d'initialiser les contrôles.
*/
@Override
protected void onStart() { super.onStart();
// Placez votre code ici }
/**
* Appelée lorsque l'activité passe en arrière plan.
* Libérez les écouteurs, arrêter les threads, * votre activité peut disparaître de la mémoire.
*/
@Override
protected void onStop() { super.onStop();
// Placez votre code ici }
/**
* Appelée lorsque l'activité est suspendue.
* Stoppez les actions qui consomment des ressources.
* L'activité va passer en arrière-plan.
*/
@Override
protected void onPause() { super.onPause();
// Placez votre code ici }
/**
* Appelée lorsque l'activité sort de l'état de veille */
@Override
protected void onRestart() { super.onRestart();
// Placez votre code ici }
/**
* Appelée après le démarrage ou une pause.
* Relancez les oprations arrêtées (threads).
* Mettez à jour votre application et vérifiez vos écouteurs.
*/
@Override
protected void onResume() { super.onResume();
// Placez votre code ici }
/**
* Appelée lorsque l'activité termine son cycle visible.
* Sauvez les données importantes */
@Override
protected void onSaveInstanceState(Bundle outState) { super.onSaveInstanceState(outState);
// Placez votre code ici }
/**
* Appelée après onCreate().
* Les données sont rechargées et
* l'interface utilisateur est restaurée dans le bon état.
*/
@Override
protected void onRestoreInstanceState(Bundle savedInstanceState) { super.onRestoreInstanceState(savedInstanceState);
// Placez votre code ici }
}
Les vues
Les vues sont les briques de construction de l'interface graphique d'une activité Android. Les objets View représentent des éléments à l'écran qui permettent d'interagir avec l'utilisateur via un mécanisme d'événements.
1. Plus concrètement, chaque écran Android contient un arbre d'éléments de type View (descendants) dont chaque élément est différent de par ses propriétés de forme, de taille, de type d'intervention, etc.
2. Bien que la plupart des éléments dont nous avons besoin - textes, boutons, zone de saisie, etc. - soient fournis par la plateforme (composants spécifiques), il est tout à fait possible de créer des éléments personnalisés.
3. Les vues peuvent être disposées dans une activité et donc à l'écran soit par une description XML, soit directement dans le code Java.
4. Nous allons aborder tout un chapitre qui traite des vues les plus utilisées, notamment ce qui s'appelle les widgets, comme les boutons, les cases à cocher, les zones de saisies, etc. voilà, à l'attendant la javadoc des composants officiels relatifs aux widgets.
Développement final de notre projet
Comme c'est souvent le cas au début, nous sommes passé par beaucoup d'explications, qui étaient bien sûr nécessaires pour bien comprendre et maîtriser l'informatique embarquée sur mobile. Nous allons enfin définir le code Java de notre activité principale (la seule ici) pour finalement commencer et terminer notre application.
fr.manu.heure.Heure.java
package fr.manu.heure;
import android.app.Activity;
import android.os.Bundle;
import android.text.format.DateFormat;
import android.view.View;
import android.widget.Button;
import java.util.Date;
public class Heure extends Activity implements View.OnClickListener { private Button bouton;
@Override
public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState);
bouton = new Button(this);
bouton.setOnClickListener(this);
donnerHeure();
setContentView(bouton);
}
public void onClick(View arg0) { donnerHeure();
}
private void donnerHeure() {
CharSequence texte = DateFormat.format("EEEE, dd MMMM, hh:mm", new Date());
bouton.setText(texte);
} }
Pour notre premier projet, tout notre travail porte sur l'élaboration de cette seule activité. Nous allons donc prendre le temps de disséquer cette classe Java et proposer en conséquence un certain nombre de remarques :
1. La toute première remarque, c'est que le code est extrêmement réduit vu ce que nous arrivons déjà à faire.
2. La déclaration du paquetage doit être identique à celle que vous avez utilisée pour définir le projet.
3. Comme pour tout projet Java, vous devez importer les classes auxquelles vous faites référence. La plupart de celles qui sont spécifiques à Android se trouvent dans le paquetage android.
4. Notez bien que toutes les classes de Java SE standard ne sont pas utilisables par les programmes Android surtout, bien entendu, les composants graphiques issus de Swing comme JButton, JLabel, etc. qui sont plus adaptés aux grands écrans des ordinateurs de bureau ou des ordinateurs portables.
5. Les activités doivent être des classes publiques héritées, directement ou indirectement, de la classe android.app.Activity.
6. Comme toute classe Java, il est bien sûr possible qu'elle possède ses propres attributs. Ici, nous avons déclaré un nouvel attribut bouton issu de la classe android.widget.Button.
7. Un bouton, comme vous pouvez le constater d'après le nom du paquetage, est un widget Android. Les widgets sont des éléments d'interface graphique que vous pouvez utiliser dans une application Android. Ils sont l'équivalent des composants Swing proposés par le Java SE standard.
8. Tous les widgets dérivent de la classe de base View. Bien que nous construisons généralement l'interface graphique à partir d'une arborescence de vue, pour notre toute première application nous n'utiliserons ici qu'une seule vue.
9. Dans notre classe Heure, nous retrouvons la méthode de rappel onCreate(), qui comme ce sera souvent le cas est la seule à prendre en compte pour l'instant.
10. La méthode onCreate() est appelée lorsque l'activité est lancée. La première chose à faire est d'établir le chaînage vers la superclasse afin de réaliser l'initialisation de l'activité android de base, grâce au mot réservé super que nous connaissons déjà.
11. Nous créons ensuite l'instance du bouton à l'aide de l'opérateur new. Attention, il existe ici une différence fondamentale avec les composants Swing du Java SE standard.
Avec Swing, il est effectivement possible de créer les instances directement au moment de la déclaration des attributs en spécifiant le constructeur désiré (plusieurs existent) pour par exemple proposer un intitulé à un JButton.
Avec les widgets, c'est totalement différent, les constructeurs proposés attendent au moins un paramètre qui spécifie le contexte, c'est-à- dire en gros le conteneur qui va prendre en compte ce composant visuel, ici par exemple l'activité. C'est la raison pour laquelle nous sommes obligé de créer l'instance du bouton uniquement après la création de l'activité elle-même, donc dans la méthode onCreate(), puisque que nous passons en paramètre l'opérateur this.
12. Nous verrons qu'il existe une autre solution beaucoup plus simple, mais nous pouvons proposer une gestion événementielle à l'image de ce que nous faisons avec la Java SE standard.
Rappelez-vous, avec Swing, un clic sur un JButton déclenche un ActionEvent qui est transmis automatiquement à l'ActionListener configuré pour ce bouton. La méthode actionPerformed() est alors exécutée.
Avec Android, en revanche, un clic sur un bouton provoque l'appel de la méthode onClick() sur l'instance OnClickListener configuré pour le bouton. L'écouteur reçoit la vue qui a déclenché le clic (ici, il s'agit du bouton).
13. Je rappelle que pour une gestion événementielle classique en Java, il est nécessaire de respecter trois critères :
1. La source de l'événement : ici, c'est le bouton, il doit donc faire appel à la méthode setOnClicListener() en désignant l'écouteur qui prend en compte cet événement.
2. La gestion de l'événement : vous spécifiez l'objet qui est capable d'être à l'écoute de l'événement à prendre en compte. Ici, c'est l'activité elle- même qui implémente l'interface OnClickListener intégrée dans la classe View.
3. L'action proposée en conséquence : lorsque qu'une classe implémente une interface, elle est dans l'obligation de respecter le contrat prévue par cette dernière, c'est-à-dire de redéfinir la ou les méthodes déclarées par l'interface. Ici, il s'agit de la méthode onClic(). C'est justement cette dernière qui sera automatiquement lancée lorsqu'un clic sur le bouton interviendra.
