L3-Info Développement sous Android année 2014/2015

TP1 Installation et prise en main

Android est le système d'exploitation pour smartphones, tablettes et autres appareils développé par
Google. Pour permettre aux utilisateurs d'installer des applications facilement, il dispose d'un
« store » d'applications, le Google Play Store. Pour permettre aux programmeurs de développer leur
application (puis de la proposer sur le store), un SDK téléchargeable sur Internet est mis à disposition
de tous.
Dans ce TP, nous allons installer et configurer les différents éléments nécessaires à la compilation,
au test et au déploiement d'une application Android.

I. Installation et configuration du SDK

Android étant un SDK basé sur le langage Java, la première chose à faire est de vérifier que Java est
bien installé. Vous devez installer un JRE (Java Runtime Environment) ainsi que le JDK (Java
Development Kit) associé. Vous pouvez installer le Java développé par Sun/Oracle ou l'OpenJDK sous
Linux notamment. Vérifiez ensuite que vous avez bien les bonnes versions :
:~$ java -version
java version "1.7.0_03"
OpenJDK Runtime Environment (IcedTea7 2.1.2) (7u3-2.1.2-2)
OpenJDK 64-Bit Server VM (build 22.0-b10, mixed mode)
:~$ javac -version
javac 1.7.0_03

Il faut aussi s'assurer que la variable d'environnement JAVA_HOME pointe bien vers votre installation
du JDK. Il est conseillé de le rajouter dans son fichier .bashrc. Le chemin dépend bien sûr de
votre machine, ce qui est donné juste après est juste un exemple :
export JAVA_HOME="/usr/lib/jvm/java-7-openjdk-amd64/jre/"

L'étape suivante est de télécharger le SDK Android pour votre plateforme de développement (Linux,
Window, Mac). Pour cela, allez sur le site http://developer.android.com/sdk/index.html et
téléchargez les fichiers correspondants. Pour la suite de ce TP, nous considérerons uniquement le cas
de l'installation sous Linux. Pour Linux, une archive contenant tout les outils nécessaires à
l'installation du SDK est téléchargeable. Une fois téléchargée, décompressez la dans le répertoire de
votre choix. Dans le répertoire nouvellement créé, vous devez avoir un autre sous-répertoire intitulé
tools dans lequel se trouvent des programmes comme : android, monitor, … Il est conseillé de
rajouter ce répertoire ainsi que celui se nommant platform-tools dans son PATH. Par exemple en
l'ajoutant dans son fichier .bashrc.
export PATH="$PATH:/home/vincent/android-sdk-
linux/tools:/home/vincent/android-sdk/android-sdk-linux/platform-tools"

Chaque version d'Android (Gingerbread, HoneyComb, IceCreamSandwich, JellyBean, KitKat …) est

