Uzyskaj tokeny autoryzacji

Pakiet SDK klienta umożliwia autoryzację przy użyciu tokenów sieciowych JSON. Token internetowy JSON (JWT) to token autoryzacji, który udostępnia co najmniej 1 żądanie usługi.

Pakiet SDK dla klientów indywidualnych używa tokena internetowego JSON udostępnionego przez aplikację do komunikują się z Fleet Engine. Szczegółowe informacje o tokenach oczekiwanych przez Serwer Fleet Engine zawiera informacje na temat tokenów sieciowych JSON i Wydaj tokeny internetowe JSON.

Token autoryzacji zapewnia dostęp do tych usług Fleet Engine:

  • TripService – daje pakietowi SDK klienta dostęp do szczegółów podróży, w tym do pozycji pojazdu, trasy i szacowanego czasu dotarcia na miejsce. Tokeny autoryzacji dla usługi wycieczki musi zawierać deklarację tripid:TRIP_ID w nagłówku authorization tokena, gdzie TRIP_ID to identyfikator udostępnianej podróży na żądanie.

  • VehicleService – przekazuje pakietowi SDK klienta informacje o przybliżone położenie pojazdu na potrzeby wyświetlania warstwy gęstości pojazdu szacowanie czasu dotarcia na miejsce. Ponieważ pakiet SDK dla klientów indywidualnych używa tylko wartości lokalizacji, tokeny autoryzacji do obsługi pojazdów nie wymagają vehicleid roszczenie.

Co to jest token?

W przypadku wywołań metod interfejsu API ze środowisk o niskim poziomie zaufania Fleet Engine wymaga: użycie tokenów sieciowych JSON (JWT) podpisanych przez odpowiednie konto usługi. Środowiska o niskim stopniu zaufania to m.in. smartfony i przeglądarki. Token JWT zaczyna się na serwerze, który jest w pełni zaufanym środowiskiem. Token JWT jest podpisany, zaszyfrowany i przekazywany do klienta w celu kolejnego serwera. do momentu ich wygaśnięcia lub utraty ważności.

Twój backend powinien uwierzytelniać się i autoryzować we Fleet Engine za pomocą standardowych domyślnych danych logowania aplikacji. Marka używaj tokenów JWT, które zostały podpisane przez odpowiednie konto usługi. Dla lista ról konta usługi, zobacz role konta usługi Fleet Engine w artykule Podstawy floty.

W przeciwieństwie do tego Twój backend powinien się uwierzytelniać i autoryzować za pomocą Fleet Engine. przy użyciu standardowych domyślnych danych logowania aplikacji. i zbierania danych.

Więcej informacji o tokenach sieciowych JSON znajdziesz w artykule na temat tokenów sieciowych JSON w Informacje o usłudze Fleet Engine.

W jaki sposób klienci otrzymują tokeny?

Gdy kierowca lub konsument zaloguje się do Twojej aplikacji za pomocą odpowiedniego uwierzytelniania, wszystkie aktualizacje wydane z tego urządzenia muszą używać odpowiednie tokeny autoryzacji, które komunikują się z Fleet Engine uprawnienia aplikacji.

Implementacja u dewelopera powinna umożliwiać następujące:

  • Pobierz token sieciowy JSON z serwera.
  • Aby zminimalizować częstotliwość odświeżania tokenów, używaj tokena do momentu jego wygaśnięcia.
  • Odśwież token po jego wygaśnięciu.

Klasa AuthTokenFactory generuje tokeny autoryzacji przy aktualizacji lokalizacji obecnie się znajdujesz. Pakiet SDK musi zawierać tokeny z informacjami o aktualizacji, które mają zostać wysłane do Fleet Engine. Upewnij się, że po stronie serwera może wysyłać tokeny przed zainicjowaniem pakietu SDK.

Szczegółowe informacje o tokenach oczekiwanych przez usługę Fleet Engine znajdziesz w artykule o wysyłaniu kodu JSON w formacie JSON Tokeny sieciowe dla Fleet Engine.

Przykład modułu pobierania tokenów autoryzacji

Poniższy przykładowy kod pokazuje, jak wdrożyć token autoryzacji oddzwanianie.

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

Co dalej?

Inicjowanie pakietu SDK klienta