Travaux Pratiques 3 : Systèmes embarqués : Outils Portables intégrés à un SIG

Enseignants : Dr. Mvogo Ngono Joseph

Dr. Bondé Lossan
Université de Douala

Objectif : A la fin de ce TP, les étudiants seront capables de développer une application simple
qui sera déployer sur un PDA ou un Smartphone doté du système d'exploitation linux embarqué
« Android 1», plus spécifiquement ce TP permettra à l'étudiant de découvrir certains concepts
inhérents au développement sous Android.
Il s'agit de développer un service qui consiste à présenter à l'utilisateur un écran comportant trois
boutons, chacun correspondant à un rayon (en km) de recherche. Lorsque l'utilisateur clique sur un
de ces boutons, l'application géolocalise l'appareil et affiche une google Map comportant les
emplacements des (hôtels, restaurants, ou autres cibles) dans le rayon souhaité.

La description du développement de l'application est divisée en deux parties:

Dans la première partie l'étudiant mettra en place son environnement de développement, par la suite
il réalisera l'interface Homme/Machine (IHM) de l'application telle que présentée à la figure 1. Ce
premier volet permettra d'introduire les concepts de layout, d'activité et d'intent et aussi le passage
d'un écran à l'autre au sein de l'application.

La seconde partie du TP portera sur l'interrogation d'un service web à l'aide de la méthode SAX et
sur le positionnement des objets recherchés sur une carte Google Map.

PARTIE I

I.1) Mise en place de l'environnement de développement

La mise en place de l'environnement nécessite l'installation des outils suivants:

 L'environnement de développement intégré Eclipse 3.5 (Galileo), téléchargeable 2
gratuitement sur Internet
 Le Kit de Développement d'applications Android (SDK) téléchargeable 3 gratuitement sur
Internet
 Le plugin Eclipse Android Developement Tools (ADT) version 0.9.3

Les étapes de mise en place de l'environnement de développement sous Windows XP.

1) Allez sur le site http://developer.android.com/sdk/installing.html pour des explications sur

l’installation de l’environnement de développement Android.
De façon détaillée :
2) Télécharger l’IDE Eclipse 3.5 (Galileo) sur le site : http://www.eclipse.org/downloads/
notamment la version Eclipse classic version 3.5.2. (eclipse-SDK-3.5.2-win32)
3) Assurez-vous le JDK 5 ou JDK 6 est installé, sinon l'installer .
4) Télécharger le SDK Android à l’URL http://developer.android.com/sdk/index.html
(android-sdk_r10-windows.zip )
5) Décompactez le fichier (android-sdk_r10-windows.zip ) et lancer le SDK Manager pour finaliser
l’installation de la plateforme Android.
6) Ajoutez le répertoire du SDK dans la variable PATH du système
7) Installation dans eclipse de l’environnement de développement Android
1
Android est système d'exploitation libre pour mobile dont la part du marché croît aujourd'hui très vite.
2
Http://www.siteeclipse.org
3
Http://developer.android.com/sdk/1.6_r1/installing.html
 a) Démarrez eclipse, sélectionnez le menu Help>>Install New Software
b) Dans la boîte de Dialogue Available Software, cliquez sur Add, on renseigne le champ Name
par exemple par « Android plugin » et le champ Location par  :
https://dl-ssl.google.com/android/eclipse/
On clique sur OK.
c) Cochez la case à cocher Developer Tools, qui comporte deux packages : Android DDMS et
Android Development Tools, cliquez ensuite sur Next.
d) Cliquez une seconde fois sur Next, acceptez les termes de la licence et cliquez sur Finish
e) Redémarrez eclipse
8) Configuration du Plugin Android :
a) Sélectionnez Windows >> Preferences,
b) Sélectionnez Android dans le panneau gauche,
c)Pour sélectionner l’emplacement du SDK, cliquez sur Browse et sélectionnez le répertoire
du SDK
d) Cliquez sur Apply et ensuite OK
Après la configuration on va ajouter les composants dans notre environnement de développement.
9) Sélectionner Windows >>Android SDK and AVD Manager

pour tester l'application avant son déploiement plutard dans un PDA ou un smartphone
l'environnement de développement intègre un émulateur qu'il est nécessaire de créer en suivants les
instructions suivantes.
1) Sélectionnez Windows>>Android SDK and AVD Manager
2) Sélectionnez Virtual Devices dans le panneau gauche de la boîte de Dialogue
3) Cliquez sur New, renseignez le champ Name: par exemple My_AVD et sélectionnez pour le
champ Target : Google APIs(Google Inc.)-API Level 4
4) Cliquez enfin sur le bouton Create AVD
Maintenant l'environnement est installé et nous allons aborder la première partie du TP qui consiste
à réaliser l'IHM de l'application.

