Erste Schritte mit Fleet Engine für die Sendungsverfolgung

Modellieren Sie Ihre Flottenaktivitäten für die erste und letzte Meile von Lieferungen mit Fleet Engine Deliveries API. Sie können diese API mit dem Driver SDK for Android verwenden und iOS oder direkt über HTTP REST- oder gRPC-Aufrufe.

Ersteinrichtung

Die Fleet Engine Deliveries API wird in der Google Cloud Console konfiguriert.

• Informationen zu den Schritten in der Konsole und zum Erstellen ein JSON Web Token zur Autorisierung verwenden, siehe Authentifizierung und Autorisierung.

• Weitere Informationen zur Verwendung der Konsole finden Sie in der Dokumentation zur Google Cloud Console

Einrichtung überprüfen

Prüfen Sie nach dem Erstellen von Dienstkonten, ob die Einrichtung abgeschlossen ist und ein Lieferfahrzeug erstellen. Einrichtung sofort überprüfen sorgt dafür, dass Sie häufige Autorisierungsprobleme behoben haben, bei der Einrichtung Ihres Projekts. Es gibt zwei Möglichkeiten, die Konfiguration zu überprüfen:

• Zwei wichtige Teile der Einrichtung testen: das Signieren des Autorisierungstokens und die Übermittlung des Testzeitraums Fahrzeugerstellung mit der gcloud-Befehlszeilendienstprogramm. Für finden Sie unter Einrichtung überprüfen. .

• Testen Sie Ihre Einrichtung mit dem Fleet Engine-Auth-Beispielskripts

Clientbibliotheken

Verwenden Sie die Methode Clientbibliotheken in verschiedenen gängigen Programmiersprachen. Für Anweisungen zum Abrufen von Clientbibliotheken für Ihre Serveranwendung finden Sie unter Clientbibliotheken.

In den Java-Beispielen in dieser Dokumentation wird davon ausgegangen, dass Sie mit gRPC vertraut sind.

Datenstrukturen

Die Fleet Engine Deliveries API verwendet zwei Datenstrukturen, um Abhol- und Liefervorgänge zu modellieren der Lieferungen:

• Das Lieferfahrzeug, das zum Transport der Sendung verwendet wird.
• Die Aufgaben zur Abholung und Lieferung von Lieferungen.

Außerdem verwenden Sie Aufgaben, um Fahrerpausen und geplante Haltestellen zu modellieren. über den Tag verteilt.

Lieferfahrzeuge

Lieferfahrzeuge transportieren Lieferungen von einem Depot zu einem Lieferort und vom Abholort ins Depot zu gelangen. In bestimmten Fällen können sie auch eine Sendung direkt vom Abholort zum Lieferort zu transportieren.

Verwenden Sie das Driver SDK, um ein DeliveryVehicle-Objekt in Fleet Engine zu erstellen und senden Standortaktualisierungen für die Sendungs- und Flottenverfolgung.

Aufgaben

Für die Aktionen, die ein Fahrzeug während des Tages ausführt, weisen Sie Aufgaben nach die Art der Aktion:

• Weisen Sie für Abholungen und Lieferungen Versandaufgaben zu.
• Wenn keine Fahrer verfügbar sind, z. B. bei erforderlichen Pausen, Nichtverfügbarkeitsaufgaben zuweisen.
• Für Aufgaben, die nicht angefahren werden, an Briefkästen oder Kundenstandorten, weisen Sie dem Kunden Geplante Aufgaben zum Beenden.

Jede zugewiesene Aufgabe muss eine eindeutige Aufgaben-ID haben, aber Aufgaben können dieselbe ID haben Tracking-ID. Wenn Fleet Engine die voraussichtliche Ankunftszeit berechnet für jede Aufgabe verwendet, werden alle Aufgaben und die Reihenfolge Schätzungen geplant sind. Weitere Informationen zu Aufgaben-IDs finden Sie unter Richtlinien für Aufgaben-ID

Verwenden Sie den Task-Manager des Driver SDK, um Aufgaben in Fleet Engine zu erstellen.

Versandaufgaben

Erstellen von Versandaufgaben für Abholung und Zustellung einer Sendung und enthalten die folgenden Informationen:

• Der Ort der Abholung oder Lieferung.
• Eine Tracking-Nummer oder -ID.
• Eine Verweildauer, um zusätzliche Zeit für die Durchführung der Aufgabe zu berücksichtigen, oder zu Fuß zur Abholstelle gehen.
• Eine eindeutige Aufgaben-ID. Siehe Richtlinien für Aufgaben-ID.

Weitere Informationen finden Sie unter folgenden Links:

Android

• Abholaufgabe erstellen
• Versandaufgabe erstellen

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

Nicht verfügbare Aufgaben

Nichtverfügbarkeitsaufgaben decken Zeiträume ab, in denen ein Fahrzeug für Abholungen oder Lieferungen, z. B. Pausen zum Tanken des Fahrzeugs oder des Fahrers Pausen.

Erstellen Sie eine Nichtverfügbarkeitsaufgabe mit den folgenden Informationen:

• Die Länge der Pause.
• Optional den Ort der Unterbrechung. Sie müssen keine einen bestimmten Standort haben, aber dadurch erhalten Sie genauere Zeitfenster für die voraussichtlichen Ankunftszeiten. über den Tag verteilt.

Weitere Informationen finden Sie unter folgenden Links:

Android

• Geplante Nichtverfügbarkeit

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

Geplante Aufgaben zum Stoppen

Geplante Haltestellenaufgaben erstellen, um die für ein Lieferfahrzeug benötigten Haltestellen zu modellieren die Sie treffen müssen. Sie können beispielsweise eine geplante Stoppaufgabe für eine täglich geplante Stoppaufgabe erstellen. Abholstation an einem bestimmten Ort, unabhängig von anderen Lieferungen oder Abholungen am selben Ort. Sie können auch geplante Stoppaufgaben erstellen für Abholung von Briefkästen oder Umzug mit Feeder-Fahrzeugen oder Haltestellen in Servicezentren.

Weitere Informationen finden Sie unter folgenden Links:

Android

• Geplante Haltestellen

iOS

• GMTD DeliveryTaskManager
• GMTSTaskType

Richtlinien für Aufgaben-IDs

Beachten Sie beim Erstellen von Aufgaben-IDs die folgenden Inhalts- und Formatrichtlinien:

• Eindeutige Aufgaben-IDs erstellen
• Legen Sie keine personenidentifizierbaren Informationen preis Klartextdaten.
• Verwenden Sie gültige Unicode-Strings.
• Verwenden Sie höchstens 64 Zeichen.
• Folgende ASCII-Zeichen dürfen nicht enthalten sein: „/“, ":", „\“, „?“ oder „#“.
• Führen Sie eine Normalisierung gemäß der Unicode-Normalisierungsform C durch.

Im Folgenden finden Sie einige Beispiele für gute Aufgaben-IDs:

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

Die folgende Tabelle enthält Beispiele für nicht unterstützte Aufgaben-IDs:

Weitere Ressourcen

Um die in den einzelnen Daten enthaltenen Felder anzuzeigen finden Sie in der API-Referenzdokumentation für DeliveryVehicle. (gRPC, REST) und Task (gRPC, REST).

Lebensdauer eines Fahrzeugs

Das DeliveryVehicle-Objekt steht für ein Lieferfahrzeug auf der ersten oder letzten Meile. Sie erstellen ein DeliveryVehicle-Objekt mit:

• Die Projekt-ID des Google Cloud-Projekts, das das Dienstkonto enthält zum Aufrufen der Fleet Engine APIs.
• Eine Fahrzeug-ID des Kunden.

Verwenden Sie für jedes Fahrzeug eindeutige Fahrzeug-IDs. Fahrzeug-ID nicht wiederverwenden es sei denn, es gibt keine aktiven Aufgaben für das ursprüngliche Fahrzeug.

Fleet Engine löscht automatisch DeliveryVehicle-Objekte, die nach sieben Tagen mit UpdateDeliveryVehicle aktualisiert. Die empfohlenen Ein Fahrzeug in Fleet Engine verfügbar zu halten, besteht darin, seinen Standort in regelmäßigen Abständen. Aktualisierung der meisten anderen Felder in DeliveryVehicle Entität verlängert auch ihre Lebensdauer, vorausgesetzt, der neue Feldwert weicht ab. aus dem vorhandenen.

So prüfen Sie, ob ein Fahrzeug vorhanden ist:

