TD 1 INF422 — Prise en main d'Android

Introduction      FAQ   Glossary   Project   TD 1   TD 2   TD 3   TD 4   TD 5   TD 6   TD 7   TD 8

Retour au cours.

0. Installation

Pour pouvoir faire fonctionner Android, tout ordinateur x86 avec 2GB de mémoire convient. Les distributions Linux 64 bits doivent être capables d'exécuter des applications 32 bits (via l'installation de paquets dédiés). Sur MacOS et Linux, la commande uname -a permet de savoir si l'on est en 64 ou 32 bits. Sous Windows, cette information est disponible en effectuant une recherche sur le mot clé system dans le menu Démarrer -> Recherche, puis cliquer sur system dans la liste retournée par la recherche. Si ça ne marche pas, essayez de déchiffer le brouhaha fourni par Microsoft. Les logiciels suivants doivent être installés (dans cet ordre):

Attention :

Pour la suite, et les manipulations en ligne de commande, il sera utile de mettre à jour la variable d'environnement PATH (ajouter les sous-répertoires tools et platform-tools du SDK, le séparateur est ":" sous Unix, et ";" dans la base de registres sous Windows) et d'indiquer le chemin du SDK Android comme SDK Location (Window->Preferences->Android).

Pour terminer l'installation du SDK Android, il faut ouvrir une ligne de commande (terminal sous UNIX, ligne de commande MSDOS sous Windows) et exécuter:

  android

Ensuite, naviguer sur l'onglet Settings et saisir le proxy HTTP de l'École. Puis naviguer sur l'onglet Available packages et sélectionner SDK Platform Android 4.1.2, API 16 puis sur Install Selected pour installer cette version du SDK.

1. Premier essai

Avant de pouvoir lancer une application, il est nécessaire de créer un AVD, pour Android Virtual Device (périphérique virtuel Android), qui permet de paramétrer les caractéristiques du matériel que l'on souhaite simuler. On se contentera des caractéristiques par défaut, et on appellera naturellement cet AVD inf422. Il sera utilisé tout au long du TD.

Si vous l'avez arrêté, relancer le programme de configuration:

  android

Naviguer sur l'onglet Virtual devices, cliquer sur New, choisir comme nom inf422 et comme cible Android 4.1.2 - API Level 16 ; laisser le reste inchangé et cliquer sur Create AVD.

Il est également possible de créer un AVD en ligne de commande. Commencer par éxécuter:

  android list targets

Repérez le numéro identifiant correspondant à la cible "android-16", et substituez le à <target_id> dans la commande suivante:

  android create avd -t <target_id> -n inf422 --abi armeabi-v7a

puis répondre no à la question proposant de définir un profil personalisé (réponse par défaut).

Il est également possible de créer un AVD sous Eclipse via le AVD Manager disponible dans le menu Window. De la même manière, on laissera vide les champs de personalisation pour créer un AVD inf422 avec les caractéristiques par défaut.

Pour vérifier qu'Android est correctement configuré, nous allons lancer un programme sur le téléphone. Le SDK contient de nombreux programmes de "demo" dans le répertoire samples/android-16. Pour lancer l'un de ces programmes, par exemple LunarLander, choisissez dans Eclipse l'item de menu pour créer un nouveau projet Android, puis Create project from existing source. Le code se trouve dans le répertoire samples/android-16/LunarLander du SDK.

Si l'émulateur Android est trop lent sur votre ordinateur, deux autres options pourront être envisagées : revenir à la version 2.2 (android-8), ou tenter l'aventure de la version x86 d'Android (en activant le support matériel pour la virtualisation sur votre ordinateur).

2. Installation des modifications

Pour pouvoir disposer des outils nécesssaires à la réalisation des TDs, nous fournissons une version modifiée du SDK Android. En pratique, cela correspond à deux fichiers :

Pour mettre à jour le SDK Android, il faut télécharger ces deux fichiers, et les déplacer dans un répertoire personnel que l'on appellera <IMAGES>/ ci-dessous.

