Developpement Windows Phone – partie 26


Développer avec le GPS Windows Phone (Services de localisation)

Cet article fait partie d’une série d’articles sur le développement Windows Phone. Il s’agit d’une traduction des articles se trouvant sur la MSDN.

Sommaire

Bien débuter et fondamentaux

Visuels et média

Travailler avec les données

Sondes et autres fonctionnalités spécifiques au téléphone


Développer avec le GPS Windows Phone (Services de localisation)

Silverlight pour Windows Phone inclut un espace de nom qui fournit la gestion et la surveillance en temps réel du service de localisation du téléphone. Le service de localisation fournit l'information la plus précise possible sur l'actuelle position du téléphone en utilisant une combinaison de données Wi-Fi et du réseau cellulaire, ainsi que des données GPS (Global Positionning System). Le service de localisation récupère la latitude, longitude, altitude, vitesse de déplacement, de direction et expose ses données au travers de l'espace de nom System.Devices.Location.

Créer une application Windows Phone utilisant la localisation signifie que certaines fonctionnalités de votre application seront sujettes à la disponibilité des données de localisation. Parce que le service de localisation se base sur les signaux satellites et cellulaires, il est important d'écrire du code qui gère les scénarios suivants:

  • L'utilisateur a coupé le GPS ou le récepteur cellulaire sur le téléphone.
  • La force du signal est trop faible pour recevoir les données de localisation.
  • Le service de localisation est encore en cours d'initialisation ou attend que les données de localisation arrivent jusqu'au téléphone.

Nous allons coder cette application d'une façon qui autorise l'utilisateur à gérer ces scénarios.

Cette QuickApp est une application qui reçoit des données du service de localisation de Windows Phone 7, et positionne les données sur une carte pendant qu'il donne une information visuelle des données. Cet article est divisé en chapitres:

Téléchargez le code complet de cette application ici.

Procédure pas à pas

Pour voir un exemple de ce quickstart exécuté sur un réel téléphone, et pour construire cette application en suivant une vidéo plutôt que de continuer à lire cet article, vous pouvez visionner la vidéo suivante. La page pour cette vidéo sur Channel 9 a plusieurs options de téléchargement si vous voulez une version en haute définition ou si vous voulez une version lisible sur des périphériques mobiles.

Get Microsoft Silverlight

Créer une interface utilisateur pour la lecture du service de localisation

Lancez Visual Studio et démarrez un projet de type "Silverlight for Windows Phone". Créez alors une interface utilisateur qui contient les éléments suivants:

  • Six champs TextBlock avec des libellés compréhensifs pour la lecture de la longitude, de la latitude, de la vitesse et des données de statut.
  • Un objet Map sur lequel nous placerons un Pushpin affichant la position actuelle du téléphone.

o Note: Vous aurez besoin d'une clé Bing Maps pour pouvoir utiliser le contrôle carte. Pour en obtenir une, suivez les instructions de l'article Obtenir une clé Bing Maps. Une fois que vous avez une clé, qui est simplement une chaine de caractères, entrez-la en tant que valeur pour la propriété CredentialsProvider dans le code XAML qui définit l'objet Map. Un exemple est fourni dans l'article Accédez au contrôle grâce à une clé Bing Maps.

  • Deux Buttons avec un libellé explicite qui vont être utilisés pour démarrer et arrêter le service de localisation ainsi que démarrer le positionnement en temps réel du téléphone sur la carte.
  • Des TextBlocks pour afficher les informations récupérées.

