Développement sous Android

Chapitres traités    Les fournisseurs de contenu (Content Provider) Création d'un service Géolocalisation, Google Maps et GPS Capteurs, accéléromètre (Dessins 2D - Drawable) Prendre des photos Bluetooth Réseau, connexions et services web

Pour cette dernière étude de l'environnement Android, nous allons en profiter pour découvrir plein de fonctionnalités intéressantes comme le partage des données, les services, la communication réseau, la prise en compte des capteurs intégrés, la géolocalisation, le graphisme, le multimédia, etc.

Les fournisseurs de contenu (Content Provider)

Vous pouvez décider d'étendre votre application en proposant des extensions utilisant les mécanismes de partage de données mis à disposition par un service déjà installé sur le téléphone de l'utilisateur. Le partage des données Android via les fournisseurs de contenu est un excellent moyen de diffuser de l'information selon une interface standard d'échange.

L'utilisation des bases de données vous permet de stocker des données complexes et structurées. L'accès à une base de données n'est possible que depuis l'application à partir de laquelle elle a été créée. Si vous souhaitez exposer les données d'une application à d'autres applications, par exemple des photos prises par votre application, Android prévoit un mécanisme plutôt élégant pour parvenir à cette fin : la notion de fournisseur de contenu, sous la forme d'une interface générique permettant d'exposer les données d'une application en lecture et/ou en écriture.

Ce mécanisme permet de faire une scission claire entre votre application et les données exposées. Ainsi, en rendant vos données disponibles au travers d'une telle interface, vous rendez votre application accessible et extensible à d'autres applications en tant que fournisseur de contenu, que ces applications soient créées par vous-même ou des tiers.

Les URIs

Avec Android, toute URI de schéma content:// représente une ressource servie par un fournisseur de contenu. Les fournisseurs de contenu encapsulent les données en utilisant des instances d'URI comme descripteur.

Nous ne savons jamais d'où viennent les données représentées par l'URI et nous n'avons pas besoin de le savoir : la seule chose qui compte est qu'elles soient disponibles lorsque nous en avons besoin.

Ces données pourraient être stockées dans une base de données SQLite ou dans des fichiers plats, voire récupérées à partir d'un terminal ou stockées sur un serveur situé loin d'ici, sur Internet.

A partir d'une URI, vous pouvez réaliser les opérations CRUD de base (Create, Read, Update, Delete) en utilisant un fournisseur de contenu. Les instances d'URI peuvent représenter des collections ou des éléments individuels. Grâce aux premières, vous pouvez créer de nouveaux contenus via des opérations d'insertion. Avec les secondes, vous pouvez lire les données qu'elles représentent, les modifier ou les supprimer.

Composantes d'une URI

Un fournisseur de contenu fonctionne un peu à la manière d'un service web accessible en REST (que nous verrons lors de cette étude) : vous exposez un ensemble d'URI capable de vous retourner différents ensembles d'éléments (tous les éléments, un seul ou un sous-ensemble) en fonction de l'URI et des paramètres.

Quand une requête cible un fournisseur de contenu, c'est le système qui gère l'instanciation de celui-ci. Un développeur n'aura jamais à instancier les objets d'un fournisseur de contenu lui-même.

Accéder à un fournisseur de contenu

Pour accéder à un fournisseur de contenu, vous devrez utiliser la classe android.content.ContentResolver. Cette classe est un véritable utilitaire qui sera votre principal point d'accès vers les fournisseurs de contenu Android.

Portez également une attention particulière à l'espace de noms android.provider dans lequel vous trouverez un ensemble de classes facilitant l'accès aux fournisseurs de contenu natifs de la plate-forme Android (appels, contacts, etc.).

android.provider.CallLog.Calls.CONTENT_URI
android.provider.Calendar.CONTENT_URI
android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI  

// Requêter toutes les données du fournisseur de contenu
ContentResolver fournisseur = getContentResolver();
Cursor données = fournisseur.query(MonFournisseur.CONTENT_URI, null, null, null, null);

// Filtrer les données retournées et trier par ordre croissant sur le nom
ContentResolver fournisseur = getContentResolver();
String[] projection = new String[] {"nom", "prénom", "âge"};
String filtre = "prénom = Julien";
String ordre = "nom ASC";
Cursor données = fournisseur.query(MonFournisseur.CONTENT_URI, projection, filtre, null, ordre);  

Uri requête = Uri.parse("content://fr.btsiris.bd");
Uri requêteParticulière = ContentUris.withAppendedId(requête, 10);
Uri requêteParticulière = Uri.withAppendPath(requête, "10");
Cursor données = managedQuery(requêteParticulière, null, null, null, null);  

package fr.btsiris.fournisseur;

import android.app.*;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.provider.ContactsContract;
import android.widget.*;

public class FournisseurContenu extends ListActivity {
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        Uri requête = ContactsContract.Contacts.CONTENT_URI;
        String ordre = ContactsContract.Contacts.DISPLAY_NAME +" COLLATE LOCALIZED ASC";
        Cursor lignes = getContentResolver().query(requête, null, null, null, ordre);
        startManagingCursor(lignes);
        ListAdapter liste = new SimpleCursorAdapter(this, 
                android.R.layout.two_line_list_item, lignes, 
                new String[] {ContactsContract.Data.DISPLAY_NAME}, 
                new int[] {android.R.id.text1});
        setListAdapter(liste);
    }
}

<?xml version="1.0" encoding="utf-8"?>
<ListView  xmlns:android="http://schemas.android.com/apk/res/android"
      android:id="@android:id/list"
      android:layout_width="fill_parent" 
      android:layout_height="fill_parent"
/>

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.fournisseur"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="@string/app_name" >
        <activity android:name="FournisseurContenu"  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.READ_CONTACTS" />
</manifest>

Créer un fournisseur de contenu

La création d'un fournisseur de contenu est d'une importance capitale lorsqu'une application souhaite mettre ses données à disposition d'autres applications. Si elle ne les garde que pour elle-même, vous pouvez éviter la création d'un fournisseur de contenu en vous contentant d'accéder directement aux données depuis vos activités.

Un fournisseur de contenu est une classe Java, tout comme une activité est une intention, la principale étape de la création d'un fournisseur consiste à produire sa classe Java, qui doit hériter de ContentProvider.

Cette sous-classe doit implémenter six méthodes qui, ensemble, assurent le service qu'un fournisseur de contenu est censé offrir aux activités qui veulent créer, lire, modifier ou supprimer du contenu.

La création d'un fournisseur de contenu s'effectue en dérivant une classe de ContentProvider et en redéfinissant les méthodes du tableau ci-dessous en fonction de vos besoin :

1. onCreate() : Obligatoire. Appelée lors de la création du fournisseur de contenu. Renvoie un booléen pour spécifier que le fournisseur de contenu a été chargé avec succès.
2. query() : Requête sur le fournisseur de contenu. Retourne un curseur permettant au programme local l'ayant appelé de naviguer au sein des résultats retournés.
3. delete() : Suppression d'une ou plusieurs lignes de données. L'entier retourné représente le nombre de lignes supprimées.
4. insert() : Appelée lorsqu'une insertion de données doit être réalisée sur le fournisseur de contenu. L'URI renvoyée correspond à la ligne nouvellement insérée.
5. update() : Mise à jour d'une URI. Toutes les lignes correspondant à la sélection seront mises à jour avec les valeurs fournies dans l'objet de type ContentValues des paramètres.
6. getType() : Retourne le type de contenu MIME à partir de l'URI spécifiée en paramètre.

La méthode query() retourne un objet Cursor vous permettant de manipuler et de naviguer dans les données de la même façon qu'avec un curseur de base de données SQLite (Cursor n'est qu'une interface). Par conséquent, vous pouvez utiliser n'importe quel curseur disponible dans le SDK Android : SQLiteCursor (base de données SQLite), MatrixCursor (pour les données non stockées dans une base de données), MergeCursor, etc.

1. De façon à identifier sans ambiguïté et pouvoir manipuler un fournisseur de conetnu, vous devez spécifier une URI unique, en général basé sur l'espace de nom de la classe d'implémentation du fournisseur. De façon à être accessible par tous les développeurs et applications, l'URI doit être exposé sous la variable publique statique nommée CONTENT_URI : "content://fr.btsiris.bd/personnes".
2. Avec cette URI, vous demanderez au fournisseur de contenu que nous allons élaborer de renvoyer toutes les personnes enregistrées actuellement dans la base de données. Si vous complétez la requête en la prefixant avec un numéro, vous demanderez uniquement la personne souhaitée à l'aide de son identifiant : "content://fr.btsiris.bd/personnes/10".
3. Le SDK d'Android possède une classe UriMatcher permettant de faciliter la gestion des URI. En utilisant et configurant celle-ci, vous n'aurez pas à scinder les URI vous-même pour essayer d'en extraire le contenu, la classe UriMatcher le fera pour vous.

Ce chapitre n'est pas erminé et sera traité dans un avenir proche.
.

Création d'un service

Les services d'Android sont destinés aux processus de longue haleine, qui peuvent devoir continuer de s'exécuter même lorsqu'ils sont séparés de toute activité. A titre d'exemple, citons la musique, qui continue d'être jouée même lorsque l'activité de "lecture" a été supprimée, la récupération des mises à jour des flux RSS sur Internet et la persistance d'une session de messagerie instantanée, même lorsque le client a perdu le focus à cause de la réception d'un appel téléphonique.

Un service est créé lorsqu'il est lancé manuellement (via un appel à l'API) ou quand une activité tente de s'y connecter via une communication interprocessus (IPC). Il perdure jusqu'à ce qu'il ne soit plus nécessaire et que le système ait besoin de récupérer de la mémoire. Cette longue exécution ayant un coût, les services doivent prendre garde à ne pas consommer trop de CPU sous peine d'user prématurément la batterie du terminal.

A la différence d'autres plates-formes du marché, Android offre un environnement pour ces applications sans interface utilisateur. Ainsi, les services sont des applications dérivant de la classe android.app.Service, qui s'exécutent en arrière-plan et qui sont capables de signaler à l'utilisateur qu'un événement ou une information nouvelle requiert son attention.

1. Contrairement aux activités qui offrent une interface utilisateur, les services en sont complètement dépourvus. Ils peuvent cependant réagir à des événements, mettre à jour des fournisseurs de contenu, effectuer n'importe quel autre traitement..., et enfin notifier leur état à l'utilisateur via des toasts et des notifications.
2. Ces services, complètement invisibles pour l'utilisateur, possèdent un cycle de vie similaire à une activité et peuvent être contrôlés depuis d'autres applications (activité, service et Broadcast Receiver). Il est ainsi commun de réaliser une application composée d'activités et d'un service ; un lecteur de musique utilisera une interface de sélection des musiques alors que le service jouera celles-ci en arrière plan.
3. Les applications qui s'exécutent fréquemment ou continuellement sans nécessiter constamment une interaction avec l'utilisateur peuvent être implémentées sous la forme d'un service. Les applications qui récupèrent des informations (informations, météo, résultats sportifs, etc.) via des flux RSS/Atom représentent de bons exemples de services.

Création d'un service

Les services sont conçus pour s'exécuter en arrière plan et nécessitent de pouvoir être démarrés, contrôlés et stoppés par d'autres applications. Les services partagent un certain nombre de comportements avec les activités. C'est pourquoi vous retrouverez des méthodes similaires à celles abordées précédemment pour les activités. Pour créer un service, dérivez votre classe de android.app.Service puis, à l'instar d'une activité, redéfinissez les méthodes du cycle de vie avant de déclarer le service dans le fichier de configuration de l'application.

Les services peuvent redéfinir trois méthodes : onCreate(), onStart() et onDestroy(). Les méthodes onCreate() et onDestroy() sont respectivement appelées lors de la création et de la destruction du service, à l'instar d'une activité.

La méthode onBind() est la seule méthode que vous devez obligatoirement implémenter dans un service. Cette méthode retourne un objet IBender qui permet au mécanisme IPC - communication interprocessus permettant d'appeler des méthodes distantes - de fonctionner.

Une fois votre service créé, il vous faudra, comme pour les activités d'une application, déclarer celui-ci dans le fichier de configuration de l'application au moyen de la balise <service android:name=".MonService" />. Voici les paramètres supplémentaires que vous pouvez spécifier sous forme d'attributs dans l'élément <service> :

1. process : Spécifie un nom de processus dans lequel le code sera exécuté.
2. enabled : Indique si le service est actif ou non (peut-être instancié par le système).
3. exported : Booléen indiquant si le service est utilisable par d'autres applications.
4. permission : Spécifie une permission nécessaire pour exécuter ce service.

En plus des attributions dans l'élément <service>, vous pouvez utiliser l'élément <meta-data> pour spécifier des données supplémentaires et une section <intent-filter> à l'instar des activités.

Démarrer et arrêter un service

Les services peuvent être démarrés manuellement (via l'appel de la méthode startService() ou via un objet Intent) ou quand une activité essaie de se connecter au service via une communication interprocessus (IPC).

1. Pour démarrer un service manuellement, utilisez la méthode startService(), laquelle accepte en paramètre un objet Intent. Ce dernier permet de démarrer un service en spécifiant son type de classe ou une action spécifiée par le filtre d'intention du service.

   // Démarre le service explicitement
   startService(new Intent(this, MonService.class));
   
   // Démarre le service en utilisant une action (enregistré dans Intent Filter).
   startService(new Intent(MonService.MON_ACTION_SPECIALE));

   Le moyen le plus simple de démarrer un service est de spécifier le nom de sa classe en utilisant le paramètre class. Cette option ne fonctionne que si le service est un composant de votre application et non un service tiers. Si le service à démarrer n'a pas été créé par vous, la seule alternative sera d'utiliser l'Intent associé à ce service.

2. La méthode startService() peut être appelée plusieurs fois, ce qui aura pour conséquence d'appeler plusieurs fois la méthode onStart() du service. Sachez donc gérer cette situation, de façon à ne pas allouer de ressources inutiles ou réaliser des traitements, qui rendraient caduque la bonne exécution de votre service.
3. Pour arrêter un service, utilisez la méthode stopService() avec l'action que vous avez utilisée lors de l'appel à la méthode startService() :

   stopService(new Intent(this, monService.getClass()));

Contrôler un service depuis une activité

L'exécution d'un service requiert le plus souvent d'avoir pu configuré ce dernier, souvent à l'aide d'une interface que l'utilisateur pourra utiliser pour spécifier ou changer les paramètres. Afin de pouvoir communiquer avec un service, vous avez plusieurs possibilités à votre disposition.

1. La première consiste à exploiter le plus possible le mécanisme des intentions au sein du service.
2. La seconde (dans le cas de deux applications distinctes) consiste à effectuer un couplage fort entre les processus de l'application appelante et le processus du service en utilisant le langage AIDL (Android Interface Definition Language), qui permet la définition de l'interface du service au niveau du système - ce thème ne sera pas abordé dans cette étude.
3. Il existe aussi une autre alternative qui combine ces deux possibilités en contrôlant un service à l'aide d'une activité et en les liant, à condition que le service et l'activité fassent partie de la même application. C'est cette dernière façon que nous allons détailler ci-après.

Lorsqu'une activité est liée à un service, celle-ci possède une référence permanente vers le service, qui vous permet de communiquer avec le service comme si ce dernier n'était qu'une simple référence à un objet de votre activité.

Pour permettre à une activité de s'associer à un service, la méthode onBind() doit être implémentée au niveau du service. Cette méthode retourne un objet qui sera utilisé plus tard par l'activité pour récupérer la référence vers le service. La méthode onBind() doit renvoyer un type IBinder propre à votre service, ce qui signifie que vous devez créer votre propre implémentation de l'interface IBinder :

public class ServiceConversion extends Service {
...
   @Override
   public IBinder onBind(Intent intention) { return new ConversionBinder();  }
   
   public class ConversionBinder extends Binder {
      ServiceConversion getService() { return ServiceConversion.this; }
   }
}

Une fois la méthode onBind() implémentée au niveau de votre service, vous devez maintenant connecter l'activité au service. Pour ce faire, vous devez utiliser une connexion de type ServiceConnection : ce sont les méthodes de cette dernière qui seront appelées par l'activité pour se connecter ou se déconnecter du service.

Créez la connexion au niveau de l'activité, en redéfinissant les méthodes onServiceConnected() et onServiceDisconnected() de la classe ServiceConnection. La première méthode sera appelée lors de la connexion de l'activité au service et la seconde lors de la déconnexion.

public class Conversion extends Activity {
   private ServiceConversion service;
   
   private ServiceConnection connexion = new ServiceConnection() {
      public void onServiceConnected(ComponentName nom, IBinder binder) {
         service = ((ServiceConversion.ConversionBinder)binder).getService();
      }

      public void onServiceDisconnected(ComponentName nom) {
         service = null;
      }
   };
}

Une fois que la méthode onBind() du service est implémentée et qu'un objet ServiceConnection est prêt à faire office de médiateur, l'activité doit encore demander de façon explicite l'association au service, à l'aide de la méthode bindService(). Cette méthode prend trois paramètres :

1. L'intention du service que vous souhaitez invoquer, souvent de façon explicite directement en utilisant la classe du service ;
2. Une instance de la connexion créée vers le service ;
3. Un drapeau spécifiant les options d'association, souvent 0 ou la constante BIND_AUTO_CREATE. Une autre valeur BIND_DEBUG_UNBIND permet d'afficher des informations de débogage. Vous pouvez combiner les deux valeurs à l'aide de l'opérateur binaire &.

public class Conversion extends Activity {

   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState); 
       Intent soumettre = new Intent(this, ServiceConversion.class);
       bindService(soumettre, connexion, Context.BIND_AUTO_CREATE);
   } 
}

