Depuis quelques semaines maintenant FrAndroid souhaite proposer un nouveau contenu dédié aux professionnels mais également à toute personne s’intéressant de près ou de loin au développement Android.

Nous proposons déjà chaque samedi, sauf cas exceptionnel, quelques liens de tutoriaux, articles ou outils intéressants liés au développement d’application Android.

Nous entamons avec cet article une nouvelle série : les tutoriaux de développement Android. Aujourd’hui, Internet regorge de tutoriaux plus ou moins bien fait, mais essentiellement en anglais. Les quelques tentatives francophones (comme nous l’avions fait sur notre wiki) sont parfois restées trop en surface. Afin de ne pas renouveler une expérience malheureuse, nous avons décider de partir d’un contenu existant de qualité. Nous avons eu l’autorisation de Lars Vogel de traduire ses tutoriaux dédiés à Android et reconnus pour leur qualité. Lars est l’auteur de nombreux tutoriaux et livres techniques (Java, Eclipse et Android) mais également formateur.

Nous espérons pouvoir respecter notre planning d’un tutorial toutes les deux semaines environ. C’est parti et bon courage 🙂

Ce premier chapitre qui sera découpé en quatre articles distincts, à paraître sur plusieurs semaines, est une présentation de l’écosystème Android, l’architecture, la mise en place de l’environnement, les grands concepts généraux du développement des applications Android.

REMARQUE : le travail de traduction n’est pas toujours aussi facile qu’on le pense. Malgré les soins que nous avons pu apporté à l’élaboration de cet article, soyez indulgents : contactez nous via notre formulaire afin de nous notifier d’éventuels soucis.

Cette suite d’article est sous licence CC et l’exploitation du contenu nous a été accordée malgré la présence de publicité sur notre site.

Traducteurs et correcteurs : Arnaud F. et Loic K.

1. Qu’est-ce qu’Android?

1.1 Système d’exploitation Android

Android est un système d’exploitation basé sur Linux pour lequel l’interface de programmation java est utilisé.  Le kit de développement logiciel Android (Android SDK) fournit tous les outils nécessaire pour développer des applications Android. Il inclut un compilateur, un deboggueur et un émulateur matériel qui disposera de sa propre machine virtuelle pour exécuter les programmes Android
Android est actuellement principalement développé par Google.
Android permet le traitement de tâche en arrière plan, fournit un librairie d’interface utilisateur très complète, supporte les graphiques 2-D et 3-D utilisant les libraries OpenGL,  accède au système de fichier et fournit une base de données embarquées SQLite.
Les applications Android contiennent différents composants et peuvent réutiliser ceux fournis par d’autres applications. Ceci  régit le concept de tache dans Android; une application peut réutiliser d’autres composants pour réaliser une tâche. Par exemple, vous pouvez écrire une application qui utilise l’application Android Galerie pour sélectionner une photo.

1.2. Google Play (Android Market)

Google propose le service « Google Play » dans lequel les développeurs peuvent offrir leurs applications Android aux utilisateurs Android. Les téléphones Google inclut l’application « Google Play » qui permet d’installer des applications.
Google Play offre également un service de mise à jour, c’est à dire que si un développeur met à jour une nouvelle version de son application sur Google Play; ce service notifiera les utilisateurs qu’une mise à jour est disponible pour cette application qu’ils pourront installer.
Google Play fut appeler « Android Market ».

 

1.3. Sécurité et permissions

Lors du déploiement sur un matériel Android, les système Android créera un unique utilisateur et un identifiant de groupe (Group ID) pour chaque application Android. Chaque fichier d’application est privé pour cet utilisateur généré, c’est à dire que les autres application ne pourront accéder à ces fichiers.

En plus, chaque application Android démarrera dans son propre processus.
Par conséquent, puisque le système repose sur le système d’exploitation Linux, chaque application Android est isolée des autres applications en fonctionnement.
Si les données doivent être partagées, l’application doit le faire explicitement, par la mise en place d’un Service ou d’un ContentProvider.
Android contient également un système de permission. Android prédéfini des permissions pour un certain nombre de tâche mais chaque application peut définir des permissions supplémentaires.
Une application Android déclare les permissions dont elle a besoin dans son fichier de configuration AndroidManifest.xml. Par exemple, une application doit déclarer qu’elle requiert un accès à Internet.
Les permissions sont de différents niveaux. Certaines permissions sont automatiquement accordées par le système Android, d’autres sont automatiquement rejetées.
Dans la plupart des cas, les demandes de permissions seront présentées à l’utilisateur avant l’installation de l’application. L’utilisateur a besoin de décider si ces permissions seront données à l’application.
Si l’utilisateur refuse une permission requises par l’application, cette application ne pourra être installée. La vérification des permission est selon réalisée durant l’installation, elles ne pourront être acceptées ou refusées après l’installation.
Bien que tous les utilisateurs fassent plus ou moins attention à ces demandes de permissions lors de l’installation des applications, certains d’entre eux, qui ne font pas réellement attention, écrivent alors de mauvais commentaires sur le Google Play.

2. Les composants Android

Ce chapitre fourni un courte description des composants les plus importants d’Android.

2.1. Activity

Une Activity représente la couche de présentation d’une application Android. Une description simplifiée est qu’une Activity représente un écran d’une application Android. Ceci est un peu incorrect puis les Activities peuvent être affichées comme des boites de dialogue ou en transparence.
Une application Android peut disposer de plusieurs Activities.

2.2. Views et ViewGroups

