Obtener tokens de autorización

El SDK de Consumer proporciona autorización con tokens web JSON. Un token web JSON (JWT) es un token de autorización que proporciona uno o más reclamos en un servicio.

El SDK para el consumidor usa el token web JSON que proporciona la aplicación para comunicarse con Fleet Engine. Para obtener detalles sobre los tokens que espera el servidor de Fleet Engine, consulta Tokens web JSON y Cómo emitir tokens web JSON.

El token de autorización proporciona acceso a los siguientes servicios de Fleet Engine:

  • TripService: Otorga al SDK de Consumer acceso a los detalles del viaje, como la posición del vehículo, la ruta y la ETA. Los tokens de autorización para el servicio de viajes deben incluir una reclamación tripid:TRIP_ID en el encabezado authorization del token, en el que TRIP_ID es el ID del viaje a pedido que se comparte.

  • VehicleService: Proporciona al SDK de Consumer información sobre la ubicación aproximada del vehículo para mostrar la capa de densidad de vehículos y estimar las ETA de los puntos de partida. Dado que el SDK de Consumer solo usa ubicaciones aproximadas, los tokens de autorización para el servicio de vehículos no requieren un reclamo de vehicleid.

¿Qué es un token?

Fleet Engine requiere el uso de tokens web JSON (JWT) para las llamadas a métodos de la API desde entornos de baja confianza: smartphones y navegadores.

Un JWT se origina en tu servidor, se firma, se encripta y se pasa al cliente para las interacciones posteriores del servidor hasta que vence o ya no es válido.

Detalles clave

Para obtener más información sobre los tokens web JSON, consulta Tokens web JSON en Conceptos básicos de Fleet Engine.

¿Cómo obtienen tokens los clientes?

Una vez que un conductor o consumidor accede a tu app con las credenciales de autorización adecuadas, todas las actualizaciones que se emitan desde ese dispositivo deben usar los tokens de autorización adecuados, que comunican a Fleet Engine los permisos de la app.

Como desarrollador, la implementación del cliente debe proporcionar la capacidad de hacer lo siguiente:

  • Recupera un token web JSON de tu servidor.
  • Reutiliza el token hasta que venza para minimizar las actualizaciones de tokens.
  • Actualiza el token cuando venza.

La clase AuthTokenFactory genera tokens de autorización en el momento de la actualización de la ubicación. El SDK debe empaquetar los tokens con la información de actualización para enviarlos a Fleet Engine. Asegúrate de que tu implementación del servidor pueda emitir tokens antes de inicializar el SDK.

Para obtener detalles sobre los tokens que espera el servicio de Fleet Engine, consulta Cómo emitir tokens web JSON para Fleet Engine.

Ejemplo de un buscador de tokens de autorización

En el siguiente ejemplo de código, se muestra cómo implementar una devolución de llamada de token de autorización.

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

¿Qué sigue?

Inicializa el SDK de Consumer