Développement d’applications de capteur pour des téléphones et tablettes Android* basés sur un processeur Intel® Atom™

Ce guide fournit aux développeurs d’applications une introduction à la structure de capteur Android et décrit comment utiliser certains des capteurs qui sont généralement disponibles sur les téléphones et tablettes basés sur le processeur Intel® Atom™. Nous décrirons notamment les capteurs de mouvement, de position et environnementaux. Bien que GPS ne soit pas strictement classé comme un capteur dans la structure Android, ce guide décrit également les services de localisation basés sur GPS. Les descriptions de ce guide se basent sur Android 4.2, Jelly Bean.

Capteurs des téléphones et tablettes Android* basés sur un processeur Intel® Atom™

Les téléphones et tablettes Android basés sur le processeur Intel Atom peuvent prendre en charge une grande gamme de capteurs matériels. Ces capteurs permettent de détecter le mouvement et les changements de position et de signaler les paramètres ambiants. Le schéma fonctionnel de la Figure 1 montre une configuration de capteur possible sur un appareil Android typique basé sur un processeur Intel Atom.

Figure 1. Capteurs sur un système Android basé sur Intel® Atom™

Nous pouvons classer les capteurs Android en différents types et classes, indiqués dans le Tableau 1, en fonction des données qu’ils fournissent.

Capteurs de mouvement	Accéléromètre (TYPE_ACCELEROMETER)	Mesure l’accélération d’un appareil en m/s²	Détection de mouvement
Capteurs de mouvement	Gyroscope (TYPE_GYROSCOPE)	Mesure la vitesse de rotation d’un appareil	Détection de la rotation
Capteurs de position	Magnétomètre (TYPE_MAGNETIC_FIELD)	Mesure l’intensité du champ géomagnétique terrestre en µT	Boussole
	Proximité (TYPE_PROXIMITY)	Mesure la proximité d’un objet en centimètres	Détection d’objets proches
	GPS (pas un type android.hardware.Sensor)	Obtient la géolocalisation précise de l’appareil	Détection précise de la géolocalisation
Capteurs environnementaux	ALS (TYPE_LIGHT)	Mesure le niveau de lumière ambiante en lx	Contrôle automatique de la luminosité de l’écran
Capteurs environnementaux	Baromètre	Mesure la pression de l’air ambiant en mbar	Détection de l’altitude

Tableau 1. Types de capteurs pris en charge par la plate-forme Android

Structure de capteurs Android

La structure de capteurs Android fournit un mécanisme permettant d’accéder aux capteurs et aux données des capteurs, à l’exception du GPS qui est accessible par l’intermédiaire des services de localisation Android. Nous décrirons cela ultérieurement dans cet article. La structure de capteurs fait partie du package android.hardware. Le Tableau 2 répertorie les principales classes et interfaces de la structure de capteurs.

Nom	Type	Description
SensorManager	Classe	Utilisée pour créer une instance du service de capteur. Fournit différentes méthodes permettant d’accéder aux capteurs, d’enregistrer et de désenregistrer les détecteurs d’événements de capteurs, etc.
Sensor	Classe	Utilisée pour créer une instance de capteur spécifique.
SensorEvent	Classe	Utilisée par le système pour publier les données de capteur. Elle comprend les valeurs brutes des données de capteur, le type de capteur, la précision des données et un horodatage.
SensorEventListener	Interface	Fournit des méthodes de rappel permettant de recevoir des notifications de SensorManager lorsque les données du capteur ou la précision du capteur ont changé.

Tableau 2. La structure de capteurs de la plate-forme Android

Obtenir la configuration des capteurs

Les fabricants d’appareils décident quels capteurs sont disponibles sur l’appareil. Vous devez découvrir les capteurs qui sont disponibles lors de l’exécution en invoquant la méthode SensorManager getSensorList() de la structure de capteurs avec le paramètre « Sensor.TYPE_ALL ». L’exemple de code 1 affiche la liste des capteurs disponibles et les informations concernant le fabricant, la puissance et la précision de chaque capteur.

package com.intel.deviceinfo;
	
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import android.app.Fragment;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ListView;
import android.widget.SimpleAdapter;
	
public class SensorInfoFragment extends Fragment {
	
    private View mContentView;
	
