Développement Android avec Android Studio et Eclipse

Lars Vogel

Traducteur

ram-0000

Cet article présente tout ce qu'il faut savoir pour commencer à développer dans un environnement Android.

Nous remercions Lars Vogel qui nous a aimablement autorisés à traduire et héberger cet article.

Les commentaires et les suggestions d'amélioration sont les bienvenus, alors, après votre lecture, n'hésitez pas. Commentez . ♪

- Titre : Développement Android avec Android Studio et Eclipse

- Auteur : Lars Vogel

- Traducteur : ram-0000

- Parution : 12 mai 2013

- Licence : Le contenu de cet article est rédigé par Lars Vogel et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Partage dans les Mêmes Conditions 3.0 non transposé. Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright ® 2013 Developpez.com.

Sommaire

- I. Qu'est-ce qu'Android ?

- I-A. Le système d'exploitation Android

- I-B. Les tâches

- I-C. Les composants de la plate-forme Android

- I-D. Google Play

- II. Les outils de développement Android

- II-A. Le SDK Android

- II-B. Le débogueur « Android debug bridge » (adb)

- II-C. Les IDE « Android Developer Tools » et « Android Studio »

- II-D. La machine virtuelle Dalvik

- II-E. Le runtime Android (ART)

- II-F. Comment développer une application Android

- II-G. Le processus de conversion depuis le source vers une application Android

- III. Sécurité et permissions

- III-A. La sécurité avec Android

- III-B. Les permissions avec Android

- IV. Installation

- IV-A. Installation de Android Developer Tools (ADT)

- IV-A-1. Télécharger Android Developer Tools

- IV-A-2. Installation autonome de ADT

- IV-A-3. Mettre à jour une installation Eclipse existante

- IV-B. Autres options d'installation Eclipse

- IV-C. L'émulateur Android et les périphériques virtuels

- IV-D. Les raccourcis de l'émulateur de périphériques Android (AVD)

- IV-E. AVD Google ou Android ?

- IV-F. Optimisation de la vitesse

- IV-G. Image système Intel

- IV-H. Émulateur alternatif

- V. Exercice : Créer un périphérique virtuel Android (AVD)

- V-A. But

- V-B. Créer l'AVD

- V-C. Démarrez l'AVD

- VI. Exercice : Créer une application Android avec Eclipse

- VI-A. Utiliser l'assistant de projet Android

- VI-B. Créer un projet Android

- VII. Exercice : Lancer l'application Android

- VII-A. Lancer l'AVD

- VII-B. Lancer l'application

- VIII. Résoudre les problèmes de développement Android

- IX. Se connecter avec le code source Android

- IX-A. Connecter le source au fichier JAR Android

- IX-B. Validation

- X. Intégration de ADT dans Eclipse

- X-A. Intégration d'Android dans l'environnement Java

- X-B. Les assistants Android

- XI. La vue DDMS

- XI-A. La vue DDMS Android

- XI-B. Le contrôle de l'émulateur

- XI-C. L'explorateur de fichiers

- XII. Les parties d'une application Android

- XII-A. Une application Android

- XII-B. Les composants logiciels Android

- XII-C. Le contexte

- XIII. Aperçu des composants d'une application Android

- XIII-A. Les activités

- XIII-B. Les récepteurs de diffusion

- XIII-C. Les services

- XIII-D. Les fournisseurs de contenu

- XIV. Composants de base de l'interface utilisateur dans Android

- XIV-A. Les activités

- XIV-B. Les fragments

- XIV-C. Les vues et la mise en page

- XIV-D. Mise en page spécifique à la configuration d'un périphérique

- XV. Autres éléments importants d'Android

- XV-A. Écran d'accueil et écran de verrouillage

- XV-B. Fonds d'écran animés

- XVI. Le manifeste Android

- XVI-A. Configuration de votre application Android

- XVI-B. Déclarer les composants dans un fichier manifeste

- XVI-C. Les permissions

- XVI-D. Fichier d'exemple AndroidManifest.xml

- XVII. Le manifeste Android

- XVII-A. Version et package

- XVII-B. Application et composants

- XVII-C. SDK minimum et cible

- XVII-D. Permissions

- XVII-E. Configuration périphérique requise

- XVII-F. Emplacement d'installation

- XVII-G. Plus d'information

- XVIII. Les ressources

- XVIII-A. Les fichiers de ressources

- XVIII-B. Exemple

- XVIII-C. Qualificateur de ressource

- XVIII-D. Identifiant de ressources et R.java

- XVIII-E. Bonnes pratiques pour les ID de ressources

- XVIII-F. Les ressources système

- XIX. Les fichiers de mise en page

- XIX-A. Mise en page et activité

- XIX-B. Les fichiers de mise en page XML

- XIX-C. Définir des identifiants (ID)

- XIX-D. Bonnes pratiques : ID prédéfinis avec un fichier séparé

- XIX-E. Considération de performance avec les layouts

- XX. Views Les vues

- XX-A. La classe View

- XX-B. Les vues standard

- XX-C. Les vues personnalisées

- XXI. Le gestionnaire de mise en page et les groupements de vues

- XXI-A. Qu'est-ce qu'un gestionnaire de mise en page ?

- XXI-B. Gestionnaires de mise en page importants

- XXI-C. Les attributs d'une mise en page

- XXI-D. Le gestionnaire FrameLayout

- XXI-E. Le gestionnaire LinearLayout

- XXI-F. Le gestionnaire RelativeLayout

- XXI-G. Le gestionnaire GridLayout

- XXI-H. La classe ScrollView

- XXII. Exercice : Utilisation des layouts et ajout d'interactions

- XXII-A. Examen du layout

- XXII-B. Enlever les vues existantes

- XXII-C. Ajouter et configurer les vues

- XXII-D. Ajout d'un bouton interactif

- XXII-E. Validation de l'action du bouton

- XXII-F. Afficher du texte depuis le champ EditText

- XXII-G. Valider le message affiché

- XXII-H. Solution

- XXIII. Exercice : modifier la mise en page dynamiquement

- XXIII-A. Ajout de boutons radio à la mise en page

- XXIII-B. Changer l'orientation du groupe dynamiquement

- XXIII-C. Validation

- XXIV. Exercice : Créer un convertisseur de température

- XXIV-A. Application de démonstration

- XXIV-B. Créer le projet

- XXIV-C. Créer les attributs

- XXIV-D. Utiliser l'éditeur de mise en page

- XXIV-E. Ajouter des objets à votre mise en page

- XXIV-F. Éditer les propriétés des objets

- XXIV-G. Créer la classe utilitaire

- XXIV-H. Modifier le code de l'activité

- XXIV-I. Lancer l'application

- XXV. Utiliser les ressources

- XXV-A. Référencer les ressources dans le code

- XXV-B. Accéder aux vues de la mise en page depuis l'activité

- XXV-C. Référencer des ressources dans des fichiers XML

- XXV-D. Référencer des ressources système Android

- XXVI. Actifs (assets)

- XXVI-A. Que sont les actifs ?

- XXVI-B. Accéder aux actifs

- XXVII. Exercice : Utiliser des ressources dans les fichiers XML et dans le code

- XXVII-A. Ajouter des images à votre projet

- XXVII-B. Ajouter des vues à votre projet

- XXVII-C. Assigner une image à votre ImageView

- XXVII-D. Modifier les images avec un clic sur le bouton

- XXVII-E. Validation

- XXVIII. Exercice : Utiliser des ScrollView

- XXIX. Le déploiement

- XXIX-A. Vue d'ensemble

- XXIX-B. Déploiement avec Eclipse

- XXIX-C. Exporter l'application

- XXIX-D. Avec des sources externes

- XXIX-E. Google Play (Market)

- XXX. Liens et littérature

- XXX-A. Code source

- XXX-B. Ressources Android en ligne

- XXXI. Remerciements

I - Qu'est-ce qu'Android ?

I-A - Le système d'exploitation Android

Android est un système d'exploitation basé sur le noyau Linux. Le projet pour le développement du système Android est appelé Android Open Source Project (AOSP) et est géré principalement par Google.

Le système Android supporte les tâches de fond, fournit une riche bibliothèque pour l'interface utilisateur, supporte la 2D et la 3D en utilisant le standard OpenGL-ES (OpenGL pour faire court) et fournit un accès au système de fichiers ainsi qu'à une base de données SQLite embarquée.

Une application Android comporte typiquement différents composants visuels ou non visuels et peut réutiliser les composants des autres applications.

I-B - Les tâches

Sous Android, le concept de réutilisation des composants d'une autre application s'appelle une tâche. Une application peut accéder aux composants d'une autre application pour exécuter une tâche. Par exemple, depuis un composant de votre application, vous pouvez déclencher un autre composant du système Android qui gère les photographies, même si ce composant ne fait pas partie de votre application. Dans ce composant, vous sélectionnez votre photographie et retournez à votre application pour utiliser la photographie sélectionnée.

Un tel flux d'événements est représenté dans le graphique ci-dessous.

I-C - Les composants de la plate-forme Android

Le système Android est une pile logicielle complète qui est divisée en quatre zones comme le montre le graphique suivant.

Ces éléments peuvent être décrits comme :

- Applications - Le projet Open Source Android contient plusieurs applications par défaut comme le navigateur, l'appareil photo, la galerie, la musique, le téléphone et plus encore ;

- Application Framework - Une API qui permet aux applications Android d'interagir avec le système Android ;

- Libraries and runtime - Les bibliothèques pour de nombreuses fonctions communes (par exemple : le rendu graphique, le stockage de données, la navigation sur le Web, etc.) de l'Application Framework et du moteur Dalvik, ainsi que le noyau de bibliothèques Java pour exécuter des applications Android ;

- Linux kernel - La couche de communication avec le matériel sous-jacent.

Le noyau Linux, les bibliothèques et le moteur d'exécution sont encapsulés par le Application Framework. Le développeur d'applications Android fonctionne généralement avec les deux couches supérieures pour créer de nouvelles applications Android.

I-D - Google Play

Google propose le service Google Play, un endroit dans lequel les développeurs peuvent déposer leurs applications Android à disposition des utilisateurs Android. Les clients utilisent l'application Google Play qui leur permet d'acheter et d'installer ces applications à partir du service Google Play.

Google Play propose également un service de mise à jour. Si un développeur propose une nouvelle version de son application à Google Play, ce service informe les utilisateurs existants qu'une mise à jour est disponible et leur propose d'installer la mise à jour.