I.2) Initialisation du projet

Nous allons d'abord créer un projet, pour ce faire nous exécutons l'environnement eclipse et on
clique sur File>>New>>Project...>>Android>>Android Project. Cliquez sur Next.
On appelle le projet « MonApp » (champ project name). Dans Build Target on sélectionne
« Google API » dans sa version 1.6. On remplit le champ Application name avec «  Mon
Application » et Min SDK version avec la valeur « 4 » qui indique le niveau minimum d'API
requis pour notre application et le champ Package name avec « com.android.monapp ». On laisse
cochée l'option Create activity et on remplit le champ adjacent avec « MyFirstActivity » et on
clique sur Finish. Le projet est créé.

Dans le Package Explorer, on peut voir que ce projet comporte- outre les fichiers .jar de l'API
Google, trois dossiers.
 Le dossier src/ contient les sources java notamment la première classe MyFirstActivity.java
de l'application.
 Le dossier res/ contient les ressources (icônes, layout,..) liées au projet.
 Le répertoire gen/ contient des fichiers sources Java mis à jour automatiquement par
l'environnement de développement Android.
 I.3)Réalisation de l'IHM
Dans un projet Android, un écran d'action correspond à une activité. Notre application comprend
deux écrans (l'affichage du Menu et l'affichage de la carte) et donc deux activités. Une activité est
une classe héritant de la classe Activity. La classe MyFirstActivity est la première activité de notre
programme.
La classe MyFirstActivity comporte une méthode publique onCreate() qui est appelée
implicitement lors de la création de l'activité, elle s'exécute automatiquement lorsque l'écran
correspondant à l'activité apparaît à l'utilisateur.
La méthode onCreate() appelle d'abord la méthode onCreate() de la classe mère Activity pour
initialiser certains attributs internes de la classe fille MyFirstActivity
(super.onCreate(savedInstanceState)). On remarque par ailleurs que cette méthode
comporte un argument de type Bundle qui correspond à un tableau associatif évolué permettant de
transmettre des paramètres entre activités.
La méthode suivante setContentView(R.layout.main) indique au système qu'il doit utiliser le
« layout » main pour cette activité. Le layout d'une activité est un fichier XML permettant de
spécifier l'organisation des composants graphiques de l'écran correspondant. Pour savoir quel
layout utiliser dans une activité on passe un identifiant (int) à setContentView. La valeur de cet
entier se trouve dans une classe R (voir fichier gen/R.java) générée automatiquement. L'ajout de cet
identifiant à la classe R a été réalisé lorsque le layout main a été créé à l'initialisation du projet. Il
est décrit sous la forme d'un fichier XML à l'emplacement res/layout/main.xml.
Le fichier main.xml décrit au stade actuel l'interface par défaut ci-après :
Cette interface doit être modifiée en vue d'obtenir l'interface ci-dessous:

Figure 1

Pour ce faire nous allons modifier le fichier res/layout/main.xml.

On dispose d'une interface qui permet d'une part de concevoir graphiquement le layout, d'autre part
d'avoir l'équivalent en XML de celui-ci. Dans ce TP on s'interessera au fichier XML.
On clique sur main.xml pour voir le code XML correspondant au layout actuel.
On doit pouvoir obtenir le code suivant:

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
>
<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"
/>
</LinearLayout>
4
On trouve dans ce code un layout de type LinearLayout à orientation verticale
(android:orientation="vertical").

Question 1: Trouvez les autres types de layout disponibles dans l'environnement Android et
donnez leurs caractéristiques principales.

Ce code contient un objet TextView:

<TextView
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:text="@string/hello"
/>

Le TextView affiche le texte contenu dans sa propriété android:text, ce contenu correspond à

une chaine constante représentée par @string/hello.

Chaque application Android possède des chaînes de caractères constantes qui sont listées dans le
fichier res/values/strings.xml. En ouvrant ce fichier on découvre le contenu ci-après:

<?xml version="1.0" encoding="utf-8"?>

