Déclencher des zones de géorepérage côté client pour suivre les ressources mobiles avec le SDK Nav

Ce document décrit le géorepérage côté client, les cas d'utilisation et la façon de l'appliquer aux cas d'utilisation dans une application mobile. Il explique également comment implémenter un exemple sur Android à l'aide du SDK Navigation Google.

<ph type="x-smartling-placeholder"></ph> SDK Nav avec détection du géorepérage
SDK Nav avec détection du géorepérage

Les entreprises ont souvent besoin de savoir quand un appareil mobile arrive sur un dans une zone géographique spécifique. Pour cela, des limites géographiques virtuelles doivent être maintenues. les zones de géorepérage, ce qui permet aux logiciels de déclencher des événements lorsqu'un appareil franchit une limite.

Il est important de savoir quand un véhicule traverse une limite pour plusieurs cas d'utilisation, par exemple :

  • Engagement client : les entreprises peuvent utiliser le géorepérage pour envoyer des notifications push aux utilisateurs finaux concernant des offres spéciales, des événements ou de nouveaux produits.
  • Sécurité et sécurité: les entreprises peuvent utiliser le géorepérage pour créer des périmètres virtuels autour de zones sensibles, telles que les centres de données ou les entrepôts, et alerter le personnel de sécurité si quelqu'un entre dans une zone ou en sort.
  • Transports: les entreprises peuvent utiliser le géorepérage pour suivre la position des véhicules, et optimiser les itinéraires et les horaires.

Il est donc important que vous sachiez comment représenter ces zones (polygones) dans une application destinée aux clients. Cette application doit suivre la position de l'appareil et vérifier s'il a franchi une certaine zone géographique.

Portée

Ce document se concentre sur une implémentation côté client du géorepérage. Cela signifie que l'application cliente doit disposer des éléments suivants :

  1. Les polygones qu'il doit vérifier pour détecter les violations
  2. Position en temps réel de l'utilisateur
  3. Logique pour vérifier si la position actuelle se trouve à l'intérieur ou à l'extérieur des polygones.

Ce guide inclut des exemples sur Android, mais il existe des méthodes équivalentes pour y parvenir sur iOS. Le service de localisation Android dispose d'une implémentation intégrée pour les géorepérages circulaires, que vous pouvez consulter sur cette page. Le code de référence et la description ci-dessous constituent un point de départ pour des implémentations plus complexes.

Le SDK Navigation est une bibliothèque Android / iOS native ajoutée à l'application du pilote. Elle est responsable des points suivants:

  • Obtenir les positions ancrées sur la route à partir de l'application qui l'exécute Cette méthode est plus précise que FusedLocationProvider (FLP) d'Android, car elle utilise le réseau routier de Google pour associer les positions au segment routier le plus proche, ce qui rend l'heure d'arrivée beaucoup plus précise, ainsi que d'autres informations de FLP.
  • Fonctionnalité de navigation détaillée permettant aux conducteurs de se rendre efficacement d'un point A à un point B en tenant compte du trafic en temps réel et d'autres restrictions d'itinéraire.
  • Déclenchement d'événements via des écouteurs d'événements et des rappels enregistrés

Écouteurs