Google Play permet aussi d'accéder à des services et des bibliothèques pour les développeurs d'application Android. Par exemple, il fournit un service à utiliser pour afficher Google Maps et un autre pour synchroniser l'état de l'application entre les différentes installations Android. La fourniture de ces services par l'intermédiaire de Google Play a l'avantage qu'ils sont disponibles pour les anciennes versions Android et peuvent être mis à jour par Google sans nécessiter une mise à jour de la version Android sur le téléphone.

II - Les outils de développement Android

II-A - Le SDK Android

Le Kit de développement logiciel Android (Android SDK) contient les outils nécessaires pour créer, compiler et déployer les applications Android. La plupart de ces outils sont en ligne de commande. Le principal moyen de développer des applications Android est d'utiliser le langage de programmation Java.

II-B - Le débogueur « Android debug bridge » (adb)

Le SDK Android contient un débogueur appelé « Android debug bridge » ou aussi « adb », qui permet de connecter un appareil Android virtuel ou réel, dans le but de gérer le périphérique ou de déboguer votre application.

II-C - Les IDE « Android Developer Tools » et « Android Studio »

Google propose deux environnements de développement intégrés (IDE) pour développer de nouvelles applications.

- Les outils de développement Android (Android Developer Tools ou ADT) sont basés sur l'IDE Eclipse. ADT est un ensemble de composants (plug-ins), qui étendent l'IDE Eclipse avec des capacités de développement Android.

- Google propose également un IDE appelé Android Studio pour la création d'applications Android. Cet IDE est basé sur l'IDE IntelliJ.

Ces deux IDE contiennent toutes les fonctionnalités requises pour créer, compiler, déboguer et déployer des applications Android. Ils permettent également au développeur de créer et démarrer des périphériques Android virtuels pour les tests.

Ces deux outils offrent des éditeurs spécialisés pour les fichiers spécifiques Android. La plupart des fichiers de configuration d'Android sont basés sur XML. Dans ce cas, ces éditeurs vous permettent de basculer entre la représentation XML du fichier et une interface utilisateur structurée pour la saisie des données.

II-D - La machine virtuelle Dalvik

Actuellement les versions d'Android utilisent la machine virtuelle Dalvik. Les dernières versions d'Android introduisent une nouvelle machine, le runtime Android.

II-E - Le runtime Android (ART)

Avec Android 4.4, Google a introduit le runtime Android (ART) comme runtime optionnel pour Android 4.4. Il est utilisé par défaut pour toutes les versions Android 4.4 et ultérieures.

ART utilise la compilation par avance (Ahead Of Time compilation). Pendant le processus de déploiement d'une application sur une tablette, le code d'application est traduit en code machine. Il en résulte un code compilé environ 30% plus grand, mais permet une exécution plus rapide au lancement de l'application.

Cela permet d'économiser aussi la vie de la batterie puisque la compilation ne se fait qu'une seule fois, lors du premier démarrage de l'application.

L'outil « dex2oat » prend le fichier .dex créé par l'IDE Android et le compile dans un format exécutable (format ELF). Ce fichier contient le code .dex, le code compilé natif et les métadonnées. Conserver le code .dex permet aux outils existants de continuer à fonctionner.

Le « garbage collector » ART a été optimisé pour réduire les délais pendant lesquels l'application se fige.

II-F - Comment développer une application Android

Les applications Android sont principalement écrites avec le langage de programmation Java.

Durant la phase d'écriture, le développeur crée les fichiers de configuration spécifiques à Android et écrit la logique d'application dans le langage de programmation Java.

ADT ou les outils Android studio convertissent ces fichiers d'application, de manière transparente pour l'utilisateur, en une application Android. Lorsque le développeur déclenche le déploiement avec leur IDE, toute l'application Android est compilée, déployée et démarrée.

II-G - Le processus de conversion depuis le source vers une application Android

Les fichiers source Java sont convertis en fichiers de classe Java par le compilateur Java.

Le SDK Android contient un outil appelé dx qui convertit les fichiers de classe Java en un fichier .dex (Dalvik Executable). Tous les fichiers de classe de l'application sont placés dans ce fichier .dex. Au cours de ce processus de conversion, les informations redondantes dans les fichiers de classe sont optimisées dans le fichier .dex.

Par exemple, si une même chaîne de caractères se trouve dans plusieurs fichiers de classe différents, le fichier .dex ne contient qu'une seule référence de cette chaîne.

Ces fichiers .dex sont donc beaucoup plus petits en taille que les fichiers des classes correspondantes.

Le fichier .dex et les ressources du projet Android, par exemple les images et les fichiers XML, sont assemblés dans un fichier ,apk (Android Package). C'est le programme aapt (Android Asset Packaging Tool) qui effectue cette étape.

Le fichier ,apk résultant contient toutes les données nécessaires pour exécuter l'application Android et peut être déployé sur un périphérique Android via l'outil adb.

III - Sécurité et permissions

III-A - La sécurité avec Android

Le système Android installe toutes les applications Android avec un identifiant unique d'utilisateur et de groupe. Chaque fichier de l'application est privé à cet utilisateur généré, les autres applications ne peuvent pas accéder à ces fichiers. En outre, chaque application Android est lancée dans son propre processus.

Par conséquent, par l'intermédiaire du noyau Linux sous-jacent, chaque application Android est isolée des autres applications en cours d'exécution.

Si des données doivent être partagées, l'application doit le faire explicitement via un composant Android qui gère le partage des données, par exemple, via un service ou un fournisseur de contenu.

III-B - Les permissions avec Android

Android contient un système d'autorisation et prédéfinit des autorisations pour certaines tâches. Chaque application peut demander les autorisations nécessaires et définir de nouvelles autorisations. Par exemple, une application peut déclarer qu'elle nécessite l'accès à Internet.

Les permissions ont différents niveaux. Certaines autorisations sont automatiquement accordées par le système Android, certaines sont automatiquement rejetées. Dans la plupart des cas, les permissions demandées sont présentées à l'utilisateur avant l'installation de l'application. L'utilisateur doit décider si ces permissions seront données à l'application.

Si l'utilisateur refuse une permission demandée, l'application concernée ne peut être installée. La vérification de l'autorisation est effectuée uniquement lors de l'installation, les permissions ne peuvent être refusées ou accordées après l'installation.

Une application Android déclare les permissions requises dans son fichier de configuration AndroidManifest.xml. Elle peut également définir des permissions supplémentaires qu'elle peut utiliser pour restreindre l'accès à certains composants.

Tous les utilisateurs ne portent pas attention aux permissions demandées lors de l'installation. Mais certains utilisateurs le font et ils écrivent alors des commentaires négatifs sur Google Play s'ils croient que la demande est non justifiée.

IV - Installation

IV-A - Installation de Android Developer Tools (ADT)

IV-A-1 - Télécharger Android Developer Tools

Google fournit un environnement de développement Android configuré sur la base de l'IDE Eclipse appelé Android Developer Tools (ADT). Sous le lien suivant, vous trouverez un fichier d'archive qui comprend tous les outils nécessaires pour le développement Android : Télécharger le SDK Android.

IV-A-2 - Installation autonome de ADT

Extraire le fichier ,zip et démarrer les outils de développement Android (Eclipse) qui se trouvent dans le dossier Eclipse. Vous pouvez le faire en double-cliquant sur le lanceur natif Eclipse (par exemple, eclipse.exe sous Windows).

IV-A-3 - Mettre à jour une installation Eclipse existante

Voir cet article pour savoir comment mettre à jour votre IDE Eclipse pour faire du développement Android.

IV-B - Autres options d'installation Eclipse

La manière la plus simple pour commencer le développement Android avec Eclipse est de télécharger un bundle complet et préconfiguré comme décrit dans la Section 4.1.1, « Télécharger Android Developer Tools ». Il est également possible de mettre à jour une installation existante d'Eclipse, voir l'installation Android pour une description plus détaillée.

IV-C - L'émulateur Android et les périphériques virtuels

Le SDK Android contient un émulateur de périphériques Android. Cet émulateur peut être utilisé pour exécuter un périphérique virtuel Android (AVD) qui émule un vrai téléphone Android. Un tel émulateur est affiché dans la capture d'écran suivante :

AVD vous permet de tester vos applications Android sur les différentes versions et configurations Android sans avoir accès au matériel réel.

Lors de la création de votre AVD, vous définissez la configuration de l'appareil virtuel. Cela comprend, par exemple, la résolution, la version Android de l'API et la densité de votre écran.

Vous pouvez définir plusieurs AVD avec des configurations différentes et les lancer en parallèle. Cela vous permet de tester plusieurs configurations des périphériques en une fois.

IV-D - Les raccourcis de l'émulateur de périphériques Android (AVD)

Le tableau suivant répertorie les raccourcis utiles pour travailler avec AVD :

Raccourci

Description

Alt+Enter

Maximize l'émulateur.

Ctrl+F11

Change l'orientation de l'émulateur de paysage à portrait et vice versa.

F8

Active ou désactive le réseau.

Table 1. Raccourcis de l'émulateur de périphériques Android

IV-E - AVD Google ou Android ?

Lors de la création d'un AVD vous décidez si vous souhaitez créer un périphérique Android ou Google.

Un AVD créé pour Android contient les programmes de l'Android Open Source Project. Un AVD créé pour l'API Google contient en plus du code spécifique Google.

Les AVD créés pour l'API Google vous permettent de tester les applications qui utilisent par exemple le service Google Play, la nouvelle API Google Maps ou les nouveaux services de localisation.

IV-F - Optimisation de la vitesse

Lors de la création d'un émulateur, vous pouvez choisir si vous voulez utiliser le mode « Snapshot » ou encore le mode « GPU ».

Ce dialogue semble indiquer que vous pouvez sélectionner les deux options, mais si vous le faites, vous obtiendrez un message d'erreur disant que ces options ne peuvent pas être sélectionnées ensemble.

Si vous sélectionnez le mode « Snapshot », la deuxième fois que vous lancez le périphérique, il est démarré beaucoup plus vite parce que AVD stocke son état lorsque vous le fermez. Si vous utilisez le mode « GPU », AVD utilise alors la carte graphique de votre ordinateur ce qui procure un rendu sur le périphérique émulé beaucoup plus rapide.

IV-G - Image système Intel

Il est possible d'exécuter AVD avec une image basée sur l'architecture CPU ARM ou Intel.

Un périphérique virtuel Android qui utilise l'image du système Intel est beaucoup plus rapide en exécution sur le matériel Intel/AMD par rapport à une image basée sur le système ARM. C'est parce que l'émulateur n'a pas besoin de traduire les instructions CPU ARM CPU vers la CPU Intel / AMD sur votre ordinateur.