<resources>
<string name="hello">Hello World, MyFirstActivity!</string>
<string name="app_name">Mon Application</string>
</resources>
Deux constantes sont définies, la première hello et la seconde app_name. Pour supprimer une
constante on peut revenir à l'onglet « resources » et selectionner la constante à supprimer, puis on
clique sur le bouton « remove ». En utilisant cette méthode supprimer la constante hello.
Enregistrez le fichier res/values/strings.xml. On remarque qu'Eclipse y trouve une erreur, c'est
normal, la constante qu'il utilisait vient d'être supprimée.

4
Comme en CSS, les objets sont placés en position absolute ou relative , on trouve un AbsoluteLayout, un
RelativeLayout ,Etc .., Le LinearLayout à orientation verticale indique que tous les objets qu'il contient sont placés à
la suite les uns en dessous des autres.
Pour simplifier, on commence par vider main.xml de tout son contenu et on le remplace par le code
ci-après:
<?xml version="1.0" encoding="utf-8"?>

<RelativeLayout android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
xmlns:android="http://schemas.android.com/apk/res/android">
<TextView android:id="@+id/titre"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_centerHorizontal="true"
android:layout_marginTop="10sp"
android:text="@string/app_name"
android:textColor="#0f0"
android:textSize="28sp">
</TextView>

</RelativeLayout>

Les attributs :
android:layout_width="fill_parent"
android:layout_height="fill_parent"
Notamment fill_parent indique que le layout doit remplir le composant parent en l'occurence, il
s'agit du layout Android de base. Dans le RelativeLayout, on commence par afficher le titre. Pour
cela on utilise un composant TextView, on lui donne un id titre (android:id="@+id/titre"). On
précise que la largeur et la hauteur du TextView doivent s'adapter à son contenu.
android:layout_width="wrap_content"
android:layout_height="wrap_content"

Question 2: Expliquez les autres attributs ci-après du TextView:

android:layout_centerHorizontal="true"
android:layout_marginTop="10sp"
 android:text="@string/app_name"
android:textColor="#0f0"
android:textSize="28sp">

On obtient l'écran ci-dessous:

On poursuit avec le texte situé entre le titre « Mon Application » et les boutons . Pour cela on insère
le composant TextView ci-après:

<TextView android:id="@+id/texteRayon"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Localisation à moins de :"
android:layout_below="@+id/titre"
android:layout_marginBottom="12sp"
android:textStyle="bold"
android:layout_marginTop="20sp"
>
</TextView>

Question 3: Quel est le rôle de l'attribut android:layout_below="@+id/titre" ?

On observe ci-dessous le layout obtenu.

Passons maintenant aux boutons de rayon. Ajoutez les lignes ci-après à la suite de votre fichier
main.xml actuel, d'abord pour créer le premier bouton.

<Button android:id="@+id/btn10km"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:textStyle="bold"
android:text="10 km"
android:textColor="#7f0"
android:layout_below="@+id/texteRayon"
android:width="30pt"
>
</Button>
Ensuite on place un texte explicatif à côté du bouton.
<TextView android:id="@+id/texte10km"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:layout_alignBaseline="@+id/btn10km"
android:text="Vous pouvez presque y aller à pied"
android:layout_toRightOf="@+id/btn10km"
android:textSize="13sp"
>
</TextView>

L'attribut android:layout_alignBaseline="@+id/btn10km" indique que le texte est aligné sur

la même ligne que le bouton et android:layout_toRightOf="@+id/btn10km" spécifie que le
texte est à droite du bouton btn10km.

On obtient l'écran suivant:

Question 4: Complétez le fichier main.xml de manière à obtenir l'écran de la
figure 1.

I.4)Mise en oeuvre de l'activité de l'écran de la figure 1

Nous allons maintenant mettre en oeuvre l'activité associé à l'écran que nous venons de réaliser, cela
se fait dans la classe de l'activité notamment la classe MyFirstActivity.java. On commence tout
d'abord par créer les attributs de la classe qui seront nécessaires.
On ajoute les trois boutons de l'écran et un LocationManager pour les fonctionnalités de
géolocalisation.
private LocationManager lm; /** Location Manager */
private Button btn10km;
private Button btn30km;
private Button btn50km;
private class MyLocationListener
implements LocationListener {
}
on ajoute une classe privée MyLocationListener servant à recevoir les notifications de la part du
Locationmanager lors des changements de position. Une fois les import correspondants ajoutés, il
reste une erreur . Cliquez dessous et selectionnez add unimplemented methods. Pour faciliter la
compréhension du TP, au stade actuel nous ne nous servirons de ces méthodes et nous allons les
laisser vides.

