Dans ce petit article je vais vous parler du développement Android avec Qt et en C++, en effet, j’ai travaillé dernièrement dans une entreprise d’automatisation et de régulation des bâtiments où un des développeurs était en charge d’un projet d’application Android. La qualité de ses développements m’a donné envie de tenter l’aventure. Malgré la magnifique API de Java pour android je voulais pouvoir déployer pour Windows, Linux, Mac, Symbian et Android la même application. Mon choix se portait donc sur mon framework préféré : Qt et naturellement mon langage préféré. Je ne serai jamais assez redevant à Bjarne Stroustrup =D.

Développer des applications basées sur Qt pour android est possible via le projet android-lighthouse, qui fonctionne très bien ! En effet ce dernier rend possible l’exécution d’une application C++/Qt complète ou encore l’utilisation en Java des libraires écrites avec le framework.

Lighthouse

Quant à lighthouse c’est un projet que l’équipe du Framework Qt a lancé avant la version 4.7 pour rendre le framework Qt portable à n’importe quelle plateforme facilement. En effet cela requiert très peu de code spécifique à la plateforme afin de faire fonctionner toutes les librairies Qt.

Depuis quelques semaines lighthouse est passé dans la branche stable de Qt. Grâce à android-lighthouse on peut d’ailleurs voir que le portage des bibliothèques est très rapide. Seulement quelques mois ont été nécessaires pour obtenir une version pleinement (ou presque) fonctionnelle: même les interfaces basées sur le QML fonctionnent! C’est grâce à BogDan Vatra, initiateur du projet, que le port de Qt pour android en est arrivé à cette maturité qui démontre ainsi que Qt peut être porté n’importe où: Code less, do more, deploy everywhere!

Awesome!

Cela rend le portage d’applications Qt sur Android très simple, écrire une application avec le framework Qt signifie que l’on peut désormais la compiler sans effort pour : Symbian, Windows, Mac, Linux & Android ! C’est à mon sens parfait pour construire une base de librairies réutilisables dans une entreprise. Dans cette idée il est également possible de développer des bibliothèques basées sur les fonctionnalités de Qt et de les lier avec JNI afin d’apporter des fonctionnalités natives aux applications Java Android existantes.

Je vous présenterai dans cet article les différentes versions d’Android supportées, les quelques limitations et clarifications nécessaires, ainsi que les procédures à suivre afin de compiler pour et lancer sur Android votre application Qt.

Les versions d’Android compatibles

Lorsque le projet Qt android-lighthouse a été créé, seuls les périphériques Android 1.5 étaient supportés avec Qt lié en statique, ce qui n’est plus le cas aujourd’hui. En effet la branche actuelle du dépôt supporte seulement Qt lié dynamiquement (cela réduit l’utilisation de la mémoire – James Noble & Charles Weir 2001 – Small Memory Software, puisque chacune des applications partagent les mêmes bibliothèques Qt). Cette dernière supporte aujourd’hui les versions d’Android actuelles du marché: 1.6, 2.0, 2.1 et 2.2. N’hésitez pas à essayer avec l’émulateur Android car il fonctionne comme les véritables périphériques, plus d’un développeur Android m’en a confirmé ses qualités.

Quelques Limitations

Il y a actuellement (25/11/2010) quelques limitations, par exemple le rendu est réalisé uniquement par le software, les accélérations matérielles Open GL ne sont pas utilisées. Toutefois ce n’est certainement qu’une question de jours, car jusqu’aujourd’hui le portage de Qt sur Android a été très rapide et est toujours aussi actif.

Une autre limitation qui sera bientôt fixée d’après les initiateurs du projet est que l’on ne peut utiliser QtMultimedia pour jouer des sons, il y a d’autres solutions pour y parvenir, toutefois le port de QtMultimedia sera bientôt fait, et d’après l’initiateur du projet cela devrait être “le correctif le plus facile” qu’il lui reste à faire.

Quelques Clarifications

