Premiers pas avec le SDK Driver pour iOS

Vous pouvez utiliser le SDK Driver pour améliorer la navigation et le suivi dans votre Application de suivi du trajet et de progression de la commande. Le SDK Driver fournit des données les mises à jour de lieu et de tâche à la solution On-demand Rides and Deliveries Solution Fleet Engine.

Le SDK Driver permet aux services Fleet Engine et à vos services personnalisés d'être informés l'emplacement et l'état du véhicule ; Par exemple, le véhicule peut être ONLINE ou OFFLINE, et la position du véhicule change au fur et à mesure du trajet.

Configuration système minimale requise

  • L'appareil mobile doit exécuter iOS 14 ou une version ultérieure.
  • Xcode version 15 ou ultérieure.

    • Prérequis

    Ce guide part du principe que votre application implémente déjà la fonctionnalité Navigation SDK et que le parc du parc Moteur est configuré et disponible. Toutefois, l'exemple de code fournit un exemple Configurer le SDK Navigation

    Vous devez également activer le SDK Maps pour iOS. dans votre projet Google Cloud et d'obtenir une API clé.

    Configuration du projet

    Gestionnaire de paquets Swift

    Pour installer le SDK Driver, utilisez Gestionnaire de paquets Swift. Pour ajouter le SDK, assurez-vous d'avoir supprimé toutes les dépendances existantes du SDK Driver.

    Pour ajouter le SDK à un projet nouveau ou existant, procédez comme suit:

    1. Ouvrez votre Xcode project ou workspace, puis accédez à File > (Fichier >) Ajouter des dépendances de packages
    2. Saisissez https://github.com/googlemaps/ios-driver-sdk comme URL, puis appuyez sur Entrée. pour extraire le package et cliquez sur « Ajouter un package ».
    3. Pour installer un version spécifique, définissez le champ Règle de dépendance sur l'une des les options basées sur les versions. Pour les nouveaux projets, nous vous recommandons de spécifier la dernière version et à l'aide de la colonne "Version exacte", . Une fois l'opération terminée, cliquez sur "Ajouter un package".
    4. Dans la fenêtre Choose Package Products (Sélectionner les produits du package), vérifiez que GoogleRidesharingDriver sera ajouté à votre main cible désignée. Une fois l'opération terminée, cliquez sur "Ajouter un package".
    5. Pour vérifier votre installation, accédez au volet General de votre cible. Les packages installés devraient s'afficher dans Cadres, bibliothèques et contenu intégré. Vous pouvez également afficher les "Dépendances des packages" de la section "Navigateur de projets" pour vérifier le package et sa version.

    Pour mettre à jour le package pour un projet existant, procédez comme suit:

    1. Si vous effectuez la mise à niveau à partir d'une version antérieure à la version 9.0.0,vous devez supprimer les dépendances suivantes: GoogleMapsBase, GoogleMapsCore et GoogleMapsM4B après la mise à niveau. Ne supprimez pas la dépendance pour GoogleMaps Pour en savoir plus, consultez les Notes de version de la version 9.0.0

      Dans les paramètres de configuration de votre projet Xcode, recherchez Frameworks, Bibliothèques, et les contenus intégrés. Utilisez le signe moins(-) pour supprimer le framework suivant:

      • GoogleMapsBase (uniquement pour les mises à niveau à partir de versions antérieures à la version 9.0.0)
      • GoogleMapsCore (uniquement pour les mises à niveau à partir de versions antérieures à la version 9.0.0)
      • GoogleMapsM4B (uniquement pour les mises à niveau à partir de versions antérieures à la version 9.0.0)
    2. Dans Xcode, accédez à Fichier > Packages > Update To Latest Package Versions" (Mise à jour vers les dernières versions du package).
    3. Pour vérifier votre installation, accédez à la section Package Dependencies (Dépendances des packages) du Project Navigator (Navigateur de projets). pour vérifier le package et sa version.

    Pour supprimer les dépendances existantes du SDK Driver ajoutées à l'aide de CocoaPods, procédez comme suit:

    1. Fermez votre espace de travail Xcode. Ouvrez le terminal et exécutez la commande suivante: 
      sudo gem install cocoapods-deintegrate cocoapods-clean 