    private ListView mSensorInfoList;	
    SimpleAdapter mSensorInfoListAdapter;
	
    private List<sensor> mSensorList;

    private SensorManager mSensorManager;
	
    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
    }
	
    @Override
    public void onPause() 
    { 
        super.onPause();
    }
	
    @Override
    public void onResume() 
    {
        super.onResume();
    }
	
    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container,
            Bundle savedInstanceState) {
        mContentView = inflater.inflate(R.layout.content_sensorinfo_main, null);
        mContentView.setDrawingCacheEnabled(false);
	
        mSensorManager = (SensorManager)getActivity().getSystemService(Context.SENSOR_SERVICE);
	
        mSensorInfoList = (ListView)mContentView.findViewById(R.id.listSensorInfo);
		
        mSensorInfoList.setOnItemClickListener( new OnItemClickListener() {
			
            @Override
            public void onItemClick(AdapterView<?> arg0, View view, int index, long arg3) {
				
                // with the index, figure out what sensor was pressed
                Sensor sensor = mSensorList.get(index);
				
                // pass the sensor to the dialog.
                SensorDialog dialog = new SensorDialog(getActivity(), sensor);

                dialog.setContentView(R.layout.sensor_display);
                dialog.setTitle("Sensor Data");
                dialog.show();
            }
        });
		
        return mContentView;
    }
	
    void updateContent(int category, int position) {
        mSensorInfoListAdapter = new SimpleAdapter(getActivity(), 
	    getData() , android.R.layout.simple_list_item_2,
	    new String[] {
	        "NAME",
	        "VALUE"
	    },
	    new int[] { android.R.id.text1, android.R.id.text2 });
	mSensorInfoList.setAdapter(mSensorInfoListAdapter);
    }
	
	
    protected void addItem(List<Map<String, String>> data, String name, String value)   {
        Map<String, String> temp = new HashMap<String, String>();
        temp.put("NAME", name);
        temp.put("VALUE", value);
        data.add(temp);
    }
	
	
    private List<? extends Map<String, ?>> getData() {
        List<Map<String, String>> myData = new ArrayList<Map<String, String>>();
        mSensorList = mSensorManager.getSensorList(Sensor.TYPE_ALL);
		
        for (Sensor sensor : mSensorList ) {
            addItem(myData, sensor.getName(),  "Vendor: " + sensor.getVendor() + ", min. delay: " + sensor.getMinDelay() +", power while in use: " + sensor.getPower() + "mA, maximum range: " + sensor.getMaximumRange() + ", resolution: " + sensor.getResolution());
        }
        return myData;
    }
}

Exemple de code 1. Un fragment qui affiche la liste des capteurs**

Système de coordonnées des capteurs

La structure de capteurs indique les données des capteurs en utilisant un système de coordonnées standard à 3 axes, où X, Y et Z sont représentés par values[0], values[1] et values[2] dans l’objet SensorEvent, respectivement.

Certains capteurs, comme les capteurs de lumière, de température, de proximité et de pression, retournent uniquement des valeurs uniques. Pour ces capteurs, seule la valeur values[0] de l’objet SensorEvent est utilisée.

Les autres capteurs indiquent les données en utilisant le système de coordonnées standard à 3 axes des capteurs. Vous trouverez ci-dessous une liste de ces capteurs :

Accéléromètre
Capteur de gravité
Gyroscope
Capteur de champ géomagnétique

Le système de coordonnées à 3 axes des capteurs est défini en fonction de l’orientation naturelle (par défaut) de l’écran de l’appareil. Pour un téléphone, l’orientation par défaut est Portrait, pour une tablette, l’orientation naturelle est Paysage. Lorsqu’un appareil est tenu dans son orientation naturelle, l’axe x est horizontal et pointe vers la droite, l’axe y est vertical et pointe vers le haut, et l’axe z pointe vers l’avant de l’écran. La Figure 2 montre le système de coordonnées des capteurs d’un téléphone et la Figure 3 celui d’une tablette.

Figure 2. Système de coordonnées de capteur d’un téléphone

Figure 3. Système de coordonnées de capteur d’une tablette

Le point le plus important à retenir concernant le système de coordonnées de capteur est que le système de coordonnées du capteur ne change jamais lorsque l’appareil bouge ou que son orientation change.

Surveillance des événements de capteur