Nous allons maintenant créer un Listener sur les boutons de manière à réagir aux clics sur les
boutons de l'interface. Pour cela on crée une classe OnClickListener (ajoutez cette classe dans
classe principale ; et non dans la classe privée MyLocationListener).

private OnClickListener btnListener = new OnClickListener(){

}
Pour cette classe l'environnement Android signale une erreur qui résolu en cliquant sur l'erreur et en
sélectionnant add unimplemented methods. Une méthode onClick() est ajoutée automatiquement
qui s'éxécutera lors des clics utilisateurs sur les boutons. Laissons-la vide pour l'instant, nous y
reviendrons par la suite.
Il nous faut maintenant une méthode (à la classe principale *Activity) qui, à partir du bouton sur
lequel on a cliqué, retourne la rayon (nombre de kilomètres) correspondant. Cette méthode prend la
forme:

private int getRayon(View btn){

if(btn10km.equals(btn)){
return 10;
}else if (btn30km.equals(btn)){
return 30;
}else if (btn50km.equals(btn)){
return 50;
}else {
Log.d("Debug MyFirstApp","Bouton inattendu");
return 10;
}
}

Les préliminaires sont terminés: on passe à l'mplémentation de la méthode onCreate(), sous l'appel à
setContentView().
On initialise les attributs de classe:
btn10km = (Button) findViewById(R.id.btn10km);
btn10km.setOnClickListener(btnListener);
btn30km = (Button) findViewById(R.id.btn30km);
btn30km.setOnClickListener(btnListener);
btn50km = (Button) findViewById(R.id.btn50km);
btn50km.setOnClickListener(btnListener);

La méthode findViewById() retourne la vue (View) correspondant à l'identifiant passé en

paramètre. On fait une opération de Cast sur cette vue pour initialiser les attributs « boutons » de la
classe . Puis on associe à chacun d'entre eux le OnclickListener créé plus haut. Les boutons
terminés, on peut passer au LocationManager:
this.lm = (LocationManager)
getSystemService(Context.LOCATION_SERVICE);
this.lm.requestLocationUpdates("gps", 0, 0, new MyLocationListener());

Android considère les périphériques matériels(GPS,accéléromètres, réseau, …) comme des

services. On recupère ici un LocationManager qui est objet permettant d'utiliser le service de
géolocalisation (LOCATION_SERVICE). On demande ensuite à être notifié
(requestLocationUpdates()) de tout changement dans la position géométrique du terminal Android.

Le squelette de notre application est maintenant en place, il faut maintenant implémenter le contenu
de la méthode onClick() . On remplace la ligne par :

Location loc;
loc = MyFirstActivity.this.lm.getLastKnownLocation("gps");
if (loc==null){
loc =
MyFirstActivity.this.lm.getLastKnownLocation("network");

Cet extrait de code a pour objectif de réupérer la dernière position connue du terminal Android. On
utilise pour cela la méthode getLastKnownLocation() du LocationManager défini précédemment.
Cette position est en général obtenue par le service de GPS, mais en cas de défaillance de ce
dernier, elle peut l'être depuis le service réseau.
A la suite du code précédent, on ajoute les lignes qui suivent:

if (loc != null){
 Intent intent;
intent = new Intent(MyFirstActivity.this,MyMap.class);
Bundle bundle = new Bundle();
bundle.putDouble("Latitude", loc.getLatitude());
bundle.putDouble("Longitude", loc.getLongitude());
bundle.putInt("Rayon", getRayon(v));
intent.putExtras(bundle);
startActivity(intent);
}else{
Toast.makeText(MyFirstActivity.this,
"Impossible de récupérer la position",
Toast.LENGTH_SHORT).show();
}
Ici, on teste une nouvelle fois si on a finalement pu récupérer la position. Si ce n'est pas le cas, on
affiche un court message à l'utilisateur, lui indiquant qu'il n'a pas été possible de le faire. En
revanche, si la géolocalisation a fonctionné, on poursuit l'éxécution et on passe à l'activité suivante.

Concrètement comment se déroule cette dernière phase? On crée un intent 5 qui correspond à une
action à éxécuter, ce qui correspond ici au lancement d'une nouvelle activité. Comme cette dernière
n'est pas encore créée, on décide de l'appeler « MyMap » (MyMap.class). A cet intent, on fournit
des paramètres qui seront transmis à MyMap. Ces paramètres sont stockées dans un objet Bundle et
par la méthode putExtras() à l'intent, par la suite on lance la nouvelle activité en appelant
startActivity().

La première activité de notre projet est terminée. Notre projet comporte maintenant une erreur. Elle
se trouve sur la reférence à la classe MyMap.class qui correspond à la seconde activité de notre
application qui n'est pas encore implémentée. Nous allons passer à la création de la seconde activité.

I.5) Mise en œuvre de la deuxième activité, affichage de la carte

