Applications Windows
Réduire la table des matières
Développer la table des matières

Répondre aux mises à jour de localisation basées sur la distance (XAML)

[Cette documentation est une version préliminaire qui peut faire l’objet de modifications.]

Découvrez comment recevoir des mises à jour lorsque l’utilisateur se déplace au-delà d’une distance spécifiée. La distance entre les mises à jour de localisation est connue sous le nom de seuil de déplacement. Cette rubrique utilise des exemples de code qui étendent la portion Suivi de la position de l’exemple de géolocalisation. Téléchargez l’exemple et regardez comment utiliser le seuil de déplacement pour contrôler le lieu où les mises à jour de localisation se produisent.

Feuille de route : comment cette rubrique s’articule-t-elle par rapport aux autres ? Voir :

Étape 1: Télécharger l’exemple de géolocalisation, ajouter une interface utilisateur et définir de nouvelles propriétés

Téléchargez l’exemple de géolocalisation Windows 10 Technical Preview et ouvrez le fichier Scenario1_TrackPosition.xaml. Dans cette étape, vous ajouterez des éléments d’interface utilisateur pour spécifier le seuil de déplacement.

Tout d’abord, ajoutez un élément RowDefinition pour l’interface utilisateur du seuil de déplacement à la fin de l’élément <Grid.RowDefinitions>, comme illustré ici.


<Grid.RowDefinitions>
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <RowDefinition Height="Auto" />
    <!--Added for entering movement threshold-->
    <RowDefinition Height="Auto" />
</Grid.RowDefinitions>

Puis, après le bloc de texte ScenarioOutput_Accuracy et avant la fin du </Grid>, ajoutez les éléments d’interface utilisateur suivants.


<!--Added for entering movement threshold-->
<TextBlock TextWrapping="Wrap" Margin="0,0,10,0" Grid.Row="4" 
            Grid.Column="0" Style="{StaticResource BasicTextStyle}" 
            HorizontalAlignment="Left" VerticalAlignment="Center" 
            Text="Movement threshold (meters): " />
                
<TextBox x:Name="ScenarioIntput_MovementThreshold" 
            TextWrapping="Wrap" Grid.Row="4" Grid.Column="1" 
            HorizontalAlignment="Left" VerticalAlignment="Center" Text="3" />

Ensuite, ouvrez le fichier Scenario1_TrackPosition.xaml.cs et ajoutez le prevLatitude, le prevLongitude, puis les variables de classe privée totalDistance à la classe partielle Scenario1:Page, comme illustré ci-dessous. Cela vous permettra d’effectuer le suivi de la distance parcourue.


public sealed partial class Scenario1 : Page
{
    // Proides access to location data
    private Geolocator _geolocator = null;

    // A pointer to the main page
    private MainPage _rootPage = MainPage.Current;

    // Distance tracking variables
    private double prevLatitude = -1;
    private double prevLongitude = -1;
    private double totalDistance = 0;

...
...

Étape 2: Vérifier que la localisation est activée

Pour que votre application puisse accéder à la fonction de localisation, l’option Emplacement doit être activée sur l’appareil. Dans l’application Paramètres, vérifiez que les paramètres de confidentialité relatifs à la géolocalisation suivants sont bien activés :

  • Le paramètre Emplacement est activé.
  • Le paramètre Autoriser Windows et les applications sélectionnées à utiliser votre emplacement et l’historique relatif à vos emplacements est activé.
  • Sous Choisir les applications qui peuvent utiliser votre emplacement, votre application est définie sur Activé.

Remarque  Dans certains cas, les paramètres Emplacement et Choisir les applications qui peuvent utiliser votre emplacement ne seront pas disponibles.

Étape 3: Activer la fonctionnalité de localisation

La fonctionnalité de localisation est déjà activée dans l’exemple de géolocalisation. Cette étape est simplement un rappel pour les nouvelles applications. Pour ajouter cette fonctionnalité, double-cliquez sur package.appxmanifest dans l’ Explorateur de solutions, puis sélectionnez l’onglet Capacités. Activez Emplacement dans la liste Capacités. Cette opération ajoute la fonctionnalité Location de l’appareil au fichier manifeste du package.


