Erste Schritte mit dem Driver SDK für Android

Hinweis: Die LMFS-Funktion bietet zwei Sicherheitsmodelle zur Verwendung mit dem Driver SDK: untrusted und untrusted. Beide Sicherheitsmodelle definieren Möglichkeiten, wie die Fahrer-App Fahrzeugdatenaktualisierungen für Fleet Engine bereitstellen kann. Das Sicherheitsmodell für nicht vertrauenswürdige Fahrzeuge bietet eine zusätzliche Ebene für die Datenprüfung von der Treiber-App. Im nicht vertrauenswürdigen Modell kann die Treiber-App nur Aktualisierungen des Standorts des Fahrzeugs direkt an Fleet Engine senden. Alle anderen Aktualisierungen von Fahrzeugdaten von einer nicht vertrauenswürdigen Fahrer-App müssen an das Kunden-Backend gesendet werden, das die Daten an Fleet Engine weiterleitet.

Mit dem vertrauenswürdigen Sicherheitsmodell kann die Fahrer-App Aktualisierungen von Fahrzeugdaten direkt an Fleet Engine senden, ohne dass ein Vermittlungsdienst erforderlich ist. Zu diesen Daten gehören das Erstellen und Aktualisieren von Fahrzeugen, Aufgaben und Haltestellen.

Das nicht vertrauenswürdige Modell ist allgemein verfügbar, während sich das vertrauenswürdige Treibermodell in der Vorabversion befindet. Weitere Informationen zum vertrauenswürdigen Treibermodell finden Sie unter Andere Dienstkontorollen.

Mindestsystemanforderungen

Auf dem Mobilgerät muss Android 6.0 (API-Level 23) oder höher installiert sein.

Build- und Abhängigkeiten-Konfiguration

Die Treiber-SDK-Versionen 4.99 und höher sind im Google Maven-Repository verfügbar.

Gradle

Füge deiner Datei build.gradle Folgendes hinzu:

repositories {
    ...
    google()
}

Maven

Füge deiner Datei pom.xml Folgendes hinzu:

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

Projektkonfiguration

Damit Sie das Driver SDK verwenden können, muss Ihre App auf minSdkVersion 23 oder höher ausgerichtet sein. Weitere Informationen finden Sie in den Versionshinweisen.

Damit Sie eine mit dem Driver SDK erstellte App ausführen können, müssen auf dem Android-Gerät Google Play-Dienste installiert sein.

Entwicklungsprojekt einrichten

So richten Sie Ihr Entwicklungsprojekt ein und rufen in der Google Cloud Console einen API-Schlüssel für das Projekt ab:

1. Erstellen Sie ein neues Google Cloud Console-Projekt oder wählen Sie ein vorhandenes Projekt zur Verwendung mit dem Treiber SDK aus. Warten Sie einige Minuten, bis das neue Projekt in der Google Cloud Console angezeigt wird.

2. Damit Sie die Demo-App ausführen können, muss Ihr Projekt Zugriff auf das Maps SDK for Android haben. Wählen Sie in der Google Cloud Console APIs und Dienste > Bibliothek aus. Suchen Sie dann nach dem Maps SDK for Android und aktivieren Sie es.

3. Rufen Sie einen API-Schlüssel für das Projekt ab. Wählen Sie dazu APIs und Dienste > Anmeldedaten > Anmeldedaten erstellen > API-Schlüssel aus. Weitere Informationen zum Abrufen eines API-Schlüssels finden Sie unter API-Schlüssel anfordern.

Treiber-SDK zur App hinzufügen

Das Treiber-SDK ist im Google Maven-Repository verfügbar. Das Repository enthält die SDK-Dateien für das Project Object Model (.pom) und Javadocs. So fügen Sie Ihrer App das Driver SDK hinzu:

1. Fügen Sie Ihrer Gradle- oder Maven-Konfiguration die folgende Abhängigkeit hinzu und ersetzen Sie dabei den Platzhalter VERSION_NUMBER durch die ausgewählte Version des Treiber-SDK.

   Gradle

   Fügen Sie zum build.gradle Folgendes hinzu:

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

   Maven

   Fügen Sie zum pom.xml Folgendes hinzu:

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