1. Rufen Sie UpdateDeliveryVehicle an.
2. Wenn Sie einen NOT_FOUND-Fehler erhalten, rufen Sie CreateDeliveryVehicle auf. um das Fahrzeug nachzubauen. Wenn durch den Anruf ein Fahrzeug zurückgegeben wird, kann es noch aktualisiert werden.

Fahrzeugtypen

Die Entität VehicleType enthält ein optionales Feld von VehicleType mit einem Category-Enum, die als AUTO, TWO_WHEELER, BICYCLE oder PEDESTRIAN Wenn Sie das Feld nicht festlegen, wird es standardmäßig auf AUTO gesetzt.

Bei allen Routen für Fahrzeuge wird der entsprechende RouteTravelMode verwendet für den Fahrzeugtyp aus.

Fahrzeugattribute

Die Entität DeliveryVehicle enthält ein wiederkehrendes Feld von DeliveryVehicleAttribute. Die ListDeliveryVehicles API enthält ein filter Feld, das zurückgegebene DeliveryVehicle-Entitäten auf diejenigen mit dem angegebene Attribute. DeliveryVehicleAttribute wirkt sich nicht auf Fleet Engine aus .

Geben Sie keine personenidentifizierbaren Informationen oder vertraulichen Informationen an in Attributen enthalten, da dieses Feld für Nutzer sichtbar sein kann.

Lebensdauer einer Aufgabe

Sie können Aufgaben in Fleet Engine mit die gRPC- oder REST-Schnittstellen der Deliveries API.

Ein Task-Objekt hat ein Zustandsfeld, um seinen Fortschritt zu verfolgen über ihren Lebenszyklus. Die Werte wechseln von OFFEN zu GESCHLOSSEN. Neue Aufgaben werden erstellt im Status OFFEN, was bedeutet, dass entweder:

• Die Aufgabe wurde noch keinem Lieferfahrzeug zugewiesen.
• Das Lieferfahrzeug hat den der Aufgabe zugewiesenen Fahrzeugstopp noch nicht passiert.

Richtlinien für Aufgaben

Sie können einem Fahrzeug nur dann eine Aufgabe zuweisen, wenn es sich im Status OFFEN befindet.

Sie brechen eine Aufgabe ab, indem Sie sie aus der Liste der Haltestellen entfernen. Dadurch wird Aufgabenstatus automatisch auf CLOSED gesetzt.

Wenn das Fahrzeug der Aufgabe den Fahrzeugstopp der Aufgabe beendet:

1. Aktualisieren Sie das Ergebnisfeld der Aufgabe in SUCCEEDED oder FAILED.

2. Geben Sie den Zeitstempel des Ereignisses an.

   Die JavaScript-Bibliothek für die Versandverfolgung zeigt dann das Ergebnis der Aufgabe an und wird der Aufgabenstatus automatisch auf CLOSED gesetzt. Weitere Informationen finden Sie unter Verfolge deine Lieferung mit der JavaScript-Bibliothek für die Sendungsverfolgung.

Wie bei Fahrzeugen löscht Fleet Engine Aufgaben, die nach dem Wenn Sie versuchen, eine Aufgabe mit einer bereits vorhandenen ID zu erstellen, wird ein Fehler zurückgegeben.

Hinweis: Fleet Engine unterstützt das explizite Löschen von Aufgaben nicht. Dienst Aufgaben werden nach sieben Tagen automatisch ohne Updates gelöscht. Wenn Sie Aufgabendaten länger als sieben Tage aufbewahren möchten, müssen Sie diese Fähigkeit selbst implementieren.

Aufgabenattribute

Die Entität Task enthält ein wiederkehrendes Feld von TaskAttribute, die einen Wert aus einem der drei Typen haben kann: String, Zahl und boolescher Wert. Die ListTasks API enthält ein filter-Feld, das die zurückgegebenen Daten Task-Entitäten zu denen mit den angegebenen Attributen hinzufügen. Aufgabenattribute können nicht sich auf das Routingverhalten von Fleet Engine auswirken.

Geben Sie keine personenidentifizierbaren Informationen oder andere vertrauliche Informationen an. in Attributen enthalten, da diese für Nutzer sichtbar sein können.

Fahrzeug- und Aufgabenlebenszyklus verwalten

Erinnerung: Ihr internes System fungiert als vertrauenswürdige Quelle für die Daten, Die Fleet Engine Deliveries API unterstützt Sie in Ihrem Namen.

Verwenden Sie die Fleet Engine Deliveries API, um Fahrzeug- und Aufgabenlebenszyklen in Ihrem System zu verwalten zum Erstellen, Aktualisieren und Nachverfolgen von Fahrzeugen und den zugehörigen Aufgaben.

Gleichzeitig kommuniziert die Treiberanwendung direkt mit Fleet Engine um Gerätestandort- und Routeninformationen zu aktualisieren. Bei diesem Modell kann Fleet Engine Echtzeitstandort effizient verwalten. Der Standort wird direkt an die Tracking-Bibliothek, mit der Sie Kunden über den Status ihrer Reihenfolge.

Angenommen, Sie haben folgendes Szenario:

• Ein Fahrer nähert sich einer Lieferstation. Die Treiberanwendung sendet ihren Standort an Fleet Engine
• Fleet Engine sendet den Gerätestandort an die Tracking-Bibliothek, mit der Ihre Nutzeranwendung benachrichtigt wird Pakets in der Nähe.
• Nachdem der Fahrer den Versand abgeschlossen hat, klickt er auf „Lieferung zugestellt“. Schaltfläche in der Treiberanwendung.
• „Lieferung zugestellt“ die Informationen an Ihr Back-End-System, der die erforderlichen Validierungs- und Verifizierungsschritte ausführt.
• Ihr System bestätigt die Aufgabe als ERFOLGREICH und aktualisiert die Fleet Engine mit der Deliveries API.

Das folgende Diagramm veranschaulicht diese Prozesse im Allgemeinen. Außerdem die Standardbeziehung zwischen Ihrem System, dem Kunden, und Fleet Engine.

Client-Tokens verwalten

Standortaktualisierungen, die von der Treiberanwendung stammen und direkt gesendet werden für Fleet Engine sind Autorisierungstokens erforderlich. Hier ist die empfohlene Vorgehensweise, zur Verarbeitung von Updates vom Client an Fleet Engine:

1. Generieren Sie das Token mit dem nicht vertrauenswürdigen Treibernutzer für Fleet Engine Delivery. Dienstkontorolle.

2. Stellen Sie der Treiberanwendung ein Token von begrenztem Umfang bereit. Dieser Bereich nur den Gerätestandort in Fleet Engine aktualisieren.

Dieser Ansatz stellt sicher, dass Anrufe, die von Mobilgeräten stammen, vertrauenswürdigen Umgebungen – halten Sie sich an die Prinzip der geringsten Berechtigung.

Andere Dienstkontorollen

Wenn Sie stattdessen die Treiberanwendungen autorisieren möchten, Fleet Engine-Updates, die über die Rolle „Nicht vertrauenswürdiger Treiber“ hinausgehen, z. B. bei bestimmten Aufgabenupdates, können Sie die Rolle „Vertrauenswürdiger Fahrer“ verwenden. Für Informationen zu einem Modell, das die Rolle „Vertrauenswürdiger Fahrer“ verwendet, finden Sie unter Modell des vertrauenswürdigen Treibers:

Weitere Informationen zur Verwendung nicht vertrauenswürdiger und vertrauenswürdiger Fahrerrollen finden Sie unter Cloud-Projekt einrichten

Einen Arbeitstag vorbilden

In der folgenden Tabelle wird der Arbeitstag für Fahrer auf der ersten oder letzten Meile beschrieben. wie ein Liefer- und Logistikunternehmen. Ihr Unternehmen kann sich in den Details unterscheiden, aber Sie können Ihren Arbeitstag gut modellieren.

So funktionieren Standortupdates

Die beste Leistung erzielen Sie, wenn Sie Fleet Engine mit einem Fahrzeugstrom versorgen. Standortaktualisierungen. Verwenden Sie eine der folgenden Möglichkeiten, um diese Aktualisierungen bereitzustellen:

1. Treiber-SDK verwenden: Android-Geräte iOS -- die einfachste Option.
2. Verwenden Sie benutzerdefinierten Code. Dies ist nützlich, wenn Standorte oder wenn Sie andere Geräte als Android oder iOS

Unabhängig davon, wie Sie Aktualisierungen des Fahrzeugstandorts bereitstellen, Fleet Engine aktualisieren, wenn ein Lieferfahrzeug auf dem Weg zu einer Haltestelle (einschließlich des Depots) sind und wann diese an einer Haltestelle ankommt. Fleet Engine erkennt diese Ereignisse nicht automatisch.

