Matiaz OUINE - Ensiwiki

Matiaz OUINE
Benoit RAYMOND
David DUMENIL
Florian GUFFON
Juin 2012
Ensimag 2A – Projet de spécialité
Projet de spécialité:
Développement d’une application Android utilisant la géolocalisation
Tutoriel :
Android: Google map et Géolocalisation
1
1
Pré-requis ........................................................................................................................................ 3
2
Insertion d’une carte Google Maps ................................................................................................. 3
2.1
3
Obtenir une clé API.................................................................................................................. 3
2.1.1
Obtention du MD5 .......................................................................................................... 3
2.1.2
Génération de la clé API .............................................................................................. 4
2.2
Travail collaboratif ................................................................................................................... 4
2.3
Implémentation ....................................................................................................................... 5
2.3.1
Mise en place................................................................................................................... 5
2.3.2
Code XML......................................................................................................................... 9
2.3.3
Code Java ....................................................................................................................... 10
Géolocalisation .............................................................................................................................. 12
3.1
Recuperer la position : Les Provider ...................................................................................... 12
3.2
Marquer la carte : les Overlay ............................................................................................... 14
2
1 Pré-requis
Avant de suivre ce tutoriel, vous devez avoir lu des tutoriels d’introduction à la programmation
Android ainsi que l’installation de votre environnement de travail sur Eclipse.
Il est nécessaire d’avoir installé le plugin ADT (Android development Tools) de Eclipse.
2 Insertion d’une carte Google Maps
Nous présentons ici la démarche à suivre afin d’insérer une carte Google Maps dans votre
application Android.
Nous allons nous appuyer sur l’API Google correspondante disponible ici :
https://developers.google.com/maps/documentation/android/reference/
2.1 Obtenir une clé API
L’utilisation d’une carte Google Maps impose la génération d’une clé propre à votre
application, nous détaillons ici les étapes afin de l’obtenir.
2.1.1 Obtention du MD5
La première étape consiste à obtenir votre MD5 checksum nécessaire à la génération de votre clé, il
est généré à partir du « debug certificate » associé à votre application.
Nous avons donc besoins du fichier debug.keystore, il y a plusieurs solutions pour localiser ce
fichier :
Windows 7: C:\Users\xxxx\.android\debug.keystore
Linux: ~/.android/debug.keystore
Si vous utilisez Eclipse, vous pouvez le localiser de la manière suivante :
« Windows -> Preferences -> Android -> Build »
3
Démarrer ensuite une console et exécuter la commande suivante :
keytool -list -alias androiddebugkey –keystore <chemin_vers_le_fichier_debug>.keystore -storepass
android -keypass android
(Si keytool n’est pas reconnu, son exécutable se trouve dans les binaires Java)
Vous obtenez en sortie votre MD5 checksum.
2.1.2 Génération de la clé API
Rendez vous maintenant ici :
https://developers.google.com/android/maps-api-signup?hl=fr-FR
Remplissez les champs demandés, ainsi que votre MD5.
Vous obtenez votre clé API, stocker la dans un fichier, elle nous servira ensuite.
2.2 Travail collaboratif
Comme dit précédemment, la clé API générée est propre à votre application, dans le cadre
d’un développement en équipe, la solution pour éviter que chacun ne génère sa propre clé API
correspondant à sa version de l’application est de partager le fichier debug.keystore. Chaque
développer doit utiliser la même version.
Si vous développez avec Eclipse, il est possible de partager le debug.keystore à l’aide de votre
gestionnaire de version et de préciser qu’il faut utiliser ce fichier.
Pour cela: «Window -> Preferences -> Android -> Build » puis donner le chemin du fichier à utiliser.
4
2.3 Implémentation
Commençons maintenant l’implémentation, elle se déroule en trois étapes :
 La mise en place du projet (Manifest et configuration de Eclipse)
 Le code XML
 Le code Java