Vous n’avez pas besoin d’être “root” ou d’avoir accès au shell root sur votre périphérique pour déployer des applications Qt, cela signifie que vous pourriez envoyer l’application sur le Google Market. Toutefois actuellement il est plutôt déconseillé de le faire, il vaudrait mieux attendre que cela soit plus testé et utilisé (ce que fait actuellement une communauté grandissante: http://groups.google.com/group/android-qt/).

Préparez votre environnement de développement

J’ai écrit les instructions suivantes en m’inspirant de la page http://code.google.com/p/android-lighthouse/wiki/Compile et de ma propre expérience sur Linux 32 bits. Si vous êtes sur Windows vous devriez jeter un oeil au problème suivant: Configure does not work with Cygwin on winxp et appliquer le patch pour cygwin qui est proposé dans l’une des réponses. Enfin si vous êtes sur Mac OS X vous devriez simplement oublier pour le moment (ou bien trouver une solution :p): broken build on mac osx – x86.

Linux semble être la meilleure plateforme pour développer avec Qt pour android actuellement, donc si vous n’utilisez pas cette plateforme, je vous conseille d’essayer avec une Machine Virtuelle, du moins c’est la solution dont je peux vous en assurer le fonctionnement.

Actuellement quelques éléments dits sur la page officielle traitant de la compilation de Qt et d’applications Qt pour android ne sont pas vraies, c’est pourquoi je vais vous guider dans la bonne direction pour faire fonctionner votre application Qt sur android, tel que Francisco Dalla Rosa Soares m’a montré cette semaine sur la mailing list d’android-lighthouse. Sans lui je n’aurai jamais pu lancer quoi que ce soit, si ce n’est mon pc portable…

Téléchargement

Avant tout il vous faut télécharger et décompresser QADK, qui est un Kit de Développement natif non officiel pour android, basé sur l’officiel mais avec quelques bibliothèques non supportées en plus:

wget http://android-lighthouse.googlecode.com/files/qadk-r4-1.tar.bz2
tar xf qadk-r4-1.tar.bz2 .

Après cela il vous faudra cloner le repository git de android-lighthouse qui lui même consiste en un clone du projet Qt lighthouse qui est officiellement fourni par Nokia:

git clone git://gitorious.org/~taipan/qt/android-lighthouse.git

Configurer & Compiler

Vous devrez compiler Qt pour la plateforme visée, il est nécessaire de définir la variable ANDROID_PLATFORM et de faire pointer NDK_ROOT vers le dossier où vous avez décompressé QADK.

mkspecs/android-g++/qmake.conf:12 ->
NDK_ROOT = /path/to/qadk-r4

mkspecs/android-g++/qmake.conf:18 ->
ANDROID_PLATFORM = android-5

La dernière ligne est présente pour cibler les plateformes android 2.0 & 2.1, ce qui fonctionna sans problèmes pour ma part. Utilisez android-4 afin de cibler les plateformes 1.6 et android-8 pour cibler les plateformes 2.2.

Vous pouvez désormais lancer la partie de configuration (n’hésitez pas à aller voir votre petite amie pendant ce temps):

./androidconfig.sh

Et enfin vous pouvez compiler le tout:

make -j3

Changez 3 par le nombre de coeur de votre processeur + un, cela activera la compilation parallèle avec autant de processus.

Il y a une dépendance de Qt qui n’est pas incluse au projet, c’est libcloog-ppl-dev, lancez simplement:

sudo apt-get install libcloog-ppl-dev

Pour ce que j’ai pu comprendre c’est une librarie utilisée pour l’optimisation de code, qui est destinée à générer du code permettant de passer sur chacun des points d’un Polyèdre. Je suppose que c’est utilisé dans qmake, mais je ne pourrai vous l’assurer. Plus de détails et un exemple sur le site officiel.

Installez Qt sur le Périphérique

Maintenant ce serait sympa d’avoir Qt sur le périphérique Android (ou dans l’émulateur), pour ce faire faites simplement ce que la page de wiki de google code conseille:

mkdir andlibs
cp -a lib/*.so* andlibs/
adb push andlibs /data/local/qt/lib

Connectez votre Périphérique

Si vous recevez l’erreur adb: command not found, c’est parce que vous êtes nouveau au développement Android (tout comme moi). Vous devez simplement télécharger le dernier sdk d’Android, vous pouvez trouver les instructions détaillées ici et le sdk ici.

Cependant à cette étape de l’article vous avez simplement besoin de télécharger le SDK, de définir le PATH et d’éxécuter:

tools/android update sdk

Ensuite si vous voulez essayer sur votre véritable téléphone vous devrez activer la connexion avec ce dernier, pour y parvenir je vous invite à suivre la petite partie décrite sur le site d’android.

Je suis sur Linux, donc j’ai simplement mis en place la configuration suivante pour mon téléphone LGGT540 sur android 2.1. Sur mon pc avec Ubuntu 10.10 j’ai défini les informations suivantes dans le fichier /etc/udev/rules.d/51-android.rules:
Les fichiers présents dans /etc/udev/rules.d/ sont destinés à définir des règles persistantes pour les périphériques, dont l’une est de changer le CHMOD d’accès à un périphérique, en fonction d’éléments permettant de l’identifier.

SUBSYSTEM=="usb", SYSFS{idVendor}=="1004", MODE="0666"
SUBSYSTEM=="usb_device", SYSFS{idVendor}=="1004", MODE="0666"

Où 1004 vient d’une liste fournie de Vendor Ids pour les périphériques android: http://developer.android.com/guide/developing/device.html#VendorIds/. Prenez celui qui convient.

Sur Windows il vous faudra simplement installer les pilotes adb, et sur Mac OS X cela fonctionne sans rien faire, toutefois rappelez vous que android-lighthouse pour Mac OS X ne semble pas fonctionner.

Pour lister les périphériques Android existants vous pouvez lancer: adb devices.

Votre première Application Qt pour Android

Nous n’allons pas écrire notre propre code (oui je sais c’est triste), parce qu’il y a beaucoup de Hello World-like dans les demos du Qt Sdk. Nous allons donc choisir un très simple, afin d’expliquer les choses qui nous intéressent: la configuration de la compilation et comment créer un projet java afin de lancer l’application.

En effet contrairement aux dires du site officiel il n’est pas possible actuellement de compiler directement l’application en temps qu’exécutable natif. Il est nécessaire de la compiler en une bibliothèque dynamique, que l’on chargera à l’aide d’un petit launcher java basé sur les classes fournies par android-lighthouse. Ces dernières sont présentes dans le package com.nokia.qt.QtActivity.

Maintenant allez dans le répertoire /android-lighthouse/demos/mainwindow/, ici vous pouvez ouvrir le fichier mainwindow.pro, qui devrait contenir les configurations suivantes:

TEMPLATE = lib
CONFIG += dll

HEADERS += colorswatch.h mainwindow.h toolbar.h
SOURCES += colorswatch.cpp mainwindow.cpp toolbar.cpp main.cpp

Il est réellement important de compiler l’application en tant que bibliothèque dynamique, ainsi pour vos prochaines applications n’oubliez pas d’utiliser les deux premières lignes données ci-dessus. Personnellement j’ai une préférence pour CMake, mais je n’ai pas encore pu préparer de configuration pour android pour le moment, et pourtant cela devrait seulement consister à éditer la méthode qt4_wrap_cpp pour lui donner la version android-lightouse spécialisée de qmake.

En effet pour compiler l’application, il faut utilisez android-lighthouse/bin/qmake afin de générer les fichiers de moc et le Makefile, et non pas la version de qmake que vous avez dans votre PATH.

/path/to/android-lighthouse/bin/qmake
make -j3

Voilà, vous ne devez même pas adapter le code de votre application Qt. Le résultat des commandes que vous avez lancées devrait être un fichier so (shared object) avec différents liens symboliques afin de rendre possible la compatibilité entre versions apportée par libtool.

Envoyez simplement celle sans informations de compatibilité de versions sur votre périphérique android: adb push libmainwindow.so /data/local/qt/lib. Une fois que vous avez fait cela, l’application est sur le téléphone, mais rien n’existe pour la lancer.

Créez le Projet Android

Nous allons ainsi créer un launcher en java, basé sur le launcher fourni par le projet android-lighthouse, qui s’occupe tout seul des bindings JNI nécessaires.

Tout d’abord créez un projet dans un sous-dossier (javaLoader par exemple)

android create project --target 2.1 \
			--name mainwindow \
			--path ./ \
			--activity mainwindow \
			--package com.yourcompany.mainwindow

Créez une classe QtMain.java (vim seul ou avec eclim est un bon outil pour cela):

package org.yourcompany.mainwindow;

	import com.nokia.qt.QtActivity;

	public class QtMain extends QtActivity
	{
		public QtMain()
		{
			/* setLibraries(libraries);
			    This could be useful for you if you need to load
			    some other libraries with your application.
			*/
			setApplication("mainwindow");
		}
	}