Haltestellen und Lieferorte

Ein Fahrzeugstopp ist der Ort, an dem ein Lieferfahrzeug eine Versandaufgabe abschließt oder eine andere Aufgabe haben. Es handelt sich entweder um einen Zugangspunkt wie eine Ladestation oder auf der Straße befinden.

Der Lieferort ist der Ort, an den die Sendung geliefert wird. oder abgeholt werden. Der Weg zum und vom Lieferort kann einen Fußweg erfordern von der Haltestelle entfernt wird.

Wenn z. B. ein Fahrer eine Sendung an ein Geschäft in einem Einkaufszentrum liefert, hält der Lieferwagen auf dem Parkplatz des Einkaufszentrums in der Nähe dem nächstgelegenen Eingang zum Geschäft. Das ist der Stopp. Der Fahrer und geht dann von der Haltestelle bis zu der Stelle im Einkaufszentrum, sich das Geschäft befindet. Dies ist der Lieferort.

Um Ihren Nutzern die bestmögliche Sendungsverfolgung zu bieten, überlegen Sie, wie Versandaufgaben werden Fahrzeugstopps zugewiesen. Beachten Sie, dass die Anzahl der verbleibende Fahrzeugstopps für Versandaufgaben werden dem Nutzer gemeldet, um ihm zu helfen den Versandstatus verfolgen.

Wenn z. B. ein Fahrer viele Lieferungen an ein einzelnes Bürogebäude durchführt, sollten Sie alle Lieferaufgaben einer einzelnen Haltestelle zuweisen. Wenn jeder Lieferaufgabe eine eigene Fahrzeughaltestelle zugewiesen ist, wird Ihre Sendung wäre die Tracking-Erfahrung für Ihre Nutzenden weniger hilfreich, da die Verfolgung verfügbar, sobald das Fahrzeug eine begrenzte Anzahl von Stopps vor sein Ziel. Viele Stopps in kurzer Zeit helfen Ihnen nicht, Nutzenden viel Zeit, um den Fortschritt ihrer Lieferung zu verfolgen.

Mobile SDKs verwenden

Bevor Sie Aufrufe an das Treiber-SDK senden, muss es initialisiert werden.

Delivery Driver API initialisieren

Stellen Sie vor der Initialisierung der Delivery Driver API im Driver SDK sicher, dass um das Navigation SDK zu initialisieren. Initialisieren Sie dann die Delivery Driver API, wie im folgenden Beispiel gezeigt:

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));
     }
   });

Anwendungsfälle

In diesem Abschnitt wird beschrieben, wie Sie mit der Deliveries API häufige Anwendungsfälle modellieren können.

Eindeutige Entitätskennungen

Das Format und der Wert der in REST-Aufrufen verwendeten eindeutigen Entitätskennungen sind für Fleet Engine undurchsichtig. Vermeiden Sie die Verwendung von IDs mit automatischer Inkrementierung und achten Sie darauf, die Kennung keine personenidentifizierbaren Informationen enthält, etwa die Telefonnummer des Fahrers.

Fahrzeug erstellen

Sie können ein Fahrzeug entweder über die Driver SDK oder aus einer Serverumgebung mit gRPC oder REST.

gRPC

Zum Erstellen eines neuen Fahrzeugs senden Sie einen CreateDeliveryVehicle-Aufruf an Fleet Engine. Verwenden Sie das CreateDeliveryVehicleRequest-Objekt, um die Attribute der das neue Lieferfahrzeug. Jeder für das Feld Name angegebene Wert ist wird gemäß der API-Anleitung für benutzerdefinierte IDs ignoriert. Verwenden Sie das Feld DeliveryVehicleId, um die ID des Fahrzeugs festzulegen.

Beim Erstellen eines DeliveryVehicle können Sie die folgenden Felder optional angeben:

• Attribute
• LastLocation
• Typ

Legen Sie keine anderen Felder fest. In diesem Fall gibt Fleet Engine einen Fehler zurück da diese Felder entweder schreibgeschützt sind oder nur durch einen Aufruf von UpdateDeliveryVehicle

Wenn Sie ein Fahrzeug erstellen möchten, ohne optionale Felder festzulegen, können Sie das Feld Das Feld DeliveryVehicle wurde in CreateDeliveryVehicleRequest aufgehoben.

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek um ein Fahrzeug zu erstellen:

    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

Führen Sie einen HTTP-REST-Aufruf aus, um ein Fahrzeug aus einer Serverumgebung zu erstellen an CreateDeliveryVehicle:

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

<id> ist eine eindeutige Kennzeichnung für ein Lieferfahrzeug in Ihrer Flotte.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der POST-Textkörper stellt die zu erstellende DeliveryVehicle-Entität dar. Sie können angeben, die folgenden optionalen Felder:

• Attribute
• lastLocation
• Typ

Beispiel eines curl-Befehls:

# 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 ignoriert das Feld name der Entität DeliveryVehicle gemäß der API-Anleitung für benutzerdefinierte IDs. Legen Sie keine anderen Felder fest. In diesem Fall gibt Fleet Engine einen Fehler zurück da diese Felder entweder schreibgeschützt sind oder nur mithilfe eines Aufrufs von UpdateDeliveryVehicle

Wenn Sie ein Fahrzeug erstellen möchten, ohne Felder festzulegen, lassen Sie den Text der POST-Anfrage unverändert Anfrage leer. Das neu erstellte Fahrzeug extrahiert dann eine Fahrzeug-ID aus dem Parameter deliveryVehicleId in der POST-URL.

Beispiel eines curl-Befehls:

# 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}"

Aufgabe zum Abholen einer Sendung erstellen

Sie können eine Aufgabe zur Abholung der Sendung entweder über die Treiber-SDK oder aus einer Serverumgebung mit gRPC oder REST.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek So erstellen Sie eine Abholung der Sendung:

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

Führen Sie einen HTTP-REST-Aufruf aus, um eine Aufgabe zur Abholung einer Sendung in einer Serverumgebung zu erstellen an CreateTask:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für die Aufgabe. Es darf sich nicht um die Sendungsnummer handeln. für die Lieferung. Wenn Sie in Ihrem System keine Aufgaben-IDs haben, können Sie Eine UUID (Universally Unique Identifier).

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine Task-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  Typ	Type.PICKUP
  Bundesstaat	State.OPEN
  trackingId	Die Nummer oder Kennung, die Sie zur Verfolgung einer Sendung verwenden.
  plannedLocation	Der Ort, an dem die Aufgabe abgeschlossen werden soll, in diesem Fall Abholort der Sendung.
  taskDuration	Die erwartete Zeit in Sekunden für die Abholung der Sendung am Abholort befinden.

• Optionale Felder:

  Feld	Wert
  targetTimeWindow	Das Zeitfenster, in dem die Aufgabe abgeschlossen werden sollte. Das bedeutet nicht, das Routingverhalten beeinflussen.
  Attribute	Eine Liste benutzerdefinierter Aufgabenattribute. Jedes Attribut muss einen eindeutigen Schlüssel haben.

Alle anderen Felder in der Entität werden bei der Erstellung ignoriert. Fleet Engine wirft Ausnahme, wenn die Anfrage eine zugewiesene deliveryVehicleId enthält. Sie weisen Aufgaben mit UpdateDeliveryVehicleRequest. Weitere Informationen finden Sie unter Weisen Sie einem Fahrzeug Aufgaben zu und UpdateDeliveryVehicleRequest.

Beispiel eines curl-Befehls:

# 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

Aufgabe für die Sendungszustellung erstellen

Erstellen Sie eine Aufgabe für den Versand über die Treiber-SDK oder aus einer Serverumgebung mit gRPC oder REST.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek So erstellen Sie eine Aufgabe für die Sendungszustellung:

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

Führen Sie einen HTTP-REST-Aufruf aus, um eine Aufgabe für die Sendungszustellung aus einer Serverumgebung mit gRPC oder REST zu erstellen. an CreateTask:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für die Aufgabe. Es darf sich nicht um die Sendungsnummer handeln. für die Lieferung. Wenn Sie in Ihrem System keine Aufgaben-IDs haben, können Sie Eine UUID (Universally Unique Identifier).

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine Task-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  Typ	Type.DELIVERY
  Bundesstaat	State.OPEN
  trackingId	Die Nummer oder Kennung, die Sie zur Verfolgung einer Sendung verwenden.
  plannedLocation	Der Ort, an dem die Aufgabe abgeschlossen werden soll, in diesem Fall Lieferort für diese Sendung.
  taskDuration	Die erwartete Zeit in Sekunden, die die Abgabe der Sendung benötigt. am Lieferort.

• Optionale Felder:

  Feld	Wert
  targetTimeWindow	Das Zeitfenster, in dem die Aufgabe abgeschlossen werden sollte. Das bedeutet nicht, das Routingverhalten beeinflussen.
  Attribute	Eine Liste benutzerdefinierter Aufgabenattribute. Jedes Attribut muss einen eindeutigen Schlüssel haben.

Alle anderen Felder in der Entität werden bei der Erstellung ignoriert. Fleet Engine wirft Ausnahme, wenn die Anfrage eine zugewiesene deliveryVehicleId enthält. Sie weisen Aufgaben mit UpdateDeliveryVehicleRequest. Weitere Informationen finden Sie unter Weisen Sie einem Fahrzeug Aufgaben zu und UpdateDeliveryVehicleRequest.

Beispiel eines curl-Befehls:

# 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

Aufgaben im Batch erstellen

Mit gRPC oder REST können Sie einen Batch von Aufgaben aus einer Serverumgebung erstellen.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek um zwei Aufgaben zu erstellen: eine für eine Lieferung und eine für die Abholung. Standort:

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

Um eine Liefer- und Abholaufgabe aus einer Serverumgebung zu erstellen, erstellen Sie eine HTTP-REST-Aufruf an BatchCreateTasks:

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

Der Anfrage-Header muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token, das von einer Fleet Engine-Token-Factory ausgegeben wird.

Der Anfragetext muss eine BatchCreateTasksRequest-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  Anfragen	Array <CreateTasksRequest>

• Optionale Felder:

  Feld	Wert
  Header	`DeliveryRequestHeader`

Jedes CreateTasksRequest-Element in requests muss dieselbe Validierung bestehen als CreateTask-Anfrage, mit der Ausnahme, dass die parent und header sind optional. Wenn festgelegt, müssen sie identisch sein mit die entsprechenden Felder auf der obersten Ebene BatchCreateTasksRequest. Weitere Informationen finden Sie unter eine Aufgabe zur Abholung der Lieferung erstellen und Versandaufgabe erstellen jeweils spezifische Validierungsregeln.

Weitere Informationen finden Sie in der API-Referenzdokumentation für BatchCreateTasks. (gRPC, REST)

Beispiel eines curl-Befehls:

# 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

Geplante Nichtverfügbarkeit

Sie können eine Aufgabe erstellen, die auf Nichtverfügbarkeit hinweist (z. B. für Fahrerinnen und Fahrer) Pannen oder das Tanken des Fahrzeugs), entweder vom Treiber-SDK oder aus einer Serverumgebung mit gRPC oder REST. Eine geplante Nichtverfügbarkeitsaufgabe darf Folgendes nicht enthalten: eine Tracking-ID. Optional können Sie einen Standort angeben.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek So erstellen Sie eine Nichtverfügbarkeitsaufgabe:

    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

Führen Sie einen HTTP-REST-Aufruf aus, um eine Nichtverfügbarkeitsaufgabe in einer Serverumgebung zu erstellen an CreateTask:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für die Aufgabe. Wenn Sie keine Aufgaben-IDs in Ihrem System haben, können Sie eine universell eindeutige Kennung (UUID).

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine Task-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  Typ	Type.UNAVAILABLE
  Bundesstaat	State.OPEN
  taskDuration	Die Länge der Pause in Sekunden.

• Optionale Felder:

  Feld	Wert
  plannedLocation	Der Ort der Unterbrechung, wenn sie an einem bestimmten Ort stattfinden muss.

Alle anderen Felder in der Entität werden bei der Erstellung ignoriert. Fleet Engine wirft Ausnahme, wenn die Anfrage eine zugewiesene deliveryVehicleId enthält. Sie weisen Aufgaben mit UpdateDeliveryVehicleRequest. Weitere Informationen finden Sie unter Weisen Sie einem Fahrzeug Aufgaben zu und UpdateDeliveryVehicleRequest.

Beispiel eines curl-Befehls:

    # 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

Geplante Haltestellen

Sie können eine geplante Stoppaufgabe entweder über die Treiber-SDK oder aus einer Serverumgebung mit gRPC oder REST. Eine geplante Stoppaufgabe darf keine Verfolgung beinhalten. ID.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek um eine geplante Haltestelle zu erstellen:

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

Führen Sie einen HTTP-REST-Aufruf aus, um eine geplante Stoppaufgabe in einer Serverumgebung zu erstellen an CreateTask:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für die Aufgabe. Wenn Sie keine in Ihrem System haben, können Sie Eine UUID (Universally Unique Identifier).

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine Task-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  Typ	Type.SCHEDULED_STOP
  Bundesstaat	State.OPEN
  plannedLocation	Die Position der Haltestelle.
  taskDuration	Die erwartete Länge der Haltestelle in Sekunden.

• Optionale Felder:

  • Keine

Alle anderen Felder in der Entität werden bei der Erstellung ignoriert. Fleet Engine wirft Ausnahme, wenn die Anfrage eine zugewiesene deliveryVehicleId enthält. Sie weisen Aufgaben mit UpdateDeliveryVehicleRequest. Weitere Informationen finden Sie unter Weisen Sie einem Fahrzeug Aufgaben zu und UpdateDeliveryVehicleRequest.

Beispiel eines curl-Befehls:

    # 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

Zielzeitfenster festlegen

Das Zielzeitfenster ist die TimeWindow in dem die Aufgabe abgeschlossen werden sollte. Wenn Sie zum Beispiel Lieferzeitfenster zu den Lieferempfängern erhalten, können Sie die Zielzeit der Aufgabe Zeitfenster zum Erfassen dieses Zeitfensters und Generieren von Benachrichtigungen oder Analysieren nach der Fahrt die Leistung mithilfe des Felds.

Das Zielzeitfenster besteht aus einer Start- und einer Endzeit und kann festgelegt werden für jeden Aufgabentyp. Das Zielzeitfenster wirkt sich nicht auf das Routing aus verhalten.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek um ein Zeitfenster für die Aufgabe festzulegen:

    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

Rufen Sie UpdateTask auf, um ein Zeitfenster für Aufgaben mithilfe von HTTP festzulegen:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für die Aufgabe.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine Task-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  targetTimeWindow	Das Zeitfenster, in dem die Aufgabe abgeschlossen werden sollte. Diese Einstellung wirkt sich nicht auf das Routingverhalten aus.

• Optionale Felder:

  • Keine

Alle anderen Felder in der Entität werden bei der Aktualisierung ignoriert.

Beispiel eines curl-Befehls:

# 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

Konfiguration für die Sichtbarkeit von Aufgaben festlegen

Die Sichtbarkeit der Daten in der Versandverfolgungsbibliothek und dieser Daten die von einem Aufruf an GetTaskTrackingInfo zurückgegeben werden, können pro Task gesteuert werden. indem Sie eine TaskTrackingViewConfig für die Aufgabe. Weitere Informationen finden Sie unter Aktive Fahrzeugaufgaben . Dies kann beim Erstellen oder Aktualisieren der . Das folgende Beispiel zeigt, wie die Aufgabe mit dieser Konfiguration aktualisiert wird:

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek um die Konfiguration der Aufgaben-Tracking-Ansicht festzulegen:

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

Rufen Sie UpdateTask auf, um das Konfigurationsfenster der Aufgaben-Tracking-Ansicht über HTTP festzulegen:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für die Aufgabe.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine Task-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  taskTrackingViewConfig	Die Konfiguration für die Aufgabenverfolgung, die angibt, welche Datenelemente unter welchen Umständen für Endnutzer sichtbar sind.

• Optionale Felder:

  • Keine

Alle anderen Felder in der Entität werden bei der Aktualisierung ignoriert.

Beispiel eines curl-Befehls:

# 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

Einem Fahrzeug Aufgaben zuweisen

Sie weisen einem Lieferfahrzeug Aufgaben zu, indem Sie die Aufgabenreihenfolge aktualisieren für das Fahrzeug. Die Aufgabenreihenfolge für ein Fahrzeug wird durch die Liste bestimmt für das Lieferfahrzeug an und Sie können eine oder mehrere Aufgaben an jeder Haltestelle zu erreichen. Weitere Informationen finden Sie unter Aktualisieren Sie die Aufgabenreihenfolge.

Wenn Sie eine Sendung von einem Fahrzeug auf ein anderes umstellen möchten, schließen Sie die ursprüngliche Aufgabe. und erstellen es dann neu, bevor Sie es dem neuen Fahrzeug zuweisen. Wenn Sie die Aufgabe aktualisieren einer Aufgabe, die bereits zugewiesen ist, zu einem anderen Fahrzeug senden, erhalten Sie eine Fehlermeldung.

Aufgabenreihenfolge aktualisieren

Sie können die Auftragsaufgaben aktualisieren, die einem Fahrzeug zugewiesen sind: die Treiber-SDK oder der Serverumgebung. Verwenden Sie nicht beide Methoden, um Race-Bedingungen und eine Single Source of Truth aufrechtzuerhalten.

Wenn Sie die Aufgabenreihenfolge für ein Fahrzeug aktualisieren, geschieht Folgendes:

• Dem Fahrzeug werden neue Aufgaben zugewiesen.
• Schließt alle Aufgaben, die dem Fahrzeug bereits zugewiesen waren, aber noch nicht in der aktualisierten Reihenfolge.

Um eine Sendung von einem Fahrzeug auf ein anderes umzustellen, ursprüngliche Aufgabe schließen und erstellen es dann neu, bevor Sie es dem neuen Fahrzeug zuweisen. Wenn Sie die Aufgabe aktualisieren einer Aufgabe, die bereits zugewiesen ist, zu einem anderen Fahrzeug senden, erhalten Sie eine Fehlermeldung.

Sie können die Aufgabenreihenfolge jederzeit aktualisieren.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek um die Aufgabenreihenfolge für das Fahrzeug zu aktualisieren:

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

Führen Sie einen HTTP-REST-Aufruf aus, um die Aufgabenreihenfolge für ein Fahrzeug aus einer Serverumgebung zu aktualisieren an UpdateDeliveryVehicle:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für ein Lieferfahrzeug in Ihrer Flotte für die Sie die Aufgabenreihenfolge aktualisieren möchten. Dies ist die Kennung, die Sie beim Erstellen des Fahrzeugs angegeben haben.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine DeliveryVehicle-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  remainingVehicleJourneySegments	Eine Liste von Journeysegmenten für Aufgaben in der Reihenfolge, in der sie ausgeführt werden sollen. Die erste Aufgabe in der Liste wird zuerst ausgeführt.
  remainingVehicleJourneySegments[i].stop	Haltestelle für Aufgabe i in der Liste.
  remainingVehicleJourneySegments[i].stop.plannedLocation	Die geplante Position der Haltestelle.
  remainingVehicleJourneySegments[i].stop.tasks	Eine Liste der Aufgaben, die an dieser Haltestelle auszuführen sind.
  remainingVehicleJourneySegments[i].stop.state	State.NEW

• Optionale Felder:

  • Keine

Alle anderen Felder in der Entität werden bei der Aktualisierung ignoriert.

Beispiel eines curl-Befehls:

# 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

Fahrzeug ist auf dem Weg zur nächsten Haltestelle

Fleet Engine muss benachrichtigt werden, wenn ein Fahrzeug an einer Haltestelle abfährt oder anfängt Navigation. Sie können Fleet Engine über die Treiber-SDK oder aus einer Serverumgebung mit gRPC oder REST. Nicht beide Methoden verwenden, um Race-Fehler zu vermeiden und eine Single Source of Truth aufrechtzuerhalten.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek um Fleet Engine zu informieren, dass ein Fahrzeug auf dem Weg zur nächsten Haltestelle ist.

    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

Um Fleet Engine zu benachrichtigen, dass ein Fahrzeug auf dem Weg zur nächsten Haltestelle von einer Serverumgebung erhalten, führen Sie einen HTTP-REST-Aufruf an UpdateDeliveryVehicle aus:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für das Lieferfahrzeug in Ihrer Flotte für die Sie die Aufgabenreihenfolge aktualisieren möchten. Dies ist die Kennung, die Sie beim Erstellen des Fahrzeugs angegeben haben.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine DeliveryVehicle-Entität enthalten:

• Pflichtfeld:

  Feld	Wert
  remainingVehicleJourneySegments	Liste der verbleibenden Fahrzeughalte, wobei deren Status als State.NEW gekennzeichnet ist. Für die erste Haltestelle auf der Liste muss der Status State.ENROUTE angegeben sein.

• Optionale Felder:

  • Keine

Alle anderen Felder in der Entität werden bei der Benachrichtigung ignoriert.

Beispiel eines curl-Befehls:

# 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

Fahrzeugstandort aktualisieren

Wenn Sie das Driver SDK nicht verwenden, um den Standort des Fahrzeugs zu aktualisieren, können Sie einen direkten Aufruf der Fleet Engine mit dem Standort des Fahrzeugs. Für alle aktiven Fahrzeuge Fleet Engine erwartet ein Standortupdate mindestens einmal pro Minute und höchstens einmal alle 5 Sekunden.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek So aktualisieren Sie den Standort eines Fahrzeugs in Fleet Engine:

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 myDeliveryVehicle = DeliveryVehicle.newBuilder()
    .setLastLocation(DeliveryVehicleLocation.newBuilder()
        .setSupplementalLocation(LatLng.newBuilder()
            .setLatitude(37.3382)
            .setLongitude(121.8863))
        .setSupplementalLocationTime(now())
        .setSupplementalLocationSensor(DeliveryVehicleLocationSensor.CUSTOMER_SUPPLIED_LOCATION)
        .setSupplementalLocationAccuracy(DoubleValue.of(15.0)))  // Optional
    .build();

// DeliveryVehicle request
UpdateDeliveryVehicleRequest updateDeliveryVehicleRequest =
  UpdateDeliveryVehicleRequest.newBuilder()  // No need for the header
      .setName(vehicleName)
      .setDeliveryVehicle(myDeliveryVehicle)
      .setUpdateMask(FieldMask.newBuilder()
          .addPaths("last_location"))
      .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

Um den Standort eines Fahrzeugs in Fleet Engine mit HTTP REST zu aktualisieren, führen Sie einen Aufruf von UpdateDeliveryVehicle:

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

&lt;id&gt; ist eine eindeutige Kennung für das Lieferfahrzeug in Ihrem oder die Sie den Standort aktualisieren möchten. Dies ist die Kennung, die Sie beim Erstellen des Fahrzeugs angegeben haben.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine DeliveryVehicle-Entität enthalten:

• Pflichtfeld:

  Feld	Wert
  lastLocation.supplementalLocation	Der Standort des Fahrzeugs.
  lastLocation.supplementalLocationTime	Der letzte bekannte Zeitstempel, mit dem sich das Fahrzeug an diesem Standort befand.
  lastLocation.supplementalLocationSensor	Sollte mit CUSTOMER_SUPPLIED_LOCATION ausgefüllt werden.

• Optionale Felder:

  Feld	Wert
  lastLocation.supplementalLocationAccuracy	Genauigkeit des angegebenen Standorts in Metern.

Beispiel eines curl-Befehls:

# 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
{
  "lastLocation": {
    "supplementalLocation": {"latitude": 12.1, "longitude": 14.5},
    "supplementalLocationTime": "$(date -u --iso-8601=seconds)",
    "supplementalLocationSensor": "CUSTOMER_SUPPLIED_LOCATION",
    "supplementalLocationAccuracy": 15
  }
}
EOM

Fahrzeug landet an einer Haltestelle

Fleet Engine muss benachrichtigt werden, wenn ein Fahrzeug an einer Haltestelle ankommt. Sie können Benachrichtigungen Fleet Engine entweder vom Treiber-SDK oder aus einer Serverumgebung mit gRPC oder REST. Nicht beide Methoden verwenden, um Race-Fehler zu vermeiden und eine Single Source of Truth aufrechtzuerhalten.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek , um Fleet Engine zu benachrichtigen, dass ein Fahrzeug an einer Haltestelle angekommen ist:

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

Um Fleet Engine über die Ankunft eines Fahrzeugs an einer Haltestelle von einer Serverumgebung zu benachrichtigen, Führen Sie einen HTTP-REST-Aufruf an UpdateDeliveryVehicle aus:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für das Lieferfahrzeug in Ihrer Flotte für die Sie die Aufgabenreihenfolge aktualisieren möchten. Dies ist die Kennung, die Sie beim Erstellen des Fahrzeugs angegeben haben.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine DeliveryVehicle-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  remainingVehicleJourneySegments	Die Haltestelle, an der Sie angekommen sind und deren Status auf „State.ARRIVED“ festgelegt ist, gefolgt von einer Liste der verbleibenden Fahrzeughalte, deren Status als State.NEW gekennzeichnet ist.

• Optionale Felder:

  • Keine

Alle anderen Felder in der Entität werden bei der Aktualisierung ignoriert.

Beispiel eines curl-Befehls:

# 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

Fahrzeug hält an

Fleet Engine muss benachrichtigt werden, wenn ein Fahrzeug einen Stopp erreicht. Das führt dazu, dass werden alle mit der Haltestelle verknüpften Aufgaben in den Status CLOSED gesetzt. Sie können Benachrichtigungen an Fleet Engine Treiber-SDK oder aus einer Serverumgebung mit gRPC oder REST. Verwenden Sie nicht beide Methoden, um Race-Bedingungen zu vermeiden und eine Single Source of Truth aufrechtzuerhalten.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek um Fleet Engine zu benachrichtigen, dass ein Fahrzeug angehalten hat.

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

Um Fleet Engine über den Abschluss eines Stopps von einer Serverumgebung zu informieren, Führen Sie einen HTTP-REST-Aufruf an UpdateDeliveryVehicle aus:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für das Lieferfahrzeug in Ihrer Flotte für die Sie die Aufgabenreihenfolge aktualisieren möchten. Dies ist die Kennung, die Sie beim Erstellen des Fahrzeugs angegeben haben.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine DeliveryVehicle-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  remaining_vehicle_journey_segments	Der von Ihnen beendete Zwischenstopp sollte nicht mehr in der Liste der verbleibenden Stopps.

• Optionale Felder:

  • Keine

Alle anderen Felder in der Entität werden bei der Aktualisierung ignoriert.

Beispiel eines curl-Befehls:

    # 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}"
              }
            ]
          }
        }
      ]
    }
    EOM

Aufgaben aktualisieren

Die meisten Aufgabenfelder sind unveränderlich. Sie können jedoch Status, Aufgabenergebnis, Aufgabenergebniszeit, Ort des Aufgabenergebnisses und Attribute, die Aufgabenentität direkt aktualisieren. Wenn eine Aufgabe beispielsweise zugewiesen wurde, schließen Sie die Aufgabe, indem Sie direkt an den Bundesstaat senden.

gRPC

Dies ist ein Beispiel für die Aktualisierung einer Aufgabe über gRPC.

REST

Dies ist ein Beispiel für die Aktualisierung einer Aufgabe über REST.

Aufgabe schließen

Zum Schließen einer Aufgabe, die einem Fahrzeug zugewiesen wurde, benachrichtigen Sie entweder Fleet Engine ob das Fahrzeug die Haltestelle beendet hat, an der die Aufgabe stattfindet oder aus der Liste der Haltestellen entfernen. Dazu können Sie die Liste das verbleibende Fahrzeug genau wie bei der Aktualisierung der Aufgabenreihenfolge anhält. für ein Fahrzeug.

Wenn eine Aufgabe noch keinem Fahrzeug zugewiesen wurde und geschlossen werden muss, aktualisieren Sie die Aufgabe in den Status CLOSED geändert. Sie können eine GESCHLOSSENE Aufgabe jedoch nicht wieder öffnen.

Das Schließen einer Aufgabe weist nicht auf Erfolg oder Misserfolg hin. Es gibt an, dass der die Aufgabe nicht mehr als in Bearbeitung gilt. Für die Sendungsverfolgung: ist es wichtig, das tatsächliche Ergebnis einer Aufgabe anzugeben, damit die Lieferung wie ein Resultat angezeigt werden kann.

gRPC

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) // You can only directly CLOSE a
  .build();                    // task that 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;
}

REST

Um eine Aufgabe von einer Serverumgebung aus als geschlossen zu markieren, führen Sie einen HTTP-REST-Aufruf an UpdateTask:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für die Aufgabe.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Sie müssen eine Task-Entität in den Anfragetext einfügen:

• Pflichtfelder:

  Feld	Wert
  Bundesstaat	State.CLOSED

• Optionale Felder:

  Feld	Wert
  taskOutcome	Result.SUCCEEDED oder Result.FAILED
  taskOutcomeTime	Die Uhrzeit, zu der die Aufgabe abgeschlossen wurde.
  taskOutcomeLocation	Der Ort, an dem die Aufgabe abgeschlossen wurde. Fleet Engine verwendet dies als Standardeinstellung. bis zum letzten Fahrzeugstandort, sofern dies nicht manuell vom Anbieter überschrieben wird.

Alle anderen Felder in der Entität werden bei der Aktualisierung ignoriert.

Beispiel eines curl-Befehls:

    # 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

Aufgabenergebnis und Ergebnisort festlegen

Das Schließen einer Aufgabe weist nicht auf Erfolg oder Misserfolg hin, sondern weist darauf hin, die Aufgabe nicht mehr als in Bearbeitung angesehen wird. Für die Sendungsverfolgung: ist es wichtig, das tatsächliche Ergebnis einer Aufgabe anzugeben, damit ein Lieferergebnis angezeigt werden kann und die Dienstleistungen ordnungsgemäß abgerechnet werden. Nachdem Sie das Aufgabenergebnis festgelegt haben, können Sie es nicht mehr ändern. Sie können jedoch das Feld und der Ort der Aufgabenergebnisse, nachdem sie festgelegt wurden.

Für Aufgaben, die sich im Status CLOSED befinden, kann das Ergebnis entweder auf ERFOLGREICH oder FEHLGESCHLAGEN. Fleet Engine berechnet nur Lieferaufgaben mit dem Status ERFOLGREICH.

Beim Markieren des Ergebnisses einer Aufgabe füllt Fleet Engine automatisch Standort des Aufgabenergebnisses mit dem letzten bekannten Fahrzeugstandort. Sie können überschreiben können.

gRPC

Sie haben die Möglichkeit, die Position des Aufgabenergebnisses festzulegen, wenn Sie die zu erzielen. Wenn Sie den Standort festlegen, kann er von Fleet Engine nicht festgelegt werden auf die Standardeinstellung der letzten Standort des Fahrzeugs. Sie können auch den Fleet Engine-Speicherort des Aufgabenergebnisses überschreiben zu einem späteren Zeitpunkt festgelegt werden. Fleet Engine überschreibt niemals einen Speicherort mit Aufgabenergebnissen. die Sie zur Verfügung stellen. Sie können keinen Ort für das Aufgabenergebnis für eine Aufgabe festlegen für die kein Aufgabenergebnis festgelegt ist. Sie können beide Aufgabenergebnisse und die Position des Aufgabenergebnisses in derselben Anfrage.

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek um ein Aufgabenergebnis auf ERFOLGREICH zu setzen und den Ort anzugeben, an dem die Aufgabe ausgeführt wurde. Abgeschlossen:

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;
}

REST

Um eine Aufgabe von einer Serverumgebung aus als erledigt zu markieren, Führen Sie einen HTTP-REST-Aufruf an UpdateTask aus:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für die Aufgabe.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss eine Task-Entität enthalten:

• Pflichtfelder:

  Feld	Wert
  taskOutcome	Result.SUCCEEDED oder Result.FAILED

• Optionale Felder:

  Feld	Wert
  taskOutcomeLocation	Der Ort, an dem die Aufgabe abgeschlossen wurde. Wenn nicht festgelegt, Fleet Engine ist standardmäßig der letzte Fahrzeugstandort.
  taskOutcomeTime	Der Zeitstempel, der angibt, wann die Aufgabe abgeschlossen wurde.

Alle anderen Felder in der Entität werden bei der Aktualisierung ignoriert.

Beispiel eines curl-Befehls:

# 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

Sendung umleiten

Sobald eine Versandaufgabe erstellt wurde, kann der geplante Ort nicht mehr geändert werden. Wenn Sie eine Sendung umleiten möchten, schließen Sie die Versandaufgabe, ohne die Einstellung ein Ergebnis und erstellen dann eine neue Aufgabe mit dem aktualisierten geplanten Standort. Nachdem Sie die neue Aufgabe erstellt haben, weisen Sie sie demselben Fahrzeug zu. Weitere Informationen Weitere Informationen finden Sie unter Versandaufgabe schließen und Weisen Sie die Aufgabe zu.

Zubringer- und Lieferfahrzeuge verwenden

Wenn Sie Feeder für den Transport von Lieferungen an Lieferfahrzeuge verwenden die Lieferung von Lieferungen als geplante Stoppaufgabe modellieren. für das Lieferfahrzeug. Um eine genaue Standortverfolgung zu gewährleisten, weisen Sie eine Aufgabe für den Versand einer übertragenen Sendung, nachdem sie auf den Lieferfahrzeugs. Weitere Informationen finden Sie unter Geplante Haltestelle.