pod deintegrate 
pod cache clean --all
    2. Supprimez Podfile, Podfile.resolved et les Xcode workspace si vous ne les utilisez pas pour d'autres produits que CocoaPods.

    Pour supprimer le SDK Driver installé manuellement, procédez comme suit:

    1. Dans les paramètres de configuration de votre projet Xcode, recherchez Frameworks, bibliothèques et contenus intégrés. Utilisez le signe moins(-) pour supprimer le framework suivant:

      • GoogleRidesharingDriver.xcframework

    2. Dans le répertoire de premier niveau de votre projet Xcode, supprimez le Lot GoogleRidesharingDriver.

    CocoaPods

    Pour configurer le SDK Driver à l'aide de CocoaPods, vous avez besoin des éléments suivants:

    • Outil CocoaPods: pour installer cet outil, ouvrez le terminal et exécutez la la commande suivante.
       sudo gem install cocoapods

    1. Créez un fichier Podfile pour le SDK Driver et utilisez-le pour installer l'API. ses dépendances: créez un fichier nommé Podfile dans le répertoire de votre projet. Ce fichier définit les dépendances de votre projet. Modifiez le Podfile et ajoutez vos dépendances. Voici un exemple qui inclut les dépendances:

      source "https://github.com/CocoaPods/Specs.git"

target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
  pod 'GoogleRidesharingDriver'