La structure de capteurs indique les données de capteur à l’aide des objets SensorEvent. Une classe peut surveiller les données d’un capteur spécifique en implémentant l’interface SensorEventListener et en s’enregistrant auprès de SensorManager pour le capteur spécifique. La structure de capteurs informe la classe des changements qui surviennent dans l’état du capteur à l’aide des deux méthodes de rappel SensorEventListener implémentée par la classe :

onAccuracyChanged()

onSensorChanged()

L’exemple de code 2 implémente la boîte de dialogue SensorDialog utilisée dans l’exemple SensorInfoFragment décrit dans la section « Obtenir la configuration des capteurs ».

package com.intel.deviceinfo;

import android.app.Dialog;
import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Bundle;
import android.widget.TextView;

public class SensorDialog extends Dialog implements SensorEventListener {
    Sensor mSensor;
    TextView mDataTxt;
    private SensorManager mSensorManager;

    public SensorDialog(Context ctx, Sensor sensor) {
        this(ctx);
        mSensor = sensor;
    }
	
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mDataTxt = (TextView) findViewById(R.id.sensorDataTxt);
        mDataTxt.setText("...");
        setTitle(mSensor.getName());
    }
	
    @Override
    protected void onStart() {
        super.onStart();
        mSensorManager.registerListener(this, mSensor,  SensorManager.SENSOR_DELAY_FASTEST);
    }
		
    @Override
    protected void onStop() {
        super.onStop();
        mSensorManager.unregisterListener(this, mSensor);
    }

    @Override
    public void onAccuracyChanged(Sensor sensor, int accuracy) {
    }

    @Override
    public void onSensorChanged(SensorEvent event) {
        if (event.sensor.getType() != mSensor.getType()) {
            return;
        }
        StringBuilder dataStrBuilder = new StringBuilder();
        if ((event.sensor.getType() == Sensor.TYPE_LIGHT)||
            (event.sensor.getType() == Sensor.TYPE_TEMPERATURE)||
            (event.sensor.getType() == Sensor.TYPE_PRESSURE)) {
            dataStrBuilder.append(String.format("Data: %.3fn", event.values[0]));
        }
        else{         
            dataStrBuilder.append( 
                String.format("Data: %.3f, %.3f, %.3fn", 
                event.values[0], event.values[1], event.values[2] ));
        }
        mDataTxt.setText(dataStrBuilder.toString());
    }
}

Exemple de code 2.Une boîte de dialogue qui montre les valeurs du capteur**

Capteurs de mouvement

Les capteurs de mouvement sont utilisés pour surveiller les mouvements de l’appareil, comme les secousses, rotations, balancements ou inclinaisons. L’accéléromètre et le gyroscope sont des capteurs de mouvement qui sont disponibles sur de nombreux téléphones et tablettes.

Les capteurs de mouvement indiquent les données en utilisant le système de coordonnées des capteurs, où les trois valeurs de l’objet SensorEvent, values[0], values[1] et values[2], représentent la valeur des axes x, y et z, respectivement.

Pour comprendre les capteurs de mouvement et appliquer les données dans une application, nous devons appliquer certaines formules de physique liées à la force, la masse, l’accélération, les lois du mouvement de Newton et la relation entre plusieurs de ces entités dans le temps. Pour en savoir plus sur ces formules et ces relations, reportez-vous à vos livres de physique ou sources du domaine public favoris.

Accéléromètre

L’accéléromètre mesure l’accélération appliquée à l’appareil et ses propriétés sont résumées dans le Tableau 3.

Capteur	Type	SensorEvent Données (m/s²)	Description
Accéléromètre	TYPE_ACCELEROMETER	values[0] values[1] values[2]	Accélération sur l’axe x Accélération sur l’axe y Accélération sur l’axe z

Tableau 3. L’accéléromètre

Le concept de l’accéléromètre est dérivé de la deuxième loi du mouvement de Newton :

a = F/m

L’accélération d’un objet est la résultante des forces externes nettes qui lui sont appliquées. Les forces externes comprennent une force appliquée à tous les objets de la terre, la gravité. Elle est proportionnelle à la force nette F appliquée à l’objet et inversement proportionnelle à la masse m de l’objet.