Les Views sont des composants (widgets) de l’interface utilisateur, par exemple des boutons ou des zones de saisie. La classe de base de toutes les Views est android.view.View. Les Views ont souvent des attributs qui peuvent être utiliser pour changer leur apparence ou leur comportement.
Un ViewGroup est en charge de positionner d’autres Views. Un ViewGroup est aussi appeler gestionnaire de composants. La classe de base du gestionnaire de composants est android.view.ViewGroups qui étend View.
Les ViewGroups peuvent être imbriqués pour créer des affichages complexes. Vous ne devrez pas imbriquer les ViewGroups trop profondémment au risque de d’avoir un impact sur les performances.

2.3. Intents

Les Intents sont des messages asynchrones qui permettent à une application de requêter une fonctionnalité d’un autre composant du système Android, par exemple des Services ou des Activities. Une application peut appeler directement un composant (Intents explicites) ou demander au système Android d’évaluer les composants enregistrés pour un type donné d’Intent (Intents implicites). Par exemple, l’application peut proposer le partage de données via un Intent et tous les composants qui fournissent la fonction de partage seront proposés à l’utilisateur pour que ce dernier puisse sélectionner celui qu’il désire. Les applications s’enregistrent d’elles même pour un Intent via un IntentFilter.
Les Intents permettront de combiner des composants faiblement couplés pour réaliser certaines tâches.

2.4. Services

Les Services exécute des tâches en arrière plan sans fournir d’interface utilisateur. Ils peuvent notifier l’utilisateur via le framework de notification d’Android.

2.5. ContentProvider

Le ContentProvider fournit une interface aux données d’application. Via un ContentProvider votre application peut partager des données avec d’autres applications. Android contient un système de base de données SQLite fréquemment utilisé conjoinement à un ContentProvider. SQLite enregistre les données, qui pourront être accédées par n ContentProvider.

2.6. BroadcastReceiver

Un BroadcastReceiver peut être enregistré pour recevoir des messages systèmes et des Intents. Un BroadcastReceiver sera notifié par le système Android, si une situation particulière survient. Par exemple, un BroadcastReceiver peut être appeler une fois que le système Android a fini de démarrer or si un appel téléphonique est reçu.

2.7. (Ecran d’accueil HomeScreen) Widgets

Les Widgets sont des composants interactifs qui sont principalement utilisés sur l’écran d’accueil Android. Ils affichent essentiement quelques données et permettent à l’utilisateur de réaliser des actions. Par exemple, un Widget pourra afficher un court résumé des nouveaux emails et si l’utilisateur sélectionne un email, ce dernier sera affiché dans l’application dédiée.

2.8. Autre

Android fournit d’autres composnats mais la liste ci-dessus décrit la plupart d’entres eux. Les autres composants sont les “Live Folders” et “Live Wallpapers”. Les Live Folders affiche des données sur l’écran d’accueil sans lancer l’application correspondante.

3. Android Development Tools

3.1. Que sont les outils de développement Android?

Google fournit les outils de développement Android (ADT Android Development Tools) pour développer des application Android avec Eclipse. ADT est un ensemble de composants (plug-ins) qui étendent les capacités de l’IDE Eclipse pour proposer le développement Android.
ADT contient toutes les fonctionnalités requises pour créer, compiler, débogguer et déployer les applications Android avec l’IDE Eclipse et des lignes de commande. D’autres IDE’s, comme IntellJ, ont aussi la possibilité d’intégrer les composants d’ADT.
ADT fournit aussi un émulateur de matériel Android, qui pourra être utilisé pour tester des applications Android sans disposer d’un réel téléphone Android.

3.2. Dalvik Virtual Machine

Le système Android utilise une machine viruelle spécifique, c’est à dire la machine virtuelle Dalvik pour exécuter des applications basées sur Java. Dalvik utilise son propre format de bytecode qui diffère du  bytecode Java.
Ainsi vous ne pouvez pas exécuter directement des fichiers de classes Java sur Android, ils devront être convertis dans le format de bytecode Dalvik.

3.3. Comment développer des applications Android