end

      Voici un exemple incluant les séries d'annonces alpha et bêta SDK Driver en tant que dépendances:

      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. Enregistrez le Podfile. Ouvrez un terminal et accédez au répertoire contenant le Podfile:

      cd <path-to-project>

    3. Exécutez la commande d'installation du pod. Les API spécifiées dans la section Podfile, ainsi que ses éventuelles dépendances.

      pod install

    4. Fermez Xcode, puis ouvrez (double-cliquez) le fichier .xcworkspace de votre projet. pour lancer Xcode. À partir de ce moment, vous devez utiliser .xcworkspace pour ouvrir le projet.

    Reportez-vous au document Premiers pas avec CocoaPods pour en savoir plus plus de détails.

    Installation manuelle

    Un XCFramework est un paquet binaire que vous utilisez pour installer SDK Driver. Vous pouvez utiliser ce package sur plusieurs plates-formes, y compris les machines utilisant Apple silicon. Ce guide vous explique comment ajoutez manuellement le XCFramework contenant SDK Driver dans votre projet et configurer votre build dans Xcode.

    Téléchargez le binaire du SDK et ses ressources:

    1. Extrayez les fichiers pour accéder au XCFramework et aux ressources.

    2. Démarrez Xcode, puis ouvrez un projet existant ou créez-en un. projet. Si vous n'avez jamais utilisé iOS, créez un projet et sélectionnez l'application iOS Modèle d'application.

    3. Créez un groupe Frameworks sous votre groupe de projets s'il n'en existe pas. déjà.

    4. Pour installer Driver SDK, faites glisser le GoogleRidesharingDriver.xcframework dans votre projet sous Cadres, bibliothèques et contenu intégré. Lorsque vous y êtes invité, sélectionnez Copiez des éléments si nécessaire.

    5. Faites glisser le GoogleRidesharingDriver.bundle téléchargé pour le placer au premier niveau de votre projet Xcode. Lorsque vous y êtes invité, sélectionnez Copy items if needed.

    6. Sélectionnez votre projet dans le navigateur de projets, puis choisissez votre cible de votre application.

    7. Ouvrez l'onglet Build Phases et, dans Link Binary with libraries, ajoutez le Les frameworks et bibliothèques suivants s'ils ne sont pas déjà présents:

      • 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. Choisissez votre projet plutôt qu'une cible spécifique, puis ouvrez le panneau Build Paramètres. Dans la section Other Linker Flags (Autres indicateurs Linker), ajoutez -ObjC pour à la fois au débogage et à la publication. Si ces paramètres ne sont pas visibles, modifiez dans la barre "Paramètres de compilation" en passant de Standard à Tous.

    Inspecter le fichier manifeste de confidentialité Apple

    Apple exige des informations sur la confidentialité des applications disponibles sur l'App Store. Pour obtenir des mises à jour et d'autres informations, consultez la page Informations sur la confidentialité sur l'App Store d'Apple.

    Le fichier manifeste de confidentialité Apple est inclus dans le bundle de ressources pour le SDK. Pour vérifier que le fichier manifeste de confidentialité a été inclus et pour inspecter son contenu, créez une archive de votre application et générez un rapport sur la confidentialité à partir de cette archive.

    Mettre en œuvre l'autorisation et l'authentification

    Lorsque votre application Conducteur génère et envoie des mises à jour au backend Fleet Engine, les demandes doivent inclure des jetons d'accès valides. Pour autoriser et authentifier à ces requêtes, le SDK Drive appelle conformément au protocole GMTDAuthorization. L'objet est responsable de en fournissant le jeton d'accès requis.

    En tant que développeur de l'application, vous choisissez la façon dont les jetons sont générés. Votre implémentation doit permettre d'effectuer les opérations suivantes:

    • Extrayez un jeton d'accès, éventuellement au format JSON, à partir d'un serveur HTTPS.
    • Analyser et mettre en cache le jeton.
    • Actualisez le jeton lorsqu'il expire.

    Pour plus d'informations sur les jetons attendus par le serveur Fleet Engine, consultez la section Créer un Jeton Web JSON (JWT) pour autorisation.

    L'ID du fournisseur est identique à l'ID du projet Google Cloud. Voir Moteur de parc Guide de démarrage rapide Guide pour en savoir plus.

    L'exemple suivant met en œuvre un fournisseur de jetons d'accès:

    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

    Créer une instance RidesharingDriverAPI

    Pour obtenir une instance GMTDVehicleReporter, vous devez d'abord créer un l'instance GMTDRidesharingDriverAPI avec l'ID du fournisseur, l'ID du véhicule, piloteContext et accessTokenProvider. L'ID du fournisseur est le même que celui de Google ID du projet Google Cloud. Vous pouvez accéder à l'instance GMTDVehicleReporter à partir de l'API du pilote.

    L'exemple suivant crée une instance GMTDRidesharingDriverAPI:

    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];
}

    Écouter les événements VehicleReporter (facultatif)

    GMTDVehicleReporter met régulièrement à jour le véhicule lorsque "locationTrackingEnabled" est "true". Pour répondre à ces mises à jour périodiques, peut s'abonner aux événements GMTDVehicleReporter en respectant le protocole GMTDVehicleReporterListener.

    Vous pouvez gérer les événements suivants:

    • vehicleReporter(_:didSucceed:)

      Informe l'application pilote que les services de backend ont bien reçu le mise à jour de la position et de l'état du véhicule

    • vehicleReporter(_:didFail:withError:)

      Informe l'écouteur qu'une mise à jour du véhicule a échoué. Tant que la localisation le suivi est activé, GMTDVehicleReporter continue d'envoyer les données les plus récentes vers le backend Fleet Engine.

    L'exemple suivant gère ces événements:

    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

    Ajouter GMTDVehicleReporter comme écouteur à GMSRoadSnappedLocationProvider

    Pour fournir des notifications de position au SDK Driver, GMTDVehicleReporter doit être défini comme écouteur pour GMSRoadSnappedLocationProvider.

    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

    Activer le suivi de la position

    Pour activer le suivi de la position, votre application peut définir locationTrackingEnabled sur true le GMTDVehicleReporter. GMTDVehicleReporter envoie automatiquement mises à jour de la position géographique. Une fois que les services correspondent et que le véhicule a été associé à un trajet, GMTDVehicleReporter envoie automatiquement des mises à jour de l'itinéraire lorsque GMSNavigator est en mode de navigation (lorsqu'une destination est définie via setDestinations).

    L'itinéraire défini lors de la mise à jour du trajet est le même que celui utilisé par le conducteur d'accéder pendant la session de navigation. Ainsi, pour le partage du parcours jusqu’au travail correctement, le point de cheminement défini dans setDestinations doit correspondre la destination définie dans le backend Fleet Engine.

    Si locationTrackingEnabled est défini sur true, les mises à jour du trajet et du véhicule sont envoyées au backend Fleet Engine à intervalles réguliers en fonction de la valeur définie pour locationUpdateInterval Si locationTrackingEnabled est défini sur false, arrêt des mises à jour et une demande finale de mise à jour du véhicule est envoyée à Fleet Engine pour définir l'état du véhicule sur GMTDVehicleState.offline. Voir updateVehicleState des considérations spéciales sur la gestion des défaillances lorsque locationTrackingEnabled est défini sur false.

    L'exemple suivant active le suivi de la position:

    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

    Par défaut, l'intervalle de rapport est de 10 secondes, mais il peut être modifié par locationUpdateInterval. Intervalle minimal de mise à jour accepté est de 5 secondes. L'intervalle de mise à jour maximal accepté est de 60 secondes. Plus fréquente les mises à jour peuvent ralentir les requêtes et provoquer des erreurs.

    Modifier l'état du véhicule

    L'exemple suivant montre comment définir l'état du véhicule sur ONLINE. Voir updateVehicleState pour en savoir plus.

    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

    Une erreur update_mask peut se produire lorsque le masque est vide, ce qui se produit généralement pour la première mise à jour après le démarrage. L'exemple suivant montre comment gérer cette erreur:

    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

    Désactiver les mises à jour de la position et mettre le véhicule hors connexion

    Votre application peut désactiver les mises à jour et mettre le véhicule hors connexion. Par exemple, lorsqu'un fin de journée de travail du conducteur, votre application peut définir locationTrackingEnabled sur false. La désactivation des mises à jour définit également l'état du véhicule sur OFFLINE sur Fleet Engine backend.

    Swift

    vehicleReporter.locationTrackingEnabled = false

    Objective-C

    _vehicleReporter.locationTrackingEnabled = NO;