Si l'émulateur est vraiment trop lent sur votre machine (plus de 3mn pour se lancer), on vous propose de travailler avec Android 2.2 (android-8). Installez cette version du SDK avec l'outil android, et utilisez les deux fichiers suivants pour le noyau modifié et l'image système modifiée kernel-qemu-8, ramdisk.img-8.

Sur la ligne de commande, l'émulateur peut alors être lancé directement par la commande

  emulator @inf422 -ramdisk <IMAGES>/ramdisk.img -kernel <IMAGES>/kernel-qemu
<IMAGES>/ doit être remplacé par le chemin complet du répertoire choisi précédemment. De nombreuses options sont disponibles, documentées ici.

Pour lancer cette commande depuis Eclipse, renseigner le menu Run->Run Configurations, sélectionnez le projet concerné (Lunar Lander par exemple), puis l'onglet Target->Additionnal Emulator Command Line Options et ajouter la séquence d'options
@inf422 -ramdisk <IMAGES>/ramdisk.img -kernel <IMAGES>/kernel-qemu. Puis cliquez successivement sur Apply et Close.
En cas de problèmes, une solution moins propre mais radicale consiste simplement à remplacer les fichiers kernel-qemu et ramdisk.img dans le répertoire system-images/android-16/armeabi-v7a de votre SDK Android.

Une autre option potentiellement utile : -http-proxy avec l'argument http://kuzh.polytechnique.fr:8080.

3. Mise en place d'une connexion shell

Pour pouvoir lancer des commandes sur Android, nous allons utiliser le protocole telnet. Ce protocole permet de se connecter par le réseau à une machine, puis d'interagir avec elle en ligne de commande. Bien qu'ayant été remplacé sur la majorité des serveurs par le protocole ssh, qui offre l'avantage de chiffrer les communications sur le réseau, telnet est encore utilisé dans le monde de l'embarqué, à cause de sa légereté (en terme de taille des programmes client et serveur, et de sa faible consommation de mémoire et de cycles processeur).

La version de l'émulateur Android fournie pour les TDs contient un serveur telnet (telnetd), qui se lance au démarrage de la machine et attend des commandes sur le port 23. Pour pouvoir utiliser telnet, il faut donc pouvoir accéder au port 23 d'Android. La documentation sur le fonctionnement du réseau dans l'émulateur Android se trouve ici. En l'occurrence, ce qui nous intéresse est la redirection de ports. La commande adb forward tcp:4444 tcp:23 permet de rediriger toute connexion effectuée sur le port 4444 de la machine hôte vers le port 23 d'Android. La dernière étape consiste alors à lancer un client telnet vers le port 4444 de la machine hôte. Il faut donc taper les commandes suivantes :

  adb forward tcp:4444 tcp:23
  telnet localhost 4444
Le login est root.

Les utilisateurs de Windows Vista, 7 et 8 pourront se référer à ce site pour installer le client telnet. Il est également conseillé d'installer putty, un client telnet et ssh pour Windows.

4. Prise en main d'ANDROID

Si tout s'est bien passé, on peut à présent lancer des applications Java sur Android et s'y connecter en ligne de commande. La liste des applications Java installées sur Android s'obtient en consultant le menu du téléphone. Il est également possible d'en compiler d'autres, notamment celles présentes dans le répertoire samples, en suivant l'exemple de LunarLander.

La liste des commandes UNIX disponibles à partir du shell est disponible ici. La documentation de l'emulateur est disponible ici ; voir en particulier Using the Emulator Console et noter le numéro de port dans le titre de la fenêtre de l'émulateur (par défaut 5554 si vous lancez un seul émulateur, entre parenthèses après inf422).

