O SDK do consumidor oferece autorização usando JSON Web Tokens. Um token da Web JSON (JWT) é um token de autorização que fornece uma ou mais declarações em um serviço.
O SDK do consumidor usa o JSON Web Token fornecido pelo aplicativo para se comunicar com o Fleet Engine. Para detalhes dos tokens esperados pelo servidor do Fleet Engine, consulte JSON Web Tokens e Emitir tokens JSON da Web.
O token de autorização fornece acesso aos seguintes serviços do Fleet Engine:
TripService: dá ao SDK do consumidor acesso a detalhes da viagem, incluindo posição do veículo, trajeto e HEC. Os tokens de autorização para o serviço de viagem precisam incluir uma declaraçãotripid:TRIP_IDno cabeçalhoauthorizationdo token, em queTRIP_IDé o ID da viagem sob demanda que está sendo compartilhada.VehicleService: fornece ao SDK do consumidor informações sobre a localização aproximada do veículo para exibir a camada de densidade do veículo e estimar os horários de chegada do ponto de retirada. Como o SDK do consumidor usa apenas locais aproximados, os tokens de autorização para o serviço de veículos não exigem uma declaraçãovehicleid.
O que é um token?
Para chamadas de método de API de ambientes de baixa confiança, o Fleet Engine exige o uso de JSON Web Tokens (JWTs) assinados por uma conta de serviço apropriada. Os ambientes de baixa confiança incluem smartphones e navegadores. Um JWT é originado no seu servidor, que é um ambiente totalmente confiável. O JWT é assinado, criptografado e transmitido ao cliente para interações posteriores do servidor até expirar ou deixar de ser válido.
O back-end precisa autenticar e autorizar o Fleet Engine usando mecanismos padrão de credenciais padrão do aplicativo. Use JWTs assinados por uma conta de serviço adequada. Para uma lista de papéis da conta de serviço, consulte os papéis da conta de serviço do Fleet Engine em Noções básicas do mecanismo de frota.
Por outro lado, o back-end precisa se autenticar e autorizar no Fleet Engine usando mecanismos padrão do Application Default Credentials.
Para mais informações sobre JSON Web Tokens, consulte JSON Web Tokens em Fleet Engine Essentials.
Como os clientes recebem tokens?
Depois que um motorista ou consumidor faz login no seu app usando as credenciais de autorização adequadas, todas as atualizações emitidas desse dispositivo precisam usar tokens de autorização apropriados, que comunicam ao Fleet Engine as permissões do app.
Como desenvolvedor, a implementação do seu cliente precisa fornecer a capacidade de fazer o seguinte:
- Busque um JSON Web Token no servidor.
- Reutilize o token até que ele expire para minimizar as atualizações.
- Atualize o token quando ele expirar.
A classe AuthTokenFactory gera tokens de autorização no momento da atualização
do local. O SDK precisa empacotar os tokens com as informações de atualização para enviar ao Fleet Engine. Verifique se a implementação
do lado do servidor pode emitir tokens antes de inicializar o SDK.
Para detalhes sobre os tokens esperados pelo serviço do Fleet Engine, consulte Emitir tokens da Web JSON para o Fleet Engine.
Exemplo de um coletor de tokens de autorização
O exemplo de código a seguir demonstra como implementar um callback de token de autorização.
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
}
}
}