Autorisierungstokens abrufen

Das Consumer SDK bietet Autorisierung mit JSON-Webtokens. Ein JSON-Webtoken (JWT) ist ein Autorisierungstoken, das einen oder mehrere Ansprüche an einen Dienst enthält.

Das Consumer SDK verwendet das von der Anwendung bereitgestellte JSON-Webtoken, um mit der Fleet Engine zu kommunizieren. Details zu den von der Fleet Engine erwarteten Tokens finden Sie unter JSON-Webtokens und JSON-Webtokens ausstellen.

Das Autorisierungstoken bietet Zugriff auf die folgenden Fleet Engine-Dienste:

  • TripService : Ermöglicht dem Consumer SDK den Zugriff auf Details zu Fahrten, einschließlich Fahrzeugposition, Route und voraussichtlicher Ankunftszeit. Autorisierungstokens für den Fahrtdienst müssen im authorization Header des Tokens einen tripid:TRIP_ID Anspruch enthalten, wobei TRIP_ID die Fahrt-ID der freigegebenen On-Demand-Fahrt ist.

  • VehicleService : Stellt dem Consumer SDK Informationen zum ungefähren Standort des Fahrzeugs zur Verfügung, um die Ebene der Fahrzeugdichte anzuzeigen und die voraussichtliche Ankunftszeit am Abholort zu schätzen. Da das Consumer SDK nur ungefähre Standorte verwendet, ist für Autorisierungstokens für den Fahrzeugdienst kein vehicleid Anspruch erforderlich.

Was ist ein Token?

Für API-Methodenaufrufe aus Umgebungen mit geringem Vertrauensgrad (Smartphones und Browser) ist in der Fleet Engine die Verwendung von JSON-Webtokens (JWTs) erforderlich.

Ein JWT wird auf Ihrem Server erstellt, signiert, verschlüsselt und an den Client weitergegeben . Es wird für nachfolgende Serverinteraktionen verwendet, bis es abläuft oder nicht mehr gültig ist.

Wichtige Details

Weitere Informationen zu JSON-Webtokens finden Sie unter JSON-Webtokens in Grundlagen der Fleet Engine.

Wie erhalten Clients Tokens?

Sobald sich ein Fahrer oder Nutzer mit den entsprechenden Autorisierungsanmeldedaten in Ihrer App anmeldet, müssen alle von diesem Gerät ausgegebenen Aktualisierungen entsprechende Autorisierungstokens verwenden, die der Fleet Engine die Berechtigungen für die App mitteilen.

Als Entwickler sollte Ihre Clientimplementierung Folgendes ermöglichen:

  • Ein JSON-Webtoken von Ihrem Server abrufen.
  • Das Token verwenden, bis es abläuft, um Tokenaktualisierungen zu minimieren.
  • Das Token aktualisieren, wenn es abläuft.

Die AuthTokenFactory Klasse generiert Autorisierungstokens zum Zeitpunkt der Standortaktualisierung. Das SDK muss die Tokens mit den Aktualisierungsinformationen verpacken, um sie an die Fleet Engine zu senden. Achten Sie darauf, dass Ihre serverseitige Implementierung Tokens ausstellen kann, bevor Sie das SDK initialisieren.

Details zu den vom Fleet Engine-Dienst erwarteten Tokens finden Sie unter JSON Webtokens für die Fleet Engine ausstellen.

Beispiel für einen Abrufer von Autorisierungstokens

Das folgende Codebeispiel zeigt, wie ein Callback für Autorisierungstokens implementiert wird.

Java

class JsonAuthTokenFactory implements AuthTokenFactory {

  private static final String TOKEN_URL =
      "https://yourauthserver.example/token";

  private static class CachedToken {
    String tokenValue;
    long expiryTimeMs;
    String tripId;
  }

  private CachedToken token;

  /*

*   This method is called on a background thread. Blocking is OK. However, be
*   aware that no information can be obtained from Fleet Engine until this
*   method returns.
*/
@Override
public String getToken(AuthTokenContext context) {
  // If there is no existing token or token has expired, go get a new one.
  String tripId = context.getTripId();
  if (tripId == null) {
    throw new RuntimeException("Trip ID is missing from AuthTokenContext");
  }
  if (token == null || System.currentTimeMillis() > token.expiryTimeMs ||
      !tripId.equals(token.tripId)) {
    token = fetchNewToken(tripId);
  }
  return token.tokenValue;
}

  private static CachedToken fetchNewToken(String tripId) {
    String url = TOKEN_URL + "/" + tripId;
    CachedToken token = new CachedToken();

    try (Reader r = new InputStreamReader(new URL(url).openStream())) {
      com.google.gson.JsonObject obj
          = com.google.gson.JsonParser.parseReader(r).getAsJsonObject();

      token.tokenValue = obj.get("ServiceToken").getAsString();
      token.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 5 minutes from that time.
    */
    token.expiryTimeMs -= 5 * 60 * 1000;
  } catch (IOException e) {
    /*
    *   It's OK to throw exceptions here. The error listeners will receive the
    *   error thrown here.
    */
    throw new RuntimeException("Could not get auth token", e);
  }
  token.tripId = tripId;

    return token;
  }
}

Kotlin

class JsonAuthTokenFactory : AuthTokenFactory() {

  private var token: CachedToken? = null

  /*

*   This method is called on a background thread. Blocking is OK. However, be
*   aware that no information can be obtained from Fleet Engine until this
*   method returns.
*/
override fun getToken(context: AuthTokenContext): String {
  // If there is no existing token or token has expired, go get a new one.
  val tripId =
    context.getTripId() ?:
      throw RuntimeException("Trip ID is missing from AuthTokenContext")

    if (token == null || System.currentTimeMillis() > token.expiryTimeMs ||
        tripId != token.tripId) {
      token = fetchNewToken(tripId)
    }

    return token.tokenValue
  }

  class CachedToken(
    var tokenValue: String? = "",
    var expiryTimeMs: Long = 0,
    var tripId: String? = "",
  )

  private companion object {
    const val TOKEN_URL = "https://yourauthserver.example/token"

    fun fetchNewToken(tripId: String) {
      val url = "$TOKEN_URL/$tripId"
      val token = CachedToken()

      try {
        val reader = InputStreamReader(URL(url).openStream())

        reader.use {
          val obj = com.google.gson.JsonParser.parseReader(r).getAsJsonObject()

          token.tokenValue = obj.get("ServiceToken").getAsString()
          token.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 5 minutes from that time.
        */
        token.expiryTimeMs -= 5 * 60 * 1000
      }
    } catch (e: IOException) {
      /*
            *   It's OK to throw exceptions here. The error listeners will receive the
            *   error thrown here.
      */
      throw RuntimeException("Could not get auth token", e)
    }

      token.tripId = tripId

      return token
    }
  }
}

Nächste Schritte

Consumer SDK initialisieren