Introduzione a Fleet Engine

L'API Fleet Engine Deliveries consente di modellare le attività del parco risorse per il primo e l'ultimo miglio delle consegne. L'API Deliveries è esposta tramite l'SDK Driver per Android e iOS e può essere utilizzata anche direttamente tramite chiamate REST HTTP o gRPC.

Configurazione iniziale

L'API Fleet Engine Deliveries viene configurata tramite la console Google Cloud. Per informazioni sui passaggi da eseguire all'interno della console e su come creare un token web JSON per l'autorizzazione, consulta la sezione Autenticazione e autorizzazione. Per informazioni dettagliate sull'utilizzo della console, consulta la documentazione relativa alla console Google Cloud.

Verificare la configurazione

Dopo aver creato gli account di servizio, devi verificare che la configurazione sia completata e poter creare un veicolo per la consegna. Eseguendo la verifica in questa fase del flusso di lavoro, ti assicuri di aver risolto i problemi di autorizzazione più comuni che possono verificarsi durante la configurazione del progetto. Segui la guida Verificare la configurazione. Questa guida fornisce dettagli su come utilizzare l'utilità a riga di comando di gcloud per testare due parti chiave della tua configurazione: firma del token di autorizzazione e creazione di un veicolo per la consegna di prova.

In alternativa, puoi utilizzare gli script di esempio di autenticazione di Fleet Engine per testare la configurazione.

Librerie client

Pubblichiamo librerie client in molti linguaggi di programmazione comuni. Queste librerie offrono una migliore esperienza per gli sviluppatori su REST o gRPC non elaborati. Per istruzioni su come ottenere le librerie client per la tua applicazione server, consulta Librerie client.

Gli esempi Java in questa documentazione presuppongono familiarità con gRPC.

Strutture di dati

L'API Deliveries utilizza due strutture di dati per definire un modello per il ritiro e la consegna delle spedizioni:

• Il veicolo per la consegna utilizzato per trasportare la spedizione.
• Le attività di ritiro e consegna della spedizione.

Inoltre, puoi utilizzare le attività per creare modelli delle pause per il conducente e delle fermate pianificate nell'arco della giornata.

Veicoli per la consegna

I veicoli per la consegna trasportano le spedizioni da un deposito a un punto di consegna e da un punto di ritiro al deposito. In alcuni casi, possono anche trasportare una spedizione direttamente dal luogo di ritiro a quello di consegna.

Puoi utilizzare l'SDK Driver per creare un oggetto DeliveryVehicle in Fleet Engine e inviare aggiornamenti di posizione per il monitoraggio delle spedizioni e del parco veicoli.

Tasks

A ogni veicolo sono assegnate attività. Queste possono includere attività di ritiro o consegna, pause necessarie per i conducenti o fermate programmate presso i punti vendita o le sedi dei clienti. Ogni attività deve avere un ID attività univoco, ma può condividere lo stesso ID monitoraggio. Le attività e l'ordine in cui vengono pianificate vengono utilizzati per calcolare le finestre ETA per ogni attività.

Usa Driver SDK Task Manager per creare attività in Fleet Engine.

Attività di spedizione

Le attività di spedizione sono correlate al ritiro o all'abbandono della spedizione. Devi specificare un numero di riferimento o un ID quando crei un'attività di spedizione. Devi anche specificare un tempo di interazione da tenere conto del tempo aggiuntivo per completare l'attività, cercare parcheggio o raggiungere a piedi il luogo del passaggio.

• Crea un'attività di ritiro per il ritiro di una spedizione, specificando il luogo di ritiro e il numero di riferimento o l'ID.
• Crea un'attività di consegna per consegnare una spedizione, specificando la località di consegna e il numero di riferimento o l'ID.

Attività di indisponibilità

Crea un'attività di non disponibilità per un periodo di tempo in cui il veicolo non sarà disponibile per il ritiro o le consegne. Può essere una sosta per fare rifornimento di carburante o un riposo per il conducente. Specifica la durata dell'interruzione quando crei l'attività. Non è necessario fare le pause in una località specifica, ma se specifichi una località ottieni finestre di orario di arrivo stimato più precise nell'arco della giornata.

Durante un'attività di non disponibilità, nessuna informazione sulla posizione viene condivisa con un utente finale. Ad esempio, la località del veicolo per la consegna è nascosta ai gestori del parco veicoli che utilizzano la libreria di monitoraggio del parco risorse.

Attività con interruzione pianificata

Crea attività di fermate programmate per modellare le fermate che devono essere effettuate da un veicolo per la consegna. Ad esempio, puoi creare un'attività di interruzione pianificata per una fermata giornaliera della raccolta pianificata in un luogo specifico, indipendentemente da altre consegne o ritiri nella stessa posizione. Puoi anche creare attività di fermata programmate per le riscossioni dei punti di ritiro oppure per creare modelli di trasferimenti o fermate nei centri assistenza e nei punti di servizio.

Puoi vedere i campi specifici contenuti in ogni struttura di dati consultando la documentazione di riferimento API per DeliveryVehicle (gRPC, REST) e Task (gRPC, REST).

• Gli ID devono essere stringhe Unicode valide.
• Gli ID devono contenere al massimo 64 caratteri.
• Gli ID verranno normalizzati in base al Modulo C di normalizzazione Unicode.
• Gli ID non possono contenere nessuno dei seguenti caratteri ASCII: "/", ":", "\", "?", o "#".

Di seguito sono riportati alcuni esempi di ID attività validi:

• 566c33d9-2a31-4b6a-9cd4-80ba1a0c643b
• e4708eabcfa39bf2767c9546c9273f747b4626e8cc44e9630d50f6d129013d38
• NTA1YTliYWNkYmViMTI0ZmMzMWFmOWY2NzNkM2Jk

La tabella seguente mostra esempi di ID attività non validi:

Vita di un veicolo

L'oggetto DeliveryVehicle rappresenta un veicolo per la consegna del primo o dell'ultimo miglio. Puoi creare un oggetto DeliveryVehicle utilizzando:

• L'ID progetto del progetto Google Cloud che contiene l'account di servizio utilizzato per chiamare le API Fleet Engine.
• Un ID veicolo di proprietà del cliente.

Gli ID veicolo devono essere univoci per ogni veicolo. Non devono essere riutilizzati per un altro veicolo, a meno che non ci siano attività attive per quel veicolo.

Assicurati di verificare la presenza di un errore NOT_FOUND quando effettui una chiamata al numero UpdateDeliveryVehicle e, se necessario, chiama il numero CreateDeliveryVehicle per creare un nuovo veicolo. Un oggetto DeliveryVehicle che non è stato aggiornato utilizzando UpdateDeliveryVehicle viene eliminato automaticamente dopo sette giorni. Tieni presente che la chiamata di CreateDeliveryVehicle con una coppia di ID progetto/ID veicolo già esistente genera un errore.

Attributi veicolo

L'entità DeliveryVehicle contiene un campo ripetuto di DeliveryVehicleAttribute. L'API ListDeliveryVehicles include un campo filter che può limitare le entità DeliveryVehicle restituite a quelle con gli attributi specificati. DeliveryVehicleAttribute non influiscono sul comportamento di routing di Fleet Engine.

Non includere informazioni sensibili o che consentono l'identificazione personale negli attributi, poiché questo campo potrebbe essere visibile agli utenti.

La vita di un'attività

Le attività in Fleet Engine possono essere create, aggiornate e interrogate utilizzando le interfacce gRPC o REST dell'API Deliveries.

Un oggetto Task ha un campo di stato per monitorare l'avanzamento nel ciclo di vita. I valori vengono spostati da APERTO a CHIUSO. Le nuove attività vengono create nello stato APERTO, il che indica che:

• L'attività non è stata ancora assegnata a un veicolo per la consegna.
• Il veicolo per la consegna non ha ancora superato la fermata del veicolo assegnata all'attività.

Un'attività può essere assegnata a un veicolo solo quando è in stato APERTO.

Un'attività può essere annullata rimuovendola dall'elenco delle fermate del veicolo. Il suo stato viene quindi impostato automaticamente su CHIUSO.

Quando il veicolo dell'attività completa l'arresto del veicolo, aggiorna il campo del risultato dell'attività impostandolo su RIUSCITA o NON RIUSCITA e specifica il timestamp dell'evento. Il risultato dell'attività può essere impostato in qualsiasi momento prima o dopo il completamento dell'attività, ma può essere impostato una sola volta.

La libreria di monitoraggio del parco risorse JavaScript può quindi indicare il risultato dell'attività. Lo stato dell'attività viene impostato automaticamente su CHIUSO. Per ulteriori informazioni, consulta la pagina Monitorare il parco risorse con la libreria di monitoraggio del parco risorse JavaScript.

Come per i veicoli, le attività che non sono state aggiornate dopo sette giorni vengono eliminate e il tentativo di creare un'attività con un ID già esistente restituisce un errore.