Cette image peut être installée via le SDK Android Manager comme décrit dans la capture d'écran ci-dessous.

Une image Intel n'est pas disponible pour tous les niveaux de l'API.

Au moment d'écrire ces lignes vous devez aussi également télécharger et installer des pilotes supplémentaires pour MS Windows.

Après le téléchargement, vous trouverez le pilote dans le répertoire d'installation Android dans le répertoire extra/intel. Vous devez installer les pilotes en lançant le fichier .exe.

Cette étape d'installation supplémentaire n'est pas nécessaire sous Windows pour accélérer l'émulateur. Le seul téléchargement du pilote via Android ne suffit pas, il faut aussi l'installer.

Après le téléchargement, vous pouvez créer un nouveau AVD basé sur l'émulateur d'Intel. L'émulateur ne démarre pas plus vite, mais est beaucoup plus rapide lors de l'exécution de votre application Android.

Après le téléchargement, vous devrez peut-être redémarrer votre environnement de développement pour être en mesure de créer un AVD avec l'émulateur d'Intel.

Linux nécessite une configuration plus complexe. Pour une description détaillée de l'installation, consultez le guide d'installation de l'émulateur Intel qui comprend également les instructions détaillées pour Windows.

IV-H - Émulateur alternatif

Il existe d'autres alternatives disponibles à l'émulateur par défaut d'Android. Par exemple, l'émulateur Genymotion est relativement rapide dans le démarrage et l'exécution de projets Android.

V - Exercice : Créer un périphérique virtuel Android (AVD)

V-A - But

Dans cet exercice, nous allons créer et démarrer un AVD. Même si vous avez un vrai appareil Android disponible, vous devez vous familiariser avec la création et l'utilisation des AVD. Les périphériques virtuels vous donnent la possibilité de tester votre application avec des versions Android sélectionnées et des configurations spécifiques.

V-B - Créer l'AVD

Définissez un nouveau périphérique virtuel Android (AVD) en ouvrant le Manager AVD via Window/Android Virtual Device Manager et en appuyant sur le bouton « New ».

Saisissez les valeurs similaires à la capture d'écran ci-dessous :

Assurez-vous que l'option « Use Host GPU » est sélectionnée. Cela permet à l'AVD d'utiliser l'unité de traitement graphique (GPU) de votre ordinateur et permet un rendu beaucoup plus rapide.

Ensuite, appuyez sur le bouton OK. Cela va créer la configuration de l'AVD et l'afficher dans la liste des périphériques virtuels disponibles.

V-C - Démarrez l'AVD

Sélectionnez la nouvelle entrée et appuyez sur le bouton « Start… ». Sélectionnez le bouton « Launch » dans le dialogue suivant :

Ne pas interrompre le processus de démarrage, car cela peut corrompre l'AVD. Le premier démarrage peut prendre jusqu'à 10 minutes sur une machine plus ancienne. Sur une machine moderne, cela prend généralement de 1 à 3 minutes pour démarrer un nouvel AVD.

Après que l'AVD est démarré, vous pouvez contrôler l'interface graphique avec la souris. L'émulateur permet également d'accéder aux boutons du téléphone via un menu sur le côté droit de l'émulateur.

Une fois démarré, n'arrêtez pas l'AVD durant votre développement. Si vous modifiez votre application et que vous voulez tester la nouvelle version, il vous suffit de redéployer votre application sur l'AVD.

VI - Exercice : Créer une application Android avec Eclipse

VI-A - Utiliser l'assistant de projet Android

Les outils Android dans Eclipse fournissent des assistants pour les applications Android. Dans cet exercice, vous allez utiliser l'assistant de création de projets d'une application Android basée sur un modèle.

Le but de cet exercice est de montrer le processus de développement. Les objets créés seront expliqués plus loin dans cet article.

VI-B - Créer un projet Android

Pour créer un nouveau projet Android, sélectionnez « File ? New ? Other… ? Android ? Android Application Project » à partir du menu. Saisissez les données du tableau suivant dans la première page de l'assistant.

Propriété

Valeur

Application Name

Test App

Project Name

com.vogella.android.first

Package Name

com.vogella.android.first

API (Minimum, Target, Compile with)

Latest

Table 2. Paramètres pour votre projet Android

Appuyez sur le bouton « Next » et vérifiez que vous avez activé les cases à cocher « Create custom launcher icon » et « Create activity ».

Sur la page de l'assistant de l'icône de lancement, créez une icône de votre choix pour l'application. La capture d'écran ci-dessous montre l'exemple d'un résultat possible.

Appuyez sur le bouton « Next » et sélectionnez le modèle d'activité vide. Appuyez sur le bouton « Next » pour continuer.

Entrez les données suivantes dans la boîte de dialogue pour le modèle. La sélection est représentée dans la capture d'écran après le tableau :

Paramètre

Valeur

Activity

MainActivity

Layout

activity_main

Table 3.Valeurs pour le modèle

Appuyez sur le bouton « Finish ». L'assistant peut vous inviter à installer la bibliothèque de support. Si c'est le cas, sélectionnez-la pour l'installer.

VII - Exercice : Lancer l'application Android

VII-A - Lancer l'AVD

Si vous n'avez pas encore fait, créer et démarrer un périphérique virtuel Android (AVD). La version Android que vous sélectionnez doit correspondre à la version minimale de l'API de votre application Android.

Après le démarrage, vous voyez l'écran d'accueil de votre AVD comme le montre la capture d'écran ci-dessous :

Une fois que votre AVD est prêt, déverrouiller votre émulateur.

VII-B - Lancer l'application

Sélectionnez votre projet Android, faites un clic droit dessus et sélectionnez l'option « Run-As ? Android Application » :

Vous pouvez être invité à indiquer si les outils de développement Android doivent surveiller les messages. Dans ce cas, sélectionnez « Yes »et appuyez sur le bouton « OK ».

Cela démarre votre application sur l'AVD. L'application lancée est une application très simple qui affiche juste la chaîne « Hello, world! ».

VIII - Résoudre les problèmes de développement Android

Les choses ne sont pas toujours aussi simples qu'elles le devraient. Vous trouverez une liste des problèmes typiques de développement Android et leur solution sous le lien suivant : Solutions aux problèmes communs de développement Android.

IX - Se connecter avec le code source Android

IX-A - Connecter le source au fichier JAR Android

Maintenant que vous avez créé un projet Android, vous êtes en mesure de vous connecter avec le code source d'Android.

Pour connecter les sources avec le fichier android.jar dans votre projet Android, faites un clic droit sur le fichier android.jar dans la vue « Package Explorer » et sélectionnez l'option « Properties ? Java Source Attachment ».

Choisissez « External location » et appuyez sur le bouton « External Folder… ». Accédez à l'emplacement path_to_android_sdk/sources/android-xx et appuyez sur le bouton OK.

IX-B - Validation

Valider que vous pouvez voir le code source d'Android. Par exemple, ouvrez la classe View via la boîte de dialogue « open type » (raccourci : Ctrl + Maj + T) et assurez-vous que vous pouvez voir le code source.

X - Intégration de ADT dans Eclipse

X-A - Intégration d'Android dans l'environnement Java

Les outils Android s'intègrent dans l'environnement Java. Ils ajoutent des boutons dans la barre d'outils pour gérer votre configuration Android avec le gestionnaire SDK Android, créer de nouveaux AVD et leurs fichiers de configuration ainsi que des assistants pour la création de nouveaux projets et des artefacts Android.

La capture d'écran suivante montre les barres d'outils Android supplémentaires ainsi qu'une petite description de ces boutons.

X-B - Les assistants Android

Vous trouverez les assistants spécifiques Android sous « File ? New ? Other… ? Android » comme le montre la capture d'écran ci-dessous. Ces assistants vous permettent de créer des projets Android et autres artefacts Android.

XI - La vue DDMS

XI-A - La vue DDMS Android

ADT ajoute la vue DDMS (Dalvik Device Monitoring Service) dans Eclipse pour interagir avec votre périphérique (virtuel) Android et votre application Android. Sélectionnez « Window ? Open Perspective ? Other… ? DDMS » pour ouvrir cette vue. Elle regroupe plusieurs vues Eclipse qui peuvent également être utilisées indépendamment.

Sur le côté gauche, elle vous montre les appareils Android connectés et les processus en cours d'exécution sur l'appareil. Le côté droit est une pile de vues avec des objectifs différents. Vous pouvez sélectionner des processus et déclencher des actions de la barre d'outils, par exemple, commencer une trace ou arrêter le processus.

La description qui suit met en évidence quelques points dans cette vue. D'autres seront décrits quand nécessaire.

XI-B - Le contrôle de l'émulateur

La vue « Emulator Control » permet de simuler des appels téléphoniques et des SMS sur l'AVD. Il a également la possibilité de simuler la position géographique courante.

XI-C - L'explorateur de fichiers

L'explorateur de fichiers permet de parcourir le système de fichiers sur votre appareil virtuel Android.

XII - Les parties d'une application Android

XII-A - Une application Android

Une application Android est une unité installable qui peut être démarrée et utilisée indépendamment des autres applications Android.

Une application Android peut avoir une classe d'application qui est instanciée dès que l'application démarre. Cette classe d'application est le dernier composant arrêté lors de l'arrêt de l'application.

Une application Android est constituée de composants logiciels Android et fichiers de ressources.

Les composants d'une application Android peuvent se connecter à des éléments d'autres applications Android basés sur une description de tâche (Intent). De cette façon, ils peuvent créer des tâches interapplications. L'intégration de ces composants peut être faite de manière à ce que l'application Android continue à fonctionner, même si les autres composants ne sont pas installés ou si différents composants effectuent la même tâche.

XII-B - Les composants logiciels Android

Les composants logiciels suivants peuvent être définis dans les applications Android :

- Activité ou « Activity » en anglais ;

- Services ;

- Récepteurs de diffusion ou « Broadcast receivers » ou encore « receivers » en anglais ;

- Fournisseur de contenu ou « Content providers » ou encore « providers » en anglais.

XII-C - Le contexte

Les instances de la classe android.content.Context assurent la connexion au système Android qui exécute l'application. Elles donnent également accès aux ressources du projet et l'information globale sur l'environnement de l'application.

Par exemple, vous pouvez obtenir la taille de l'affichage du périphérique avec ce Context.