Une fois l'association effectuée à l'aide de la méthode bindService(), la méthode onServiceConnected() sera appelée et la référence vers le service associé sera récupérée. Vous pourrez ainsi appeler toutes les méthodes et propriétés publiques du service au travers de cette référence comme s'il s'agissait d'un simple objet de l'activité, et de cette façon contrôler le service au travers de l'interface utilisateur proposée par l'activité. Pour vous déconnecter, utilisez la méthode unbindService() de l'instance de l'activité.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.conversion"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Service en action" >
        <activity android:name="Conversion" android:label="Conversion">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <service android:name="ServiceConversion" />
    </application>
</manifest>   

<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:stretchColumns="1">
    <TableRow>
       <fr.btsiris.conversion.Monnaie 
          android:id="@+id/euro"
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content"
          android:layout_span="3"/>
       <Button     
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content" 
          android:text="Franc"
          android:onClick="calculFranc"  />
    </TableRow>
    <TableRow>
       <fr.btsiris.conversion.Monnaie 
          android:id="@+id/franc"
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content"
          android:layout_span="3"/>
       <Button     
          android:layout_width="fill_parent" 
          android:layout_height="wrap_content" 
          android:text="€uro"
          android:onClick="calculEuro"  />
    </TableRow>    
</TableLayout>

package fr.btsiris.conversion;

import android.app.*;
import android.content.Intent;
import android.os.*;
import android.widget.Toast;

public class ServiceConversion extends Service {
   private final double TAUX = 6.55957;

   @Override
   public void onCreate() {
      super.onCreate();
      Toast.makeText(this, "Service en action", Toast.LENGTH_LONG).show();
   }

   @Override
   public void onDestroy() {
      super.onDestroy();
      Toast.makeText(this, "Service désactivé", Toast.LENGTH_LONG).show();
   }
   
   public double euroFranc(double euro) {
      return euro * TAUX;
   }
   
   public double francEuro(double franc) {
      return franc / TAUX;
   }   
   
   @Override
   public IBinder onBind(Intent intention) { return new ConversionBinder();  }
   
   public class ConversionBinder extends Binder {
      ServiceConversion getService() { return ServiceConversion.this; }
   }
} 

package fr.btsiris.conversion;

import android.content.Context;
import android.text.InputType;
import android.util.AttributeSet;
import android.view.Gravity;
import android.widget.EditText;
import java.text.*;

public class Monnaie extends EditText {
   private NumberFormat formatMonnaie;

   public Monnaie(Context context, AttributeSet attrs, int defStyle) {
      super(context, attrs, defStyle);
      init();
   }

   public Monnaie(Context context, AttributeSet attrs) {
      super(context, attrs);
      init();
   }

   public Monnaie(Context context) {
      super(context);
      init();
   }
   
   private void init() {
      setSymbole('€');
      setValeur(0.0);
      setGravity(Gravity.RIGHT);
      setInputType(InputType.TYPE_CLASS_NUMBER);
   }

   public void setSymbole(char symbole) {
      formatMonnaie = new DecimalFormat("#,##0.00 "+symbole);
   }

   public double getValeur() {
      try {
         Number valeur = (Number) formatMonnaie.parse(getText().toString());
         setText(formatMonnaie.format(valeur));
         return valeur.doubleValue();
      } 
      catch (ParseException ex) { return 0.0; }
   }

   public void setValeur(double valeur) {
      setText(formatMonnaie.format(valeur));
   }
}  

package fr.btsiris.conversion;

import android.app.Activity;
import android.content.*;
import android.os.*;
import android.view.View;

public class Conversion extends Activity {
   private Monnaie euro, franc;
   private ServiceConversion service;
   
   private ServiceConnection connexion = new ServiceConnection() {
      public void onServiceConnected(ComponentName nom, IBinder binder) {
         service = ((ServiceConversion.ConversionBinder)binder).getService();
      }

      public void onServiceDisconnected(ComponentName nom) {
         service = null;
      }
   };
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState); 
       setContentView(R.layout.main);
       euro = (Monnaie) findViewById(R.id.euro);
       franc = (Monnaie) findViewById(R.id.franc);
       franc.setSymbole('F');     
       franc.setValeur(0.0);
       Intent soumettre = new Intent(this, ServiceConversion.class);
       bindService(soumettre, connexion, Context.BIND_AUTO_CREATE);
   }

   @Override
   protected void onDestroy() {
      super.onDestroy();
      unbindService(connexion);
   }   
    
   public void calculFranc(View vue) {
      franc.setValeur(service.euroFranc(euro.getValeur()));
   }
   
   public void calculEuro(View vue) {
      euro.setValeur(service.francEuro(franc.getValeur()));
   }   
}

Géolocalisation, Google Maps et GPS

L'une des caractéristiques essentielles des téléphones mobiles est leur portabilité, et il n'est donc pas surprenant que quelques-unes des fonctionnalités les plus séduisantes d'Android soient les services permettant de déterminer, de contextualiser et de cartographier des positions géographiques.

Vous pouvez créer des activités fondées sur des cartes utilisant Google Maps comme un élément d'interface utilisateur. Vous aurez un accès complet aux cartes, ce qui vous permettra de contrôler les paramètres d'affichage, de changer le niveau de zoom et de faire un panoramique. Vous pourrez annoter les cartes et gérer la saisie de l'utilisateur pour produire des informations et des fonctionnalités contextuelles.

Nous couvrirons également dans ce chapitre les services de géolocalisation, qui permettent de déterminer la position courante de l'appareil. Ils incluent le GPS et la technologie Google de localisation cellulaire. Vous pourrez spécifier quelle technologie utiliser en la nommant explicitement ou implicitement, en définissant un ensemble de critères en termes de précision, coût ou autres.

Les cartes et les services de géolocalisation utilisent la latitude et la longitude pour identifier les positions géographiques, mais la plupart des utilisateurs raisonnent plutôt en terme d'adresses. Android fournit un Geocoder qui supporte les géocodages avant et inverse. Grâce à lui, vous pourrez convertir latitudes et longitudes en adresses et inversement.

Utilisés conjointement, la cartographie, le géocodage et les services de géolocalisation fournissent une puissante boîte à outils pour incorporer la mobilité native de votre téléphone à vos applications. Les services de géolocalisation d'Android sont donc divisés en deux grandes parties :