Et ensuite tapez simplement:

ant debug
cd bin
adb install mainwindow-debug.apk

Votre application est installée, et peut facilement être lancée sur votre périphérique à l’aide de:

adb shell am start -a android.intent.action.MAIN -n com.yourcompany.mainwindow/.mainwindow

À propos du débogage

Pour le moment je n’ai hélas pas réussi à déboguer l’application sur le périphérique, mais les sorties consoles sont redirigées, il est donc tout de même possible d’utiliser qDebug pour faire le débogage. Ce n’est pas optimal mais ce n’est qu’en attendant de trouver un moyen simple. Je pense néanmoins que l’outil qadk-r4/ndk-gdb peut rendre le débogage possible, je n’ai pas réussi cependant à faire quoi que ce soit pour l’instant à ce sujet. Je posterai dès que j’y parviendrai.

Qt Creator

Apparemment l’intégration d’Android pour Qt Creator est très avancée mais pas encore dans le dépôtd’après un mail de Tero Savolainen arrivé au moment de poster l’article, sur la liste de diffusion nommé “Re: Qt porting status and some great news” l’intégration de Qt Creator avec Androïd est faite et le débogage est la prochaine fonctionnalité à venir.

Conclusion

Comme vous avez pu le voir il devient très simple de développer nativement pour Android, le projet étant très actif, il y a fort à parier que pour fin décembre les limitations citées devraient avoir disparues et que le débogage soit possible.