  <Capabilities>
    <!-- DeviceCapability elements must follow Capability elements (if present) -->
    <DeviceCapability Name="location"/>
  </Capabilities>

Étape 4: Demander l’accès à l’emplacement de l’utilisateur

Comme illustré dans le fichier Scenario1_TrackPosition.xaml.cs de l’exemple de géolocalisation, il est important de demander l’accès à l’emplacement de l’utilisateur à l’aide de la méthode RequestAccessAsync.

Important  Appelez le RequestAccessAsync avant d’accéder à l’emplacement de l’utilisateur. À ce stade, votre application doit être au premier plan et RequestAccessAsync doit être appelée à partir du thread d’interface utilisateur. Jusqu’à ce que l’utilisateur l’y autorise, votre application ne peut pas accéder aux données d’emplacement.


using Windows.Devices.Geolocation;
...
var accessStatus = await Geolocator.RequestAccessAsync();

La méthode RequestAccessAsync demande à l’utilisateur l’autorisation d’accéder à son emplacement. L’utilisateur est invité uniquement une fois (par application). Une fois la première autorisation accordée ou refusée, cette méthode ne demande plus l’autorisation. Pour aider l’utilisateur à modifier les autorisations d’emplacement une fois qu’ils ont été invités, nous vous recommandons de fournir un lien vers les paramètres d’emplacement, comme illustré plus loin dans cette rubrique.

Étape 5: Définir le seuil de déplacement et enregistrer les mises à jour de localisation

Dans le fichier Scenario1_TrackPosition.xaml.cs de l’exemple de géolocalisation, remplacez les méthodes StartTracking et StopTracking par le code de l’exemple suivant. Ce nouveau code utilise la propriété MovementThreshold pour spécifier le degré de changement de l’emplacement qui déclenchera l’événement PositionChanged. Dans ce cas, la valeur de seuil de déplacement provient de la zone de texte ScenarioIntput_MovementThreshold ajoutée à l’étape précédente.

Une instruction switch est utilisée avec la propriété accessStatus afin d’agir uniquement lorsque l’accès à l’emplacement est autorisé. Si l’accès est autorisé, le code crée un objet Geolocator, spécifie le type de suivi et enregistre les mises à jour de localisation.



 private async void StartTracking(object sender, RoutedEventArgs e)
{
    // Request permission to access location
    var accessStatus = await Geolocator.RequestAccessAsync();

    switch (accessStatus)
    {
        case GeolocationAccessStatus.Allowed:

            // Disable movement threshold textbox
            ScenarioIntput_MovementThreshold.IsEnabled = false;

            // Create Geolocator and define the movement threshold (in meters)
            _geolocator = new Geolocator();
            _geolocator.MovementThreshold = float.Parse(ScenarioIntput_MovementThreshold.Text);

            // Subscribe to PositionChanged event to get updated tracking positions
            _geolocator.PositionChanged += OnPositionChanged;

            // Subscribe to StatusChanged event to get updates of location status changes
            _geolocator.StatusChanged += OnStatusChanged;
                    
            _rootPage.NotifyUser("Waiting for update...", NotifyType.StatusMessage);
            LocationDisabledMessage.Visibility = Visibility.Collapsed;
            StartTrackingButton.IsEnabled = false;
            StopTrackingButton.IsEnabled = true;
            break;

        case GeolocationAccessStatus.Denied:
            _rootPage.NotifyUser("Access to location is denied.", NotifyType.ErrorMessage);
            LocationDisabledMessage.Visibility = Visibility.Visible;
            break;

        case GeolocationAccessStatus.Unspecified:
            _rootPage.NotifyUser("Unspecificed error!", NotifyType.ErrorMessage);
            LocationDisabledMessage.Visibility = Visibility.Collapsed;
            break;
    }
}


private void StopTracking(object sender, RoutedEventArgs e)
{
    _geolocator.PositionChanged -= OnPositionChanged;
    _geolocator.StatusChanged -= OnStatusChanged;
    _geolocator = null;

    StartTrackingButton.IsEnabled = true;
    StopTrackingButton.IsEnabled = false;

    // Enable movement threshold textbox
    ScenarioIntput_MovementThreshold.IsEnabled = true;

    // Clear status
    _rootPage.NotifyUser("Tracking stopped.", NotifyType.StatusMessage);
}

Étape 6: Gérer les mises à jour de localisation

Dans le fichier Scenario1_TrackPosition.xaml.cs de l’exemple de géolocalisation, remplacez la méthode OnPositionChanged par le code de l’exemple suivant. Ce nouveau code utilise la position actuelle pour calculer la distance depuis la dernière mise à jour (updateDistance) et la distance totale depuis le début du suivi (totalDistance).

L’objet Geolocator déclenche l’événement PositionChanged afin d’indiquer que l’emplacement de l’utilisateur a changé. Cet événement transmet l’emplacement correspondant via la propriété de l’argument Position (de type Geoposition). Comme indiqué dans l’exemple, la méthode n’est pas appelée à partir du thread d’interface utilisateur et l’objet Dispatcher invoque les modifications de l’interface utilisateur.


async private void OnPositionChanged(Geolocator sender, PositionChangedEventArgs e)
{
    await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
    {
        double updateDistance = 0;

        // Calculate distance;
        if ((prevLatitude == -1) || (prevLongitude == -1))
        {
            updateDistance = 0;
        }
        else
        {
            updateDistance = CalculateDistance(prevLatitude, prevLongitude,
               e.Position.Coordinate.Point.Position.Latitude, 
               e.Position.Coordinate.Point.Position.Longitude);
        }

        // Update tracking
        prevLatitude = e.Position.Coordinate.Point.Position.Latitude;
        prevLongitude = e.Position.Coordinate.Point.Position.Longitude;
        totalDistance += updateDistance;

        // Update UI
        _rootPage.NotifyUser("Latest distance: " + 
            updateDistance.ToString("F2") +
            " meters,  Total distance: " +
            totalDistance.ToString("F2") +
            " meters", 
            NotifyType.StatusMessage);

        UpdateLocationData(e.Position);
    });
}

Étape 7: Calculer la distance

Dans le fichier Scenario1_TrackPosition.xaml.cs de l’exemple de géolocalisation, ajoutez la méthode CalculateDistance indiquée dans l’exemple suivant. Cette méthode utilise la formule de Haversine pour calculer la distance entre deux emplacements géographiques.


private double CalculateDistance(double prevLat, double prevLong, double currLat, double currLong)
{
    const double degreesToRadians = (Math.PI / 180.0);
    const double earthRadius = 6371; // kilometers

    // convert latitude and longitude values to radians
    var prevRadLat = prevLat * degreesToRadians;
    var prevRadLong = prevLong * degreesToRadians;
    var currRadLat = currLat * degreesToRadians;
    var currRadLong = currLong * degreesToRadians;

    // calculate radian delta between each position.
    var radDeltaLat = currRadLat - prevRadLat;
    var radDeltaLong = currRadLong - prevRadLong;

    // calculate distance
    var expr1 = (Math.Sin(radDeltaLat / 2.0) *
                    Math.Sin(radDeltaLat / 2.0)) +

                (Math.Cos(prevRadLat) *
                    Math.Cos(currRadLat) *
                    Math.Sin(radDeltaLong / 2.0) *
                    Math.Sin(radDeltaLong / 2.0));

    var expr2 = 2.0 * Math.Atan2(Math.Sqrt(expr1),
                                    Math.Sqrt(1 - expr1));

    var distance = (earthRadius * expr2);
    return distance * 1000;  // return results as meters
}

Étape 8: Gérer les modifications apportées aux autorisations d’emplacement

Comme illustré dans l’exemple de géolocalisation, PositionStatus peut être utilisé pour vérifier l’état actuel des autorisations d’emplacement. Vous devez effectuer cette vérification au cas où les paramètres d’emplacement de l’utilisateur sont modifiés lorsque votre application est en cours d’exécution au premier plan. Cette fois encore, la méthode n’est pas appelée à partir du thread d’interface utilisateur et l’objet Dispatcher invoque les modifications de l’interface utilisateur.



using Windows.UI.Core;
...
async private void OnStatusChanged(Geolocator sender, StatusChangedEventArgs e)
{
    await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
    {
        // Show the location setting message only if status is disabled.
        LocationDisabledMessage.Visibility = Visibility.Collapsed;

        switch (e.Status)
        {
            case PositionStatus.Ready:
                // Location platform is providing valid data.
                ScenarioOutput_Status.Text = "Ready";
                _rootPage.NotifyUser("Location platform is ready.", NotifyType.StatusMessage);
                break;

            case PositionStatus.Initializing:
                // Location platform is attempting to acquire a fix. 
                ScenarioOutput_Status.Text = "Initializing";
                _rootPage.NotifyUser("Location platform is attempting to obtain a position.", NotifyType.StatusMessage);
                break;

            case PositionStatus.NoData:
                // Location platform could not obtain location data.
                ScenarioOutput_Status.Text = "No data";
                _rootPage.NotifyUser("Not able to determine the location.", NotifyType.ErrorMessage);
                break;

            case PositionStatus.Disabled:
                // The permission to access location data is denied by the user or other policies.
                ScenarioOutput_Status.Text = "Disabled";
                _rootPage.NotifyUser("Access to location is denied.", NotifyType.ErrorMessage);

                // Show message to the user to go to location settings
                LocationDisabledMessage.Visibility = Visibility.Visible;

                // Clear cached location data if any
                UpdateLocationData(null);
                break;

            case PositionStatus.NotInitialized:
                // The location platform is not initialized. This indicates that the application 
                // has not made a request for location data.
                ScenarioOutput_Status.Text = "Not initialized";
                _rootPage.NotifyUser("No request for location is made yet.", NotifyType.StatusMessage);
                break;

            case PositionStatus.NotAvailable:
                // The location platform is not available on this version of the OS.
                ScenarioOutput_Status.Text = "Not available";
                _rootPage.NotifyUser("Location is not available on this version of the OS.", NotifyType.ErrorMessage);
                break;

            default:
                ScenarioOutput_Status.Text = "Unknown";
                _rootPage.NotifyUser(string.Empty, NotifyType.StatusMessage);
                break;
        }
    });
}

Étape 9: Aider l’utilisateur à modifier les paramètres d’emplacement

Si les paramètres de localisation n’autorisent votre application à accéder à l’emplacement de l’utilisateur, nous vous recommandons de fournir un lien pratique vers les paramètres de confidentialité d’emplacement dans l’application Paramètres. L’exemple de géolocalisation utilise un contrôle de lien hypertexte, comme indiqué ci-dessous, pour naviguer vers l’URI ms-settings://privacy/location.


        <TextBlock x:Name="LocationDisabledMessage" FontStyle="Italic" 
                   Visibility="Collapsed" Margin="0,15,0,0" TextWrapping="Wrap" >
            <Run Text="This app is not able to get location data. Go to" />
                <Hyperlink NavigateUri="ms-settings://privacy/location">
                    <Run Text="Settings" />
                </Hyperlink>
            <Run Text="to check the location privacy settings."/>

Par ailleurs, votre application peut appeler la méthodeLaunchUriAsync pour lancer l’application Paramètres à partir du code. Pour plus d’informations, voir Comment afficher des pages de paramètres intégrées via le protocole ms-settings.


using Windows.System;
...
bool result = await Launcher.LaunchUriAsync(new Uri("ms-settings://privacy/location"));

Étape 10: Tester le nouveau code

Avant de commencer à tester l’application, gardez à l’esprit les éléments suivants :

  • L’utilisation d’un seuil de déplacement pour déclencher les mises à jour de localisation nécessite le déplacement physique de l’appareil ou la simulation d’un nouvel emplacement avec l’émulateur. Pour plus d’informations sur la simulation d’emplacements, voir Définir la localisation géographique simulée du périphérique.
  • En fonction de la source des données de localisation, l’imprécision de votre emplacement peut dépasser considérablement le seuil de déplacement spécifié. Par exemple, un emplacement de Wi-Fi peut varier entre 30 mètres et 500 mètres. Pour plus d’informations sur les sources de localisation, voir Windows.Devices.Geolocation.

Pour commencer à tester le nouveau code, procédez comme suit :

  1. Dans le menu Déboguer, cliquez sur Démarrer le débogage pour tester la solution.
  2. Sélectionnez Suivi de la position pour afficher la page Scenario1_TrackPosition.xaml.cs qui a été modifiée.
  3. Appuyez sur la touche Démarrer le suivi pour commencer le suivi basé sur le mouvement.
  4. La première fois que vous exécutez l’exemple, une invite vous demande si l’application peut utiliser votre localisation. Choisissez l’option Autoriser.
  5. Déplacez votre appareil en dehors du seuil de déplacement spécifié (qui garantit la précision de l’emplacement) et voyez les valeurs updateDistance et totalDistance changer dans l’interface utilisateur.

Rubriques associées

Exemple de géolocalisation Windows 10 Technical Preview
Exemple de géolocalisation Windows 8.1
Exemples du Kit de développement logiciel (SDK) des cartes Bing
Windows.Devices.Geolocation
Recommandations en matière d’utilisation de périphériques sensibles

 

 

Afficher:
© 2017 Microsoft