1. Les API qui gèrent les plans (dans l'espace de noms com.google.android.maps) ;
2. Les API qui gèrent la localisation à proprement parler (dans l'espace de noms android.location).

Nous allons d'abord voir comment déterminer la position d'un appareil sur Android. Ensuite, nous verrons en deux temps comment utiliser l'émulateur pour simuler des positions en étudiant d'abord la génération des fichiers de points et ensuite leur emploi. La suite du chapitre sera consacrée aux capacités de la plate-forme et notamment à l'affichage de cartes Google Maps ainsi qu'aux différents dessins ou affichage réalisables grâce à ces mêmes cartes.

Utiliser les services de géolocalisation

Les services de géolocalisation sont un terme générique désignant les différentes technologies utilisées pour déterminer la position courante d'un appareil. Les deux principaux éléments sont les suivants :

1. Location Manager : Fournit des points d'entrée vers les services de géolocalisation.
2. Location Providers : (fournisseurs de position) : Chacun d'eux représente une technologie de localisation de la position de l'appareil.

A l'aide du Location Manager vous pouvez :

1. Obtenir une position courante.
2. Suivre des déplacements.
3. Déclencher des alertes de proximité en détectant les mouvements dans une zone spécifique.
4. Trouver les Location Providers disponibles.

Lorsqu'il s'agit de déterminer la position courante de l'appareil, plusieurs problèmes peuvent être rencontrés :

1. Tous les appareils ne disposent pas tous du même matériel de géolocalisation (certains n'ont pas de récepteur GPS) ;
2. Les conditions d'utilisation du téléphone peuvent rendre inutilisable une méthode de localisation (cas de fonctionnalités GPS dans un tunnel, par exemple).

Sélectionner un fournisseur de position - Location Provider

En fonction de l'appareil, Android peut utiliser plusieurs technologies pour déterminer la position courante. Chacune d'elles, appelée Location Provider, offrira diverses caractéristiques en matière de consommation d'énergie, de coût, de précision et de capacité à déterminer l'altitude, la vitesse ou le cap.

C'est pourquoi Android offre plusieurs moyens de localisation au travers d'une liste de fournisseurs de positions : selon les conditions du moment ou vos propres critères, Android se chargera de sélectionner le plus apte à donner la position de l'appareil.

Il faudra donc récupérer cette liste de fournisseurs et déterminer celui qui est le plus adapté à l'utilisation souhaitée. De manière générale, nous distinguons deux types de fournisseurs naturels :

1. Le fournisseur basé sur la technologie GPS, de type LocationManager.GPS_PROVIDER. C'est le plus précis des deux, mais c'est également le plus consommateur en terme de batterie.
2. Le fournisseur qui se repère grâce aux antennes des opérateurs mobiles et aux points d'accès WI-FI, de type LocationManager.NETWORK_PROVIDER.

// Ainsi, pour obtenir une instance d'un provider spécifique, appelez la méthode getProvider() en lui passant son nom :
String fournisseur = LocationManager.GPS_PROVIDER;
LocationProvider gpsProvider = sysLocalisation.getProvider(fournisseur);

Ceci n'est en général utile que pour déterminer les capacités d'un provider particulier. La plupart des méthodes d'un Location Manager ne requièrent que le nom du provider pour exécuter les services de géolocalisation.

Obtenir la liste des fournisseurs de position

Le but des services de géolocalisation est de déterminer la position de l'appareil. L'accès à ces services est géré par le système au travers de la méthode getSystemService(). La classe des fournisseurs de position, LocationProvider, est une classe abstraite : chacune des différentes implémentations (correspondant aux différents moyens de localisation à notre disposition) fournit l'accès aux informations de localisation d'une manière qui lui est propre.

//  Le code suivant permet d'obtenir la liste de tous les fournisseurs :
LocationManager sysLocalisation = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
List<String> fournisseurs = sysLocalisation.getAllProviders();

A un instant donné, tous les outils de géolocalisation de l'appareil ne sont peut-être pas disponibles : l'utilisateur peut en effet décider de désactiver certains moyens (par exemple, le GPS peut être désactivé pour économiser les batteries).

Une autre alternative permet ainsi d'obtenir la liste de tous les providers disponibles sur l'appareil en appelant cette fois-ci la méthode getProviders() en spécifiant un booléen pour indiquer si vous désirez toute la liste des fournisseurs ou uniquement ceux qui sont activés :

//  Le code suivant permet d'obtenir la liste de tous les fournisseurs activés :
LocationManager sysLocalisation = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
boolean actifsSeulement = true;
List<String> fournisseurs = sysLocalisation.getProviders(actifsSeulement);

Comme nous l'avons vu plus haut, si vous souhaitez obtenir un fournisseur particulier, appelez plutôt la méthode getProvider() en spécifiant le type de fournisseur à l'aide des constantes prédéfinies LocationManager.GPS_PROVIDER ou LocationManager.NETWORK_PROVIDER :

LocationManager sysLocalisation = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
String fournisseur = LocationManager.GPS_PROVIDER;
LocationProvider gpsProvider = sysLocalisation.getProvider(fournisseur);

Comme la plupart des fonctionnalités sous Android, pour utiliser ces quelques lignes de code, il ne faut pas oublier de déclarer les permissions appropriées dans la section <manifest> du fichier de configuration de l'application.

<manifest xmlns:android="http://schemas.android.com/apk/res/android" ...>
    <application android:label="@string/app_name" >
		....    
    </application>
    //  L'utilisation du fournisseur de type GPS est lié à la déclaration de permission suivante :
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    //  L'utilisation du fournisseur réseau dépend quant à lui de la permission :
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
</manifest>

Nous retrouvons ici la notion de localisation grossière ou fine suivant la méthode utilisée par l'implémentation.
.

Je rappelle encore une fois que le but des services de géolocalisation est de déterminer la position de l'appareil. Une seule ligne de code suffit pour cela. Il faut cependant choisir auparavant un fournisseur de position. Une fois cette étape réalisée, nous utilisons la méthode getLastKnownLocation() issue de la classe LocationManager, avec comme paramètre le fournisseur de position choisi. Le retour de cette méthode est une instance d'un objet Location si une position a été calculée, sinon son résultat vaut null :

LocationManager sysLocalisation = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
String fournisseur = LocationManager.GPS_PROVIDER;
Location localisation = sysLocalisation.getLastKnownLocation(fournisseur);

L'objet de type Location renvoyé par la méthode getLastKnownLocation() inclut toutes les informations de position disponibles données par le fournisseur : latitude, longitude, cap, altitude, vitesse et heure à laquelle la position a été déterminée. Toutes ces propriétés sont accessibles via les méthodes getXxx() de l'objet Location. Dans certaines instances, des détails additionnels sont fournis dans le Bundle des compléments.

Choix d'un fournisseur de position en fonctions de critères

Il est peu probable dans la plupart des scenarii que vous souhaitiez explicitement choisir le fournisseur de position à utiliser. Plus communément, vous spécifierez les exigences qu'un fournisseur devra respecter et laisserez Android déterminer la meilleure technologie à utiliser.

Une méthode existe dans Android pour choisir un fournisseur à partir de besoins que vous formulez, ce qui permet de déterminer le fournisseur le plus adapté à vos attentes.

La classe centrale pour la définition des critères se nomme Criteria. Grâce à elle vous pouvez spécifier vos exigences en terme de précision (fine ou approximative), de consommation d'énergie (faible, moyenne, élevée), de coût et de capacité à renvoyer l'altitude, la vittesse et le cap.

//  Spécifie des critères de précision approximative, de faible consommation d'énergie et pas d'altitude, cap et vitesse.
Criteria critères = new Criteria(); 
critères.setAccuracy(Criteria.ACCURACY_COARSE);
critères.setPowerRequirement(Criteria.POWER_LOW);
critères.setAltitudeRequired(false);
critères.setBearingRequired(false);
critères.setSpeedRequired(false);
critères.setCostAllowed(true);
//  Spécifie des critères de localisation la plus fine possible avec l'altitude fournie obligatoirement.
Criteria critères = new Criteria(); 
critères.setAccuracy(Criteria.ACCURACY_FINE);
critères.setAltitudeRequired(true);

Une fois les critères définis, nous utilisons la méthode getBestProvider() de l'instance de la classe LocationManager récupérée un peu plus tôt. Le booléen en paramètre donne la possibilité de se restreindre aux fournisseurs activés uniquement.

LocationManager sysLocalisation = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
Criteria critères = new Criteria(); 
critères.setAccuracy(Criteria.ACCURACY_FINE);
critères.setAltitudeRequired(true);
String fournisseur = sysLocalisation.getBestProvider(critères, true);

Si plus d'un fournisseur de position correspond à vos critères, celui possédant la précision la plus élevée est renvoyé. Si aucun fournisseur ne répond à vos exigences, les critères sont assouplis dans l'ordre suivant jusqu'à ce qu'un fournisseur soit trouvé :

1. Consommation d'énergie.
2. Précision.
3. Capacité à déterminer le cap, la vitesse et l'altitude.

Le critère de coût n'est jamais modifié. Si aucun fournisseur n'est trouvé, la valeur null est renvoyée.
.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.localisation"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="GPS" >
        <activity android:name="Geolocalisation" android:label="Où suis-je ?">
            <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.ACCESS_FINE_LOCATION" />
</manifest>

<?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:id="@+id/latitude"
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content"  />
    <TextView  
        android:id="@+id/longitude"
        android:layout_width="fill_parent" 
        android:layout_height="wrap_content"  />
</LinearLayout>

package fr.btsiris.localisation;

import android.app.Activity;
import android.content.Context;
import android.location.*;
import android.os.Bundle;
import android.widget.TextView;

public class Geolocalisation extends Activity {
   private TextView latitude, longitude;
    @Override
    public void onCreate(Bundle savedInstanceState)  {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        latitude = (TextView) findViewById(R.id.latitude);
        longitude = (TextView) findViewById(R.id.longitude);
        
        LocationManager localisations = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        Location position = localisations.getLastKnownLocation(LocationManager.GPS_PROVIDER);
        if (position!=null) {
            latitude.setText("Latitude : "+position.getLatitude());
            longitude.setText("Longitude : "+position.getLongitude());           
        }
        else latitude.setText("Position  non déterminée ");
    }
}

package fr.btsiris.localisation;

import android.app.Activity;
import android.content.Context;
import android.location.*;
import android.os.Bundle;
import android.widget.TextView;

public class Geolocalisation extends Activity {
   private TextView latitude, longitude;
    @Override
    public void onCreate(Bundle savedInstanceState)  {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        latitude = (TextView) findViewById(R.id.latitude);
        longitude = (TextView) findViewById(R.id.longitude);
        
        LocationManager localisations = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        Criteria critères = new Criteria(); 
        critères.setAccuracy(Criteria.ACCURACY_COARSE);
        critères.setPowerRequirement(Criteria.POWER_LOW);
        critères.setAltitudeRequired(false);
        critères.setBearingRequired(false);
        critères.setSpeedRequired(false);
        critères.setCostAllowed(true);
        
        String fournisseur = localisations.getBestProvider(critères, true);        
        Location position = localisations.getLastKnownLocation(fournisseur);
        if (position!=null) {
            latitude.setText("Latitude : "+position.getLatitude());
            longitude.setText("Longitude : "+position.getLongitude());  
        }
        else latitude.setText("Position  non déterminée ");
    }
}

Suivre les déplacements

La plupart des applications de localisation doivent réagir aux déplacements de l'utilisateur. Se contenter de sonder le LocationManager ne suffira pas à forcer l'obtention des nouvelles mises à jour des Location Providers. Détecter le changement de position relève de deux problématiques : recevoir des mises à jour de sa position et détecter le mouvement.

Ces deux problématiques de changement se résolvent par l'utilisation de la même méthode du LocationManager. Il s'agit de la méthode requestLocationUpdates() dont voici les paramètres utiles :

LocationManager sysLocalisation = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
String fournisseur = LocationManager.GPS_PROVIDER;
sysLocalisation.requestLocationUpdates(fournisseur, temps, distance, écouteurLocalisation);

1. Le premier paramètre est le fournisseur de position souhaité.
2. Ensuite, le deuxième paramètre indique le temps entre deux mises à jour exprimé en millisecondes. Attention à ne pas mettre de valeur trop faibles, qui accaparerait les ressources du téléphone et viderait votre batterie. La documentation du SDK recommande une valeur minimale de 60 000 ms.
3. Le troisième paramètre précise la distance correspond au nombre de mètres qui doivent être parcourus avant de recevoir une nouvelle position. Si elle est supérieure à zéro, la mise à jour s'effectuera uniquement une fois la distance parcourue.
4. Enfin, le dernier paramètre est l'écouteur (une implémentation de l'interface LocationListener) qui recevra les diverses notifications. Cet écouteur propose quatre méthodes que vous devez redéfinir suivant les circonstances :

   class ChangementPosition implements LocationListener {
          
       public void onLocationChanged(Location position) {
           // Met à jour l'application en fonction de la nouvelle position.
       }
   
       public void onStatusChanged(String fournisseur, int statut, Bundle extras) {
           // Met à jour l'application si le status du matériel a changé.
       }
   
       public void onProviderEnabled(String fournisseur) {
           // Met à jour l'application lorsque le fournisseur est activé.
       }
   
       public void onProviderDisabled(String fournisseur) {
           // Met à jour l'application lorsque le fournisseur est désactivé.
       }       
   }

5. Pour arrêter les mises à jour, il faut fournir au gestionnaire de localisation l'instance de l'écouteur à retirer au travers de la méthode removeUpdates().

Les GPS ont pour la plupart une consommation électrique significative. Pour la minimiser, vous devez désactiver les mises à jour à chaque fois que cela est possible, particulièrement lorsqu'elles servent à mettre à jour l'interface utilisateur mais que votre application n'est pas visible. Vous pouvez également améliorer les performances en augmentant le temps minimal entre les mises à jour.

package fr.btsiris.localisation;

import android.app.Activity;
import android.content.Context;
import android.location.*;
import android.os.Bundle;
import android.widget.*;

public class Geolocalisation extends Activity {
   private TextView latitude, longitude;
   private LocationManager localisations;
   private String fournisseur;
   
    @Override
    public void onCreate(Bundle savedInstanceState)  {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        latitude = (TextView) findViewById(R.id.latitude);
        longitude = (TextView) findViewById(R.id.longitude);     
        
        Criteria critères = new Criteria(); 
        critères.setAccuracy(Criteria.ACCURACY_COARSE);
        critères.setPowerRequirement(Criteria.POWER_LOW);
        critères.setAltitudeRequired(false);
        critères.setBearingRequired(false);
        critères.setSpeedRequired(false);
        critères.setCostAllowed(true);
        
        localisations = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        fournisseur = localisations.getBestProvider(critères, true);   
        localisations.requestLocationUpdates(fournisseur, 5000, 5, new ChangementPosition());
    }

    class ChangementPosition implements LocationListener {
         public void onLocationChanged(Location position) {
            if (position!=null) {
                  latitude.setText("Latitude : "+position.getLatitude());
                  longitude.setText("Longitude : "+position.getLongitude());  
            }
            else latitude.setText("Position  non déterminée ");
            Toast.makeText(Geolocalisation.this, "Nouvelle position", Toast.LENGTH_SHORT).show();
         }
         public void onStatusChanged(String fournisseur, int statut, Bundle extras) {  }
         public void onProviderEnabled(String fournisseur) {  }
         public void onProviderDisabled(String fournisseur) {  } 
    }
}  

package fr.btsiris.localisation;

import android.app.Activity;
import android.content.Context;
import android.location.*;
import android.os.Bundle;
import android.widget.*;

public class Geolocalisation extends Activity {
   private TextView latitude, longitude;
   private LocationManager localisations;
   private String fournisseur;
   private ChangementPosition changements = new ChangementPosition();
   
    @Override
    public void onCreate(Bundle savedInstanceState)  {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        latitude = (TextView) findViewById(R.id.latitude);
        longitude = (TextView) findViewById(R.id.longitude);     
        localisations = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        miseAJourDeLaPosition(localisations.getLastKnownLocation(LocationManager.GPS_PROVIDER));
    }

    @Override
    protected void onStart() {
        super.onStart();
        localisations.requestLocationUpdates(LocationManager.GPS_PROVIDER, 2000, 2, changements);   
        localisations.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 5000, 5, changements); 
    }

    @Override
    protected void onStop() {
       super.onStop();
       localisations.removeUpdates(changements);
    } 

    private void miseAJourDeLaPosition(Location position) {
        if (position!=null) {
            latitude.setText("Latitude : "+position.getLatitude());
            longitude.setText("Longitude : "+position.getLongitude());  
        }
        else latitude.setText("Position  non déterminée ");
        Toast.makeText(Geolocalisation.this, "Nouvelle position", Toast.LENGTH_SHORT).show();       
    }
    
    class ChangementPosition implements LocationListener {
         public void onLocationChanged(Location position) { miseAJourDeLaPosition(position);  }
         public void onStatusChanged(String fournisseur, int statut, Bundle extras) { }
         public void onProviderEnabled(String fournisseur) { }
         public void onProviderDisabled(String fournisseur) { } 
    }
}

Alertes de proximité

Il est souvent utile de voir vos applications réagir lorsque l'utilisateur se déplace en direction d'un lieu particulier ou s'en éloigne. Les alertes de proximité permettent de mettre en place des déclencheurs exécutés dans ces cas-là.

Pour mettre en place une alerte de proximité pour une zone de donnée, sélectionnez le centre de celle-ci (en l'exprimant en longitude et latitude), le rayon et un délai d'expiration de l'alerte. Elle sera déclenchée si l'appareil entre ou sort du rayon défini.

Lorsqu'elles sont déclenchées, les alertes de proximité exécutent des intentions, le plus souvent des Broadcast Intents. Pour spécifier l'intention, utilisez un PendingIntent, une classe qui wrappe l'intention en une sorte de pointeur de méthode au moyen de la méthode getBroadcast() :

Intent intention = new Intent(MON_ACTION);
PendingIntent proximité = PendingIntent.getBroadcast(this, -1, intention, 0);

La méthode addProximityAlert() de la classe LocationManager permet, quant à elle, d'enregistrer un PendingIntent qui sera déclenché quand l'appareil se trouvera à une certaine distance du point fixé. La méthode possède la signature suivante :

public void addProximityAlert(double latitude, double longitude, float rayon, long expiration, PendingIntent intention);

1. latitude : correspond à la latitude du point d'alerte ;
2. longitude : correspond à la longitude du point d'alerte ;
3. rayon : correspond au rayon autour du point d'alerte qui déterminera la sensibilité de la détection ;
4. expiration : définit une période en millisecondes à la fin de laquelle l'élément LocationManager retirera le point d'alerte des alertes surveillées. La valeur -1 signifie que l'enregistrement est valide jusqu'à qu'il soit retiré manuellement par la méthode removeProximityAlert().
5. intention : est utilisé pour générer l'intention déclenchée quand l'appareil rentre ou sort de la zone désignée par le point et le rayon.

L'intention PendingIntent est étendue avec un extra dont la clé se nomme KEY_PROXIMITY_ENTERING. Nous obtenons alors un booléen dont la valeur est true si nous sommes dans la zone définie et false si nous la quittons.

La gestion de l'alerte se réalise au travers d'un BroadcastReceiver, dont vous devez redéfinir la méthode de rappel onReceiver() qui permet de spécifier quelles actions vous souhaitez réaliser par rapport à la proximité du lieu, qu'il est ensuite nécessaire d'enregistrer au travers de la méthode registerReceiver(). Si l'activité n'est plus active, il est souhaitable d'enlever l'alerte au moyen de la méthode removeProximityAlert().

package fr.btsiris.localisation;

import android.app.*;
import android.content.*;
import android.location.*;
import android.os.Bundle;
import android.widget.*;

public class Geolocalisation extends Activity {
   private TextView latitude, longitude;
   private LocationManager localisations;
   private ChangementPosition changements = new ChangementPosition();
   private static final String ALERTE_PROXIMITE = "fr.btsiris.localisation";
   private PendingIntent proximite;
   private Location position;
   private boolean premiereFois = true;
   
    @Override
    public void onCreate(Bundle savedInstanceState)  {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        latitude = (TextView) findViewById(R.id.latitude);
        longitude = (TextView) findViewById(R.id.longitude);     
        localisations = (LocationManager) getSystemService(Context.LOCATION_SERVICE);     
    }

    @Override
    protected void onStart() {
        super.onStart();
        position = localisations.getLastKnownLocation(LocationManager.GPS_PROVIDER);
        localisations.requestLocationUpdates(LocationManager.GPS_PROVIDER, 3000, 2, changements);   
        localisations.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 3000, 2, changements); 
    }

    @Override
    protected void onStop() {
       super.onStop();
       localisations.removeUpdates(changements);
       localisations.removeProximityAlert(proximite);
    } 

    private void miseAJourDeLaPosition(Location position) {
       if (position!=null) {
          latitude.setText("Latitude : "+position.getLatitude());
          longitude.setText("Longitude : "+position.getLongitude());  
       }
       else latitude.setText("Position  non déterminée ");      
     }
    
    private void ajouterAlerte() {
       Intent intention = new Intent(ALERTE_PROXIMITE);
       proximite = PendingIntent.getBroadcast(this, -1, intention, 0);
       double lat = position.getLatitude();
       double lng = position.getLongitude();
       localisations.addProximityAlert(lat, lng, 7.0F, -1, proximite);
       IntentFilter filtre = new IntentFilter(ALERTE_PROXIMITE);
       registerReceiver(new Zone(), filtre);
    }
    
    class ChangementPosition implements LocationListener {
       public void onLocationChanged(Location position) { 
          if (premiereFois) { premiereFois = false; ajouterAlerte(); }
          miseAJourDeLaPosition(position);  
       }
       public void onStatusChanged(String fournisseur, int statut, Bundle extras) { }
       public void onProviderEnabled(String fournisseur) { }
       public void onProviderDisabled(String fournisseur) { } 
    }
    
    class Zone extends BroadcastReceiver {
       @Override
       public void onReceive(Context context, Intent intention) {
          String cle = LocationManager.KEY_PROXIMITY_ENTERING;
          boolean dans = intention.getBooleanExtra(cle, false);
          String alerte = dans ? "Rentre dans la zone" : "Sort de la zone";
          Toast.makeText(Geolocalisation.this, alerte, Toast.LENGTH_LONG).show();           
       }       
    }
}

Conversion d'adresses et d'endroits - Géocodage

Le géocodage permet de déterminer des coordonnées en latitude et longitude à partir d'une adresse ou d'une description d'un endroit. A l'inverse, le géocodage permet de retrouver un lieu en fonction de ses coordonnées. Ces fonctionnalités sont liées à l'API Google.

Ainsi, le géocodage, au travers de la classe Geocoder, permet de traduire automatiquement des adresses en coordonnées géographiques et inversement. Cela permet de connaître les positions utilisées par les services de géolocalisation et les activités géographiques. Les recherches de géocodage ont lieu sur le serveur et vos applications devront donc avoir la permission de se connecter à Internet :

<manifest xmlns:android="http://schemas.android.com/apk/res/android" ...>
    <application android:label="@string/app_name" >
		....    
    </application>
    //  L'utilisation du fournisseur de type GPS est lié à la déclaration de permission suivante :
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    //  L'utilisation du géocodage dépend quant à lui de la permission :
    <uses-permission android:name="android.permission.INTERNET" />
</manifest>

La classe Geocoder donne accès à deux fonctions de géocodage :

1. Géocodage avant : Détermine la latitude et la longitude d'une adresse.
2. Géocodage inverse : Détermine l'adresse en fonction de la latitude et de la longitude.

Le résultat de ces appels sont contextualisés par le biais d'une locale (utilisée pour définir votre emplacement et votre langue habituels). L'extrait qui suit montre comment la mettre en oeuvre lors de la création du Geocoder. Si vous ne la spécifiez pas, celle de votre appareil sera utilisée par défaut.

Geocoder geocodage = new Geocoder(this, Locale.FRANCE);
Geocoder geocodage = new Geocoder(this, Locale.getDefault());

Les deux fonctions de géocodage renvoient une liste d'objets Address. Chacun peut contenir plusieurs résultats en fonction d'une limite que vous spécifiez lors de l'appel. Chaque objet Address est renseigné avec tous les détails que le géocoder a pu déterminer. Cela peut inclure la latitude, la longitude, un numéro de téléphone et des détails d'adresse de granularité de plus en plus fine allant du pays au numéro de la voie.

Les recherches du Geocoder sont effectuées de façon synchrone et bloquent donc le thread appelant. Dans le cas de connexions réseau lentes, cela peut se traduire par un écran figé. dans la plupart des cas, il est conseillé de déplacer ces recherches vers un Service ou un Thread en arrière-plan.

Géocodage inverse

Le géocodage inverse renvoie des adresses en fonctions de lieux spécifiés par leur latitude et leur longitude. Il permet de reconnaître les positions renvoyées par les services de géolocalisation.

Pour effectuer une recherche inversée, passez la latitude et la longitude à la méthode getFromLocation() du Geocoder. Elle renverra une liste des correspondances possibles d'adresses. Si le Geocoder ne peut déterminer aucune adresse pour les coordonnées spécifiées, il renverra la valeur null.

L'exactitude et la granularité des recherches inversées dépendent entièrement de la qualité des données de la base de géocodage. La conséquence en est que la qualité des résultats peut varier de façon importante selon les pays.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.localisation"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="GPS" >
        <activity android:name="Geolocalisation" android:label="Où suis-je ?">
            <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.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.INTERNET" />
</manifest>   

<?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:id="@+id/latitude"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"  />
   <TextView  
      android:id="@+id/longitude"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"   />
   <TextView  
      android:id="@+id/adresse"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"   />      
</LinearLayout>

package fr.btsiris.localisation;

import android.app.Activity;
import android.content.Context;
import android.location.*;
import android.os.Bundle;
import android.widget.*;
import java.io.IOException;
import java.util.*;

public class Geolocalisation extends Activity {
   private TextView latitude, longitude, adresse;
   private LocationManager localisations;
   private ChangementPosition changements = new ChangementPosition();
   private Geocoder geocodage;
   
   @Override
    public void onCreate(Bundle savedInstanceState)  {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        latitude = (TextView) findViewById(R.id.latitude);
        longitude = (TextView) findViewById(R.id.longitude);   
        adresse =  (TextView) findViewById(R.id.adresse);  
        geocodage = new Geocoder(this, Locale.FRANCE);
        localisations = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        miseAJourDeLaPosition(localisations.getLastKnownLocation(LocationManager.GPS_PROVIDER));
    }

    @Override
    protected void onStart() {
        super.onStart();
        localisations.requestLocationUpdates(LocationManager.GPS_PROVIDER, 2000, 2, changements);   
        localisations.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 5000, 5, changements); 
    }

    @Override
    protected void onStop() {
       super.onStop();
       localisations.removeUpdates(changements);
    } 

    private void miseAJourDeLaPosition(Location position) {
       if (position!=null) {
          double lat = position.getLatitude();
          double lng = position.getLongitude();
          latitude.setText("Latitude : "+lat);
          longitude.setText("Longitude : "+lng);  
          try {
             List<Address> adresses = geocodage.getFromLocation(lat, lng, 1);
             StringBuilder texte = new StringBuilder();
             if (adresses.size() > 0) {
                Address une = adresses.get(0);
                texte.append(une.getAddressLine(0)).append("\n");
                texte.append(une.getPostalCode()).append(" ").append(une.getLocality()).append("\n");
                texte.append(une.getCountryName()).append("\n");
                adresse.setText(texte.toString());
             }
          } 
          catch (IOException ex) { }
       }
       else latitude.setText("Position  non déterminée ");
       Toast.makeText(Geolocalisation.this, "Nouvelle position", Toast.LENGTH_SHORT).show();    
    }    
     
    class ChangementPosition implements LocationListener {
         public void onLocationChanged(Location position) { miseAJourDeLaPosition(position);   }
         public void onStatusChanged(String fournisseur, int statut, Bundle extras) {  }
         public void onProviderEnabled(String fournisseur) {  }
         public void onProviderDisabled(String fournisseur) {  } 
    }
} 

