Développment Android sous Ubuntu

Qu'est ce qu'Android
Android est un système d'exploitation open source pour smartphones, PDA et terminaux mobiles conçu par Android, une startup rachetée par Google.
D'autres types d'appareils possédant ce système d'exploitation existent, par exemple des téléviseurs et des tablettes comme le Samsung Galaxy Tab.

Source: wikipedia

Android est un système d'exploitation fondé sur un noyau Linux, il comporte une interface spécifique, développée en java, les programmes sont exécutés via un interpréteur JIT, toutefois il est possible de passer outre cette interface, en programmant ses applications en C.
Android a été conçu pour intégrer au mieux des applications existantes de Google comme le service de courrier Gmail, ou celui de cartographie, Google Maps, ou encore Google Agenda, Google Talk, YouTube.
Source: Android sur Wikipédia

Introduction
Le but de cet article est de décrire comment installer un environnement Android sous Ubuntu.
Un dilemme se pose déjà avant même de commencer. En effet, il est possible de tirer partiellement parti de la Logitech d'Ubuntu mais cette façon de faire n'est pas en phase avec les documentations techniques proposés par Google.
 
La méthode Ubuntu
Il est visiblement possible d'installer Eclipse et un environnement Java (JDK) depuis les dépôts d'Ubuntu. Si cette voie semble raisonnable, je m'en suis écarté immédiatement pour plutôt me conformer à la méthode Google.
L'article Installer Eclipse paru sur le site communautaire d'Ubuntu fait d'ailleurs largement référence à l'utilisation des dépôts.

La méthode Google
Par contre, je me suis entêté à suivre la voie générale décrite par Google dans son document "installing the SDK" (celui d'Android bien entendu), document qui donne également des précisions sur l'installation d'Eclipse et de Java.
Voici le résultat de mes tribulations.
Tout ne fût pas toujours roses et violettes, aussi simple que le laisse paraitre la documentation. Mais je suis finalement arrivé a bon port.

Installer Eclipse
Il faut installer Eclipse en version 3.5 au minimum.
Cette version est disponible dans la section téléchargement de Eclipse.Org.
J'ai installé "Eclipse Classic" depuis eclipse.org au lieu d'opter pour le package Eclipse dans la "Logitech Ubuntu".
Les instructions d'installations mentionnent de simplement dézipper le contenu de l'archive, cela crée un sous répertoire "eclipse" (utiliser le gestionnaire d'archive ou la commande "file-roller").
J'ai choisi de placer les fichiers dans mon répertoire home (/home/domeu/ ou ~ ).
Eclipse est donc installé dans ~/eclipse, emplacement où les fichiers peuvent être modifiés librement par Eclipse lui-même.
Note:
Lors d'une première tentative j'ai bien essayé d'installer éclipse dans /usr/bin/eclipse/ mais il s'est avéré que je ne pouvais le démarrer qu'en mode super user! (et cela même après modification des droits d'accès sur les répertoires et fichiers).

Installer Java
Il est possible de télécharger le JDK 6 Java SE depuis la section de téléchargement du site d'Oracle. J'ai opté pour Oracle car il faut impérativement disposer d'un JDK, un JRE (Java RunTime Environment) étant insuffisant selon la documentation d'Android.
Il faut télécharger les binaires pour linux et effectuer l'installation manuelle puisqu'Ubuntu ne supporte pas les RPM.

En suivant les instructions d'installation sur le site d'Oracle:

• j'ai downloadé la version 6.23 du JDK (soit le fichier jdk-6u23-linux-i586.bin).
• J'ai déplacé le bin dans /usr/bin (c'est une archive auto extract).
  J'ai utilisé un sudo nautilus pour disposer des droits nécessaires (être certain de déplacer l'archive dans /usr/bin).
• J'ai activé un terminal en mode super user (ouvrir terminal puis sudo -i).
• J'ai activé l'exécution du binaire (chmod +x jdk-6u23-linux-i586.bin) dans /usr/bin.
• J'ai exécuté l'archive (./jdk-6u23-linux-i586.bin), elle s'est décompressée dans le sous répertoire /usr/bin/jdk1.6.0_23/ 
• J'ai effacé l'archive.

