Obtener tokens de autorización

El SDK para consumidores proporciona autorización mediante tokens web JSON. Un token web JSON (JWT) es un token de autorización que proporciona una o más reclamaciones sobre un servicio.

El SDK de consumidor usa el token web JSON proporcionado por la aplicación para comunicarse con Fleet Engine. Para obtener más información sobre los tokens esperados por el Servidor de Fleet Engine, consulta Tokens web de JSON y emitir tokens web JSON.

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

• TripService: Le otorga al SDK del consumidor acceso a los detalles del viaje, lo que incluye lo siguiente: la posición del vehículo, la ruta y la hora de llegada estimada. Tokens de autorización para el servicio de viajes debe incluir una reclamación tripid:TRIP_ID en el encabezado authorization del token. donde TRIP_ID es el ID del viaje a pedido que se comparte.

• VehicleService: Proporciona al SDK del consumidor información sobre el ubicación aproximada del vehículo para mostrar la capa de densidad del vehículo y que estima las horas de llegada estimadas del punto de partida. Debido a que el SDK del consumidor solo usa valores los tokens de autorización del servicio vehicular no requieren una vehicleid reclamo.

¿Qué es un token?

Fleet Engine requiere el uso de tokens web JSON (JWT) firmados por un cuenta de servicio adecuada para las llamadas de método a la API desde modelos de entornos de desarrollo de software. Los entornos de baja confianza incluyen smartphones y navegadores. Un JWT Se origina en tu servidor, que es un entorno completamente confiable. El token JWT se firma, se encripta y se pasa al cliente para la posterior interacciones hasta que caduque o deje de ser válida.

Tu backend debe autenticarse y autorizarse contra Fleet Engine usando mecanismos estándar de credenciales predeterminadas de la aplicación. Marca asegúrate de usar JWT firmados con la cuenta de servicio correspondiente. Para un lista de los roles de la cuenta de servicio; consulta los roles de la cuenta de servicio de Flet Engine en Aspectos básicos de Flet Engine.

Para obtener más información sobre los tokens web JSON, consulta Tokens web JSON en Aspectos esenciales de Flet Engine.

¿Cómo obtienen tokens los clientes?

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

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

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

La clase AuthTokenFactory genera tokens de autorización durante la actualización de la ubicación. tiempo. El SDK debe empaquetar los tokens con la actualización para enviar a Fleet Engine. Asegúrate de que la configuración del servidor puede emitir tokens antes de inicializar el SDK.

Para obtener más información sobre los tokens que espera el servicio de Fleet Engine, consulta el problema de JSON Tokens web para Fleet Engine.

Ejemplo de un recuperador de tokens de autorización

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

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

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 del consumidor