Développement Android avec Android Studio et Eclipse

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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

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.

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▲

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.

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.

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

Table 1. Raccourcis de l'émulateur de périphériques 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.

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

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.

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.

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.

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.

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.

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.

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 :

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.

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

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.

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.

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.

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 :

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.

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.

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! ».

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.

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.

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.

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.

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.

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.

L'explorateur de fichiers permet de parcourir le système de fichiers sur votre appareil virtuel 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.

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.

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.

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.

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.

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.

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.

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

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.

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.

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.

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.

Les fonds d'écran animés permettent de créer des arrière-plans animés pour l'écran d'accueil d'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.

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.

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.

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>

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.

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.

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

Table 4. Versions minimum et cible

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>.

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" />

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.

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

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.

Table 5. Ressources

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>

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.

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.

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

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.

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.

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);
    }

}

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.

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>

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.

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.

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.

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

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.

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.

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 :

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 :

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.

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.

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>

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 :

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.

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.

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>

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.

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.

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();
}

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

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).

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

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>

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();
  }
}

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.

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.

Assign them based on the following table.

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 :

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.

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;
    }
  }
});

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.

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.

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

Table 8. Nouveau projet Android

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

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.

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>

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 :

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.

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>

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.

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.

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>

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;
  }
}

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;
    }
  }

}

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.

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);

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

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.

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.

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 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();
      }
    }
}

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 ».

Ouvrez votre fichier de mise en page et ajoutez un nouveau bouton « Button » et une image « 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" />

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).

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

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.

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.

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.

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é.

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é ».

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.

• Codes source d'exemple

• Android Developer Homepage
• vogella Android online tutorials
• Android Issues / Bugs
• Android Google Groups
• Android emulator skins