Comme la première activité, la seconde nécessite un layout et un fichier java. Pour ce qui est de
layout il suffit de faire un clic droit sur le dossier res/layout>>New>>File. On rentre alors map.xml
dans File name et on clique sur Finish.

5
Consulter la documentation en ligne http://developer.android.com/reference/android/content/Intent.html
On copie le code suivant dans le fichier nouvellement créé (res/layout/map.xml):
<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout android:orientation="vertical"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
xmlns:android="http://schemas.android.com/apk/res/android">

<com.google.android.maps.MapView
android:id="@+id/gmapview"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:enabled="true"
android:clickable="true"
android:apiKey="PUT_HERE_THE_KEY"/>

</RelativeLayout>
Ce second layout est uniquement composé d'un MapView permettant la visualisation de la Google
Map. Le seul élément nouveau ici concerne l'attribut android:apikey. La classe MapView donne
accès à des données fournies par Google Maps. Pour nous en servir, il faut accepter les Terms of
service de Google, sans quoi le MapView ne présentera qu'un écran vide. L'API key sert à vous
identifier en tant développeur ayant bien accepter les conditions d'utilisation du service. Pour
récupérer votre API key, la procédure est décrite sur la page:
http://code.google.com/intl/en/android/add-ons/google-apis/mapkey.html
Une fois obtenue, on l'utilise pour remplacer PUT_HERE_THE_KEY.

Passons maintenant au fichier java correspondant. Au même emplacement que MyFirstActivity.java

on créé une nouvelle classe MyMap.java et on remplace le peu de code qu'il comporte par celui-ci:

package com.android.monapp;
public class MyMap extends MapActivity {
 /** Called when the activity is first created. */
public void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);

}
@Override
protected boolean isRouteDisplayed() {
// TODO Auto-generated method stub
return false;
}

}
Ajoutez les import et sauvegardez votre fichier. Comme la première activité, celle-ci comporte une
méthode onCreate(). En revanche cette classe n'hérite pas d'Activity mais de MapActivity. Cela
oblige à redéfinir la méthode isRouteDisplayed() (voir les spécifications de la classe MapActivity) à
l'adresse :
http://code.google.com/intl/en/android/add-
ons/googleapis/reference/google/android/maps/MapActivity.html

L'enregistrement de ce fichier corrige maintenant l'erreur qu'eclipse signalait au niveau du

MyMap.class dans l'activité précédente. A cette nouvelle classe, on ajoute des attributs.

private MapView mapview; /** vue de la carte */

private MapController mc; /** Contrôleur de la carte */
private int zoomInitial; /** valeurinitiale du zoom */
private GeoPoint centreInitial; /** Centre de la carte */

On passe à la méthode onCreate() à laquelle on ajoute les lignes de code:

setContentView(R.layout.map); (1)
mapview = (MapView) findViewById(R.id.gmapview);(2)
mc = mapview.getController();(3)

on précise dans ce code qu'on veut utiliser le layout map pour cette activité (1). On associe la vue
gmapview à l'objet mapview de type MapView (2). On recupère également le contrôleur de l'objet
mapview (3).

on ajoute à la suite le code:

Bundle bundle = this.getIntent().getExtras();
double latitude = bundle.getDouble("Latitude");
double longitude = bundle.getDouble("Longitude");
int rayon = bundle.getInt("Rayon");
qui permet de transmettre les paramètres de la première activité préalablement encapsulés dans un
objet bundle dans notre nouvelle activité.
On continue avec :
zoomInitial = 14;
centreInitial = new GeoPoint((int)(latitude*1E6),
(int)(longitude*1E6));
Le zoom initial correspond à la valeur de zoom que l'on veut avoir pour la visualisation de la carte
au chargement de l'activité.
Le centre initial est le point géographique que l'on veut avoir au centre de l'écran lors de l'affichage
de la carte. Ce dernier point est calculé en fonction des coordonnées GPS obtenues lors de la
géolocalisation.
Enfin on complète le méthode onCreate() par les lignes de code :
mc.animateTo(centreInitial);
mc.setZoom(zoomInitial);
mapview.setSatellite(true);
mapview.setBuiltInZoomControls(true);
Toast.makeText(this,
"Lat: " +latitude+ "Lng: "+longitude+" Ray:" + rayon,
 Toast.LENGTH_LONG).show();

