קבלת אסימוני הרשאה

מה זה אסימון?

ב-Fleet Engine נדרש להשתמש ב-JSON Web Tokens (אסימוני JWT) חתומים על ידי חשבון שירות מתאים לקריאות לשיטה של API מרמת אמון נמוכה של סביבות. סביבות עם רמת אמון נמוכה כוללות סמארטפונים ודפדפנים. JWT נוצר בשרת שלכם, שהוא סביבה מהימנה לגמרי. ה-JWT חתום, מוצפן ומועבר ללקוח עבור השרת הבא אינטראקציות עד שהתוקף שלהן פג או שהוא לא בתוקף.

הקצה העורפי שלך צריך לבצע אימות ואישור מול Fleet Engine באמצעות המנגנונים הרגילים של Application Default Credentials. יצרן להשתמש באסימוני JWT שחתמו על ידי חשבון שירות מתאים. עבור לרשימת תפקידי חשבון השירות, ראו התפקידים בחשבון שירות ב-Fleet Engine במאמר Fleet Engine Basics.

מידע נוסף על אסימוני אינטרנט JSON זמין במאמר JSON Web Tokens ב- היסודות של כלל ה-Fleet Engine.

איך הלקוחות מקבלים אסימונים?

אחרי שנהג או צרכן מתחברים לאפליקציה באמצעות פרטי כניסה לאימות, בכל עדכון שמונפקים מהמכשיר הזה יש להשתמש אסימוני הרשאה מתאימים, שמעבירים ל-Fleet Engine את הרשאות לאפליקציה.

כמפתח, הטמעת הלקוח שלך אמורה לספק יכולת לבצע את הפעולות הבאות:

• יש לאחזר אסימון אינטרנט מסוג JSON מהשרת שלך.
• כדי למזער את פעולות הרענון של האסימון, משתמשים שוב באסימון עד שהתוקף שלו יפוג.
• צריך לרענן את האסימון כשהתוקף שלו יפוג.

הפרוטוקול GMTDAuthorization מאחזר אסימוני אינטרנט מסוג JSON בזמן עדכון המיקום על סמך האובייקט GMTD AuthorizationContext. ה-SDK חייבים לארוז את האסימונים עם פרטי העדכון כדי לשלוח אותם אל Fleet Engine. עליכם לוודא שההטמעה בצד השרת יכולה להנפיק אסימונים לפני באתחול ה-SDK.

פרטים על האסימונים הצפויים על ידי Fleet Engine אפשר למצוא בכתובת שליחת אסימוני אינטרנט JSON ל-Fleet Engine.

ה-providerID זהה ל-Project ID של Google Cloud פרויקט. למידע על הגדרת הפרויקט ב-Google Cloud, אפשר לעיין במאמר הבא: יוצרים פרויקט ב-Fleet Engine.

דוגמה לכלי לאחזור אסימון אימות

בדוגמה הבאה מוצג הטמעה של GMTDAuthorization. של Google.

Swift

import GoogleRidesharingDriver

private let providerURL = "INSERT_YOUR_TOKEN_PROVIDER_URL"

class SampleAccessTokenProvider: NSObject, GMTDAuthorization {
  private struct AuthToken {
    // The cached vehicle token.
    let token: String
    // Keep track of when the token expires for caching.
    let expiration: TimeInterval
    // Keep track of the vehicle ID the cached token is for.
    let vehicleID: String
  }

  enum AccessTokenError: Error {
    case missingAuthorizationContext
    case missingData
  }

  private var authToken: AuthToken?

  func fetchToken(
    with authorizationContext: GMTDAuthorizationContext?,
    completion: @escaping GMTDAuthTokenFetchCompletionHandler
  ) {
    // Get the vehicle ID from the authorizationContext. This is set by the Driver SDK.
    guard let authorizationContext = authorizationContext else {
      completion(nil, AccessTokenError.missingAuthorizationContext)
      return
    }
    let vehicleID = authorizationContext.vehicleID

    // If appropriate, use the cached token.
    if let authToken = authToken,
      authToken.expiration > Date.now.timeIntervalSince1970 && authToken.vehicleID == vehicleID
    {
      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 vehicleTokenKey = "VEHICLE_TOKEN_KEY"
      let tokenExpirationKey = "TOKEN_EXPIRATION"
      guard let data = data,
        let fetchData = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
        let token = fetchData[vehicleTokenKey] as? String,
        let expiration = fetchData[tokenExpirationKey] as? Double
      else {
        completion(nil, AccessTokenError.missingData)
        return
      }

      strongSelf.authToken = AuthToken(
        token: token, expiration: expiration, vehicleID: vehicleID)
      completion(token, nil)
    }
    task.resume()
  }
}

Objective-C

#import "SampleAccessTokenProvider.h"
#import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>

// SampleAccessTokenProvider.h
@interface SampleAccessTokenProvider : NSObject<GMTDAuthorization>
@end

static NSString *const PROVIDER_URL = @"INSERT_YOUR_TOKEN_PROVIDER_URL";

// SampleAccessTokenProvider.m
@implementation SampleAccessTokenProvider{
  // The cached vehicle token.
  NSString *_cachedVehicleToken;
  // Keep track of the vehicle ID the cached token is for.
  NSString *_lastKnownVehicleID;
  // Keep track of when tokens expire for caching.
  NSTimeInterval _tokenExpiration;
}

-   (void)fetchTokenWithContext:(nullable GMTDAuthorizationContext *)authorizationContext
                   completion:(nonnull GMTDAuthTokenFetchCompletionHandler)completion {

  if (!completion) {
   NSAssert(NO, @"%s encountered an unexpected nil completion.", __PRETTY_FUNCTION__);
   return;
  }

  // Get the vehicle ID from the authorizationContext. This is set by the Driver SDK.
  NSString *vehicleID = authorizationContext.vehicleID;
  if (!vehicleID) {
    NSAssert(NO, @"Vehicle ID is missing from authorizationContext.");
    return;
  }

  // Clear cached vehicle token if vehicle ID has changed.
  if (![_lastKnownVehicleID isEqual:vehicleID]) {
    _tokenExpiration = 0.0;
    _cachedVehicleToken = nil;
  }
  _lastKnownVehicleID = vehicleID;

  // Clear cached vehicletoken if it has expired.
  if ([[NSDate date] timeIntervalSince1970] > _tokenExpiration) {
    _cachedVehicleToken = nil;
  }

  // If appropriate, use the cached token.
  if (_cachedVehicleToken) {
    completion(_cachedVehicleToken, 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 *vehicleTokenKey = @"VEHICLE_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->_cachedVehicleToken = JSONResponse[vehicleTokenKey];
          completion(JSONResponse[vehicleTokenKey], 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

המאמרים הבאים

הפעלת ה-SDK של מנהל התקן