Merci beaucoup pour votre lecture, je suis ouvert à toutes vos suggestions et remarques concernant cet l’article.

Il faut le reconnaître, l’intégration Android dans Eclipse est très bien pensée et plutôt efficace : auto-complètement, assistants à tout va, débogueur, etc. Seulement voilà, il faut se rendre à l’évidence : quand on est habitué à Vim, l’éditeur de texte d’Eclipse fait plutôt pâle figure. Et en y réfléchissant bien, l’essentiel du développement Android reste l’écriture de code toute bête ou la modification de fichiers XML : pourquoi ne pourrait-on pas simplement utiliser une console et l’éditeur de texte de notre choix ?

Voici donc ce que propose ce tutorial : l’installation d’un environnement de développement simplifié pour Android.

Prérequis

Avant de poursuivre ce tutorial, vérifiez que vous :

• Êtes habitué au développement “console”. Si vous n’avez jamais utilisé que des IDE, je ne peux que trop vous conseiller de rester dans cet environnement. Le développement Android en console n’est pas recommandé par Google et de plus beaucoup moins facile d’accès que pour d’autres langages (C, C++).
• Savez ajouter/modifier/supprimer des variables d’environnement.
• Avez téléchargé et installé le Android SDK. Si vous ne connaissez pas la marche à suivre, elle est indiquée dans cet article.
• Êtes prêt à passer pour un fanatique auprès de vos amis qui utilisent un IDE.

Si vous remplissez toutes ces conditions, c’est parti !

Développons en Java

On a beau se passer d’Eclipse, on ne peut évidement se passer d’utiliser Java.

Commencez par télécharger le kit de développement Java (JDK) pour votre système d’exploitation, puis installez-le.

Pour ma part, j’ai choisi le chemin d’installation par défaut, c’est à dire “C:\Program Files\Java” sur mon Windows Seven 64 bits.

On se retrouve avec les deux répertoires suivants :

Répertoires Java

La dernière étape concernant Java, consiste à ajouter le sous-répertoire “C:\Program Files\Java\jdk1.6.0_22\bin” au PATH de l’environnement.

Ouvrez une fenêtre console et saisissez la commande suivante :

javac

Si vous obtenez la sortie suivante :

C:\Users\Julien>javac
Usage: javac <options> <source files>
where possible options include:
 -g                         Generate all debugging info
 -g:none                    Generate no debugging info
 -g:{lines,vars,source}     Generate only some debugging info
 -nowarn                    Generate no warnings
 -verbose                   Output messages about what the compiler is doing
 -deprecation               Output source locations where deprecated APIs are used
 -classpath <path>          Specify where to find user class files and annotation processors
 -cp <path>                 Specify where to find user class files and annotation processors
 -sourcepath <path>         Specify where to find input source files
 -bootclasspath <path>      Override location of bootstrap class files
 -extdirs <dirs>            Override location of installed extensions
 -endorseddirs <dirs>       Override location of endorsed standards path
 -proc:{none,only}          Control whether annotation processing and/or compilation is done.
 -processor <class1>[,<class2>,<class3>...]Names of the annotation processors to run; bypasses default discovery proces
s
 -processorpath <path>      Specify where to find annotation processors
 -d <directory>             Specify where to place generated class files
 -s <directory>             Specify where to place generated source files
 -implicit:{none,class}     Specify whether or not to generate class files for implicitly referenced files
 -encoding <encoding>       Specify character encoding used by source files
 -source <release>          Provide source compatibility with specified release
 -target <release>          Generate class files for specific VM version
 -version                   Version information
 -help                      Print a synopsis of standard options
 -Akey[=value]              Options to pass to annotation processors
 -X                         Print a synopsis of nonstandard options
 -J<flag>                   Pass <flag> directly to the runtime system

C’est que tout est bien configuré

Un peu de ménage

Avant d’installer le JDK, je me suis rendu compte que j’avais déjà une version du runtime Java installée.

Si c’est également votre cas, rien ne vous empêche de la garder, mais pour éviter les conflits potentiel, et ne pas gaspiller inutilement de l’espace disque, j’ai choisi de procéder manuellement à sa désinstallation avant d’installer le JDK.