On utilise le contrôleur (mc) de l'objet mapview pour se déplacer (animateTo(centreInitial)) au

centre choisi et appliquer la valeur de zoom (setZoom(zoomInitial) définie plus haut. On indique
ensuite qu'on veut un affichage de type satellite ( setSatellite(true)). La valeur de zoom est
alors adaptée si Google possède des images satellites à la précision voulue. La méthode
setBuiltInZoomControls(true) permet quant à elle de spécifier si on désire ou non avoir le
contrôleur de zoom sur la carte. Enfin on fait apparaître un message indiquant les coordonnées du
terminal et le rayon choisi au chargement de la carte.

I.6) Exécution de la première partie de l'application

1.6.1) Création du fichier AndroidManifest.xml
Avant d'exécuter cette première partie de l'application, il nous faut encore régler quelques
paramètres. On ouvre pour cela le fichier AndroidManifest.xml qui se trouve à la racine du projet, il
s'agit d'un fichier xml modifiable avec une interface graphique.
On va à l'onglet Application>>Application Nodes>>add..>>Uses Library>>OK

Dans le champ name, on insère « com.google.android.maps »

On clique à nouveau sur Add...>>Activity>>OK. Dans le champ Name, On insère « MyMap ».
Ces actions ajoutent la bibliothèque des cartes Google au projet et identifient la classe MyMap
comme une activité du projet ( la classe MyFirstActivity l'étant déjà depuis la création).

On va ensuite sur l'onglet Permissions>>Add...>>Uses Permission>>OK.

Dans le champ Name,on insère « android.permission.ACCESS_FINE_LOCATION »
On clique à nouveau sur Permissions>>Add...>>Uses Permission>>OK et on insère dans le
champ Name « android.permission.INTERNET ». On vient à travers ces deux opérations
d'autoriser
les accès à Internet et au GPS à notre application, deux choses dont elle a besoin pour fonctionner
correctement. On enregistre le fichier.

1.6.2) Lancement du programme dans l'émulateur

On crée maintenant une configuration d'éxécution, pour ce faire, on clique :
Run>>Run Configurations ...>>Clic droit sur Android Application>>New. Dans le champ
Name on insère « launch_MyFirstApp », dans Project, On sélectionne MonApp et dans Launch
Action, on coche Do Nothing. Sur l'onglet Target. On peut voir la liste des (AVD) utilisables dans
notre application. On coche my_avd et enfin on clique sur Apply puis Close.
On peut maintenant émuler Android sur notre AVD en cliquant sur:
Run Configurations>>launch_MyFirstApp>>Run
Une fois l'émulateur démarré, on peut simuler le fonctionnement du GPS en fournissant des
coordonnées au terminal. Pour ce faire on ouvre une console et on y entre la commande:
telnet 127.0.0.1 5554
Après cette commande on est connecté au terminal android émulé. On peut alors envoyé des
coordonnées GPS à l'aide de la commande:
geo fix <<longitude>> <<latitude>>
<<latitude>> : latitude du point
<<longitude>> : longitude du point
La page http://developer.android.com/guide/topics/location/index.html donne plus d'information au
sujet de la simulation GPS avec l'émulateur.
On peut maintenant exécuter le programme qui nous présente le menu de la première activité, puis
lorsqu'on choisi un rayon, on affiche un écran à l'image de la figure 2 ci-après.
Cette première partie de l'application nous a permis d'accéder à certains concepts concernant le
développement des applications sous Android. Au stade actuel notre application affiche une carte
google map autour de la position de notre terminal Android. La deuxième partie améliorera
l'application actuelle en localisant certains objets sur la carte (Hôtels, Restaurants, …).

N.B: L'étudiant devra répondre aux questions posées dans le texte et envoyez ses réponses à
l'enseignant.

Par exemple la ville de Paris à la coordonnées suivantes :

Latitude 48°51'44' nord, longitude 2°21'03' est

En coordonnées GPS, cela donne 2.35 et 48.86 à fournir dans cet ordre à la commen geo fix de
telnet.

Bon travail !!!