La classe Context donne aussi accès aux services Android. Par exemple le gestionnaire d'alarmes pour déclencher des événements en fonction du temps.

Les activités et les services dérivent de la classe Context. Par conséquent, ils peuvent être directement utilisés pour accéder au Context.

XIII - Aperçu des composants d'une application Android

XIII-A - Les activités

Une activité (activity en anglais) est la représentation visuelle d'une application Android. Une application Android peut avoir plusieurs activités.

Les activités utilisent des vues et des fragments pour créer l'interface utilisateur et pour interagir avec celui-ci. Ces deux éléments (vues et fragments) sont décrits dans les sections suivantes.

XIII-B - Les récepteurs de diffusion

Un récepteur de diffusion (Broadcast receiver en anglais) peut être enregistré pour écouter des messages et des intentions du système. Un récepteur reçoit les notifications par le système Android si l'événement spécifié se produit.

Par exemple, vous pouvez enregistrer un récepteur pour le cas où le système Android a terminé le processus de démarrage. Ou vous pouvez vous inscrire à l'événement de suivi de l'état du téléphone, par exemple, quelqu'un qui appelle.

XIII-C - Les services

Un service exécute des tâches sans fournir d'interface utilisateur. Ils peuvent communiquer avec d'autres composants Android, par exemple, par l'intermédiaire de récepteurs de diffusion et envoyer des notifications à l'utilisateur par l'intermédiaire des notifications Android.

XIII-D - Les fournisseurs de contenu

Un fournisseur de contenu (content provider en anglais) définit une interface structurée de données d'application. Un fournisseur peut être utilisé pour accéder aux données à l'intérieur d'une application, mais peut également être utilisé pour échanger des données avec d'autres applications.

Android contient une base de données SQLite qui est souvent utilisée avec un fournisseur de contenu. La base de données SQLite peut stocker les données qui deviennent accessibles via le fournisseur de contenu.

XIV - Composants de base de l'interface utilisateur dans Android

Les descriptions qui suivent donnent un aperçu de l'interface utilisateur d'une application Android.

XIV-A - Les activités

Les activités sont la base de l'interface utilisateur dans Android. Elles ont déjà été introduites dans la section 14.1, « Activité ».

XIV-B - Les fragments

Les fragments sont des composants qui fonctionnent dans le contexte d'une activité. Un fragment encapsule le code d'application de sorte qu'il est plus facile de le réutiliser et de gérer des périphériques de tailles différentes.

L'image suivante montre une activité appelée MainActivity. Sur un écran plus petit, il ne montre qu'un fragment et permet à l'utilisateur de naviguer à un autre fragment. Sur un grand écran, il montre ces deux fragments juxtaposés.

XIV-C - Les vues et la mise en page

Les vues sont des objets (widget en anglais) de l'interface utilisateur, par exemple, des boutons ou des champs texte. Les vues ont des attributs qui peuvent être utilisés pour configurer leur apparence et leur comportement.

Un groupe de vues (ViewGroup en anglais) est responsable de l'organisation d'autres vues. Il est également connu en tant que gestionnaire de mise en page. La classe de base pour ces gestionnaires de vues est la classe android.view.ViewGroup qui étend la classe android.view.View qui est la classe de base pour les vues.

Les gestionnaires de mise en page peuvent être imbriqués pour créer des modèles complexes.

XIV-D - Mise en page spécifique à la configuration d'un périphérique

L'interface utilisateur pour les activités est généralement définie par des fichiers XML (fichiers de mise en page). Il est possible de définir des fichiers de mise en page spécifiques pour des configurations d'appareils différents, par exemple, par rapport à la largeur disponible du dispositif qui exécute l'application.

XV - Autres éléments importants d'Android

XV-A - Écran d'accueil et écran de verrouillage

Les widgets sont des éléments interactifs qui sont principalement utilisés sur l'écran d'accueil d'Android. Ils affichent généralement un certain type de données et permettent à l'utilisateur d'effectuer des actions avec eux. Par exemple, un widget peut afficher un résumé de nouveaux e-mails et si l'utilisateur sélectionne un e-mail, il peut lancer l'application de messagerie sur l'e-mail sélectionné.

Pour éviter toute confusion avec les vues (qui sont aussi des widgets), ce document utilise le terme widget de l'écran d'accueil s'il parle de ce widget.

XV-B - Fonds d'écran animés

Les fonds d'écran animés permettent de créer des arrière-plans animés pour l'écran d'accueil d'Android.

XVI - Le manifeste Android

XVI-A - Configuration de votre application Android

Les composants et les paramètres d'une application Android sont décrits dans le fichier AndroidManifest.xml. Ce fichier est connu comme le fichier manifeste ou le manifeste.

Le manifeste précise également des métadonnées supplémentaires pour l'application, par exemple, les icônes et le numéro de version de l'application.

Ce fichier est lu par le système applications lors de l'installation de l'application. Le système Android évalue ce fichier de configuration et détermine les capacités de l'application.

XVI-B - Déclarer les composants dans un fichier manifeste

Toutes les activités, les services et les fournisseurs de contenu de l'application doivent être déclarés de manière statique dans ce fichier. Les fournisseurs de contenu peuvent être déclarés de manière statique dans le fichier manifeste ou dynamiquement lors de l'exécution de l'application.

XVI-C - Les permissions

Le fichier manifeste Android doit également contenir les permissions requises pour l'application. Par exemple, si l'application nécessite l'accès au réseau, il doit être spécifié ici.

XVI-D - Fichier d'exemple AndroidManifest.xml

Le listing suivant montre un exemple d'un fichier AndroidManifest.xml simple :

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.example.android.rssfeed"
android:versionCode="1"
android:versionName="1.0" >

<uses-sdk
android:minSdkVersion="16"
android:targetSdkVersion="19" />

<uses-permission android:name="android.permission.INTERNET" />

<application
android:name="RssApplication"
android:allowBackup="false"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name="RssfeedActivity"
android:label="@string/title_activity_main" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
<activity
android:name=".DetailActivity"
android:label="Details" >
</activity>
<activity android:name="MyPreferenceActivity" >
</activity>

<service android:name="RssDownloadService" >
</service>
</application>

</manifest>

XVII - Le manifeste Android

XVII-A - Version et package

L'attribut package définit le package de base pour les objets Java référencés par ce fichier. Si un objet Java se trouve dans un package différent, il doit être déclaré avec le nom complètement qualifié du package.

Google Play impose que chaque application Android utilise son propre nom unique de package. Par conséquent, une bonne habitude est d'utiliser votre nom de domaine inverse. Cela permet d'éviter les collisions avec d'autres applications Android.

Les attributs android:versionName et android:codeVersion permettent de préciser la version de votre application.

- versionName est ce que l'utilisateur voit et peut être n'importe quelle chaîne de caractères.

- codeVersion doit être un entier. L'Android Market détermine s'il doit effectuer une mise à jour de l'application existante sur la base de ce codeVersion. Vous commencerez généralement à « 1 » et augmentez cette valeur si vous créez une nouvelle version de votre application.

XVII-B - Application et composants

La section <application> permet de définir les métadonnées pour votre application et éventuellement définir une classe d'application explicite. C'est également un conteneur pour déclarer vos composants Android.