Dans notre code, au lieu d’utiliser directement l’équation ci-dessus, nous sommes plus intéressés par le résultat de l’accélération pendant une certaine période sur la vitesse et la position de l’appareil. L’équation suivante décrit la relation de la vitesse v1 d’un objet, sa vitesse initiale v0, l’accélération a et la durée t :

v1 = v0 + at

Pour calculer le déplacement s de la position de l’objet, nous utilisons l’équation suivante :

s = v0t + (1/2)at²

Nous commençons dans de nombreux cas avec une condition v0 égale à 0 (avant que l’appareil commence à bouger), ce qui simplifie l’équation :

s = at²/2

Compte tenu de la gravité, l’accélération gravitationnelle, représentée par le symbole g, est appliquée à tous les objets de la terre. Quelle que soit la masse d’un objet, g dépend uniquement de la latitude de l’emplacement de l’objet, avec une plage de valeurs s’étendant de 9,78 à 9,82 (m/s^{2^{). Nous adoptons une valeur conventionnelle standard pour g :}}

g = 9.80665 (m/s²)

Comme l’accéléromètre retourne les valeurs en utilisant un système de coordonnées multidimensionnel, nous pouvons calculer dans notre code les distances parcourues sur les axes x, y et z en utilisant les équations suivantes :

S_x = A_xT²/2

S_y=A_yT²/2

S_z=A_zT²/2

Où S_x, S_y et S_z correspondent aux déplacements sur les axes x, y et z, respectivement, et A_x, A_y et A_z correspondent aux accélérations sur les axes x, y et z, respectivement. T correspond à la durée de la période de mesure.

public class SensorDialog extends Dialog implements SensorEventListener {
    …	
    private Sensor mSensor;
    private SensorManager mSensorManager;
	
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mSensor = mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER);
    …
}

Exemple de code 3. Instanciation d’un accéléromètre**

Parfois, il arrive que nous n’utilisions pas les trois valeurs de données dimensionnelles. D’autres fois, il arrive que nous devions également prendre en compte l’orientation de l’appareil. Par exemple, pour une application de labyrinthe, nous utilisons uniquement l’accélération gravitationnelle des axes x et y pour calculer les directions et les distances de déplacement de la boule en fonction de l’orientation de l’appareil. Le fragment de code suivant (exemple de code 4) décrit la logique.

@Override
public void onSensorChanged(SensorEvent event) {
    if (event.sensor.getType() != Sensor.TYPE_ACCELEROMETER) {
        return;
    } 
float accelX, accelY;
…
//detect the current rotation currentRotation from its “natural orientation”
//using the WindowManager
    switch (currentRotation) {
        case Surface.ROTATION_0:
            accelX = event.values[0];
            accelY = event.values[1];
            break;
        case Surface.ROTATION_90:
            accelX = -event.values[0];
            accelY = event.values[1];
            break;
        case Surface.ROTATION_180:
            accelX = -event.values[0];
            accelY = -event.values[1];
            break;
        case Surface.ROTATION_270:
            accelX = event.values[0];
            accelY = -event.values[1];
            break;
    }
    //calculate the ball’s moving distances along x, and y using accelX, accelY and the time delta
        …
    }
}

Exemple de code 4.Prise en compte de l’orientation de l’appareil lors de l’utilisation des données de l’accéléromètre dans un jeu de labyrinthe**

Gyroscope

Le gyroscope (ou simplement gyro) mesure la rotation de l’appareil autour des axes x, y et z, comme illustré dans le Tableau 4. Les données du gyroscope peuvent être des valeurs positives ou négatives. En regardant vers l’origine depuis une position située sur la moitié positive de l’axe, si la rotation tourne dans le sens inverse des aiguilles d’une montre autour de l’axe, la valeur est positive ; si elle tourne dans le sens des aiguilles d’une montre autour de l’axe, la valeur est négative. Nous pouvons également déterminer la direction d’une valeur gyroscopique en utilisant le « sens trigonométrique » illustré dans la Figure 4.

Figure 4. Utilisation du « sens trigonométrique » pour décider de la direction de rotation positive

Capteur	Type	SensorEvent Données (rad/s)	Description
Gyroscope	TYPE_GYROSCOPE	values[0] values[1] values[2]	Taux de rotation autour de l’axe x Taux de rotation autour de l’axe y Taux de rotation autour de l’axe z

