On-Demand-Lösungen für Fahrten und Lieferungen sind derzeit nur für ausgewählte Partner verfügbar.

Erste Schritte mit dem Driver SDK für iOS

Mit dem Driver SDK können Sie die Navigation und die Nachverfolgung Ihrer App für Fahrten und Bestellfortschritte verbessern. Das Driver SDK stellt Aktualisierungen des Fahrzeugstandorts und der Aufgaben für die On-Demand-Flotten-Engine der Lösung „Rides and Deliveries“ bereit.

Das Driver SDK informiert die Fleet Engine-Dienste und Ihre benutzerdefinierten Dienste über den Standort und den Status des Fahrzeugs. Das Fahrzeug kann beispielsweise ONLINE oder OFFLINE sein und der Standort des Fahrzeugs ändert sich im Laufe der Fahrt.

Mindestsystemanforderungen

  • Auf dem Mobilgerät muss iOS 13 oder höher installiert sein.
  • Xcode Version 14 oder höher.
  • Voraussetzungen

    In diesem Leitfaden wird davon ausgegangen, dass in Ihrer App bereits das Navigation SDK 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 in Ihrem Google Cloud-Projekt das Maps SDK for iOS aktivieren und API-Schlüssel anfordern.

    Projektkonfiguration

    Sie können das Treiber-SDK mit CocoaPods konfigurieren.

    Mit CocoaPods

    Sie benötigen Folgendes, um das Treiber-SDK mit CocoaPods zu konfigurieren:

    • CocoaPods-Tool: Öffnen Sie das Terminal und führen Sie den folgenden Befehl aus, um dieses Tool zu installieren. shell sudo gem install cocoapods Weitere Informationen findest du im Startleitfaden zu CocoaPods.
    1. Erstellen Sie eine Podfile-Datei für das Driver SDK und installieren Sie damit die API und die zugehörigen Abhängigkeiten: Erstellen Sie in Ihrem Projektverzeichnis eine Datei namens Podfile. Diese Datei definiert die Abhängigkeiten Ihres Projekts. Bearbeiten Sie die Podfile-Datei und fügen Sie die Abhängigkeiten hinzu. Hier ist ein Beispiel, das die Abhängigkeiten enthält:

      source "https://github.com/CocoaPods/Specs.git"
      
      target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
        pod 'GoogleRidesharingDriver'
      end
      

      Das folgende Beispiel enthält die Alpha- und Beta-Pods für das Treiber-SDK als Abhängigkeiten:

      source "https://cpdc-eap.googlesource.com/ridesharing-driver-sdk.git"
      source "https://github.com/CocoaPods/Specs.git"
      
      target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
        pod 'GoogleRidesharingDriver'
      end
      
    2. Speichern Sie die Podfile-Datei. Öffnen Sie ein Terminal und rufen Sie das Verzeichnis auf, das die Podfile-Datei enthält:

      cd <path-to-project>
      
    3. Führen Sie den Befehl „pod install“ aus. Dadurch werden die in der Podfile-Datei angegebenen APIs und alle zugehörigen Abhängigkeiten installiert.

      pod install
      
    4. Schließen Sie Xcode und öffnen Sie per Doppelklick die .xcworkspace-Datei Ihres Projekts, um Xcode zu starten. Ab diesem Zeitpunkt müssen Sie zum Öffnen des Projekts die .xcworkspace-Datei verwenden.

    Alpha- und Betaversionen des SDK

    Zum Konfigurieren der Alpha- oder Betaversionen des Driver SDK for iOS benötigen Sie Folgendes:

    • CocoaPods-Tool: Öffnen Sie das Terminal und führen Sie den folgenden Befehl aus, um dieses Tool zu installieren.

      sudo gem install cocoapods
      

      Weitere Informationen findest du im Startleitfaden zu CocoaPods.

    • Ihr Entwicklungskonto in der Google-Zugriffsliste. Das Pod-Repository der Alpha- und Betaversionen des SDK ist keine öffentliche Quelle. Wenden Sie sich an den Google Customer Engineer, um auf diese Versionen zuzugreifen. Der Entwickler fügt Ihr Entwicklungskonto der Zugriffsliste hinzu und setzt ein Cookie zur Authentifizierung ein.

    Sobald sich Ihr Projekt in der Zugriffsliste befindet, können Sie auf den Pod zugreifen.

    1. Erstellen Sie eine Podfile-Datei für das Delivery SDK for iOS und installieren Sie damit die API und die zugehörigen Abhängigkeiten. Erstellen Sie dazu in Ihrem Projektverzeichnis eine Datei namens Podfile. Diese Datei definiert die Abhängigkeiten Ihres Projekts. Bearbeiten Sie die Podfile-Datei und fügen Sie die Abhängigkeiten hinzu. Hier ist ein Beispiel, das die Abhängigkeiten enthält:

      source "https://cpdc-eap.googlesource.com/ridesharing-driver-sdk.git"
      source "https://github.com/CocoaPods/Specs.git"
      
      target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
        pod 'GoogleRidesharingDriver'
      end
      
    2. Speichern Sie die Podfile-Datei. Öffnen Sie ein Terminal und rufen Sie das Verzeichnis auf, das die Podfile-Datei enthält:

      cd <path-to-project>
      
    3. Führen Sie den Befehl „pod install“ aus. Mit diesem Befehl werden die in der Podfile-Datei angegebenen APIs zusammen mit ihren Abhängigkeiten installiert.

      pod install
      
    4. Schließen Sie Xcode und öffnen Sie per Doppelklick die .xcworkspace-Datei Ihres Projekts, um Xcode zu starten. Ab diesem Zeitpunkt müssen Sie zum Öffnen des Projekts die .xcworkspace-Datei verwenden.

    Autorisierung und Authentifizierung implementieren

    Wenn Ihre Treiberanwendung Aktualisierungen an das Fleet Engine-Back-End generiert und sendet, müssen die Anfragen gültige Zugriffstokens enthalten. Zur Autorisierung und Authentifizierung dieser Anfragen ruft das Driver SDK Ihr Objekt gemäß 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 folgende Möglichkeiten bieten:

    • Rufen Sie ein Zugriffstoken, möglicherweise im JSON-Format, von einem HTTPS-Server ab.
    • Parst das Token und speichert 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) für die Autorisierung erstellen.

    Die Anbieter-ID ist mit der Google Cloud-Projekt-ID identisch. Weitere Informationen finden Sie in der Kurzanleitung zu Fleet Engine.

    Im folgenden Beispiel wird ein Zugriffstoken-Anbieter implementiert:

    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 {
      // 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
    

    RidesharingDriverAPI-Instanz erstellen

    Um eine GMTDVehicleReporter-Instanz zu erhalten, müssen Sie zuerst eine GMTDRidesharingDriverAPI-Instanz mit den Provider-IDs, Fahrzeug-IDs, Treiber-Contexts und accessTokenProviders erstellen. Die providerID ist mit der Google Cloud-Projekt-ID identisch. Außerdem können Sie direkt über die Treiber-API auf die GMTDVehicleReporter-Instanz zugreifen.

    Im folgenden Beispiel wird eine GMTDRidesharingDriverAPI-Instanz erstellt:

    Swift

    import GoogleRidesharingDriver
    
    private let providerID = "INSERT_YOUR_PROVIDER_ID"
    
    class SampleViewController: UIViewController {
      private let mapView: GMSMapView
    
      override func viewDidLoad() {
        super.viewDidLoad()
    
        let vehicleID = "INSERT_CREATED_VEHICLE_ID"
        let accessTokenProvider = SampleAccessTokenProvider()
        let driverContext = GMTDDriverContext(
          accessTokenProvider: accessTokenProvider,
          providerID: providerID,
          vehicleID: vehicleID,
          navigator: mapView.navigator)
        let ridesharingDriverAPI = GMTDRidesharingDriverAPI(driverContext: driverContext)
      }
    }
    

    Objective-C

    #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];
    
      GMTDRidesharingDriverAPI *ridesharingDriverAPI = [[GMTDRidesharingDriverAPI alloc] initWithDriverContext:driverContext];
    }
    

    Optional auf VehicleReporter-Ereignisse warten

    GMTDVehicleReporter aktualisiert das Fahrzeug regelmäßig, wenn locationTrackingEnabled den Wert true hat. Um auf diese regelmäßigen Aktualisierungen zu reagieren, kann jedes Objekt GMTDVehicleReporter-Ereignisse abonnieren, wenn es dem GMTDVehicleReporterListener-Protokoll entspricht.

    Sie können die folgenden Ereignisse verarbeiten:

    • vehicleReporter(_:didSucceed:)

      Informiert die Fahrer-App darüber, dass die Back-End-Dienste den Fahrzeugstandort und die Statusaktualisierung erfolgreich empfangen haben.

    • vehicleReporter(_:didFail:withError:)

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

    Im folgenden Beispiel werden diese Ereignisse verarbeitet:

    Swift

    import GoogleRidesharingDriver
    
    private let providerID = "INSERT_YOUR_PROVIDER_ID"
    
    class SampleViewController: UIViewController, GMTDVehicleReporterListener {
      private let mapView: GMSMapView
    
      override func viewDidLoad() {
        // Assumes you have implemented the sample code up to this step.
        ridesharingDriverAPI.vehicleReporter.add(self)
      }
    
      func vehicleReporter(_ vehicleReporter: GMTDVehicleReporter, didSucceed vehicleUpdate: GMTDVehicleUpdate) {
        // Handle update succeeded.
      }
    
      func vehicleReporter(_ vehicleReporter: GMTDVehicleReporter, didFail vehicleUpdate: GMTDVehicleUpdate, withError error: Error) {
        // Handle update failed.
      }
    }
    

    Objective-C

    /*
     * 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 have implemented the sample code up to this step.
      [ridesharingDriverAPI.vehicleReporter addListener:self];
    }
    
    - (void)vehicleReporter:(GMTDVehicleReporter *)vehicleReporter didSucceedVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate {
      // Handle update succeeded.
    }
    
    - (void)vehicleReporter:(GMTDVehicleReporter *)vehicleReporter didFailVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate withError:(NSError *)error {
      // Handle update failed.
    }
    
    @end
    

    GMTDVehicleReporter als Listener zu GMSRoadSnappedLocationProvider hinzufügen

    Damit Standortaktualisierungen für das Driver SDK bereitgestellt werden können, muss GMTDVehicleReporter als Listener für GMSRoadSnappedLocationProvider festgelegt sein.

    Swift

    import GoogleRidesharingDriver
    
    private let providerID = "INSERT_YOUR_PROVIDER_ID"
    
    class SampleViewController: UIViewController, GMTDVehicleReporterListener {
      private let mapView: GMSMapView
    
      override func viewDidLoad() {
        // Assumes you have implemented the sample code up to this step.
        if let roadSnappedLocationProvider = mapView.roadSnappedLocationProvider {
          roadSnappedLocationProvider.add(ridesharingDriverAPI.vehicleReporter)
          roadSnappedLocationProvider.startUpdatingLocation()
        }
      }
    }
    

    Objective-C

    /*
     * 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 have implemented the sample code up to this step.
      [_mapView.roadSnappedLocationProvider addListener:ridesharingDriverAPI.vehicleReporter];
      [_mapView.roadSnappedLocationProvider startUpdatingLocation];
    }
    
    @end
    

    Standortermittlung aktivieren

    Um die Standortermittlung zu aktivieren, kann deine App locationTrackingEnabled auf true auf GMTDVehicleReporter setzen. GMTDVehicleReporter sendet automatisch Standortaktualisierungen. Nachdem die Dienste abgeglichen und das Fahrzeug einer Fahrt zugewiesen haben, sendet GMTDVehicleReporter automatisch Routenaktualisierungen, wenn sich das GMSNavigator im Navigationsmodus befindet (wenn über setDestinations ein Ziel festgelegt ist).

    Die während der Fahrtaktualisierung festgelegte Route ist die Route, zu der der Fahrer während der Navigationssitzung navigiert. Damit die Freigabe der Route richtig funktioniert, sollte der über setDestinations festgelegte Wegpunkt mit dem im Fleet Engine-Back-End festgelegten Ziel übereinstimmen.

    Wenn locationTrackingEnabled auf true gesetzt ist, werden Updates zu Fahrten und Fahrzeugen in regelmäßigen Abständen anhand des für locationUpdateInterval festgelegten Werts an das Fleet Engine-Back-End gesendet. Wenn locationTrackingEnabled auf false gesetzt ist, wird die Haltestelle aktualisiert und eine endgültige Anfrage für ein Fahrzeugupdate wird an das Fleet Engine-Back-End gesendet, um den Fahrzeugstatus auf GMTDVehicleState.offline zu setzen. Unter updateVehicleState finden Sie spezielle Hinweise zur Behandlung von Fehlern, wenn locationTrackingEnabled auf false gesetzt ist.

    Im folgenden Beispiel wird die Standortermittlung aktiviert:

    Swift

    import GoogleRidesharingDriver
    
    private let providerID = "INSERT_YOUR_PROVIDER_ID"
    
    class SampleViewController: UIViewController, GMTDVehicleReporterListener {
      private let mapView: GMSMapView
    
      override func viewDidLoad() {
        // Assumes you have implemented the sample code up to this step.
        ridesharingDriverAPI.vehicleReporter.locationTrackingEnabled = true
      }
    }
    

    Objective-C

    /*
     * 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 have implemented the sample code up to this step.
      ridesharingDriverAPI.vehicleReporter.locationTrackingEnabled = YES;
    }
    
    @end
    

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

    Fahrzeugstatus aktualisieren

    Das folgende Beispiel zeigt, wie der Fahrzeugstatus auf ONLINE gesetzt wird. Weitere Informationen finden Sie unter updateVehicleState.

    Swift

    import GoogleRidesharingDriver
    
    private let providerID = "INSERT_YOUR_PROVIDER_ID"
    
    class SampleViewController: UIViewController, GMTDVehicleReporterListener {
      private let mapView: GMSMapView
    
      override func viewDidLoad() {
        // Assumes you have implemented the sample code up to this step.
        ridesharingDriverAPI.vehicleReporter.update(.online)
      }
    }
    

    Objective-C

    #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 have implemented the sample code up to this step.
      [ridesharingDriverAPI.vehicleReporter
                                       updateVehicleState:GMTDVehicleStateOnline];
    }
    
    @end
    

    Ein update_mask-Fehler kann auftreten, wenn die Maske leer ist. Er tritt normalerweise bei der ersten Aktualisierung nach dem Start auf. Das folgende Beispiel zeigt, wie dieser Fehler behandelt wird:

    Swift

    import GoogleRidesharingDriver
    
    class VehicleReporterListener: NSObject, GMTDVehicleReporterListener {
      func vehicleReporter(
        _ vehicleReporter: GMTDVehicleReporter,
        didFail vehicleUpdate: GMTDVehicleUpdate,
        withError error: Error
      ) {
        let fullError = error as NSError
        if let innerError = fullError.userInfo[NSUnderlyingErrorKey] as? NSError {
          let innerFullError = innerError as NSError
          if innerFullError.localizedDescription.contains("update_mask cannot be empty") {
            emptyMaskUpdates += 1
            return
          }
        }
        failedUpdates += 1
      }
    
      override init() {
        emptyMaskUpdates = 0
        failedUpdates = 0
      }
    }
    
    

    Objective-C

    #import "VehicleReporterListener.h"
    #import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>
    
    @implementation VehicleReporterListener {
      NSInteger emptyMaskUpdates = 0;
      NSInteger failedUpdates = 0;
    }
    
    - (void)vehicleReporter:(GMTDVehicleReporter *)vehicleReporter
       didFailVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate
                  withError:(NSError *)error {
      for (NSError *underlyingError in error.underlyingErrors) {
        if ([underlyingError.localizedDescription containsString:@"update_mask cannot be empty"]) {
          emptyMaskUpdates += 1;
          return;
        }
      }
      failedUpdates += 1
    }
    
    @end
    

    Standortupdates deaktivieren und Fahrzeug offline schalten

    Deine App kann Updates deaktivieren und das Fahrzeug offline nehmen. Wenn beispielsweise die Schicht eines Fahrers endet, kann Ihre Anwendung locationTrackingEnabled auf false setzen. Wenn die Updates deaktiviert werden, wird der Fahrzeugstatus im Fleet Engine-Back-End auch auf OFFLINE gesetzt.

    Swift

    vehicleReporter.locationTrackingEnabled = false
    

    Objective-C

    _vehicleReporter.locationTrackingEnabled = NO;