Partager via

Obtenir la localisation de l’utilisateur

  • Article

Important

Retrait du service Bing Maps for Enterprise

Le MapControl UWP et les services cartographiques de l'espace de noms Windows.Services.Maps reposent sur Bing Maps. Bing Maps for Enterprise est obsolète et sera supprimé. À ce moment-là, le MapControl et les services ne recevront plus de données.

Pour plus d'informations, consultez le centre de développement de Bing Maps et la documentation de Bing Maps.

Remarque

MapControl et les services de carte nécessitent une clé d’authentification de cartes appelée MapServiceToken. Pour plus d’informations sur l’obtention et la définition d’une clé d’authentification de cartes, voir Demander une clé d’authentification de cartes.

Recherchez l’emplacement de l’utilisateur et répondez aux modifications apportées à l’emplacement. L’accès à l’emplacement de l’utilisateur est géré par les paramètres de confidentialité dans l’application Paramètres Windows. Cette rubrique montre également comment vérifier si votre application est autorisée à accéder à l’emplacement de l’utilisateur.

Activer la fonctionnalité d’emplacement

  1. Dans Explorateur de solutions, double-cliquez sur package.appxmanifest et sélectionnez l’onglet Fonctionnalités.
  2. Dans la liste des fonctionnalités , cochez la case pour l’emplacement. Cela ajoute la fonctionnalité d’appareil location au fichier manifeste du package.
  <Capabilities>
    <!-- DeviceCapability elements must follow Capability elements (if present) -->
    <DeviceCapability Name="location"/>
  </Capabilities>

Obtenir la position actuelle

Cette section explique comment détecter l’emplacement géographique de l’utilisateur à l’aide d’API dans l’espace de noms Windows.Devices.Geolocation .

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

À moins que votre application ne dispose d’une fonctionnalité d’emplacement grossière (voir la remarque), vous devez demander l’accès à l’emplacement de l’utilisateur à l’aide de la méthode RequestAccessAsync avant de tenter d’accéder à l’emplacement. Vous devez appeler la méthode RequestAccessAsync à partir du thread d’interface utilisateur et votre application doit être au premier plan. Votre application ne pourra pas accéder aux informations d’emplacement de l’utilisateur tant que l’utilisateur n’a pas accordé l’autorisation à votre application.*

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

La méthode RequestAccessAsync invite l’utilisateur à accéder à son emplacement. L’utilisateur n’est invité qu’une seule fois (par application). Après la première fois qu’ils accordent ou refusent l’autorisation, cette méthode n’invite plus l’utilisateur à obtenir l’autorisation. Pour aider l’utilisateur à modifier les autorisations d’emplacement une fois qu’il a été invité, nous vous recommandons de fournir un lien vers les paramètres d’emplacement, comme illustré plus loin dans cette rubrique.

Remarque

La fonctionnalité d’emplacement grossière permet à votre application d’obtenir un emplacement intentionnellement obfusqué (imprécisé) sans obtenir l’autorisation explicite de l’utilisateur (le commutateur d’emplacement à l’échelle du système doit toujours être activé, toutefois). Pour savoir comment utiliser un emplacement grossière dans votre application, consultez la méthode AllowFallbackToConsentlessPositions dans la classe Geolocator.

Étape 2 : Obtenir l’emplacement de l’utilisateur et s’inscrire aux modifications apportées aux autorisations d’emplacement

La méthode GetGeopositionAsync effectue une lecture unique de l’emplacement actuel. Ici, une switch instruction est utilisée avec accessStatus (de l’exemple précédent) pour agir uniquement lorsque l’accès à l’emplacement de l’utilisateur est autorisé. Si l’accès à l’emplacement de l’utilisateur est autorisé, le code crée un objet Geolocator , s’inscrit aux modifications apportées aux autorisations d’emplacement et demande l’emplacement de l’utilisateur.

switch (accessStatus)
{
    case GeolocationAccessStatus.Allowed:
        _rootPage.NotifyUser("Waiting for update...", NotifyType.StatusMessage);

        // If DesiredAccuracy or DesiredAccuracyInMeters are not set (or value is 0), DesiredAccuracy.Default is used.
        Geolocator geolocator = new Geolocator { DesiredAccuracyInMeters = _desireAccuracyInMetersValue };

        // Subscribe to the StatusChanged event to get updates of location status changes.
        _geolocator.StatusChanged += OnStatusChanged;

        // Carry out the operation.
        Geoposition pos = await geolocator.GetGeopositionAsync();

        UpdateLocationData(pos);
        _rootPage.NotifyUser("Location updated.", NotifyType.StatusMessage);
        break;

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

    case GeolocationAccessStatus.Unspecified:
        _rootPage.NotifyUser("Unspecified error.", NotifyType.ErrorMessage);
        UpdateLocationData(null);
        break;
}

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