La balise <activity> définit une composante de type activité. Son attribut « name » pointe sur la classe, qui (si elle n'est pas pleinement qualifiée) est relative au package défini avec l'attribut package.

La partie « intent filter » du fichier manifeste Android déclare à Android que cette activité doit être enregistrée comme un point d'entrée possible dans l'application et mise à disposition dans le lanceur du système Android. L'action définit qu'il (android:name = « android.intent.action.MAIN ») peut être démarré et le paramètre android:name = « android.intent.category.LAUNCHER » indique au système Android d'ajouter l'activité dans le lanceur.

La valeur @chaîne/app_name fait référence au fichier de ressources qui contient la valeur réelle du nom de l'application. L'utilisation d'un fichier de ressources permet de faciliter l'accès à différentes ressources (par exemple, des chaînes, des couleurs, des icônes) pour les différents périphériques et faciliter la traduction des applications.

De même qu'avec la balise <activity>, vous pouvez utiliser <service>, <receiver> et <provider> pour déclarer d'autres composants Android.

XVII-C - SDK minimum et cible

La section « use-sdk » du fichier manifeste permet de spécifier la version minSdkVersion et targetSdkVersion de votre application :

Valeur

Description

MinSdkVersion

Définir la version minimale d'Android sur laquelle votre application peut fonctionner. Cet attribut est utilisé comme un filtre dans Google Play, c'est-à-dire qu'un utilisateur ne peut pas installer votre application sur un périphérique avec un niveau d'API inférieur à celui spécifié par cet attribut.

targetSdkVersion

Indique la version sur laquelle vous avez testé et développé. Si elle n'est pas égale à la version de l'API de l'appareil Android, le système Android peut appliquer les changements avant ou arrière pour assurer la compatibilité. Il est une bonne pratique de toujours définir cet attribut avec la dernière version de l'API Android afin de profiter des changements et des améliorations des dernières versions Android.

Table 4. Versions minimum et cible

XVII-D - Permissions

Votre application peut déclarer les permissions requises avec la balise <permission> et déclarer qu'il faut une permission particulière avec la balise <uses-permission>.

XVII-E - Configuration périphérique requise

La section uses-configuration dans le manifeste permet de spécifier les méthodes d'entrée requises pour votre appareil. Par exemple, avec le code suivant, il faudrait que le dispositif comporte un clavier physique.

<uses-configuration android:reqHardKeyboard="true"/>

La section uses-feature permet de spécifier la configuration matérielle requise pour votre appareil. Par exemple, avec le code suivant, il faudrait que l'appareil possède une caméra.

<uses-feature android:name="android.hardware.camera" />

XVII-F - Emplacement d'installation

Avec l'attribut installLocation de votre application, vous pouvez spécifier si elle peut être installée sur le stockage externe de l'appareil. Utilisez « auto » ou « preferExternal » pour cela.

En réalité, cette option est rarement utilisée, car une application installée sur la mémoire externe est arrêtée quand l'appareil est connecté à un ordinateur et est monté en tant que stockage USB.

XVII-G - Plus d'information

Vous trouverez plus d'informations sur les attributs et les sections du manifeste dans la documentation du manifeste Android.

XVIII - Les ressources

XVIII-A - Les fichiers de ressources

Les ressources, comme les images et les fichiers de configuration XML, sont séparées du code source des applications Android.

Les fichiers de ressources doivent être placés dans le répertoire /res dans un sous-dossier prédéfini. Le nom de ce sous-dossier dépend du type de ressources qui y est stocké.

Le tableau suivant donne un aperçu des ressources prises en charge ainsi que le sous-dossier standard.

Ressource

Répertoire

Description

Dessins (drawables)

/res/drawables

Images (fichiers PNG ou JPEG par exemple ) ou fichiers XML qui décrivent un dessin (Drawable).

Valeurs simples

/res/values

Permet de définir des chaînes de caractères, des couleurs, des dimensions, des styles et des tableaux statiques de chaînes ou d'entiers via des fichiers XML. Par convention chaque type est stocké dans un fichier séparé, par exemple, les chaînes sont définies dans le fichier /res/values/strings.xml.

Mises en page (layouts)

/res/layout

Fichiers XML avec les mises en page utilisées pour définir l'interface utilisateur des activités et fragments.

Styles et Thèmes

/res/values

Fichiers qui définissent l'apparence de votre application Android.

Animations

/res/animator

Définitions XML pour l'API d'animation qui permet de modifier des propriétés arbitraires d'objets au cours du temps.

Données brutes (raw data)

/res/raw

Des fichiers arbitraires enregistrés dans leur forme brute. Vous y accédez via un objet InputStream.

Menus

/res/menu

Définit les propriétés des entrées d'un menu.

Table 5. Ressources

XVIII-B - Exemple

Le code suivant est un exemple de fichier appelé values.xml dans /res/values qui définit quelques constantes de chaîne, un tableau de chaînes, une couleur et une dimension.

<?xml version="1.0" encoding="utf-8"?>
<resources>

<string name="app_name">Test</string>
<string name="action_settings">Settings</string>
<string name="hello_world">Hello world!</string>

<string-array name="operationsystems">
<item>Ubuntu</item>
<item>Android</item>
<item>Microsoft Windows</item>
</string-array>

<color name="red">#ffff0000</color>

<dimen name="mymargin">10dp</dimen>

</resources>

XVIII-C - Qualificateur de ressource

Vous pouvez également ajouter des qualificatifs supplémentaires au nom du sous-dossier pour indiquer que ces ressources ne devraient être utilisées pour des configurations spéciales. Par exemple, vous pouvez spécifier que le fichier de mise en page n'est valable que pour une certaine taille de l'écran.

XVIII-D - Identifiant de ressources et R.java

Chaque ressource reçoit un ID affecté par le système de construction Android. Le répertoire « gen » dans le projet Android contient le fichier de références R.java qui contient ces valeurs générées. Ces références sont des valeurs entières statiques.

Si vous ajoutez un nouveau fichier de ressources, la référence correspondante est automatiquement créée dans un fichier R.java. Les modifications manuelles dans le fichier R.java ne sont pas nécessaires et seront écrasées par les outils.

Le système Android fournit des méthodes pour accéder aux fichiers de ressources correspondantes par ces ID.

Par exemple, pour accéder à une chaîne avec l'ID R.string.yourString dans votre code source, vous pouvez utiliser la méthode getString(R.string.yourString) définie avec la classe Context.

XVIII-E - Bonnes pratiques pour les ID de ressources

Le SDK Android utilise la notation camelCase pour la plupart de ses ID, par exemple, buttonRefresh. Il est bon de suivre cette pratique.

XVIII-F - Les ressources système

Android fournit également des ressources. Celles-ci sont appelées ressources système. Les ressources du système sont distinguées des ressources locales par le préfixe d'espace de nommage android. Par exemple, android.R.string.cancel définit la chaîne de caractères pour une opération d'annulation.

XIX - Les fichiers de mise en page

XIX-A - Mise en page et activité

Les activités Android définissent leur interface utilisateur avec des vues (widgets) et les fragments. Cette interface utilisateur peut être définie via les fichiers de ressources de mise en page XML dans le répertoire /res/layout ou via le code Java. Vous pouvez également mixer ces deux approches.

Définir des mises en page avec des fichiers XML est le moyen privilégié. Cela sépare la logique de programmation de la définition de mise en page. Cela permet également la définition de différentes configurations pour différents appareils.

XIX-B - Les fichiers de mise en page XML

Un fichier de ressources de mise en page est désigné comme un layout. Un tel fichier spécifie les ViewGroups, les vues, leurs relations et leurs attributs via une représentation XML.

Le code suivant est un exemple d'un fichier de mise en page simple :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity" >

<TextView
android:id="@+id/mytext"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/hello_world" />

</RelativeLayout>

Une mise en page est affectée à une activité avec l'appel à la fonction setContentView () comme le montre l'exemple de code suivant :

package com.vogella.android.first;

import android.os.Bundle;
import android.app.Activity;
import android.view.Menu;

public class MainActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
}

}

XIX-C - Définir des identifiants (ID)

Si une vue doit être accédée avec le code Java, vous devez utiliser l'identifiant unique de cette vue donné par l'attribut android:id. Pour attribuer un nouveau numéro à une vue, utilisez l'attribut android:id de l'élément correspondant dans le fichier de configuration. Le tableau suivant montre un exemple dans lequel un bouton obtient l'ID de button1 défini avec l'attribut android:id=« @+id/button1 ».

<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Show Preferences" >
</Button>

Lors de la conversion de cette déclaration, cela crée un nouvel ID si nécessaire dans le fichier R.java et assigne cet ID à la vue correspondante.

XIX-D - Bonnes pratiques : ID prédéfinis avec un fichier séparé

Comme décrit dans paragraphe précédent, Android vous permet de définir les ID les composants de l'interface utilisateur dynamique dans les fichiers de mise en page. Pour avoir un endroit central pour définir les ID, vous pouvez également les définir dans un fichier de configuration.

Pour contrôler vos identifiants, vous pouvez également créer un fichier, généralement appelé ids.xml, dans le répertoire /res/values et définir vos identifiants dans ce fichier. Le code suivant montre un exemple d'un tel fichier :

<?xml version="1.0" encoding="utf-8"?>
<resources>
<item name="button1" type="id"/>
</resources>

Cela vous permet d'utiliser l'ID de votre fichier de mise en page de cette façon :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity" >

<Button
android:id="@id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_centerVertical="true"
android:layout_marginRight="27dp"
android:text="Button" />

</RelativeLayout>

XIX-E - Considération de performance avec les layouts

Le calcul de la mise en page et le dessin d'une vue est une opération à forte demande de ressources CPU. Vous devez utiliser la mise en page la plus simple possible pour obtenir de bonnes performances. Par exemple, vous devriez éviter les imbrications trop profondes ou éviter d'utiliser des mises en pages complexes dans le cas où une mise en page simple est suffisante.

XX - Views Les vues

XX-A - La classe View

Une vue Android représente un widget, par exemple, un bouton, un gestionnaire de mise en page.

Toutes les vues dans Android dérivent de la classe android.view.View. Cette classe est relativement importante (plus de 18 000 lignes de code) et fournit un grand nombre de fonctionnalités de base pour les sous-classes.

XX-B - Les vues standard

Le SDK Android fournit des vues standard (widgets), par exemple, par l'intermédiaire des classes Button, TextView, EditText.

Il comprend aussi des widgets complexes, par exemple ListView ou GridView pour afficher des données structurées.

Les principaux paquetages pour les vues font partie de l'espace de noms android.view pour toutes les classes de base et android.widget pour les widgets par défaut de la plate-forme Android.

XX-C - Les vues personnalisées

Les développeurs peuvent implémenter leurs propres vues en les dérivant de la classe android.view.View.

XXI - Le gestionnaire de mise en page et les groupements de vues

XXI-A - Qu'est-ce qu'un gestionnaire de mise en page ?

Un gestionnaire de mise en page est une sous-classe de ViewGroup et est responsable de la mise en page pour lui-même et ses vues enfants. Android supporte différents gestionnaires de disposition par défaut.

XXI-B - Gestionnaires de mise en page importants

Depuis Android 4.0, les gestionnaires de mise en page les plus importants sont LinearLayout, FrameLayout, RelativeLayout et GridLayout.

AbsoluteLayout est obsolète et TableLayout peut être mis en œuvre plus efficacement avec GridLayout.

RelativeLayout est un gestionnaire de mise en page complexe et ne doit être utilisé que si un tel schéma complexe est nécessaire, car il effectue des calculs intensifs pour la mise en page de ses enfants.

XXI-C - Les attributs d'une mise en page

Toutes les mises en page permettent au développeur de définir leurs attributs. Les enfants peuvent également définir des attributs qui peuvent être évalués par la mise en page du parent.

Les enfants peuvent préciser leur largeur et hauteur souhaitées avec les attributs suivants :

Attribut

Description

android:layout_width

Définit la largeur du widget.

android:layout_height

Définit la hauteur du widget.

Table 6. Définition de la hauteur et de la largeur

Les widgets peuvent utiliser une taille fixe, avec l'utilisation de « dp » par exemple, 100dp. Alors que dp est une taille fixe, il sera mis à l'échelle suivant les configurations des différents périphériques.

La valeur « match_parent » indique à l'application de maximiser le widget dans son parent. La valeur « wrap_content » indique au gestionnaire d'allouer la taille minimum de sorte que le widget soit rendu correctement. L'effet de ces éléments est illustré dans les graphiques suivants :

XXI-D - Le gestionnaire FrameLayout

FrameLayout est un gestionnaire de mise en page qui positionne tous les éléments enfants au-dessus des autres. Cela permet de créer de jolis effets visuels.

La capture d'écran ci-dessous montre l'application Gmail qui utilise FrameLayout pour afficher plusieurs boutons sur le dessus d'une autre mise en page.

XXI-E - Le gestionnaire LinearLayout

LinearLayout positionne tous ses éléments enfants dans une seule colonne ou ligne en fonction de l'attribut android:orientation. Les valeurs possibles pour cet attribut sont « horizontal » ou « vertical ». Horizontal est la valeur par défaut.

Si horizontal est utilisé, les éléments enfants sont mis en page comme indiqué par l'image suivante :

Vertical entraînerait une mise en page comme illustré dans l'image suivante :

Les gestionnaires LinearLayout peuvent être imbriqués pour obtenir des dispositions plus complexes.

LinearLayout permet d'attribuer un poids à chaque enfant avec l'attribut android:layout_weight. Cette valeur indique combien de l'espace supplémentaire dans la mise en page est alloué à la vue. Si, par exemple, vous avez deux widgets et que le premier définit une layout_weight de 1 et le second de 2, le premier obtiendra un tiers de l'espace disponible et l'autre 2/3. Vous pouvez également définir le layout_width à zéro pour avoir toujours un certain rapport.