Une proposition du positionnement de ces éléments est fournie ci-dessous. Ici, la valeur par défaut des six TextBlocks est changée pour montrer le format et les paramètres utilisés par le service de localisation (par exemple, "Mètres par secondes" est la valeur par défaut pour la vitesse ainsi c'est clair).

image_thumb1

XAML
  1. <Grid x:Name="ContentPanel" Grid.Row="1" Margin="12,0,12,12">
  2. <TextBlock Height="30" Margin="12,6,395,0" Name="textBlock1" Text="Long:"
  3. VerticalAlignment="Top" />
  4. <TextBlock Height="30" HorizontalAlignment="Left" Margin="12,42,0,0" Name="textBlock2"
  5. Text="Lat:" VerticalAlignment="Top" />
  6. <TextBlock Height="30" HorizontalAlignment="Left" Margin="71,6,0,0"
  7. Name="longitudeTextBlock" Text="Long" VerticalAlignment="Top" />
  8. <TextBlock Height="30" HorizontalAlignment="Left" Margin="53,42,0,0"
  9. Name="latitudeTextBlock" Text="Lat" VerticalAlignment="Top" />
  10. <my:Map Height="352" HorizontalAlignment="Left" Margin="12,322,0,0" Name="myMap"
  11. VerticalAlignment="Top" Width="421" CredentialsProvider="KEY" ZoomLevel="1" />
  12. <TextBlock Height="30" HorizontalAlignment="Left" Margin="12,196,0,0"
  13. Name="textBlock3" Text="Status:" VerticalAlignment="Top" />
  14. <TextBlock Height="66" HorizontalAlignment="Left" Margin="78,196,0,0"
  15. Name="statusTextBlock" Text="Status TextBlock w/TextWrapping=&quot;Wrap&quot;"
  16. VerticalAlignment="Top" Width="355" TextWrapping="Wrap" />
  17. <Button Content="Track Me On Map" Height="72" HorizontalAlignment="Left"
  18. Margin="0,256,0,0" Name="trackMe" VerticalAlignment="Top" Width="255"
  19. Click="trackMe_Click" />
  20. <TextBlock Height="30" HorizontalAlignment="Left" Margin="12,78,0,0"
  21. Name="textBlock4" Text="Speed:" VerticalAlignment="Top" />
  22. <TextBlock Height="30" HorizontalAlignment="Left" Margin="78,78,0,0"
  23. Name="speedreadout" Text="Meters Per Second" VerticalAlignment="Top" />
  24. <TextBlock Height="30" HorizontalAlignment="Left" Margin="12,114,0,0"
  25. Name="textBlock6" Text="Course:" VerticalAlignment="Top" />
  26. <TextBlock Height="30" HorizontalAlignment="Left" Margin="84,114,0,0"
  27. Name="coursereadout" Text="Heading in Degrees (0=N)" VerticalAlignment="Top"
  28. Width="339" />
  29. <TextBlock Height="30" HorizontalAlignment="Left" Margin="12,150,0,0"
  30. Name="textBlock5" Text="Altitude:" VerticalAlignment="Top" />
  31. <TextBlock Height="30" HorizontalAlignment="Left" Margin="93,150,0,0"
  32. Name="altitudereadout" Text="Altitude in Meters (0=Sea Level)"
  33. VerticalAlignment="Top" />
  34. <Button Content="Stop LocServ" Height="72" HorizontalAlignment="Left"
  35. Margin="235,256,0,0" Name="startStop" VerticalAlignment="Top"
  36. Width="209" Click="startStop_Click" />
  37. </Grid>

Pour faire fonctionner le XAML ci-dessus, vous devez définir l'espace de nom "my:Map" qui est utilisé en ajoutant un attribut xmlns sur le tag phone:PhoneApplicationPage en haut du document XAML qui définit l'UI, tel que:

XAML
  1. <phone:PhoneApplicationPage
  2. ...
  3. xmlns:my=
  4. "clr-namespace:Microsoft.Phone.Controls.Maps;assembly=Microsoft.Phone.Controls.Maps">

En dernier recours, si Visual Studio ne l'a pas fait pour vous lorsque vous avez ajouté les éléments, ajoutez une référence vers Microsoft.Phone.Controls.Maps. Silverlight pour Windows Phone utilise l'assembly Microsoft.Phone.Controls.Maps pour fournir une fonctionnalité de cartographie, qui doit être référencée par votre application avant que l'un de ses types, évènements ou méthodes ne puisse être utilisés par votre code.

Pour ajouter Microsoft.Phone.Controls.Maps à votre application:

  1. Dans l'explorateur de Solution, cliquez à l'aide du bouton droit de la souris sur le nœud Références de votre projet et sélectionnez Ajouter référence.
  2. Sélectionnez Microsoft.Phone.Controls.Maps depuis la liste et cliquez sur OK.

Note: Visual Studio devrait automatiquement ajouter l'attribut xmlns et la référence vers Microsoft.Phone.Controls.Maps dès que vous ajoutez le contrôle Map sur l'interface en la glissant depuis la barre d'outils sur le designer.

Obtenir des données du service de localisation en temps réel

Dans l'explorateur de solutions, ouvrez le fichier xaml.cs file, et ajoutez les trois lignes de code suivantes en haut de la page.

C#
  1. using Microsoft.Phone.Controls.Maps;
  2. using System.Device.Location;
  3. using System.Threading;
Visual Basic
  1. Imports Microsoft.Phone.Controls.Maps
  2. Imports System.Device.Location
  3. Imports System.Threading

Cela permet à votre code C# d'accéder au contrôle Bing Maps, à l'API du service de localisation et au modèle de Threading, tout ce que nous utiliserons pour cette application.

L'utilisation du service de localisation nécessitera de la coordination au travers de quelques méthodes et c'est pourquoi nous allons ajouter quelques membres à la classe principale. Le plus notable sera l'objet GeoCoordinateWatcher, qui reçoit constamment les informations du service de localisation dès qu'il est démarré par la méthode TryStart(), que nous allons étudier dans un moment. Nous allons appeler notre watcher. Dès que notre guetteur (watcher) a été démarré, il va essayer de récupérer des informations depuis le service de localisation et exposer ces informations via ses différentes propriétés, ainsi que déclencher l'évènement PositionChanged lorsque l'information de position est mise à jour (c’est-à-dire lorsque le périphérique change de lieu).

Ce membre doit être au niveau de la classe car plusieurs méthodes vont être impliquées dans la lecture des données service de localisation pour gérer les différents évènements que le service va déclencher.

En complément, nous surveillerons si l'utilisateur a activé le tracking sur la carte, et il s'agira encore un membre de classe. Finalement, nous utiliserons le même objet Pushpin tout au long de l'application car nous n'en avons besoin que d'un seul, et nous mettrons à jour sa position continuellement dans différentes méthodes, et sera donc instancié au niveau de la classe. Les trois membres ressemblent à ceci dans le code:

C#
  1. public partial class MainPage : PhoneApplicationPage
  2. {
  3. GeoCoordinateWatcher watcher;
  4. bool trackingOn = false;
  5. Pushpin myPushpin = new Pushpin();
  6. ...
Visual Basic
  1. Public Partial Class MainPage
  2. Inherits PhoneApplicationPage
  3. Private watcher As GeoCoordinateWatcher
  4. Private trackingOn As Boolean = False
  5. Private myPushpin As New Pushpin()
  6. ...

Comme indiqué, il y aura plusieurs méthodes qui utiliseront notre watcher. Pour être exact, il y en aura trois:

  1. Une méthode qui gère l'évènement PositionChanged du watcher et analyse les nouvelles données. Nous appellerons cette méthode watcher_PositionChanged.
  2. Une méthode qui gère l'évènement StatusChanged, qui se déclenche lorsque le service de localisation change d'état (inactif, initialisation, réception de données, etc.). Nous appellerons cette méthode watcher_StatusChanged.
  3. Une méthode qui gèrera le démarrage du watcher par lui-même dans son propre thread. Bien que cette méthode ne fasse qu'une ligne de code, nous voulons compartimenter ce code pour qu'il puisse être lancé dans son propre thread et ne bloque pas l'application pendant que le service de localisation s'initialise. Nous appellerons cette méthode startLocServInBackground.

Nous pourrions vouloir faire cela dès que l'application démarre donc mettons-les dans le constructeur, la méthode MainPage().

Deux lignes supplémentaires sont nécessaires pour instancier le watcher et mettre à jour l'interface à propos de l'initialisation du service de localisation, laissant la méthode MainPage() ressembler à ceci:

C#
  1. // Constructor
  2. public MainPage()
  3. {
  4. InitializeComponent();
  5. // instantiate watcher, setting its accuracy level and movement threshold.
  6. watcher = new GeoCoordinateWatcher(GeoPositionAccuracy.High); // using high accuracy;
  7. watcher.MovementThreshold = 10.0f; // meters of change before "PositionChanged"
  8. // wire up event handlers
  9. watcher.StatusChanged += new
  10. EventHandler<GeoPositionStatusChangedEventArgs>(watcher_StatusChanged);
  11. watcher.PositionChanged += new
  12. EventHandler<GeoPositionChangedEventArgs<GeoCoordinate>>(watcher_PositionChanged);
  13. // start up LocServ in bg; watcher_StatusChanged will be called when complete.
  14. new Thread(startLocServInBackground).Start();
  15. statusTextBlock.Text = "Starting Location Service...";
  16. }
Visual Basic
  1. ' Constructor
  2. Public Sub New()
  3. InitializeComponent()
  4. ' instantiate watcher, setting its accuracy level and movement threshold.
  5. watcher = New GeoCoordinateWatcher(GeoPositionAccuracy.High)
  6. ' using high accuracy;
  7. watcher.MovementThreshold = 10.0F
  8. ' meters of change before "PositionChanged"
  9. ' wire up event handlers
  10. watcher.StatusChanged += New EventHandler(Of GeoPositionStatusChangedEventArgs)(watcher_StatusChanged)
  11. watcher.PositionChanged += New EventHandler(Of GeoPositionChangedEventArgs(Of GeoCoordinate))(watcher_PositionChanged)
  12. ' start up LocServ in bg; watcher_StatusChanged will be called when complete.
  13. New Thread(startLocServInBackground).Start()
  14. statusTextBlock.Text = "Starting Location Service..."
  15. End Sub

Il est maintenant temps d'implémenter les gestionnaires d'évènements. Commençons avec watcher_StatusChanged. watcher donnera son statut à la méthode watcher_StatusChanged en utilisant un objet GeoPositionStatusChangedEventArgs passé en argument. Cet objet a une propriété enum appelée GeoPositionStatus qui fournit des noms compréhensibles pour les différents états du service de localisation. Tout ce que nous voulons faire dans notre application est de notifier l'utilisateur lorsque le statut a changé et nous pouvons accomplir cela avec un seul switch qui gère les quatre valeurs possibles GeoPositionStatus:

C#
  1. void watcher_StatusChanged(object sender, GeoPositionStatusChangedEventArgs e)
  2. {
  3. switch (e.Status)
  4. {
  5. case GeoPositionStatus.Disabled:
  6. // The Location Service is disabled or unsupported.
  7. // Check to see if the user has disabled the Location Service.
  8. if (watcher.Permission == GeoPositionPermission.Denied)
  9. {
  10. // The user has disabled the Location Service on their device.
  11. statusTextBlock.Text = "You have disabled Location Service.";
  12. }
  13. else
  14. {
  15. statusTextBlock.Text = "Location Service is not functioning on this device.";
  16. }
  17. break;
  18. case GeoPositionStatus.Initializing:
  19. statusTextBlock.Text = "Location Service is retrieving data...";
  20. // The Location Service is initializing.
  21. break;
  22. case GeoPositionStatus.NoData:
  23. // The Location Service is working, but it cannot get location data.
  24. statusTextBlock.Text = "Location data is not available.";
  25. break;
  26. case GeoPositionStatus.Ready:
  27. // The Location Service is working and is receiving location data.
  28. statusTextBlock.Text = "Location data is available.";
  29. break;
  30. }
  31. }
Visual Basic
  1. Private Sub watcher_StatusChanged(sender As Object, e As GeoPositionStatusChangedEventArgs)
  2. Select Case e.Status
  3. Case GeoPositionStatus.Disabled
  4. ' The Location Service is disabled or unsupported.
  5. ' Check to see if the user has disabled the Location Service.
  6. If watcher.Permission = GeoPositionPermission.Denied Then
  7. ' The user has disabled the Location Service on their device.
  8. statusTextBlock.Text = "You have disabled Location Service."
  9. Else
  10. statusTextBlock.Text = "Location Service is not functioning on this device."
  11. End If
  12. Exit Select
  13. Case GeoPositionStatus.Initializing
  14. statusTextBlock.Text = "Location Service is retrieving data..."
  15. ' The Location Service is initializing.
  16. Exit Select
  17. Case GeoPositionStatus.NoData
  18. ' The Location Service is working, but it cannot get location data.
  19. statusTextBlock.Text = "Location data is not available."
  20. Exit Select
  21. Case GeoPositionStatus.Ready
  22. ' The Location Service is working and is receiving location data.
  23. statusTextBlock.Text = "Location data is available."
  24. Exit Select
  25. End Select
  26. End Sub

Maintenant que nous pouvons voir ce qui va se passer lorsque le service de localisation sera activé et que l'évènement StatusChanged est déclenché, implémentons la méthode qui s'occupe de l'initialisation et que l'on appellera startLocServInBackground. Cette méthode consistera en une seule ligne qui appelle la méthode TryStart de notre watcher, en spécifiant un timeout de 60 secondes pour l'initialisation. Parce que la méthode TryStart est synchrone, cela pourrait bloquer l'application sur une longue période si nous ne l'avions pas la lancer en arrière-plan, d'où l'utilisation d'un nouveau thread dans l'appel de startLocServInBackground dans la méthode MainPage. Le thread que nous avons démarré dans MainPage sera automatiquement arête avec la période de timeout de la method TryStart ou lorsque le watcher est initialisé avec succès et l’évènement watcher_StatusChanged est déjà implémenté pour gérer tout ce qui passe après l’initialisation :

C#
  1. void startLocServInBackground()
  2. {
  3. watcher.TryStart(true, TimeSpan.FromMilliseconds(60000));
  4. }
Visual Basic
  1. Private Sub startLocServInBackground()
  2. watcher.TryStart(True, TimeSpan.FromMilliseconds(60000))
  3. End Sub

Avant que nous n'implémentions watcher_PositionChanged, câblons deux boutons qui vont affecter le comportement de l'application lorsque le téléphone change de position. Nous appellerons ces deux boutons "Track Me On Map" et "Stop LocServ," et dans le XAML, vous verrez que nous avons spécifié des gestionnaires pour l'évènement Click pour chacun de ces boutons, nommés respectivement trackMe_Click et startStop_Click.

Ces deux méthodes sont liées à l'activation et la désactivation du service de localisation, la valeur booléenne trackingOn ainsi que watcher_PositionChanged met à jour ou non l'objet carte pour afficher la position actuelle du téléphone. De plus, un petit travail d'interface est fait pour modifier l'affichage du bouton et fournir un message de statut.

Un appel intéressant à l'objet Map est fait dans la méthode trackMe_Click. Si l'utilisateur spécifie qu'il veut voir sa position actuelle sur la carte, le niveau de zoom sur la carte passe de 1.0 (zoom arrière pour montrer la planète entière) à 16.0 (zoom au niveau des rues).

L'activation du service de localisation se fait encore en arrière-plan en utilisant startLocServInBackground. Les deux méthodes ressemblent à ceci:

C#
  1. private void trackMe_Click(object sender, RoutedEventArgs e)
  2. {
  3. if (trackingOn)
  4. {
  5. trackMe.Content = "Track Me On Map";
  6. trackingOn = false;
  7. myMap.ZoomLevel = 1.0f;
  8. }
  9. else
  10. {
  11. trackMe.Content = "Stop Tracking";
  12. trackingOn = true;
  13. myMap.ZoomLevel = 16.0f;
  14. }
  15. }
  16. private void startStop_Click(object sender, RoutedEventArgs e)
  17. {
  18. if (startStop.Content.ToString() == "Stop LocServ")
  19. {
  20. startStop.Content = "Start LocServ";
  21. statusTextBlock.Text = "Location Services stopped...";
  22. watcher.Stop();
  23. }
  24. else if (startStop.Content.ToString() == "Start LocServ")
  25. {
  26. startStop.Content = "Stop LocServ";
  27. statusTextBlock.Text = "Starting Location Services...";
  28. new Thread(startLocServInBackground).Start();
  29. }
  30. }
Visual Basic
  1. Private Sub trackMe_Click(sender As Object, e As RoutedEventArgs)
  2. If trackingOn Then
  3. trackMe.Content = "Track Me On Map"
  4. trackingOn = False
  5. myMap.ZoomLevel = 1.0F
  6. Else
  7. trackMe.Content = "Stop Tracking"
  8. trackingOn = True
  9. myMap.ZoomLevel = 16.0F
  10. End If
  11. End Sub
  12. Private Sub startStop_Click(sender As Object, e As RoutedEventArgs)
  13. If startStop.Content.ToString() = "Stop LocServ" Then
  14. startStop.Content = "Start LocServ"
  15. statusTextBlock.Text = "Location Services stopped..."
  16. watcher.[Stop]()
  17. ElseIf startStop.Content.ToString() = "Start LocServ" Then
  18. startStop.Content = "Stop LocServ"
  19. statusTextBlock.Text = "Starting Location Services..."
  20. New Thread(startLocServInBackground).Start()
  21. End If
  22. End Sub

Enfin, il y a la méthode watcher_PositionChanged qui gère l'évènement PositionChanged,. Cette méthode reçoit des informations à propos de la position actuellement dans l'objet GeoPositionChangedEventArgs, qui est passé en argument. Cet objet contient les informations à propos du périphérique, sa longitude, sa latitude, sa vitesse (en mètres par seconde), sa direction (une valeur flottante entre 0 et 360) et même l'altitude (en mètres au dessus du niveau de la mer). Nous allons afficher toutes ces données dans l'écran que nous avons créé plus tôt.

De plus, si l'utilisateur a cliqué le bouton "Track Me On Map", alors la variable trackingOn est définie à "true," et que la carte est zoomée au niveau de la rue, ainsi, dans la méthode watcher_PositionChanged nous vérifions la valeur trackingOn' et centrons la carte sur notre position actuelle si sa valeur est true. La méthode finale ressemble à ceci:

C#
  1. void watcher_PositionChanged(object sender, GeoPositionChangedEventArgs<GeoCoordinate> e)
  2. {
  3. //update the TextBlock readouts
  4. latitudeTextBlock.Text = e.Position.Location.Latitude.ToString("0.0000000000000");
  5. longitudeTextBlock.Text = e.Position.Location.Longitude.ToString("0.0000000000000");
  6. speedreadout.Text = e.Position.Location.Speed.ToString("0.0") + " meters per second";
  7. coursereadout.Text = e.Position.Location.Course.ToString("0.0");
  8. altitudereadout.Text = e.Position.Location.Altitude.ToString("0.0");
  9. // update the Map if the user has asked to be tracked.
  10. if (trackingOn)
  11. {
  12. // center the pushpin and map on the current position
  13. myPushpin.Location = e.Position.Location;
  14. myMap.Center = e.Position.Location;
  15. // if this is the first time that myPushpin is being plotted, plot it!
  16. if (myMap.Children.Contains(myPushpin) == false) {myMap.Children.Add(myPushpin);};
  17. }
  18. }
Visual Basic
  1. Private Sub watcher_PositionChanged(sender As Object, e As GeoPositionChangedEventArgs(Of GeoCoordinate))
  2. ' met jour les liblls
  3. latitudeTextBlock.Text = e.Position.Location.Latitude.ToString("0.0000000000000")
  4. longitudeTextBlock.Text = e.Position.Location.Longitude.ToString("0.0000000000000")
  5. speedreadout.Text = e.Position.Location.Speed.ToString("0.0") & " meters per second"
  6. coursereadout.Text = e.Position.Location.Course.ToString("0.0")
  7. altitudereadout.Text = e.Position.Location.Altitude.ToString("0.0")
  8. ' met jour la carte si l'utilisateur a demand connaitre sa position.
  9. If trackingOn Then
  10. ' centre la punaise et la carte sur la position actuelle
  11. myPushpin.Location = e.Position.Location
  12. myMap.Center = e.Position.Location
  13. ' si c'est le premire fois que la punaise est plante, on la plante!
  14. If myMap.Children.Contains(myPushpin) = False Then
  15. myMap.Children.Add(myPushpin)
  16. End If
  17. End If
  18. End Sub

Cette application est maintenant complète et vous avez un exemple de programme qui est structuré pour répondre à l'initialisation synchrone du service de localisation, pour garder trace du statut courant du service (qui est sujet à la qualité des signaux GPS et cellulaire) et aussi pour positionner une punaise sur une carte Bing qui affiche à la demande les rues ou la vue satellite.

Considérations finales

  • Nous utilisons le paramétrage high-accuracy dans cette application ce qui consommé rapidement la batterie du telephone. Essayez d’utiliser GeoPositionAccuracy.Default autant que possible, comme par exemple lorsque votre application recherche dans les environs.
  • Le paramétrage MovementThreshold est un élément clé de la consommation de la batterie, parce qu'en général, les données de position sont conséquentes et l’application ne devrait pas répondre à chaque fluctuation des données. Si l’évènement PositionChanged est déclenché trop fréquemment, la batterie et le temps de processeur seront consommés avec gâchis.
  • Parce que le service de localisation utilise une combinaison de données Wi-Fi, cellulaires et GPS, la position devient de plus en plus précise après que le service ait été démarré et au fur et à mesure qu'il reçoit des données. Les informations de réseau Wi-Fi et cellulaire sont généralement reçues en quelques secondes pendant que les données GPS peuvent prendre plusieurs minutes.
  • L'objet GeoCoordinateWatcher déclenche des évènements dans le thread UI. Cela signifie que vous voudrez réaliser le moins de travail possible dans les fonctions de gestionnaires des évènements PositionChanged et StatusChanged, ou n'importe quel autre évènement GeoCoordinateWatcher. Si un traitement important a besoin d'être fait lorsque ces évènements sont déclenchés, ayez des fonctions de traitement agissant dans des threads d'arrière-plan pour éviter que l'interface ne se fige.

Voir aussi


Cliquez ici pour revenir au sommaire de la liste d’articles

Skip to main content