La JVM (l'exécutable "java") est accessible dans le JRE /usr/bin/jdk1.6.0_23/jre/bin ou bien encore dans le JDK /usr/bin/jdk1.6.0_23/bin

Tester le démarrage d'éclipse
Pour ce premier test, je fini par ne pas définir les variables système JAVA_HOME, ni PLUGIN_HOME de java comme précisé dans plusieurs documents (ex: Eclipse sur Ubuntu-Fr). Mes premiers tests étaient tous infructueux.

Je n'ai pas défini le fichier ~/.eclipse/eclipserc non plus comme mentionné dans la documentation d'installation d'éclipse trouvé sur Ubuntu.fr (mes essais étaient également infructueux, c'est peut être parce que la documentation Ubuntu-fr fait référence à la VM de Sun et une installation à l'aide d'apt-get).

Pour démarré éclipse, j'ai utilisé un terminal et depuis le répertoire /home/domeu/eclipse, j'ai démarré éclipse en indiquant l'emplacement de la JVM (Java Virtual Machine).
Soit l'exécution de la commande suivante:
./eclipse -vm /usr/bin/jdk1.6.0_23/bin

Au démarrage, eclipse demande de paramètrer le répertoire Workspace.
J'ai volontairement choisi /home/domeu/eclipse/workspace au lieu de /home/domeu/workspace pour éviter la prolifération des répertoires.

Démarrer éclipse sans devoir spécifier la JVM
L'article "installer Eclipse sur Ubuntu" paru sur aide-ubuntu.com propose de créer un fichier ~/.eclipse/eclipserc et d'y ajouter la commande export JAVA_HOME=/usr/bin/jdk1.6.0_23/bin
Je ne suis jamais arrivé à quoi que cela soit avec cette option.
PAR CONTRE, après quelques recherche, j'ai finalement réaliser que "java" ne pouvait être accessible que depuis l'un des répertoires de $PATH (echo $PATH).
Cette liste de répertoire n'incluant pas le jdk mais bien /usr/bin.

Il suffit donc de rajouter le lien symbolique suivant depuis le répertoire /usr/bin:
sudo ln -s /usr/bin/jdk1.6.0_23/bin/java java

Maintenant la simple commande "./eclipse" sans paramètre démarre aussi Eclipse :-)
Nous verrons plus tard que le SDK d'Android utilise aussi le lien symbolique "java", il est donc primordial de le déclarer correctement.

Installer le SDK d'Android
Le SDK d'Android est disponible sur la page de téléchargement de Google.
J'y ai téléchargé le SDK correspondant à Linux (android-sdk_r08-linux_86.tgz) que j'ai ensuite décompressé dans /usr/bin à l'aide du gestionnaire d'archive (sudo file-roller).
Après décompression, le répertoire /usr/bin/android-sdk-linux_86 est disponible.

Modifier les droits sur le répertoires et fichiers /usr/bin/android-sdk-linux_86 pour permettre l'écriture et modification pour tous les utilisateurs.
Si cela n'est pas fait, le logiciel Android ne sera pas capable de créer les sous-répertoires temporaires dont il aura besoin.

Tester le SDK android
Pour fonctionner, il est impératif que le lien symbolique java ait été définit dans /usr/bin comme décrit précédemment.
Se rendre dans le répertoire /usr/bin/android-sdk-linux_86/tools et exécuter android (./android).
Cet outil contient le package principal permettant de télécharger le restant du SDK en fonction des besoins. L'outil donne également accès aux différentes machines virtuelle d'Android.
En quelques manipulations complémentaires, j'ai installé les packages suivants:

• Android SDK platform-tools, revision 1
• Documentation for Android SDK, API 9
• SDK Platform Android 2.3, API 9
• SDK Platform Android 2.2, API 8
• Samples for SDK API 9
• Samples for SDK API 8

Création d'une machine virtuelle
Maintenant que les packages sont installés avec l'outil android, aller dans la section machine virtuelle et créer une nouvelle machine virtuelle.
Les machines virtuelles sont appelées AVD pour Android Virtual Device.