XXI-F - Le gestionnaire RelativeLayout

RelativeLayout permet de positionner le widget par rapport aux autres. Il peut être utilisé pour des mises en page plus complexes.

Une utilisation simple du RelativeLayout permet de centrer un seul composant. Il suffit d'ajouter un composant au RelativeLayout et positionner l'attribut android:layout_centerInParent à true.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:orientation="vertical" >

<ProgressBar
android:id="@+id/progressBar1"
style="?android:attr/progressBarStyleLarge"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerInParent="true"
/>

</RelativeLayout>

XXI-G - Le gestionnaire GridLayout

GridLayout a été introduit avec Android 4.0. Cette disposition permet d'organiser une vue sur une grille. GridLayout sépare sa zone de dessin en lignes, colonnes et cellules.

Vous pouvez spécifier le nombre de colonnes que vous souhaitez pour chaque vue, dans quelles ligne et colonne, il doit être placé ainsi que le nombre de colonnes et de lignes qu'il doit utiliser. Si ce n'est pas spécifié, GridLayout utilise par défaut, une colonne, une ligne et la position de la vue dépend de l'ordre de la déclaration des vues.

Le code de mise en page suivant définit une mise en page avec GridLayout :

<?xml version="1.0" encoding="utf-8"?>
<GridLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/GridLayout1"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:columnCount="4"
android:useDefaultMargins="true" >

<TextView
android:layout_column="0"
android:layout_columnSpan="3"
android:layout_gravity="center_horizontal"
android:layout_marginTop="40dp"
android:layout_row="0"
android:text="User Credentials"
android:textSize="32dip" />

<TextView
android:layout_column="0"
android:layout_gravity="right"
android:layout_row="1"
android:text="User Name: " >
</TextView>

<EditText
android:id="@+id/input1"
android:layout_column="1"
android:layout_columnSpan="2"
android:layout_row="1"
android:ems="10" />

<TextView
android:layout_column="0"
android:layout_gravity="right"
android:layout_row="2"
android:text="Password: " >
</TextView>

<EditText
android:id="@+id/input2"
android:layout_column="1"
android:layout_columnSpan="2"
android:layout_row="2"
android:inputType="textPassword"
android:ems="8" />

<Button
android:id="@+id/button1"
android:layout_column="2"
android:layout_row="3"
android:text="Login" />

</GridLayout>

Cela crée une interface utilisateur similaire à la capture d'écran ci-dessous :

XXI-H - La classe ScrollView

La classe ScrollView peut être utilisée pour contenir une vue qui pourrait être trop grande pour tenir sur un seul écran. Dans ce cas, ScrollView affiche une barre de défilement.

Bien sûr, cela peut être un gestionnaire de mise en page qui peut alors contenir d'autres éléments.

Le code suivant montre un exemple de fichier de mise en page qui utilise une ScrollView :

<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fillViewport="true"
android:orientation="vertical" >

<TextView
android:id="@+id/TextView01"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:paddingLeft="8dip"
android:paddingRight="8dip"
android:paddingTop="8dip"
android:text="This is a header"
android:textAppearance="?android:attr/textAppearanceLarge" >
</TextView>

</ScrollView>

L'attribut android:fillViewport=« true » fait en sorte que la scrollview s'affiche en mode plein écran, même si les éléments sont plus petits que la taille de l'écran.

XXII - Exercice : Utilisation des layouts et ajout d'interactions

XXII-A - Examen du layout

Dans votre projet com.vogella.android.first, ouvrez le fichier de mise en page activity_main.xml dans le répertoire res/layout.

Étudiez la mise en page XML dans l'éditeur visuel ainsi que dans la structure du fichier XML.

XXII-B - Enlever les vues existantes

Supprimez toutes les vues, sauf l'entrée de haut niveau qui est le gestionnaire de disposition. Dans le mode de conception visuelle, vous pouvez supprimer une vue par un clic droit dessus puis en sélectionnant l'option « Delete » du menu contextuel.

Le fichier de mise en page résultant doit ressembler au code suivant :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity" >

</RelativeLayout>

XXII-C - Ajouter et configurer les vues

Ajoutez un EditText (texte brut) et un bouton à votre mise en page. Le plus simple est de trouver ces éléments dans la palette et de les faire glisser et déposer dans votre mise en page.

Utilisez l'éditeur XML pour modifier l'ID du nouveau champ EditText à main_input. Dans le fichier XML, cela ressemble @+id/main_input.

Changez la couleur de fond de votre mise en page pour la couleur argent (# C0C0C0). Utilisez la propriété android:background pour cela.

XXII-D - Ajout d'un bouton interactif

Modifiez le texte du bouton pour « Start » avec la propriété android:text property dans le fichier de mise en page.

Assignez la fonction onClick à la propriété android:onClick de votre bouton.

Ceci définit que la fonction « public void onClick (View view) » sera appelée dans l'activité quand le bouton est pressé.

Le résultat de la mise en page devrait ressembler à ceci :

Créez la méthode suivante dans votre classe MainActivity :

public void onClick (View view) {
Toast.makeText(this, "Button 1 pressed",
Toast.LENGTH_LONG).show();
}

XXII-E - Validation de l'action du bouton

Démarrez votre application et appuyez sur le bouton « Start ». Vérifiez qu'un message (Toast) est bien affiché.

XXII-F - Afficher du texte depuis le champ EditText

Retournez dans votre code source et utilisez la fonction findViewById(id) avec l'identifiant correct en transformant (castant) la valeur retournée en EditText. Par exemple, EditText text = (EditText) findViewById(id). Vous pouvez obtenir la valeur correcte de l'identifiant en utilisant la classe « R ». Il doit se trouver parmi les « ID » et s'appeler main_input.

Utilisez la méthode text.getText().toString() pour lire la valeur du champ EditText et ajouter ce texte au message affiché (Toast).

XXII-G - Valider le message affiché

Relancez votre application, et assurez-vous que le message affiché correspond au contenu du champ EditText.

XXII-H - Solution

Après ces changements, votre fichier de mise en page devrait ressembler à ceci :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity" >

<EditText
android:id="@+id/main_input"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_alignParentTop="true"
android:layout_marginLeft="14dp"
android:ems="10" >

<requestFocus />
</EditText>

<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignLeft="@+id/editText1"
android:layout_below="@+id/editText1"
android:layout_marginTop="31dp"
android:onClick="onClick"
android:text="Start" />

</RelativeLayout>

Vous risquez d'avoir quelques warnings dans l'éditeur parce que vous utilisez des chaînes de caractères codées en dur. Ces warnings peuvent être ignorés pour une si petite application de démonstration.

Et le code de votre activité devrait être semblable à ceci :

package com.vogella.android.first;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.EditText;
import android.widget.Toast;

public class MainActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
if (BuildConfig.DEBUG) {
Log.d(Constants.LOG, "onCreated called");
}
setContentView(R.layout.activity_main);
}

// you may have here an onCreateOptionsMenu method
// this method is not required for this exercise
// therefore I deleted it

public void onClick(View view) {
EditText input = (EditText) findViewById(R.id.main_input);
String string = input.getText().toString();
Toast.makeText(this, string, Toast.LENGTH_LONG).show();
}
}

XXIII - Exercice : modifier la mise en page dynamiquement

XXIII-A - Ajout de boutons radio à la mise en page

Continuez à utiliser le projet com.vogella.android.first. Dans cet exercice, vous ajouterez des boutons radio de votre mise en page. Selon le choix de l'utilisateur, l'arrangement des boutons radio sera horizontal ou vertical.

Ouvrez votre fichier de mise en page et ajoutez un groupe de boutons radio (RadioGroup) contenant deux boutons radio.

Dans le cas où vous auriez des problèmes lors de la création des boutons radio avec l'éditeur visuel, vous trouverez l'extrait de code XML résultant plus loin dans cet exercice.

Le groupe de boutons radio est difficile à trouver dans la palette des outils, le widget est mis en évidence dans la capture d'écran ci-dessous. Si nécessaire, supprimez des boutons radio jusqu'à ce que vous ne disposiez plus que de deux boutons.

Pour assigner les ID aux widgets, utilisez l'attribut android:id, par exemple android: id="@+id/orientation.

Assign them based on the following table.

ID

Widget

orientation

Groupe de boutons radio

horizontal

Premier bouton radio

vertical

Second bouton radio

Table 7. Valeurs des ID

Le résultat de votre fichier de mise en page devrait être similaire à ceci :

<!-- this snippet is part of the larger layout file -->

<RadioGroup
android:id="@+id/orientation"
android:layout_width="match_parent"
android:layout_height="wrap_content" >

<RadioButton
android:id="@+id/horizontal"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Horizontal" >
</RadioButton>

<RadioButton
android:id="@+id/vertical"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:checked="true"
android:text="Vertical" >
</RadioButton>
</RadioGroup>

Le résultat de cette mise en page devrait ressembler à cette copie d'écran :

XXIII-B - Changer l'orientation du groupe dynamiquement

Modifiez la fonction onCreate() de votre activité. Utilisez la méthode findViewById() pour retrouver votre RadioGroup dans la mise en page.

Implémentez un listener sur ce groupe de boutons radio qui modifie son orientation en se basant sur la sélection courante du bouton. Le bouton actuellement sélectionné peut être identifié par son identifiant.

L'objet RadioGroup vous permet d'ajouter un RadioGroup.OnCheckedChangeListener (issu de android.widget.RadioGroup) avec la méthode setOnCheckedChangeListener(). Cet écouteur (Listener) est appelé lors de tout changement de sélection du groupe de boutons radio.

Vous pouvez utiliser le code suivant comme modèle pour créer le listener.

RadioGroup group1 = (RadioGroup) findViewById(R.id.orientation);
group1.setOnCheckedChangeListener(new RadioGroup.OnCheckedChangeListener() {
@Override
public void onCheckedChanged(RadioGroup group, int checkedId) {
switch (checkedId) {
case R.id.horizontal:
group.setOrientation(LinearLayout.HORIZONTAL);
break;
case R.id.vertical:
group.setOrientation(LinearLayout.VERTICAL);
break;
}
}
});

XXIII-C - Validation

Lancez votre application et sélectionnez les différents boutons radio. Assurez-vous que l'orientation des boutons est modifiée en fonction de votre sélection.

XXIV - Exercice : Créer un convertisseur de température

XXIV-A - Application de démonstration

