Erste Schritte mit dem Driver SDK für iOS

Das Driver SDK ist eine Bibliothek, die Sie in Ihre Treiber-App einbinden können. Damit wird Fleet Engine mit Fahrzeugstandort, Route, verbleibende Entfernung und voraussichtliche Ankunftszeit aktualisiert. Er lässt sich auch in das Navigation SDK einbinden, das dem Fahrer eine detaillierte Routenführung bietet.

Mindestsystemanforderungen

Voraussetzungen

In dieser Anleitung wird davon ausgegangen, dass das Navigation SDK in Ihrer Anwendung bereits implementiert ist und das Fleet Engine-Back-End eingerichtet und verfügbar ist. Der Beispielcode enthält jedoch ein Beispiel für die Einrichtung des Navigation SDK.

Außerdem müssen Sie das Maps SDK for iOS in Ihrem Google Cloud-Projekt aktivieren und API-Schlüssel abrufen.

Zugriff erhalten

Wenn Sie Google Workspace-Kunde sind, erstellen Sie beim Onboarding eine Arbeitsbereichsgruppe wie google-maps-platform-sdk-users@workspacedomain.com und teilen Sie Google den Namen mit. Dies ist der empfohlene Ansatz. Ihre Arbeitsbereichsgruppe wird dann einer Zulassungsliste hinzugefügt, die Zugriff auf die richtigen CocoaPods-Repositories gewährt. Prüfen Sie, ob die E-Mail-Adressen der Nutzer und Dienstkonten, die Zugriff benötigen, in dieser Liste enthalten sind.

Wenn Ihre Organisation keine Workspace-Gruppen erstellen kann, senden Sie eine Liste der Nutzer- und Dienstkonto-E-Mail-Adressen, die Zugriff auf diese Artefakte benötigen, an Google.

Lokale Entwicklung

Für die lokale Entwicklung reicht es aus, sich mit dem Cloud SDK anzumelden.

gcloud auth login

Die für die Anmeldung verwendete E-Mail-Adresse muss Mitglied der Workspace-Gruppe sein.

Automatisierung (Systeme erstellen oder kontinuierliche Integration)

Richten Sie Automatisierungshosts gemäß den Best Practices ein:

• Wenn Ihr Prozess in einer Google Cloud-Umgebung ausgeführt wird, verwenden Sie die automatische Erkennung von Anmeldedaten.

• Speichern Sie andernfalls die Dienstkonto-Schlüsseldatei an einem sicheren Ort im Dateisystem des Hosts und legen Sie die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS entsprechend fest.

Die mit den Anmeldedaten verknüpfte E-Mail-Adresse des Dienstkontos muss Mitglied der Arbeitsbereichsgruppe sein.

Projektkonfiguration

Sie können das Treiber-SDK für iOS mithilfe von CocoaPods oder manuell konfigurieren.

Apple Privacy Manifest-Datei prüfen

Apple verlangt, dass für Apps im App Store Details zum App-Datenschutz angegeben werden. Aktuelle Informationen und weitere Informationen finden Sie auf der Seite zu Datenschutzdetails im Apple App Store.

Die Apple Privacy Manifest-Datei ist im Ressourcenpaket für das SDK enthalten. Wenn Sie prüfen möchten, ob die Privacy Manifest-Datei enthalten ist, und ihren Inhalt prüfen möchten, erstellen Sie ein Archiv Ihrer App und generieren Sie aus dem Archiv einen Datenschutzbericht.

Autorisierung und Authentifizierung implementieren

Wenn Ihre Treiber-App Aktualisierungen generiert und an das Fleet Engine-Back-End sendet, müssen die Anfragen gültige Zugriffstokens enthalten. Zum Autorisieren und Authentifizieren dieser Anfragen ruft das Driver SDK Ihr Objekt in Übereinstimmung mit dem GMTDAuthorization-Protokoll auf. Das -Objekt ist für die Bereitstellung des erforderlichen Zugriffstokens verantwortlich.

Als App-Entwickler entscheiden Sie, wie Tokens generiert werden. Ihre Implementierung sollte Folgendes ermöglichen:

• Rufen Sie ein Zugriffstoken im JSON-Format von einem HTTPS-Server ab.
• Parsen Sie das Token und speichern Sie es im Cache.
• Aktualisieren Sie das Token, wenn es abläuft.

Weitere Informationen zu den vom Fleet Engine-Server erwarteten Tokens finden Sie unter JSON Web Token (JWT) zur Autorisierung erstellen.

Die Anbieter-ID ist mit der Google Cloud-Projekt-ID identisch. Weitere Informationen finden Sie im Nutzerhandbuch der Fleet Engine Deliveries API.

Im folgenden Beispiel wird ein Zugriffstokenanbieter implementiert:

#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 vehicle token 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

DeliveryDriverAPI-Instanz erstellen