Le site d'Android fournit également plus d'information sur les propriétés supportées les machines virtuelles.

Soit, créons un device nommé "Domeu" avec une carte SD de 32 mb, un skin par defaut (HVGA), un track-ball, un clavier et une camera (640 pixels max).
Il ne reste plus qu'à demarrer le nouvel AVD :-)

Attention, les AVD sont lentes
Si le tout fonctionne bien d'une façon générale, je dois reconnaitre que cela rame quand même un peu (DuoCore T3200 à 2Ghz avec 3Go de Ram), mes pauvres processeurs sont presque tout le temps au dessus de 80%.
Ainsi, il ne faudra pas être trop exigeant sur le temps de démarrage du simulateur, mon premier essai aura pris presque 4 minutes de boot.
Comme recommandé sur certains fils de discussions, il est préférable de garder l'émulateur en route lorsqu'il à été démarré. Cela permet d'économiser beaucoup de temps.

Voir les Logs de l'AVD
En cas de doute, il est possible de voir les messages de log du device AVD.
Utiliser la commande ./adb logcat (Android Debug) disponible dans le répertoire /usr/bin/android-sdk-linux_86/platform-tools

Cet outil m'a été bien utile pour me rendre compte que mon AVD était planté dans une boucle infernale d'initialisation. Le tout se répétant indéfiniment sans aucune notification à l'écran.

Plus d'information concernant les méthodes de debugging sont disponible sur la page "Debugging Tasks" (http://developer.android.com/guide/developing/debug-tasks.html) de la plateforme Android. L'article mentionne également comment placer ses propres messages de Log.

PlugIn AVD pour éclipse
Le site d'Android offre l'extension ADT (Android Development Tools) pour l'éditeur Eclipse.
Cette extension offre un puissant environnement intégré permettant de concevoir des applications Android. Il permet de rapidemment créer de nouveaux projets Android, de créer des applications avec interface utilisateur, de débugger les applications en utilisant le SDK d'Android, d'exporter des signatures pour distributer l'application. Le developpement d'application Android en utilisant ADT et Eclipse est une approche recommendée par Google pour les nouveaux venus.

Les instructions d'installations sont disponibles dans le document Google ADT PlugIn for Eclipse
Comme j'ai installé la version Helios (3.6) d'éclipse, je vais suivre les instructions qui y sont spécifiques, à savoir:

• Démarrer Eclipse
• Menu Help | Install New software
• Bouton "Add" en haut a droite de la fenêtre et y indiquer les information suivante pour le repository d'ADT:
  "Android ADT plugin"
  https://dl-ssl.google.com/android/eclipse/
• Selectionner tous les éléments du plugin ADT et les installer.
• Accepter les conditions de licenses, installer et redémarrer Eclipse.

Configurer le module ADT dans Eclipse

• Afficher le module des préférences (menu Windows|préférences).
• Sélectionner le module Android et indiquer l'emplacement du SDK Android (/usr/bin/android-sdk-linux_86).
  Cliquer sur Apply provoque l'affichage d'une liste des targets disponibles (à savoir android 2.2 et 2.3 comme précédemment téléchargés dans le SDK Android).

Un premier développement Android avec Eclipse
Le site Android Developper de Google contient l'article d'introduction "developing In Eclipse with ADT"
Ce document est une bonne prise en main pour créer et exécuter un premier projet.
ce qu'il précise moins, c'est:

• Le détails des différentes propriétés du projet nouvellement créé.
• La nécessité de définir un "Run Configuration" pour tester l'application sur un ADV Android.

Propriétés du projet
Avec quelques recherches sur internet en arrive assez vite à bout. Par exemple, j'ai utilisé les paramètre suivants:

Project Name: FirstAndroidApp (utilisé par Eclipse pour stocker le projet dans le workspace)
Target: Android 2.3
Application Name: My first Android App (Nom affiché dans l'ADV)
Package Name: be.domeu.firstandroidapp (un namespace unique. Il est conseillé d'utiliser uniquement des minuscules et de commencer la le code pays suivit du nom de la société).
Min SDK version: 9 (correspond à la version de l'API d'Android).

Définir un Run Configuration
Avant d'exécuter le programme pour le tester, il faut impérativement définir une configuration d'exécution pour l'application android.
Accessible depuis le menu associé au bouton Run (entrée "Run configurations..."), la configuration est composée de plusieurs volets.
Ma config se nomme "firstAndroidApp - 2.3", et en voici les détails.

Sélectionner "Android Application" et ajouter une nouvelle entrée.
Nommée l'entrée "firstAndroidApp - 2.3"
Sélectionner le projet Eclipse correspondant (à savoir "FirstAndroidApp").

Laisser l'environnement choisir l'AVD de façon automatique.
La seule correspondance disponible pour une API de version 9 est bien la machine virtuelle "Domeu" qui a été crée plus tôt dans cet article. Le système automatique fonctionnera donc parfaitement.

Activer "Display in favorites menu" pour Run et Debug.

Pour démarré l'application, il suffira de sélectionner "firstAndroidApp - 2.3" dans le popup menu du bouton Run (et de presser Run pour effectivement démarrer l'application).

Avant de démarrer l'application

Démarrer par avance un device AVD avec la bonne configuration permet de gagner un temps monstre lorsque l'on veut tester son application Android.
Le device étant déja disponible et en cours de fonctionnement, Eclipse téléchargera et activera l'application directement dans l'instance de l'ADV en cours d'exécution. C'est presque instantané.

Première application Android

Un tutoriel Android
Lars Vogel a écrit un tutoriel assez complet sur Android (version GingerBread).
Il permet de se faire la main avec l'environnement de développement et d'explorer les spécificités de l'environnement de développement.
A mon sens, il fait partie des incontournables!

Le tutoriel est disponible a l'adresse www.vogella.de/articles/Android/article.html

Le tutoriel comporte les erreurs/imprécisions suivantes:

• L'inputType de la zone texte doit être codée "numberSigned|numberDecimal".
  Un pipe doit être utiliser pour combiner les flags.
• Il faut être vigilant car le code fait référence à des ressources string (même pour le nom de la méthode à appeler).
• Pour utiliser une ressource string, on utilise @string/TheStringName (ex:@string/celcius)
• Harrg!!! Pour sélectionner une couleur, il faut utiliser le "reference chooser" dans l'éditeur de propriété... mais seulement, le reference chooser n'apparait jamais lorsque l'on clique dessus.
  Voici un workaround: il suffit de faire un clique droit sur le bouton [...] et de presser ensuite la barre d'espacement. C'est un peu contraignant mais cela fonctionne.
• L'utilisation de l'outil "adb logcat" s'est montré très utile pour tracer les exceptions causée par les bugs de mon application. Il est vrai que lorsque je teste, je sors un peu des sentiers battus :-)

Voici d'ailleurs le résultat de mes premiers essais:


Conclusion
Cet article démontre qu'il est tout à fait possible de faire des développements Android depuis Ubuntu.
Eclipse se révèle être un environnement de développement relativement convivial et assez réactif même à sa première approche.
Un développeur .Net s'y retrouve assez facilement (aussi bien dans l'environnement qu'avec le langage Java).
Par contre, Android est un éco-système complet et y conduire des développements plus avancés demandera un investissement plus conséquent.
La plateforme dispose de nombreux widgets (composants visuels d'ailleurs nommés View) mais c'est surtout le nombre de propriétés disponibles qui les rendent difficiles à cerner au premier abord.
Les concepts habituels des fenêtres Windows est totalement balayé par d'autres concepts comme les Activity, ViewGroup, View, etc (voir le tutoriel de Lars Vogel).
C'est encore sans compter avec l'humour des concepteurs d'Android.
Le petit message "Please, enter a valid number" s'affiche avec une classe nommée Toast... comme le pain qui saute hors du Toaster.
Assez humoristique mais un peu déroutant. 

Pour poursuivre, je vous propose de consulter l'article "Hello, Android: une introduction à la plateforme de développement Google Mobile" et sa vidéo.
Cet article présente un livre de référence pour conduire le développement Android.