Géocodage avant

Le géocodage avant (ou tout simplement géocodage) détermine cette fois-ci les coordonnées géographiques d'un lieu à partir d'un texte décrivant un endroit. Le format des adresses, noms de stations ou codes postaux dépendent évidemment de la zone géographique concernée.

Ce que nous appelons lieu valide varie effectivement en fonction de la zone géographique. Il s'agira en général d'une adresse normale de granularité variable (depuis le pays jusqu'au numéro dans la voie), d'un code postal, d'une gare, d'un monument, d'un hôpital ou, de façon générale, de tout ce qui peut être utilisé dans une recherche sur Google Maps.

Pour effectuer un géocodage, appelez la méthode getFromLocationName() sur une instance de Geocoder. Passez-lui le lieu dont vous souhaitez obtenir les coordonnées ainsi que le nombre maximal de résultats :

Geocoder geocodage = new Geocoder(this, Locale.FRANCE);
List<Address> positions = geocodage.getFromLocationName(adresse, 1);

La liste renvoyée peut inclure plusieurs correspondances possibles pour le lieu indiqué. Chaque résultat inclura une latitude et une longitude ainsi que toutes les informations d'adresse disponibles. Ceci est utile pour confirmer que la position a été correctement résolue ainsi que pour fournir des informations spécifiques lors de recherches de monuments.

Comme pour le géocodage inverse, null est renvoyé si aucune correspondance n'est trouvée. De même, la disponibilité, l'exactitude et la granularité des résultats dépendent entièrement des données disponibles dans la base.

Lorsque vous effectuez des recherches inversées, l'objet Locale spécifié lors de la création du Geocoder est particulièrement important. La Locale fournit le contexte géographique pour l'interprétation des résultats de recherche car un nom de lieu peut exister à plusieurs endroits. Lorsque c'est possible, sélectionnez une Locale régionale pour éviter les ambiguïtés.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.localisation"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Localisation" >
        <activity android:name="Localisation" android:label="Latitude et Longitude ?">
            <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>

<?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"
    android:padding="3px">
   <EditText 
      android:id="@+id/rue"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"
      android:hint="Rue" />   
   <EditText 
      android:id="@+id/ville"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"
      android:hint="Ville" />         
   <Button 
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:text="Rechercher" 
      android:onClick="localiser"/>         
   <TextView  
      android:id="@+id/latitude"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:textStyle="bold"
      android:textColor="#00FF00" 
      android:textSize="18sp" />
   <TextView  
      android:id="@+id/longitude"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"  
      android:textStyle="bold"
      android:textColor="#00FF00"
      android:textSize="18sp" />
</LinearLayout>  

package fr.btsiris.localisation;

import android.app.Activity;
import android.location.*;
import android.os.Bundle;
import android.view.View;
import android.widget.*;
import java.io.IOException;
import java.util.*;

public class Localisation extends Activity {
   private TextView latitude, longitude;
   private EditText rue, ville;
   private Geocoder geocodage;
    
   @Override
   public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.main);
       latitude = (TextView) findViewById(R.id.latitude);
       longitude = (TextView) findViewById(R.id.longitude);   
       rue =  (EditText) findViewById(R.id.rue);
       ville =  (EditText) findViewById(R.id.ville);
       geocodage = new Geocoder(this, Locale.FRANCE);       
   }
   
   public void localiser(View vue) {
      String adresse = rue.getText().toString() + ", " + ville.getText().toString() + ", France";
      try {
         List<Address> positions = geocodage.getFromLocationName(adresse, 1);
         if (positions.size() > 0) {
            Toast.makeText(this, adresse, Toast.LENGTH_LONG).show();
            Address position = positions.get(0);
            latitude.setText("Latitude = "+position.getLatitude());
            longitude.setText("Longitude = "+position.getLongitude());
         }
      } 
      catch (IOException ex) { Toast.makeText(this, "Non localisée", Toast.LENGTH_LONG).show(); }      
   }          
}

Création d'activités géographiques utilisant Google Maps

La manipulation d'adresses ou de lieux, que ce soit pour un affichage ou une saisie, peut se faire via des affichages textes ou des formulaires mais l'utilisateur est habitué à tout visualiser sur des cartes. Afin de réaliser des applications utilisant ces vues à base de cartes, nous allons employer, entre autres, les différentes classes suivantes :

1. MapActivity : la classe de base à étendre pour créer une activité qui contiendra une carte (une MapView). Cette classe prend en charge le cycle de vie de l'application et la gestion du service d'arrière-plan requis pour afficher les cartes. En conséquence, vous ne pouvez utiliser les MapView que dans des activités dérivées de la classe MapActivity.
2. MapView : une vue affichant une carte sous forme de tuiles (parties de carte téléchargées indépendamment). L'une des façon les plus intuitive de présenter le contexte géographique est de l'afficher sur une carte. A l'aide d'une MapView, vous pouvez créer des activités présentant des cartes interactives. Les MapView supportent les annotations par le biais des Overlays et par l'épinglage de Views sur des positions géographiques.
3. MapControler : permet de contrôler la carte (centrage, niveau de zoom, etc.). Ce système apporte le contrôle total par programmation sur l'affichage de la carte, vous permettant de contrôler le zoom, la position et les modes d'affichage, y compris l'option d'afficher des vues satellite, de la rue ou du trafic.
4. Overlay : sorte de calque pour rajouter des annotations sur les cartes. Avec elle, vous pourrez utiliser un Canvas pour dessiner autant de couches que vous voudrez, qui seront affichées au dessus de la MapView.
5. MyLocationOverlay : est un Overlay particulier qui peut être utilisé pour afficher la position courante et l'orientation de l'appareil.
6. ItemizedOverlays et OverlayItems : sont utilisés pour vous permettre de créer une couche de marqueurs de cartes, affichés à l'aide de Drawable et de texte associé.

Les activités géographiques sont exécutées nativement sur l'appareil, vous permettant de vous appyer sur son matériel et sa mobilité pour apporter une expérience personnalisée à l'utilisateur.

Authentification - obtention de votre clé d'API

Pour utiliser une MapView dans votre application, vous devrez d'abord obtenir une clé d'API sur le site des développeurs Android http://code.google.com/android/maps-api-signup.html (voir plus loin). Sans elle, la MapView ne pourra pas télécharger les images utilisées pour afficher la carte.

Pour obtenir une clé, vous devrez spécifier l'empreinte MD5 du certificat utilisé pour signer votre application. En général, vous signerez votre application à l'aide de deux certificats, l'un de débogage, l'autre de production.

Pour voir les images des cartes pendant le débogage, vous devrez obtenir une clé d'API enregistrée via l'empreint MD5 du certificat de débogage. L'emplacement du magasin de clés (keystore) de débogage est stocké aux emplacement suivants :

1. Windows Vista & 7 : \Utilisateurs\<utilisateur>\.android\debug.
2. Windows XP : \Documents and Settings\<utilisateur>\.android\debug.
3. Linux ou Mac : ~/.android/debug.keystore.

ATTENTION : Chaque ordinateur que vous utilisez lors du développement aura son propre certificat de débogage et sa propre valeur MD5. Si vous désirez déboguer et développer des applications géographiques sur plusieurs machines, vous devez générer et utiliser plusieurs clés d'API.

Récupération de votre clé Google Map en mode débogage

Comme nous venons de le signaler, afin de pouvoir utiliser Google Map dans votre application, il vous faut une clé API. Voici les étapes pour obtenir cette dernière :

1. Génération du MD5 : La première étape pour l’obtention de la clé API, c’est de créer votre MD5 Checksum. Il est créé grâce au debug certificate. Nous avons besoin de ce MD5, car il faut que la Google Map de l’application soit signée et la clé API sert à ça. Pour créer votre MD5, il faut trouver où se situe votre fichier debug.keystore. Une fois le chemin connu, il faut taper la commande keytool en mode console et respecter les options suivantes :
   
   
2. Génération de votre clé API : Il suffit maintenant de vous rendre sur : http://code.google.com/intl/fr/android/maps-api-signup.html. Vous devez par contre disposer d’un compte Google. Pour pouvoir générer votre clé, il vous suffit d’accepter les termes et saisir le MD5 obtenu au dessus.
   
   
3. Obtention de la clé API : La clé obtenue correspond à l’instance de votre ordinateur, si vous changer d’ordinateur, il faudra générer une autre clé. Gardez la clé que vous avez obtenu dans un coin ou un fichier, nous verrons son utilisation lors de l'élaboration d'une application affichant une carte Google Map.
   
   
   

Récupération de votre clé Google Map en mode production définitive pour le déploiement sur votre smartphone

Avant de compiler et de signer votre application pour la diffuser, vous devrez obtenir une clé d'API en utilisant l'empreinte MD5 de votre certificat de production. Déterminez-la avec la commande keytool et spécifiez le paramètre -liste et les keystore et alias que vous utiliserez pour signer votre application. Vous devrez entrer vos mots de passe de keystore et d'alias avant que l'empreinte MD5 ne vous soit fournie.

keytool -list -alias mon-android-alias -keystore mon-android-keystore

Créer une activité géographique

La classe MapActivity est étroitement liée à la classe MapView. Elle permet, grâce à ses différentes méthodes, de prendre en charge les tâches - notamment de connexion réseau - pour simplifier l'utilisation d'une vue orientée carte.

Pour utiliser des cartes dans vos applications, vous devez étendre MapActivity. Le layout de la nouvelle classe doit inclure une MapView pour afficher l'élément d'interface Google Maps. En pratique, l'emploi de la classe MapActivity dans une application nécessite plusieurs étapes :

1. La bibliothèque cartographique d'Android n'est pas un paquetage standard Android. En tant qu'API optionnelle, elle doit être explicitement incluse dans le manifeste de l'application afin de pouvoir être utilisée.

   <uses-library android:name="com.google.android.maps" />

   Ce paquetage ne fait pas partie du projet open-source Android standard. Il est fourni par Google dans le SDK Android et est disponible sur la plupart des appareils. Mais, n'étant pas standard, il se peut qu'un appareil ne le supporte pas.

2. Les images des cartes sont téléchargées à la demande et votre application doit donc avoir la permission d'utiliser Internet. Effectivement, puisque les tuiles du plan ainsi que toutes les informations comme le trafic routier sont téléchargées au fur et à mesure (vous devez avoir remarqué qu'à chaque déplacement de la carte, les zones sont affichées progressivement), il faut également prévoir la permission d'accéder aux données Internet comme suit :

   <uses-permission android:name="android.permission.INTERNET" />  

   AndroidManifest.xml

   <?xml version="1.0" encoding="utf-8"?>
   <manifest xmlns:android="http://schemas.android.com/apk/res/android"
         package="fr.btsiris.localisation"  android:versionCode="1"  android:versionName="1.0">
       <application android:label="Cartographie" >    
           <activity android:name="Cartographie" android:label="Où suis-je ?">
               <intent-filter>
                   <action android:name="android.intent.action.MAIN" />
                   <category android:name="android.intent.category.LAUNCHER" />
               </intent-filter>
           </activity>
           <uses-library android:name="com.google.android.maps" />
       </application>
       <uses-permission android:name="android.permission.INTERNET" />
   </manifest>