reliée à une version ou plusieurs versions du SDK (chacune étant également associée à un niveau
d'API). Il n'est pas nécessaire de toutes les installer, mais il faudra sûrement en installer plusieurs.
Pour installer les SDK, il suffit d'exécuter le programme android depuis la ligne de commande. Cette
application permet de gérer les différents composants du SDK et notamment de choisir les versions
à installer. Il est conseillé d'installer au moins les versions suivantes :
• Android 2.3.3 (API 10) – Gingerbread
• Android 4.1.2 (API 16) – Jelly Bean
• Android 4.3 (API 18) – Jelly Bean
Vous pouvez en installer d'autres, libre à vous ! Il est aussi conseillé d'installer les API Google afin de
bénéficier du support de Google Maps dans vos applications. En tapant la commande android, vous
devez obtenir une application ressemblant à la copie d'écran suivante :

1/7
L3-Info Développement sous Android année 2014/2015

II. Installation et configuration des outils de développement

Pour compiler, tester et déployer une application Android, d'autres outils sont nécessaires.
Configuration d'un émulateur
Pour tester l'application, il est toujours utile d'avoir un smartphone, ou une tablette sous Android,
mais le plus simple et le plus rapide pour tester plusieurs configurations matérielles différentes sous
différentes versions d'Android est de configurer un ou plusieurs émulateurs.
Pour accéder à la configuration des émulateurs, exécutez : android avd depuis la ligne de
commande. Vous obtenez la fenêtre suivante :

2/7
L3-Info Développement sous Android année 2014/2015

Sur l'exemple ci-contre, un émulateur simulant

Android 4.3 (Jelly Bean) est configuré. Le
processeur choisi est un ARM et la taille de la
mémoire SD de 200 mo.
La résolution choisie est assez élevée pour être
représentative des appareils hauts de gamme du
marché actuel.

Démarrez ensuite l'émulateur et normalement

vous devriez avoir un Android lancé et utilisable.
En lançant le navigateur Internet, vous devriez
être capable de surfer sur Internet si votre
ordinateur est connecté.
Vous trouverez ci-dessous un exemple de ce que
vous devriez obtenir :

3/7
L3-Info Développement sous Android année 2014/2015

Rôle de monitor
monitor est une autre application fournie dans le SDK. C'est le couteau Suisse utile dans beaucoup
de situations. Il permet par exemple de prendre des copies d'écran du contenu d'un émulateur, de
forcer les coordonnées GPS de l'émulateur, d'analyser les logs de l'émulateur, etc.
Capturer les logs de l'émulateur est une des utilisation de monitor indispensable au quotidien. Pour
écrire dans les logs depuis une activité, il faut tout d'abord dans votre fichier source .java, importer
le paquet de log : import android.util.Log ; Ce paquet fournit la classe Log qui contient plusieurs
méthodes d'affichage dans les logs. Par exemple, la méthode Log.v("un tag","Le texte du
log") ; permet d'écrire la chaîne "Le texte du log" dans les logs d'Android avec le niveau
verbose. En ajoutant un filtre sur le nom complet de l'application il est possible de n'afficher que les
logs de cette application. En affinant le filtre en tenant compte du tag ajouté au moment de l'appel à
Log.v, il est possible de n'afficher que les logs utilisant ce tag. La classe Log possède d'autres
méthodes d'écritures qui permettent notamment de changer le niveau du log (verbose, debug, error,
...)
Installation de ant
Maintenant que le SDK est installé et configuré, il faut pouvoir créer et compiler une application
Android. Nous verrons deux façons de procéder : manuellement ou avec Eclipse (un peu plus tard).
En cours nous avons vu comment créer une première application en ligne de commande avec le
programme android fourni dans le SDK :
android create project --target "android-18" \
--path ProjetTest \
--activity Debut \
--package com.univangers.l3info.projettest

Le projet est bien créé et en entrant dans le répertoire ProjetTest, on observe toute la hiérarchie de
répertoires vus en cours.
Attention ! Le nom du package doit être unique !

Il faut encore compiler le projet. Même si le JDK est bien installé, il manque encore un outil pour
réaliser la compilation : ant. ant est un outil servant à automatiser le processus de compilation de
fichiers Java (à l'image de make pour d'autres langages), la commande android crée des projets
android intégrant tous les fichiers nécessaires pour être compilés avec ant. Vous devez donc
installer le paquet fournissant ant sur votre système. Une fois installé, vous pouvez compiler votre
application par la commande suivante :
ant clean debug install

Cette commande permet de compiler le programme en mode debug et de le déployer

automatiquement sur l'émulateur lancé (il faut bien évidemment que l'émulateur soit lancé!). Si tout
s'est bien déroulé, vous devez avoir une application du nom de l'activité principale (ici Debut) dans
les applications de votre émulateur.
Installation et configuration d'Eclipse
La méthode précédente est indépendante de tout éditeur et environnement de développement.
Toutefois, un environnement de développement intégré apporte un grand nombre d'avantages
(complétion automatique, assistants, automatisation du processus de déploiement, …). Eclipse est
l'IDE supporté par Google. Ainsi en installant et paramétrant le plugin ADT, Eclipse peut créer des
projets Android, les compiler, les déployer. Il peut également contrôler certains outils du SDK comme
android, monitor, …

4/7
L3-Info Développement sous Android année 2014/2015

Pour installer le plugin ADT, choisissez

le menu Help > Install New Software. Il
faut ensuite ajouter le site
https://dl-
ssl.google.com/android/eclipse
dans la liste des sites sur lesquels
rechercher les nouveaux plugins.
Sélectionner tout ce qui se trouve sous
Developer Tools.

Une fois installé, il faut redémarrer Éclipse puis indiquer dans les préférences (onglet Android) où a
été installé le SDK (cf. étape précédente).
Pour assurer le bon fonctionnement sous Éclipse, il faut installer le paquet Android
Support Library depuis le gestionnaire du SDK Android.

Pour créer son premier projet Android avec Eclipse, il suffit de créer un nouveau projet puis de
choisir Android / Android Application Project. Il suffit ensuite de se laisser guider. Depuis Eclipse, il est
possible de compiler et charger directement le code de l'application dans l'émulateur.

5/7
L3-Info Développement sous Android année 2014/2015

Utilisation d'adb
L'outil adb (Android Debug Bridge) fourni avec le SDK permet de communiquer avec un émulateur ou
un appareil connecté sur la machine de développement. Il permet notamment de se connecter sur
l'appareil (physique ou émulé), d'ouvrir un shell dessus, de réaliser des sauvegardes complètes de
l'appareil, d'installer un fichier .apk (extensions des fichiers contenant des applications installables
sur un appareil Android), etc … Android est basé sur un noyau Linux et adb permet d'accéder à la
console de l'appareil. Ce programme peut prendre plusieurs paramètres. Il est fortement conseillé de
lire la documentation fournie.
Voici la liste des principales commandes :
adb help Affiche l'aide des commande adb.

adb devices Liste les appareils physiques ou émulés détectés

adb kill-server Tue le serveur adb lancé (il faudra le redémarrer soit par un
appel à adb start-server soit à adb devices)

adb get-state Permet de connaître l'état de le périphérique connecté

(appareil physique ou émulateur) :
• offline : hors ligne
• device : normal et connecté

adb install fichier.apk Installe le fichier .apk sur le périphérique connecté.

adb pull fichier-appareil fichier- Permet de transférer un fichier situé sur le périphérique
ordinateur vers l'ordinateur

adb push fichier-ordinateur fichier- Permet de transférer un fichier de l'ordinateur vers le

appareil périphérique

adb shell Ouvre un shell en ligne de commande sur le périphérique

connecté.

Pour la majorité de ces commandes, il faut spécifier sur quel périphérique (appareil physique ou
émulateur) exécuter la commande. En effet, il peut y avoir plusieurs périphériques connectés et
actifs simultanément. L'argument « -s » suivi d'un nom (obtenu par l'appel adb devices) permet de
spécifier le périphérique cible. Toutefois, si un seul émulateur est actif l'argument « -e » permet de
diriger la commande vers celui-ci. De la même façon, si un seul appareil physique est connecté en
USB, l'argument « -d » cible cet appareil. La commande suivante ouvre un shell sur le seul
émulateur lancé et actif : adb -e shell.
Attention, pour communiquer avec un appareil physique, il faut activer le « Débogage
USB » sur le périphérique en question.

Exercices
Exercice n°1 :
Installer et configurer les différents éléments présentés dans l'énoncé. Lancer un émulateur ainsi que
monitor puis ajouter un filtre pour ne capter que les logs qui concernent le navigateur web.
Créer un projet manuellement en ligne de commande puis l'exécuter dans un émulateur. Prendre une
copie d'écran du projet. Modifier ce projet pour ajouter quelques logs par endroits et ajouter un filtre
à monitor pour ne capturer que ces logs.
Refaire exactement la même chose depuis Eclipse.
Exercice n°2 :
En utilisant adb, se connecter sur un émulateur actif. Ouvrir un shell dessus, lister les fichiers et
vérifier que l'on peut copier des fichiers vers et depuis l'émulateur.

6/7
L3-Info Développement sous Android année 2014/2015

Exercice n°3 :
Télécharger le programme d'exemple Android à l'URL suivante :
http://www.info.univ-angers.fr/pub/barichar/page_perso/enseignements/android/position_gps-debug.apk
Installer le fichier grâce à adb sur un émulateur. Forcer les coordonnées GPS de l'émulateur à la
position suivante :
Latitude = 47,481124 Longitude = -0,600365

Faire une copie d'écran de l'émulateur afin d'avoir une trace du lieu indiqué à ces coordonnées.
Exercice n°4 :
Refaire toutes les manipulations depuis l'exercice n°2 mais cette fois-ci en utilisant un appareil
physique plutôt qu'un émulateur.
Exercice n°5 :
Compiler et tester les exemples donnés en cours (sur les Widgets et Containers notamment).

7/7