Autorisierungstokens abrufen

Das Consumer SDK bietet Autorisierungen mithilfe von JSON Web Tokens. Ein JSON-Webtoken (JWT) ist ein Autorisierungstoken, das eine oder mehrere Anforderungen für einen Dienst bereitstellt.

Das Consumer SDK verwendet das von der Anwendung bereitgestellte JSON Web Token, um mit der Fleet Engine zu kommunizieren. Einzelheiten zu den vom Fleet Engine-Server, siehe JSON Web Tokens und Ausstellen von JSON-Webtokens.

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

  • TripService: Gewährt dem Consumer SDK Zugriff auf Fahrtdetails, einschließlich Fahrzeugposition, Route und voraussichtliche Ankunftszeit. Autorisierungstokens für den Fahrdienst muss eine tripid:TRIP_ID-Anforderung im authorization-Header des Tokens enthalten. Dabei ist TRIP_ID die Fahrt-ID der On-Demand-Fahrt, die geteilt wird.

  • VehicleService: Bietet dem Consumer SDK Informationen zum ungefähren Standort des Fahrzeugs, um die Fahrzeugdichteebene anzuzeigen und die geschätzte Ankunftszeit am Abholpunkt zu ermitteln. Da das Consumer SDK nur ungefähre für den Fahrzeugservice erfordern keine Autorisierungstokens vehicleid Anspruch.

Was ist ein Token?

Für API-Methodenaufrufe aus Low-Trust-Umgebungen benötigt Fleet Engine Verwendung von JSON-Webtokens (JWTs), die von einem entsprechenden Dienstkonto signiert wurden. Zu den Umgebungen mit wenig Vertrauen gehören Smartphones und Browser. Ein JWT stammt von Ihrem Server, einer voll vertrauenswürdigen Umgebung. Das JWT wird signiert, verschlüsselt und an den Client für den nachfolgenden Server übergeben. Interaktionen, bis sie abläuft oder nicht mehr gültig ist.

Ihr Backend sollte sich mit der folgenden Methode bei Fleet Engine authentifizieren und autorisieren Standardmechanismen für Standardanmeldedaten für Anwendungen. Marke Verwenden Sie JWTs, die von einem entsprechenden Dienstkonto signiert wurden. Für eine Eine Liste der Dienstkontorollen finden Sie unter Fleet Engine-Dienstkontorollen. in Fleet Engine-Grundlagen.

Im Gegensatz dazu sollte sich Ihr Backend bei Fleet Engine authentifizieren und autorisieren mit standardmäßigen Standardanmeldedaten für Anwendungen Mechanismen.

Weitere Informationen zu JSON Web Tokens finden Sie unter JSON Web Tokens in Fleet Engine Essentials.

Wie erhalten Clients Tokens?

Sobald sich ein Treiber oder Nutzer mit der entsprechenden müssen alle Updates, die von diesem Gerät ausgehen, entsprechende Autorisierungstokens, die mit Fleet Engine Berechtigungen für die App.

Als Entwickler sollte Ihre Client-Implementierung die Möglichkeit bieten, Folgendes:

  • Rufen Sie ein JSON Web Token von Ihrem Server ab.
  • Verwenden Sie das Token wieder, bis es abläuft, um Tokenaktualisierungen zu minimieren.
  • Aktualisieren Sie das Token, wenn es abläuft.

Die Klasse AuthTokenFactory generiert Autorisierungstokens bei der Standortaktualisierung . Das SDK muss die Tokens mit dem Update verpacken an Fleet Engine zu senden. Achten Sie darauf, dass Ihre serverseitige Implementierung von Tokens vor der Initialisierung des SDK Tokens ausgeben.

Weitere Informationen zu den vom Fleet Engine-Dienst erwarteten Tokens finden Sie unter Problem mit JSON Web Tokens für Fleet Engine.

Beispiel für einen Abruf von Autorisierungstokens

Im folgenden Codebeispiel wird gezeigt, wie ein Autorisierungstoken implementiert wird. Callback des Nutzers an.

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