Premiers pas avec le SDK Driver pour Android

Remarque:La fonctionnalité LMFS fournit deux modèles de sécurité à utiliser avec le SDK Driver: untrusted et untrusted. Les deux modèles de sécurité définissent la manière dont l'application du conducteur peut fournir des mises à jour des données du véhicule à Fleet Engine. Le modèle de sécurité non approuvé fournit une couche supplémentaire de vérification des données à partir de l'application du conducteur. Dans le modèle non approuvé, l'application du conducteur ne peut envoyer que les mises à jour de la position du véhicule directement à Fleet Engine. Toutes les autres mises à jour de données du véhicule effectuées par une application de conducteur non approuvée doivent être envoyées au backend du client, qui relaie les données à Fleet Engine.

Le modèle de sécurité fiable permet à l'application du conducteur d'envoyer les mises à jour des données du véhicule directement à Fleet Engine, sans avoir besoin d'un service intermédiaire. Ces données incluent à la fois la création et la mise à jour des véhicules, des tâches et des arrêts.

Le modèle non approuvé est en disponibilité générale, tandis que le modèle de pilote de confiance est en version Preview. Pour en savoir plus sur le modèle de pilote de confiance, consultez la section Autres rôles de compte de service.

Configuration système minimale requise

L'appareil mobile doit être équipé d'Android 6.0 (niveau d'API 23) ou version ultérieure.

Configuration de la compilation et des dépendances

Les versions 4.99 et ultérieures du SDK Driver sont disponibles dans le dépôt Maven de Google.

Gradle

Ajoutez le code ci-dessous à votre fichier build.gradle :

repositories {
    ...
    google()
}

Maven

Ajoutez le code ci-dessous à votre fichier pom.xml :

<project>
  ...
  <repositories>
    <repository>
      <id>google-maven-repository</id>
      <url>https://maven.google.com</url>
    </repository>
  </repositories>
  ...
</project>

Configuration du projet

Pour utiliser le SDK Driver, votre application doit cibler minSdkVersion 23 ou une version ultérieure. Pour en savoir plus, consultez les notes de version.

Pour exécuter une application créée avec le SDK Driver, les services Google Play doivent être installés sur l'appareil Android.

Configurer votre projet de développement

Pour configurer votre projet de développement et obtenir une clé API pour le projet dans la console Google Cloud:

1. Créez un projet dans la console Google Cloud ou sélectionnez un projet existant à utiliser avec le SDK Driver. Attendez quelques minutes que le nouveau projet soit visible dans la console Google Cloud.

2. Pour que vous puissiez exécuter l'application de démonstration, votre projet doit avoir accès au SDK Maps pour Android. Dans la console Google Cloud, sélectionnez API et services > Bibliothèque, puis recherchez et activez le SDK Maps pour Android.

3. Obtenez une clé API pour le projet en sélectionnant API et services > Identifiants > Créer des identifiants > Clé API. Pour savoir comment obtenir une clé API, consultez Obtenir une clé API.

Ajouter le SDK Driver à votre application

Le SDK Driver est disponible dans le dépôt Maven de Google. Le dépôt inclut les fichiers .pom (Project Object Model) du SDK, ainsi que des documents Javadocs. Pour ajouter le SDK Driver à votre application:

1. Ajoutez la dépendance suivante à votre configuration Gradle ou Maven, en remplaçant l'espace réservé VERSION_NUMBER par la version choisie du SDK Driver.

   Gradle

   Ajoutez les éléments suivants à votre build.gradle :

   dependencies {
     ...
     implementation 'com.google.android.libraries.mapsplatform.transportation:transportation-driver:VERSION_NUMBER'
   }
   

   Maven

   Ajoutez les éléments suivants à votre pom.xml :

   <dependencies>
     ...
     <dependency>
       <groupId>com.google.android.libraries.mapsplatform.transportation</groupId>
       <artifactId>transportation-driver</artifactId>
       <version>VERSION_NUMBER</version>
     </dependency>
   </dependencies>
   

2. Le SDK Driver dépend du SDK Navigation. Cette dépendance est configurée de sorte que si une version spécifique du SDK Navigation est nécessaire, elle doit être explicitement définie dans le fichier de configuration de compilation comme ci-dessous. Si vous omettez le bloc de code mentionné, le projet pourra toujours télécharger la dernière version du SDK Navigation dans la version majeure. Notez que les comportements combinés des dernières versions du SDK Drive et du SDK Navigation ont été soumis à des tests rigoureux avant leur publication.

   Organisez la configuration des dépendances de vos environnements de développement et de publication en conséquence.

   Gradle

   Ajoutez les éléments suivants à votre build.gradle :

   dependencies {
     ...
     implementation 'com.google.android.libraries.navigation:navigation:5.0.0'
   }
   

   Maven

   Ajoutez les éléments suivants à votre pom.xml :

   <dependencies>
     ...
     <dependency>
       <groupId>com.google.android.libraries.navigation</groupId>
       <artifactId>navigation</artifactId>
       <version>5.0.0</version>
     </dependency>
   </dependencies>
   

Mettre à jour le fichier manifeste de votre application

Une fois le SDK Driver ajouté à votre application, vous pouvez mettre à jour son fichier manifeste en modifiant son fichier AndroidManifest.xml.

Ajoutez votre clé API dans l'élément <application>. Vous devez utiliser la clé API du projet que vous avez obtenue lors de la configuration de votre projet de développement.

Par exemple, remplacez PASTE_YOUR_API_KEY_HERE par votre clé API dans les métadonnées d'application suivantes:

<meta-data
    android:name="com.google.android.geo.API_KEY"
    android:value="PASTE_YOUR_API_KEY_HERE"/>

L'exemple suivant présente un fichier manifeste complet pour une application exemple:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.driverapidemo" >
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/_AppTheme" >

        <meta-data
            android:name="com.google.android.geo.API_KEY"
            android:value="PASTE_YOUR_API_KEY_HERE"/>

        <activity android:name=".MainActivity" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

Remarque :Pour une expérience de navigation optimale, les autorisations android.permission.ACCESS_COARSE_LOCATION et android.permission.ACCESS_FINE_LOCATION doivent être accordées par l'utilisateur. Veillez à demander les deux au moment de l'exécution dans l'application.

Inclure les attributions requises dans votre application

Si vous utilisez le SDK Driver dans votre application, vous devez inclure le texte d'attribution et les licences Open Source dans la section des mentions légales de votre application. Il est préférable d'inclure les attributions dans un élément de menu indépendant ou dans un élément de menu About (À propos).

Les informations sur les licences se trouvent dans le fichier "third_party_licenses.txt" du fichier AAR désarchivé.

Pour savoir comment inclure des notifications Open Source, consultez la page https://developers.google.com/android/guides/opensource.

Dépendances

Le SDK Driver utilise gRPC pour communiquer avec le serveur Fleet Engine. Si vous n'utilisez pas encore gRPC, vous devrez peut-être déclarer les dépendances suivantes:

dependencies {
    implementation 'io.grpc:grpc-android:1.12.0'
    implementation 'io.grpc:grpc-okhttp:1.12.0'
}

Sans ces dépendances, le SDK Driver rencontrera des erreurs au moment de l'exécution lorsqu'il tentera de communiquer avec le serveur Fleet Engine.

Si vous utilisez ProGuard pour optimiser vos builds, vous devrez peut-être ajouter les lignes suivantes à votre fichier de configuration ProGuard:

-dontwarn com.google.**
-dontwarn io.grpc.**
-dontwarn okio.**

Le niveau d'API minimal accepté est 23.

Initialiser le SDK

Un ID de fournisseur (généralement l'ID du projet Google Cloud) est nécessaire pour initialiser l'objet FleetEngine. Pour en savoir plus sur la configuration du projet Google Cloud, consultez la page Authentification et autorisation.

Avant d'utiliser le SDK Driver, vous devez d'abord initialiser le SDK Navigation. Pour initialiser le SDK, procédez comme suit :

1. Obtenez un objet Navigator à partir de NavigationApi.

   NavigationApi.getNavigator(
         this, // Activity
         new NavigationApi.NavigatorListener() {
           @Override
           public void onNavigatorReady(Navigator navigator) {
             // Keep a reference to the Navigator (used to configure and start nav)
             this.navigator = navigator;
           }
         }
   );
   

2. Créez un objet DriverContext en renseignant les champs obligatoires.

   DriverContext driverContext = DriverContext.builder(application)
                .setProviderId(providerId)
                .setVehicleId(vehicleId)
                .setAuthTokenFactory(authTokenFactory)
                .setNavigator(navigator)
                .setRoadSnappedLocationProvider(
                    NavigationApi.getRoadSnappedLocationProvider(application))
                .build()
   

3. Utilisez l'objet DriverContext pour initialiser *DriverApi.

   DeliveryDriverApi driverApi = DeliveryDriverApi.createInstance(driverContext);
   

4. Obtenez DeliveryVehicleReporter à partir de l'objet API. (DeliveryVehicleReporter étend NavigationVehicleReporter.)

   DeliveryVehicleReporter vehicleReporter = driverApi.getDeliveryVehicleReporter();
   

S'authentifier avec AuthTokenFactory

Lorsque le SDK Driver génère des mises à jour de position, il doit les envoyer au serveur Google Fleet Engine. Pour authentifier ces requêtes, le SDK Driver appelle une instance de AuthTokenFactory fournie par l'appelant. La fabrique est chargée de générer des jetons d'authentification au moment de la mise à jour de l'emplacement.

La façon dont les jetons sont générés est spécifique à la situation de chaque développeur. Cependant, l'implémentation doit probablement:

• Récupérez un jeton d'authentification, éventuellement au format JSON, à partir d'un serveur HTTPS.
• Analyser et mettre en cache le jeton.
• Actualisez le jeton lorsqu'il expire.

Pour en savoir plus sur les jetons attendus par le serveur Fleet Engine, consultez la page Créer un jeton Web JSON (JWT) pour l'autorisation.

Voici un squelette d'implémentation d'une AuthTokenFactory:

class JsonAuthTokenFactory implements AuthTokenFactory {
  String vehicleServiceToken;  // initially null
  long expiryTimeMs = 0;

  // This method is called on a thread whose only responsibility is to send
  // location updates. Blocking is OK, but just know that no location updates
  // can occur until this method returns.
  @Override public String getToken(AuthTokenContext authTokenContext) {
    if (System.currentTimeMillis() > expiryTimeMs) {
      // The token has expired, go get a new one.
      fetchNewToken(vehicleId);
    }
    if (ServiceType.VEHICLE.equals(authTokenContext.getServiceType)) {
      return vehicleServiceToken;
    } else {
      throw new RuntimeException("Unsupported ServiceType: " + authTokenContext.getServiceType());
    }
  }

  private void fetchNewToken(String vehicleId) {
    String url = "https://yourauthserver.example/token/" + vehicleId;

    try (Reader r = new URL(url).openStream()) {
      com.google.gson.JsonObject obj
          = new com.google.gson.JsonParser().parse(r);
      vehicleServiceToken = obj.get("VehicleServiceToken").getAsString();
      expiryTimeMs = obj.getAsLong("TokenExpiryMs");

      // The expiry time could be an hour from now, but just to try and avoid
      // passing expired tokens, we subtract 10 minutes from that time.
      expiryTimeMs -= 10 * 60 * 1000;
    } catch (IOException e) {
      // It's OK to throw exceptions here, the StatusListener you passed to
      // create the FleetEngine class will be notified and pass along the failed
      // update warning.
      throw new RuntimeException("Could not get auth token", e);
    }
  }
}

Cette implémentation particulière utilise le client HTTP Java intégré pour récupérer un jeton au format JSON à partir du serveur d'authentification du développeur. Le jeton est enregistré pour être réutilisé. Le jeton est à nouveau récupéré si l'ancien jeton se trouve dans les 10 minutes précédant son délai d'expiration.

Votre implémentation peut se comporter différemment, par exemple en utilisant un thread d'arrière-plan pour actualiser les jetons.

Les exceptions dans AuthTokenFactory sont traitées comme temporaires, sauf si elles se produisent de façon répétée. Après plusieurs tentatives, le SDK Drive suppose que l'erreur est permanente et cesse de tenter d'envoyer des mises à jour.

Rapports d'état et d'erreurs avec StatusListener

Étant donné que le SDK Driver effectue des actions en arrière-plan, utilisez StatusListener pour déclencher des notifications lorsque certains événements se produisent, tels que des erreurs, des avertissements ou des messages de débogage. Les erreurs peuvent être de nature temporaire (par exemple, BACKEND_CONNECTIVITY_ERROR) ou entraîner l'arrêt permanent des mises à jour de la position (telles que VEHICLE_NOT_FOUND, indiquant une erreur de configuration).

Vous fournissez une implémentation StatusListener facultative comme celle-ci:

class MyStatusListener implements StatusListener {
  /** Called when background status is updated, during actions such as location reporting. */
  @Override
  public void updateStatus(
    StatusLevel statusLevel,
    StatusCode statusCode,
    String statusMsg) {
    // Status handling stuff goes here.
    // StatusLevel may be DEBUG, INFO, WARNING, or ERROR.
    // StatusCode may be DEFAULT, UNKNOWN_ERROR, VEHICLE_NOT_FOUND,
    // BACKEND_CONNECTIVITY_ERROR, or PERMISSION_DENIED.
  }
}

Remarques sur SSL/TLS

En interne, la mise en œuvre du SDK Driver utilise SSL/TLS pour communiquer de manière sécurisée avec le serveur Fleet Engine. Les versions antérieures d'Android (versions d'API 23 ou antérieures) peuvent nécessiter un correctif SecurityProvider pour communiquer avec le serveur. Pour en savoir plus sur l'utilisation de SSL sous Android, consultez Mettre à jour votre fournisseur de solutions de sécurité pour vous protéger contre les failles SSL. Il contient également des exemples de code permettant d'appliquer un correctif au fournisseur de solutions de sécurité.

Activer les mises à jour de la position

Une fois que vous disposez d'une instance *VehicleReporter, l'activation des mises à jour de la position est simple:

DeliveryVehicleReporter reporter = ...;

reporter.enableLocationTracking();

Les mises à jour de la position sont envoyées à intervalles réguliers, si possible. Chaque mise à jour de la localisation indique également que le véhicule est en ligne.

Par défaut, l'intervalle de rapport est de 10 secondes, mais vous pouvez le modifier avec FleetEngine.setLocationReportingInterval(long, TimeUnit). L'intervalle minimal de mise à jour accepté est de 5 secondes. Des mises à jour plus fréquentes peuvent entraîner des requêtes plus lentes et des erreurs.

Désactiver les notifications de position

Une fois le quart de travail du conducteur terminé, vous pouvez arrêter les mises à jour de la position en appelant DeliveryVehicleReporter.disableLocationTracking.

Cas d'utilisation des modèles de confiance

Ce produit ou cette fonctionnalité est en preview (pré-DG). La prise en charge des fonctionnalités et produits pré-DG peut être limitée, et il se peut que les modifications apportées à ces fonctionnalités ou produits ne soient pas compatibles avec d'autres versions pré-DG. Les offres en pré-DG sont couvertes par les Conditions spécifiques du service Google Maps Platform. Pour en savoir plus, consultez les descriptions des étapes de lancement.

Cette section explique comment utiliser le SDK Driver pour mettre en œuvre des cas d'utilisation courants lors de l'utilisation du modèle de confiance.

Créer un véhicule

Vous pouvez créer un véhicule à partir du SDK Driver.

Avant de créer un véhicule, veillez à initialiser l'API Delivery Driver. L'ID du véhicule doit être créé avec les ID du véhicule et du fournisseur utilisés lors de l'initialisation du SDK Driver. Créez ensuite le véhicule comme illustré dans l'exemple suivant:

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryVehicleManager vehicleManager = api.getDeliveryVehicleManager();
try {
  DeliveryVehicle vehicle = vehicleManager.createVehicle().get();
  // Handle CreateVehicleRequest DeliveryVehicle response.
} catch (Exception e) {
  // Handle CreateVehicleRequest error.
}

Créer une tâche de retrait en livraison

Vous pouvez créer une tâche de retrait d'un colis à partir du SDK Driver.

Avant de créer une tâche, veillez à initialiser l'API Delivery Driver. La tâche doit être créée à l'aide de l'ID de fournisseur spécifié lors de l'initialisation du SDK Driver. Créez ensuite la tâche de retrait en magasin, comme illustré dans l'exemple suivant. Pour en savoir plus sur les ID de tâche, consultez des exemples d'ID de tâche.

static final String TASK_ID = "task-8241890"; // Avoid auto-incrementing IDs.

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryTaskManager taskManager = api.getDeliveryTaskManager();
CreateDeliveryTaskRequest request = CreateDeliveryTaskRequest.builder(TASK_ID)
   .setPlannedWaypoint(Waypoint.builder().setLatLng(-6.195139, 106.820826).build())
   .setTaskDurationSeconds(2 * 60)
   .setParentId("my-tracking-id")
   .setTaskType(TaskType.DELIVERY_PICKUP)
   .build();

try {
   DeliveryTask task = taskManager.createTask(request).get();
   // Handle CreateTaskRequest DeliveryTask response.
} catch (Exception e)  {
   // Handle CreateTaskRequest error.
}

Créer une tâche de livraison

Vous pouvez créer une tâche de livraison à partir du SDK Driver.

Avant de créer une tâche, veillez à initialiser l'API Delivery Driver. Créez ensuite la tâche de livraison, comme illustré dans l'exemple suivant. Pour en savoir plus sur les ID de tâche, consultez les exemples d'ID de tâche.

static final String TASK_ID = "task-8241890"; // Avoid auto-incrementing IDs.

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryTaskManager taskManager = api.getDeliveryTaskManager();
CreateDeliveryTaskRequest request = CreateDeliveryTaskRequest.builder(TASK_ID)
   .setPlannedWaypoint(Waypoint.builder().setLatLng(-6.195139, 106.820826).build())
   .setTaskDurationSeconds(2 * 60)
   .setParentId("my-tracking-id")
   .setTaskType(TaskType.DELIVERY_DELIVERY)
   .build();
try {
   DeliveryTask task = taskManager.createTask(request).get();
   // Handle CreateTaskRequest DeliveryTask response.
} catch (Exception e)  {
   // Handle CreateTaskRequest error.
}

Indisponibilité planifiée

Vous pouvez créer une tâche indiquant une indisponibilité (par exemple, pour des pauses au volant ou pour le réapprovisionnement en carburant d'un véhicule) à partir du SDK Driver. Une tâche d'indisponibilité planifiée ne doit pas inclure d'ID de suivi. Vous pouvez éventuellement indiquer un lieu.

Avant de créer une tâche, veillez à initialiser l'API Delivery Driver. Créez ensuite la tâche d'indisponibilité, comme illustré dans l'exemple suivant. Pour en savoir plus sur les ID de tâche, consultez les exemples d'ID de tâche.

static final String TASK_ID = "task-8241890"; // Avoid auto-incrementing IDs.

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryTaskManager taskManager = api.getDeliveryTaskManager();
CreateDeliveryTaskRequest request = CreateDeliveryTaskRequest.builder(TASK_ID)
   .setTaskDurationSeconds(2 * 60) // Duration or location (or both) must be provided for a BREAK task.
   .setTaskType(TaskType.UNAVAILABLE)
   .build();
try {
   DeliveryTask task = taskManager.createTask(request).get();
   // Handle CreateTaskRequest DeliveryTask response.
} catch (Exception e)  {
   // Handle CreateTaskRequest error.
}

Arrêts planifiés

Vous pouvez créer une tâche d'arrêt planifiée à partir du SDK Driver. Une tâche d'arrêt planifié ne peut pas inclure d'ID de suivi.

Avant de créer une tâche, veillez à initialiser l'API Delivery Driver. Créez ensuite la tâche d'arrêt planifié, comme indiqué dans l'exemple suivant. Pour en savoir plus sur les ID de tâche, consultez les exemples d'ID de tâche.

static final String TASK_ID = "task-8241890"; //  Avoid auto-incrementing IDs.

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryTaskManager taskManager = api.getDeliveryTaskManager();
CreateDeliveryTaskRequest request = CreateDeliveryTaskRequest.builder(TASK_ID)
   .setPlannedWaypoint(Waypoint.builder().setLatLng(-6.195139, 106.820826).build())
   .setTaskDurationSeconds(2 * 60)
   .setTaskType(TaskType.DELIVERY_SCHEDULED_STOP)
   .build();
try {
   DeliveryTask task = taskManager.createTask(request).get();
   // Handle CreateTaskRequest DeliveryTask response.
} catch (Exception e)  {
   // Handle CreateTaskRequest error.
}

Mettre à jour l'ordre des tâches

Vous pouvez modifier l'ordre d'exécution des tâches attribuées à un véhicule à partir du SDK Driver.

La mise à jour de l'ordre des tâches attribue également des tâches à un véhicule si elles n'ont pas été précédemment attribuées à un véhicule. Elle ferme également les tâches précédemment attribuées à un véhicule et qui ont été laissées dans l'ordre modifié. L'attribution d'une tâche à un autre véhicule si elle a déjà été attribuée à un autre véhicule génère une erreur. Avant d'attribuer une tâche au nouveau véhicule, fermez la tâche existante, puis créez-en une autre.

Vous pouvez modifier l'ordre des tâches à tout moment.

Avant de mettre à jour l'ordre des tâches pour un véhicule, assurez-vous que le véhicule et les tâches ont déjà été créés dans Fleet Engine. Ensuite, mettez à jour l'ordre des tâches pour le véhicule, comme illustré dans l'exemple suivant.

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryVehicleReporter reporter = api.getDeliveryVehicleReporter();
try {
   List<VehicleStop> stops = reporter.setVehicleStops(
     ImmutableList.of(
         VehicleStop.builder()
             .setVehicleStopState(VehicleStopState.ARRIVED)
             .setWaypoint(Waypoint.builder().setLatLng(37.1749, 122.412).build())
             .setTasks(ImmutableList.of(task1)) // Previously created DeliveryTask in Fleet Engine.
             .build(),
         VehicleStop.builder()
             .setVehicleStopState(VehicleStopState.NEW) // The current vehicle stop.
             .setWaypoint(Waypoint.builder().setLatLng(37.7749, 122.4194).build())
             .setTasks(ImmutableList.of(task2)) // Previously created DeliveryTask in Fleet Engine.
             .build(),
         VehicleStop.builder()
             .setVehicleStopState(VehicleStopState.NEW)
             .setWaypoint(Waypoint.builder().setLatLng(37.3382, 121.8863).build())
             .setTasks(ImmutableList.of(task3, task4)) // Previously created DeliveryTasks in Fleet Engine.
             .build())).get();
   // Successfully updated vehicle stops in Fleet Engine. Returns the successfully set VehicleStops.
} catch (Exception e)  {
   // Failed to update vehicle stops in Fleet Engine. Setting VehicleStops must be attempted again after resolving
   // errors.
}

Une exception peut empêcher la mise à jour de l'état interne du SDK Driver. Le cas échéant, résolvez le problème, puis appelez à nouveau setVehicleStops jusqu'à ce que l'appel aboutisse.

Voici quelques exemples de problèmes potentiels:

• Les arrêts de véhicule spécifiés ne suivent pas un schéma valide. Seul le premier VehicleStop peut être dans l'un des VehicleStopStates: NEW, ENROUTE ou ARRIVED. Les arrêts de véhicules après l'arrêt actuel doivent être dans le NEW VehicleStopState.

• Les tâches n'existent pas ou appartiennent à un autre véhicule.

• Le véhicule n'existe pas.

Le véhicule est en route pour le prochain arrêt

Fleet Engine doit être averti lorsqu'un véhicule quitte un arrêt et qu'il commence la navigation. Vous pouvez envoyer une notification à Fleet Engine à partir du SDK Driver.

Avant d'informer Fleet Engine qu'un véhicule a décollé d'un arrêt, assurez-vous que les arrêts du véhicule ont été créés et définis. Informez ensuite Fleet Engine du départ du véhicule, comme illustré dans l'exemple suivant.

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryVehicleReporter reporter = api.getDeliveryVehicleReporter();
reporter.enableLocationTracking(); // Location tracking must be enabled.

// Create Vehicle, VehicleStops, and DeliveryTasks.
// Set VehicleStops on Vehicle.

navigator.setDestination(vehicleStop.getWaypoint());
try {
   List<VehicleStop> updatedStops = reporter.enrouteToNextStop().get();
   // Successfully updated vehicle stops in Fleet Engine. Returns the set VehicleStops, with the first
   // VehicleStop updated to ENROUTE state.
} catch (Exception e)  {
   // Failed to update vehicle stops in Fleet Engine. Updating VehicleStops must be attempted again
   // after resolving errors.
}

Une exception peut empêcher la mise à jour de l'état interne du SDK Driver. Si cela se produit, résolvez le problème, puis appelez à nouveau enrouteToNextStop jusqu'à ce que l'opération réussisse.

Voici quelques exemples de problèmes potentiels:

• Aucun élément VehicleStops restant défini dans le SDK Driver.

Le véhicule arrive à un arrêt

Fleet Engine doit recevoir une notification lorsqu'un véhicule arrive à un arrêt. Vous pouvez informer Fleet Engine à partir du SDK Driver.

Avant d'informer Fleet Engine qu'un véhicule est arrivé à un arrêt, assurez-vous que les arrêts du véhicule ont été définis. Informez ensuite Fleet Engine de l'arrivée du véhicule à l'arrêt, comme illustré dans l'exemple suivant.

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryVehicleReporter reporter = api.getDeliveryVehicleReporter();
reporter.enableLocationTracking(); // Location tracking must be enabled.

// Create Vehicle, VehicleStops, and DeliveryTasks.
// Set VehicleStops on Vehicle.
// Mark ENROUTE to VehicleStop and start guidance using Navigator.

try {
   List<VehicleStop> updatedStopsArrived = reporter.arrivedAtStop().get();
   // Successfully updated vehicle stops in Fleet Engine. Returns the set VehicleStops, with the first
   // VehicleStop updated to ARRIVED state.
   navigator.clearDestinations();
} catch (Exception e)  {
   // Failed to update vehicle stops in Fleet Engine. Updating VehicleStops must be attempted again
   // after resolving errors.
}

Une exception peut empêcher la mise à jour de l'état interne du SDK Driver. Le cas échéant, résolvez le problème, puis appelez à nouveau arrivedAtStop jusqu'à ce que l'opération réussisse.

Voici quelques exemples de problèmes potentiels:

• Aucun élément VehicleStops restant défini dans le SDK Driver.

Le véhicule termine un arrêt

Fleet Engine doit être averti lorsqu'un véhicule s'arrête. Toutes les tâches associées à l'arrêt sont alors définies sur l'état CLOSED. Vous pouvez en informer Fleet Engine à partir du SDK Driver.

Informez Fleet Engine que le véhicule a terminé son arrêt de véhicule, comme illustré dans l'exemple suivant.

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryVehicleReporter reporter = api.getDeliveryVehicleReporter();
reporter.enableLocationTracking(); // Location tracking must be enabled.

// After completing the tasks at the VehicleStop, remove it from the
// the current list of VehicleStops.

try {
   List<VehicleStop> updatedStopsCompleted = reporter.completedStop().get();
   // Successfully updated vehicle stops in Fleet Engine. All tasks on the completed stop are set to CLOSED.
   // Returns the set VehicleStops, with the completed VehicleStop removed from the remaining list.
} catch (Exception e)  {
   // Failed to update vehicle stops in Fleet Engine. Updating VehicleStops must be attempted again
   // after resolving errors.
}

Une exception peut empêcher la mise à jour de l'état interne du SDK Driver. Le cas échéant, résolvez le problème, puis appelez à nouveau completedStop jusqu'à ce que l'opération réussisse.

Voici quelques exemples de problèmes potentiels:

• Aucun élément VehicleStops restant défini dans le SDK Driver.

Fermer une tâche

Pour fermer une tâche qui a été attribuée à un véhicule, informez Fleet Engine que le véhicule a terminé l'arrêt où la tâche a lieu, ou supprimez-la de la liste des arrêts du véhicule. Pour ce faire, vous pouvez définir la liste des arrêts restants du véhicule, comme lorsque vous modifiez l'ordre des tâches pour un véhicule.

Si un véhicule n'a pas encore été attribué à une tâche et qu'il doit être fermé, définissez l'état de la tâche sur CLOSED (FERMÉ). Toutefois, vous ne pouvez pas rouvrir une tâche CLOSED.

La fermeture d'une tâche n'indique pas la réussite ou l'échec. Cela indique que la tâche n'est plus considérée comme en cours. Pour le suivi du colis, il est important d'indiquer le résultat réel d'une tâche afin de pouvoir afficher le résultat de la livraison.

Vous devez attribuer une tâche à un véhicule pour pouvoir la fermer à l'aide du SDK Driver. Pour fermer une tâche qui a été attribuée à un véhicule, informez Fleet Engine que le véhicule a terminé l'arrêt où la tâche est effectuée.

Vous pouvez également mettre à jour l'ordre des tâches du véhicule auquel la tâche est attribuée, puis supprimer la tâche souhaitée de la liste des arrêts.

Définir le résultat de la tâche et le lieu du résultat

La fermeture d'une tâche n'indique pas la réussite ou l'échec. Cela indique que la tâche n'est plus considérée comme en cours. Pour le suivi des livraisons, il est important d'indiquer le résultat réel d'une tâche afin qu'un résultat de livraison puisse être affiché et que la facturation des services soit appropriée. Une fois défini, vous ne pouvez plus modifier le résultat de la tâche. Mais vous pouvez modifier l'heure du résultat de la tâche et l'emplacement du résultat de la tâche après les avoir définis.

Le résultat des tâches à l'état FERMÉE peut être défini sur SUCCEEDED (SUCCEEDED) ou FAILED (ÉCHEC). Fleet Engine ne facture que les tâches de livraison dont l'état est "SUCCEEDED" (Réussite).

Lorsque vous marquez le résultat d'une tâche, Fleet Engine indique automatiquement la dernière position connue du véhicule dans le champ du résultat de la tâche. Vous pouvez ignorer ce comportement en appelant Fleet Engine. Notez que vous ne pouvez pas définir l'emplacement du résultat de la tâche à l'aide du SDK Driver.

L'exemple de code suivant montre comment utiliser le SDK Driver pour définir un résultat et un horodatage de tâche.

static final String TASK_ID = "task-8241890";

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryTaskManager taskManager = api.getDeliveryTaskManager();

// Updating an existing DeliveryTask which is already CLOSED. Manually
// setting TaskOutcomeLocation with Driver SDK is not supported at this time.
UpdateDeliveryTaskRequest req = UpdateDeliveryTaskRequest.builder(TASK_ID)
    .setTaskOutcome(TaskOutcome.SUCCEEDED)
    .setTaskOutcomeTimestamp(now()) // Timestamp in milliseconds.
    .build();

try {
   DeliveryTask updatedTask = taskManager.updateTask(req);
   // Handle UpdateTaskRequest DeliveryTask response.
} catch (Exception e)  {
   // Handle UpdateTaskRequest error.
}

Rechercher un véhicule

Vous pouvez rechercher un véhicule à partir du SDK Driver. Avant de rechercher un véhicule, veillez à initialiser l'API Delivery Driver. Vous pouvez ensuite rechercher le véhicule comme illustré dans l'exemple suivant.

DeliveryDriverApi api = DeliveryDriverApi.getInstance();
DeliveryVehicleManager vehicleManager = api.getDeliveryVehicleManager();
try {
   DeliveryVehicle vehicle = vehicleManager.getVehicle().get();
   // Handle GetVehicleRequest DeliveryVehicle response.
} catch (Exception e)  {
   // Handle GetVehicleRequest error.
}

DeliveryVehicleManager ne peut rechercher le DeliveryVehicle que pour l'ID de véhicule fourni lors de l'initialisation de l'API Delivery Driver.