Tableau 4. Le gyroscope

L’exemple de code 5 montre comment instancier un gyroscope.

public class SensorDialog extends Dialog implements SensorEventListener {
    …	
    private Sensor mGyro;
    private SensorManager mSensorManager;
	
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mGyro = mSensorManager.getDefaultSensor(Sensor.TYPE_GYROSCOPE);
    …
}

Exemple de code 5.Instanciation d’un gyroscope**

Capteurs de position

De nombreuses tablettes Android prennent en charge deux capteurs de position : le magnétomètre et les capteurs de proximité. Le magnétomètre mesure l’intensité du champ magnétique terrestre sur les axes x, y et z, alors que le capteur de proximité détecte la distance de l’appareil à un autre objet.

Magnétomètre

L’utilisation la plus importante du magnétomètre (décrite dans le Tableau 5) sur les systèmes Android est l’implémentation d’une boussole.

Capteur	Type	SensorEvent Données (µT)	Description
Magnétomètre	TYPE_MAGNETIC_FIELD	values[0] values[1] values[2]	Intensité du champ magnétique terrestre sur l’axe x Intensité du champ magnétique terrestre sur l’axe y Intensité du champ magnétique terrestre sur l’axe z

Tableau 5. Le magnétomètre

L’exemple de code 6 montre comment instancier un magnétomètre.

public class SensorDialog extends Dialog implements SensorEventListener {
    …	
    private Sensor mMagnetometer;
    private SensorManager mSensorManager;
	
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mMagnetometer = mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD);
    …
}

Exemple de code 6.Instanciation d’un magnétomètre**

Proximité

Le capteur de proximité détecte la distance entre l’appareil et un autre objet. L’appareil peut utiliser cette mesure pour détecter si l’appareil est tenu à proximité de l’utilisateur (voir le Tableau 6), ce qui permet de déterminer si l’utilisateur est au téléphone et de désactiver l’affichage pendant l’appel téléphonique.

Tableau 6 : Le capteur de proximité

Capteur	Type	SensorEvent Données	Description
Proximité	TYPE_PROXIMITY	values[0]	Distance d’un objet en cm. Certains capteurs de proximité retournent uniquement une valeur booléenne indiquant si l’objet est suffisamment proche.

L’exemple de code 7 montre comment instancier un capteur de proximité.

public class SensorDialog extends Dialog implements SensorEventListener {
    …	
    private Sensor mProximity;
    private SensorManager mSensorManager;
	
    public SensorDialog(Context context) {
        super(context);
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mProximity = mSensorManager.getDefaultSensor(Sensor.TYPE_PROXIMITY);
    …
}

Exemple de code 7.Instanciation d’un capteur de proximité**

Capteurs environnementaux

Les capteurs environnementaux détectent et indiquent les paramètres ambiants de l’appareil, comme la lumière, la température, la pression et l’humidité. Le capteur de luminosité ambiante (ALS) et le capteur de pression (baromètre) sont disponibles sur de nombreuses tablettes Android.

Capteur de luminosité ambiante (ALS)

Le capteur de luminosité ambiante, décrit dans le Tableau 7, est utilisé par le système pour détecter la luminosité du milieu environnant et ajuster automatiquement la luminosité de l’écran en conséquence.

Tableau 7 : Le capteur de luminosité ambiante

Capteur	Type	SensorEvent Données (lx)	Description
ALS	TYPE_LIGHT	values[0]	La luminosité autour de l’appareil

L’exemple de code 8 montre comment instancier un capteur de luminosité ambiante.

…	
    private Sensor mALS;
    private SensorManager mSensorManager;

    …	
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mALS = mSensorManager.getDefaultSensor(Sensor.TYPE_LIGHT);
    …

Exemple de code 8.Instanciation d’un capteur de luminosité ambiante**

Baromètre

Les applications peuvent utiliser le capteur de pression atmosphérique (baromètre), décrit dans le Tableau 8, pour calculer l’altitude de l’emplacement actuel de l’appareil.

Tableau 8 : Le capteur de pression atmosphérique

Capteur	Type	SensorEvent Données (lx)	Description
Baromètre	TYPE_PRESSURE	values[0]	La pression de l’air ambiant en mbar

L’exemple de code 9 montre comment instancier un baromètre.

…	
    private Sensor mBarometer;
    private SensorManager mSensorManager;