Nota: Fleet Engine non supporta l'eliminazione esplicita di un'attività. Il servizio elimina automaticamente le attività dopo sette giorni senza aggiornamenti. Se vuoi conservare i dati delle attività per più di sette giorni, devi implementare personalmente questa funzionalità.

Attributi attività

L'entità Task contiene un campo ripetuto di TaskAttribute, che può avere un valore da uno dei tre tipi: string, number e bool. L'API ListTasks include un campo filter che può limitare le entità Task restituite a quelle con gli attributi specificati. TaskAttribute non influiscono sul comportamento di routing di Fleet Engine.

Non includere informazioni sensibili o che consentono l'identificazione personale negli attributi, poiché questo campo potrebbe essere visibile agli utenti.

Gestione del ciclo di vita di veicoli e attività

Per gestire i cicli di vita dei veicoli e delle attività nel tuo sistema, utilizza l'API Fleet Engine Deliveries per creare, aggiornare e monitorare i tuoi veicoli e le attività associate. Il tuo sistema interno funge da fonte attendibile dei dati che l'API Fleet Engine Deliveries aumenta per tuo conto.

Allo stesso tempo, l'applicazione del conducente comunica direttamente con Fleet Engine per aggiornare la posizione del dispositivo e le informazioni sul percorso. Questo modello consente a Fleet Engine di gestire in modo efficiente la posizione in tempo reale e di inviarla direttamente alla libreria di monitoraggio, che puoi utilizzare per i consumatori che necessitano di aggiornamenti sullo stato dell'ordine.

Ad esempio, supponi di avere il seguente scenario:

• Un autista si avvicina a una fermata di consegna e Fleet Engine invia la posizione del dispositivo alla libreria di monitoraggio, che la tua applicazione consumer utilizza per avvisare il consumatore della vicinanza del pacco.
• Una volta completata la spedizione, il conducente fa clic sul pulsante "Spedizione consegnata" nell'applicazione del conducente.
• Le informazioni vengono inviate al sistema di backend, che esegue i passaggi di convalida e verifica aziendali necessari.
• Il sistema conferma l'attività come SUCCEEDED e aggiorna Fleet Engine utilizzando l'API Deliveries.

Il seguente diagramma illustra questi processi a livello generico. Mostra inoltre la relazione standard tra il sistema, il client e Fleet Engine.

Gestione token client

Tutti gli aggiornamenti della posizione provenienti dall'applicazione del driver e inviati direttamente a Fleet Engine richiedono token di autorizzazione. L'approccio consigliato per gestire gli aggiornamenti dal client a Fleet Engine consiste nel fornire all'applicazione del driver un token di ambito limitato che possa aggiornare la posizione del dispositivo solo in Fleet Engine. Per questo tipo di token, utilizzi un ruolo dell'account di servizio noto come Utente driver non attendibile per la consegna di Fleet Engine. In questo modo, le chiamate provenienti da dispositivi mobili, considerati ambienti a bassa attendibilità, rispettano il principio del privilegio minimo.

Altri ruoli dell'account di servizio

Se, invece, vuoi autorizzare le applicazioni driver ad apportare aggiornamenti diretti di Fleet Engine oltre a quelli limitati al ruolo Driver non attendibile, ad esempio per alcuni aggiornamenti di attività, puoi utilizzare il ruolo Driver attendibile. Per informazioni su un modello che utilizza il ruolo Driver attendibile, vedi Modello driver attendibile.

Per ulteriori informazioni sugli utilizzi dei ruoli di driver non attendibili e attendibili, consulta Configurazione del progetto cloud.

Definizione di una giornata lavorativa

La tabella seguente descrive l'aspetto di una giornata lavorativa per i conducenti del primo o dell'ultimo miglio per un'azienda di consegna e logistica. La tua azienda potrebbe essere diversa nei dettagli, ma puoi vedere come potresti modellare una giornata lavorativa.

Informazioni sugli aggiornamenti di posizione

Gli aggiornamenti della posizione vengono inviati a Fleet Engine quando un veicolo per la consegna parte da una fermata (incluso il deposito) fino all'arrivo alla fermata successiva. Poiché questi eventi non vengono rilevati automaticamente, devi contrassegnarli in modo programmatico. Utilizza le librerie che rilevano modifiche alla modalità di trasporto per attivare l'invio delle notifiche richieste a Fleet Engine.

Gli aggiornamenti della posizione devono essere sospesi quando il conducente non è alla guida, in quanto la qualità degli indicatori di posizione peggiora drasticamente quando qualcuno si trova all'interno di un edificio.

La frequenza di aggiornamento della posizione può essere impostata nell'SDK Driver. Per impostazione predefinita, gli aggiornamenti vengono inviati ogni 10 secondi.

Fermate dei veicoli e luoghi di consegna

Una fermata è il luogo in cui un veicolo per la consegna completa un'attività di spedizione o qualche altra attività. Può essere un punto di accesso come un molo di carico o un punto di accesso bloccato sulla strada.

Il luogo di consegna è il luogo in cui viene consegnata o ritirata la spedizione. Per raggiungere e tornare dal punto di consegna potrebbe essere necessario camminare una volta dalla fermata del veicolo.

Ad esempio, quando un autista consegna un pacco a un negozio di un centro commerciale, il veicolo per la consegna si ferma nel parcheggio del centro commerciale vicino all'ingresso più vicino del negozio. Questa è la fermata del veicolo. L'autista, quindi, cammina dalla fermata del veicolo al punto in cui si trova il negozio. Questa è la località di consegna.

Per un'esperienza di monitoraggio della spedizione ottimale per i tuoi utenti, considera il modo in cui le attività di spedizione vengono assegnate alle fermate dei veicoli e tieni presente che il numero di fermate del veicolo rimanenti per le attività di spedizione viene segnalato all'utente per aiutarli a visualizzare l'avanzamento della spedizione.

Ad esempio, se un conducente effettua molte consegne in un singolo ufficio, valuta la possibilità di assegnare tutte le attività di consegna a una singola fermata del veicolo. Se ogni attività di consegna è assegnata a una propria fermata, l'esperienza di monitoraggio della spedizione sarebbe meno utile per i tuoi utenti poiché il tracciamento è disponibile solo dopo che il veicolo ha raggiunto un numero limitato di fermate prima della destinazione. Il completamento di molte fermate del veicolo in un breve periodo di tempo non dà all'utente molto tempo da utilizzare per monitorare l'avanzamento della consegna.

Utilizzo degli SDK per dispositivi mobili

Prima di effettuare chiamate all'SDK Driver, assicurati di inizializzarlo.

Inizializzazione dell'API Delivery Driver

Prima di inizializzare l'API Delivery Driver nell'SDK Driver, assicurati di inizializzare l'SDK Navigation. Quindi inizializza l'API Delivery Driver come mostrato nell'esempio seguente:

static final String PROVIDER_ID = "provider-1234";
static final String VEHICLE_ID = "vehicle-8241890";

NavigationApi.getNavigator(
   this, // Activity.
   new NavigatorListener() {
     @Override
     public void onNavigatorReady(Navigator navigator) {
       DeliveryDriverApi.createInstance(DriverContext.builder(getApplication())
         .setNavigator(navigator)
         .setProviderId(PROVIDER_ID)
         .setVehicleId(VEHICLE_ID)
         .setAuthTokenFactory((context) -> "JWT") // AuthTokenFactory returns JWT for call context.
         .setRoadSnappedLocationProvider(NavigationApi.getRoadSnappedLocationProvider(getApplication()))
         .setNavigationTransactionRecorder(NavigationApi.getNavigationTransactionRecorder(getApplication()))
         .setStatusListener((statusLevel,statusCode,statusMsg) -> // Optional, surfaces polling errors.
             Log.d("TAG", String.format("New status update. %s, %s, %s", statusLevel, statusCode, statusMsg)))
         .build));
     }

     @Override
     public void onError(int errorCode) {
       Log.e("TAG", String.format("Error loading Navigator instance: %s", errorCode));
     }
   });

Casi d'uso

Questa sezione descrive come utilizzare l'API Deliveries per creare modelli di casi d'uso comuni.

Identificatori univoci delle entità

Il formato e il valore degli identificatori univoci delle entità utilizzati nelle chiamate REST sono opachi per Fleet Engine. Evita di utilizzare ID con incrementi automatici e assicurati che l'identificatore non contenga informazioni che consentono l'identificazione personale (PII), ad esempio il numero di telefono del conducente.

Crea un veicolo

Puoi creare un veicolo dall'SDK Driver o dall'ambiente del server.

gRPC

Per creare un nuovo veicolo, effettua una chiamata CreateDeliveryVehicle a Fleet Engine. Utilizza l'oggetto CreateDeliveryVehicleRequest per definire gli attributi del nuovo veicolo per la consegna. Tieni presente che qualsiasi valore specificato nel campo Name verrà ignorato in base alle linee guida dell'API per gli ID specificati dall'utente. Devi utilizzare il campo DeliveryVehicleId per impostare l'ID del veicolo.