3. Une fois la bibliothèque ajoutée et la permission configurée, vous êtes prêt à créer votre nouvelle activité géographique. Cette activité contiendra une vue de type plan et un contrôleur de carte. Les vues de type plan (MapView ne peuvent être utilisés que dans une activité qui étend la classe MapActivity. Redéfinissez la méthode onCreate() pour disposer l'écran contenant la MapView et la méthode isRouteDisplayed() pour envoyer true si l'activité doit afficher des informations de directions.

   Android ne supporte actuellement qu'une seule MapActivity et une seule MapView par application.
   .

   public class Cartographie extends MapActivity {
      private MapView carte;
      private MapController controleur;
      
       @Override
       public void onCreate(Bundle savedInstanceState) {
           super.onCreate(savedInstanceState);
           setContentView(R.layout.main);
           carte = (MapView) findViewById(R.id.carte);
           controleur = carte.getController();
       }
   
      @Override
      protected boolean isRouteDisplayed() {
         return false;
      }
   }

Manipuler la classe MapView

La classe MapView gère l'affichage de la carte (proposée par Google). Par défaut, MapView montre la carte standard. Vous pouvez en plus choisir d'afficher une vue satellite, les vues plus précises des bâtiments au niveau de la rue ainsi que le trafic estimé :

MapView carte = (MapView) findViewById(R.id.carte);
carte.setSatellite(true);
carte.setSteetView(true);
carte.setTraffic(true);

Vous pouvez également interroger la carte (MapView) pour déterminer les zooms courant et maximal ainsi que le centre de la carte et les longitudes et latitudes visibles (en degrés). Ce dernier (vois extrait ci-après) est particulièrement utile pour effectuer des recherches de géocodage géographiquement bornées. Vous pouvez également de façon optionnelle afficher des contrôles de zoom standard en utilisant la méthode setBuiltInZoomControls().

MapView carte = (MapView) findViewById(R.id.carte);
int zoomMaxi = carte.getMaxZoomLevel();
GeoPoint point = carte.getMapCenter();
int latitude = carte.getLatitudeSpan();
int longitude = carte.getLongitudeSpan();
carte.setBuiltInZoomControls(true);

Pour employer correctement la classe MapView dans votre application, n'oubliez pas, bien entendu, de vous occuper de sa présentation au moyen du layout associé qui complète le squelette de l'activité que nous venons de découvrir :

res/layout/main.xml

<?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"   >
...
   <com.google.android.maps.MapView 
      android:id="@+id/carte"   
      android:layout_width="fill_parent" 
      android:layout_height="fill_parent" 
      android:enabled="true"
      android:clickable="true"
      android:apiKey="0kHT1LZrcfazDGalQpFJThJQVO55qyxFQ15LbZA" />       
</LinearLayout>

Nous retrouvons sans surprise la vue avec son identifiant. Nous constatons la présence d'un paramètre supplémentaire essentiel : la clé Google Maps. Elle peut soit être saisie directement dans la description de la vue, comme le montre le code précédent, soit donné sous forme de ressource annexe.

Manipuler la classe MapControler

Nous utilisons la classe MapControler pour manipuler la carte en termes de position (recentrer) et de zoom. La récupération de l'instance de MapControler associée à une vue de type carte se fait à l'aide d'un accesseur getController() de la classe MapView.

MapController controleur = carte.getController();

Dans les classes géographiques Android, les positions sur une carte sont représentées par des objets GeoPoint qui contiennent la latitude et la longitude mesurées en micro-degrés, à savoir degrés*1E6 (10 puissance 6). Avant de pouvoir utiliser les valeurs de latitude et de longitude stockées dans les objets Location renvoyés par les services de géolocalisation, vous devez les convertir en micro-degrés et les stocker en GeoPoint.

Double lat = Double.parseDouble(latitude.getText().toString()) * 1E6;
Double lng = Double.parseDouble(longitude.getText().toString()) * 1E6;
GeoPoint point = new GeoPoint(lat.intValue(), lng.intValue());
controleur.animateTo(point); ou controleur.setCenter(point); 
controleur.setZoom(1);

1. Recentrez et zoomez dans la carte en utilisant respectivement les setCenter() et setZoom() disponibles dans le MapController de la classe MapView. La méthode setCenter() permet de "sauter" vers une nouvelle position. Pour une transition sans à-coups, utilisez la méthode animateTo() de MapView.
2. Lorsque vous utilisez la méthode setZoom(), 1 représente le zoom le plus large (le plus lointain) et 21, le plus proche. Le niveau de zoom réel disponible pour une position donnée dépend de la résolution des cartes Google et de l'imagerie disponible pour la zone. Vous pouvez également utiliser les méthodes zoomIn() et zoomOut() pour modifier le niveau par incrément de 1.
3. Lorsque vous utilisez Google Maps, vous remarquez que le fond cartographique se charge selon un découpage (dit tuilage) comprenant un ensemble de morceaux (tuiles) visibles à l'écran. Quand vous vous déplacez sur la carte, les tuiles sont chargées au fur et à mesure. Ce tuilage est stocké, pour chaque niveau de précision (et donc de zoom pour nous), sur les serveurs de Google.
4. Quand nous changeons le niveau de précision (de zoom), nous chargeons un ensemble de tuiles différent. Suivant la zone ciblée, les images sont disponibles à des précisions variées. Le niveau de zoom est réglable de 1 (plus petit niveau) à 21 inclus, sachant qu'il n'existe pas toujours de tuiles du lieu choisi aux niveaux de zoom les plus élevés (la zone n'a pas été photographiée avec cette précision ou elle fait partie d'un ensemble sensible qui doit être masqué par exemple). Pour donner un ordre d'idée, au niveau de zoom 1, l'Equateur terrestre mesure 256 pixels de long et que chaque niveau de zoom successifs grossit d'un facteur 2.

<?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"
    android:padding="3px">
   <EditText 
      android:id="@+id/latitude"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:hint="Latitude" />
   <EditText 
      android:id="@+id/longitude"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:hint="Longitude" />     
   <Button 
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:text="Localiser" 
      android:onClick="localiser"/>    
   <com.google.android.maps.MapView 
      android:id="@+id/carte"   
      android:layout_width="fill_parent" 
      android:layout_height="fill_parent" 
      android:enabled="true"
      android:clickable="true"
      android:apiKey="0kHT1LZrcfazDGalQpFJThJQVO55qyxFQ15LbZA" />       
</LinearLayout>
  

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.localisation"  android:versionCode="1"  android:versionName="1.0">
    <application android:label="Cartographie" >    
        <activity android:name="Cartographie" android:label="Où suis-je ?">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <uses-library android:name="com.google.android.maps" />
    </application>
    <uses-permission android:name="android.permission.INTERNET" />
</manifest>

package fr.btsiris.localisation;

import android.os.Bundle;
import android.view.View;
import android.widget.*;
import com.google.android.maps.*;

public class Cartographie extends MapActivity {
   private EditText latitude, longitude;
   private MapView carte;
   private MapController controleur;
   
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        latitude = (EditText) findViewById(R.id.latitude);
        longitude = (EditText) findViewById(R.id.longitude);
        carte = (MapView) findViewById(R.id.carte);
        carte.setBuiltInZoomControls(true);
        controleur = carte.getController();
    }

   @Override
   protected boolean isRouteDisplayed() {
      return false;
   }
   
   public void localiser(View vue) {
      Double lat = Double.parseDouble(latitude.getText().toString()) * 1E6;
      Double lng = Double.parseDouble(longitude.getText().toString()) * 1E6;
      GeoPoint point = new GeoPoint(lat.intValue(), lng.intValue());
      controleur.animateTo(point);
   }
}

Placer des données sur une carte

Les calques (Overlays) permettent d'ajouter des formes, des images ou du texte sur une vue de type carte (MapView). Il est possible de superposer plusieurs calques qui masquerons potentiellement des zones correspondant à des couches plus anciennes.

Les Overlays vous permettent d'ajouter des annotations et une gestion des clics dans les MapViews. Chaque Overlay permet de tracer des primitives 2D, comme du texte, des lignes des images et des formes, sur un Canvas qui recouvrira ensuite une MapView.

Vous pouvez ainsi ajouter plusieurs Overlays sur une carte. Tous les Overlays assignés à une MapView sont ajoutés comme des couches, chaque nouvelle couche masquant potentiellement les précédentes. Les clics des utilisateurs sont transmis au travers de la pile jusqu'à ce qu'ils soient pris en charge par un Overlay ou enregistrés comme des clics sur la MapView elle-même.

Créer et utiliser des calques

Pour créer un calque, vous devez définir une nouvelle classe qui hérite de la classe Overlay. Nous disposons alors d'une sorte de canevas pour dessiner. Les instructions de dessins personnalisés doivent alors être placées dans la méthode draw() qui est à redéfinir. Pour réagir aux actions utilisateur sur ces annotations, il faut également redéfinir la méthode onTap().

Chaque Overlay est un Canvas possédant un fond transparent, recouvrant une MapView et utilisé pour prendre en charge les clics sur la carte (qui ont lieu en général lorsque l'utilisateur tape sur une annotation ajoutée par l'Overlay).

import android.graphics.Canvas;
import com.google.android.maps.*;

public class Calque extends Overlay {

   @Override
   public void draw(Canvas canevas, MapView carte, boolean ombres) {
      if (!ombres) {
         // Dessiner les annotations sur la couche principale
      }
      else {
         // Dessiner les annotations sur la couche cachée
      }      
   }

   @Override
   public boolean onTap(GeoPoint centre, MapView carte) {
      return false;
   }   
}

Ajouter et supprimer des calques de la vue

Chaque MapView contient la liste de ses calques en cours d'affichage. Nous pouvons obtenir une référence à cette liste en appelant la méthode getOverlays() issue de la classe MapView :

List<Overlay> calques = carte.getOverlays();
Calque nouveau = new Calque();
calques.add(nouveau);
carte.postInvalidate();

L'ajout et la suppression de calques dans la liste sont automatiquement sécurisés et synchronisés. L'ajout et la suppression se fait ainsi de façon totalement transparente, sans préoccupation de gestion multi-tâche étant donné que la liste a été passé à la méthode Collection.synchronized() avant de nous être retournée.

Ainsi, pour ajouter un Overlay sur une MapView, créez simplement une instance de l'Overlay et ajoutez-la à la liste sans autre écriture supplémentaire. Tous les calques de la liste seront dessinés par ordre croissant et recevront des événements progressivement en ordre inverse tant qu'un calque ne les traitera pas.

L'Overlay ajouté sera affiché la prochaine fois que la MapView sera redessinée et il est donc conseillé d'appeler la méthode postInvalidate() après une modification de la liste afin de mettre à jour l'affichage de la carte.

Dessiner sur un calque

Le dessin sur un calque est possible en redéfinissant la méthode draw() du calque, un peu comme si nous redéfinissions la méthode paintComponent() d'un composant Swing de l'API de Java SE.

Comme nous l'avons découvert, cette méthode draw() possède trois paramètres que nous allons maintenant détailler :

1. Le premier est de type Canvas et constitue la surface sur laquelle nous allons dessiner. L'objet Canvas contient des méthodes pour tracer des primitives 2D sur vos cartes (lignes, texte, formes, ellipses, images, etc.). Utilisez des objets Paint pour définir le style et la couleur.
2. Le deuxième est la référence de type MapView qui correspond à la vue qui affiche la carte concernée par notre dessin.
3. Le dernier est un booléen qui indique dans quel appel nous nous trouvons. En effet, cette méthode est appelée deux fois pour permettre, quand ombres vaut true, de dessiner des ombres aux formes créées.

ATTENTION : Le Canvas utilisé pour tracer les annotations des Overlays est un Canvas standard représentant la surface affichée visible. Pour ajouter des annotations basées sur des positions, vous devrez effectuer une conversion entre coordonnées géographiques et coordonnées d'écran.

Introduction aux projections

La classe Projection vous permet de traduire des coordonnées de latitude et longitude en coordonnées d'écran. Un objet de type Projection est obtenu grâce à la méthode getProjection() de la classe MapView. Dès lors, à l'aide de cet objet, nous pouvons réaliser la conversion dans les deux sens, d'un GeoPoint vers un Point et vice versa, respectivement avec les méthodes toPixels() et fromPixels().

Projection transformation = carte.getProjection();
Double lat = Double.parseDouble(latitude.getText().toString()) * 1E6;
Double lng = Double.parseDouble(longitude.getText().toString()) * 1E6;
GeoPoint pointCarte = new GeoPoint(lat.intValue(), lng.intValue());
Point pointEcran = new Point();
transformation.toPixels(pointCarte, pointEcran);

Les styles

Nous disposons à présent de coordonnées pour dessiner. Il reste à choisir le style du pinceau que nous allons utiliser pour réaliser une forme, et c'est là qu'intervient la classe Paint. Elle va nous permettre de déterminer le style et la couleur des formes et des textes que nous voulons dessiner sur le calque grâce aux méthodes setARGB(), setAlpha(), setColor(), setAntiAlias(), etc.

Paint pinceau = new Paint();
pinceau.setARGB(255, 255, 255, 0);

La boîte à outils du dessinateur

Une fois les coordonnées de la forme et le style choisi, nous utilisons toutes les méthodes de l'instance de Canvas pour réaliser des tracés personnalisés 2D sur vos cartes (lignes, texte, formes, ellipse, images, etc.) à l'aide des méthodes tel que drawLine(), drawCircle(), drawRect(), drawText(), drawBitmap(), drawPicture(), etc.

canevas.drawText("C'est ici !", pointEcran.x, pointEcran.y, pinceau);

Réagir à une sélection

Le tapotement sur l'écran sont l'équivalent des clics de souris. Vous les prendrez en charge en redéfinissant le gestionnaire onTap() dans la classe d'extension de l'Overlay. Il reçoit deux paramètres :

1. Un GeoPoint contenant la latitude et la longitude de la position cliquée.
2. La MapView sur laquelle l'événement a été déclenché.

Lorsque vous décidez de redéfinir onTap(), la méthode devra renvoyer true si elle a pris en charge un clic particulier et false pour laisser un autre Overlay le gérer.

package fr.btsiris.localisation;

import android.graphics.*;
import com.google.android.maps.*;

public class Calque extends Overlay {

   @Override
   public void draw(Canvas canevas, MapView carte, boolean ombres) {
      if (!ombres) {         
         Point pointEcran = new Point();
         Projection transformation = carte.getProjection();
         transformation.toPixels(carte.getMapCenter(), pointEcran);
         Paint pinceau = new Paint();
         pinceau.setARGB(200, 0, 0, 255);
         pinceau.setAntiAlias(true);
         pinceau.setFakeBoldText(true);
         int rayon = 5;
         canevas.drawCircle(pointEcran.x, pointEcran.y, rayon, pinceau);
         canevas.drawText("Je suis là", pointEcran.x+10, pointEcran.y-10, pinceau);
      }
   }

   @Override
   public boolean onTap(GeoPoint centre, MapView carte) {
      return false;
   }   
}

package fr.btsiris.localisation;

import android.os.Bundle;
import android.view.View;
import android.widget.*;
import com.google.android.maps.*;
import java.util.List;

public class Cartographie extends MapActivity {
   private EditText latitude, longitude;
   private MapView carte;
   private MapController controleur;
   private Calque calque = new Calque();
   
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        latitude = (EditText) findViewById(R.id.latitude);
        longitude = (EditText) findViewById(R.id.longitude);
        carte = (MapView) findViewById(R.id.carte);
        carte.setBuiltInZoomControls(true);
        controleur = carte.getController();
        List<Overlay> calques = carte.getOverlays();
        calques.add(calque);
    }

   @Override
   protected boolean isRouteDisplayed() {
      return false;
   }
   
   public void localiser(View vue) {
      Double lat = Double.parseDouble(latitude.getText().toString()) * 1E6;
      Double lng = Double.parseDouble(longitude.getText().toString()) * 1E6;
      GeoPoint point = new GeoPoint(lat.intValue(), lng.intValue());
      controleur.animateTo(point);
   }
}

Calque MyLocationOverlay

L'API Android propose également un calque prédéfini spécifique qui peut répondre à deux problématiques usuelles :

1. Montrer où vous êtes sur la carte à partir de coordonnées GPS ou d'un autre fournisseur de position.
2. Montrer votre orientation grâce à la boussole électronique si elle est disponible sur votre matériel.

La classe MyLocationOverlay est un Overlay particulier pour afficher votre position courante et votre orientation sur une MapView. Pour l'utiliser, vous devez l'instancier, lui passer le contexte de l'application et la carte cible puis l'ajouter à la liste des Overlays.

MapView carte = (MapView) findViewById(R.id.carte);
List<Overlay> calques = carte.getOverlays();
MyLocationOverlay calque = new MyLocationOverlay(this, carte);
calques.add(calque);
calque.enableCompass();
calque.enableMyLocation();

Vous pouvez maintenant l'utiliser pour afficher à la fois votre position courante (représentée par un marqueur bleu clignotant) et votre direction (représentée sous la forme d'une boussole sur la carte). Pour activer ces fonctionnalités spécifiques, utilisez pour cela les méthodes enabledCompass() et enableMyLocation() sur l'instance que vous souhaitez impacter.

Afin d'optimiser la durée de vie de la batterie, il serait judicieux d'activer et de désactiver ces fonctionnalités au moment opportun, au travers des méthodes de rappel, respectivement onResume() ou onStart() et onPause() ou onStop().

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.localisation"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Cartographie">    
        <activity android:name="Cartographie" android:label="Où suis-je ?">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <uses-library android:name="com.google.android.maps" />  
    </application>
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
</manifest>

<?xml version="1.0" encoding="utf-8"?>
<com.google.android.maps.MapView  xmlns:android="http://schemas.android.com/apk/res/android"
      android:id="@+id/carte"   
      android:layout_width="fill_parent" 
      android:layout_height="fill_parent" 
      android:enabled="true"
      android:clickable="true"
      android:apiKey="0kHT1LZrcfaxP_vuzbfx3ScZMpYTT-8wmSDX2RA" 
/>

package fr.btsiris.localisation;

import android.content.Context;
import android.location.*;
import android.os.Bundle;
import com.google.android.maps.*;
import java.util.List;

