Les capteurs sont des composants matériels qui fournissent à votre appareil (téléphone ou ordinateur) des renseignements sur lui-même. Les données qu’ils fournissent peuvent être utilisées par vos applications. Par exemple l’application La Fourchette utilise le GPS pour localiser les restaurants à proximité. Autrefois, interagir avec les capteurs des appareils Windows n’était pas aisé. Il fallait gérer différents drivers et utiliser de nombreuses librairies externes.

Aujourd’hui, il est plus simple de communiquer avec ces dispositifs. Windows propose des API qui facilitent cette communication. Je vous propose dans cet article une vue d’ensemble de ces API.

A partir de la version 8, Windows propose deux namespaces pour gérer les capteurs:

• Windows.Devices.Sensors, inclut les capteurs de mouvement, d’orientation et le capteur de luminosité
• Windows.Devices.Geolocation, gère la localisation

Windows.Devices.Sensors

Le code qui permet de manipuler ces capteurs est presque toujours le même. D’abord on crée l’objet qui représente le capteur, ensuite on accède à ses données soit en appelant une fonction, soit en s’abonnant à un évènement. Voyons tout ça en détail.

L’accéléromètre

L’accéléromètre mesure l’accélération linéaire selon 3 axes orthogonaux. Pour utiliser un accéléromètre, la première chose à faire est de récupérer une référence à un objet Accelerometer.

Accelerometer accelerometer = Accelerometer.GetDefault();
if (accelerometer == null)
{
    //pas d'accéléromètre
}

On peut ensuite accéder de trois manières aux données de l’accéléromètre:

• s’abonner à l’évènement ReadingChanged
• s’abonner à l’évènement Shaken
• appeler une fonction

L’évènement ReadingChanged est levé à chaque fois que l’accéléromètre lit une nouvelle donnée.

accelerometer.ReadingChanged += Accelerometer_ReadingChanged;
...
private void Accelerometer_ReadingChanged(Accelerometer sender,
    AccelerometerReadingChangedEventArgs args)
{
    if (args.Reading != null)
    {
        Debug.WriteLine(String.Format("X:{0} - Y:{1} - Z:{2}", args.Reading.AccelerationX,
            args.Reading.AccelerationY, args.Reading.AccelerationZ));
    }
}

La seconde méthode consiste à accéder aux données via la méthode GetCurrentReading.

var readings = accelerometer.GetCurrentReading();

Debug.WriteLine(String.Format("X:{0} - Y:{1} - Z:{2}", readings.AccelerationX,
            readings.AccelerationY,readings.AccelerationZ));

La classe Accelerometer fournit également un évènement Shaken. L’abonnement à cet évènement ne permet pas d’obtenir l’accélération mais indique que l’appareil a été secoué.

accelerometer.Shaken += Accelerometer_Shaken;
...
private void Accelerometer_Shaken(Accelerometer sender,
    AccelerometerShakenEventArgs args)
{
    Debug.WriteLine("Je suis secoué!");
}

Le gyromètre et l’inclinomètre

Un gyromètre est un instrument qui mesure la vitesse angulaire selon trois axes. Le code pour gérer le gyromètre est similaire à celui de l’accéléromètre.
D’abord, avoir une référence à un objet Gyrometer.

Gyrometer gyrometer = Gyrometer.GetDefault();

Puis on accède aux données du gyromètre en s’abonnant à l’évènement ReadingChanged ou en appelant la méthode GetCurrentReading.
L’inclinomètre retourne les angles de rotation selon trois axes. Il fonctionne de la même façon que les précédents capteurs. Il est géré par la classe Inclinometer.

La boussole

La boussole donne le nord magnétique et éventuellement le nord géographique. L’obtention du Nord géographique dépend des capacités du capteur.
Comme pour les précédents capteurs, d’abord obtenir une référence à la classe Compass,

Compass compass = Compass.GetDefault();

puis s’abonner à l’évènement ReadingChanged.

compass.ReadingChanged += Compass_ReadingChanged;
...
void Compass_ReadingChanged(Compass sender, CompassReadingChangedEventArgs args)
{
if (args.Reading != null)
{
Debug.WriteLine("Nord magnétique : {0} degrés",
    args.Reading.HeadingMagneticNorth);

        if(args.Reading.HeadingTrueNorth != null)
        {
        Debug.WriteLine("Nord géographique: {0} degrés",
            args.Reading.HeadingMagneticNorth);
        }
        else
        {
            Debug.WriteLine("Nord géographique non disponible.");
        }
    }
}

Le nord géographique n’étant pas toujours disponible. Il faut vérifier sa disponibilité avant d’accéder à la propriété.

Le capteur de luminosité

Ce capteur permet de mesurer l’intensité lumineuse. Il peut être utilisé, par exemple, pour modifier la luminosité de l’écran en fonction de l’éclairage de la pièce dans laquelle nous sommes.
L’éclarairage ambiant est exprimé en LUX. On accède à cette valeur à travers la classe LightSensor.

LightSensor lightSensor =  LightSensor.GetDefault();
lightSensor.ReadingChanged += LightSensor_ReadingChanged;
...
private void LightSensor_ReadingChanged(LightSensor sender,
    LightSensorReadingChangedEventArgs args)
{
    Debug.WriteLine("Luminosité en lux : {0}", args.Reading.IlluminanceInLux);
}

Windows.Devices.Geolocation

Windows Runtime utilise deux moyens pour déterminer la position de l’utilisateur:

• Windows Location Provider qui utilise le Wifi ou l’adresse IP
• le GPS qui est le moyen le plus précis

L’API de localisation détermine la position de manière transparente pour l’utilisateur. Il ne sait pas quel moyen est utilisé pour la déterminer. L’API utilise la source de données la plus précise disponible, souvent le GPS lorsqu’il est présent.
Le namespace Windows.Devices.Geolocation contient toutes les classes gérant la localisation. C’est un objet de type Geolocator qui est utilisé pour déterminer la position.

Geolocator geoLocator = new Geolocator();

Pour récupérer les données, soit on s’abonne à l’évènement PositionChanged

geoLocator.PositionChanged += GeoLocator_PositionChanged;
...
private void GeoLocator_PositionChanged(Geolocator sender, PositionChangedEventArgs args)
{
    Debug.WriteLine("Longitude: {0} Latitude: {1} Précision: {2} mètres",
        args.Position.Coordinate.Longitude, args.Position.Coordinate.Latitude,
        args.Position.Coordinate.Accuracy);
}

, soit on appelle la fonction GetGeopositionAsync.

var position = await geoLocator.GetGeopositionAsync();

Debug.WriteLine("Longitude: {0} Latitude: {1} Précision: {2} mètres",
    position.Coordinate.Longitude, position.Coordinate.Latitude,
    position.Coordinate.Accuracy);

Il est possible de définir l’effort que doit fournir le service pour déterminer la position via la propriété DesiredAccuracy. Lorsque sa valeur est fixée à High, on essaiera d’obtenir la position la plus précise. La valeur par défaut fournit une localisation moins précise mais préserve la batterie.

Pour finir

Cet article vous a permis de constater à quel point il est simple de développer des applications Windows utilisant les capteurs. Ceux-ci peuvent fournir de nombreuses informations sur l’utilisateur de votre application. Un peu trop, peut être. De nombreuses sociétés veulent transformer leurs applications en véritables mouchards. Uber, par exemple, est en train de modifier son application pour surveiller la manière de conduire de ses chauffeurs.