Quando crei un DeliveryVehicle, puoi facoltativamente specificare due campi:

• Attributi
• LastLocation

Non è necessario impostare tutti gli altri campi; in caso contrario, Fleet Engine restituirà un errore perché questi campi sono di sola lettura o possono essere aggiornati solo tramite chiamate UpdateDeliveryVehicle.

Per creare un veicolo senza impostare campi facoltativi, puoi lasciare il campo DeliveryVehicle non impostato in CreateDeliveryVehicleRequest.

L'esempio seguente mostra come utilizzare la libreria gRPC Java per creare un veicolo:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890"; // Avoid auto-incrementing IDs.

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String parent = "providers/" + PROJECT_ID;
DeliveryVehicle vehicle = DeliveryVehicle.newBuilder()
  .addAttributes(DeliveryVehicleAttribute.newBuilder()
    .setKey("route_number").setValue("1"))  // Opaque to the Fleet Engine
  .build();

// Vehicle request
CreateDeliveryVehicleRequest createVehicleRequest =
  CreateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setParent(parent)
      .setDeliveryVehicleId(VEHICLE_ID)     // Vehicle ID assigned by the Provider
      .setDeliveryVehicle(vehicle)
      .build();

// Error handling
// If Fleet Engine does not have vehicle with that ID and the credentials of the
// requestor pass, the service creates the vehicle successfully.

try {
  DeliveryVehicle createdVehicle =
    deliveryService.createDeliveryVehicle(createVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per creare un veicolo da un ambiente server, effettua una chiamata REST HTTP a CreateDeliveryVehicle:

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles?deliveryVehicleId=<id>

<id> è un identificatore univoco di un veicolo per la consegna del tuo parco veicoli.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo del POST rappresenta l'entità DeliveryVehicle da creare. Puoi specificare i seguenti campi facoltativi:

• attributes
• lastLocation

Esempio di comando curl:

# Set $JWT, $PROJECT_ID, and $VEHICLE_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles?deliveryVehicleId=${VEHICLE_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
--data-binary @- << EOM
{
  "attributes": [{"key": "model", "value": "sedan"}],
  "lastLocation": {"location": {"latitude": 12.1, "longitude": 14.5}}
}
EOM

Fleet Engine ignora il campo name dell'entità DeliveryVehicle in base alle linee guida API per gli ID specificati dall'utente. Tutti gli altri campi non devono essere impostati; in caso contrario, Fleet Engine restituirà un errore perché tali campi sono di sola lettura o possono essere aggiornati solo tramite chiamate UpdateDeliveryVehicle.

Per creare un veicolo senza impostare alcun campo, puoi lasciare vuoto il corpo della richiesta POST. Per il veicolo appena creato verrà estratto un ID veicolo estratto dal parametro deliveryVehicleId nell'URL POST.

Esempio di comando curl:

# Set $JWT, $PROJECT_ID, and $VEHICLE_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles?deliveryVehicleId=${VEHICLE_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}"

Crea un'attività di ritiro della spedizione

Puoi creare un'attività di ritiro della spedizione dall'SDK Driver o dall'ambiente del server.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per creare un'attività di ritiro della spedizione:

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.PICKUP)
  .setState(Task.State.OPEN)
  .setTrackingId("my-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .setTargetTimeWindow(
    TimeWindow.newBuilder()
      .setStartTime(Timestamp.newBuilder().setSeconds(1680123600))
      .setEndTime(Timestamp.newBuilder().setSeconds(1680130800)))
  .addAttributes(TaskAttribute.newBuilder().setKey("foo").setStringValue("value"))
  .addAttributes(TaskAttribute.newBuilder().setKey("bar").setNumberValue(10))
  .addAttributes(TaskAttribute.newBuilder().setKey("baz").setBoolValue(false))
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)          // Avoid using auto-incrementing IDs for the taskId
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have a task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per creare un'attività di ritiro della spedizione da un ambiente server, esegui una chiamata REST HTTP a "CreateTask":

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>

<id> è un identificatore univoco dell'attività. Non deve essere il numero di riferimento della spedizione. Se non hai ID attività nel tuo sistema, puoi generare un UUID (Universally Unique Identifier).

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità Task:

• Campi obbligatori:

  Campo	Valore
  digita	Digita.PICKUP
  finale	Stato.OPEN
  ID monitoraggio	Il numero o l'identificatore che stai utilizzando per tracciare una spedizione.
  posizione pianificata	Il luogo in cui deve essere completata l'attività, in questo caso il luogo di ritiro della spedizione.
  taskDuration	Il tempo previsto, in secondi, necessario per ritirare la spedizione presso il luogo di ritiro.

• Campi facoltativi:

  Campo	Valore
  Finestra temporale target	L'intervallo di tempo durante il quale deve essere completata l'attività. Al momento questa operazione non influisce sul comportamento di routing.
  attributes	Un elenco di attributi personalizzati dell'attività. Ogni attributo deve avere una chiave univoca.

Tutti gli altri campi dell'entità vengono ignorati per la creazione. Fleet Engine genera un'eccezione se la richiesta include un Delivery VehicleId assegnato. Puoi assegnare le attività utilizzando UpdateDeliveryVehicleRequests. Per maggiori informazioni, vedi Assegnare attività a un veicolo.

Esempio di comando curl:

# Set $JWT, $PROJECT_ID, $TRACKING_ID, and $TASK_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "type": "PICKUP",
  "state": "OPEN",
  "trackingId": "${TRACKING_ID}",
  "plannedLocation": {
     "point": {
        "latitude": -6.195139,
        "longitude": 106.820826
     }
  },
  "taskDuration": "90s",
  "targetTimeWindow": {
    "startTime": "2023-03-29T21:00:00Z",
    "endTime": "2023-03-29T23:00:00Z"
  }
}
EOM

Crea un'attività di consegna delle spedizioni

Puoi creare un'attività di consegna della spedizione dall'SDK Driver o dall'ambiente del server.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per creare un'attività di consegna della spedizione:

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.DELIVERY)
  .setState(Task.State.OPEN)
  .setTrackingId("my-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .setTargetTimeWindow(
    TimeWindow.newBuilder()
      .setStartTime(Timestamp.newBuilder().setSeconds(1680123600))
      .setEndTime(Timestamp.newBuilder().setSeconds(1680130800)))
  .addAttributes(TaskAttribute.newBuilder().setKey("foo").setStringValue("value"))
  .addAttributes(TaskAttribute.newBuilder().setKey("bar").setNumberValue(10))
  .addAttributes(TaskAttribute.newBuilder().setKey("baz").setBoolValue(false))
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)          // Avoid using auto-incrementing IDs for the taskId
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per creare un'attività di consegna della spedizione da un ambiente server, esegui una chiamata REST HTTP a "CreateTask":

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>

<id> è un identificatore univoco dell'attività. Non deve essere il numero di riferimento della spedizione. Se non hai ID attività nel tuo sistema, puoi generare un UUID (Universally Unique Identifier).

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità Task:

• Campi obbligatori:

  Campo	Valore
  digita	Tipo.DELIVERY
  finale	Stato.OPEN
  ID monitoraggio	Il numero o l'identificatore che stai utilizzando per tracciare una spedizione.
  posizione pianificata	La località in cui deve essere completata l'attività, in questo caso il luogo di consegna per la spedizione.
  taskDuration	Il tempo previsto, in secondi, necessario per consegnare la spedizione presso il luogo di consegna.

• Campi facoltativi:

  Campo	Valore
  Finestra temporale target	L'intervallo di tempo durante il quale deve essere completata l'attività. Al momento questa operazione non influisce sul comportamento di routing.
  attributes	Un elenco di attributi personalizzati dell'attività. Ogni attributo deve avere una chiave univoca.

Tutti gli altri campi dell'entità vengono ignorati per la creazione. Fleet Engine genera un'eccezione se la richiesta include un Delivery VehicleId assegnato. Puoi assegnare le attività utilizzando UpdateDeliveryVehicleRequests. Per maggiori informazioni, vedi Assegnare attività a un veicolo.

Esempio di comando curl:

# Set $JWT, $PROJECT_ID, $TRACKING_ID, and $TASK_ID in the local
# environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "type": "DELIVERY",
  "state": "OPEN",
  "trackingId": "${TRACKING_ID}",
  "plannedLocation": {
     "point": {
        "latitude": -6.195139,
        "longitude": 106.820826
     }
  },
  "taskDuration": "90s",
  "targetTimeWindow": {
    "startTime": "2023-03-29T21:00:00Z",
    "endTime": "2023-03-29T23:00:00Z"
  }
}
EOM

Creazione in gruppo di attività