Dans cet exercice, nous allons apprendre à créer et utiliser des ressources Android et réviser la création d'une application interactive.

Cette application est disponible sur Google Play avec l'URL suivante : Android Temperature converter

Sinon, vous pouvez aussi scanner le code-barres ci-dessous avec votre téléphone Android pour l'installer via l'application Google Play.

XXIV-B - Créer le projet

Selectionnez l'option « File ? New ? Other… ? Android ? Android Application Project » pour créer un nouveau projet Android avec les informations suivantes :

Propriété

Valeur

Application Name

Temperature Converter

Project Name

de.vogella.android.temperature

Package name

de.vogella.android.temperature

API (Minimum, Target, Compile with)

Latest

Template

Empty Activity

Activity

MainActivity

Layout

activity_main

Table 8. Nouveau projet Android

À la fin de la création, une structure projet semblable à l'image suivante est créée :

XXIV-C - Créer les attributs

Android vous permet de créer des ressources statiques pour définir des attributs, par exemple des chaînes de caractères ou bien des couleurs. Ces attributs peuvent être utilisés dans les fichiers XML ou par le code source Java.

Sélectionnez le fichier res/values/string.xml pour ouvrir l'éditeur de ce fichier.

Vous voulez ajouter une définition de couleur à ce fichier ? Appuyez sur le bouton « Add » pour cela :

Sélectionnez le choix « Colour » dans la boîte de dialogue et appuyez sur le bouton « OK ».

Entrez le nom myColor et #F5F5F5 comme valeur.

Ajoutez d'autres attributs, cette fois-ci des chaînes de caractères (String). Les attributs « Chaîne de caractères » permettent plus tard au développeur de traduire l'application.

Nom

Valeur

celsius

to Celsius

fahrenheit

to Fahrenheit

calc

Calculate

Table 9. Chaînes de caractères

Basculez en mode « représentation XML » et validez que les valeurs sont correctes :

<?xml version="1.0" encoding="utf-8"?>
<resources>

<string name="app_name">Temperature Converter</string>
<string name="action_settings">Settings</string>
<string name="hello_world">Hello world!</string>
<color name="myColor">#F5F5F5</color>
<string name="celsius">to Celsius</string>
<string name="fahrenheit">to Fahrenheit</string>
<string name="calc">Calculate</string>

</resources>

XXIV-D - Utiliser l'éditeur de mise en page

Sélectionnez le fichier res/layout/activity_main.xml. Ouvrez l'éditeur Android associé avec un double-clic sur le fichier. Cet éditeur vous permet de créer la mise en page avec du « drag and drop » ou encore en modifiant directement le fichier XML. Vous pouvez basculer d'une représentation à l'autre avec les onglets au-dessous de l'éditeur. Pour modifier la position et le regroupement des éléments, vous pouvez utiliser la vue Eclipse « Outline ».

L'image suivante montre une capture d'écran de la palette à côté de cet éditeur. Cet élément vous permet de glisser-déposer de nouveaux éléments dans votre mise en page. Pour identifier les éléments de la vue plus facilement, vous pouvez changer la représentation pour afficher l'icône et le texte tel que représenté sur la capture d'écran ci-dessous :

La vue de la Palette change fréquemment, ce que vous voyez peut être légèrement différent.

XXIV-E - Ajouter des objets à votre mise en page

Dans cette partie de l'exercice, nous allons créer l'interface utilisateur de base pour votre application.

Faites un clic droit sur l'objet text « Hello World! » dans la mise en page. Sélectionnez l'option « Delete » du menu contextuel pour supprimer cet objet texte.

Ensuite, sélectionnez la section « Text Fields » dans la palette et localisez le texte brut ou Plain Text (en vous aidant de l'info-bulle).

Cliquez sur l'entête de la section « Text Field » pour voir tous les champs texte. Faites glisser le widget de texte brut (Plain Text) sur votre mise en page pour créer un champ de saisie de texte.

Toutes les entrées de la section Champs de texte définissent des champs de texte. Les différentes entrées définissent des attributs supplémentaires, par exemple, si un champ de texte ne doit contenir que des chiffres.

Ensuite, sélectionnez la section Formulaire Widgets dans la palette et faites glisser une entrée RadioGroup dans votre mise en page. Le nombre de boutons radio ajoutés au groupe de boutons radio dépend de votre version d'Eclipse. Assurez-vous qu'il y a deux boutons radio en supprimant ou en ajoutant des boutons radio pour le groupe.

Ensuite, glissez un bouton sur votre mise en page.

Le résultat devrait ressembler à ceci :

Passez à l'onglet XML de votre fichier de mise en page et vérifiez que le fichier ressemble au code suivant. ADT modifie les modèles de temps en temps de sorte que votre XML pourrait être légèrement différent :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity" >

<EditText
android:id="@+id/editText1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_alignParentTop="true"
android:ems="10" />

<RadioGroup
android:id="@+id/radioGroup1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignLeft="@+id/editText1"
android:layout_below="@+id/editText1" >

<RadioButton
android:id="@+id/radio0"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:checked="true"
android:text="RadioButton" />

<RadioButton
android:id="@+id/radio1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="RadioButton" />
</RadioGroup>

<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignLeft="@+id/radioGroup1"
android:layout_below="@+id/radioGroup1"
android:layout_marginTop="22dp"
android:text="Button" />

</RelativeLayout>

Il y a quelques warnings liés au fait que l'on utilise des chaînes de caractères codées en dur. Ceci sera fixé dans la prochaine section de cet exercice.

XXIV-F - Éditer les propriétés des objets

Vous pouvez ajouter et modifier les propriétés d'une vue directement dans le fichier XML. Les outils Android fournissent également des assistants de contenu via le raccourci clavier Ctrl + Espace.

Les attributs d'une vue peuvent également être modifiés à l'aide de la vue Propriétés Eclipse ou via le menu contextuel de la vue. Mais la modification des propriétés dans le fichier XML est typiquement plus rapide si vous savez ce que vous voulez changer.

Basculez vers la vue XML et affectez la valeur @string/Celsius à la propriété android:text du premier bouton de la radio. Affectez la valeur @string/Fahrenheit à la propriété android:text du deuxième bouton radio.

À partir de maintenant, il est supposé que vous êtes capable de modifier les propriétés de vos vues dans un fichier de mise en page.

Assurez-vous que la propriété « Checked » a la valeur « true » pour le premier RadioButton.

Attribuez @string/calc à la propriété texte de votre bouton et affectez la valeur onClick à la propriété OnClick.

Définissez la propriété « inputType » à « numberSigned » et « numberDecimal » pour le champ EditText. Par exemple, vous pouvez utiliser la dernière ligne de l'extrait de code XML suivant.

<EditText
android:id="@+id/editText1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_alignParentTop="true"
android:ems="10"
android:inputType="numberSigned|numberDecimal" />

Tous les composants de l'interface utilisateur sont contenus dans une mise en page. Affectez la couleur de fond à cette page. Choisissez la couleur et puis sélectionnez myColor dans la boîte de dialogue. Par exemple, vous pouvez utiliser la dernière ligne de l'extrait de code XML suivant :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity"
android:background="@color/myColor">

Ensuite, le fond doit changer pour la couleur « whitesmoke ». Il peut être difficile de voir la différence.

Passez à l'onglet activity_main.xml et vérifiez que le XML est correct :

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".MainActivity"
android:background="@color/myColor">

<EditText
android:id="@+id/editText1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignParentLeft="true"
android:layout_alignParentTop="true"
android:ems="10"
android:inputType="numberSigned|numberDecimal" />

<RadioGroup
android:id="@+id/radioGroup1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignLeft="@+id/editText1"
android:layout_below="@+id/editText1" >

<RadioButton
android:id="@+id/radio0"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:checked="true"
android:text="@string/celsius" />

<RadioButton
android:id="@+id/radio1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/fahrenheit" />
</RadioGroup>

<Button
android:id="@+id/button1"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignLeft="@+id/radioGroup1"
android:layout_below="@+id/radioGroup1"
android:layout_marginTop="22dp"
android:text="@string/calc"
android:onClick="onClick" />

</RelativeLayout>

XXIV-G - Créer la classe utilitaire

Créez la classe de service suivant pour convertir des degrés Celsius en Fahrenheit et vice versa :

package de.vogella.android.temperature;

public class ConverterUtil {
// converts to celsius
public static float convertFahrenheitToCelsius(float fahrenheit) {
return ((fahrenheit - 32) * 5 / 9);
}

// converts to fahrenheit
public static float convertCelsiusToFahrenheit(float celsius) {
return ((celsius * 9) / 5) + 32;
}
}

XXIV-H - Modifier le code de l'activité

L'assistant de projet Android a créé la classe MainActivity correspondant au code de votre activité. Modifiez-le pour ceci :

package de.vogella.android.temperature;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;
import android.widget.RadioButton;
import android.widget.Toast;

public class MainActivity extends Activity {
private EditText text;

@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
text = (EditText) findViewById(R.id.editText1);

}

// this method is called at button click because we assigned the name to the
// "OnClick property" of the button
public void onClick(View view) {
switch (view.getId()) {
case R.id.button1:
RadioButton celsiusButton = (RadioButton) findViewById(R.id.radio0);
RadioButton fahrenheitButton = (RadioButton) findViewById(R.id.radio1);
if (text.getText().length() == 0) {
Toast.makeText(this, "Please enter a valid number",
Toast.LENGTH_LONG).show();
return;
}

float inputValue = Float.parseFloat(text.getText().toString());
if (celsiusButton.isChecked()) {
text.setText(String
.valueOf(ConverterUtil.convertFahrenheitToCelsius(inputValue)));
celsiusButton.setChecked(false);
fahrenheitButton.setChecked(true);
} else {
text.setText(String
.valueOf(ConverterUtil.convertCelsiusToFahrenheit(inputValue)));
fahrenheitButton.setChecked(false);
celsiusButton.setChecked(true);
}
break;
}
}

}

La méthode onClick est appelée par un clic sur le bouton en raison de la propriété OnClick du bouton.

XXIV-I - Lancer l'application

Faites un clic droit sur votre projet et sélectionnez l'option « Run-As ? Android Application ». Si l'émulateur n'est pas encore lancé, il le sera.

Tapez un nombre, sélectionnez votre conversion et appuyez sur le bouton. Le résultat doit être affiché et l'autre option devrait être sélectionnée.

XXV - Utiliser les ressources

XXV-A - Référencer les ressources dans le code