J’ai également à ce moment là, fait le ménage dans les variables d’environnement qui faisaient référence à Java.

Ant, un “Makefile-like” pour Java

Le Android SDK utilise Ant pour automatiser la compilation des projets. Pour ceux qui connaissent, c’est une alternative orientée Java à Makefile, CMake, SConstruct ou encore BJAM.

Pour les plus curieux, vous pouvez faire un tour sur la page officielle de Ant.

Sinon, passons directement au téléchargement : Télécharger Ant.

Décompressez l’archive où bon vous semble (j’ai choisi encore une fois de tout mettre dans C:\) et ajoutez les variables d’environnement suivantes :

• ANT_HOME : Le chemin vers l’archive décompressée. Chez moi : “C:\apache-ant-1.8.1″
• JAVA_HOME : Le chemin vers l’installation du JDK. Chez moi : “C:\Program Files\Java\jdk1.6.0_22″
• PATH : Ajoutez le chemin vers les binaires de Ant. Chez moi : “C:\apache-ant-1.8.1\bin”

Une fois que tout est configuré, ouvrez une nouvelle console et tapez :

ant

Si vous obtenez la sortie suivante :

C:\Users\Julien>ant
Buildfile: build.xml does not exist!
Build failed

C’est que Ant est correctement installé.

Si ça ne fonctionne pas, vérifiez bien que l’environnement de votre console est bien à jour. Sous Windows, il faut fermer toutes les fenêtres consoles et les ré-ouvrir pour appliquer les modifications faites à l’environnement.

C’est tout ?

Oui. Il n’en faut pas plus pour avoir un environnement de compilation simple pour Android.

Nous pouvons d’ores et déjà voir comment créer un nouveau projet, le compiler et le déployer sur un émulateur.

Création d’un projet

Pour créer un nouveau projet, nous allons utiliser la commande “android”.

Voici la syntaxe pour créer un nouveau projet :

android create project \
--target <em>&lt;version_cible&gt;</em> \
--name <em>&lt;nom&gt;</em> \
--path <em>&lt;chemin&gt;</em> \
--activity <em>&lt;activité&gt;</em> \
--package <em>&lt;</em>espace_de_nom<em>&gt;
</em>

La signification des différents paramètres est la suivante :

• version_cible : l’identifiant de version Android cible à utiliser. Pour avoir la liste des identifiants disponibles sur votre poste, utilisez la commande “android list targets”.
• nom : Le nom de votre projet. Ce paramètre est optionnel, mais s’il est spécifié, ce nom sera celui du paquet “.apk” généré ultérieurement.
• chemin : Le répertoire cible où sera créé votre nouveau projet.
• activité : Le nom complet de l’activité. Exemple : “MyAndroid”.
• espace_de_nom : L’espace de nom (ou “namespace”) utilisé par votre projet. Exemple : “org.freelan.myandroid”.

Google donne la commande exemple suivante :

android create project \
--target 1 \
--name MyAndroidApp \
--path ./MyAndroidAppProject \
--activity MyAndroidAppActivity \
--package com.example.myandroid

Qui crée dans le répertoire courant un sous-répertoire “MyAndroidAppProject” contenant le nouveau projet.

Arborescence d'un nouveau projet Android

Nous ne rentrerons pas ici dans les détails de cette arborescence, mais voici tout de même dans les grandes lignes les choses intéressantes :

• Les fichiers source Java sont situés dans le répertoire “src”.
• Tout ce qui concerne les chaînes de caractères, fichiers XML représentant l’interface graphique (ou “Layouts”) ou images sont dans le répertoire “res”.
• Ne touchez jamais aux fichiers “*.properties” ! Ils sont utilisés par Ant pour la phase de “build” et n’ont pas vocation à être modifiés manuellement.

Compilation du projet

Le projet, tel que créé par défaut est simpliste mais fonctionnel. Le rôle de ce tutoriel n’étant pas d’apprendre à concevoir une application Android mais de simplement maitriser les outils du SDK, nous ne ferons aucune modification de ce projet.

Pour être diffusée, une application Android doit être signée. Ceci implique plusieurs démarches dont nous traiterons dans un autre tutoriel. Pour l’heure, nous choisissons de compiler notre projet en “debug”, ce qui nous permet de nous affranchir de cette étape.

Dans la même console, toujours à la racine du projet, tapez simplement la commande :

ant debug

Qui a pour effet de générer dans le répertoire “bin” différentes choses, dont le fichier “MyAndroidApp-debug.apk”.

Ce n’est pas plus compliqué que ça.

Création d’un périphérique virtuel

Pour tester notre application, il nous faut soit un téléphone sous Android relié en USB et configuré en mode développeur, soit un téléphone virtuel lancé dans un émulateur.

Si vous n’avez pas encore créé de téléphone virtuel, voici la marche à suivre :

Dans votre console, tapez la commande :

android

Ce qui a pour effet d’ouvrir la fenêtre suivante :

Gestion des téléphone virtuels

Cliquez sur “New…”, puis spécifiez les caractéristiques de votre téléphone virtuel :

Caractéristiques du téléphone virtuel

Puis validez en cliquant sur “Create AVD”.

Si tous les paramètres sont corrects, votre téléphone virtuel est créé. Vous pouvez d’ores et déjà le démarrer en le sélectionnant dans la liste et en cliquant sur le bouton “Start…”.

Ce premier démarrage peut être assez long, aussi, soyez patient.

Installer son application sur le téléphone

Une fois le paquet “apk” créé, l’installation sur un téléphone (qu’il soit virtuel ou non) se fait très simplement :

adb install <em>bin\MyAndroidApp-debug</em>.apk

La commande prends quelques secondes et vous indique le succès ou l’échec de l’opération.

Si vous disposez de plusieurs émulateurs, ou d’un émulateur et d’un téléphone physique, adb ne peut pas deviner où installer votre paquet.

Utilisez alors la syntaxe suivante pour spécifier le périphérique à utiliser :

adb -s emulator-5554 install bin\MyAndroidApp-debug.apk

Ou positionnez la variable d’environnement ANDROID_SERIAL avant vos appels à adb.

Pour obtenir la liste des numéros de série des périphériques, vous pouvez utiliser la commande suivante :

adb devices

La commande “adb install” possède tout un tas d’option qu’il ne serait pas raisonnable de détailler ici. Vous devriez cependant y jeter un coup d’oeil. Pour les lister, tapez simplement :

adb install

Qui produit la sortie suivante :

C:\Users\Julien>adb install
Android Debug Bridge version 1.0.26

 -d                            - directs command to the only connected USB device returns an error if more than one USB device is present.
 -e                            - directs command to the only running emulator. returns an error if more than one emulator is running.
 -s <serial number>            - directs command to the USB device or emulator with the given serial number. Overrides ANDROID_SERIAL environment variable.
 -p <product name or path>     - simple product name like 'sooner', or  a relative/absolute path to a product out directory like 'out/target/product/sooner'.
 If -p is not specified, the ANDROID_PRODUCT_OUT environment variable is used, which must be an absolute path.
 devices                       - list all connected devices
 connect <host>:<port>         - connect to a device via TCP/IP
 disconnect <host>:<port>      - disconnect from a TCP/IP device

device commands:
 adb push <local> <remote>    - copy file/dir to device
 adb pull <remote> [<local>]  - copy file/dir from device
 adb sync [ <directory> ]     - copy host->device only if changed
 (see 'adb help all')
 adb shell                    - run remote shell interactively
 adb shell <command>          - run remote shell command
 adb emu <command>            - run emulator console command
 adb logcat [ <filter-spec> ] - View device log
 adb forward <local> <remote> - forward socket connections
 forward specs are one of:
 tcp:<port>
 localabstract:<unix domain socket name>
 localreserved:<unix domain socket name>
 localfilesystem:<unix domain socket name>
 dev:<character device name>
 jdwp:<process pid> (remote only)
 adb jdwp                     - list PIDs of processes hosting a JDWP transport
 adb install [-l] [-r] [-s] <file> - push this package file to the device and install it
 ('-l' means forward-lock the app)
 ('-r' means reinstall the app, keeping its data)
 ('-s' means install on SD card instead of internal storage)
 adb uninstall [-k] <package> - remove this app package from the device ('-k' means keep the data and cache directories)
 adb bugreport                - return all information from the device that should be included in a bug report.

 adb help                     - show this help message
 adb version                  - show version num

DATAOPTS:
 (no option)                   - don't touch the data partition
 -w                           - wipe the data partition
 -d                           - flash the data partition

scripting:
 adb wait-for-device          - block until device is online
 adb start-server             - ensure that there is a server running
 adb kill-server              - kill the server if it is running
 adb get-state                - prints: offline | bootloader | device
 adb get-serialno             - prints: <serial-number>
 adb status-window            - continuously print device status for a specified device
 adb remount                  - remounts the /system partition on the device read-write
 adb reboot [bootloader|recovery] - reboots the device, optionally into the bootloader or recovery program
 adb reboot-bootloader        - reboots the device into the bootloader
 adb root                     - restarts the adbd daemon with root permissions
 adb usb                      - restarts the adbd daemon listening on USB
 adb tcpip <port>             - restarts the adbd daemon listening on TCP on the specified port