Versandstatus des Geschäfts und andere Metainformationen

Wenn eine Versandaufgabe abgeschlossen ist, werden der Aufgabenstatus und das Ergebnis aufgezeichnet in der Aufgabe an. Vielleicht möchten Sie jedoch andere Meta-Informationen die für die Lieferung spezifisch sind. Um weitere Meta-Informationen zu speichern, außerhalb des Fleet Engine-Dienstes die Tracking-ID zu verwenden, mit der Aufgabe als Schlüssel in einer externen Tabelle.

Weitere Informationen finden Sie unter Lebensdauer einer Aufgabe.

Fahrzeug suchen

Sie können ein Fahrzeug entweder Treiber-SDK oder aus einer Serverumgebung mit gRPC oder REST.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek nach einem Fahrzeug suchen:

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

Um ein Fahrzeug in einer Serverumgebung zu suchen, Führen Sie einen HTTP-REST-Aufruf an GetVehicle aus:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für die Aufgabe.

&lt;vehicleId&gt; ist die ID des Fahrzeugs, nach dem gesucht werden soll.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss leer sein.

Wenn die Suche erfolgreich ist, enthält der Antworttext eine Fahrzeugentität.

Beispiel eines curl-Befehls:

# 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}"

Nach einer Aufgabe suchen

Sie können eine Aufgabe aus einer Serverumgebung mit gRPC oder REST abrufen. Das Treiber-SDK enthält keine bei der Suche nach einer Aufgabe helfen.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek nach einer Aufgabe suchen:

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

Um eine Aufgabe in einer Serverumgebung nachzuschlagen, Führen Sie einen HTTP-REST-Aufruf an GetTask aus:

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

&lt;id&gt; ist eine eindeutige Kennzeichnung für die Aufgabe.

&lt;taskId&gt; ist die ID der nachzuschlagenden Aufgabe.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Der Anfragetext muss leer sein.

Wenn die Suche erfolgreich ist, enthält der Antworttext eine Aufgabenentität.

Beispiel eines curl-Befehls:

    # 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}"

Informationen zu Versandaufgaben anhand der Tracking-ID abrufen

Sie haben folgende Möglichkeiten, Informationen zu Versandaufgaben abzurufen: die jeweils einem anderen Zweck dienen:

• durch eine Aufgaben-ID: wird von Nutzern wie Flottenbetreibern verwendet, die Zugriff auf vollständige Ansicht der Aufgabendaten.
• Durch eine Tracking-ID: wird von Ihrer Clientsoftware verwendet, um eingeschränkte an Endnutzer gesendet werden, z. B. wenn ein Paket bei ihnen zu Hause erwartet wird.

In diesem Abschnitt wird erläutert, wie Sie Aufgabeninformationen anhand einer Tracking-ID abrufen können. Bei Bedarf Um eine Aufgabe anhand der Aufgaben-ID zu suchen, gehen Sie zu Aufgabe suchen.

Sie haben folgende Möglichkeiten, Informationen anhand einer Tracking-ID abzurufen:

• Lookups mit Java mithilfe von gRPC
• Lookups mit HTTP

Lookup-Anforderungen

• Die Versandinformationen einer Sendungsverfolgungs-ID entsprechen den Sichtbarkeitsregeln angegeben in Sichtbarkeit von beobachteten Standorten verwalten

• Verwenden Sie Fleet Engine, um Versandinformationen anhand der Sendungsverfolgungs-ID abzurufen. Der Fahrer Das SDK unterstützt keine Informationssuche anhand der Tracking-ID. So erreichen Sie dies mit Fleet Engine verwenden, verwenden Sie entweder eine Server- oder Browserumgebung.

• Verwenden Sie so wenig Token wie möglich, um Sicherheitsrisiken zu minimieren. Wenn Sie beispielsweise ein Delivery Consumer Token verwenden, geben alle Fleet Engine Deliveries API-Aufrufe nur Informationen, die für diesen Endnutzer relevant sind, wie das Versandunternehmen oder Empfänger einer Sendung. Alle anderen Informationen in den Antworten werden entfernt. Weitere Informationen zu Tokens finden Sie unter JSON Web Token (JWT) zur Autorisierung erstellen:

Lookups mit Java unter Verwendung von gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek , um Informationen zu einer Versandaufgabe anhand der Tracking-ID abzurufen.

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;
}

Lookups mit HTTP

Um eine Versandaufgabe in einem Browser nachzuschlagen, führen Sie einen HTTP-REST-Aufruf an GetTaskTrackingInfo:

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

&lt;tracking_id&gt; ist die mit der Aufgabe verknüpfte Tracking-ID.

Der Anfrageheader muss das Feld Authorization mit dem Wert Inhaber <token>, wobei <token> ein Token, das von einer Fleet Engine-Token-Factory ausgegeben wird.

Wenn die Suche erfolgreich ist, enthält der Antworttext ein taskTrackingInfo Entität.

Beispiel eines curl-Befehls:

# 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}"

Aufgaben auflisten

Sie können Aufgaben aus einer Server- oder Browserumgebung auflisten. Das Treiber-SDK enthält keine das Auflisten von Aufgaben.

Wenn Sie Aufgaben auflisten, wird ein umfassender Zugriff auf Aufgaben angefordert. Das Auflisten von Aufgaben ist nur für vertrauenswürdigen Nutzern. Delivery Fleet Reader oder Delivery Super User Authentication verwenden Tokens für Anfragen zu Listenaufgaben.

In aufgeführten Aufgaben wurden die folgenden Felder entfernt:

• VehicleStop.planned_location
• VehicleStop.state
• VehicleStop.TaskInfo.taskId

Aufgelistete Aufgaben können nach den meisten Aufgabeneigenschaften gefiltert werden. Für die Filterabfragesyntax Siehe AIP-160. Die folgende Liste zeigt gültige Aufgaben Eigenschaften, die Sie zum Filtern verwenden können:

• Attribute
• delivery_vehicle_id
• Bundesstaat
• planned_location
• task_duration
• task_outcome
• task_outcome_location
• task_outcome_location_source
• task_outcome_time
• tracking_id
• Typ

Verwenden Sie basierend auf den Google API-Verbesserungsvorschlägen die folgenden Feldformate:

Eine vollständige Liste der Filterabfragen finden Sie unter AIP-160. .

Wenn keine Filterabfrage angegeben ist, werden alle Aufgaben aufgelistet.

Aufgabenlisten sind paginiert. Eine Seitengröße kann in Anfragen vom Typ „Aufgaben auflisten“ angegeben werden. Wenn eine Seitengröße angegeben ist, ist die Anzahl der zurückgegebenen Aufgaben nicht größer als die angegebene Seitengröße. Wenn keine Seitengröße vorhanden ist, kann ein angemessener Standardwert verwendet wird. Überschreitet die angeforderte Seitengröße einen internen Höchstwert, wird der interne Maximalwert verwendet.

Eine Aufgabenliste kann ein Token zum Lesen der nächsten Ergebnisseite enthalten. Seitentoken mit einer Anfrage verwenden, die ansonsten mit dem vorherigen identisch ist -Anforderung zum Abrufen der nächsten Aufgabenseite. Wenn das zurückgegebene Seitentoken leer ist, stehen keine Aufgaben zum Abrufen mehr zur Verfügung.

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek Aufgaben für eine deliveryVehicleId und ein Aufgabenattribut aufgelistet werden. Eine erfolgreiche kann die Antwort noch leer sein. Eine leere Antwort bedeutet, dass keine Aufgaben die mit der angegebenen deliveryVehicleId verknüpft ist.

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

Führen Sie einen HTTP-REST-Aufruf an ListTasks aus, um Aufgaben über einen Browser aufzulisten:

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

Wenn Sie einen Filter auf die aufgeführten Aufgaben anwenden möchten, fügen Sie einen „Filter“ hinzu URL-Parameter mit einer Filterabfrage mit URL-Escaping als Wert.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Wenn die Suche erfolgreich ist, enthält der Antworttext Daten mit der folgenden Struktur:

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

Eine erfolgreiche Antwort kann immer noch leer sein. Eine leere Antwort bedeutet, dass keine Es wurden Aufgaben gefunden, die den angegebenen Filterkriterien entsprechen.

Beispiel eines curl-Befehls:

    # 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}"

Lieferfahrzeuge auflisten