Puoi creare un gruppo di attività dall'ambiente server.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per creare due attività, una per una consegna e una per un ritiro nella stessa località:

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Delivery Task settings
Task deliveryTask = Task.newBuilder()
  .setType(Task.Type.DELIVERY)
  .setState(Task.State.OPEN)
  .setTrackingId("delivery-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .build();

// Delivery Task request
CreateTaskRequest createDeliveryTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header or parent fields
      .setTaskId("task-8312508")  // Task ID assigned by the Provider
      .setTask(deliveryTask)      // Initial state
      .build();

// Pickup Task settings
Task pickupTask = Task.newBuilder()
  .setType(Task.Type.PICKUP)
  .setState(Task.State.OPEN)
  .setTrackingId("pickup-tracking-id")
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .build();

// Pickup Task request
CreateTaskRequest createPickupTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header or parent fields
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(pickupTask)        // Initial state
      .build();

// Batch Create Tasks settings
String parent = "providers/" + PROJECT_ID;

// Batch Create Tasks request
BatchCreateTasksRequest batchCreateTasksRequest =
  BatchCreateTasksRequest.newBuilder()
      .setParent(parent)
      .addRequests(createDeliveryTaskRequest)
      .addRequests(createPickupTaskRequest)
      .build();

// Error handling
// If Fleet Engine does not have any task(s) with these task ID(s) and the
// credentials of the requestor pass, the service creates the task(s)
// successfully.

try {
  BatchCreateTasksResponse createdTasks = deliveryService.batchCreateTasks(
    batchCreateTasksRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per creare un'attività di consegna e ritiro dall'ambiente del server, esegui una chiamata REST HTTP a BatchCreateTasks:

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks:batchCreate

L'intestazione della richiesta deve contenere un campo di Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità BatchCreateTasksRequest:

• Campi obbligatori:

  Campo	Valore
  richieste	Array<CreateTasksRequest>

• Campi facoltativi:

  Campo	Valore
  intestazione	"DeliveryRequestHeader"

Ogni elemento CreateTasksRequest in requests deve superare le stesse regole di convalida di una richiesta CreateTask, ad eccezione del fatto che i campi parent e header sono facoltativi. Se impostati, devono essere identici ai rispettivi campi nell'elemento BatchCreateTasksRequest di livello superiore. Consulta Creare un'attività di ritiro della spedizione e creare un'attività di consegna della spedizione per regole di convalida specifiche per ciascun prodotto.

Per ulteriori informazioni, consulta la documentazione di riferimento API per BatchCreateTasks (gRPC, REST).

Esempio di comando curl:

# Set $JWT, $PROJECT_ID, $DELIVERY_TRACKING_ID, $DELIVERY_TASK_ID,
# $PICKUP_TRACKING_ID, and $PICKUP_TASK_ID in the local environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks:batchCreate" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "requests" : [
    {
      "taskId": "${DELIVERY_TASK_ID}",
      "task" : {
        "type": "DELIVERY",
        "state": "OPEN",
        "trackingId": "${DELIVERY_TRACKING_ID}",
        "plannedLocation": {
          "point": {
              "latitude": -6.195139,
              "longitude": 106.820826
          }
        },
        "taskDuration": "90s"
      }
    },
    {
      "taskId": "${PICKUP_TASK_ID}",
      "task" : {
        "type": "PICKUP",
        "state": "OPEN",
        "trackingId": "${PICKUP_TRACKING_ID}",
        "plannedLocation": {
          "point": {
              "latitude": -6.195139,
              "longitude": 106.820826
          }
        },
        "taskDuration": "90s"
      }
    }
  ]
}
EOM

Indisponibilità pianificata

Puoi creare un'attività che indica la non disponibilità (ad esempio, per sospensioni del conducente o rifornimento di veicoli) dall'SDK Driver o dall'ambiente del server. Un'attività di non disponibilità pianificata non deve includere un ID monitoraggio. Se vuoi, puoi fornire una località.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per creare un'attività di non disponibilità:

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.UNAVAILABLE)
  .setState(Task.State.OPEN)
  .setTaskDuration(
    Duration.newBuilder().setSeconds(60 * 60))  // 1hr break
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)          // Avoid using auto-incrementing IDs for the taskId
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTask(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per creare un'attività di non disponibilità da un ambiente server, effettua una chiamata REST HTTP a "CreateTask":

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>

<id> è un identificatore univoco dell'attività. Se non hai ID attività nel tuo sistema, puoi generare un UUID (Universally Unique Identifier).

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità Task:

• Campi obbligatori:

  Campo	Valore
  digita	Tipo.UNAVAILABLE
  finale	Stato.OPEN
  taskDuration	La durata dell'interruzione in secondi.

• Campi facoltativi:

  Campo	Valore
  posizione pianificata	Il luogo dell'interruzione se deve essere scattata in un luogo specifico.

Tutti gli altri campi dell'entità vengono ignorati per la creazione. Fleet Engine genera un'eccezione se la richiesta include un Delivery VehicleId assegnato. Puoi assegnare le attività utilizzando UpdateDeliveryVehicleRequests. Per maggiori informazioni, vedi Assegnare attività a un veicolo.

Esempio di comando curl:

# Set $JWT, $PROJECT_ID, and $TASK_ID in the local environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "type": "UNAVAILABLE",
  "state": "OPEN",
  "plannedLocation": {
     "point": {
        "latitude": -6.195139,
        "longitude": 106.820826
     }
  },
  "taskDuration": "300s"
}
EOM

Fermate programmate

Puoi creare un'attività di interruzione pianificata dall'SDK Driver o dall'ambiente server. Un'attività di interruzione pianificata potrebbe non includere un ID monitoraggio.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per creare un'attività di interruzione pianificata:

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String parent = "providers/" + PROJECT_ID;
Task task = Task.newBuilder()
  .setType(Task.Type.SCHEDULED_STOP)
  .setState(Task.State.OPEN)
  .setPlannedLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .setTaskDuration(
    Duration.newBuilder().setSeconds(2 * 60))
  .build();

// Task request
CreateTaskRequest createTaskRequest =
  CreateTaskRequest.newBuilder()  // No need for the header
      .setParent(parent)
      .setTaskId("task-8241890")  // Task ID assigned by the Provider
      .setTrip(task)              // Initial state
      .build();

// Error handling
// If Fleet Engine does not have task with that ID and the credentials of the
// requestor pass, the service creates the task successfully.

try {
  Task createdTask = deliveryService.createTask(createTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case ALREADY_EXISTS:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per creare un'attività di interruzione pianificata da un ambiente server, esegui una chiamata REST HTTP a CreateTask:

POST https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks?taskId=<id>

<id> è un identificatore univoco dell'attività. Se non hai ID attività nel tuo sistema, puoi generare un UUID (Universally Unique Identifier).

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità Task:

• Campi obbligatori:

  Campo	Valore
  digita	Tipo.SCHEDULED_STOP
  finale	Stato.OPEN
  posizione pianificata	Il luogo della fermata.
  taskDuration	La durata prevista della fermata in secondi.

• Campi facoltativi:

  • Nessuno

Tutti gli altri campi dell'entità vengono ignorati per la creazione. Fleet Engine genera un'eccezione se la richiesta include un Delivery VehicleId assegnato. Puoi assegnare le attività utilizzando UpdateDeliveryVehicleRequests. Per maggiori informazioni, vedi Assegnare attività a un veicolo.

Esempio di comando curl:

# Set $JWT, $PROJECT_ID, and $TASK_ID in the local environment
curl -X POST "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?taskId=${TASK_ID}" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "type": "SCHEDULED_STOP",
  "state": "OPEN",
  "plannedLocation": {
     "point": {
        "latitude": -6.195139,
        "longitude": 106.820826
     }
  },
  "taskDuration": "600s"
}
EOM

La finestra temporale di destinazione è TimeWindow durante la quale l'attività deve essere completata. Ad esempio, se comunichi una finestra dei tempi di consegna ai destinatari della consegna, puoi utilizzare la finestra temporale target dell'attività per acquisire questa finestra temporale e generare avvisi o analizzare il rendimento dopo il viaggio utilizzando questo campo.

La finestra temporale target è composta da un'ora di inizio e un'ora di fine e può essere impostata per qualsiasi tipo di attività. La finestra temporale di destinazione attualmente non influisce sul comportamento di routing.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per impostare una finestra temporale dell'attività:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setTargetTimeWindow(
    TimeWindow.newBuilder()
      .setStartTime(Timestamp.newBuilder().setSeconds(1680123600))
      .setEndTime(Timestamp.newBuilder().setSeconds(1680130800)))
  .build();

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("targetTimeWindow"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per impostare una finestra temporale dell'attività utilizzando HTTP, chiama UpdateTask:

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=targetTimeWindow

<id> è un identificatore univoco dell'attività.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità Task:

• Campi obbligatori:

  Campo	Valore
  Finestra temporale target	L'intervallo di tempo durante il quale deve essere completata l'attività. Al momento questa azione non influisce sul comportamento di routing

• Campi facoltativi:

  • Nessuno

Tutti gli altri campi dell'entità vengono ignorati per l'aggiornamento.

Esempio di comando curl:

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=targetTimeWindow" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "targetTimeWindow": {
    "startTime": "2023-03-29T21:00:00Z",
    "endTime": "2023-03-29T23:00:00Z"
  }
}
EOM