networking:
 adb ppp <tty> [parameters]   - Run PPP over USB.
 Note: you should not automatically start a PPP connection.
 <tty> refers to the tty for PPP stream. Eg. dev:/dev/omap_csmi_tty1
 [parameters] - Eg. defaultroute debug dump local notty usepeerdns

adb sync notes: adb sync [ <directory> ]
 <localdir> can be interpreted in several ways:

 - If <directory> is not specified, both /system and /data partitions will be updated.

 - If it is "system" or "data", only the corresponding partition is updated.

Démarrer une activité

Une fois installée, vous pouvez démarrer l’activité sur votre téléphone comme vous le feriez pour n’importe quelle autre application. Mais si vous le souhaitez, vous pouvez également le faire en ligne de commande (voire automatiquement, si vous mettez toutes les commandes dans un script).

La commande ci-après démarre votre activité sur le téléphone spécifié (ou sur le seul téléphone connecté) :

adb shell am start -a android.intent.action.MAIN -n com.example.myandroid/.MyAndroidAppActivity

Vous pouvez d’ailleurs démarrer n’importe-quelle activité en utilisant cette méthode.

Une seule commande pour tout

Astuce qu’il est agréable de connaître : Il est possible de réunir les dernières étapes en une seule commande en utilisant la commande suivante :

ant install

Qui va se charger de faire un “ant debug”, “adb install…” pour vous. Plutôt sympa non ?

Conclusion

Le développement Android en mode console s’avère moins pénible à mettre en place que je ne l’aurais pensé. Google a fait un travail impressionnant en fournissant aux développeurs des outils simples et facile à intégrer à n’importe quel environnement.

Certains argueront que l’apprentissage du développement Android est bien plus facile sous Eclipse, et je pense que dans un sens ce n’est pas faux : il est clair qu’avoir le complètement automatique et des assistants permet d’apprendre peu à peu et facilement les différentes structures de données à utiliser. Cependant, la découverte de cet environnement console permet assurément de comprendre tout ce qu’Eclipse fait pour nous de façon automatique.

L’utilisation directe de “adb” peut notamment fournir au développeur des outils avancés indispensables et une aide précieuse au développement.

Commençons par le début, voulez-vous ?

Nous allons supposer que vous disposez d’un ordinateur, d’une connexion à l’Internet et éventuellement d’un téléphone sous Android. Ce dernier point n’est évidemment pas obligatoire mais il faut reconnaître que c’est quand même moins marrant de tester son application dans un émulateur que sur un vrai téléphone.

Les instructions que je vais décrire sont pour Windows, mais il ne sera certainement pas très difficile de les transcrire pour Linux ou Mac OSX.

Installer le support de Java

Le langage de choix pour le développement Android est le Java. Il s’agit d’un langage complètement portable : le code est le même indépendamment du système d’exploitation ou de son architecture (x86, x64, etc.). Pour s’exécuter sur les différents systèmes, Java requiert l’installation d’une JVM, (“Java Virtual Machine” ou encore “Machine Virtuelle Java”) qui “traduit” le code Java en instructions compréhensibles par le système hôte.

Installons donc cette JVM : Télécharger la JVM

Le “Android SDK”

Il faut ensuite télécharger le kit de développement Android fourni par Google. Encore une fois, rien de plus simple : Télécharger le Android SDK

Une fois l’archive récupérée, décompressez-la où bon vous semble. Pour ma part, j’aime avoir mes différents environnements de développement sous Windows à la racine du C:\, mais vous pouvez très bien décider de la mettre ailleurs^*.

* Évitez tant que possible d’utiliser un chemin contenant des espaces, ce ne serait pas la première fois que ça cause des problèmes !

Il faut ensuite ajouter au PATH le répertoire de l’archive contenant les outils du SDK. Sur mon poste, j’ai donc ajouté “C:\android-sdk-windows\tools” à mon PATH :

Ajouter les outils du Android SDK à son PATH

Eclipse, l’outil de prédilection

Pour développer, il faut ensuite au moins un éditeur de texte et au mieux un IDE. Bien que ne connaissant que très peu Java, j’avais cependant déjà entendu parler d’Eclipse. Google ayant en plus eu le bon goût de développer un plugin Eclipse pour le développement Android : il semble s’agir d’un bon choix.

Mon instinct de développeur à la page m’inciterait à télécharger la dernière version d’Eclipse (la 3.6 au moment où ces lignes sont rédigées), mais Google indique sur la page de présentation de son plugin que celui-ci ne fonctionne qu’avec la version 3.5.

Téléchargeons donc la version 3.5 : Page de téléchargement d’Eclipse

