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
iOS
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
iOS
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
iOS
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:
| Nicht unterstützte Aufgaben-IDs | Grund |
|---|---|
| 8/31/2019-20:48-46.70746,-130.10807,-85.17909,61.33680 | Verstößt gegen personenidentifizierbare Informationen und Zeichenanforderungen: Kommas, Punkte, Doppelpunkte und Schrägstriche. |
| JohnDoe-577b484da26f-Cupertino-SantaCruz | Verstößt gegen Anforderungen an personenidentifizierbare Informationen. |
| 4R0oXLToF"112 Summer Dr. East Hartford, CT06118"577b484da26f8a | Verstößt gegen personenidentifizierbare Informationen und Zeichenanforderungen: Leerzeichen, Kommas und Anführungszeichen. Mehr als 64 Zeichen. |
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:
- Rufen Sie
UpdateDeliveryVehiclean. - Wenn Sie einen NOT_FOUND-Fehler erhalten, rufen Sie
CreateDeliveryVehicleauf. 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:
Aktualisieren Sie das Ergebnisfeld der Aufgabe in SUCCEEDED oder FAILED.
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:
Generieren Sie das Token mit dem nicht vertrauenswürdigen Treibernutzer für Fleet Engine Delivery. Dienstkontorolle.
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.
| Zeit | Aktivität | Modellierung |
|---|---|---|
| Innerhalb von 24 Stunden nach Tagesbeginn | Der Disponent weist Lieferungen den Lieferfahrzeugen oder -routen zu. | Sie können Aufgaben für Lieferungen, Abholungen, Pausen
anderen in Fleet Engine. Sie können beispielsweise eine
Abholoption der Sendung
Lieferung
geplante Nichtverfügbarkeit
Geplanter Stopp.
Einem Fahrzeug Aufgaben zuweisen, sobald die Lieferpakete vorhanden sind und die Reihenfolge, in der sie geliefert werden sollen, festgelegt ist. |
| Tagesbeginn | Der Fahrer beginnt den Tag am Depot, indem er sich in der Driver App anmeldet. | Initialisieren Sie die Delivery Driver API. Erstellen Sie das Lieferfahrzeug nach Bedarf in Fleet Engine. |
| Der Fahrer lädt Sendungen auf das Lieferfahrzeug und scannt sie. | Wenn Lieferaufgaben nicht im Voraus erstellt wurden, Versandaufgaben erstellen zum Zeitpunkt des Scans. | |
| Der Fahrer bestätigt die Reihenfolge der auszuführenden Aufgaben. | Wenn sie nicht im Voraus erstellt wurden, erstellen Sie sie Aufgaben zur Abholung der Sendung, geplante Nichtverfügbarkeit geplante Haltestellen | |
| Der Fahrer verlässt das Depot und übernimmt die nächste Anzahl von Aufgaben. abgeschlossen. | Alle Aufgaben oder nur einen Teil der Aufgaben zuweisen an das Fahrzeug senden, indem der Abschlussauftrag übernommen wird. | |
| Der Fahrer stellt eine Sendung zu. | Nach der Ankunft an der Lieferstation Aktionen in Bezug auf bis zu einem Fahrzeug, das an einer Haltestelle ankommt. Schließen Sie nach dem Versand die Lieferaufgabe und optional Versandstatus des Geschäfts und andere Metainformationen Nach Erledigung aller Aufgaben an der Haltestelle und davor beginnen, zur nächsten Haltestelle zu fahren, Aktionen in Bezug auf mit dem Fahrzeug angehalten wird und Fahrzeug auf dem Weg zur nächsten Haltestelle ist. | |
| Fahrer trifft auf Zustellfahrzeug, um zusätzliche Sendungen auf das Lieferfahrzeug zu übertragen. | Treffpunkt für den Umstieg zwischen Zubringer- und Lieferfahrzeugen
sollte als geplanter Stopp modelliert werden.
Nach dem Übertragen und Scannen der Sendungen Zustellaufgaben erstellen falls noch nicht geschehen. Aktualisieren Sie dann den Abschluss der Aufgabe indem Sie einem Fahrzeug Aufgaben zuweisen und Aktualisieren der Aufgabenreihenfolge. |
|
| Der Fahrer wird über eine Abholanfrage benachrichtigt. | Nachdem Sie die Abholanfrage akzeptiert haben, eine Aufgabe zur Abholung der Sendung erstellen. Aktualisieren Sie dann die Aufgabenausführung indem Sie einem Fahrzeug Aufgaben zuweisen und Aktualisieren der Aufgabenreihenfolge. | |
| Mittag | Fahrer macht Mittagspause. | Wenn ein Standort mit der Nichtverfügbarkeitsaufgabe verknüpft ist, behandeln Sie ihn wie
andere Aufgaben zu erledigen. Aktionen für ein Fahrzeug ausführen
an einer Haltestelle ankommen,
Haltestelle
und Fahrzeug auf dem Weg zur nächsten Haltestelle ist.
Andernfalls müssen Sie bis zum Ende der Unterbrechung nichts weiter tun. Entfernen Sie die Aufgabe, indem Sie die nächsten und verbleibenden Aufgaben bestätigen und Aktualisieren der Aufgabenreihenfolge. |
| Der Fahrer holt eine Sendung ab. | Dies wird wie ein Lieferstopp modelliert. Aktionen ausführen bis zu einem Fahrzeug, das an einer Haltestelle ankommt und eine Aufgabe schließen und optional Versandstatus und andere Metainformationen speichern. Nach Abschluss aller Aufgaben an der Haltestelle und vor Fahrtantritt zur nächsten Haltestelle: Aktionen für einen Stopp des Fahrzeugs durchführen und Fahrzeug auf dem Weg zur nächsten Haltestelle ist. Hinweis: Damit die Abrechnung korrekt ist, muss für alle Abholungen ein entsprechender Lieferaufgabe. Wenn das Paket an einen anderen Ort geliefert werden soll, dieselbe Route am selben Tag fährt, empfehlen wir, diese Lieferaufgabe als auf der Route durchführen. Wenn der Fahrer den Abholer bringt zurück zum Warenlager, empfehlen wir, im Lager einen Lieferauftrag zu erstellen, Ziel. | |
| Der Fahrer hält an einem planmäßigen Stopp die Lieferungen aus einer Ablagebox ab. | Dieser Wert wird wie bei jedem anderen Abholstopp modelliert. Aktionen ausführen bis zu einem Fahrzeug, das an einer Haltestelle ankommt und Schließen einer Aufgabe. Nach Abschluss alle Aufgaben an der Haltestelle zu sehen und zur nächsten Haltestelle zu fahren. Aktionen durchführen, die sich auf den Stopp eines Fahrzeugs beziehen und Fahrzeug auf dem Weg zur nächsten Haltestelle ist. | |
| Der Fahrer wird benachrichtigt, dass eine Sendung an einen anderen Ort umgeleitet wird. | Legen Sie den ursprünglichen Status der Lieferaufgabe auf ABGESCHLOSSEN fest und erstellen Sie eine neue Lieferauftrag für den neuen Lieferort. Weitere Informationen Siehe Sendung umleiten. | |
| Der Fahrer versuchte, ein Paket zuzustellen, konnte das aber nicht tun. | Dies wird ähnlich wie ein erfolgreicher Lieferstopp modelliert. Lieferaufgabe als abgeschlossen gilt. Aktionen ausführen, die sich auf Folgendes beziehen: ein an einer Haltestelle ankommendes Fahrzeug. Nachher die Lieferung versäumt hat, die Aufgabe schließen und optional Versandstatus des Geschäfts und andere Metainformationen Nach Abschluss aller Aufgaben an der Haltestelle und vor Fahrtantritt zur nächsten Haltestelle: Aktionen für einen Stopp des Fahrzeugs durchführen und Fahrzeug auf dem Weg zur nächsten Haltestelle ist. | |
| Der Fahrer wurde benachrichtigt, eine Sendung zurückzuhalten (nicht zuzustellen). | Nach Erhalt und Bestätigung der Benachrichtigung Aufgabenstatus auf ABGESCHLOSSEN setzen. | |
| Der Fahrer wurde aufgefordert, eine bestimmte Lieferung als Nächstes zuzustellen. Dadurch änderte sich die zugesagte Lieferreihenfolge. | Aktualisieren Sie die Aufgabenreihenfolge. | |
| Der Fahrer entscheidet, eine Lieferung außerordentlich zu liefern. | Aktualisieren Sie die Aufgabenreihenfolge und dann ganz normal fortfahren. | |
| Der Fahrer liefert mehrere Lieferungen an einen Ort. | Dies ähnelt dem Modell einer einzelnen Lieferstation. Führen Sie nach der Ankunft an der Haltestelle Aktionen in Bezug auf an einer Haltestelle ankommendes Fahrzeug. Nachdem Sie eine Sendung zugestellt haben, schließen Sie jede Aufgabe. sowie optional den Versandstatus des Geschäfts und andere Metainformationen. Nach Abschluss aller Aufgaben an der Haltestelle und vor Fahrtantritt zur nächsten Haltestelle: Aktionen für einen Stopp des Fahrzeugs durchführen und Fahrzeug auf dem Weg zur nächsten Haltestelle ist. | |
| Tagesende | Der Fahrer kehrt zum Depot zurück. | Wenn der Fahrer zum Depot zurückkehrt und die Sendungen während der jedes Pakets als Lieferaufgabe erstellen und abschließen, für eine korrekte Abrechnung. Sie können dies erreichen, indem Sie das Depot wie anderen Lieferstopps. Wenn das Depot nicht als Lieferstopp genutzt wird, können Sie trotzdem optional das Depot als planmäßige Haltestelle modellieren. Durch die Modellierung der Haltestelle können Ihre Fahrer auf dem Weg zurück zum Depot und geben Aufschluss über die voraussichtliche Dauer bei der Ankunft. |
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:
- Treiber-SDK verwenden: Android iOS -- die einfachste Option.
- 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 den 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 Abholung der Sendung entweder über die Treiber-SDK oder aus einer Serverumgebung mit gRPC oder REST.
gRPC
Das folgende Beispiel zeigt, wie Sie den 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>`
<id> 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. 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 den 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>`
<id> 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 den 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 den 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>`
<id> 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 den 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>`
<id> 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 den 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`
<id> 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 den 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`
<id> 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 auch Folgendes:
- Dem Fahrzeug werden neue Aufgaben zugewiesen.
- Schließt alle Aufgaben, die dem Fahrzeug zuvor 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 den 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`
<id> 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 den 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`
<id> 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 den 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`
<id> 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 den 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`
<id> 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, bei 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, 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 den 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`
<id> 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`
<id> 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 den 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`
<id> 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 die Sendungszustellung einer übertragenen Sendung, nachdem sie auf den Lieferfahrzeug. 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 den 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>`
<id> ist eine eindeutige Kennzeichnung für die Aufgabe.
<vehicleId> 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 den 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>`
<id> ist eine eindeutige Kennzeichnung für die Aufgabe.
<taskId> 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:
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 den 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>`
<tracking_id> 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:
| Feldtyp | Format | Beispiel |
|---|---|---|
| Zeitstempel | RFC-3339 | task_outcome_time = 2022-03-01T11:30:00-08:00 |
| Dauer | Anzahl der Sekunden, gefolgt von s |
task_duration = 120s |
| Enum | String | state = CLOSED AND type = PICKUP |
| Standort | point.latitude und point.longitude |
planned_location.point.latitude > 36.1 AND planned_location.point.longitude < -122.0 |
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 den 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 den 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 Spediteur 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äufige 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.