2. Das Driver SDK hängt vom Navigation SDK ab. Diese Abhängigkeit ist so konfiguriert, dass bei Bedarf eine bestimmte Navigation SDK-Version in der Build-Konfigurationsdatei explizit definiert werden muss. Beispiel: Wenn der erwähnte Codeblock weggelassen wird, kann das Projekt immer die neueste Version des Navigation SDK in der Hauptversion herunterladen. Das gemeinsame Verhalten der aktuellen Versionen des Driver SDK und des Navigation SDK wurde vor ihrer Veröffentlichung strengen Tests unterzogen.

   Ordnen Sie die Abhängigkeitskonfiguration Ihrer Entwicklungs- und Releaseumgebungen entsprechend an.

   Gradle

   Fügen Sie zum build.gradle Folgendes hinzu:

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

   Maven

   Fügen Sie zum pom.xml Folgendes hinzu:

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

API-Schlüssel in die App einfügen

Nachdem Sie Ihrer App das Driver SDK hinzugefügt haben, fügen Sie den API-Schlüssel zu Ihrer App hinzu. Sie müssen den Projekt-API-Schlüssel verwenden, den Sie beim Einrichten Ihres Entwicklungsprojekts erhalten haben.

In diesem Abschnitt wird beschrieben, wie Sie Ihren API-Schlüssel speichern, damit er von Ihrer App sicherer referenziert werden kann. Sie sollten ihn nicht in Ihrem Versionsverwaltungssystem einchecken. Sie sollte in der Datei local.properties gespeichert werden, die sich im Stammverzeichnis Ihres Projekts befindet. Weitere Informationen zur Datei local.properties finden Sie unter Gradle properties files.

Mit dem Secrets Gradle-Plug-in für Android können Sie diese Aufgabe optimieren. Folgen Sie dieser Anleitung, um das Secrets Gradle-Plug-in zu installieren und Ihren API-Schlüssel sicher zu speichern.

1. Öffnen Sie die Datei build.gradle auf Stammebene und fügen Sie den folgenden Code in das Element dependencies unter buildscript ein.

   Groovy

   buildscript {
       dependencies {
           // ...
           classpath "com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin:2.0.0"
       }
   }
   

   Kotlin

   buildscript {
       dependencies {
           // ...
           classpath("com.google.android.libraries.mapsplatform.secrets-gradle-plugin:secrets-gradle-plugin:2.0.0")
       }
   }
   

2. Öffne die Datei build.gradle auf App-Ebene und füge dem plugins-Element den folgenden Code hinzu.

   Groovy

   id 'com.google.android.libraries.mapsplatform.secrets-gradle-plugin'
   

   Kotlin

   id("com.google.android.libraries.mapsplatform.secrets-gradle-plugin")
   

3. Synchronisieren Sie Ihr Projekt mit Gradle.

4. Öffnen Sie local.properties in Ihrem Verzeichnis auf Projektebene und fügen Sie den folgenden Code ein. Achten Sie darauf, YOUR_API_KEY durch Ihren API-Schlüssel zu ersetzen.

   MAPS_API_KEY=YOUR_API_KEY
   

5. Gehen Sie in der Datei AndroidManifest.xml zu com.google.android.geo.API_KEY und aktualisieren Sie das Attribut android:value so:

   <meta-data
       android:name="com.google.android.geo.API_KEY"
       android:value="${MAPS_API_KEY}" />
   

Das folgende Beispiel zeigt ein vollständiges Manifest für eine Beispiel-App:

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

        <meta-data
            android:name="com.google.android.geo.API_KEY"
            android:value="${MAPS_API_KEY}" />

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

Hinweis :Für eine optimale Navigation müssen die Berechtigungen android.permission.ACCESS_COARSE_LOCATION und android.permission.ACCESS_FINE_LOCATION vom Nutzer erteilt werden. Beides muss zur Laufzeit in der App angefordert werden.

Fügen Sie Ihrer App die erforderlichen Quellenangaben hinzu.

Wenn Sie das Driver SDK in Ihrer App verwenden, müssen Sie Quellenangaben und Open-Source-Lizenzen in den Abschnitt mit den rechtlichen Hinweisen für Ihre App aufnehmen. Die Quellenangaben sollten am besten als eigenständigen Menüpunkt oder als Teil des Menüpunkts Info eingebunden werden.

Die Lizenzinformationen befinden sich in der wieder aktivierten AAR-Datei in der Datei „third_party_Licenses.txt“.

Informationen zum Einbinden von Open-Source-Hinweisen finden Sie unter https://developers.google.com/android/guides/opensource.

Abhängigkeiten

Das Driver SDK verwendet gRPC, um mit dem Fleet Engine-Server zu kommunizieren. Wenn Sie gRPC noch nicht einbinden, müssen Sie möglicherweise die folgenden Abhängigkeiten deklarieren:

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

Ohne diese Abhängigkeiten können im Driver SDK bei der Kommunikation mit dem Fleet Engine-Server während der Laufzeit Fehler auftreten.

Wenn Sie Ihre Builds mit ProGuard optimieren, müssen Sie Ihrer ProGuard-Konfigurationsdatei möglicherweise die folgenden Zeilen hinzufügen:

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

Das Mindest-API-Level, das unterstützt wird, ist 23.

SDK initialisieren

Zum Initialisieren des DriverContext-Objekts ist eine Anbieter-ID (in der Regel die Google Cloud-Projekt-ID) erforderlich. Weitere Informationen zum Einrichten des Google Cloud-Projekts finden Sie unter Authentifizierung und Autorisierung.

Bevor Sie das Driver SDK verwenden können, müssen Sie zuerst das Navigation SDK initialisieren. So initialisieren Sie das SDK:

1. Rufen Sie ein Navigator-Objekt aus NavigationApi ab.

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

2. Erstellen Sie ein DriverContext-Objekt und füllen Sie die Pflichtfelder aus.

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

3. Verwenden Sie das DriverContext-Objekt, um *DriverApi zu initialisieren.

   DeliveryDriverApi driverApi = DeliveryDriverApi.createInstance(driverContext);
   

4. Rufen Sie die DeliveryVehicleReporter aus dem API-Objekt ab. (DeliveryVehicleReporter erweitert NavigationVehicleReporter.)

   DeliveryVehicleReporter vehicleReporter = driverApi.getDeliveryVehicleReporter();
   

Mit AuthTokenFactory authentifizieren

Wenn das Treiber SDK Standortaktualisierungen generiert, muss es diese Aktualisierungen an den Fleet Engine-Server senden. Zum Authentifizieren dieser Anfragen ruft das Driver SDK eine vom Aufrufer bereitgestellte Instanz von AuthTokenFactory auf. Die Factory ist für das Generieren von Authentifizierungstokens zum Zeitpunkt der Standortaktualisierung verantwortlich.

Wie genau Tokens generiert werden, hängt von der Situation des jeweiligen Entwicklers ab. Die Implementierung muss jedoch wahrscheinlich:

• Authentifizierungstoken, möglicherweise im JSON-Format, von einem HTTPS-Server abrufen
• Token analysieren und im Cache speichern
• Aktualisieren Sie das Token, wenn es abläuft.

Weitere Informationen zu den vom Fleet Engine-Server erwarteten Tokens finden Sie unter JSON Web Token (JWT) zur Autorisierung erstellen.

Hier ist die grundlegende Implementierung einer AuthTokenFactory:

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

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

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

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

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

Diese spezielle Implementierung verwendet den integrierten Java-HTTP-Client, um ein Token im JSON-Format vom Authentifizierungsserver des Entwicklers abzurufen. Das Token wird für die Wiederverwendung gespeichert. Das Token wird noch einmal abgerufen, wenn das alte Token innerhalb von 10 Minuten seine Ablaufzeit erreicht.

Ihre Implementierung kann andere Dinge tun, z. B. die Verwendung eines Hintergrundthreads zum Aktualisieren von Tokens.

Ausnahmen in AuthTokenFactory werden als vorübergehend behandelt, es sei denn, sie treten wiederholt auf. Nach mehreren Versuchen geht das Driver SDK davon aus, dass der Fehler dauerhaft ist, und versucht nicht mehr, Aktualisierungen zu senden.

Status- und Error Reporting mit StatusListener

Da das Driver SDK im Hintergrund Aktionen ausführt, sollten Sie mit StatusListener Benachrichtigungen auslösen, wenn bestimmte Ereignisse auftreten, z. B. Fehler, Warnungen oder Debug-Meldungen. Fehler können vorübergehend sein (z. B. BACKEND_CONNECTIVITY_ERROR) oder dazu führen, dass Standortaktualisierungen dauerhaft beendet werden (z. B. VEHICLE_NOT_FOUND, was auf einen Konfigurationsfehler hindeutet).

Sie stellen eine optionale StatusListener-Implementierung wie die folgende bereit:

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

Hinweise zu SSL/TLS

Intern verwendet die Driver SDK-Implementierung SSL/TLS, um sicher mit dem Fleet Engine-Server zu kommunizieren. Bei früheren Android-Versionen (API-Version 23 oder älter) ist für die Kommunikation mit dem Server möglicherweise ein SecurityProvider-Patch erforderlich. Weitere Informationen zur Arbeit mit SSL unter Android finden Sie unter Sicherheits-GMD-Anbieter. Der Artikel enthält außerdem Codebeispiele zum Patchen des Sicherheitsanbieters.

Standortaktualisierungen aktivieren

Sobald Sie eine *VehicleReporter-Instanz haben, ist das Aktivieren von Standortupdates ganz einfach:

DeliveryVehicleReporter reporter = ...;

reporter.enableLocationTracking();

Standortaktualisierungen werden nach Möglichkeit in regelmäßigen Abständen gesendet. Bei jedem Standortupdate wird auch angezeigt, dass das Fahrzeug online ist.

Standardmäßig beträgt das Berichtsintervall 10 Sekunden. Sie können das Berichtszeitraum mit reporter.setLocationReportingInterval(long, TimeUnit) ändern. Das unterstützte Mindestaktualisierungsintervall beträgt 5 Sekunden. Häufigere Aktualisierungen können zu langsameren Anfragen und Fehlern führen.

Standortaktualisierungen deaktivieren

Wenn der Fahrer seine Schicht beendet hat, kannst du die Standortaktualisierungen durch Aufrufen von DeliveryVehicleReporter.disableLocationTracking stoppen.

Anwendungsfälle für vertrauenswürdige Modelle

Dieses Produkt oder diese Funktion ist eine Vorabversion (pre-GA). Pre-GA-Produkte und ‑Features werden eventuell nur eingeschränkt unterstützt. Außerdem sind Änderungen an diesen Produkten und Features möglicherweise nicht mit anderen pre-GA-Versionen kompatibel. Pre-GA-Angebote sind durch die dienstspezifischen Nutzungsbedingungen für die Google Maps Platform abgedeckt. Weitere Informationen finden Sie in den Beschreibungen der Einführungsphasen.

In diesem Abschnitt wird beschrieben, wie Sie mit dem Driver SDK häufige Anwendungsfälle bei Verwendung des vertrauenswürdigen Modells implementieren.

Fahrzeug erstellen

Sie können ein Fahrzeug über das Driver SDK erstellen.

Bevor Sie ein Fahrzeug erstellen, müssen Sie die Delivery Driver API initialisieren. Die Fahrzeug-ID muss mit der Fahrzeug- und Anbieter-ID erstellt werden, die bei der Initialisierung des Driver SDK verwendet wurde. Erstellen Sie dann das Fahrzeug wie im folgenden Beispiel gezeigt:

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

Aufgabe zum Abholen einer Sendung erstellen

Sie können eine Aufgabe zur Abholung der Sendung über das Driver SDK erstellen.

Bevor Sie eine Aufgabe erstellen, müssen Sie die Delivery Driver API initialisieren. Die Aufgabe muss mit der Anbieter-ID erstellt werden, die bei der Initialisierung des Treiber-SDK angegeben wurde. Erstellen Sie dann die Aufgabe zur Abholung der Sendung, wie im folgenden Beispiel gezeigt. Weitere Informationen zu Aufgaben-IDs finden Sie in den Beispielen für Aufgaben-IDs.

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

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

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

Aufgabe für die Sendungszustellung erstellen

Sie können eine Aufgabe für die Sendungszustellung über das Driver SDK erstellen.

Bevor Sie eine Aufgabe erstellen, müssen Sie die Delivery Driver API initialisieren. Erstellen Sie dann die Aufgabe für die Sendungszustellung, wie im folgenden Beispiel gezeigt. Weitere Informationen zu Aufgaben-IDs finden Sie in den Beispielen für Aufgaben-IDs.

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

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

Geplante Nichtverfügbarkeit

Du kannst über das Driver SDK eine Aufgabe erstellen, die Nichtverfügbarkeit angibt (z. B. für Pausen oder Tanken von Fahrzeugen). Eine geplante Nichtverfügbarkeitsaufgabe darf keine Tracking-ID enthalten. Optional können Sie einen Standort angeben.

Bevor Sie eine Aufgabe erstellen, müssen Sie die Delivery Driver API initialisieren. Erstellen Sie dann die Nichtverfügbarkeitsaufgabe, wie im folgenden Beispiel gezeigt. Weitere Informationen zu Aufgaben-IDs finden Sie in den Beispielen für Aufgaben-IDs.

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

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

Geplante Haltestellen

Sie können eine geplante Stoppaufgabe entweder über das Driver SDK erstellen. Eine geplante Stoppaufgabe enthält möglicherweise keine Tracking-ID.

Bevor Sie eine Aufgabe erstellen, müssen Sie die Delivery Driver API initialisieren. Erstellen Sie dann die geplante Stoppaufgabe, wie im folgenden Beispiel gezeigt. Weitere Informationen zu Aufgaben-IDs finden Sie in den Beispielen für Aufgaben-IDs.

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

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

Aufgabenreihenfolge aktualisieren

Sie können die Reihenfolge der Ausführungen von Aufgaben, die einem Fahrzeug zugewiesen sind, über das Driver SDK aktualisieren.

Beim Aktualisieren der Aufgabenreihenfolge werden einem Fahrzeug auch Aufgaben zugewiesen, sofern sie noch keinem Fahrzeug zugewiesen waren. Außerdem werden Aufgaben, die zuvor einem Fahrzeug zugewiesen und bei der aktualisierten Reihenfolge nicht berücksichtigt wurden, geschlossen. Wenn eine Aufgabe einem anderen Fahrzeug zugewiesen wird, wenn sie zuvor einem anderen Fahrzeug zugewiesen war, wird ein Fehler generiert. Bevor Sie dem neuen Fahrzeug eine Aufgabe zuweisen, schließen Sie die vorhandene Aufgabe und erstellen Sie dann eine neue.

Sie können die Aufgabenreihenfolge jederzeit aktualisieren.

Bevor Sie die Aufgabenreihenfolge für ein Fahrzeug aktualisieren, prüfen Sie, ob das Fahrzeug und die Aufgaben bereits in Fleet Engine erstellt wurden. Aktualisieren Sie dann die Aufgabenreihenfolge für das Fahrzeug, wie im folgenden Beispiel gezeigt.

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

Es kann eine Ausnahme auftreten, die eine Aktualisierung des internen Status des Treiber-SDK verhindern könnte. Beheben Sie in diesem Fall das Problem und rufen Sie setVehicleStops noch einmal auf, bis der Aufruf erfolgreich ist.

Mögliche Probleme sind:

• Die angegebenen VehicleStops folgen keinem gültigen Muster. Nur die erste VehicleStop kann einen der folgenden VehicleStopStates haben: NEW, ENROUTE oder ARRIVED. VehicleStops nach der aktuellen Haltestelle müssen den Wert NEW VehicleStopState haben.

• Aufgaben sind entweder nicht vorhanden oder gehören zu einem anderen Fahrzeug.

• Das Fahrzeug ist nicht vorhanden.

Fahrzeug ist auf dem Weg zur nächsten Haltestelle

Fleet Engine muss benachrichtigt werden, wenn ein Fahrzeug von einer Haltestelle abfährt und die Navigation beginnt. Sie können Fleet Engine über das Driver SDK benachrichtigen.

Bevor Sie Fleet Engine darüber informieren, dass ein Fahrzeug von einer Haltestelle abgefahren wurde, müssen Sie die Haltestellen erstellen und festlegen. Informieren Sie dann Fleet Engine über die Abfahrt des Fahrzeugs, wie im folgenden Beispiel gezeigt.

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

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

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

Es kann eine Ausnahme auftreten, die eine Aktualisierung des internen Status des Treiber-SDK verhindern könnte. Beheben Sie in diesem Fall das Problem und rufen Sie enrouteToNextStop noch einmal auf, bis der Vorgang erfolgreich war.

Mögliche Probleme sind:

• Keine verbleibenden VehicleStops im Driver SDK festgelegt.

Fahrzeug landet an einer Haltestelle

Fleet Engine muss benachrichtigt werden, wenn ein Fahrzeug an einer Haltestelle ankommt. Sie können Fleet Engine über das Driver SDK benachrichtigen.

Bevor Sie Fleet Engine benachrichtigen, dass ein Fahrzeug an einer Haltestelle angekommen ist, müssen Sie die Haltestellen festlegen. Informieren Sie dann Fleet Engine über die Ankunft des Fahrzeugs an der Haltestelle, wie im folgenden Beispiel gezeigt.

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

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

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

Es kann eine Ausnahme auftreten, die eine Aktualisierung des internen Status des Treiber-SDK verhindern könnte. Beheben Sie in diesem Fall das Problem und rufen Sie arrivedAtStop noch einmal auf, bis der Vorgang erfolgreich war.

Mögliche Probleme sind:

• Keine verbleibenden VehicleStops im Driver SDK festgelegt.

Fahrzeug hält an

Sie müssen Fleet Engine benachrichtigen, wenn ein Fahrzeug anhält. Diese Benachrichtigung bewirkt, dass alle mit der Haltestelle verknüpften Aufgaben in den Status CLOSED (GESCHLOSSEN) gesetzt werden. Sie können Fleet Engine über das Driver SDK benachrichtigen.

Informieren Sie Fleet Engine darüber, dass das Fahrzeug die VehicleStop (VehicleStop) des Fahrzeugs abgeschlossen hat, wie im folgenden Beispiel gezeigt.

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

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

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

Es kann eine Ausnahme auftreten, die eine Aktualisierung des internen Status des Treiber-SDK verhindern könnte. Beheben Sie in diesem Fall das Problem und rufen Sie completedStop noch einmal auf, bis der Vorgang erfolgreich war.

Mögliche Probleme sind:

• Keine verbleibenden VehicleStops im Driver SDK festgelegt.

Aufgabe schließen

Wenn Sie eine Aufgabe schließen möchten, die einem Fahrzeug zugewiesen wurde, benachrichtigen Sie entweder Fleet Engine, dass das Fahrzeug die Haltestelle abgeschlossen hat, an der die Aufgabe stattfindet, oder entfernen Sie das Fahrzeug aus der Liste der Fahrzeughalte. Dazu können Sie die Liste der verbleibenden Fahrzeughaltestellen festlegen, genau wie beim Aktualisieren der Aufgabenreihenfolge für ein Fahrzeug.

Wenn eine Aufgabe noch keinem Fahrzeug zugewiesen wurde und geschlossen werden muss, setzen Sie die Aufgabe auf CLOSED (GESCHLOSSEN). GESCHLOSSENE Aufgaben können jedoch nicht wieder geöffnet werden.

Das Schließen einer Aufgabe weist nicht auf Erfolg oder Misserfolg hin. Es weist darauf hin, dass die Aufgabe nicht mehr als in Bearbeitung angesehen wird. Für die Sendungsverfolgung ist es wichtig, das tatsächliche Ergebnis einer Aufgabe anzugeben, damit das Lieferergebnis angezeigt werden kann.

Einem Fahrzeug muss eine Aufgabe zugewiesen werden, damit die Aufgabe über das Driver SDK geschlossen werden kann. Zum Schließen einer Aufgabe, die einem Fahrzeug zugewiesen wurde, benachrichtigen Sie Fleet Engine, dass das Fahrzeug die Haltestelle abgeschlossen hat, an der die Aufgabe stattfindet.

Alternativ können Sie die Aufgabenreihenfolge des Fahrzeugs aktualisieren, dem die Aufgabe zugewiesen ist, und die Aufgabe dann aus der Liste der Haltestellen entfernen.

Aufgabenergebnis und Ergebnisort festlegen

Das Schließen einer Aufgabe weist nicht auf Erfolg oder Misserfolg hin. Es weist darauf hin, dass die Aufgabe nicht mehr als in Bearbeitung angesehen wird. Für die Sendungsverfolgung ist es wichtig, das tatsächliche Ergebnis einer Aufgabe anzugeben, damit das Lieferergebnis angezeigt werden kann und die Dienste ordnungsgemäß abgerechnet werden. Wenn das Aufgabenergebnis einmal festgelegt wurde, können Sie es nicht mehr ändern. Sie können jedoch die Zeit und den Ort des Aufgabenergebnisses ändern, nachdem Sie diese festgelegt haben.

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

Beim Markieren des Ergebnisses einer Aufgabe gibt Fleet Engine automatisch den letzten bekannten Fahrzeugstandort für den Standort des Aufgabenergebnisses ein. Sie können dieses Verhalten überschreiben.

Das folgende Beispiel zeigt, wie Sie mit dem Driver SDK ein Aufgabenergebnis und einen Zeitstempel festlegen. Sie können den Speicherort des Aufgabenergebnisses nicht mit dem Driver SDK festlegen.

    static final String TASK_ID = "task-8241890";

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

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

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

Fahrzeug suchen

Sie können ein Fahrzeug im Driver SDK suchen. Bevor Sie nach einem Fahrzeug suchen, müssen Sie die Delivery Driver API initialisieren. Sie können dann das Fahrzeug wie im folgenden Beispiel suchen.

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

DeliveryVehicleManager kann nur die DeliveryVehicle für die Fahrzeug-ID suchen, die bei der Initialisierung der Delivery Driver API angegeben wurde.