Sie können Lieferfahrzeuge aus einer Server- oder Browserumgebung auflisten. Der Fahrer Das SDK unterstützt keine Einträge für Lieferfahrzeuge.

Das Eintragen von Lieferfahrzeugen erfordert umfassenden Zugriff auf Lieferfahrzeuge und ist die nur für vertrauenswürdige Nutzer bestimmt sind. Delivery Fleet Reader oder Delivery Super verwenden Nutzer-Authentifizierungstoken für Anfragen zu Listenlieferfahrzeugen

In den aufgeführten Lieferfahrzeugen wurden die folgenden Felder aufgrund ihrer Auswirkungen entfernt zur Antwortgröße:

• CurrentRouteSegment
• RemainingVehicleJourneySegments

Du kannst die Liste der Lieferfahrzeuge nach ihrer attributes-Property filtern. Für Um beispielsweise ein Attribut mit dem Schlüssel my_key und dem Wert my_value abzufragen, verwenden Sie attributes.my_key = my_value JOIN-Abfragen, um mehrere Attribute abzufragen mithilfe der logischen Operatoren AND und OR, wie in attributes.key1 = value1 AND attributes.key2 = value2. Unter AIP-160 findest du eine vollständige Beschreibung der Filterabfragesyntax.

Mit der viewport-Anfrage können Sie aufgelistete Lieferfahrzeuge nach Standort filtern . Der Anfrageparameter viewport definiert Darstellungsbereiche mithilfe von zwei Begrenzungen Koordinaten: Breiten- und Längengrad für high (Nordosten) und low (Südwesten) -Koordinatenpaar. Anfragen werden abgelehnt, wenn sie einen hohen Breitengrad enthalten geografisch niedriger als ein niedriger Breitengrad ist.

Listen mit Fahrzeugen werden standardmäßig mit einer angemessenen Seitengröße paginiert. Wenn Wenn Sie eine Seitengröße angeben, wird in der Anfrage nur die Anzahl der Fahrzeuge zurückgegeben. durch das Limit festgelegt oder niedriger aus. Wenn die angeforderte Seitengröße einen internen Maximalwert, wird der interne Maximalwert verwendet. Die Standard- und Höchstseite jeweils 100 Fahrzeuge.

Eine Liste der Lieferfahrzeuge kann ein Token zum Lesen der nächsten Seite Ergebnisse. Ein Seitentoken ist nur in einer Antwort vorhanden, wenn mehr Seiten mit Übermittlungsseiten Fahrzeuge zum Abholen verfügbar sind. Um die nächste Seite mit Aufgaben abzurufen, verwenden Sie Das Seitentoken mit einer Anfrage, die ansonsten mit dem vorherigen identisch ist

gRPC

Das folgende Beispiel zeigt, wie Sie die Methode Java gRPC-Bibliothek , um Lieferfahrzeuge in einer bestimmten Region mit einem bestimmten Attribut aufzulisten. A erfolgreiche Antwort kann immer noch leer sein. In diesem Fall können keine Fahrzeuge mit dem angegebenen Attribut befinden sich bereits im angegebenen Darstellungsbereich.

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

Führen Sie einen HTTP-REST-Aufruf an ListDeliveryVehicles aus, um Aufgaben über einen Browser aufzulisten:

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

Wenn Sie einen Filter auf die aufgeführten Aufgaben anwenden möchten, fügen Sie einen „Filter“ hinzu URL-Parameter mit einem Filterabfrage mit URL-Escaping als Wert.

Der Anfrageheader muss das Feld Authorization mit dem Wert Bearer <token>, wobei <token> ein Token ist, das von einer Fleet Engine Token Factory ausgegeben wird.

Wenn die Suche erfolgreich ist, enthält der Antworttext Daten mit der folgenden Struktur:

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

Eine erfolgreiche Antwort kann immer noch leer sein. In diesem Fall können keine Es wurden Lieferfahrzeuge gefunden, die der angegebenen Filterabfrage und dem angegebenen Darstellungsbereich entsprechen.

Beispiel eines curl-Befehls:

# 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"

Sendungsverfolgung

Sie haben zwei Möglichkeiten, Fleet Engine Deliveries API verwenden, um die Sendungsverfolgung zu ermöglichen:

• Bevorzugt: Verwenden Sie die Methode JavaScript-Bibliothek für Versandverfolgung. In der Bibliothek können Sie die Position von Fahrzeugen und Standorten visualisieren. in Fleet Engine erfasst. Sie enthält eine JavaScript-Kartenkomponente. das ein Drop-in-Ersatz für ein standardmäßiges google.maps.Map-Objekt ist, und Datenkomponenten zur Verbindung mit Fleet Engine. Mit dieser Komponente können Sie bieten eine anpassbare, animierte Versandverfolgung. aus Ihrer Web- oder mobilen App.

• Implementieren Sie zusätzlich zur Fleet Engine Deliveries API Ihre eigene Sendungsverfolgung.

Wichtig ist, Versandaufgaben anhand der Sendungsverfolgungs-ID zu ermitteln.

Wenn Sie eine Delivery-Nutzerrolle verwenden, werden alle Fleet Engine Deliveries API-Aufrufe nur Informationen zurückgeben, die für einen Versandanbieter oder Empfänger relevant sind. Alle anderen Informationen in den Antworten entfernt. Du bist verantwortlich zur Authentifizierung von Endnutzern. Außerdem werden Standortinformationen gefiltert, basierend auf der bereits erledigten Aufgabe. Bei einer Nichtverfügbarkeitsaufgabe werden keine Standortinformationen an Endnutzer weitergegeben.

Logging

Sie können Fleet Engine so einstellen, dass RPC-Logs an Cloud Logging gesendet werden. Weitere Informationen finden Sie unter Logging:

Autorisierungsrollen und ‐tokens

Wie unter Fahrzeug- und Aufgabenlebenszyklus verwalten beschrieben und die Autorisierungshinweise für einzelne Anwendungsfälle, Aufrufe an Fleet Engine erfordern eine Authentifizierung mit JSON Web Tokens, mit Dienstkonto-Anmeldedaten signiert. Verwendete Dienstkonten zum Ausstellen dieser Tokens können eine oder mehrere Rollen haben, wobei jede Rolle anderen Berechtigungen festlegen.

Weitere Informationen finden Sie unter Authentifizierung und Autorisierung.

Häufig auftretende Probleme beheben

Falls Probleme auftreten, finden Sie in den folgenden Abschnitten Hilfe.

Robustheit

Fleet Engine gilt nicht als „Source of Truth“. Du bist verantwortlich um den Systemzustand bei Bedarf wiederherzustellen, Fleet Engine

Verlorener Status in Fleet Engine

Implementieren Sie bei der Arbeit mit Fleet Engine Kunden, damit das System repariert wird. selbst wenn ein Fehler auftritt. Wenn Fleet Engine beispielsweise versucht, eine wird möglicherweise eine Fehlermeldung angezeigt, dass das Fahrzeug existieren. Der Kunde sollte das Fahrzeug dann im neuen Zustand neu erstellen. Obwohl tritt dieses Problem selten auf. Achten Sie darauf, dass Ihr System stabil genug ist, .

Im äußerst unwahrscheinlichen Szenario eines katastrophalen Ausfalls von Fleet Engine müssen Sie möglicherweise die meisten oder alle Fahrzeuge und Aufgaben neu erstellen. Wenn die Erstellungsrate zu hoch wird, schlagen einige Anfragen aufgrund von Kontingentproblemen möglicherweise wieder fehl, da Kontingentprüfungen, um DoS-Angriffe (Denial of Service) zu vermeiden. Verlangsamen Sie in diesem Fall die Neuerstellungsrate, indem Sie eine Backoff-Strategie für und Wiederholungsversuche.

Verloren-Status in der Treiber-App

Wenn die Treiber-App abstürzt, muss die App den aktuellen Zustand neu erstellen im Treiber SDK. Die App sollte versuchen, Aufgaben neu zu erstellen, dass sie existieren, und um ihren aktuellen Zustand wiederherzustellen. Die App sollte auch neu erstellen und die Liste der Haltestellen für das Driver SDK explizit festlegen.

FAQ

Was passiert, wenn ein Fahrer bei einer Aufgabe anhält, die nicht in der richtigen Reihenfolge ist?

Aktualisieren Sie in diesem Fall zuerst die Reihenfolge der Aufgaben und fahren Sie dann wie gewohnt fort. die Ankunft an der Haltestelle, den Abschluss der Aufgabe und andere Details markieren. Andernfalls kann das System uneinheitlich werden, und unerwartete Fehler können gemeldet werden.