Le SDK Navigation propose de nombreux écouteurs que vous pouvez utiliser. dont les suivants :

  • Modifications d'emplacement via le fournisseur RoadSnappedLocation
  • Événements de rediversion (l'utilisateur ne fait pas demi-tour, ne tourne pas à gauche, etc. et s'écarte de l'itinéraire recommandé) via ReroutingListener.
  • Les événements d'arrivée (l'utilisateur arrive à la destination prévue) via ArrivalListener.
  • Événements de distance restante et d'heure d'arrivée prévue (recevoir une notification lorsque le conducteur est sur le point d'arriver à destination, en fonction des mètres ou du temps) disponibles via RemainingTimeOrDistanceChangedListener

Dans ce guide, seul le RoadSnappedLocationProvider et son LocationListener sont utilisés.

La solution de géorepérage côté client

Voyons maintenant comment créer une fonctionnalité de géorepérage côté client. Dans l'exemple ci-dessous, le SDK Navigation fonctionne en mode "Itinéraire détaillé" et un polygone est défini dans l'itinéraire pour représenter notre géorepérage.

Schéma fonctionnel
Schéma fonctionnel

  1. Les géorepérages sont stockés dans BigQuery et récupérés par votre backend.
  2. Le backend envoie régulièrement les zones de géorepérage aux applications Drive.
  3. Le pilote effectue la navigation, et l'application du pilote vérifie régulièrement les zones de géorepérage pour détecter un déclencheur.
  4. L'application conducteur informe le backend d'un événement de déclenchement afin qu'il puisse agir.

À mesure que le véhicule avance sur le parcours, l'application vérifie régulièrement si le polygone a été franchi. Lorsque l'application détecte qu'elle a franchi une zone de géorepérage, un message Zone de géorepérage franchie s'affiche dans l'UI.

Configurer les dépendances pour Android-Maps-Utils

Cette solution utilise Android-Maps-Utils, une bibliothèque Open Source contenant des utilitaires utiles pour un large éventail d'applications utilisant l'API Google Maps Android.

Cette bibliothèque est publique et hébergée sur GitHub. Vous pouvez y accéder à l'adresse suivante:

  • Android : https://github.com/googlemaps/android-maps-utils
  • iOS : https://github.com/googlemaps/google-maps-ios-utils

Pour inclure cette bibliothèque dans votre application Android (champ d'application de ce document), vous devez modifier votre fichier build.gradle pour l'inclure. Notez que ce fichier build.gradle est destiné au module (application) que vous compilez, et non au niveau du projet.

dependencies {
   ...
   // Utilities for Maps SDK for Android (requires Google Play Services)
   implementation 'com.google.maps.android:android-maps-utils:2.3.0'
}

Ensuite, après avoir synchronisé Gradle avec votre dernier fichier build.gradle, vous pouvez importer com.google.maps.android.PolyUtil dans votre fichier Java :

import com.google.android.gms.maps.model.PolygonOptions;
import com.google.maps.android.PolyUtil;

Définir vos zones de géorepérage

Notez que dans ce cas, PolygonOptions est également en cours d'importation. En effet, c'est ce qui est utilisé pour représenter le polygone :

mPolygonOptions = new PolygonOptions()
       .add(new LatLng(29.4264525,-98.4948758))
       .add(new LatLng(29.4267029,-98.4948758))
       .add(new LatLng(29.4273742,-98.4945822))
       .add(new LatLng(29.4264562,-98.4943592))
       .fillColor(0x0000ff36)
       .strokePattern(Arrays.asList(new Dash(45.0f), new Gap(10.0f)))
       .strokeColor(Color.BLUE)
       .strokeWidth(5);

Comme vous pouvez le voir ci-dessus, nous définissons ici un polygone fixe avec des coordonnées préétablies (latitude, longitude). Toutefois, dans des scénarios réels, ces coordonnées et ces définitions de polygones proviennent le plus souvent d'un point de terminaison backend et seront probablement récupérées à distance. Cela signifie que les polygones devront être créés à la volée par l'application.

Pour en savoir plus sur ce qui peut être spécifié dans PolygonOptions, cliquez ici.

Vous devez définir le ou les polygones lors de la création de votre fragment ou de votre activité. Exemple :

protected void onCreate(Bundle savedInstanceState) {
   ...
   mPolygonOptions = new PolygonOptions()
           .add(new LatLng(29.4264525,-98.4948758))
           .add(new LatLng(29.4267029,-98.4948758))
           .add(new LatLng(29.4273742,-98.4945822))
           .add(new LatLng(29.4264562,-98.4943592))
           .fillColor(0x0000ff36)
           .strokePattern(Arrays.asList(new Dash(45.0f), new Gap(10.0f)))
           .strokeColor(Color.BLUE)
           .strokeWidth(5);

   ...// more code here
}

Écouter les notifications de position

Après avoir défini vos zones de géorepérage, il vous suffit de créer un écouteur de mise à jour de la position pour vous abonner à l'événement mentionné précédemment dans le SDK Navigation, appelé RoadSnappedLocationProvider, qui renverra la dernière position de l'appareil.

mLocListener = new RoadSnappedLocationProvider.LocationListener() {
   @Override
   public void onLocationChanged(Location snapped) {
       LatLng snappedL = new LatLng(snapped.getLatitude(), snapped.getLongitude());
       if(PolyUtil.containsLocation(snappedL, mPolygonOptions.getPoints(), true) && !mGeofenceBreached){
           Log.d("Geofence", "Vehicle has breached the polygon");
       }
   }
   @Override
   public void onRawLocationUpdate(Location location) {
   }
};

Avec Android-Maps-Utils, vous pouvez utiliser PolyUtil.containsLocation pour vérifier si le lieu reçu se trouve à l'intérieur du polygone prédéfini. Dans l'exemple ci-dessous, le polygone prédéfini représentant la zone de géorepérage est utilisé, mais en pratique, vous pouvez avoir plusieurs polygones, ce qui peut nécessiter une boucle.

Une autre approche

Ce document se concentre sur une application destinée aux clients qui vérifie si une zone géographique personnalisée (polygone) est enfreinte. Il existe cependant des cas dans lesquels vous souhaiterez peut-être effectuer de telles vérifications sur votre backend.

Cela signifie que l'application signale les mises à jour de position à un backend, qui vérifie ensuite si le véhicule a pénétré un certain polygone, et ne dépend donc pas de l'application cliente pour effectuer la validation.

Voici une solution possible :

[Environnement d'exécution] Architecture de géorepérage côté serveur

Exemple d'architecture illustrant une approche côté serveur du géorepérage

<ph type="x-smartling-placeholder"></ph> Solution côté serveur
Solution côté serveur

  1. L'application de pilote, à l'aide du SDK Driver, envoie des notifications de position à Fleet Engine. Les mises à jour de la position et la navigation dans l'application sont effectuées via le SDK Navigation.
  2. Fleet Engine envoie ces mises à jour à Cloud Logging ou Pub/Sub.
  3. Le backend collecte ces signaux de localisation.
  4. Les zones de géorepérage sont stockées dans BigQuery afin d'être analysées par le backend.
  5. Lorsqu'il déclenche la zone de géorepérage, des alertes sont envoyées à l'application Conducteur.

Dans cette architecture, le SDK Driver et Fleet Engine sont utilisés. Fleet Engine peut émettre des mises à jour Pub/Sub et générer des entrées de journal dans Cloud Logging. Dans les deux cas, la position du véhicule peut être récupérée.

Le backend peut alors surveiller la file d'attente Pub/Sub, ou lire les journaux et surveiller les mises à jour du véhicule. Ensuite, chaque fois qu'une mise à jour est effectuée (ou toutes les quelques secondes, minutes, en fonction de son caractère critique), le backend peut appeler les fonctions SIG BigQuery pour déterminer si un véhicule donné se trouve à l'intérieur ou à l'extérieur des géorepérages. Si un ou plusieurs géorepérages ont été violés, le backend peut intervenir et déclencher des pipelines internes ou d'autres workflows pertinents.

Conclusion

Le géorepérage est un outil puissant qui peut être utilisé à des fins diverses. Les entreprises peuvent utiliser le géorepérage pour cibler les utilisateurs finaux avec des annonces et des promotions pertinentes, fournir des services géolocalisés, et renforcer la sécurité.

Le SDK Navigation fournit des écouteurs d'événements utiles qui peuvent détecter de nombreux moments importants au cours d'un trajet. Les entreprises ont souvent besoin de zones géographiques personnalisées pour des cas d'utilisation spécifiques. Dans ce document, nous avons montré comment y parvenir, mais les possibilités sont infinies. Nous sommes impatients de découvrir vos projets.

Étapes suivantes

Documentation complémentaire suggérée: