Erste Schritte mit dem Treiber-SDK für iOS

Mit dem Driver SDK können Sie die Navigation und das Tracking für Ihre Fahrt- und Bestellfortschrittsanwendung verbessern. Das Driver SDK stellt Updates zu Fahrzeugstandorten und Aufgaben für die Fleet Engine der Lösung „On-demand Rides and Deliveries“ bereit.

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

Sie können sich auch die iOS-Beispiel-Apps oder die kombinierten Beispiele als konkretes Beispiel ansehen.

Mindestsystemanforderungen

Auf dem Mobilgerät muss iOS 14 oder höher installiert sein.

Xcode Version 15 oder höher.

Voraussetzungen

In diesem Leitfaden wird davon ausgegangen, dass das Navigation SDK in Ihrer App bereits implementiert ist und das Fleet Engine-Back-End eingerichtet und verfügbar ist. Der Beispielcode zeigt jedoch, wie das Navigation SDK eingerichtet wird.

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

Projektkonfiguration

Swift-Paketmanager

Das Treiber SDK kann über den Swift Package Manager installiert werden. Prüfen Sie vor dem Hinzufügen des SDK, ob Sie alle vorhandenen Driver SDK-Abhängigkeiten entfernt haben.

Wichtig: Diese Anleitung setzt die Verwendung von Xcode 15 oder höher voraus, sollte aber für frühere Versionen von Xcode ähnlich sein.

So fügen Sie das SDK einem neuen oder vorhandenen Projekt hinzu:

1. Öffnen Sie Xcode project oder workspace und klicken Sie dann auf Datei > Paketabhängigkeiten hinzufügen.
2. Geben Sie https://github.com/googlemaps/ios-driver-sdk als URL ein, drücken Sie die Eingabetaste, um das Paket abzurufen, und klicken Sie auf „Paket hinzufügen“.
3. Wenn Sie eine bestimmte version installieren möchten, legen Sie das Feld Abhängigkeitsregel auf eine der versionsbasierten Optionen fest. Bei neuen Projekten empfehlen wir, die neueste Version anzugeben und die Option „Exakte Version“ zu verwenden. Klicke anschließend auf „Paket hinzufügen“.
4. Prüfen Sie im Fenster Paketprodukte auswählen, ob GoogleRidesharingDriver dem festgelegten Ziel main hinzugefügt wird. Klicke anschließend auf „Paket hinzufügen“.
5. Um die Installation zu überprüfen, navigiere zum Bereich General deines Ziels. Die installierten Pakete sollten nun unter Frameworks, Bibliotheken und eingebettete Inhalte zu sehen sein. Sie können auch den Abschnitt „Paketabhängigkeiten“ der Projektnavigation aufrufen, um das Paket und seine Version zu prüfen.

So aktualisieren Sie package für ein vorhandenes Projekt:

1. Wenn Sie ein Upgrade von einer Version vor 9.0.0 durchführen, müssen Sie nach dem Upgrade die folgenden Abhängigkeiten entfernen: GoogleMapsBase, GoogleMapsCore und GoogleMapsM4B. Entfernen Sie die Abhängigkeit für GoogleMaps nicht. Weitere Informationen finden Sie in den Versionshinweisen zu Version 9.0.0.

   Suchen Sie in den Xcode-Projektkonfigurationseinstellungen nach Frameworks, Bibliotheken und eingebettete Inhalte. Verwenden Sie das Minuszeichen(-), um das folgende Framework zu entfernen:

   • GoogleMapsBase (nur für Upgrades von Versionen vor 9.0.0)
   • GoogleMapsCore (nur für Upgrades von Versionen vor 9.0.0)
   • GoogleMapsM4B (nur für Upgrades von Versionen vor 9.0.0)
2. Gehen Sie in Xcode zu „File > Packages > Update to Latest Package Versions“ (Datei > Pakete> Auf neueste Paketversionen aktualisieren).
3. Um Ihre Installation zu überprüfen, gehen Sie zum Abschnitt Paketabhängigkeiten der Projektnavigation, um das Paket und seine Version zu überprüfen.

Wichtig: Manchmal können Artefakte nicht behoben werden oder es können Fehler auftreten. Wählen Sie in diesem Fall „Datei > Pakete > Paket-Cache zurücksetzen“ aus.

So entfernen Sie vorhandene Driver SDK-Abhängigkeiten, die mit CocoaPods hinzugefügt wurden:

1. Schließen Sie den Xcode-Arbeitsbereich. Öffnen Sie das Terminal und führen Sie den folgenden Befehl aus:

   sudo gem install cocoapods-deintegrate cocoapods-clean 
   pod deintegrate 
   pod cache clean --all

2. Entferne Podfile, Podfile.resolved und Xcode workspace, wenn du sie ausschließlich für CocoaPods verwendest.

So entfernen Sie das vorhandene Driver SDK manuell:

1. Suchen Sie in den Xcode-Projektkonfigurationseinstellungen nach Frameworks, Libraries, and Embedded Content (Frameworks, Bibliotheken und eingebettete Inhalte). Verwenden Sie das Minuszeichen(-), um das folgende Framework zu entfernen:

   • GoogleRidesharingDriver.xcframework

2. Entfernen Sie im Verzeichnis der obersten Ebene Ihres Xcode-Projekts das Bundle GoogleRidesharingDriver.

CocoaPods

Wenn Sie das Driver SDK mit CocoaPods konfigurieren möchten, benötigen Sie Folgendes:

• CocoaPods-Tool: Öffnen Sie zum Installieren dieses Tools das Terminal und führen Sie den folgenden Befehl aus.

   sudo gem install cocoapods

1. Erstellen Sie eine Podfile-Datei für das Driver SDK und installieren Sie damit die API und ihre Abhängigkeiten: Erstellen Sie in Ihrem Projektverzeichnis eine Datei mit dem Namen „Podfile“. In dieser Datei sind die Abhängigkeiten Ihres Projekts definiert. Bearbeiten Sie die Podfile-Datei und fügen Sie Ihre Abhängigkeiten hinzu. Hier ein Beispiel mit den Abhängigkeiten:

   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 wechseln Sie zum Verzeichnis mit der Podfile-Datei:

   cd <path-to-project>
   

3. Führen Sie den Befehl „pod install“ aus. Dadurch werden die im Podfile angegebenen APIs und ggf. vorhandene Abhängigkeiten installiert.

   pod install
   

4. Schließen Sie Xcode und öffnen Sie dann per Doppelklick die .xcworkspace-Datei Ihres Projekts, um Xcode zu starten. Ab jetzt müssen Sie das Projekt mit der .xcworkspace-Datei öffnen.

Hinweis :Führen Sie regelmäßig pod outdated aus, um zu ermitteln, wann eine neuere Version des SDK verfügbar ist. Weitere Informationen finden Sie unter Treiber SDK für iOS-Versionen.

Weitere Informationen finden Sie im Startleitfaden für CocoaPods.

Manuelle Installation

Achtung: Als Best Practice empfehlen wir, CocoaPods nach Möglichkeit zur Installation des Treiber-SDK zu verwenden. Bevor Sie mit diesem Leitfaden beginnen, müssen Sie das XCFramework heruntergeladen haben.

Ein XCFramework ist ein Binärpaket, mit dem Sie das Treiber-SDK installieren. Sie können dieses Paket auf mehreren Plattformen verwenden, einschließlich Rechnern, die Apple Silicon verwenden. In dieser Anleitung erfahren Sie, wie Sie das XCFramework, das das Driver SDK enthält, Ihrem Projekt manuell hinzufügen und Ihre Build-Einstellungen in Xcode konfigurieren.

Laden Sie das SDK-Binärprogramm und die Ressourcen herunter:

• GoogleRidesharingDriver.xcframework
• GoogleRidesharingDriver.bundle

Wichtig: Installieren Sie das Navigation SDK, bevor Sie diese Anleitung verwenden.

1. Extrahieren Sie die Dateien, um auf XCFramework und Ressourcen zuzugreifen.

2. Starten Sie Xcode und öffnen Sie entweder ein vorhandenes Projekt oder erstellen Sie ein neues Projekt. Wenn Sie neu bei iOS sind, erstellen Sie ein neues Projekt und wählen Sie die Vorlage für die iOS-App aus.

3. Erstellen Sie eine Frameworks-Gruppe unter Ihrer Projektgruppe, falls noch keine vorhanden ist.

4. Ziehen Sie die Datei GoogleRidesharingDriver.xcframework in Ihr Projekt unter Frameworks, Libraries, and Embedded Content (Frameworks, Bibliotheken und eingebettete Inhalte), um das Treiber-SDK zu installieren. Wählen Sie bei Aufforderung „Elemente bei Bedarf kopieren“ aus.

5. Ziehen Sie die heruntergeladene Datei GoogleRidesharingDriver.bundle in das Verzeichnis der obersten Ebene Ihres Xcode-Projekts. Wenn Sie dazu aufgefordert werden, wählen Sie Copy items if needed aus.

6. Wählen Sie Ihr Projekt aus dem Project Navigator und dann das Ziel Ihrer Anwendung aus.

7. Öffnen Sie den Tab „Build Phases“ (Build-Phasen) und fügen Sie in „Link Binary with Libraries“ (Binärdatei mit Bibliotheken verknüpfen) die folgenden Frameworks und Bibliotheken hinzu, sofern sie noch nicht vorhanden sind:

   • Accelerate.framework
   • AudioToolbox.framework
   • AVFoundation.framework
   • CoreData.framework
   • CoreGraphics.framework
   • CoreLocation.framework
   • CoreTelephony.framework
   • CoreText.framework
   • GLKit.framework
   • ImageIO.framework
   • libc++.tbd
   • libxml2.tbd
   • libz.tbd
   • LocalAuthentication.framework
   • OpenGLES.framework
   • QuartzCore.framework
   • SystemConfiguration.framework
   • UIKit.framework
   • WebKit.framework

8. Wählen Sie Ihr Projekt anstelle eines bestimmten Ziels aus und öffnen Sie den Tab Build-Einstellungen. Fügen Sie im Bereich Other Linker Flags (Weitere Verknüpfungs-Flags) -ObjC sowohl für die Fehlerbehebung als auch für den Release hinzu. Wenn diese Einstellungen nicht sichtbar sind, ändern Sie den Filter in der Leiste mit den Build-Einstellungen von Einfach zu Alle.

Apple Privacy Manifest-Datei hinzufügen

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.

Wichtig: Diese Anleitung für die Apple Privacy Manifest-Datei gilt nur für die neueste SDK-Version.

1. Laden Sie das Privacy Manifest-Bundle für das Driver SDK for iOS herunter: GoogleRidesharingDriverPrivacy.
2. Extrahieren Sie die Datei, um auf GoogleRidesharingDriverPrivacy.bundle zuzugreifen.
3. Fügen Sie GoogleRidesharingDriverPrivacy.bundle mit einer dieser Methoden zum Xcode Project Navigator hinzu. Achten Sie darauf, dass für das Ziel Ihrer App ein Häkchen bei „Zu Zielen hinzufügen“ gesetzt ist. Nach dem Hinzufügen wird die PrivacyInfo-Datei im Projektnavigator angezeigt und Sie können die Werte prüfen.

4. Prüfen Sie, ob das Datenschutzmanifest hinzugefügt wurde. Erstellen Sie dazu ein Archiv Ihrer App und generieren Sie einen Datenschutzbericht aus dem Archiv.

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 gemäß dem Protokoll GMTDAuthorization auf. Das Objekt ist für die Bereitstellung des erforderlichen Zugriffstokens zuständig.

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.

Details zu den vom Fleet Engine-Server erwarteten Tokens finden Sie unter JSON-Webtoken (JWT) für Autorisierung erstellen.

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

Im folgenden Beispiel wird ein Zugriffstokenanbieter 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

Wenn Sie eine GMTDVehicleReporter-Instanz abrufen möchten, müssen Sie zuerst eine GMTDRidesharingDriverAPI-Instanz mit den Attributen „providerID“, „vehicleID“, „driverContext“ und „accessTokenProvider“ erstellen. Die Anbieter-ID 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 Standort und Status des Fahrzeugs erfolgreich empfangen haben.

• vehicleReporter(_:didFail:withError:)

  Informiert den Listener, dass ein Fahrzeugupdate fehlgeschlagen ist. Solange die Standortverfolgung 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 werden.

Hinweis :Zur Optimierung sendet GMSRoadSnappedLocationProvider möglicherweise keine fortlaufenden Standortaktualisierungen, wenn das Gerät seit dem letzten Standortupdate nicht bewegt wurde. Das kann passieren, wenn ein Fahrer im Leerlauf im Auto ist. Wenn es Situationen gibt, in denen GMTDVehicleReporter als Listener festgelegt wird, nachdem startUpdatingLocation auf GMSRoadSnappedLocationProvider aufgerufen wurde, beende und starte GMSRoadSnappedLocationProvider, damit ein neues Standortupdate gesendet wird.

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 GMTDVehicleReporter auf true setzen. GMTDVehicleReporter sendet automatisch Standortaktualisierungen. Nachdem die Dienste übereinstimmen und das Fahrzeug einer Fahrt zugewiesen wurden, sendet GMTDVehicleReporter automatisch Routenaktualisierungen, wenn sich der GMSNavigator im Navigationsmodus befindet (wenn ein Ziel über setDestinations festgelegt wurde).

Die Route, die während der Fahrtaktualisierung festgelegt wird, entspricht der Route, die der Fahrer während der Navigation verwendet. Damit die Routenfreigabe ordnungsgemäß funktioniert, sollte der über setDestinations festgelegte Wegpunkt mit dem im Fleet Engine-Back-End festgelegten Ziel übereinstimmen.

Wenn locationTrackingEnabled auf true gesetzt ist, werden Fahrten und Fahrzeugaktualisierungen in regelmäßigen Abständen basierend auf dem für locationUpdateInterval festgelegten Wert an das Fleet Engine-Back-End gesendet. Wenn locationTrackingEnabled auf false gesetzt ist, werden Aktualisierungen angehalten und eine letzte Fahrzeugaktualisierungsanfrage an das Fleet Engine-Back-End gesendet, um den Fahrzeugstatus auf GMTDVehicleState.offline zu setzen. Unter updateVehicleState finden Sie weitere Informationen zum Umgang mit Fehlern, wenn locationTrackingEnabled auf false festgelegt 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, 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.

Fahrzeugstatus aktualisieren

Das folgende Beispiel zeigt, wie der Fahrzeugstatus auf ONLINE festgelegt 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

Standortaktualisierungen deaktivieren und Fahrzeug offline stellen

Deine App kann Updates deaktivieren und das Fahrzeug offline nehmen. Wenn beispielsweise die Schicht eines Fahrers endet, kann Ihre App locationTrackingEnabled auf false setzen. Durch das Deaktivieren von Updates wird der Status des Fahrzeugs im Fleet Engine-Back-End auf OFFLINE gesetzt.

Swift

vehicleReporter.locationTrackingEnabled = false

Objective-C

_vehicleReporter.locationTrackingEnabled = NO;