    …	
        mSensorManager = (SensorManager)context.getSystemService(Context.SENSOR_SERVICE);
        mBarometer = mSensorManager.getDefaultSensor(Sensor.TYPE_PRESSURE);
    …

Exemple de code 9. Instanciation d’un baromètre**

Conseils sur les performances et l’optimisation des capteurs

Pour utiliser des capteurs dans vos applications, vous devez suivre les meilleures pratiques suivantes :

Vérifiez toujours la disponibilité d’un capteur spécifique avant de l’utiliser
La plate-forme Android n’exige pas qu’un capteur spécifique soit inclus ou exclus sur un appareil. Avant d’utiliser un capteur dans votre application, vérifiez toujours s’il est effectivement disponible.
Désenregistrez toujours les détecteurs des capteurs
Si l’activité qui implémente le détecteur du capteur devient invisible ou si la boîte de dialogue s’arrête, désenregistrez le détecteur du capteur. Cela peut être réalisé à l’aide de la méthode onPause() de l’activité ou de la méthode onStop() de la boîte de dialogue. Autrement, le capteur continuera à recueillir des données et à pomper inutilement l’énergie de la batterie.
Ne bloquez pas la méthode onSensorChanged()
La méthode onSensorChanged() est appelée fréquemment par le système pour fournir les données du capteur. Vous devriez insérer une petite logique dans cette méthode dans la mesure du possible. Les calculs complexes effectués avec les données du capteur doivent être réalisés hors de cette méthode.
Testez toujours les applications de capteur sur des appareils réels.
Tous les capteurs décrits dans cette section sont des capteurs matériels. Il est possible que l’émulateur Android ne soit pas en mesure de simuler les fonctions et performances d’un capteur particulier.

GPS et localisation

GPS (Global Positioning System) est un système satellitaire qui fournit des informations de géolocalisation précise dans le monde entier. La fonctionnalité GPS est disponible sur de nombreux téléphones et tablettes Android. La fonctionnalité GPS se comporte à de nombreux égards comme un capteur de position. Elle peut fournir des données de localisation précises à des applications exécutées sur l’appareil. Sur la plate-forme Android, la fonctionnalité GPS n’est pas gérée directement par la structure de capteurs. À la place, le service de localisation Android accède aux données GPS et les transfère à une application à l’aide des rappels du détecteur de position.

Cette section décrit la fonctionnalité GPS et les services de localisation d’un point de vue de capteur matériel uniquement. Les stratégies de localisation complètes offertes par les téléphones et tablettes Android 4.2 basés sur des processeurs Intel Atom constituent un sujet bien plus large qui n’entre pas dans les limites de cette section.

Services de localisation Android

L’utilisation du service GPS n’est pas le seul moyen d’obtenir des informations de localisation sur un appareil Android. Le système peut également utiliser Wi-Fi*, les réseaux cellulaires ou d’autres réseaux sans fil pour obtenir la position actuelle de l’appareil. Le système GPS et les réseaux sans fil (y compris Wi-Fi et les réseaux cellulaires) jouent le rôle de « fournisseurs de position » auprès des services de localisation Android. Le Tableau 9 répertorie les principales classes et interfaces utilisées pour accéder aux services de localisation Android.

Tableau 9 : Le service de localisation de la plate-forme Android

Nom	Type	Description
LocationManager	Classe	Utilisée pour accéder aux services de localisation. Fournit différentes méthodes permettant de demander des mises à jour régulières de la position à l’intention d’une application, ou permettant d’envoyer des alertes de proximité.
LocationProvider	Classe abstraite	La super classe abstraite des fournisseurs de position
Location	Classe	Utilisée par les fournisseurs de position pour encapsuler les données géographiques
LocationListener	Interface	Utilisée pour recevoir des notifications de position du LocationManager

Obtention des mises à jour de position GPS

Comme le mécanisme qui utilise la structure de capteurs pour accéder aux données des capteurs, l’application implémente plusieurs méthodes de rappel définies dans l’interface LocationListener pour recevoir des mises à jour de position GPS. Le LocationManager envoie des notifications de mise à jour GPS à l’application par le biais de ces rappels (la règle « Ne nous appelez pas, on vous rappellera »).

Pour accéder aux données de localisation GPS dans l’application, vous devez demander l’autorisation d’accès aux données de localisation précises dans le fichier manifeste Android (exemple de code 10).

<manifest …>
…
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
…  
</manifest>

Exemple de code 10.Demander l’autorisation d’accès aux données de positionnement précises dans le fichier manifeste**

L’exemple de code 11 montre comment obtenir des mises à jour des positions GPS et afficher les coordonnées de latitude et de longitude sous forme de texte dans une boîte de dialogue.

package com.intel.deviceinfo;

import android.app.Dialog;
import android.content.Context;
import android.location.Location;
import android.location.LocationListener;
import android.location.LocationManager;
import android.os.Bundle;
import android.widget.TextView;

public class GpsDialog extends Dialog implements LocationListener {
    TextView mDataTxt;
    private LocationManager mLocationManager;
	