Imposta la configurazione della visibilità del monitoraggio delle attività

La visibilità dei dati nella libreria di Shipment Tracking e dei dati restituiti da una chiamata a GetTaskTrackingInfo può essere controllata in base all'attività impostando un TaskTrackingViewConfig sull'attività. Per ulteriori informazioni, consulta Attività attive con un veicolo. Questa operazione può essere eseguita durante la creazione o l'aggiornamento dell'attività. Di seguito è riportato un esempio di aggiornamento dell'attività con questa configurazione:

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per impostare la configurazione della visualizzazione del monitoraggio delle attività:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setTaskTrackingViewConfig(
    TaskTrackingViewConfig.newBuilder()
      .setRoutePolylinePointsVisibility(
        VisibilityOption.newBuilder().setRemainingStopCountThreshold(3))
      .setEstimatedArrivalTimeVisibility(
        VisibilityOption.newBuilder().remainingDrivingDistanceMetersThreshold(5000))
      .setRemainingStopCountVisibility(
        VisibilityOption.newBuilder().setNever(true)))
  .build();

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("taskTrackingViewConfig"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
      case NOT_FOUND:
        break;
      case PERMISSION_DENIED:
        break;
  }
  return;
}

REST

Per impostare la finestra di configurazione della visualizzazione del monitoraggio delle attività utilizzando HTTP, chiama UpdateTask:

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=taskTrackingViewConfig

<id> è un identificatore univoco dell'attività.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità Task:

• Campi obbligatori:

  Campo	Valore
  taskTrackingViewConfig	La configurazione per il monitoraggio delle attività che specifica quali elementi di dati sono visibili agli utenti finali in quali circostanze.

• Campi facoltativi:

  • Nessuno

Tutti gli altri campi dell'entità vengono ignorati per l'aggiornamento.

Esempio di comando curl:

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=taskTrackingViewConfig" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "taskTrackingViewConfig": {
    "routePolylinePointsVisibility": {
      "remainingStopCountThreshold": 3
    },
    "estimatedArrivalTimeVisibility": {
      "remainingDrivingDistanceMetersThreshold": 5000
    },
    "remainingStopCountVisibility": {
      "never": true
    }
  }
}
EOM

Assegnare attività a un veicolo

Le attività vengono assegnate a un veicolo per la consegna aggiornando l'ordinamento delle attività per il veicolo. L'ordinamento delle attività per un veicolo è determinato dall'elenco delle fermate per il veicolo per la consegna. A ogni fermata può essere assegnata una o più attività.

L'aggiornamento dell'ordine delle attività per un'attività assegnata in precedenza a un altro veicolo genera un errore.

Per cambiare una spedizione da un veicolo a un altro, chiudi l'attività originale, quindi ricreala prima di assegnarla al nuovo veicolo.

Aggiorna l'ordine delle attività

Puoi aggiornare l'ordine di esecuzione delle attività assegnate a un veicolo dall'SDK Driver o dall'ambiente del server. I due metodi non devono essere misti per evitare race condition.

L'aggiornamento dell'ordinamento delle attività assegnerà anche attività a un veicolo, se non erano state assegnate in precedenza a un veicolo, e chiudono le attività precedentemente assegnate a un veicolo e escluse dall'ordine aggiornato. L'assegnazione di un'attività a un altro veicolo, se quest'ultima era stata precedentemente assegnata a un altro veicolo, genera un errore. Chiudi prima l'attività esistente, poi creane una nuova prima di assegnarla al nuovo veicolo.

L'ordine delle attività può essere aggiornato in qualsiasi momento.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per aggiornare l'ordinamento delle attività per il veicolo:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";
static final String TASK1_ID = "task-756390";
static final String TASK2_ID = "task-849263";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String vehicleName = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 1st stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.7749)
                   .setLongitude(122.4194)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
           .setState(VehicleStop.State.NEW)))
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 2nd stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW)))
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder().addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per aggiornare l'ordinamento delle attività per un veicolo da un ambiente server, esegui una chiamata REST HTTP a "UpdateDeliveryVeicoli":

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remainingVehicleJourneySegments

<id> è un identificatore univoco per un veicolo per la consegna nel tuo parco risorse per il quale intendi aggiornare l'ordinamento dell'attività. È l'identificatore che hai specificato durante la creazione del veicolo.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità DeliveryVehicle:

• Campi obbligatori:

  Campo	Valore
  Segmenti di percorsaVeicolo rimanenti	Un elenco di segmenti del percorso per le attività nell'ordine di esecuzione. La prima attività nell'elenco viene eseguita per prima.
  restanteVeicoloJourneySegments[i].stop	L'interruzione per l'attività i nell'elenco.
  restanteVeicoloJourneySegments[i].stop.plannedLocation	Il luogo pianificato per la fermata.
  restanteVeicoloJourneySegments[i].stop.tasks	Un elenco di attività da eseguire presso questa fermata del veicolo.
  restanteVeicoloJourneySegments[i].stop.state	Stato.NOVITÀ

• Campi facoltativi:

  • Nessuno

Tutti gli altri campi dell'entità vengono ignorati per l'aggiornamento.

Esempio di comando curl:

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.7749,
            "longitude": -122.084061
          }
        },
        "tasks": [
          {
            "taskId": "${TASK1_ID}"
          }
        ]
      }
    },
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}"
          }
        ]
      }
    }
  ]
}
EOM

Fleet Engine deve ricevere una notifica quando un veicolo parte da una fermata o inizia la navigazione. Puoi notificare Fleet Engine dall' SDK Driver o dall'ambiente del server. I due metodi non devono essere combinati per evitare le condizioni di gara e per mantenere un'unica fonte attendibile.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per notificare a Fleet Engine che un veicolo sta per raggiungere la fermata successiva.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    // Next stop marked as ENROUTE
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 1st stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.7749)
                   .setLongitude(122.4194)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
           .setState(VehicleStop.State.ENROUTE)))
    // All other stops marked as NEW
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 2nd stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW)))
    .build();


// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder().addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per notificare a Fleet Engine che un veicolo sta per raggiungere la fermata successiva da un ambiente server, esegui una chiamata REST HTTP a "UpdateDeliveryVeicoli":

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remainingVehicleJourneySegments

<id> è un identificatore univoco per il veicolo per la consegna nel parco risorse per il quale intendi aggiornare l'ordinamento dell'attività. È l'identificatore che hai specificato durante la creazione del veicolo.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità DeliveryVehicle:

• Campo obbligatorio:

  Campo	Valore
  Segmenti di percorsaVeicolo rimanenti	Elenco delle fermate rimanenti del veicolo con i relativi stati contrassegnati come State.NEW. La prima fermata nell'elenco deve avere il proprio stato contrassegnato come State.ENROUTE.

• Campi facoltativi:

  • Nessuno

Tutti gli altri campi dell'entità vengono ignorati per la notifica.

Esempio di comando curl:

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "ENROUTE",
        "plannedLocation": {
          "point": {
            "latitude": 37.7749,
            "longitude": -122.084061
          }
        },
        "tasks": [
          {
            "taskId": "${TASK1_ID}"
          }
        ]
      }
    },
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}"
          }
        ]
      }
    }
  ]
}
EOM

Fleet Engine deve ricevere una notifica quando un veicolo si ferma. Puoi inviare una notifica a Fleet Engine dall' SDK Driver o dall'ambiente del server. I due metodi non devono essere combinati per evitare le condizioni di gara e per mantenere un'unica fonte attendibile.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per notificare a Fleet Engine che un veicolo è arrivato a una fermata:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String vehicleName = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    // Marking the arrival at stop.
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.7749)
                   .setLongitude(122.4194)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
           .setState(VehicleStop.State.ARRIVED)))
    // All other remaining stops marked as NEW.
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // 2nd stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW))) // Remaining stops must be NEW.
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder()
          .addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per notificare a Fleet Engine l'arrivo di un veicolo a una fermata dall'ambiente di un server, effettua una chiamata REST HTTP a "UpdateDeliveryVeicoli":

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remainingVehicleJourneySegments

<id> è un identificatore univoco per il veicolo per la consegna nel parco risorse per il quale intendi aggiornare l'ordinamento dell'attività. È l'identificatore che hai specificato durante la creazione del veicolo.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità DeliveryVehicle:

• Campi obbligatori:

  Campo	Valore
  Segmenti di percorsaVeicolo rimanenti	La fermata a cui hai raggiunto il suo stato è impostato su State.ARRIVED, seguito da un elenco delle fermate rimanenti del veicolo con i relativi stati contrassegnati come State.NEW.

• Campi facoltativi:

  • Nessuno

Tutti gli altri campi dell'entità vengono ignorati per l'aggiornamento.

Esempio di comando curl:

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "ARRIVED",
        "plannedLocation": {
          "point": {
            "latitude": 37.7749,
            "longitude": -122.084061
          }
        },
        "tasks": [
          {
            "taskId": "${TASK1_ID}"
          }
        ]
      }
    },
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}"
          }
        ]
      }
    }
  ]
}
EOM

Fleet Engine deve ricevere una notifica quando un veicolo completa una fermata. In questo modo, tutte le attività associate alla fermata vengono impostate sullo stato CHIUSO. Puoi inviare notifiche a Fleet Engine dall' SDK Driver o dall'ambiente server. I due metodi non devono essere combinati per evitare race condition e mantenere un'unica fonte attendibile.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per notificare a Fleet Engine che un veicolo ha completato una fermata.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle settings
String vehicleName = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
DeliveryVehicle deliveryVehicle = DeliveryVehicle.newBuilder()
    // This stop has been completed and is commented out to indicate it
    // should be removed from the list of vehicle journey segments.
    // .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()
    //    .setStop(VehicleStop.newBuilder()
    //        .setPlannedLocation(LocationInfo.newBuilder()
    //            .setPoint(LatLng.newBuilder()
    //                .setLatitude(37.7749)
    //                .setLongitude(122.4194)))
    //        .addTasks(TaskInfo.newBuilder().setTaskId(TASK1_ID))
    //        .setState(VehicleStop.State.ARRIVED)))
    // All other remaining stops marked as NEW.
    // The next stop could be marked as ENROUTE if the vehicle has begun
    // its journey to the next stop.
    .addRemainingVehicleJourneySegments(VehicleJourneySegment.newBuilder()  // Next stop
       .setStop(VehicleStop.newBuilder()
           .setPlannedLocation(LocationInfo.newBuilder()
               .setPoint(LatLng.newBuilder()
                   .setLatitude(37.3382)
                   .setLongitude(121.8863)))
           .addTasks(TaskInfo.newBuilder().setTaskId(TASK2_ID))
           .setState(VehicleStop.State.NEW)))
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // no need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(deliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder()
          .addPaths("remaining_vehicle_journey_segments"))
      .build();

try {
  DeliveryVehicle updatedDeliveryVehicle =
      deliveryService.updateDeliveryVehicle(updateDeliveryVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per notificare a Fleet Engine il completamento di un'interruzione da un ambiente server, esegui una chiamata REST HTTP a "UpdateDeliveryVeicoli":

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<id>?updateMask=remaining_vehicle_journey_segments

<id> è un identificatore univoco per il veicolo per la consegna nel parco risorse per il quale intendi aggiornare l'ordinamento dell'attività. È l'identificatore che hai specificato durante la creazione del veicolo.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità DeliveryVehicle:

• Campi obbligatori:

  Campo	Valore
  segmenti_per_per_i_veicoli_restanti	La fermata che hai completato non dovrebbe più essere nell'elenco delle fermate del veicolo rimanenti.

• Campi facoltativi:

  • Nessuno

Tutti gli altri campi dell'entità vengono ignorati per l'aggiornamento.

Esempio di comando curl:

# Set JWT, PROJECT_ID, VEHICLE_ID, TASK1_ID, and TASK2_ID in the local
# environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}?updateMask=remainingVehicleJourneySegments" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "remainingVehicleJourneySegments": [
    {
      "stop": {
        "state": "NEW",
        "plannedLocation": {
          "point": {
            "latitude": 37.3382,
            "longitude": 121.8863
          }
        },
        "tasks": [
          {
            "taskId": "${TASK2_ID}",
            "taskDuration": "120s"
          }
        ]
      }
    }
  ]
}
EOM

Questo è un esempio di aggiornamento di un'attività tramite gRPC.

REST

Questo è un esempio di aggiornamento di un'attività tramite REST.

Per chiudere un'attività assegnata a un veicolo, informa Fleet Engine che il veicolo ha completato la fermata in cui si svolge l'attività oppure rimuovi il veicolo dall'elenco delle fermate. Per farlo, puoi impostare l'elenco delle fermate dei veicoli rimanenti esattamente come per aggiornare l'ordine delle attività per un veicolo.

Se a un'attività non è ancora stato assegnato un veicolo e deve essere chiusa, impostala su uno stato CHIUSO. Tuttavia, non puoi riaprire un'attività CHIUSA.

La chiusura di un'attività non indica l'esito positivo o negativo. Indica che l'attività non è più considerata in corso. Per il monitoraggio del parco risorse, è importante indicare il risultato effettivo di un'attività in modo da poter mostrare i risultati di consegna.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setState(Task.State.CLOSED) // It's only possible to directly CLOSE a
  .build();                    // task which is NOT assigned to a vehicle.

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("state"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=state

<id> è un identificatore univoco per l'attività.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità Task:

• Campi obbligatori:

  Campo	Valore
  finale	Stato.CHIUSO

• Campi facoltativi:

  Campo	Valore
  Risultato attività	Risultato.SUCCEEDED o Risultato.FAILED
  attivitàRisultatoTempo	L'ora in cui l'attività è stata completata.
  attivitàRisultatoPosizione	La posizione in cui è stata completata l'attività. Fleet Engine imposta questa impostazione sull'ultima posizione del veicolo per impostazione predefinita, a meno che non venga sostituita manualmente dal fornitore.

Tutti gli altri campi dell'entità vengono ignorati per l'aggiornamento.

Esempio di comando curl:

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=state,taskOutcome,taskOutcomeTime" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "state": "CLOSED",
  "taskOutcome": "SUCCEEDED",
  "taskOutcomeTime": "$(date -u --iso-8601=seconds)"
}
EOM

L'esempio seguente mostra come utilizzare la libreria gRPC Java per impostare il risultato di un'attività su SUCCEEDED e la località in cui è stata completata l'attività:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task settings
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
Task task = Task.newBuilder()
  .setName(taskName)
  .setTaskOutcome(TaskOutcome.SUCCEEDED)
  .setTaskOutcomeTime(now())
  .setTaskOutcomeLocation(               // Grand Indonesia East Mall
    LocationInfo.newBuilder().setPoint(
      LatLng.newBuilder().setLatitude(-6.195139).setLongitude(106.820826)))
  .build();

// Task request
UpdateTaskRequest updateTaskRequest =
  UpdateTaskRequest.newBuilder()  // No need for the header
      .setTask(task)
      .setUpdateMask(FieldMask.newBuilder().addPaths("task_outcome", "task_outcome_time", "task_outcome_location"))
      .build();

