Configurer une limite géographique
Configurez une limite géographique dans votre application et découvrez comment gérer les notifications au premier plan et en arrière-plan.
Activer la fonctionnalité d’emplacement
- Dans Explorateur de solutions, double-cliquez sur package.appxmanifest et sélectionnez l’onglet Fonctionnalités.
- Dans la liste Des fonctionnalités , vérifiez l’emplacement. Cela ajoute la fonctionnalité d’appareil
Locationau fichier manifeste du package.
<Capabilities>
<!-- DeviceCapability elements must follow Capability elements (if present) -->
<DeviceCapability Name="location"/>
</Capabilities>
Configuration de la limite géographique
Étape 1 : Demander l’accès à l’emplacement de l’utilisateur
Important
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 de l’utilisateur. 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.
Étape 2 : S’inscrire aux modifications apportées à l’état de limite géographique et aux autorisations d’emplacement
Dans cet exemple, une instruction switch 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 accède aux limites géographiques actuelles, s’inscrit aux modifications d’état de limite géographique et s’inscrit aux modifications apportées aux autorisations d’emplacement.
Conseil Lors de l’utilisation d’une limite géographique, surveillez les modifications apportées aux autorisations d’emplacement à l’aide de l’événement StatusChanged à partir de la classe GeofenceMonitor au lieu de l’événement StatusChanged de la classe Geolocator. Une geofenceMonitorStatus of Disabled équivaut à une positionStatus désactivée. Les deux indiquent que l’application n’a pas l’autorisation d’accéder à l’emplacement de l’utilisateur.
switch (accessStatus)
{
case GeolocationAccessStatus.Allowed:
geofences = GeofenceMonitor.Current.Geofences;
FillRegisteredGeofenceListBoxWithExistingGeofences();
FillEventListBoxWithExistingEvents();
// Register for state change events.
GeofenceMonitor.Current.GeofenceStateChanged += OnGeofenceStateChanged;
GeofenceMonitor.Current.StatusChanged += OnGeofenceStatusChanged;
break;
case GeolocationAccessStatus.Denied:
_rootPage.NotifyUser("Access denied.", NotifyType.ErrorMessage);
break;
case GeolocationAccessStatus.Unspecified:
_rootPage.NotifyUser("Unspecified error.", NotifyType.ErrorMessage);
break;
}
Ensuite, lors de la navigation loin de votre application de premier plan, annulez l’inscription des écouteurs d’événements.
protected override void OnNavigatingFrom(NavigatingCancelEventArgs e)
{
GeofenceMonitor.Current.GeofenceStateChanged -= OnGeofenceStateChanged;
GeofenceMonitor.Current.StatusChanged -= OnGeofenceStatusChanged;
base.OnNavigatingFrom(e);
}
Étape 3 : Créer la limite géographique
Vous êtes maintenant prêt à définir et configurer un objet Geofence. Il existe plusieurs surcharges de constructeur différentes à choisir, en fonction de vos besoins. Dans le constructeur de limite géographique le plus simple, spécifiez uniquement l’ID et la forme géographique comme indiqué ici.
// Set the fence ID.
string fenceId = "fence1";
// Define the fence location and radius.
BasicGeoposition position;
position.Latitude = 47.6510;
position.Longitude = -122.3473;
position.Altitude = 0.0;
double radius = 10; // in meters
// Set a circular region for the geofence.
Geocircle geocircle = new Geocircle(position, radius);
// Create the geofence.
Geofence geofence = new Geofence(fenceId, geocircle);
Vous pouvez affiner votre limite géographique en utilisant l’un des autres constructeurs. Dans l’exemple suivant, le constructeur de limite géographique spécifie les paramètres supplémentaires suivants :
- MonitoringStates : indique les événements de limite géographique que vous souhaitez recevoir pour entrer dans la région définie, quitter la région définie ou supprimer la limite géographique.
- SingleUse : supprime la limite géographique une fois que tous les états dont la limite géographique est surveillée ont été respectées.
- DwellTime : indique la durée pendant laquelle l’utilisateur doit se trouver dans ou hors de la zone définie avant que les événements d’entrée/sortie soient déclenchés.
- StartTime : indique quand démarrer la surveillance de la limite géographique.
- Durée : indique la période pour laquelle surveiller la limite géographique.
// Set the fence ID.
string fenceId = "fence2";
// Define the fence location and radius.
BasicGeoposition position;
position.Latitude = 47.6510;
position.Longitude = -122.3473;
position.Altitude = 0.0;
double radius = 10; // in meters
// Set the circular region for geofence.
Geocircle geocircle = new Geocircle(position, radius);
// Remove the geofence after the first trigger.
bool singleUse = true;
// Set the monitored states.
MonitoredGeofenceStates monitoredStates =
MonitoredGeofenceStates.Entered |
MonitoredGeofenceStates.Exited |
MonitoredGeofenceStates.Removed;
// Set how long you need to be in geofence for the enter event to fire.
TimeSpan dwellTime = TimeSpan.FromMinutes(5);
// Set how long the geofence should be active.
TimeSpan duration = TimeSpan.FromDays(1);
// Set up the start time of the geofence.
DateTimeOffset startTime = DateTime.Now;
// Create the geofence.
Geofence geofence = new Geofence(fenceId, geocircle, monitoredStates, singleUse, dwellTime, startTime, duration);
Après avoir créé, n’oubliez pas d’inscrire votre nouvelle limite géographique au moniteur.
// Register the geofence
try {
GeofenceMonitor.Current.Geofences.Add(geofence);
} catch {
// Handle failure to add geofence
}
Étape 4 : Gérer les modifications apportées aux autorisations d’emplacement
L’objet GeofenceMonitor 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 l’expéditeur de l’argument . Propriété Status (de type GeofenceMonitorStatus). 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;
...
public async void OnGeofenceStatusChanged(GeofenceMonitor sender, object e)
{
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
// Show the location setting message only if the status is disabled.
LocationDisabledMessage.Visibility = Visibility.Collapsed;
switch (sender.Status)
{
case GeofenceMonitorStatus.Ready:
_rootPage.NotifyUser("The monitor is ready and active.", NotifyType.StatusMessage);
break;
case GeofenceMonitorStatus.Initializing:
_rootPage.NotifyUser("The monitor is in the process of initializing.", NotifyType.StatusMessage);
break;
case GeofenceMonitorStatus.NoData:
_rootPage.NotifyUser("There is no data on the status of the monitor.", NotifyType.ErrorMessage);
break;
case GeofenceMonitorStatus.Disabled:
_rootPage.NotifyUser("Access to location is denied.", NotifyType.ErrorMessage);
// Show the message to the user to go to the location settings.
LocationDisabledMessage.Visibility = Visibility.Visible;
break;
case GeofenceMonitorStatus.NotInitialized:
_rootPage.NotifyUser("The geofence monitor has not been initialized.", NotifyType.StatusMessage);
break;
case GeofenceMonitorStatus.NotAvailable:
_rootPage.NotifyUser("The geofence monitor is not available.", NotifyType.ErrorMessage);
break;
default:
ScenarioOutput_Status.Text = "Unknown";
_rootPage.NotifyUser(string.Empty, NotifyType.StatusMessage);
break;
}
});
}
Configurer les notifications de premier plan
Une fois vos limites géographiques créées, vous devez ajouter la logique pour gérer ce qui se passe lorsqu’un événement de limite géographique se produit. Selon les MonitorStates que vous avez configurés , vous pouvez recevoir un événement lorsque :
- L’utilisateur entre dans une région d’intérêt.
- L’utilisateur quitte une région d’intérêt.
- La limite géographique a expiré ou a été supprimée. Notez qu’une application en arrière-plan n’est pas activée pour un événement de suppression.
Vous pouvez écouter les événements directement à partir de votre application lorsqu’elle est en cours d’exécution ou s’inscrire pour une tâche en arrière-plan afin de recevoir une notification en arrière-plan lorsqu’un événement se produit.
Étape 1 : S’inscrire aux événements de modification d’état de limite géographique
Pour que votre application reçoive une notification de premier plan d’un changement d’état de limite géographique, vous devez inscrire un gestionnaire d’événements. Cela est généralement configuré lorsque vous créez la limite géographique.
private void Initialize()
{
// Other initialization logic
GeofenceMonitor.Current.GeofenceStateChanged += OnGeofenceStateChanged;
}
Étape 2 : Implémenter le gestionnaire d’événements de limite géographique
L’étape suivante consiste à implémenter les gestionnaires d’événements. L’action effectuée ici dépend de ce que votre application utilise la limite géographique.
public async void OnGeofenceStateChanged(GeofenceMonitor sender, object e)
{
var reports = sender.ReadReports();
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
foreach (GeofenceStateChangeReport report in reports)
{
GeofenceState state = report.NewState;
Geofence geofence = report.Geofence;
if (state == GeofenceState.Removed)
{
// Remove the geofence from the geofences collection.
GeofenceMonitor.Current.Geofences.Remove(geofence);
}
else if (state == GeofenceState.Entered)
{
// Your app takes action based on the entered event.
// NOTE: You might want to write your app to take a particular
// action based on whether the app has internet connectivity.
}
else if (state == GeofenceState.Exited)
{
// Your app takes action based on the exited event.
// NOTE: You might want to write your app to take a particular
// action based on whether the app has internet connectivity.
}
}
});
}
Configurer des notifications en arrière-plan
Une fois vos limites géographiques créées, vous devez ajouter la logique pour gérer ce qui se passe lorsqu’un événement de limite géographique se produit. Selon les MonitorStates que vous avez configurés , vous pouvez recevoir un événement lorsque :
- L’utilisateur entre dans une région d’intérêt.
- L’utilisateur quitte une région d’intérêt.
- La limite géographique a expiré ou a été supprimée. Notez qu’une application en arrière-plan n’est pas activée pour un événement de suppression.
Pour écouter un événement de limite géographique en arrière-plan
- Déclarez la tâche en arrière-plan dans le manifeste de votre application.
- Inscrivez la tâche en arrière-plan dans votre application. Si votre application a besoin d’un accès Internet, par exemple pour accéder à un service cloud, vous pouvez définir un indicateur pour cela lorsque l’événement est déclenché. Vous pouvez également définir un indicateur pour vous assurer que l’utilisateur est présent lorsque l’événement est déclenché afin que vous soyez sûr que l’utilisateur reçoit une notification.
- Pendant que votre application s’exécute au premier plan, invitez l’utilisateur à accorder les autorisations d’emplacement de votre application.
Étape 1 : S’inscrire aux modifications de l’état de limite géographique
Dans le manifeste de votre application, sous l’onglet Déclarations , ajoutez une déclaration pour une tâche en arrière-plan d’emplacement. Pour ce faire :
- Ajoutez une déclaration de type Tâches en arrière-plan.
- Définissez un type de tâche de propriété location.
- Définissez un point d’entrée dans votre application pour appeler lorsque l’événement est déclenché.
Étape 2 : Inscrire la tâche en arrière-plan
Le code de cette étape inscrit la tâche en arrière-plan de géofencing. Rappelez-vous que lorsque la limite géographique a été créée, nous avons vérifié les autorisations d’emplacement.
async private void RegisterBackgroundTask(object sender, RoutedEventArgs e)
{
// Get permission for a background task from the user. If the user has already answered once,
// this does nothing and the user must manually update their preference via PC Settings.
BackgroundAccessStatus backgroundAccessStatus = await BackgroundExecutionManager.RequestAccessAsync();
// Regardless of the answer, register the background task. Note that the user can use
// the Settings app to prevent your app from running background tasks.
// Create a new background task builder.
BackgroundTaskBuilder geofenceTaskBuilder = new BackgroundTaskBuilder();
geofenceTaskBuilder.Name = SampleBackgroundTaskName;
geofenceTaskBuilder.TaskEntryPoint = SampleBackgroundTaskEntryPoint;
// Create a new location trigger.
var trigger = new LocationTrigger(LocationTriggerType.Geofence);
// Associate the location trigger with the background task builder.
geofenceTaskBuilder.SetTrigger(trigger);
// If it is important that there is user presence and/or
// internet connection when OnCompleted is called
// the following could be called before calling Register().
// SystemCondition condition = new SystemCondition(SystemConditionType.UserPresent | SystemConditionType.InternetAvailable);
// geofenceTaskBuilder.AddCondition(condition);
// Register the background task.
geofenceTask = geofenceTaskBuilder.Register();
// Associate an event handler with the new background task.
geofenceTask.Completed += new BackgroundTaskCompletedEventHandler(OnCompleted);
BackgroundTaskState.RegisterBackgroundTask(BackgroundTaskState.LocationTriggerBackgroundTaskName);
switch (backgroundAccessStatus)
{
case BackgroundAccessStatus.Unspecified:
case BackgroundAccessStatus.Denied:
rootPage.NotifyUser("This app is not allowed to run in the background.", NotifyType.ErrorMessage);
break;
}
}
Étape 3 : Gestion de la notification en arrière-plan
L’action que vous effectuez pour avertir l’utilisateur dépend de ce que fait votre application, mais vous pouvez afficher une notification toast, lire un son audio ou mettre à jour une vignette active. Le code de cette étape gère la notification.
async private void OnCompleted(IBackgroundTaskRegistration sender, BackgroundTaskCompletedEventArgs e)
{
if (sender != null)
{
// Update the UI with progress reported by the background task.
await Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
{
try
{
// If the background task threw an exception, display the exception in
// the error text box.
e.CheckResult();
// Update the UI with the completion status of the background task.
// The Run method of the background task sets the LocalSettings.
var settings = ApplicationData.Current.LocalSettings;
// Get the status.
if (settings.Values.ContainsKey("Status"))
{
rootPage.NotifyUser(settings.Values["Status"].ToString(), NotifyType.StatusMessage);
}
// Do your app work here.
}
catch (Exception ex)
{
// The background task had an error.
rootPage.NotifyUser(ex.ToString(), NotifyType.ErrorMessage);
}
});
}
}
Modifier les paramètres de confidentialité
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 the user's 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"));
Tester et déboguer votre application
Le test et le débogage d’applications de géofencing peuvent être un défi, car ils dépendent de l’emplacement d’un appareil. Ici, nous décrivons plusieurs méthodes pour tester à la fois les zones géographiques de premier plan et d’arrière-plan.
Pour déboguer une application de géofencing
- Déplacez physiquement l’appareil vers de nouveaux emplacements.
- Testez l’entrée d’une limite géographique en créant une région de limite géographique qui inclut votre emplacement physique actuel. Vous êtes donc déjà à l’intérieur de la limite géographique et l’événement « geofence entrée » est déclenché immédiatement.
- Utilisez l’émulateur Microsoft Visual Studio pour simuler des emplacements pour l’appareil.
Tester et déboguer une application de géofencing qui s’exécute au premier plan
Pour tester votre application de géofencing en cours d’exécution au premier plan
- Générez votre application dans Visual Studio.
- Lancez votre application dans l’émulateur Visual Studio.
- Utilisez ces outils pour simuler différents emplacements à l’intérieur et à l’extérieur de votre région de limite géographique. Veillez à attendre suffisamment longtemps après l’heure spécifiée par la propriété DwellTime pour déclencher l’événement. Notez que vous devez accepter l’invite pour activer les autorisations d’emplacement pour l’application. Pour plus d’informations sur la simulation d’emplacements, consultez Définir la géolocalisation simulée de l’appareil.
- Vous pouvez également utiliser l’émulateur pour estimer la taille des clôtures et des durées de vie environ nécessaires à la détection à différentes vitesses.
Tester et déboguer une application de géofencing en cours d’exécution en arrière-plan
Pour tester votre application de géofencing qui exécute l’arrière-plan
- Générez votre application dans Visual Studio. Notez que votre application doit définir le type de tâche d’arrière-plan Emplacement .
- Déployez d’abord l’application localement.
- Fermez votre application en cours d’exécution localement.
- Lancez votre application dans l’émulateur Visual Studio. Notez que la simulation de géofencing en arrière-plan est prise en charge sur une seule application à la fois dans l’émulateur. Ne lancez pas plusieurs applications de géofencing au sein de l’émulateur.
- À partir de l’émulateur, simulez différents emplacements à l’intérieur et à l’extérieur de votre région de limite géographique. Veillez à attendre suffisamment longtemps après le DwellTime pour déclencher l’événement. Notez que vous devez accepter l’invite pour activer les autorisations d’emplacement pour l’application.
- Utilisez Visual Studio pour déclencher la tâche en arrière-plan de l’emplacement. Pour plus d’informations sur le déclenchement de tâches en arrière-plan dans Visual Studio, consultez Guide pratique pour déclencher des tâches en arrière-plan.
Résoudre les problèmes de votre application
Pour que votre application puisse accéder à l’emplacement, 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