Zum Abrufen einer GMTDDeliveryVehicleReporter-Instanz müssen Sie zuerst eine GMTDDeliveryDriverAPI-Instanz mit providerID, vehicleID, driverContext und accessTokenProvider erstellen. providerID ist mit der Google Cloud-Projekt-ID identisch. Außerdem können Sie direkt über die Treiber-API auf die GMTDDeliveryVehicleReporter-Instanz zugreifen.

Im folgenden Beispiel wird eine GMTDDeliveryDriverAPI-Instanz erstellt:

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

static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";

@implementation SampleViewController {
 GMSMapView *_mapView;
}

- (void)viewDidLoad {
  NSString *vehicleID = @"INSERT_CREATED_VEHICLE_ID";
  SampleAccessTokenProvider *accessTokenProvider = 
                                [[SampleAccessTokenProvider alloc] init];
  GMTDDriverContext *driverContext = 
     [[GMTDDriverContext alloc] initWithAccessTokenProvider:accessTokenProvider
                                                 providerID:PROVIDER_ID 
                                              vehicleID:vehicleID 
      navigator:_mapView.navigator];

  GMTDDeliveryDriverAPI *deliveryDriverAPI = [[GMTDDeliveryDriverAPI alloc] initWithDriverContext:driverContext];
}

Optional auf VehicleReporter-Ereignisse warten

GMTDDeliveryVehicleReporter aktualisiert das Fahrzeug regelmäßig, wenn locationTrackingEnabled auf YES (JA) gesetzt ist. Um auf diese regelmäßigen Aktualisierungen zu reagieren, kann jedes Objekt GMTDDeliveryVehicleReporter-Ereignisse abonnieren, wenn es dem GMTDVehicleReporterListener-Protokoll entspricht.

Sie können die folgenden Ereignisse verarbeiten:

• vehicleReporter:didSucceedVehicleUpdate

  Informiert die Fahrer-App darüber, dass die Back-End-Dienste den Standort und Status des Fahrzeugs erfolgreich empfangen haben.

• vehicleReporter:didFailVehicleUpdate:withError

  Informiert den Listener, dass ein Fahrzeugupdate fehlgeschlagen ist. Solange das Standort-Tracking aktiviert ist, sendet GMTDDeliveryVehicleReporter weiterhin die neuesten Daten an das Fleet Engine-Back-End.

Im folgenden Beispiel werden diese Ereignisse verarbeitet:

SampleViewController.h
@interface SampleViewController : UIViewController<GMTDVehicleReporterListener>
@end

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

static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";

@implementation SampleViewController {
 GMSMapView *_mapView;
}

- (void)viewDidLoad {
  // ASSUMES YOU IMPLEMENTED HAVE THE SAMPLE CODE UP TO THIS STEP.
  [ridesharingDriverAPI.vehicleReporter addListener:self];
}

- (void)vehicleReporter:(GMTDDeliveryVehicleReporter *)vehicleReporter didSucceedVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate {
  // Handle update succeeded.
}

- (void)vehicleReporter:(GMTDDeliveryVehicleReporter *)vehicleReporter didFailVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate withError:(NSError *)error {
  // Handle update failed.
}

@end

Standortermittlung aktivieren

Um das Standort-Tracking zu aktivieren, kann deine App locationTrackingEnabled auf GMTDDeliveryVehicleReporter auf YES setzen. Anschließend sendet GMTDDeliveryVehicleReporter automatisch Standortaktualisierungen. Wenn sich GMSNavigator im Navigationsmodus befindet (wenn ein Ziel über setDestinations festgelegt wurde) und locationTrackingEnabled auf YES gesetzt ist, sendet GMTDDeliveryVehicleReporter automatisch auch Aktualisierungen der Route und der voraussichtlichen Ankunftszeit.

Die dabei festgelegte Route ist dieselbe, die der Fahrer während der Navigation verwendet. Damit das Flotten-Tracking ordnungsgemäß funktioniert, sollte der über -setDestinations:callback: festgelegte Wegpunkt mit dem Ziel im Fleet Engine-Back-End übereinstimmen.

Im folgenden Beispiel wird die Standortermittlung aktiviert:

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

static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";

@implementation SampleViewController {
 GMSMapView *_mapView; 
}

- (void)viewDidLoad {
  // ASSUMES YOU IMPLEMENTED HAVE THE SAMPLE CODE UP TO THIS STEP.
  deliveryDriverAPI.vehicleReporter.locationTrackingEnabled = YES;
}

@end

Standardmäßig beträgt das Berichtsintervall 10 Sekunden, das Berichtsintervall kann jedoch mit locationUpdateInterval geändert werden. Das unterstützte Mindestaktualisierungsintervall beträgt 5 Sekunden. Das maximal unterstützte Aktualisierungsintervall beträgt 60 Sekunden. Häufigere Aktualisierungen können zu langsameren Anfragen und Fehlern führen.

Standortaktualisierungen deaktivieren und Fahrzeug offline stellen

Deine App kann Standortupdates für ein Fahrzeug deaktivieren. Wenn beispielsweise die Schicht eines Fahrers endet, kann Ihre App locationTrackingEnabled auf NO setzen.

  _vehicleReporter.locationTrackingEnabled = NO