L’objet Geolocator déclenche l’événement StatusChanged pour indiquer que les paramètres d’emplacement de l’utilisateur ont changé. Cet événement transmet l’état correspondant via la propriété Status de l’argument (de type PositionStatus). Notez que cette méthode n’est pas appelée à partir du thread d’interface utilisateur et que l’objet Dispatcher appelle les modifications apportées à 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 any cached location data.
                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;
        }
    });
}

Répondre aux mises à jour d’emplacement

Cette section explique comment utiliser l’événement PositionChanged pour recevoir des mises à jour de l’emplacement de l’utilisateur sur une période donnée. Étant donné que l’utilisateur peut révoquer l’accès à l’emplacement à tout moment, il est important d’appeler RequestAccessAsync et d’utiliser l’événement StatusChanged comme indiqué dans la section précédente.

Cette section suppose que vous avez déjà activé la fonctionnalité d’emplacement et appelé RequestAccessAsync à partir du thread d’interface utilisateur de votre application de premier plan.

Étape 1 : Définir l’intervalle de rapport et s’inscrire aux mises à jour d’emplacement

Dans cet exemple, une switch instruction est utilisée avec accessStatus (à partir de l’exemple précédent) pour agir uniquement lorsque l’accès à l’emplacement de l’utilisateur est autorisé. Si l’accès à l’emplacement de l’utilisateur est autorisé, le code crée un objet Geolocator , spécifie le type de suivi et s’inscrit pour les mises à jour d’emplacement.

L’objet Geolocator peut déclencher l’événement PositionChanged en fonction d’un changement de position (suivi basé sur la distance) ou d’un changement dans le temps (suivi périodique).

Si aucune propriété n’est définie, une position est retournée toutes les 1 secondes (équivalente à ReportInterval = 1000). Ici, un intervalle de rapport de 2 secondes (ReportInterval = 2000) est utilisé.

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

switch (accessStatus)
{
    case GeolocationAccessStatus.Allowed:
        // Create Geolocator and define periodic-based tracking (2 second interval).
        _geolocator = new Geolocator { ReportInterval = 2000 };

        // Subscribe to the PositionChanged event to get location updates.
        _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("Unspecified error!", NotifyType.ErrorMessage);
        LocationDisabledMessage.Visibility = Visibility.Collapsed;
        break;
}

Étape 2 : Gérer les mises à jour d’emplacement

L’objet Geolocator déclenche l’événement PositionChanged pour indiquer que l’emplacement de l’utilisateur a changé ou que le temps est passé, selon la façon dont vous l’avez configuré. Cet événement transmet l’emplacement correspondant via la propriété Position de l’argument (de type Geoposition). Dans cet exemple, la méthode n’est pas appelée à partir du thread d’interface utilisateur et l’objet Dispatcher appelle les modifications de l’interface utilisateur.

using Windows.UI.Core;
...
async private void OnPositionChanged(Geolocator sender, PositionChangedEventArgs e)
{
    await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
    {
        _rootPage.NotifyUser("Location updated.", NotifyType.StatusMessage);
        UpdateLocationData(e.Position);
    });
}

Modifier les paramètres de confidentialité de l’emplacement

Si les paramètres de confidentialité de l’emplacement n’autorisent pas votre application à accéder à l’emplacement de l’utilisateur, nous vous recommandons de fournir un lien pratique vers les paramètres de confidentialité de l’emplacement dans l’application Paramètres. Dans cet exemple, un contrôle Hyperlink est utilisé pour accéder à l’URI ms-settings:privacy-location .

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

Vous pouvez également appeler la méthode LaunchUriAsync pour lancer l’application Paramètres à partir du code. Pour plus d’informations, voir Lancer l’application Paramètres de Windows.

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

Résoudre les problèmes de votre application

Pour que votre application puisse accéder à l’emplacement de l’utilisateur, l’emplacement doit être activé sur l’appareil. Dans l’application Paramètres, vérifiez que les paramètres de confidentialité de l’emplacement suivants sont activés :

  • Emplacement de cet appareil... est activé (non applicable dans Windows 10 Mobile)
  • Le paramètre des services d’emplacement, Emplacement, est activé
  • Sous Choisir des applications qui peuvent utiliser votre emplacement, votre application est définie sur