Co to jest token?
Fleet Engine wymaga użycia tokenów sieciowych JSON (JWT) podpisanych przez odpowiednie konto usługi do wywołań metody interfejsu API pochodzących od low-Trust . Ś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.
Więcej informacji o tokenach sieciowych JSON znajdziesz w artykule na temat tokenów sieciowych JSON w Informacje o usłudze Fleet Engine.
Jak klienci otrzymują tokeny?
Gdy kierowca lub konsument zaloguje się do Twojej aplikacji za pomocą odpowiedniego uwierzytelniania, wszystkie aktualizacje dokonywane z tego urządzenia muszą używać odpowiednie tokeny autoryzacji, które komunikują się z Fleet Engine uprawnienia aplikacji.
Jako deweloper, implementacja klienta powinna umożliwiać wykonaj te czynności:
- 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.
Protokół GMTDAuthorization
pobiera tokeny internetowe JSON podczas aktualizacji lokalizacji
na podstawie obiektu GMTD AuthorizationContext
. Pakiet SDK
musi spakować tokeny z informacjami o aktualizacji, które mają zostać wysłane do Fleet Engine.
Sprawdź, czy implementacja po stronie serwera może wydawać tokeny przed
zainicjowanie pakietu SDK.
Szczegółowe informacje o tokenach oczekiwanych przez Fleet Engine znajdziesz w sekcji Wydaj tokeny sieciowe JSON dla Fleet Engine.
Identyfikator dostawcy jest taki sam jak identyfikator projektu Twojego Google Cloud. Projekt. Informacje o konfigurowaniu projektu Google Cloud znajdziesz tutaj: Utwórz projekt Fleet Engine.
Przykład modułu pobierania tokenów uwierzytelniania
Oto przykład implementacji dostawcy tokena autoryzacji:
Swift
/*
* SampleAccessTokenProvider.swift
*/
import GoogleRidesharingConsumer
private let providerURL = "INSERT_YOUR_TOKEN_PROVIDER_URL"
class SampleAccessTokenProvider: NSObject, GMTCAuthorization {
private struct AuthToken {
// The cached trip token.
let token: String
// Keep track of when the token expires for caching.
let expiration: TimeInterval
// Keep track of the trip ID the cached token is for.
let tripID: String
}
enum AccessTokenError: Error {
case missingAuthorizationContext
case missingData
}
private var authToken: AuthToken?
func fetchToken(
with authorizationContext: GMTCAuthorizationContext?,
completion: @escaping GMTCAuthTokenFetchCompletionHandler
) {
// Get the trip ID from the authorizationContext. This is set by the Consumer SDK.
guard let authorizationContext = authorizationContext else {
completion(nil, AccessTokenError.missingAuthorizationContext)
return
}
let tripID = authorizationContext.tripID
// If appropriate, use the cached token.
if let authToken = authToken,
authToken.expiration > Date.now.timeIntervalSince1970 && authToken.tripID == tripID
{
completion(authToken.token, nil)
return
}
// Otherwise, try to fetch a new token from your server.
let request = URLRequest(url: URL(string: providerURL))
let task = URLSession.shared.dataTask(with: request) { [weak self] data, _, error in
guard let strongSelf = self else { return }
guard error == nil else {
completion(nil, error)
return
}
// Replace the following key values with the appropriate keys based on your
// server's expected response.
let tripTokenKey = "TRIP_TOKEN_KEY"
let tokenExpirationKey = "TOKEN_EXPIRATION"
guard let data = data,
let fetchData = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
let token = fetchData[tripTokenKey] as? String,
let expiration = fetchData[tokenExpirationKey] as? Double
else {
completion(nil, AccessTokenError.missingData)
return
}
strongSelf.authToken = AuthToken(token: token, expiration: expiration, tripID: tripID)
completion(token, nil)
}
task.resume()
}
}
Objective-C
/*
* SampleAccessTokenProvider.h
*/
#import <Foundation/Foundation.h>
#import <GoogleRidesharingConsumer/GoogleRidesharingConsumer.h>
NS_ASSUME_NONNULL_BEGIN
@interface SampleAccessTokenProvider : NSObject <GMTCAuthorization>
@end
NS_ASSUME_NONNULL_END
/*
* SampleAccessTokenProvider.m
*/
#import "SampleAccessTokenProvider.h"
#import "GoogleRidesharingConsumer/GoogleRidesharingConsumer.h"
static NSString *const PROVIDER_URL = @"INSERT_YOUR_TOKEN_PROVIDER_URL";
// SampleAccessTokenProvider.m
@implementation SampleAccessTokenProvider {
// The cached token with claims to the current trip.
NSString *_cachedTripToken;
// Keep track of the Trip ID the cached token is for.
NSString *_lastKnownTripID;
// Keep track of when tokens expire for caching.
NSTimeInterval _tokenExpiration;
}
- (void)fetchTokenWithContext:(nullable GMTCAuthorizationContext *)authorizationContext
completion:(nonnull GMTCAuthTokenFetchCompletionHandler)completion {
// Get the trip ID from the authorizationContext. This is set by the Consumer SDK.
NSString *tripID = authorizationContext.tripID;
// Clear cached trip token if trip ID has changed.
if (![_lastKnownTripID isEqual:tripID]) {
_tokenExpiration = 0.0;
_cachedTripToken = nil;
}
_lastKnownTripID = tripID;
// Clear cached tripToken if it has expired.
if ([[NSDate date] timeIntervalSince1970] > _tokenExpiration) {
_cachedTripToken = nil;
}
// If appropriate, use the cached token.
if (_cachedTripToken) {
completion(_cachedTripToken, nil);
return;
}
// Otherwise, try to fetch a new token from your server.
NSURL *requestURL = [NSURL URLWithString:PROVIDER_URL];
NSMutableURLRequest *request =
[[NSMutableURLRequest alloc] initWithURL:requestURL];
request.HTTPMethod = @"GET";
// Replace the following key values with the appropriate keys based on your
// server's expected response.
NSString *tripTokenKey = @"TRIP_TOKEN_KEY";
NSString *tokenExpirationKey = @"TOKEN_EXPIRATION";
__weak typeof(self) weakSelf = self;
void (^handler)(NSData *_Nullable data, NSURLResponse *_Nullable response,
NSError *_Nullable error) =
^(NSData *_Nullable data, NSURLResponse *_Nullable response, NSError *_Nullable error) {
typeof(self) strongSelf = weakSelf;
if (error) {
completion(nil, error);
return;
}
NSError *JSONError;
NSMutableDictionary *JSONResponse =
[NSJSONSerialization JSONObjectWithData:data options:kNilOptions error:&JSONError];
if (JSONError) {
completion(nil, JSONError);
return;
} else {
// Sample code only. No validation logic.
id expirationData = JSONResponse[tokenExpirationKey];
if ([expirationData isKindOfClass:[NSNumber class]]) {
NSTimeInterval expirationTime = ((NSNumber *)expirationData).doubleValue;
strongSelf->_tokenExpiration = [[NSDate date] timeIntervalSince1970] + expirationTime;
}
strongSelf->_cachedTripToken = JSONResponse[tripTokenKey];
completion(JSONResponse[tripTokenKey], nil);
}
};
NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
NSURLSession *mainQueueURLSession =
[NSURLSession sessionWithConfiguration:config delegate:nil
delegateQueue:[NSOperationQueue mainQueue]];
NSURLSessionDataTask *task = [mainQueueURLSession dataTaskWithRequest:request completionHandler:handler];
[task resume];
}
@end