Rendez-vous dans l’onglet “Older versions” puis choisissez “Eclipse Galileo SR2 Packages (v 3.5.2)” puis enfin prenez “Eclipse IDE for Java Developers“.

Décompressez l’archive, et placez le dossier “eclipse” où bon vous semble. Encore une fois, j’ai choisi de le mettre à la racine du C:\ par souci de cohérence.

Rendez-vous dans le répertoire fraîchement décompressé puis lancez “eclipse.exe”. Ceci peut prendre un peu de temps, puis le programme vous demande où vous souhaitez enregistrer vos futurs projets.

Le plugin ADT

Il ne manque plus que l’installation du plugin officiel Google pour Android (ADT).

Rendez-vous sur cette page. Et suivez les instructions concernant votre version d’Eclipse.

Pour ceux qui auraient un problème avec la langue de Shakespeare, voici les premières instructions traduites :

1. Démarrez Eclipse, et rendez-vous dans le menu “Help” puis “Install New Software”.
2. Cliquez sur le bouton “Add…”
3. Dans le premier champ, entrez “Android Developer Tools” puis dans le second champ, saisissez “https://dl-ssl.google.com/android/eclipse/”. Validez par un clic sur le bouton “OK”.
4. Vous devriez désormais voir une entrée “Developer Tools” dans la liste plus bas. Sélectionnez la case à cocher, ce qui a pour effet de sélectionner automatiquement les deux sous-cases.
5. Faites “Next” autant de fois que nécessaire, acceptez la license d’utilisation (si vous la comprenez), puis cliquez sur “Finish”. Eclipse télécharge ensuite les composants.
6. Redémarrez Eclipse pour terminer l’installation du plugin.

Installer de nouveaux composants pour Eclipse

Ajouter la source ADT

Acceptation de la licence

Avant d’être utilisé, le plugin ADT doit être configuré. Rendez-vous dans “Windows”, puis “Preferences” et sélectionnez “Android” dans la liste à gauche.

Spécifiez le chemin vers le SDK installé en cliquant sur le bouton “Browse…” et en cherchant l’endroit où vous avez décompressé le Android SDK. Chez moi, il s’agit de “C:\android-sdk-windows”.

Validez par “OK” pour terminer la configuration.

Configuration du Android SDK

La dernière étape avant de pouvoir développer pour Android consiste à configurer le Android SDK.

Rendez-vous dans le répertoire où vous avez décompressé le Android SDK, puis exécutez le programme : “SDK Manager.exe”.

Configuration du Android SDK

Choisissez les paquets à installer en les acceptant ou en les refusant.

Pour ma part, j’ai conservé le choix par défaut, puis j’ai cliqué sur “Install”. S’en suit une série de téléchargements, plus ou moins rapides.

Créer un périphérique virtuel

Cette étape n’est pas obligatoire pour ceux qui disposent d’un téléphone sous Android, mais il peut être pratique d’avoir un téléphone virtuel prêt à l’emploi pour faire des tests rapides (ou lorsqu’on est dans le train et qu’avoir 15 000 trucs sur les genoux n’est pas une option !).

Toujours dans le “Android SDK Manager”, rendez-vous dans la catégorie : “Virtual Devices” puis faites “New…”.

Choisissez un nom significatif pour votre périphérique virtuel. Dans mon cas, j’ai décidé de reproduire les caractéristiques physiques de mon téléphone : je l’ai donc nommé “HTC_Desire”.

Choisissez une version de l’OS à utiliser (dans mon cas toujours, “Android 2.2 – API Level 8″) et une taille pour la carte SD. Ici, ça dépend vraiment de votre espace disque : j’ai choisi “4096 Mo” comme ma vraie carte SD, mais si vous êtes limité en place, quelque-chose comme “128 Mo” peut être suffisant.

Pour le reste, j’ai laissé les réglages par défaut qui semblaient convenir.

Cliquez sur “Create AVD” pour finaliser la création.

Vous pouvez, si vous le souhaitez, vous amuser à démarrer le téléphone virtuel en cliquant sur le bouton “Start” à droite. Le téléphone peut mettre un peu de temps à démarrer (surtout la première fois) aussi, soyez patient.

L'émulateur de périphérique Android

Félicitations !

Ça y est ! Vous avez terminé la configuration de l’environnement de développement et vous êtes prêt à développer pour votre nouvelle plateforme préférée !

Rendez-vous dans Eclipse, faites “New”, “Project” puis choisissez “Android Project” et laissez-vous guider !

]]> https://blog.freelan.org/2010/11/20/installer-lenvironnement-de-developpement-pour-android/feed/ 8