Obtenir des jetons d'autorisation

Le SDK client fournit une autorisation à l'aide de jetons Web JSON. Un jeton Web JSON (JWT) est un jeton d'autorisation qui fournit une ou plusieurs revendications sur un service.

Le SDK client utilise le jeton Web JSON fourni par l'application pour communiquer avec Fleet Engine. Pour en savoir plus sur les jetons attendus par le serveur Fleet Engine, consultez Jetons Web JSON et Émettre des jetons Web JSON.

Le jeton d'autorisation permet d'accéder aux services Fleet Engine suivants :

  • TripService : permet au SDK client d'accéder aux informations sur le trajet, y compris la position du véhicule, l'itinéraire et l'heure d'arrivée prévue. Les jetons d'autorisation pour le service de trajet doivent inclure une revendication tripid:TRIP_ID dans l'en-tête authorization du jeton, où TRIP_ID correspond à l'ID du trajet à la demande partagé.

  • VehicleService : fournit au SDK client des informations sur la position approximative du véhicule pour afficher la couche de densité des véhicules et estimer l'heure d'arrivée prévue au point de prise en charge. Étant donné que le SDK client n'utilise que des positions approximatives, les jetons d'autorisation pour le service de véhicule ne nécessitent pas de revendication vehicleid.

Qu'est-ce qu'un jeton ?

Fleet Engine nécessite l'utilisation de jetons Web JSON (JWT) pour les appels de méthode API à partir d'environnements à faible niveau de confiance : smartphones et navigateurs.

Un jeton JWT provient de votre serveur, est signé, chiffré et transmis au client pour les interactions ultérieures avec le serveur jusqu'à son expiration ou sa non-validité.

Informations essentielles

Pour en savoir plus sur les jetons Web JSON, consultez Jetons Web JSON dans Principes de base de Fleet Engine.

Comment les clients obtiennent-ils des jetons ?

Une fois qu'un chauffeur ou un consommateur se connecte à votre application à l'aide des identifiants d'autorisation appropriés, toutes les mises à jour émises à partir de cet appareil doivent utiliser des jetons d'autorisation appropriés, qui communiquent à Fleet Engine les autorisations de l'application.

En tant que développeur, l'implémentation de votre client doit permettre d'effectuer les opérations suivantes :

  • Récupérer un jeton Web JSON à partir de votre serveur.
  • Réutiliser le jeton jusqu'à son expiration pour minimiser les actualisations de jeton.
  • Actualiser le jeton lorsqu'il expire.

La classe AuthTokenFactory génère des jetons d'autorisation au moment de la mise à jour de la position. Le SDK doit regrouper les jetons avec les informations de mise à jour à envoyer à Fleet Engine. Assurez-vous que votre implémentation côté serveur peut émettre des jetons avant d'initialiser le SDK.

Pour en savoir plus sur les jetons attendus par le service Fleet Engine, consultez Émettre des jetons Web pour Fleet Engine.

Exemple de récupérateur de jetons d'autorisation

L'exemple de code suivant montre comment implémenter un rappel de jeton d'autorisation.

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

Étape suivante

Initialiser le SDK client