2.3.1 Mise en place
2.3.1.1 Installation de l’API Google et création de L’AVD
Si vous avez installé le plugin ADT (Android Development Tools) de Eclipse vous devriez voir
ces deux icones :
Le premier permet d’installer différentes version de SDK et le second de créer des AVD (Android
Virtual Device), un AVD permet de simuler l’exécution de l’application sur une plateforme Android.
Cliquez sur celui de gauche, afin de lancer notre application, nous devons installer google APIs, dans
cet exemple, nous utiliserons la version 2.3.3 d’Android, installer donc au minimum le « SDK
Platform » ainsi que « Google APIs » pour cette version :
5
Nous allons maintenant créer l’AVD qui nous permettra de lancer notre application sur notre
ordinateur (Sur une platforme Android virtuelle), pour cela, cliqué maintenant sur le bouton de
droite :
Vous pouvez à présent créer une nouvelle AVD, comme ci-dessous :
6
2.3.1.2 Création du projet
Notre environnement de travail est configuré, créons maintenant nouveau projet Android,
nous l’appellerons ici androidGoogleMap :
7
Il vous est ensuite demandé de choisir un SDK pour le projet (celui si est par la suite modifiable), nous
choisissons ici l’API Google que nous venons de télécharger.
Nous créons une activité nommé AndroidGoogleMapActivity dans le package googleMap.tutoriel :
8
Notre projet est créé, passons maintenant à l’implémentation de l’application.
Pour plus de détail sur la structure d’une application android, veuillez lire une introduction à la
programmation android.
2.3.1.3 Mise en place du manifest
Dans le fichier AndroidManifest.xml, ajoutez les lignes suivantes:
-
Cette première entre les balises <application> </application> qui permet de préciser que
nous allons utiliser la librairie permettant l’usage de carte Google Maps.
<uses-library android:name="com.google.android.maps" />
- Cette seconde, entre les balises <manifest> </manifest> donnant à notre application
l’autorisation d’utiliser l’accès internet de la plateforme :
<uses-permission android:name="android.permission.INTERNET" />
Ce qui devrait vous donner :
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="googleMap.tutoriel"
android:versionCode="1"
android:versionName="1.0" >
<uses-sdk android:minSdkVersion="10" />
<application
android:icon="@drawable/ic_launcher"
android:label="@string/app_name" >
<uses-library android:name="com.google.android.maps" />
<activity
android:name=".AndroidGoogleMapActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />
</intent-filter>
</activity>
</application>
<uses-permission android:name="android.permission.INTERNET" />
</manifest>
2.3.2 Code XML
Modifions maintenant le fichier main.xml (res/layout/main.xml) qui contient les vues qui seront
affichées par notre activité principale.
Ajouter dans de LinearLayout (entre les balise <LinearLayout> </LinearLayout>) le code suivant :
9
<com.google.android.maps.MapView
android:id="@+id/mapView"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:enabled="true"
android:clickable="true"
android:apiKey="votre_API_KEY "
/>
Vous devez mettre votre API key au champ android:apiKey. Ce code nous permet d’ajouter une
carte GoogleMaps à notre activité.
2.3.3 Code Java
Modifier le fichier AndroidGoogleMapActivity.java (qui correspond à l’activité qui sera lancé en
premier lors du démarrage de l’application) afin qu’il corresponde au code si dessous.
package googleMap.tutoriel;
import com.google.android.maps.MapActivity;
import android.app.Activity;
import android.os.Bundle;
public class AndroidGoogleMapActivity extends MapActivity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.main);
}
@Override
protected boolean isRouteDisplayed() {
// TODO Auto-generated method stub
return false;
}
}
Détaillons un peu ce code :
-
la classe étend maintenant MapActivity, qui nous permet de manipuler une carte
GoogleMaps.
-
La méthode isRouteDisplayed() est obligatoire mais n’a pas d’importance dans notre cas.
-
La ligne setContentView(R.layout.main); permet de définir le layout qui sera afficher. Ce
layout contient les vues de l’activité (Ici, la carte).
2.3.3.1 Démarrage de l’application
Pour lancer votre application dans une AVD (Android Virtual Device), effectué l’opération suivante :
« click droit sur le projet -> run as -> android application »
Vous devez ensuite sélectionner l’AVD dans laquelle vous voulez démarrer votre application :
10
Vous voyez apparaitre ensuite cet écran, l’AVD est en cours de démarrage, cela peu prendre
plusieurs minutes…
11
Une fois démarré, votre application est directement lancée, voici le résultat de notre application :
3 Géolocalisation
3.1 Recupérer la position : les Providers
Avant de récupérer la position de l’utilisateur, on va ajouter des champs à notre classe
AndroidGoogleMapActivity afin de pouvoir manipuler la carte.
Le champ mapView va permettre de conserver la vue associée à la carte.
private MapView mapView = null;
Le champ mc va permettre de conserver le contrôleur associé à la vue.
private MapController mc = null;
Ces champs sont initalisés dans la méthode onCreate ainsi :
mapView = (MapView) this.findViewById(R.id.mapView);
mc = mapView.getController();
Pour pouvoir récupérer la position d’un utilisateur, on dispose d’un listener sous la forme de
l’interface LocationListener.
Reprenez la classe AndroidGoogleMapActivity et faites lui implémenter l’interface
LocationListener. Il y a alors quatre méthodes à implémenter :
12
@Override
public void onLocationChanged(Location location) {}
@Override
public void onProviderDisabled(String provider) {
}
@Override
public void onProviderEnabled(String provider) {
}
@Override
public void onStatusChanged(String provider, int status, Bundle extras) {}
La méthode onLocationChanged est appelée lors d’une modification de localisation de
l’utilisateur. En ajoutant le code suivant dans la méthode, la carte sera centrée sur notre position à
chaque changement :
@Override
public void onLocationChanged(Location location) {
GeoPoint p = new GeoPoint((int) (location.getLatitude() * 1E6),
(int) (location.getLongitude() * 1E6));
// on centre la carte par rapport à notre position
mc.setCenter(p);
}
Il faut ensuite indiquer à la carte quel fournisseur de localisation (provider), elle va utiliser.
On crée un nouveau champ à la classe qui va récupérer le service associé à la localisation dans le
téléphone :
private LocationManager lm = null;
On l’initialise dans la méthode onCreate() :
lm = (LocationManager) this.getSystemService(LOCATION_SERVICE);
À la fin de la méthode onCreate(), on peut alors ajouter :
// localisation par le gps
lm.requestLocationUpdates(LocationManager.GPS_PROVIDER, 1, 5,
this);
// localisation par le réseau
lm.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 1, 5,
this);
Le premier paramètre indique le type de provider, le second le temps en millisecondes à
attendre entre deux localisations, le troisième la précision en mètres au-delà de laquelle on
considère qu’il y a eu modification de la localisation et le dernier paramètre correspond au
LocationListener qui recevra les mises à jour.
13
Il faut ajouter dans le AndroidManifest, avant la balise <application> les permissions
nécessaires en fonction du provider :
Pour le réseau (NETWORK_PROVIDER) :
<uses-permission android:name="android.permission.INTERNET" />
Pour le GPS (GPS_PROVIDER) :
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
Lancer l’application pour voir fonctionner la géolocalisation.
Si vous utilisez un émulateur sous Eclipse, vous pouvez lui envoyer une nouvelle position en
affichant la fenêtre Emulator Control.
3.2 Marquer la carte : les Overlay
Dans cette partie nous allons voir comment ajouter des marqueurs sur la carte. Dans un
premier temps créez une classe BasicItemizedOverlay qui hérite de la classe ItemizedOverlay
avec le champ ci-dessous qui contiendra les marqueurs à afficher.
private ArrayList<OverlayItem> mOverlays = new ArrayList<OverlayItem>();
14
Il faut ensuite écrire les méthodes suivantes.
@Override
protected OverlayItem createItem(int i) {
return mOverlays.get(i);
}
@Override
public int size() {
return mOverlays.size();
}
public synchronized void addOverlay(OverlayItem overlay) {
mOverlays.add(overlay);
populate();
}
public synchronized void clear() {
mOverlays.clear();
populate();
}
On ajoute ensuite un attribut mContext de type Context à la classe pour conserver le
contexte parent et on ajoute deux constructeurs.
public BasicItemizedOverlay(Drawable defaultMarker, Activity context) {
// on centre l'image
super(boundCenterBottom(defaultMarker));
mContext = context;
populate();
}
public BasicItemizedOverlay(Drawable defaultMarker) {
// on centre l'image
super(boundCenterBottom(defaultMarker));
populate();
}
La méthode populate permet d’initialiser les marqueurs en appelant la méthode
createItem. Il est nécessaire de l’appeler dans le constructeur si la liste mOverlays est vide et à
chaque ajout d’un nouvel élément dans la liste pour garder une correspondance entre cette liste et
les marqueurs créés.
Enfin la méthode onTap peut être définie pour gérer le clic sur le marqueur.
15
@Override
protected boolean onTap(int index) {
OverlayItem item = mOverlays.get(index);
AlertDialog.Builder dialog = new AlertDialog.Builder(mContext);
dialog.setTitle(item.getTitle());
dialog.setMessage(item.getSnippet());
dialog.show();
return true;
}
Il faut maintenant l’utiliser dans la classe AndroidGoogleMapActivity. Ajouter le champ
itemizedoverlay de type BasicItemizedOverlay dans cette classe.
À la fin de la méthode onCreate, ajouter ces lignes pour l’initialiser :
// image utilisée pour le marqueur, ici ic_launcher
Drawable drawable =
this.getResources().getDrawable(R.drawable.ic_launcher);
// initialisation
itemizedoverlay = new BasicItemizedOverlay(drawable, this);
// ajout à la carte
mapView.getOverlays().add(itemizedoverlay);
Enfin, à la fin de méthode onLocationChanged ajoutez 
// creation du marqueur
OverlayItem overlayitem = new OverlayItem(p,"Hello","Vous êtes ici");
// on supprimme l’ancien marqueur
itemizedoverlay.clear() ;
// ajout du nouveau
itemizedoverlay.addOverlay(overlayitem);
Lancez l’application et vous verrez un marqueur apparaître à votre position.
16