Les applications Android sont essentiellement écrites avec le langage de programmation Java. Les fichiers sources Java sont convertis en fichiers de classe Java par le compilateur Java.
Android fournit un outil nommé « dx » qui convertit les fichiers de classes Java en un fichier  dex (Dalvik Executable). Tous les fichiers classes d’une application sont placés dans un fichier compressé .dex. Au cours de ce processus de conversion les informations redondantes des fichiers classes seront optimisées dans le fichier .dex. Par exemple, si la même chaîne String est trouvée dans différents fichiers classes, le fichier .dex ne contiendra qu’une seule référence à cette chaîne.
Ces fichiers dex sont donc plus petit en taille que les fichiers classes correspondants.
Le fichier .dex et les ressources d’un projet Android, comme les images et les fichiers XML, sont packagés dans un fichier .apk (Android Package. Le programme aapt (Android Asset Packaging Tool) réalise ce packaging.
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 matériel Android via l’outil “adb”.
Les outils de développement Android (ADT – Android Development Tools ) permettent que toutes ces étapes soient réalisées de manière transparente pour l’utilisateur; soit avec Eclipse soit en ligne de commande.
Si vous utilisez ADT, vous appuierez sur un bouton ou exécuterez un script pour que l’intégralité de l’application Android (fichier .apk) soit créée et déployée.

3.4. Resource editors

ADT permet au développeur de définir certains artéfact, par exemple des chaînes de caractères ou des fichiers de layout, de deux manières  : via un éditeur riche et directement via XML. Ceci est réalisé via des éditeurs multiples d’Eclipse. Dans ces éditeurs vous pouvez navigeur entre les deux types de représentation en cliquant sur les onglets présents sur la partie basse de l’écran.
Par exemple, si vous ouvrez le fichier « res/layout/main.xml » dans le Package Explorer, vous pouvez basculer entre les deux modes de présentations comme indiqué dans la copie d’écran suivante.

3.5. Logging

Android utilise la classe android.util.Log pour logguer avec les méthodes statiques Log.i(), Log.w(),Log.e() et Log.wtf(). Cette liste est triée par sévérité.
Le premier paramètre de ces méthodes est la catégorie et le seconde le message.
Typiquement vous créez une classe Constants dans votre application Android et fournissez l’identifiant (flag) de votre log comme un attribut public static final.

Android conseille qu’une application déployée ne devrait pas contenir de code de log. Les outils de développement Android fournissent un marqueur BuildConfig.DEBUG pour cela. Ce flag sera automatiquement positionné à false si vous exporter l’application pour un déploiement. En cours de développement, il sera positionné à true, ce qui vous permettra de visualiser l’intégralité des informations de log.
L’exemple suivant montre comment écrire un message de log d’erreur. Ce message est visible dans la vue “LogCat” dans Eclipse.

if (BuildConfig.DEBUG) {
Log.e(Constants.LOG, « onCreate called »);
}

4. Architecture d’une application Android

4.1. AndroidManifest.xml

Les composants et paramètres d’une application Android sont définis dans le fichier AndroidManifest.xml. Par exemple, toutes les Activities et tous les Services de l’application doivent être déclarer dans ce fichier.
Il doit aussi contenir les permissions nécessaires pour votre application. Par exemple, si l’application requiert la permission d’accéder au réseau, elle sera définie ici.

<?xml version= »1.0″ encoding= »utf-8″?><manifest xmlns:android= »http://schemas.android.com/apk/res/android »package= »de.vogella.android.temperature »android:versionCode= »1″android:versionName= »1.0″><application android:icon= »@drawable/icon » android:label= »@string/app_name »><activity android:name= ».Convert »android:label= »@string/app_name »><intent-filter>

<action android:name= »android.intent.action.MAIN » />

<category android:name= »android.intent.category.LAUNCHER » />

</intent-filter>

</activity>

</application>

<uses-sdk android:minSdkVersion= »9″ />

</manifest>


L’attribut de package défini le package de base des objets Java référencés dans ce fichier. Si un objet Java se situe dans un package différent, il doit être déclaré avec le nom complet du package.
Google Play requière que chaque application Android utilise son propre package de manière unique. Ainsi, il existe une bonne habitude qui est d’utiliser votre nom de domaine inversé comme nom de package. Ceci évitera des collisions avec d’autres applications Android.
android:versionName et android:versionCode spécifient la version de votre application. versionName est ce que voit l’utilisateur et peut être une chaine de caractères.
versionCode doit être un entier. Google Play se base sur le versionCode afin de déterminer s’il peut réaliser une mise à jour de l’application pour les installations existantes. Vous commencerez typiquement avec la valeur « 1 » et augmenterez cette valeur de un en un, si vous publiez une nouvelle version de votre application.
La balise <activity> définit une Activity, dans cet exemple pointant vers la classe Convert du package de.vogella.android.temperature. Un filtre d’intention est enregistré pour cette classe qui définit que cette Activity est démarrée dès que l’application démarre (action android:name= »android.intent.action.MAIN »). La définition de la catégorie android:name= »android.intent.category.LAUNCHER » definit que l’application est ajoutée dans le répertoire des applications sur le matériel Android.
La valeur @string/app_name fait référence au fichier de ressources qui contient la valeur actuelle du nom de l’application. L’utilisation de fichiers de ressource facilite la l’accès à différents types ressources, telles que des chaînes de caractères, des couleurs, des icônes, pour les différents matériels et pour les applications multilingues.
La partie « uses-sdk » du fichier « AndroidManifest.xml » définie la version minimale du SDK pour laquelle l’application est valide. Ceci évite que l’application ne soit installée sur des matériels avec une ancienne version du SDK.

4.2. R.java et Resources

Le répertoire « gen » dans un projet Android contient des valeurs générées. R.java est une classe générée contenant les références vers certaines ressources du projet.
Ces ressources doivent être définies dans le répertoire « res » et peut être des fichiers XML, des icônes ou des images. Vous pouvez par exemple définir des valeurs, des menus, des layouts ou des animations par des fichiers XML.
Si vous créez une nouvelle ressource, la référence correspondante est automatiquement créée dans le fichier R.java via les outils ADT d’Eclipse. Ces références sont des valeurs entières statiques et définissent les identifiants des ressources.
Le système Android fournit des méthodes pour accéder aux ressources correspondant à ces identifiants.
Par exemple, pour accéder à une chaîne de caractères avec l’identifiant R.string.yourString, vous devrez utilisez la méthode getString(R.string.yourString).
R.java est automatiquement créé par l’environnement de développement Eclipse, les changements manuels ne sont pas nécessaires et seront écrasés à la prochaine compilation.

4.3. Assets

Alors que le répertoires res contient des valeurs structurées qui sont connues par la plateforme Android, le répertoire assets peut être utilisé pour enregistrer toute sorte de données. Vous accédez à ces données via le AssetsManager disponibles depuis la méthode getAssets() fourni dans l’objet Context.
AssetsManager permet de lire un assets comme un InputStream avec la méthode open().

// Récupère l’AssetManager
AssetManager manager = getAssets();// Lit un Bitmap depuis un Assets
try {
InputStream open = manager.open(« logo.png »);
Bitmap bitmap = BitmapFactory.decodeStream(open);
// Assigne l’image à un ImageView dans le layout
ImageView view = (ImageView) findViewById(R.id.imageView1);
view.setImageBitmap(bitmap);
} catch (IOException e) {
e.printStackTrace();
}

 

 

4.4. Les activités et les layouts

L’interface utilisateur pour les activités est définie via des layouts. Le layout définit les vues (Views également nommées widgets) incluses et leurs propriétés.
Un layout peut être défini en Java ou XML. Dans la plupart des cas, le layout est défini par un fichier XML.
Les layouts définis en XML le sont dans des fichiers présents placés dans le répertoire /res/layout. Ce fichier spécifies les ViewGroups, Views, leurs relations et leurs attributs pour ce layout spécifique.
Si une vue a besoin d’être accédée depuis le code Java, vous devrez donner à la vue un identifiant unique via l’attribut android:id. Pour assigner un nouvel identifiant à une vue (View) utilisez @+id/yourvalue. Ci-dessous un exemple montrant un bouton (Button) auquel lui a été assigné l’identifiant « button1 ».

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

 

Par conversion ceci créera et assignera un nouvel identifiant button1 correspondant à la vue. Dans votre code Java vous pourrez accéder plus tard à la vue via la méthode findViewById(R.id.button1).
La définition des layouts par XML est habituellement préféré car il permet de séparer la logique de programmation et la définition des vues. Cela permet aussi de définir différents layouts pour différents matériels. Vous pouvez aussi avoir une approches mixtes utilisant les deux approches.

4.5. Référence aux ressources dans les fichiers XML

Dans vos fichiers XML, par exemple vos fichiers XML, vous pouvez faire référence à d’autres ressources via le signe @.
Par exemple, si vous voulez faire référence à une couleur qui définie dans un fichier XML de ressource, vous pouvez y faire référence par @color/yout_id. Ou si vous définissez une chaîne de caractères « hello » dans un fichier XML de ressource, vous pouvez y accéder par @string/hello.

4.6. Activités et cycle de vie

Le système Android contrôle le cycle de vie de votre application. A n’importe quel moment le système Android peut arrêter ou stopper votre application, par exemple lors d’un appel entrant. Le système Android définit un cycle de vie des activités via des méthodes prédéfinies. Les méthodes les plus importantes sont :

  • onSaveInstanceState() – appelée si une activité est stoppée. Permet d’enregistrer des données que l’Activity peut restorer si ses étâts sont redemarrés
  • onPause() – toujours appelée si l’activité se termine. Peut être utilisée pour libérer les ressource ou sauver des données
  • onResume() – appelée si l’activité est redemarrée, peut être utilisée pour initialiser des attributs

4.7. Changement de configuration

Une activité peut aussi être redemarré si un appel à un changement de configuration intervient. Un changement de configuration intervient si un évènement est déclenché et peut être important pour l’application. Par exemple, si l’utilisateur change l’orientation du matériel, (verticallement ou horizontalement). Android considère qu’une activité  peut vouloir utiliser différentes ressources pour cette orientation et ainsi la rédémarre.
Dans l’émulateur pour pouvez simuler le changement d’orientation via CTRL+F11.
Vous pouvez éviter un redémarrage de l’application pour certains changements de configuration via l’attribut configChanges de la définition de votre Activity dans votre fichier AndroidManifest.xml. L’activité suivante ne sera pas redemarrer dans le cas d’un changement d’orientation ou de positionnement de clavier physique (caché / visible).

 

<activity android:name= ».ProgressTestActivity »
android:label= »@string/app_name »
android:configChanges= »orientation|keyboardHidden|keyboard »>
</activity>

 

 

4.8. Context

La classe android.content.Context fournit les connexions au système Android. C’est l’interface pour obtenir les informations générales concernant l’environnement de l’application. Un contexte fournit aussi des accès aux services Android, par exemple le service de géolocalisation. Les activités et les services héritent de la classe Context et peuvent alors être utilisés comme un contexte.

 

5. Installation

5.1. Eclipse

Nous supposerons ici que vous avez déjà Java et Eclipse installés et que vous connaissez l’utilisation d’Eclipse. Pour plus d’information sur Eclipse, merci de consulter le tutorial Eclipse IDE de Lars Vogel.
Le tutorial d’Eclipse décrit aussi comment installer de nouveaux composants dans Eclipse. Ceci est le prérequis pour installer le plugin Android Development Tools. Vous trouverez les étapes nécessaires décrites dans la section du tutorial ci-dessus nommé : Eclipse Update Manager
L’auteur de ce texte a aussi publié un livre Kindle sur l’usage de l’IDE Ecliose que vous pourrez trouver ici : Eclipse IDE Book for Kindle.

5.2. Prérequis pour une utilisation de Linux 64bit

Le SDK Android est 32bit, donc sur un système Linux 64bit vous aurez la nécessité d’installer le package ia32-libs. Pour Ubuntu vous pouvez réaliser ceci par ligne de commande.

apt-get install ia32-libs

Vérifiez la documentation de votre distribution, si vous utiliser les services d’une autre distribution Linux.

5.3. Install ADT Plug-ins and Android SDK

Utilisez l’ouil de mise à jour Eclipse (Eclipse update manager) pour installer tous les composants disponibles pour l’Android Development Tools (ADT) depuis l’URL https://dl-ssl.google.com/android/eclipse/.
Une fois que tous les composants de développement Android auront été installés, vous serez invité à installer le SDK Android. Vous pouvez utiliser l’outil d’installation suivant ou aller à la section suivant pour apprendre à le faire manuellement.


5.4. Installation manuelle du SDK Android

Après l’installation d’ADT, Eclipse vous permet de téléchargement automatiquement le SDK Android. Mais vous pouvez aussi télécharger manuellement le SDK Android depuis la page Android SDK.
Le téléchargement contient un fichier zip, que vous pouvez extraire à n’importe quel endroit de votre système de fichier, par exemple sur mon système Linux, je l’ai placé sous « /home/vogella/android-sdks ». Evitez l’utilisation d’espace dans le nom du chemin, sinon vous pourriez rencontrer des problèmes lors de l’utilisation du SDK Android.
Vous devrez aussi définir l’emplacement du SDK Android dans les préférences d’Eclipse. Dans Eclipse, ouvrez la boite de dialogue des préférences via le menu Windows ? Preferences. Sélectionnez Andorid et entrez le chemin d’installation du SDK Android.

5.5. Installez une version spécifique d’Android

Le gestionnaire de SDK Android (Android SDK Manager) vous permet d’installer des versions spécifiques d’Android. Sélectionnez Window ? Android SDK Manager depuis le menu Eclipse.

La boite dialogue vous permet d’installer de nouveaux packages et également de les supprimer. Sélectionnez « Available packages » (packages disponibles) et ouvrez « Third Party Add-ons » (modules tiers). Sélectionnez la version Google API 15 (Android 4.0.3) du SDK et appuyez sur « Install ».

Appuyez le bouton « Install » et confirmez la licence pour tous les packages. Une fois l’installation complétée, redémarrez Eclipse.

5.6. Code source Android

L’étape suivante est optionnelle.

10.4. Créer des attributs5.6.1. A partir d’Android 4.0

Pendant le développement Android il est très utile de disposer des codes sources Android disponibles.
Comme pour Android 4.0  les outils de développement Android fournissent aussi le code source. Vous pouvez le télécharger via le gestionnaire de SDK Android en sélectionnant « Sources for Android SDK ».
Les sources seront télécharger dans le répertoire présent dans « chemin_sdk_android/sources/android-xx ». xx est le niveau d’API d’Android, par exemple 15 pour la version Android 4.0.3.
Pour connecter les sources avec le fichier android.jar dans votre projet Android, procédez à un clic droit sur le fichier android.jat dans l’explorateur de package Eclipse et sélectionnez Properties ? Java Source Attachment. Saisissez le répertoire des sources et appuyez sur OK.
Vous pourrez ensuite naviguer à travers le code source.

5.6.2. Avant Android 4.0

Pour les versions précédentes Haris Peco maintient les plugins et fournit le code Source Android. Utilisez le gestionnaire de mise à jour d’Eclipse (Eclipse update manager) pour installer le plugin des codes sources Android depuis le site: http://adt-addons.googlecode.com/svn/trunk/source/com.android.ide.eclipse.source.update.
Pour plus de détails, rendez vous sur le site du projet.

6. Machine virtuelle Android – Emulateur

6.1. Qu’est ce que l’émulateur Android ?

L’Android Development Tools (ADT) inclut un émulateur pour faire fonctionner un système Android. L’émulateur se comporte comme un vrai matériel Android (dans la plus part des cas) et vous permet de tester votre application dans disposer d’un véritable matériel.
Vous pouvez configurer la version du système Android qui fonctionnera, la taille de la carte SD, la résolution de l’écran et d’autres paramètres importants. Vous pouvez en définir de nombreux avec des configurations différentes.
Ces matériels sont appelés Machine Virtuelle Android « Android Virtual Device » (AVD) et vous pouvez en démarrer plusieurs en parallèle. Le démarrage d’un nouvel émulateur est très lent, parce que le système de fichier du nouvel AVD a besoin d’être préparé.
ADT permet de déployer et d’éxecuter votre programme Android sur l’AVD.

6.2. Google contre Android AVD

Pendant la création d’un AVD vous decidez si vous souhaitez un matériel Android ou un matériel Google.
Un AVD créé pour Android contiendra les programmes du projet Android Open Source Project. Un AVD créé pour les API Google contiendra aussi plusieurs applications Google, la plus notable étant l’application Google Maps.
Si vous souhaitez utilisez une fonctionnalité qui n’est fourni que par les API Google, par exemple Cloud2DeviceMessaging ou Google Maps vous devrez executer cette application sur un AVD avec Google API.

6.3. Raccourcis de l’émulateur

Les raccourcis ci-dessous sont utiles en travaillant avec l’émulateur.
Alt+Enter Maximise la fenêtre de l’émulateur. Pratique pour les démos.
Ctrl+F11 change l’orientation de l’émulateur.
F8 Active / Désactive le réseau.

6.4. Performance

Les graphismes de l’émulateur sont rendus de manière logicielle, ce qui est très lent. Pour avoir un émulateur réactive, utilisez une petite résolution pour votre émulateur, comme par exemple HVGA.
Aussi, si vous avez assez de mémoire sur votre ordinateur, ajouter au moins 1Go de mémoire à votre émulateur. Ceci est possible en modifiant la valeur « Device ram size » lors de la création d’un AVD.
Aussi, activez la case à cocher « Enabled » pour la valeur Snapshots. Ceci sauvegardera l’état de l’émulateur et redemarrera plus rapidement.

6.5. Bouton matériel

Android 4.0 a introduit que les matériels n’ont plus de bouton matériel. Si vous souhaitez créer un tel AVD, positionnez la valeur à “false” pour la propriété « Hardware Back/Home keys » dans la configuration du matériel.

7. Tutorial: créer et executer une machine virtuelle Android

Pour définir une machine virtuelle Android Android Virtual Device (AVD) ouvrez le « AVD Manager » via le menu Windows ? AVD Manager et appuyez sur « New ».

Entrez comme suit :

Vous pouvez aussi sélectionner la case “Enabled” dans la section Snapshots. Ceci permettra de gagner quelques secondes au démarrage de la machine virtuelle.
A là fin appuyez sur le bouton « Create AVD ». Ceci créera la configuration de l’AVD et l’affichera sous « Virtual devices ».
Pour tester si vos paramètres sont corrects, sélectionnez votre machine et appuyez sur « Start ».
Après (un certain temps) votre AVD démarre. Vous pourrez l’utiliser via la sourier et le clavier virtuel de l’émulateur.

8. Gestion d’erreur et problèmes standards

Les choses ne fonctionnent pas toujours comme on le voudrait. Cette section fournit une vision des problèmes courants et la manière pour les résoudre.

8.1. Workspace

N’utilisez jamais un workspace (espace de travail) dans Eclipse dont le nom du répertoire contiendrait des espace, il peut être la source de nombreux problèmes étranges.

8.2. Nettoyez le project

Plusieurs utilisateurs reportent qu’ils ont les erreurs suivantes :

  1. Project … is missing required source folder: ‘gen’ (le projet … a le répertoire source requis manquant : ‘gen’)
  2. The project could not be built until build path errors are resolved. (Le projet ne peut être construit tant que les erreurs de chemin ne sont pas résolu.)
  3. Unable to open class file R.java. (Impossible d’ouvrir le fichier R.java.)

Pour résoudre une ces erreurs, allez dans le menu du projet et sélectionniez Project ? Clean.

8.3. Problèmes avec Android Debug Bridge (adb)

La communication avec l’émulateur et votre matériel Android peut avoir des problèmes. Cette communication est gérée par l’Android Debug Bridge (adb).
Eclipse permet de réinitialiser adb dans le cas où ce type de problème survient. Sélectionnez donc la perspective DDMS via Window ? Open Perspective ? Other ? DDMS
Pour redémarrer adb, sélectionnez « Reset adb » dans la vue Device.

8.4. LogCat

La vue « LogCat » vous affiche les messages de log de votre matériel Android et vous aide à analyser des problèmes. Par exemple, les exceptions Java de votre programme seront affichées ici. Pour afficher cette vue, sélectionnez Window ? Show View ? Other ? Android ? LogCat.

8.5. Java7

Si Android se plaint que vous ne pouvez pas utiliser Java7, faites un clic droit sur votre projet et sélectionnez l’entrée Java compiler. Assuez-vous que Java 1.5 ou Java 1.6 est utilisé. Vous devrez sélectionner la case à cocher Enable project specific settings.

8.6. Editeur Android ne s’ouvre pas

Android fournit de bons éditeurs pour éditer les fichiers de ressource Android, malheureusement ces éditeurs ne sont pas toujours automatiquement utilisés à cause de bugs dans ADT. Si cela survient, vous pouvez ouvrir cet éditeur manuellement. Faites un clic droit sur le fichier et sélectionnez dans le menu Open with ? Android Menu Editor.

8.7. L’émulateur ne démarre pas

Si votre émulateur ne démarre pas, assurez vous que la version android-sdk présent dans le path ne contient pas d’espaces dans son nom.

8.8. Timeout pendant le déploiement

Si vous rencontrez des problèmes de timeout pendant le déploiement augmentez la valeur par défaut du timeout dans les préférences Eclipse. Sélectionnez Window ? Preferences ? Android ? DDMS et augmenter la valeur « ADB connection timeout (in ms)”.

8.9. Echec de l’installation due à un stockage insuffisant

Quelques fois l’émulateur refusera d’installer une applications avec le message d’erreur : INSTALL_FAILED_INSUFFICIENT_STORAGE.
Un machine virtuelle Android fournit par défaut seulement 64Mo de stockage pour les applications Android. Vous pouvez nettoyer votre application installée en redémarrant l’émulateur et sélectionnant l’option « Wipe user data”.
Sinon vous pouvez fixer la taille de la partition de données. Si vous éditez l’AVD, vous pouvez fixer la propriété « Ideal size of data partition » via le bouton « New ».

8.10. Certificat de Debug expiré

Si vous obtenez le message d’erreur « Debug Certificate expired » placez vous dans le répertoire qui contient les AVD Android, par exemple « .android » sous Linux, et supprimez le fichier « debug.keystore ». Ce fichier est seulement valide pour une année et s’il n’est pas présent, Eclipse le régénérera.

8.11. Message d’erreur pour @Override

L’annotation @Override a été introduit dans Java 1.6. Si vous obtenez un message d’erreur pour @Override, changez le niveau du compilateur Java à Java 1.6. Pour faire cela, faites un clic droit sur le projet, sélectionnez Properties ?Java Compiler ? Compiler compliance level et sélectionnez « 1.6 » dans la liste déroulante.

8.12. Imports manquants

Java requiert que des classes qui ne font partie du langage Java standard soient nommée de manière explicite ou déclarée par des imports.
Si vous voyez un message d’erreur avec « XX ne peut être résolue comme une variable » (XX cannot be resolved to a variable), faites un clic droit dans votre éditeur et sélectionnez Source ? Organize Imports ? Import required packages.

8.13. Conseils Eclipse

Pour travailler plus efficacement avec Ecliose, sélectionnez Window ? Preferences ? Java ? Editor ? Save Actions et sélectionnez le fait que le code source doit être formaté et que les imports devront être organisés à action de sauvegarde.

9.  Conventions des tutoriaux

9.1.  Version d’API, package et nom d’application

Les tutoriaux de ce document ont été dévelopés et testés avec Android 4.0.4, API Level 15. Vérifiez à bien utiliser cette version pour tous les tutoriaux de ce livre. Les plus récentes versions de l’API devront également fonctionner. Une version antérieure pourrait également fonctionner, mais si vous faites face à des problèmes, essayez avec la version recommandée.
Le package de base des projets est tujours le même que le nom du projet, par exemple si vous créer un projet « de.vogella.android.example.test », alors le nom de package correspondant est « de.vogella.android.example.test ».
Le nom de l’application qui doit être entré dans l’outil de création automatique de projet Android (Wizard) ne sera pas prédéfini; Choisissez le nom que vous souhaitez.

9.2.  Les messages d’avertissements pour les Strings

Les outils de développement Android affichent des avertissements, si vous codez “en dur” les chaines de caractères, par exemple dans les fichiers de layout. Pour de réelles applications vous devrez utiliser les fichiers de ressources String. Pour simplifier la création des exemple, nous utiliserons directement les chaines de caractères en dur (hard-coded). Ne tenez donc pas compte de ces avertissements.

10. Tutorial: Votre premier projet Android

10.1. Installer l’application de démonstration

Cette application est aussi disponible sur Google Play sous le nom Android Temperature Converter

10.2. Créer un projet

Selectionnez File ? New ? Other ? Android ? Android Project et créer le projet Android « de.vogella.android.temperature ». Entrez les informations suivantes :


Appuyez sur « Finish ». Ceci devrait créer la structure l’arborescence suivante.

10.3. Modification des ressources

Comme décrit dans le chapitre Android Development Tools (ADT), ADT fournit des éditeurs spécialisés pour les fichiers de ressources, comme par exemple les fichiers de layout. Ces éditeurs permettront de basculer entre la représentation XML du fichier et une interface utilisateur riche via les onglets présents en bas de l’éditeur.
La déscription suivante utilise l’interface utilisateur riche pour construire les fichiers de layout. The following description uses the rich user interface to build layout files. Dans un souci de validation, les résultats XML est également inclus dans la description.

10.4. Créer des attributs

Android autorise de créer des attributs statiques, comme les Strings (chaine de caractères) ou couleurs. Ces attributs peuvent par exemple être utilisés dans vos fichiers XML ou référencé depuis le code source Java.
Selectionnez le fichier « res/values/string.xml » et appuyez sur le bouton Add. Sélectionnez « Color » et entrez « myColor » pour le nom et « #3399CC » pour la valeur.

Ajouter les attributs suivants de type « String ». Les attributs String permettent aux développeur de traduire l’application attributes allow the developer to translate the application plus tard.
Table 1. Attributs Chaines

Nom Valeur
celsius to Celsius
fahrenheit to Fahrenheit
calc Calculate


Basculez en représentaton XML et validez que les valeurs soient correctes.

<?xml version= »1.0″ encoding= »utf-8″?>
<resources>
<string name= »hello »>Hello World, Convert!</string>
<string name= »app_name »>Temperature Converter</string>
<color name= »myColor »>#3399CC</color>
<string name= »myClickHandler »>myClickHandler</string>
<string name= »celsius »>to Celsius</string>
<string name= »fahrenheit »>to Fahrenheit</string>
<string name= »calc »>Calculate</string>
</resources>

 

 

10.5. Ajouter des Views

Selectionnez « res/layout/main.xml » et ouvrez l’éditeur Android par un double clic. cet éditeur vous permet de créer le layout par “drag and drop” et via le code source XML. Vous pouvez basculer entre les deux représentation via les onglets présents en bas de l’éditeur. Pour modifier la positionnement et grouper des éléments vous pouvez utiliser la vue “Outline” d’Eclipse.
Ce qui suit montre une copie d’écran de la vue « Palette » dans laquelle vous pouvez utiliser le frag and drop pour ajouter de nouveaux composants d’interface utilisateur dans votre layout. Vérifiez que la vue « Palette » change fréquemment et donc que votre vue peut être peu différente.

Vous pouvez maintenant créer votre nouveau layout.
Faites un clic droit sur l’objet existant “Hello World, Hello!” dans le layout. Selectionnez « Delete » dans le menu affiché pour supprimer l’objet texte. Puis, depuis la vue “Palette”, selectionnez Text Fields et  recherchez « Plain Text ». Déplacez ce composant dans le layout pour créer un champ de saisie texte. Tous les objets de ce type, présents dans la section « Text Fields”, dérivent de la classe « EditText », ils spécifient juste des attributs supplémentaires que les types de texte peuvent utiliser.
Ensuite, sélectionnez dans la palette la section « Form Widgets » et déplacez l’objet “RadioGroup” dans le layout. Le nombre de boutons radios ajouté dépend de votre version d’Ecliose. Assurez vous qu’il y ait deux radio bouttons en suppression ou en ajout dans le groupe.
Depuis la section Form Widget de la palette, déplacez un objet Bouton dans le layout.
Le résultat devrait être quelque chose de semblable à l’image ci-après :

Basculez dans « main.xml » et vérifiez que votre code XML est similaire à ce qui suit.

 

<?xml version= »1.0″ encoding= »utf-8″?>
<LinearLayout xmlns:android= »http://schemas.android.com/apk/res/android »
android:layout_width= »fill_parent »
android:layout_height= »fill_parent »
android:orientation= »vertical » ><EditText
android:id= »@+id/editText1″
android:layout_width= »match_parent »
android:layout_height= »wrap_content »
android:text= »EditText » >
</EditText><RadioGroup
android:id= »@+id/radioGroup1″
android:layout_width= »match_parent »
android:layout_height= »wrap_content » ><RadioButton
android:id= »@+id/radio0″
android:layout_width= »wrap_content »
android:layout_height= »wrap_content »
android:checked= »true »
android:text= »RadioButton » >
</RadioButton><RadioButton
android:id= »@+id/radio1″
android:layout_width= »wrap_content »
android:layout_height= »wrap_content »
android:text= »RadioButton » >
</RadioButton>
</RadioGroup><Button
android:id= »@+id/button1″
android:layout_width= »wrap_content »
android:layout_height= »wrap_content »
android:text= »Button » >
</Button></LinearLayout>

10.6. Edit View properties

Si vous sélectionnez un composant de l’interface utilisateur (une instance de View), vous pouvez changer ses propriétés via la vue Eclipse “Properties”. La plupart des propriétés peuvent être modifiées via le menu affiché par le clic droit. Vous pouvez aussi modifier les valeurs des propriétés directement dans le XML. Le changement des propriétés est plus rapide dans le fichier XML si vous savez ce que vous souhaitez changer. Mais le fonctionnement du clic droit est pratique si vous recherchez certaines propriétés.
Ouvrez votre fichier « main.xml ». Le contrôle EditText  affiche actuellement un texte par défaut. Nous voulons supprimer ce texte initial dans le code XML. Basculez sur l’onglet XML nommé « main.xml » et supprimer  la propriété android:text= »EditText » de la partie EditText. Revenez sur l’onglet « Graphical Layout » et vérifiez que le texte a été supprimé.
Utilisez le clic droit sur le premier bouton radio et assignez la chaîne de caractère « celsius » dans l’attribut « text ». Assignez la chaîne « fahrenheit » sur le second bouton radio.


A partir de maintenant, je considére que vous savez utiliser les menus permettant de modifier les composants de l’interface utilisateur. Vous aurez toujours la possibilité d’éditer le fichier XML ou de modifier les propriétés par l’accès au clic droit.
Afftectez la valeur “true” à la propriété « Checked » du premier RadioButton.
Assignez « calc » à la propriété texte de votre bouton et assigner la valeur « myClickHandler » à la propriété « onClick ».
Resneignez la valeur “numberSigned” et “numberDecimal” à la propriété « Input type » de votre EditText.
Tous les composants de votre interface utilisateur sont contenus dans un LinearLayout. Nous souhaitons assigné une couleur à arrière-plan de ce LinearLayout. Faites un clic droit dans un espace vide dans le mode Graphical Layou, et sélectionnez Other Properties ? All by Name ? Background. Sélectionnez “Color” puis « myColor » dans la liste qui sera affichée.

Basculez dans l’onglet « main.xml » et vérifiez que le XML est correct.

 

<?xml version= »1.0″ encoding= »utf-8″?>
<LinearLayout xmlns:android= »http://schemas.android.com/apk/res/android »
android:layout_width= »fill_parent »
android:layout_height= »fill_parent »
android:background= »@color/myColor »
android:orientation= »vertical » ><EditText
android:id= »@+id/editText1″
android:layout_width= »match_parent »
android:layout_height= »wrap_content »
android:inputType= »numberDecimal|numberSigned » >
</EditText><RadioGroup
android:id= »@+id/radioGroup1″
android:layout_width= »match_parent »
android:layout_height= »wrap_content » ><RadioButton
android:id= »@+id/radio0″
android:layout_width= »wrap_content »
android:layout_height= »wrap_content »
android:checked= »true »
android:text= »@string/celsius » >
</RadioButton><RadioButton
android:id= »@+id/radio1″
android:layout_width= »wrap_content »
android:layout_height= »wrap_content »
android:text= »@string/fahrenheit » >
</RadioButton>
</RadioGroup><Button
android:id= »@+id/button1″
android:layout_width= »wrap_content »
android:layout_height= »wrap_content »
android:onClick= »myClickHandler »
android:text= »@string/calc » >
</Button></LinearLayout>

 

 

10.7. Changer le code source de l’Activity

Lors de la génération de votrenouveau projet Android vous avez spécifié qu’une Activity nommée ConvertActivity devait être créée. L’outil de création de projet a créé la classe Java correspondante.
Changez votre code dans ConvertActivity.java comme ci-dessous. Notez que myClickHandler sera nommée car vous affectez cette valeur dans la propriété onClick de votre bouton.

 

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 ConvertActivity extends Activity {
private EditText text;@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
text = (EditText) findViewById(R.id.editText1);
}// This method is called at button click because we assigned the name to the
// « On Click property » of the button
public void myClickHandler(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(convertFahrenheitToCelsius(inputValue)));
celsiusButton.setChecked(false);
fahrenheitButton.setChecked(true);
} else {
text.setText(String
.valueOf(convertCelsiusToFahrenheit(inputValue)));
fahrenheitButton.setChecked(false);
celsiusButton.setChecked(true);
}
break;
}
}// Converts to celsius
private float convertFahrenheitToCelsius(float fahrenheit) {
return ((fahrenheit – 32) * 5 / 9);
}

// Converts to fahrenheit
private float convertCelsiusToFahrenheit(float celsius) {
return ((celsius * 9) / 5) + 32;
}
}

 

 

10.8. Démarrer le projet

Pour démarrer l’application Android, sélectionnez votre projet, faites un clic droit et sélectionnez Run-As ? Android Application. Si un émulateur n’est pas déjà en fonctionnement, il sera démarré. Soyez patient, le démarrage de l’émulateur est très lent.
Vous devriez voir le résultat suivant.

Tapez un nombre, sélectionnez votre conversion et pressez le bouton. Le résultat devrait être affiché et le bouton radio correspondant à l’unité de la valeur calculée sélectionné.

11. Démarrer une application installée

Après avoir executer votre application sur la machine virtuelle, vous pouvez de nouveau la démarrer. Si vous pressez sur le bouton “Home” vous pouvez sélectionnez votre application.