La classe « Resources » permet d'accéder à des ressources individuelles. Une instance de la classe des ressources peut être obtenue avec la méthode getResources() de la classe Context. Comme les activités et les services étendent la classe Context, vous pouvez directement utiliser cette méthode dans les implémentations de ces composants.

Une instance de la classe des ressources est également nécessaire pour d'autres classes du framework Android. Par exemple, le code suivant montre comment créer un fichier Bitmap à partir d'un ID de référence.

// BitmapFactory requires an instance of the Resource class
BitmapFactory.decodeResource(getResources(), R.drawable.ic_action_search);

XXV-B - Accéder aux vues de la mise en page depuis l'activité

Dans le code de votre activité (et aussi de votre fragment) vous aurez souvent besoin d'accéder à des objets « vues » pour obtenir et modifier leurs propriétés.

Dans une activité, vous pouvez utiliser la méthode findViewById (id) pour rechercher une vue dans la mise en page courante. L'identifiant est l'attribut ID de la vue dans la mise en page. L'utilisation de ce procédé est montrée avec le code suivant :

package com.vogella.android.first;

import android.app.Activity;
import android.os.Bundle;
import android.widget.TextView;

public class MainActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
TextView textView = (TextView) findViewById(R.id.mytext);

// TODO do something with the TextView
}

}

Il est également possible de rechercher dans une hiérarchie de vues avec la méthode findViewById (id), comme le montre l'extrait de code suivant :

// search in the layout of the activity
LinearLayout linearLayout = (LinearLayout) findViewById(R.id.mylayout);

// afterwards search in linearLayout for another view
TextView textView = (TextView) linearLayout.findViewById(R.id.mytext);

// note, you could have directly searched for R.id.mytext, the above coding
// is just for demonstration purposes

XXV-C - Référencer des ressources dans des fichiers XML

Dans vos fichiers XML, par exemple vos fichiers de mise en page, vous pouvez vous référer à d'autres ressources par le signe @.

Par exemple, si vous voulez faire référence à une couleur, qui est définie dans une ressource XML, vous pouvez vous référer à elle avec @color/your_id. Ou si vous avez défini une chaîne avec l'identifiant « titlepage »dans une ressource XML, vous pouvez y accéder via @string/titlepage.

XXV-D - Référencer des ressources système Android

Pour utiliser une ressource du système Android, inclure l'espace de noms android dans les références, par exemple android.R.string.cancel.

XXVI - Actifs (assets)

XXVI-A - Que sont les actifs ?

Alors que le répertoire « res » ne contient que des données structurées connues du système Android, le répertoire « assets » peut être utilisé pour stocker des données de n'importe quel type.

Vous pouvez accéder aux fichiers stockés dans ce répertoire en utilisant leur chemin. Le répertoire « assets » supporte aussi des sous-répertoires.

Vous pouvez aussi stocker vos données non structurées dans le répertoire « /res/raw folder », mais c'est une bonne pratique que d'utiliser le répertoire « assets » pour cela.

XXVI-B - Accéder aux actifs

Vous accédez à ces données avec le gestionnaire d'assets « AssetsManager » que vous obtenez avec la méthode getAssets() à partir d'une instance de la classe Context.

La classe AssetsManager vous permet d'accéder aux fichiers du répertoire « assets » avec un InputStream et la méthode open(). Le code suivant montre un exemple pour faire ceci :

// get the AssetManager
AssetManager manager = getAssets();

// read the "logo.png" bitmap from the assets folder
InputStream open = null;
try {
open = manager.open("logo.png");
Bitmap bitmap = BitmapFactory.decodeStream(open);
// assign the bitmap to an ImageView in this layout
ImageView view = (ImageView) findViewById(R.id.imageView1);
view.setImageBitmap(bitmap);
} catch (IOException e) {
e.printStackTrace();
} finally {
if (open != null) {
try {
open.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

XXVII - Exercice : Utiliser des ressources dans les fichiers XML et dans le code

XXVII-A - Ajouter des images à votre projet

Continuez à utiliser le projet com.vogella.android.first.

Placez deux fichiers .png de votre choix dans le répertoire « /res/drawable-mdpi ». La première image doit être appelée « initial.png » et la seconde doit être appelée « assigned.png ».

Si vous n'avez aucun fichier .png sous la main, faites une recherche Google avec « Android png files ».

XXVII-B - Ajouter des vues à votre projet

Ouvrez votre fichier de mise en page et ajoutez un nouveau bouton « Button » et une image « ImageView ».

XXVII-C - Assigner une image à votre ImageView

Assignez le fichier initial.png à votre ImageView avec le fichier de mise en page comme montré dans le code suivant :

<!--
NOTE: More attributes are required
for the correct layout of the ImageView. These are left
out for brevity
-->

<ImageView
android:id="@+id/myicon"
.... more attributes
android:src="@drawable/initial" />

XXVII-D - Modifier les images avec un clic sur le bouton

Si le bouton est cliqué, utilisez la méthode findViewById() pour rechercher l'objet ImageView. Utilisez sa méthode setImageResource() pour lui assigner le fichier .png (qui est instancié sous la forme dans objet Drawable).

Le paramètre de la méthode setImageResource() est une référence à la classe « R » pour référencer votre fichier, par exemple R.drawable.your_png_file.

XXVII-E - Validation

Assurez-vous que si vous cliquez sur le bouton, l'image affichée est modifiée.

XXVIII - Exercice : Utiliser des ScrollView

Cet exercice montre l'utilisation de la vue ScrollView pour fournir un élément de défilement de l'interface utilisateur. Créer un projet Android « de.vogella.android.scrollview » avec une activité nommée ScrollViewActivity. Utilisez activity_main.xml comme fichier de mise en page.

Modifiez le fichier de mise en page de votre activité comme ceci :

<?xml version="1.0" encoding="utf-8"?>
<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:fillViewport="true"
android:orientation="vertical" >

<LinearLayout
android:id="@+id/LinearLayout01"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:orientation="vertical" >

<TextView
android:id="@+id/TextView01"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:paddingLeft="8dip"
android:paddingRight="8dip"
android:paddingTop="8dip"
android:text="This is a header"
android:textAppearance="?android:attr/textAppearanceLarge" >
</TextView>

<TextView
android:id="@+id/TextView02"
android:layout_width="wrap_content"
android:layout_height="match_parent"
android:layout_weight="1.0"
android:text="@+id/TextView02" >
</TextView>

<LinearLayout
android:id="@+id/LinearLayout02"
android:layout_width="wrap_content"
android:layout_height="wrap_content" >

<Button
android:id="@+id/Button01"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_weight="1.0"
android:text="Submit" >
</Button>

<Button
android:id="@+id/Button02"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_weight="1.0"
android:text="Cancel" >
</Button>
</LinearLayout>
</LinearLayout>

</ScrollView>

Modifiez le code de votre activité comme ceci :

package de.vogella.android.scrollview;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.TextView;

public class ScrollViewActivity extends Activity {
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
TextView view =  (TextView) findViewById(R.id.TextView02);
String s="";
for (int i=0; i < 500; i++) {
s += "vogella.com ";
}
view.setText(s);
}
}

Lancez votre application et assurez-vous que vous pouvez scroller jusqu'aux boutons.

XXIX - Le déploiement

XXIX-A - Vue d'ensemble

En général, il y a des restrictions pour déployer une application Android sur votre appareil. Vous pouvez utiliser un port USB, vous envoyer un e-mail ou utiliser l'un des nombreux market Android pour installer l'application. Ce qui suit vous montre les plus courantes.

XXIX-B - Déploiement avec Eclipse

Activez l'option « USB Debugging » sur votre périphérique dans les paramètres. Sélectionnez « Settings ? Development Options » puis activez l'option « USB-Debugging ».

Vous pouvez aussi avoir besoin d'installer le pilote pour votre téléphone mobile. Linux et Mac OS n'en ont habituellement pas besoin alors que Windows nécessite généralement l'installation d'un pilote.

Pour les détails sur l'installation du driver sous Windows, voyez Google guide for device deployment.

La version Android minimale de votre application a besoin d'être en accord avec la version Android sur votre appareil.

Si vous avez plusieurs périphériques connectés à votre ordinateur, vous pouvez sélectionner celui qui doit être utilisé. Si un seul périphérique est connecté, l'application est automatiquement déployée sur cet appareil.

XXIX-C - Exporter l'application

Les applications Android doivent être signées avant qu'elles puissent être installées sur un appareil Android. Au cours du développement, Eclipse signe votre application automatiquement avec une clé de débogage.

Si vous voulez installer votre application sans l'IDE Eclipse, vous pouvez faire un clic droit dessus et sélectionner l'option « Android Tools ? Export Signed Application Package ».

Cet assistant permet d'utiliser une clé existante ou d'en créer une nouvelle.

S'il vous plaît, notez que vous devez utiliser la même clé de signature dans Google Play (Google Market) pour mettre à jour votre application. Si vous perdez la clé, vous ne serez plus jamais capable de mettre à jour votre application.

Veillez à sauvegarder votre clé.

XXIX-D - Avec des sources externes

Android permet également d'installer des applications directement. Il suffit de cliquer sur un lien qui pointe vers un fichier APK, par exemple, dans une pièce jointe ou sur une page Web. Android vous demandera si vous voulez installer cette application.

Cela nécessite un réglage sur l'appareil Android qui permet l'installation d'une application qui ne provient pas du Google Market. Généralement, ce paramètre se trouve dans les paramètres « Sécurité ».

XXIX-E - Google Play (Market)

Google Play nécessite un droit d'entrée une seule fois, actuellement de 25 dollars. Après cela, le développeur peut télécharger directement son application et les icônes nécessaires sous Google Play Publishing.

Google effectue une analyse automatique des applications, mais aucun processus d'approbation n'est en place. Toute demande qui ne contient pas de logiciel malveillant sera publiée. Habituellement quelques minutes après le téléchargement, l'application est disponible.

XXX - Liens et littérature

XXX-A - Code source

- Codes source d'exemple

XXX-B - Ressources Android en ligne

- Android Developer Homepage

- vogella Android online tutorials

- Android Issues / Bugs

- Android Google Groups

- Android emulator skins

XXXI - Remerciements

Nous remercions l'auteur, Lars Vogel, de nous avoir aimablement autorisés à publier son article. Cet article est une traduction autorisée dont le texte original peut être trouvé sur vogella.com. Nous remercions aussi ram-0000 pour sa traduction ainsi que Claude Leloup pour sa relecture orthographique.