Voici quelque exercices pour vous guider dans une première exploration d'Android :

  1. Android est avant tout un téléphone. Bien qu'il ne dispose ni de carte SIM, ni du matériel GSM, l'émulateur permet de passer des "coups de fil virtuels". En vous aidant de la documentation fournie précédemment, essayez de simuler un appel entrant. Essayez également d'envoyer un SMS.
  2. Dans l'autre sens, appelez un numéro depuis Android, puis terminez l'appel en simulant que la ligne est occupée.
  3. Connectez vous à Android en ligne de commande. Essayez quelques commandes, et tentez d'en savoir plus sur le système émulé. Quel est le type de processeur ? La version du noyau Linux ? Quelle est la quantité de RAM ? Et (plus difficile) combien y a-t-il de commandes disponibles dans le répertoire /bin ?
  4. Écrivez toutes ces informations dans un fichier placé dans votre répertoire $HOME.

Indication : vous pourrez utiliser les commandes ls, cd, cat, wc, uname sur la ligne de commande de l'émulateur. Pour éditer un fichier, le plus simple est de le faire sur votre ordinateur et de le transférer sur l'émulateur par la commande adb push.

Question: how do I find help on Linux commands?

5. Premiers pas avec un projet (optionnel)

Le but des TDs n'est pas de faire de vous des développeurs experts Android, mais de vous faire découvrir concrètement un système complet (matériel et logiciel). Pour avancer rapidement dans les exercices illustrant les concepts de système les plus intéressants, il est fortement encouragé de suivre le tutoriel Android. Il est fourni avec solutions, mais cela ne remplace pas l'expérience personnelle.

Auparavant, il vous sera peut-être utile de lire le premier chapitre du cours INF431, portant sur la programmation en Java, ou bien, de suivre le tutoriel Java Trail de Sun (simple et pédagogique).

Cet exercice optionnel permet de se poser les bonnes questions avant de se lancer dans la lecture de ces tutoriels et documentations. Il permet aussi de se familiariser avec la notion de projet Android. Il sert d'introduction au prochain TD.

Le squelette d'une première application fonctionnelle est à télécharger ici. Exécuter une première fois le code de cette application dans l'émulateur (procédure similaire au lancement de LunarLander).

Processus à suivre :

  1. Décompresser td1.zip.
  2. Créer un nouveau projet Android dans Eclipse, depuis les sources existantes (le répertoire TD1 est créé à la décompression).
  3. Mettre à jour la configuration (Run -> Run configurations...)
    1. Définir le projet (Browse... puis sélection du projet).
    2. l'action de démarrage (Launch action) qui doit pointer vers le module d'activité com.android.td1.TD1.
  4. Appliquer la configuration (Apply) et lancer l'application (Run).

Détails de l'application :

  1. Description de la partie graphique (GUI)

  2. Description de la classe principale
    La classe Java principale de notre application se nomme TD1 et son code source se situe dans le fichier td1/src/com/android/td1/TD1.java.
    Cette classe dirige l'affichage de la fenêtre principale de notre application (classe héritant de Activity). Lors du lancement de l'application, la méthode onCreate est invoquée. Notre classe la surchage afin de faire apparaître le champ de texte présent dans le fichier main.xml.
    Une autre méthode est également surchargée: onStart. Elle est appelée juste après onCreate. C'est dans cette fonction que la zone de texte est mise à jour avec la quantitée mémoire disponible:

  3. La fonction get_meminfo() qui renvoie une chaine de caractères (String) contenant la valeur de la mémoire disponible. Pour ce faire on analyse syntaxiquement le fichier /proc/meminfo (on appelle cette analyse syntaxique le parsing, qui donne le verbe franglais "parser").

Quelques questions :

  1. La quantité de mémoire libre est-elle mise à jour automatiquement ?
  2. Lancez ou relancez une autre application (par exemple LunarLander) puis revenez à TD1 en utilisant les boutons situés sur le téléphone. Que se passe-t-il ?
  3. Dans quel(s) cas l'affichage de la quantité mémoire est-il mis à jour ?

Pour en savoir plus :