try {
  Task updatedTask = deliveryService.updateTask(updateTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

PATCH https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<id>?updateMask=taskOutcome,taskOutcomeTime,taskOutcomeLocation

<id> è un identificatore univoco per l'attività.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve contenere un'entità Task:

• Campi obbligatori:

  Campo	Valore
  Risultato attività	Risultato.SUCCEEDED o Risultato.FAILED
  attivitàRisultatoTempo	Il timestamp di quando è stato impostato il risultato dell'attività (dal provider). Si tratta dell'ora in cui l'attività è stata completata.

• Campi facoltativi:

  Campo	Valore
  attivitàRisultatoPosizione	La posizione in cui è stata completata l'attività. Fleet Engine imposta questa impostazione sull'ultima posizione del veicolo per impostazione predefinita, a meno che non venga sostituita manualmente dal fornitore.

Tutti gli altri campi dell'entità vengono ignorati per l'aggiornamento.

Esempio di comando curl:

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -X PATCH "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}?updateMask=taskOutcome,taskOutcomeTime,taskOutcomeLocation" \
  -H "Content-type: application/json" \
  -H "Authorization: Bearer ${JWT}" \
  --data-binary @- << EOM
{
  "taskOutcome": "SUCCEEDED",
  "taskOutcomeTime": "$(date -u --iso-8601=seconds)",
  "taskOutcomeLocation": {
    "point": {
      "latitude": -6.195139,
      "longitude": 106.820826
    }
  }
}
EOM

Deviare una spedizione

Una volta creata un'attività di spedizione, la località pianificata non può essere modificata. Per reindirizzare una spedizione, chiudi l'attività di spedizione senza impostare un risultato, quindi crea una nuova attività con la posizione pianificata aggiornata. Dopo aver creato la nuova attività, assegnala allo stesso veicolo. Per saperne di più, consulta Chiudere l'attività di spedizione e assegnarla.

Utilizzare il feeder e i veicoli per la consegna

Se utilizzi veicoli con feeder per trasportare le spedizioni ai veicoli per la consegna nell'arco dell'intera giornata, modella il trasferimento delle spedizioni come un'attività di interruzione pianificata per il veicolo per la consegna. Per garantire un monitoraggio della posizione accurato, assegna un'attività di consegna per una spedizione trasferita solo dopo che questa è stata caricata sul veicolo per la consegna. Per ulteriori informazioni, consulta la sezione Fermata programmata.

Stato di spedizione del negozio e altre meta informazioni

Quando un'attività di spedizione è completata, lo stato e il risultato dell'attività vengono registrati nell'attività. Tuttavia, ti consigliamo di aggiornare altre meta informazioni specifiche per la spedizione. Per archiviare altre meta informazioni a cui puoi fare riferimento al di fuori del servizio Fleet Engine, utilizza il tracking_id associato all'attività come chiave in una tabella esterna.

Per saperne di più, vedi Vita di un'attività.

Cercare un veicolo

Puoi cercare un veicolo dall'SDK Driver o dall'ambiente del server.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per cercare un veicolo:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String VEHICLE_ID = "vehicle-8241890";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Vehicle request
String name = "providers/" + PROJECT_ID + "/deliveryVehicles/" + VEHICLE_ID;
GetDeliveryVehicleRequest getVehicleRequest = GetDeliveryVehicleRequest.newBuilder()  // No need for the header
    .setName(name)
    .build();

try {
  DeliveryVehicle vehicle = deliveryService.getDeliveryVehicle(getVehicleRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;
     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per cercare un veicolo da un ambiente server, esegui una chiamata REST HTTP a "Get Vehicle":

GET https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles/<vehicleId>

<id> è un identificatore univoco dell'attività.

<vehicleId> è l'ID del veicolo da cercare.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve essere vuoto.

Se la ricerca ha esito positivo, il corpo della risposta contiene un'entità veicolo.

Esempio di comando curl:

# Set JWT, PROJECT_ID, and VEHICLE_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles/${VEHICLE_ID}"

Cercare un'attività

Puoi cercare un'attività da un ambiente server. L'SDK Driver non supporta la ricerca di un'attività.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per cercare un'attività:

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TASK_ID = "task-8597549";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Task request
String taskName = "providers/" + PROJECT_ID + "/tasks/" + TASK_ID;
GetTaskRequest getTaskRequest = GetTaskRequest.newBuilder()  // No need for the header
    .setName(taskName)
    .build();

try {
  Task task = deliveryService.getTask(getTaskRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;

     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per cercare un'attività da un ambiente server, esegui una chiamata REST HTTP a "GetTask":

GET https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks/<taskId>

<id> è un identificatore univoco dell'attività.

<taskId> è l'ID dell'attività da cercare.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Il corpo della richiesta deve essere vuoto.

Se la ricerca ha esito positivo, il corpo della risposta contiene un'entità attività.

Esempio di comando curl:

# Set JWT, PROJECT_ID, and TASK_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks/${TASK_ID}"

Cerca le informazioni sull'attività di spedizione in base al relativo ID monitoraggio

Puoi cercare le informazioni sull'attività di spedizione nei seguenti modi, ognuno dei quali ha uno scopo distinto:

• da un ID attività: utilizzato da utenti come gli operatori del parco risorse che hanno accesso alla visualizzazione completa dei dati delle attività.
• da un ID monitoraggio: utilizzato dal software client per fornire informazioni limitate a un utente finale, ad esempio l'arrivo di un pacco a casa.

Questa sezione illustra la ricerca delle informazioni sulle attività in base a un ID monitoraggio. Se vuoi cercare un'attività in base al relativo ID, vai alla sezione relativa alla ricerca di un'attività.

Per cercare informazioni in base a un ID monitoraggio, puoi utilizzare uno dei seguenti metodi:

• Ricerche con Java utilizzando gRPC
• Ricerche mediante HTTP

Requisiti di ricerca

• Le informazioni sulla spedizione fornite da un ID monitoraggio sono conformi alle regole di visibilità indicate nella sezione Controllare la visibilità delle località monitorate.

• Utilizza Fleet Engine per cercare informazioni sulla spedizione per ID monitoraggio. L'SDK Driver non supporta le ricerche di informazioni per ID monitoraggio. Per farlo con Fleet Engine, utilizzerai un ambiente server o browser.

• Utilizza il token più stretto possibile per limitare i rischi per la sicurezza. Ad esempio, se utilizzi un token consumer per la consegna, qualsiasi chiamata all'API Fleet Engine Deliveries restituisce solo informazioni pertinenti per l'utente finale, ad esempio il corriere o il destinatario di una spedizione. Tutte le altre informazioni nelle risposte vengono oscurate. Per ulteriori informazioni sui token, consulta la pagina Creazione di un token JWT (JSON Web Token) per l'autorizzazione.

Ricerche con Java utilizzando gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per cercare informazioni su un'attività di spedizione in base al relativo ID monitoraggio.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TRACKING_ID = "TID-7449w087464x5";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Tasks request
String parent = "providers/" + PROJECT_ID;
GetTaskTrackingInfoRequest getTaskTrackingInfoRequest = GetTaskTrackingInfoRequest.newBuilder()  // No need for the header
    .setParent(parent)
    .setTrackingId(TRACKING_ID)
    .build();

try {
  TaskTrackingInfo taskTrackingInfo = deliveryService.getTaskTrackingInfo(getTaskTrackingInfoRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;

     case PERMISSION_DENIED:
       break;
  }
  return;
}

Ricerche mediante HTTP

Per cercare un'attività di spedizione da un browser, effettua una chiamata REST HTTP a GetTaskTrackingInfo:

GET https://fleetengine.googleapis.com/v1/providers/<project_id>/taskTrackingInfo/<tracking_id>

<tracking_id> è l'ID monitoraggio associato all'attività.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token emesso dalla fabbrica di token di Fleet Engine.

Se la ricerca ha esito positivo, il corpo della risposta contiene un'entità taskTrackingInfo.

Esempio di comando curl:

# Set JWT, PROJECT_ID, and TRACKING_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/taskTrackingInfo/${TRACKING_ID}"

Elenca attività

Puoi elencare le attività da un ambiente server o browser. L'SDK Driver non supporta la creazione di schede di attività.

Le attività delle schede richiedono accesso completo alle attività. L'attività della scheda è destinata solo a utenti attendibili. Utilizza il lettore di Delivery Fleet o i token di autenticazione super user di consegna per effettuare richieste di attività elenco.

I seguenti campi delle attività elencate sono oscurati:

• VehicleStop.planned_location
• Stato.Veicolo
• VehicleStop.TaskInfo.taskId

Le attività elencate possono essere filtrate in base alla maggior parte delle proprietà delle attività. Per la sintassi delle query di filtro, consulta AIP-160. Il seguente elenco mostra le proprietà valide delle attività che puoi utilizzare per i filtri:

• attributes
• ID veicolo di consegna
• finale
• località_pianificata
• durata_attività
• risultato_attività
• località_outcome_attività
• origine_località_outcome_attività
• orario_di_fine_attività
• ID_monitoraggio
• digita

Utilizza i seguenti formati di campo basati sulle proposte di miglioramento dell'API di Google:

Consulta AIP-160 per un elenco completo degli operatori di query di filtro.

Se non viene specificata alcuna query di filtro, vengono elencate tutte le attività.

Gli elenchi di attività sono impaginati. È possibile specificare le dimensioni di pagina nelle richieste di attività di elenco. Se viene specificata una dimensione di pagina, il numero di attività restituite non supera le dimensioni di pagina specificate. Se non sono presenti dimensioni di pagina, viene utilizzata una dimensione predefinita ragionevole. Se le dimensioni di pagina richieste superano un valore massimo interno, viene utilizzato il valore massimo interno.

Un elenco di attività può includere un token per leggere la pagina dei risultati successiva. Utilizza il token di pagina con una richiesta altrimenti identica alla richiesta precedente per recuperare la pagina di attività successiva. Quando il token della pagina restituito è vuoto, non sono disponibili altre attività da recuperare.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per elencare le attività per un oggetto Delivery VehicleId e un attributo di attività. Una risposta corretta può essere ancora vuota. Una risposta vuota indica che nessuna attività è associata all'ID veicolo fornito.

static final String PROJECT_ID = "my-delivery-co-gcp-project";
static final String TRACKING_ID = "TID-7449w087464x5";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Tasks request
String parent = "providers/" + PROJECT_ID;
ListTasksRequest listTasksRequest = ListTasksRequest.newBuilder()  // No need for the header
    .setParent(parent)
    .setFilter("delivery_vehicle_id = 123 AND attributes.foo = true")
    .build();

try {
  ListTasksResponse listTasksResponse = deliveryService.listTasks(listTasksRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
     case NOT_FOUND:
       break;

     case PERMISSION_DENIED:
       break;
  }
  return;
}

REST

Per elencare le attività da un browser, effettua una chiamata REST HTTP a ListTasks:

GET https://fleetengine.googleapis.com/v1/providers/<project_id>/tasks

Per applicare un filtro alle attività elencate, includi un parametro URL "filtro" con una query di filtro con caratteri di escape URL come valore.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Se la ricerca ha esito positivo, il corpo della risposta contiene dati con la seguente struttura:

// JSON representation
{
  "tasks": [
    {
      object (Task)
    }
  ],
  "nextPageToken": string,
  "totalSize": integer
}

Una risposta corretta può ancora essere vuota. Una risposta vuota indica che non sono state trovate attività che soddisfano i criteri di filtro specificati.

Esempio di comando curl:

# Set JWT, PROJECT_ID, and VEHICLE_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/tasks?filter=state%20%3D%20OPEN%20AND%20delivery_vehicle_id%20%3D%20${VEHICLE_ID}"

Elenca veicoli per la consegna

Puoi elencare i veicoli per la consegna da un ambiente server o browser. L'SDK Driver non supporta la pubblicazione di schede sui veicoli per la consegna.

La scheda dei veicoli per la consegna richiede l'accesso completo ai veicoli per la consegna ed è destinata solo agli utenti affidabili. Utilizza il lettore di Delivery Fleet o i token di autenticazione super utente di Delivery per effettuare richieste di veicoli per la consegna di elenchi.

I veicoli di consegna elencati hanno i seguenti campi oscurati a causa del loro impatto sulle dimensioni della risposta:

• Segmento route corrente
• Segmenti di percorrereveicoli rimanenti

Puoi filtrare l'elenco dei veicoli per la consegna in base alla relativa proprietà attributes. Ad esempio, per eseguire query su un attributo con chiave my_key e valore my_value, utilizza attributes.my_key = my_value. Per eseguire query su più attributi, unisci le query utilizzando gli operatori logici AND e OR, come in attributes.key1 = value1 AND attributes.key2 = value2. Consulta AIP-160 per una descrizione completa della sintassi delle query di filtro.

Puoi filtrare i veicoli di consegna elencati per località utilizzando il parametro di richiesta viewport. Il parametro di richiesta viewport definisce le aree visibili utilizzando due coordinate di delimitazione: latitudine/longitudine high (nord-est) e low (sud-ovest). Le richieste vengono rifiutate se contengono un'alta latitudine geograficamente inferiore a una bassa.

Gli elenchi di veicoli per la consegna vengono impaginati per impostazione predefinita utilizzando dimensioni di pagina ragionevoli. Se specifichi una dimensione di pagina, la richiesta restituisce solo il numero massimo di veicoli specificati dal limite. Se le dimensioni della pagina richieste superano un valore massimo interno, viene utilizzato il valore massimo interno. Le dimensioni predefinite e massime delle pagine corrispondono a 100 veicoli.

Un elenco di veicoli per la consegna può includere un token per la lettura della pagina dei risultati successiva. Un token di pagina è presente in una risposta solo quando sono disponibili per il recupero più pagine di veicoli di consegna. Per recuperare la pagina successiva di attività, utilizza il token della pagina con una richiesta identica alla richiesta precedente.

gRPC

L'esempio seguente mostra come utilizzare la libreria gRPC Java per elencare i veicoli di consegna in una determinata regione con un determinato attributo. Una risposta corretta può ancora essere vuota. Quando ciò accade, significa che nessun veicolo con l'attributo specificato si trova attualmente nell'area visibile specificata.

static final String PROJECT_ID = "my-delivery-co-gcp-project";

DeliveryServiceBlockingStub deliveryService =
  DeliveryServiceGrpc.newBlockingStub(channel);

// Tasks request
String parent = "providers/" + PROJECT_ID;
ListDeliveryVehiclesRequest listDeliveryVehiclesRequest =
  ListDeliveryVehiclesRequest.newBuilder()  // No need for the header
      .setParent(parent)
      .setViewport(
            Viewport.newBuilder()
              .setHigh(LatLng.newBuilder()
                  .setLatitude(37.45)
                  .setLongitude(-122.06)
                  .build())
              .setLow(LatLng.newBuilder()
                  .setLatitude(37.41)
                  .setLongitude(-122.11)
                  .build())
      .setFilter("attributes.my_key = my_value")
      .build();

try {
  ListDeliveryVehiclesResponse listDeliveryVehiclesResponse =
      deliveryService.listDeliveryVehicles(listDeliveryVehiclesRequest);
} catch (StatusRuntimeException e) {
  Status s = e.getStatus();
  switch (s.getCode()) {
      case NOT_FOUND:
          break;

      case PERMISSION_DENIED:
          break;
  }
  return;
}

REST

Per elencare le attività da un browser, effettua una chiamata REST HTTP a ListDeliveryVehicles:

GET https://fleetengine.googleapis.com/v1/providers/<project_id>/deliveryVehicles

Per applicare un filtro alle attività elencate, includi un parametro URL "filtro" con una query di filtro con escape URL come valore.

L'intestazione della richiesta deve contenere un campo Autorizzazione con il valore Bearer <token>, dove <token> è un token coniato da una fabbrica di token di Fleet Engine.

Se la ricerca ha esito positivo, il corpo della risposta contiene dati con la seguente struttura:

// JSON representation
{
  "deliveryVehicles": [
    {
      object (DeliveryVehicle)
    }
  ],
  "nextPageToken": string,
  "totalSize": integer
}

Una risposta corretta può ancora essere vuota. Quando ciò accade, significa che non sono stati trovati veicoli per la consegna che soddisfano la query di filtro e l'area visibile specificate.

Esempio di comando curl:

# Set JWT, PROJECT_ID, and VEHICLE_ID in the local environment
curl -H "Authorization: Bearer ${JWT}" \
  "https://fleetengine.googleapis.com/v1/providers/${PROJECT_ID}/deliveryVehicles?filter=attributes.my_key%20%3D%20my_value%20&viewport.high.latitude=37.45&viewport.high.longitude=-122.06&viewport.low.latitude=37.41&viewport.low.longitude=-122.11"

Monitoraggio del parco risorse

Hai due opzioni per utilizzare l'API Fleet Engine Deliveries per abilitare il monitoraggio del parco risorse:

• Preferito: utilizza la libreria per il monitoraggio del parco risorse JavaScript. La libreria ti consente di visualizzare la posizione dei veicoli e le località di interesse monitorati in Fleet Engine. Contiene un componente di mappa JavaScript che sostituisce un oggetto google.maps.Map standard e componenti di dati per la connessione a Fleet Engine. In questo modo puoi fornire un'esperienza di monitoraggio del parco risorse animata e personalizzabile dalla tua applicazione web o mobile.

• Implementa il monitoraggio del tuo parco veicoli in aggiunta all'API Fleet Engine Deliveries.

Logging

Puoi abilitare un'opzione per consentire a Fleet Engine di inviare log RPC a Cloud Logging. Per ulteriori informazioni, consulta Logging.

Come descritto in Integrazione dell'API Deliveries e nelle note di autorizzazione per singoli casi d'uso, per effettuare chiamate a Fleet Engine è necessaria l'autenticazione con token web JSON che sono stati firmati utilizzando le credenziali dell'account di servizio. Gli account di servizio utilizzati per creare i token possono avere uno o più ruoli e ogni ruolo concede un insieme diverso di autorizzazioni.

Per ulteriori informazioni, consulta la sezione Autenticazione e autorizzazione.

Risoluzione dei problemi

Resilienza

Fleet Engine non è considerato una fonte attendibile. Sei responsabile del ripristino dello stato del sistema, se necessario, senza fare affidamento su Fleet Engine.

Stato perso in Fleet Engine

Quando lavori con Fleet Engine, implementa i client in modo che il sistema si ripara da solo in caso di errore. Ad esempio, quando Fleet Engine prova ad aggiornare un veicolo, potrebbe restituire un errore che indica che il veicolo non esiste. Il cliente deve quindi ricreare il veicolo nel nuovo stato. Questa situazione si verifica raramente, pertanto il sistema deve essere resiliente in caso contrario.

Nello scenario estremamente improbabile di un guasto catastrofico di Fleet Engine, potresti dover ricreare la maggior parte o tutti i veicoli e le attività. Se la frequenza di creazione diventa troppo elevata, alcune richieste potrebbero non riuscire di nuovo a causa di problemi di quota, poiché sono in corso controlli delle quote per evitare attacchi DOS (Denial of Service). In questo caso, rallenta la percentuale di ricreazione utilizzando una strategia di backoff per i nuovi tentativi.

Stato perso nell'app del conducente

Se l'app del driver si arresta in modo anomalo, deve ricreare lo stato attuale nell'SDK Driver. L'app deve tentare di ricreare le attività per assicurarle che esistano e ripristinare lo stato attuale. L'app deve inoltre ricreare e impostare esplicitamente l'elenco di fermate per l'SDK Driver.

Tieni presente che questi ripristini devono essere eseguiti in modo autonomo senza fare affidamento sulle informazioni di Fleet Engine, ad eccezione degli errori che indicano se e quando un'entità esiste già nel database. Se un'entità esiste già, l'errore può essere assorbito e l'entità può essere aggiornata utilizzando il suo ID.

Domande frequenti

Cosa succede se un conducente si ferma per un'attività non in ordine?

In questo caso, devi prima aggiornare l'ordine delle attività e poi procedere come di consueto, contrassegnando l'arrivo alla fermata, il completamento dell'attività e così via. In caso contrario, il sistema potrebbe diventare incoerente. Gli orari di arrivo stimati potrebbero diventare errati e potrebbero essere segnalati errori imprevisti.