public class Cartographie extends MapActivity {
   private MapView carte;
   private MapController controleur;
   private MyLocationOverlay calque;
   private LocationManager localisations;
   private ChangementPosition changements = new ChangementPosition();  
   
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);       
        carte = (MapView) findViewById(R.id.carte);
        carte.setBuiltInZoomControls(true);
        controleur = carte.getController();
        List<Overlay> calques = carte.getOverlays();
        calque = new MyLocationOverlay(this, carte);
        calques.add(calque);
        localisations = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        miseAJourDeLaPosition(localisations.getLastKnownLocation(LocationManager.GPS_PROVIDER));
    }

    @Override
    protected boolean isRouteDisplayed() { return false; }
   
    @Override
    protected void onStart() {
        super.onStart();
        localisations.requestLocationUpdates(LocationManager.GPS_PROVIDER, 2000, 2, changements);   
        localisations.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 5000, 5, changements); 
        calque.enableCompass();
        calque.enableMyLocation();       
    }

    @Override
    protected void onStop() {
       super.onStop();
       localisations.removeUpdates(changements);
       calque.disableCompass();
       calque.disableMyLocation();
    } 
    
    private void miseAJourDeLaPosition(Location position) {
       if (position!=null) {
          Double lat = position.getLatitude() * 1E6;
          Double lng = position.getLongitude() * 1E6;
          GeoPoint point = new GeoPoint(lat.intValue(), lng.intValue());
          controleur.animateTo(point);
       }
    }        
    
    class ChangementPosition implements LocationListener {
       public void onLocationChanged(Location position) { miseAJourDeLaPosition(position);   }
       public void onStatusChanged(String fournisseur, int statut, Bundle extras) {  }
       public void onProviderEnabled(String fournisseur) {  }
       public void onProviderDisabled(String fournisseur) {  } 
    }   
}

Classes ItemizedOverlay et OverlayItem

Comme son nom l'indique, la classe ItemizedOverlay affiche sur une carte une liste de points d'intérêts. Ces points sont des instances de la classe OverlayItem.

La classe ItemizedOverlay fourni un raccourci pour ajouter des marqueurs à une carte, vous permettant d'assigner une image et son texte associé à une position géographique. L'instance ItemizedOverlay prend en charge le dessin, le placement, la gestion des clics, le contrôle du focus et l'optimisation du layout de chaque OverlayItem.

Pour ajouter un marqueur ItemizedOverlay à votre carte, il est nécessaire de créer une nouvelle classe étendant ItemizedOverlay<OverlayItem>. En réalité, ItemizedOverlay est une classe générique qui vous permet de créer des extensions fondées sur n'importe quelle sous-classe dérivée d'OverlayItem.

Voici les différentes étapes de la manipulation de ce type de calque :

1. Comme nous venons de le dire, en premier lieu, une classe doit hériter de Itemized<OverlayItem>. Nous créons également un constructeur qui prendra en paramètre un objet de type Drawable. Cet objet est un marqueur qui mettra en valeur les points que nous souhaitons montrer (comme les bulles rouges de Google Maps).
2. Dans le constructeur, préparez tous les éléments OverlayItem (la localisation, un titre, un texte plus complet) et appeler la méthode populate() une fois qu'ils sont prêts.
3. Implémenter la méthode size() qui renvoie le nombre d'éléments du calque.
4. Redéfinir la méthode createItem() pour renvoyer les éléments OverlayItem un par un en fonction de l'index donné.
5. Instancier la classe ItemizedOverlay et l'ajouter aux calques de la vue.

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:padding="2px">
   <Button 
      android:id="@+id/recherche"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:text="Nouvelle position" 
      android:layout_alignParentBottom="true"
      android:onClick="localiser"/>    
   <com.google.android.maps.MapView 
      android:id="@+id/carte"   
      android:layout_width="fill_parent" 
      android:layout_height="fill_parent" 
      android:enabled="true"
      android:clickable="true"
      android:layout_above="@id/recherche"
      android:apiKey="0kHT1LZrcfaxP_vuzbfx3ScZMpYTT-8wmSDX2RA" />       
</RelativeLayout>

<?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"
    android:padding="2px">
   <EditText 
      android:id="@+id/rue"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"
      android:hint="Rue" />   
   <EditText 
      android:id="@+id/ville"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"
      android:hint="Ville" />                
   <Button 
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:text="Rechercher" 
      android:onClick="valider"/>         
</LinearLayout>

package fr.btsiris.localisation;

import android.content.*;
import android.graphics.drawable.Drawable;
import android.location.*;
import android.os.Bundle;
import android.view.View;
import android.widget.Toast;
import com.google.android.maps.*;
import java.io.IOException;
import java.util.*;

public class Cartographie extends MapActivity {
   private MapView carte;
   private MapController controleur;
   private MyLocationOverlay position;
   private Marqueur marqueurs;
   private LocationManager localisations;
   private ChangementPosition changements = new ChangementPosition();  
   private Intent intention;
   private Geocoder geocodage;
   
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);    
        intention = new Intent(this, NouvelleAdresse.class);
        carte = (MapView) findViewById(R.id.carte);
        carte.setBuiltInZoomControls(true);
        controleur = carte.getController();
        List<Overlay> calques = carte.getOverlays();
        position = new MyLocationOverlay(this, carte);
        calques.add(position);
        Drawable pastille = getResources().getDrawable(R.drawable.marqueur);
        marqueurs = new Marqueur(pastille, this);
        calques.add(marqueurs);
        geocodage = new Geocoder(this, Locale.FRANCE);
        localisations = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        miseAJourDeLaPosition(localisations.getLastKnownLocation(LocationManager.GPS_PROVIDER));
    }

    @Override
    protected boolean isRouteDisplayed() { return false; }
   
    @Override
    protected void onStart() {
        super.onStart();
        localisations.requestLocationUpdates(LocationManager.GPS_PROVIDER, 2000, 2, changements);   
        localisations.requestLocationUpdates(LocationManager.NETWORK_PROVIDER, 5000, 5, changements); 
        position.enableCompass();
        position.enableMyLocation();       
    }

    @Override
    protected void onStop() {
       super.onStop();
       localisations.removeUpdates(changements);
       position.disableCompass();
       position.disableMyLocation();
    } 
    
    private void miseAJourDeLaPosition(Location position) {
       if (position!=null) {
          Double lat = position.getLatitude() * 1E6;
          Double lng = position.getLongitude() * 1E6;
          GeoPoint point = new GeoPoint(lat.intValue(), lng.intValue());
          controleur.animateTo(point);
       }
    }        
    
    class ChangementPosition implements LocationListener {
       public void onLocationChanged(Location position) { miseAJourDeLaPosition(position);   }
       public void onStatusChanged(String fournisseur, int statut, Bundle extras) {  }
       public void onProviderEnabled(String fournisseur) {  }
       public void onProviderDisabled(String fournisseur) {  } 
    }   
    
    public void localiser(View bouton) {
       startActivityForResult(intention, 1);
    }

   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
      if (resultCode==RESULT_OK) {
         String endroit = data.getExtras().getString("localisation");
         try {
            List<Address> positions = geocodage.getFromLocationName(endroit, 1);
            if (positions.size() > 0) {
               Address localisation = positions.get(0);
               marqueurs.ajout(localisation);
            }
         } 
         catch (IOException ex) { Toast.makeText(this, "Non localisée", Toast.LENGTH_LONG).show(); }   
      }
   }  
}

package fr.btsiris.localisation;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;

public class NouvelleAdresse extends Activity {
   private EditText rue, ville;

   @Override
   public void onCreate(Bundle icicle) {
      super.onCreate(icicle);     
      setContentView(R.layout.adresses);
      rue = (EditText) findViewById(R.id.rue);
      ville = (EditText) findViewById(R.id.ville);
   }
   
   public void valider(View vue) {
      String adresse = rue.getText().toString() + ", " + ville.getText().toString() + ", France";
      getIntent().putExtra("localisation", adresse);
      setResult(RESULT_OK, getIntent());     
      finish();
   }
} 

package fr.btsiris.localisation;

import android.content.Context;
import android.graphics.Canvas;
import android.graphics.drawable.Drawable;
import android.location.Address;
import android.widget.Toast;
import com.google.android.maps.*;
import java.util.ArrayList;

public class Marqueur extends ItemizedOverlay<OverlayItem> {
   private ArrayList<OverlayItem> liste = new ArrayList<OverlayItem>();
   private Drawable image;
   private Context contexte;

   public Marqueur(Drawable image, Context contexte) {
      super(image);
      this.image = image;
      this.contexte = contexte;
      populate();
   }
   
   @Override
   protected OverlayItem createItem(int index) {
      return liste.get(index);
   }

   @Override
   public int size() {
      return liste.size();
   }  
   
   public void ajout(Address adresse) {
      Double latitude = adresse.getLatitude() * 1E6;
      Double longitude = adresse.getLongitude() * 1E6;
      GeoPoint point = new GeoPoint(latitude.intValue(), longitude.intValue());
      liste.add(new OverlayItem(point, adresse.getLocality(), adresse.getAddressLine(0)));
      populate();
   }

   @Override
   public void draw(Canvas canevas, MapView carte, boolean ombre) {
      super.draw(canevas, carte, ombre);
      boundCenterBottom(image);
   }

   @Override
   protected boolean onTap(int index) {
      OverlayItem marque = liste.get(index);
      String texte = marque.getTitle() +'\n'+ marque.getSnippet() + '\n'+ marque.routableAddress();
      Toast.makeText(contexte, texte, Toast.LENGTH_LONG).show();
      return true;
   }
}

Epingler des Views à une carte et à des positions

Vous avez la possibilité d'épingler n'importe quel objet dérivé d'une View à une MapView (y compris les layouts et autres ViewGroup) en l'attachant à une position à l'écran ou géographique.

Dans le dernier cas, la view se déplacera pour suivre sa position épinglée sur la carte, agissant comme un véritable marqueur interactif. Cette solution consommant plus de ressources, elle est habituellement réservée à l'affichage de détails dans une bulle affichée pour fournir des informations complémentaires lorsque nous cliquons sur un marqueur.

1. Vous pouvez implémenter les deux mécanismes en appelant addView() sur la carte, en général depuis les méthodes onCreate() ou onRestore() dans l'activité la contenant. Passer la vue que vous désirez épingler ainsi que les paramètres de layout à utiliser.
2. Les paramètres MapView.LayoutParams que vous passerez à la méthode addView() déterminent comment la vue est ajoutée à la carte.
3. Pour ajouter une nouvelle View relativement à l'écran, spécifiez un nouveau MapView.LayoutParams contenant les arguments correspondant à la hauteur et à la largeur de la View, les coordonnées cibles (x, y) de l'écran et l'alignement à utiliser pour le positionnement.
4. Pour épingler une View relativement à une position géographique, passez quatre paramètres dans MapView.LayoutParams, représentant la hauteur, la largeur, le GeoPoint cible et l'alignement du layout.
5. Un panoramique de la carte laissera la première TextView en place dans le coin supérieur gauche alors que la seconde se déplacera pour rester épinglée à sa position.
6. Pour supprimer une View d'une MapView, appelez la méthode removeView() en passant l'instance de View que vous voulez supprimer.

Capteurs, accéléromètre (Dessins 2D - Drawables)

Les dernières générations de téléphones tentent d'embarquer de plus en plus de fonctionnalités matérielles : GPS, boussole, gyroscope, Wi-Fi, Bluetooth, capteur magnétique, capteur de température, etc. Bien évidemment, en tant que dévelopeur, vous comprendrez immédiatement que ce sont autant d'opportunités de créer des applications toujours plus immersives, communicantes et interactives !

Nous allons découvrir dans ce chapitre les capteurs existant sous Android et comment utiliser le Sensor Manager pour les monitorer. Nous examinerons de près l'accéléromètre et les capteurs d'orientation et les utiliserons pour déterminer les changements dans l'orientation de l'appareil ainsi que l'accélération. Ceci sera particulièrement utile pour créer des interfaces utilisateur basées sur le mouvement et vous permettra de donnéer une nouvelle dimension à vos applications basées sur la géolocalisation.

Les ressources disponibles sur un appareil Android

La plate-forme Android gère de façon native bon nombre de ressources matérielles telles que le clavier et le trackball qui ne nécessitent pas vraiment d'adaptation lorsque ceux-ci ne sont pas disponibles sur le terminal. Par exemple, le clavier physique sera remplacé par un clavier virtuel sans avoir besoin de reprogrammer l'interface utilisateur.

Liste des principales ressources utilisables depuis Android

Affichage

- Appareil photo
- 3D

Entrées

- Clavier
- Matrice tactile
- Boule de commande (trackball)

Son

- Haut parleur / Microphone
- Reconnaissance vocale
- Vibration

Réseau

- 3G
- Wi-Fi
- Bluetooth
- GPS

Capteurs

- Accéléromètre
- Orientation
- Champ magnétique
- Température

Les capteurs

Une bonne partie du succès des terminaux modernes est la gestion du mouvement. Cela ne serait pas possible sans l'extraordinaire démocratisation des capteurs embarqués. Désormais, votre appareil détecte le mouvement et peut se situer dans l'espace. Voyons comment tout cela fonctionne sur Android, en créant un projet qui utilise les capteurs.

Comme pour les services de géolocalisation, Android rend abstraites les implémentations des capteurs de chaque appareil. La classe Sensor est utilisée pour décrire les propriétés de chaque capteur matériel, comme son type, son nom, son fabricant et ses détails de précision et de portée.

Identification des capteurs

Le panel des capteurs s'est étoffé avec les versions successives d'Android : accéléromètre, capteur de pression, capteur de proximité... Ceci dit, il ne faut pas croire que tous les capteurs sont disponibles sur tous les terminaux, loin de là !

L'API d'Android 1.6 a donc introduit une nouvelle classe Sensor responsable de la récupération des données, sous la houlette d'un autre classe nommée SensorManager qui comme son nom l'indique chapeaute le groupe de capteurs au travers d'un service commun à tout le système. SensorManager est ainsi utilisé pour gérer l'ensemble des capteurs disponibles sur les appareils Android.

Utilisez la méthode getSystemService() pour renvoyer une référence vers le service SensorManager :

SensorManager gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);

Ensuite, la classe Sensor contient un ensemble de constantes utilisées pour décrire quel type de capteur matériel est représenté par un objet de type Sensor. Ces constantes sont de la forme Sensor.TYPE_<Type>. La section suivante décrit chaque type de capteur supporté. Vous apprendrez ensuite comment trouver et utiliser chacun d'eux.

Liste des différents types de capteurs disponibles

Sensor.TYPE_ACCELEROMETER

Permet d'évaluer les mouvements du terminal ou tout simplement la gravité. Accéléromètre à trois axes renvoyant l'accélération courante en m/s².

Sensor.TYPE_GYROSCOPE

Permet de connaître la position angulaire en degré du terminal en fonction des trois axes x, y et z.

Sensor.TYPE_LIGHT

Le capteur de lumière permet d'évaluer l'exposition lumineuse subie par le terminal. Capteur de lumière ambiante renvoyant une valeur exprimée en lux. Le capteur de lumière est couramment utilisé pour contrôler la luminosité de l'écran.

Sensor.TYPE_MAGNETIC_FIELD

Permet de détecter les modifications des champs magnétiques environnants. Capteur de champ magnétique renvoyant le champ en microteslas suivant les trois axes.

Sensor.TYPE_ORIENTATION

Permet de déterminer la position du terminal en fonction des trois axes x, y et z.

Sensor.TYPE_PRESSURE

Indique la pression atmosphérique. Capteur de pression renvoyant une valeur exprimée en kilopascals.

Sensor.TYPE_PROXIMITY

Indique la distance du terminal par rapport à un objet. Capteur de proximité indiquant la distance entre l'appareil et un objet cible en mètres. La façon dont l'objet est sélectionné et la distance supportée dépendront de l'implémentation matérielle du détecteur de proximité. Un usage typique est la détection de l'approche de l'appareil de l'oreille de l'utilisateur, l'ajustement automatique de la luminosité de l'écran ou le lancement d'une commande vocale.

Sensor.TYPE_TEMPERATURE

Indique la température à proximité du capteur. Thermomètre renvoyant la température en degré Celsius. Il peut s'agir de la température ambiante, de celle de la batterie ou d'un capteur distant en fonction de l'implémentation matérielle.

Trouver les capteurs

Un appareil Android peut contenir plusieurs implémentations d'un type de capteur particulier. Pour déterminer l'implémentation par défaut, utilisez la méthode getDefaultSensor() issue de la classe SensorManager en lui passant le type de capteur requis sous la forme d'une des constantes décrites dans la section précédente.

Si le capteur n'est pas disponible sur le terminal, la méthode getDefaultSensor() renverra une valeur null nous permettant d'agir en conséquence.

SensorManager gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);
Sensor gyroscope = gestionCapteurs.getDefaultSensor(Sensor.TYPE_GYROSCOPE);

De façon alternative, utilisez plutôt la méthode getSensorList() pour renvoyer la liste de tous les capteurs d'un type donné comme dans le code suivant, qui renvoie tous les capteurs de pression :

SensorManager gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);
List<Sensor> capteursPression = gestionCapteurs.getSensorList(Sensor.TYPE_PRESSURE);

Enfin, pour déterminer tous les capteurs disponibles sur une plate-forme hôte, utilisez de nouveau la méthode getSensorList(), en lui passant cette fois-ci la constante Sensor.TYPE_ALL. Cette technique vous permet de déterminer quels capteurs et types de capteurs sont disponibles sur l'appareil.

SensorManager gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);
List<Sensor> capteurs = gestionCapteurs.getSensorList(Sensor.TYPE_ALL);

<?xml version="1.0" encoding="utf-8"?>
<ListView xmlns:android="http://schemas.android.com/apk/res/android"  
    android:id="@android:id/list"
    android:layout_width="fill_parent" 
    android:layout_height="fill_parent" 
/>

package fr.btsiris.capteurs;

import android.app.ListActivity;
import android.content.Context;
import android.hardware.*;
import android.os.Bundle;
import android.widget.ArrayAdapter;
import java.util.List;

public class Capteur extends ListActivity {
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      SensorManager gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);
      List<Sensor> capteurs = gestionCapteurs.getSensorList(Sensor.TYPE_ALL);
      String[] listeCapteurs = new String[capteurs.size()];
      for (int i=0; i<capteurs.size(); i++) listeCapteurs[i] = capteurs.get(i).getName();
      setListAdapter(new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, listeCapteurs));
   }
}

Comment utiliser les capteurs

Pour accéder aux capteurs, après avoir récupérer l'instance du service, vous devez vous abonner aux événements du capteur qui vous intéressent.

Pour cela, vous devez implémenter l'interface SensorEventListener et redéfinir les méthodes adpatées à ce type d'événements, d'une part la méthode onSensorChanged() pour monitorer les valeurs du capteur et d'autre part la méthode onAccuracyChanged() pour réagir à ses changements de précision.

class Scrutation implements SensorEventListener {
    public void onSensorChanged(SensorEvent evt) {
       // A faire : Monitorer les changements dans le capteur
    }

    public void onAccuracyChanged(Sensor capteur, int accuracy) {
       // A faire : Réagir aux demandes de changement de précision du capteur
    }
}

Le paramètre de type SensorEvent dans la méthode onSensorChanged() contient quatre propriétés utilisées pour décrire un événement particulier du capteur.

Paramètres de SensorEvent

sensor

L'objet de type Sensor ayant déclanché l'événement.

accuracy

La précision du capteur lorsque l'événement est survenu (faible, moyenne, haute ou non fiable).

values

Tableau de flottants contenant la ou les nouvelles valeurs détectées.

timestamp

L'horodatage (en nanosecondes) auquel l'événement est survenu.

Vous pouvez monitorer séparément les changements dans la précision d'un capteur en utilisant la méthode onAccuracyChanged(). Dans les deux gestionnaires, la valeur accuracy représente la précision du capteur monitoré sous la forme de constantes prédéfinies dont la liste est proposée ci-dessous.

Précision du capteur

SensorManager.SENSOR_STATUS_ACCURACY_LOW

Indique que le capteur possède une faible précision et doit être recalibré.

SensorManager.SENSOR_STATUS_ACCURACY_MEDIUM

Indique que les données du capteur sont de précision intermédiaire et qu'une recalibration améliorerait la lecture.

SensorManager.SENSOR_STATUS_ACCURACY_HIGH

Indique que le capteur a la précision la plus élevée possible.

SensorManager.SENSOR_STATUS_UNRELIABLE

Indique que les données du capteur ne sont pas fiable et qu'une calibration est nécessaire ou que la lecture n'est pas possible.

Pour obtenir les données, nous devons nous enregistrer auprès du service comme écouteur de type SensorEventListener à l'aide de la méthode registerListener() de la classe SensorManager. Spécifiez alors le capteur à observer et la fréquence à laquelle vous voulez recevoir les mises à jour.

SensorManager gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);
Sensor gyroscope = gestionCapteurs.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
Scrutation scrutation = new Scrutation();
gestionCapteurs.registerListener(scrutation, gyroscope, SensorManager.SENSOR_DELAY_NORMAL);

Comme nous le constatons, la récupération d'une instance de capteur s'associe à un taux de rafraîchissement des données qui peut être plus ou moins précis. Ce taux influence directement les performances de l'application ainsi que l'usage de la batterie. Plus le taux est élévé, plus les données sont rafraîchies et précises, et plus la consommation d'énergie est élevée. Le SensorManager contient les constantes suivantes (dans l'ordre décroissant de réactivité) pour sélectionner une fréquence appropriée :

Taux de rafraîchissement des mesures effectuées

SensorManager.SENSOR_DELAY_FASTER

Le taux de rafraîchissement le plus élevé. Les données sont récupérées aussi vite que possible par le système.

SensorManager.SENSOR_DELAY_GAME

Taux utilisable pour des applications nécessitant des données précises telles que les jeux.

SensorManager.SENSOR_DELAY_NORMAL

Taux normal utilisé par exemple par le système pour détecter les changements d'orientation.

SensorManager.SENSOR_DELAY_UI

Le taux le plus bas utilisé dans les applications ne nécessitant qu'une faible précision ou ne sollicitant que très peu de données, comme les composants graphiques d'une interface utilisateur.

La fréquence que vous sélectionnez n'est pas obligatoire. Le SensorManager peut répondre plus ou moins vite que ce que vous avez spécifié, mais il a tendance à être plus rapide. Pour minimiser le coût en ressources d'utilisation d'un capteur dans votre application, sélectionnez la fréquence la plus faible.

Il est également important de désenregistrer votre SensorEventListener lorsque votre application n'a plus besoin de recevoir de mise à jour, en utilisant la méthode opposée unregisterListener(). Il est d'ailleurs conseillé d'enregistrer et de désenregistrer votre SensorEventListener dans les méthodes de rappel onResume() et onPause() de vos activités pour garantir qu'ils ne sont utilisés que lorsque votre activité est active.

Interpréter les valeurs des capteurs

La longueur et la composition des valeurs renvoyées par l'événement onSensorChanged() varient selon le capteur monitoré. Les détails sont donnés ci-dessous. Des détails complémentaires , du capteur d'orientation et du capteur de champ magnétique seront donnés dans les sections suivantes.

Utiliser le compas, l'accéléromètre et les capteurs d'orientation

La prise en compte du mouvement au sein des applications est possible grâce à la présence du capteur d'orientation et de l'accéléromètre dans la plupart des appareils récents. Ces dernières années, ces capteurs sont devenus de plus en plus répandus et ont trouvé leur place dans les manettes de contrôle de jeux et les smartphones.

Les accéléromètres et les compas sont utilisés pour fournir des fonctionnalités fondées sur la direction, l'orientation et le mouvement de l'appareil. La disponibilté d'un compas et d'un accéléromètre dépend du matériel sur lequel votre application est exécutée. Lorsqu'ils sont disponibles, ils sont exposés via le SensorManager, vous permettant de :

1. Déterminer l'orientation courante de l'appareil.
2. Monitorer et tracer les changements d'orientation.
3. Savoir à quelle direction l'utilisateur fait face.
4. Monitorer l'accélération dans toutes les directions : verticale, latérale ou longitudinale.

Cela ouvre quelques perspectives inhabituelles à vos applications. En monitorant l'orientation, la direction et le mouvement, vous pouvez :

1. Utiliser le compas et l'accéléromètre pour déterminer votre vitesse et votre direction. En conjonction avec une carte, un appareil photo et des services de géolocalisation, vous pouvez créer des interfaces en réalité augmentée qui rajoutent des données locales à un flux temps réel de l'appareil photo.
2. Créer des interfaces utilisateur s'ajustant dynamiquement à l'orientation de l'appareil. Android modifie déjà l'orientation de l'écran natif lorsque l'appareil passe du mode portrait au mode paysage et inversement.
3. Monitorer une accélération rapide pour déterminer si l'appareil tombe ou est lancé.
4. Mesurer le mouvement ou la vibration. Vous pourrez par exemple créer une application qui vous permet de vérouiller l'appareil. Si un mouvement est détecté pendant qu'il est vérouillé, une alerte SMS contenant la position courante peut être envoyée.
5. Créer des contrôles d'interface utilisateur qui utilisent les gestes et les mouvements comme mode d'entrée.

Vous devrez toujours vérifier la disponibilité des capteurs requis et vous assurer que votre application se terminera proprement s'ils sont absents.

Introduction aux accéléromètres

Les accéléromètres, comme leur nom l'indique, sont utilisés pour mesurer l'accélération. Ils sont aussi parfois nommés capteurs de gravité.

Les accéléromètres sont appelés capteurs de gravité en raison de leur incapacité à distinguer une accélération due à un mouvement d'une accélération due à la gravité. Par conséquent, une accélération détectant une accélération sur l'axe z (vertical) lira -9.81 m/s² lorsque l'appareil sera immobile (cette valeur est disponible dans la constante SensorManager.STANDARD_GRAVITY).

L'accélération est définie comme la modification de la vitesse d'un mouvement et les accéléromètres mesureront donc comment la vitesse de l'appareil change dans une direction donnée. En utilisant un accéléromètre, vous pourrez détecter les mouvements et, plus utilement, la variation de leur vitesse.

Il est important de noter que les accéléromètres ne mesurent pas la vélocité, et vous ne pourrez donc pas mesurer directement la vitesse par une seule lecture de l'accéléromètre. A la place, vous devrez mesurer les changements d'accélération dans le temps.

Généralement, vous serez intéressé par les changements d'accélération par rapport à un état repos ou par des mouvements rapides (repérables par des changements rapides dans l'accélération) comme des gestes de l'utilisateur. Dans le premier cas, vous devrez souvent calibrer l'appareil pour calculer l'orientation et l'accélération initiales afin de les prendre en compte dans les résultats futurs.

Détecter les changements d'accélération

Comme nous l'avons découvert dans le tableau un peu plus haut, le SensorManager renvoie les modifications selon trois axes. Les valeurs de la propriété values du paramètre de type SensorEvent issu de l'écouteur SensorEventListener représente latérale, longitudinale et verticale dans cet ordre.

Le SensorManager considère qu'un appareil est "au repos" lorsqu'il est posé face vers le haut en mode portrait sur une surface plane. L'accélération peut donc être mesurée selon trois directions :

1. latéral : gauche-droite : Accélération vers la gauche ou la droite, les valeurs positives représentent la droite et les négatives, la gauche. Une accélération latérale positive sera détectée sur un appareil posé à plat sur son dos en mode portrait et déplacé vers la droite.
2. longitudinal : avant-arriere : Accélération vers l'avant ou vers l'arrrière, une valeur positive représentant l'avant. Dans la même configuration que ci-dessus, une accélération longitudinale positive sera créée en déplaçant l'appareil vers l'avant.
3. verticale : haut-bas : Accélération vers le haut ou vers le bas, une valeur positive représentant le haut. Au repos, l'accéléromètre enregistre une valeur de 9.81 m/s² du fait de la gravité.

Comme nous l'avons décrit plus haut, vous pouvez monitorer les changements dans l'accélération en utilisant un SensorEventListener. Enregistrer une implémentation de ce type d'écouteur avec le SensorManager en utilisant un objet Sensor de type Sensor.TYPE_ACCELEROMETER pour interroger l'accéléromètre.

<?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"
    android:padding="2px"
    android:background="#FFFF00" >
   <TextView 
      android:id="@+id/lateral"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"
      android:textSize="23dp"
      android:textColor="#FF4400" />   
   <TextView 
      android:id="@+id/longitudinal"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"
      android:textSize="23dp"
      android:textColor="#FF4400" /> 
   <TextView 
      android:id="@+id/vertical"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"
      android:textSize="23dp"
      android:textColor="#FF4400" />       
</LinearLayout>

package fr.btsiris.capteurs;

import android.app.Activity;
import android.content.Context;
import android.hardware.*;
import android.os.Bundle;
import android.widget.TextView;

public class Accelerometre extends Activity implements SensorEventListener {
   private SensorManager gestionCapteurs;
   private Sensor accelerometre;
   private TextView lateral, longitudinal, vertical;
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      lateral = (TextView) findViewById(R.id.lateral);
      longitudinal = (TextView) findViewById(R.id.longitudinal);
      vertical = (TextView) findViewById(R.id.vertical);
      gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);     
      accelerometre = gestionCapteurs.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
   }

   @Override
   protected void onStart() {
      super.onStart();
      gestionCapteurs.registerListener(this, accelerometre, SensorManager.SENSOR_DELAY_NORMAL);
   }

   @Override
   protected void onStop() {
      super.onStop();
      gestionCapteurs.unregisterListener(this);
   }   
   
   public void onSensorChanged(SensorEvent evt) {
      if (evt.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
         lateral.setText("Latéral ........... : "+evt.values[0]);
         longitudinal.setText("Longitudinal ... : "+evt.values[1]);
         vertical.setText("Vertical .......... : "+evt.values[2]);
      }
   }

   public void onAccuracyChanged(Sensor capteur, int precision) {   }
}

<?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:id="@+id/acceleration"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:gravity="center"
      android:textStyle="bold"
      android:textSize="32sp"
      android:text="CENTRE"
      android:editable="false"
      android:singleLine="true"
      android:layout_margin="10px" />
    <TextView  
      android:id="@+id/accelerationMax"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:gravity="center"
      android:textStyle="bold"
      android:textSize="40sp"
      android:text="CENTRE"
      android:editable="false"
      android:singleLine="true"
      android:layout_margin="10px"  />     
</LinearLayout>

package fr.btsiris.capteurs;

import android.app.Activity;
import android.content.Context;
import android.hardware.*;
import android.os.Bundle;
import android.widget.TextView;
import java.util.Timer;
import java.util.TimerTask;

public class Gravitation extends Activity implements SensorEventListener {
   private SensorManager gestionCapteurs;
   private Sensor accelerometre;
   private TextView acceleration, accelerationMax;
   private float courante, maxi;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      acceleration = (TextView) findViewById(R.id.acceleration);
      accelerationMax = (TextView) findViewById(R.id.accelerationMax);
      gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);     
      accelerometre = gestionCapteurs.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
      Timer update = new Timer("update");
      update.scheduleAtFixedRate(new TimerTask() {
         @Override
         public void run() {
            miseAJour();
         }
      }, 0, 300);
   }

   @Override
   protected void onStart() {
      super.onStart();
      gestionCapteurs.registerListener(this, accelerometre, SensorManager.SENSOR_DELAY_FASTEST);
   }

   @Override
   protected void onStop() {
      super.onStop();
      gestionCapteurs.unregisterListener(this);
   }   
   
   public void onSensorChanged(SensorEvent evt) {
      float x = evt.values[0];
      float y = evt.values[1];
      float z = evt.values[2];
      float resultante = (float) Math.sqrt(x*x + y*y + z*z);
      courante = Math.abs(resultante-SensorManager.STANDARD_GRAVITY);
      if (courante > maxi) maxi = courante;
   }

   public void onAccuracyChanged(Sensor capteur, int precision) { }
   
   private void miseAJour() {
      runOnUiThread(new Runnable() {
         public void run() {
            String Gs = ""+courante / SensorManager.STANDARD_GRAVITY ;
            acceleration.setText(Gs);
            acceleration.invalidate();            
            String Gmax = "Max = "+ maxi / SensorManager.STANDARD_GRAVITY;
            accelerationMax.setText(Gmax);
            accelerationMax.invalidate();      
         }
      });
   }
}  

Déterminer votre orientation

Le capteur d'orientation est une combinaison de capteurs de champ magnétique qui fonctionne comme un compas électronique et un accéléromètre pour déterminer le tangage et le roulis.

En réalité, Android fournit deux alternatives pour déterminer l'orientation de l'appareil. Vous pouvez directement interroger le capteur d'orientation ou dériver celle-ci de l'accéléromètre et du capteur de champ magnétique. La dernière option prend plus de temps mais offre l'avantage d'une plus grande précision et de pouvoir modifier la trame de référence lorsque vous déterminer votre orientation.

En utilisant la trame de référence standard, l'orientation de l'appareil est donnée selon trois dimensions comme l'illustre la liste ci-dessous :

1. Azimut : Axe qui pointe vers le haut : L'azimut (ou lacet) est la direction à laquelle l'appareil fait face suivant l'axe des x où 0/360 degrés est le nord, 90 degré l'est, 180 degré le sud et 270 degré l'ouest.
2. Tangage : Axe qui pointe vers l'avant : Le tangage représente l'ange de l'appareil autour de l'axe des y. Lorsque l'appareil est à plat sur son dos, la valeur est 0. Lorsqu'il est "debout" (sommet de l'appareil vers le haut), la valeur est -90. Lorsqu'il est vers le bas, la valeur est 90 et 180/-180 lorsqu'il est retourné.
3. Roulis : Axe qui pointe vers le côté droit : Le roulis représente le mouvement de l'appareil autour de l'axe des z. Lorsque l'appareil est posé à plat sur son dos, la valeur est 0, -90 lorsque l'écran fait face à la gauche et 90 lorsque l'écran fait face à la droite.

Déterminer l'orientation avec le capteur d'orientation

La façon la plus simple de monitorer l'orientation de l'appareil est d'utiliser le capteur d'orientation dédié. Créer et enregistrer un SensorEventListener avec le SensorManager en utilisant le capteur d'orientation par défaut.

SensorManager gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);
Sensor orientation = gestionCapteurs.getDefaultSensor(Sensor.TYPE_ORIENTATION);
gestionCapteurs.registerListener(this, orientation, SensorManager.SENSOR_DELAY_NORMAL);

Lorsque l'orientation change, la méthode onSensorChanged() de votre SensorEventListener est déclenchée. Le paramètre SensorEvent contient un tableau de float qui fournit l'orientation de l'appareil suivant les trois axes, respectivement l'azimut, le tangage et le roulis.

<?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"
    android:padding="10dp"
    android:background="#FFFF00">
   <TextView 
      android:id="@+id/azimut"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"      
      android:textSize="23dp"
      android:textColor="#FF4400"/>   
   <TextView 
      android:id="@+id/tangage"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"
      android:textSize="23dp"
      android:textColor="#FF4400" /> 
   <TextView 
      android:id="@+id/roulis"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content" 
      android:textSize="23dp"
      android:textColor="#FF4400"/>       
</LinearLayout>

package fr.btsiris.orientation;

import android.app.Activity;
import android.content.Context;
import android.hardware.*;
import android.os.Bundle;
import android.widget.TextView;

public class Orientation extends Activity implements SensorEventListener {
   private SensorManager gestionCapteurs;
   private Sensor orientation;
   private TextView azimut, tangage, roulis;
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      azimut = (TextView) findViewById(R.id.azimut);
      tangage = (TextView) findViewById(R.id.tangage);
      roulis = (TextView) findViewById(R.id.roulis);
      gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);     
      orientation = gestionCapteurs.getDefaultSensor(Sensor.TYPE_ORIENTATION);
   }

   @Override
   protected void onStart() {
      super.onStart();
      gestionCapteurs.registerListener(this, orientation, SensorManager.SENSOR_DELAY_NORMAL);
   }

   @Override
   protected void onStop() {
      super.onStop();
      gestionCapteurs.unregisterListener(this);
   }   
   
   public void onSensorChanged(SensorEvent evt) {
      if (evt.sensor.getType() == Sensor.TYPE_ORIENTATION) {
         azimut.setText("Azimut ........... : "+evt.values[0]);
         tangage.setText("Tangage ... : "+evt.values[1]);
         roulis.setText("Roulis .......... : "+evt.values[2]);
      }
   }

   public void onAccuracyChanged(Sensor capteur, int precision) {   }
}

<?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"
    android:background="#FFFF00">
   <TextView  
      android:id="@+id/azimut"
      android:layout_width="fill_parent" 
      android:layout_height="wrap_content"
      android:textSize="28sp"
      android:textStyle="italic|bold"
      android:textColor="#000000"
      android:gravity="center" />       
   <ImageView  
      android:layout_width="wrap_content" 
      android:layout_height="wrap_content"
      android:layout_gravity="center"
      android:src="@drawable/rosedesvents" />
</LinearLayout>

package fr.btsiris.cardinaux;

import android.app.Activity;
import android.content.Context;
import android.hardware.*;
import android.os.Bundle;
import android.widget.TextView;

public class PointsCardinaux extends Activity implements SensorEventListener {
   private SensorManager gestionCapteurs;
   private Sensor orientation;
   private TextView azimut;
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      azimut = (TextView) findViewById(R.id.azimut);
      gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);     
      orientation = gestionCapteurs.getDefaultSensor(Sensor.TYPE_ORIENTATION);
   }

   @Override
   protected void onStart() {
      super.onStart();
      gestionCapteurs.registerListener(this, orientation, SensorManager.SENSOR_DELAY_FASTEST);
   }

   @Override
   protected void onStop() {
      super.onStop();
      gestionCapteurs.unregisterListener(this);
   }   
   
   public void onSensorChanged(SensorEvent evt) {
      if (evt.sensor.getType() == Sensor.TYPE_ORIENTATION) {
         String cap = "";
         float x = evt.values[0];
         if (x<11.25 || x>=348.75) cap ="Nord";
         else if (x>11.25 && x<33.75) cap ="Nord-Nord-Est";
         else if (x>33.75 && x<56.25) cap ="Nord-Est";
         else if (x>56.25 && x<78.75) cap ="Est-Nord-Est";
         else if (x>78.75 && x<101.25) cap ="Est";
         else if (x>101.25 && x<123.75) cap ="Est-Sud-Est";
         else if (x>123.75 && x<146.25) cap ="Sud-Est";
         else if (x>146.25 && x<168.75) cap ="Sud-Sud-Est";
         else if (x>168.75 && x<191.25) cap ="Sud";
         else if (x>191.25 && x<213.75) cap ="Sud-Sud-Ouest";
         else if (x>213.75 && x<236.25) cap ="Sud-Ouest";
         else if (x>236.25 && x<258.75) cap ="Ouest-Sud-Ouest";
         else if (x>258.75 && x<281.25) cap ="Ouest";
         else if (x>281.25 && x<303.75) cap ="Ouest-Nord-Ouest";
         else if (x>303.75 && x<326.25) cap ="Nord-Ouest";
         else if (x>326.25 && x<348.75) cap ="Nord-Nord-Ouest";
         azimut.setText(cap);
      }
   }

   public void onAccuracyChanged(Sensor capteur, int precision) {   }
}

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="fr.btsiris.compas"
      android:versionCode="1"
      android:versionName="1.0">
    <application android:label="Boussole" >
        <activity android:name="Compas"  android:label="Boussole" android:screenOrientation="portrait">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

<?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"
    android:padding="5dp"
    android:background="#FFBB00" >
   <fr.btsiris.compas.VueCompas
      android:id="@+id/boussole"
      android:layout_width="fill_parent" 
      android:layout_height="fill_parent" />
</LinearLayout>

package fr.btsiris.compas;

import android.app.Activity;
import android.content.Context;
import android.hardware.*;
import android.os.Bundle;

public class Compas extends Activity implements SensorEventListener {
   private VueCompas boussole;
   private SensorManager gestionCapteurs;
   private Sensor orientation;
   
   @Override
   public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.main);
      boussole = (VueCompas) findViewById(R.id.boussole);
      gestionCapteurs =  (SensorManager) getSystemService(Context.SENSOR_SERVICE);     
      orientation = gestionCapteurs.getDefaultSensor(Sensor.TYPE_ORIENTATION);
   }

   @Override
   protected void onStart() {
      super.onStart();
      gestionCapteurs.registerListener(this, orientation, SensorManager.SENSOR_DELAY_FASTEST);
   }

   @Override
   protected void onStop() {
      super.onStop();
      gestionCapteurs.unregisterListener(this);
   }   
      
   public void onSensorChanged(SensorEvent evt) {
      if (evt.sensor.getType() == Sensor.TYPE_ORIENTATION) {
         boussole.setAzimut(evt.values[0]);
         boussole.invalidate();
      }
   }

   public void onAccuracyChanged(Sensor capteur, int precision) { }
}

package fr.btsiris.compas;

import android.content.Context;
import android.graphics.*;
import android.util.AttributeSet;
import android.view.View;

public class VueCompas extends View {
   private Paint texte, cercle, marque;
   private int hauteurTexte;
   private float azimut;

   public void setAzimut(float azimut) { this.azimut = azimut;  }

   public VueCompas(Context context, AttributeSet attrs, int defStyle) {
      super(context, attrs, defStyle);
      init();
   }

   public VueCompas(Context context, AttributeSet attrs) {
      super(context, attrs);
      init();
   }

   public VueCompas(Context context) {
      super(context);
      init();
   }

   private void init() {
      cercle = new Paint(Paint.ANTI_ALIAS_FLAG); 
      cercle.setColor(Color.RED);
      texte =  new Paint(Paint.ANTI_ALIAS_FLAG);
      texte.setColor(Color.YELLOW);
      texte.setTextSize(20);
      hauteurTexte = (int) texte.measureText("yY");
      marque =  new Paint(Paint.ANTI_ALIAS_FLAG);
      marque.setColor(Color.YELLOW);
      marque.setStrokeWidth(3);
   }

   @Override
   protected void onMeasure(int largeur, int hauteur) {
      int dimension = Math.min(mesure(largeur), mesure(hauteur));
      setMeasuredDimension(dimension, dimension);
   }

   private int mesure(int dimension) {
      int modeMesure = MeasureSpec.getMode(dimension);
      int tailleMesure = MeasureSpec.getSize(dimension);
      if (modeMesure == MeasureSpec.UNSPECIFIED) return 200;
      else return tailleMesure;
   }
   
   @Override
   protected void onDraw(Canvas canvas) {
      int px = getMeasuredWidth() / 2;
      int py = getMeasuredHeight() / 2;
      int rayon = Math.min(py, py);
      canvas.drawCircle(px, py, rayon, cercle);
      canvas.save();
      canvas.rotate(-azimut, px, py);
      int largeurTexte = (int) texte.measureText("O");
      int cardinalX = px - largeurTexte / 2;
      int cardinalY = py - rayon+hauteurTexte;
      for (int i=0; i<8; i++) {
         canvas.drawLine(px, py-rayon, px, py-rayon+15, marque);
         canvas.save();
         canvas.translate(0, hauteurTexte);
         String[] cap = {"N", "NE", "E", "SE", "S", "SO", "O", "NO"};       
         if (i==0) {
               int flecheY = 2*hauteurTexte;
               canvas.drawLine(px, flecheY, px-5, 3*hauteurTexte, marque);
               canvas.drawLine(px, flecheY, px+5, 3*hauteurTexte, marque);
               canvas.drawLine(px, flecheY, px, 6*hauteurTexte, marque);
         }
         canvas.drawText(cap[i], cardinalX, cardinalY, texte);
         canvas.restore();
         canvas.rotate(45, px, py);
      }
      canvas.restore();
   }     
} 

package fr.btsiris.compas;

import android.content.Context;
import android.graphics.*;
import android.util.AttributeSet;
import android.view.View;

public class VueCompas extends View {
   private Paint texte, cercle, marque;
   private int hauteurTexte;
   private float azimut;
   private float tangage;
   private float roulis;

   public float getAzimut() { return azimut;  }
   public void setAzimut(float azimut) { this.azimut = azimut;  }

   public float getRoulis() { return roulis;  }
   public void setRoulis(float roulis) { this.roulis = roulis; }

   public float getTangage() { return tangage;  }
   public void setTangage(float tangage) { this.tangage = tangage;  }

   public VueCompas(Context context, AttributeSet attrs, int defStyle) {
      super(context, attrs, defStyle);
      init();
   }

   public VueCompas(Context context, AttributeSet attrs) {
      super(context, attrs);
      init();
   }

   public VueCompas(Context context) {
      super(context);
      init();
   }

   private void init() {
      setFocusable(true);
      cercle = new Paint(Paint.ANTI_ALIAS_FLAG); // Mise en place de l'anti-aliasing pout ne pas avoir d'effet d'escalier dans les tracés
      cercle.setColor(Color.RED);
      cercle.setStrokeWidth(1); // dimension du trait (STROKE)
      cercle.setStyle(Paint.Style.FILL_AND_STROKE);  // le bord et le contenu va être pris en compte
      texte =  new Paint(Paint.ANTI_ALIAS_FLAG);
      texte.setColor(Color.YELLOW);
      hauteurTexte = (int) texte.measureText("yY");
      marque =  new Paint(Paint.ANTI_ALIAS_FLAG);
      marque.setColor(Color.YELLOW);
   }

   @Override
   protected void onMeasure(int largeur, int hauteur) {
      int dimension = Math.min(mesure(largeur), mesure(hauteur));
      setMeasuredDimension(dimension, dimension);
   }

   private int mesure(int dimension) {
      int modeMesure = MeasureSpec.getMode(dimension);
      int tailleMesure = MeasureSpec.getSize(dimension);
      if (modeMesure == MeasureSpec.UNSPECIFIED) return 200;
      else return tailleMesure;
   }
   
   @Override
   protected void onDraw(Canvas canvas) {
      int px = getMeasuredWidth() / 2;
      int py = getMeasuredHeight() / 2;
      int rayon = Math.min(py, py);
      canvas.drawCircle(px, py, rayon, cercle);
      canvas.save();
      canvas.rotate(-azimut, px, py);
      int largeurTexte = (int) texte.measureText("O");
      int cardinalX = px - largeurTexte / 2;
      int cardinalY = py - rayon+hauteurTexte;
      for (int i=0; i<24; i++) {
         canvas.drawLine(px, py-rayon, px, py-rayon+10, marque);
         canvas.save();
         canvas.translate(0, hauteurTexte);
         if (i % 6 == 0) {
            String cap = "";
            switch (i) {
               case 0 : 
                  cap = "N";
                  int flecheY = 2*hauteurTexte;
                  canvas.drawLine(px, flecheY, px-5, 3*hauteurTexte, marque);
                  canvas.drawLine(px, flecheY, px+5, 3*hauteurTexte, marque);
                  break;

               case 6 : cap = "E"; break;
               case 12 : cap = "S"; break;
               case 18 : cap = "O"; break;
            }
            canvas.drawText(cap, cardinalX, cardinalY, texte);
         }
         else if (i % 3 == 0) {
            String angle = String.valueOf(i*15);
            float largeurAngle = texte.measureText(angle);
            int angleTexteX = (int) (px - largeurAngle / 2);
            int angleTexteY = py - rayon + hauteurTexte;
            canvas.drawText(angle, angleTexteX, angleTexteY, texte);
         }
         canvas.restore();
         canvas.rotate(15, px, py);
      }
      canvas.restore();
      
      float d = 2*rayon;
      RectF cercleRoulis = new RectF(d/3-d/7, d/2-d/7, d/3+d/7, d/2+d/7);
      marque.setStyle(Paint.Style.STROKE); // Tracé du coutour uniquement
      canvas.drawOval(cercleRoulis, marque);
      marque.setStyle(Paint.Style.FILL); // Tracé de l'intérieur uniquement
      canvas.save();
      canvas.rotate(roulis, d/3, d/2);
      canvas.drawArc(cercleRoulis, 0, 180, false, marque);
      canvas.restore();
      
      RectF cercleTangage = new RectF(2*d/3-d/7, d/2-d/7, 2*d/3+d/7, d/2+d/7);
      marque.setStyle(Paint.Style.STROKE); // Tracé du coutour uniquement
      canvas.drawOval(cercleTangage, marque);
      marque.setStyle(Paint.Style.FILL); // Tracé de l'intérieur uniquement
      canvas.drawArc(cercleTangage, 0-tangage/2, 180+tangage, false, marque);      
   }     
}