    public GpsDialog(Context context) {
        super(context);
        mLocationManager = (LocationManager)context.getSystemService(Context.LOCATION_SERVICE);
    }

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
	       mDataTxt = (TextView) findViewById(R.id.sensorDataTxt);
          mDataTxt.setText("...");
		
        setTitle("Gps Data");
    }
	
    @Override
    protected void onStart() {
        super.onStart();
        mLocationManager.requestLocationUpdates(
            LocationManager.GPS_PROVIDER, 0, 0, this);
    }
		
    @Override
    protected void onStop() {
        super.onStop();
        mLocationManager.removeUpdates(this);
    }

    @Override
    public void onStatusChanged(String provider, int status, 
        Bundle extras) {
    }

    @Override
    public void onProviderEnabled(String provider) {
    }

    @Override
    public void onProviderDisabled(String provider) {
    }

    @Override
    public void onLocationChanged(Location location) {
        StringBuilder dataStrBuilder = new StringBuilder();
        dataStrBuilder.append(String.format("Latitude: %.3f,   Logitude%.3fn", location.getLatitude(), location.getLongitude()));
        mDataTxt.setText(dataStrBuilder.toString());
		
    }
}

Exemple de code 11. Une boîte de dialogue affichant les données de localisation GPS**

Conseils sur les performances et l’optimisation des fonctionnalités GPS et de localisation

La fonctionnalité GPS fournit les informations de localisation les plus précises sur l’appareil. Cependant, comme il s’agit d’une fonctionnalité matérielle, elle consomme davantage d’énergie. De plus, l’obtention de la première position par le GPS prend du temps. Voici quelques conseils à suivre lorsque vous développez des applications sensibles aux données GPS et de localisation :

Prenez en considération tous les fournisseurs de position disponibles
En plus de GPS_PROVIDER, il existe aussi NETWORK_PROVIDER. Si vos applications nécessitent uniquement des données de localisation grossières, il peut s’avérer préférable d’utiliser NETWORK_PROVIDER.
Utilisez les positions mises en cache
L’obtention de la première position par le GPS prend du temps. Lorsque votre application attend que le système GPS lui procure une mise à jour de position précise, vous pouvez d’abord utiliser les positions fournies par la méthode getlastKnownLocation() de LocationManager pour commencer le travail.
Minimisez la fréquence et la durée des demandes de mise à jour de position
Vous ne devez demander une mise à jour de position que lorsqu’elle est nécessaire et vous désenregistrer du gestionnaire de position dès que vous n’avez plus besoin des mises à jour de position.

Résumé

La plate-forme Android fournit des API permettant aux développeurs d’accéder aux capteurs incorporés à l’appareil. Ces capteurs sont capables de fournir des données brutes sur les mouvements et la position de l’appareil, ainsi que sur les conditions ambiantes, avec un haut degré de précision. Lorsque vous développez des applications utilisant des capteurs, suivez les meilleures pratiques afin d’améliorer les performances et l’efficacité énergétique.

À propos de l'auteur

Miao Wei est un ingénieur en applications logicielles d’Intel Software and Services Group. Il travaille actuellement sur les projets d’implémentation du dimensionnement sur le processeur Intel® Atom™.

**Cet exemple de code source est divulgué dans le cadre du Contrat de licence sur les exemples de code source Intel (Intel Sample Source Code License Agreement).

Developers

Android*

Intel® Atom™ Processors