Guida introduttiva all'SDK Driver per iOS

Puoi utilizzare l'SDK Driver per fornire funzionalità di navigazione e monitoraggio avanzate per la tua applicazione Trip and Order Progress. L'SDK Driver fornisce aggiornamenti sulla posizione dei veicoli e sulle attività su On-demand Rides and Deliveries Solution Fleet Engine.

L'SDK Driver tiene informati i servizi Fleet Engine e i tuoi servizi personalizzati della posizione e dello stato del veicolo. Ad esempio, il veicolo può essere ONLINE o OFFLINE e la posizione del veicolo cambia man mano che il percorso procede.

Requisiti minimi di sistema

  • Sul dispositivo mobile deve essere installato iOS 14 o versioni successive.
  • Xcode 15 o versioni successive.
  • Prerequisiti

    Questa guida presuppone che la tua app implementi già l'SDK di navigazione e che il backend del Fleet Engine sia configurato e disponibile. Tuttavia, il codice di esempio fornisce un esempio di come configurare l'SDK di navigazione.

    Devi inoltre abilitare Maps SDK for iOS nel tuo progetto Google Cloud e ottenere una chiave API.

    Configurazione progetto

    Gestione pacchetti Swift

    L'SDK Driver può essere installato tramite Swift Package Manager. Per aggiungere l'SDK, assicurati di aver rimosso tutte le dipendenze dell'SDK Driver esistenti.

    Per aggiungere l'SDK a un progetto nuovo o esistente:

    1. Apri Xcode project o workspace, quindi vai a File > Aggiungi dipendenze pacchetto.
    2. Inserisci https://github.com/googlemaps/ios-driver-sdk come URL, premi Invio per estrarre il pacchetto e fai clic su "Aggiungi pacchetto".
    3. Per installare un elemento version specifico, imposta il campo Regola di dipendenza su una delle opzioni basate sulle versioni. Per i nuovi progetti, ti consigliamo di specificare la versione più recente e di utilizzare l'opzione "Versione esatta". Al termine, fai clic su "Aggiungi pacchetto".
    4. Nella finestra Choose Package Products (Scegli prodotti in pacchetto), verifica che GoogleRidesharingDriver verrà aggiunto alla destinazione main designata. Al termine, fai clic su "Aggiungi pacchetto".
    5. Per verificare l'installazione, vai al riquadro General della destinazione. In Framework, librerie e contenuti incorporati dovresti vedere i pacchetti installati. Puoi anche visualizzare la sezione "Dipendenze pacchetto" di "Navigatore progetti" per verificare il pacchetto e la sua versione.

    Per aggiornare package per un progetto esistente:

    1. Se esegui l'upgrade da una versione precedente alla 9.0.0, devi rimuovere le seguenti dipendenze: GoogleMapsBase, GoogleMapsCore e GoogleMapsM4B dopo l'upgrade. Non rimuovere la dipendenza per GoogleMaps. Per maggiori informazioni, consulta le note di rilascio della versione 9.0.0.

      Nelle impostazioni di configurazione del progetto Xcode, individua Frameworks, librerie e contenuti incorporati. Utilizza il segno meno(-) per rimuovere il seguente framework:

      • GoogleMapsBase (solo per gli upgrade da versioni precedenti alla 9.0.0)
      • GoogleMapsCore (solo per gli upgrade da versioni precedenti alla 9.0.0)
      • GoogleMapsM4B (solo per gli upgrade da versioni precedenti alla 9.0.0)
    2. Da Xcode, vai a "File > Pacchetti > Aggiorna alle versioni più recenti dei pacchetti".
    3. Per verificare l'installazione, vai alla sezione Dipendenze pacchetto di Navigatore progetto per verificare il pacchetto e la relativa versione.

    Per rimuovere le dipendenze dell'SDK Driver esistenti aggiunte utilizzando CocoaPods, segui questi passaggi:

    1. Chiudi l'area di lavoro Xcode. Apri terminale ed esegui questo comando:
      sudo gem install cocoapods-deintegrate cocoapods-clean 
      pod deintegrate 
      pod cache clean --all
    2. Rimuovi Podfile, Podfile.resolved e Xcode workspace se non li utilizzi per scopi diversi da CocoaPods.

    Per rimuovere manualmente l'SDK Driver esistente installato, segui questi passaggi:

    1. Nelle impostazioni di configurazione del progetto Xcode, individua Frameworks, Librerie e contenuti incorporati. Usa il segno meno(-) per rimuovere il seguente framework:

      • GoogleRidesharingDriver.xcframework
    2. Dalla directory di primo livello del progetto Xcode, rimuovi il bundle GoogleRidesharingDriver.

    CocoaPods

    Per configurare l'SDK Driver utilizzando CocoaPods, devi disporre dei seguenti elementi:

    • Lo strumento CocoaPods: per installare questo strumento, apri il terminale ed esegui questo comando.
       sudo gem install cocoapods
    
    1. Crea un podfile per l'SDK Driver e utilizzalo per installare l'API e le sue dipendenze: crea un file denominato Podfile nella directory del progetto. Questo file definisce le dipendenze del progetto. Modifica il Podfile e aggiungi le dipendenze. Ecco un esempio che include le dipendenze:

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

      Ecco un esempio che include i pod alpha e beta per l'SDK Driver come dipendenze:

      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. Salva il Podfile. Apri un terminale e vai alla directory contenente il pod:

      cd <path-to-project>
      
    3. Esegui il comando di installazione pod. In questo modo verranno installate le API specificate nel pod, insieme alle eventuali dipendenze.

      pod install
      
    4. Chiudi Xcode, quindi apri (doppio clic) il file .xcworkspace del tuo progetto per avviare Xcode. Da questo momento in poi, devi utilizzare il file .xcworkspace per aprire il progetto.

    Per ulteriori dettagli, consulta la guida introduttiva di CocoaPods.

    Installazione manuale

    Un XCFramework è un pacchetto binario che utilizzi per installare l'SDK Driver. Puoi utilizzare questo pacchetto su più piattaforme, incluse macchine che utilizzano il silicio Apple. Questa guida mostra come aggiungere manualmente al progetto l'XCFramework contenente l'SDK Driver e come configurare le impostazioni di build in Xcode.

    Scarica il programma binario e le risorse dell'SDK:

    1. Estrai i file per accedere a XCFramework e alle risorse.

    2. Avvia Xcode e apri un progetto esistente o creane uno nuovo. Se è la prima volta che utilizzi iOS, crea un nuovo progetto e seleziona il modello di app per iOS.

    3. Crea un gruppo di framework all'interno del gruppo di progetto se non ne esiste già uno.

    4. Per installare l'SDK Driver, trascina il file GoogleRidesharingDriver.xcframework nel progetto in Framework, librerie e contenuti incorporati. Quando richiesto, seleziona Copia elementi, se necessario.

    5. Trascina il file GoogleRidesharingDriver.bundle scaricato nella directory di primo livello del tuo progetto Xcode. Quando richiesto, seleziona Copy items if needed.

    6. Seleziona il progetto nel Navigatore progetti e scegli il target dell'applicazione.

    7. Apri la scheda Fasi di creazione e, in Collega binari alle librerie, aggiungi i seguenti framework e librerie, se non sono già presenti:

      • 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. Scegli il progetto anziché una destinazione specifica e apri la scheda Impostazioni build. Nella sezione Altri flag linker, aggiungi -ObjC per il debug e la release. Se queste impostazioni non sono visibili, nella barra delle impostazioni di build cambia il filtro da Di base a Tutti.

    Aggiungi il file manifest sulla privacy di Apple

    Apple richiede i dettagli sulla privacy delle app disponibili per l'App Store. Visita la pagina dei dettagli sulla privacy dell'App Store di Apple per aggiornamenti e ulteriori informazioni.

    1. Scarica il bundle manifest per la privacy per l'SDK Driver per iOS: GoogleRidesharingDriverPrivacy.
    2. Estrai il file per accedere a GoogleRidesharingDriverPrivacy.bundle.
    3. Aggiungi GoogleRidesharingDriverPrivacy.bundle nel navigatore dei progetti Xcode utilizzando uno di questi metodi. Assicurati che la casella "Aggiungi ai target" sia selezionata per il target dell'app. Una volta aggiunto, il file PrivacyInfo viene visualizzato nella barra di navigazione dei progetti e puoi esaminare i valori.
    4. Screenshot delle informazioni sulla privacy Xcode
    5. Verifica che il manifest per la privacy sia stato aggiunto creando un archivio della tua app e generando un report sulla privacy dall'archivio.

    Implementare autorizzazione e autenticazione

    Quando l'app Driver genera e invia aggiornamenti al backend Fleet Engine, le richieste devono includere token di accesso validi. Per autorizzare e autenticare queste richieste, l'SDK Driver chiama l'oggetto in conformità al protocollo GMTDAuthorization. L'oggetto è responsabile di fornire il token di accesso richiesto.

    In qualità di sviluppatore dell'app, sei tu a scegliere come generare i token. La tua implementazione dovrebbe consentirti di:

    • Recupera un token di accesso, possibilmente in formato JSON, da un server HTTPS.
    • Analizza e memorizza il token nella cache.
    • Aggiorna il token alla scadenza.

    Per i dettagli sui token previsti dal server Fleet Engine, consulta la pagina relativa alla creazione di un token JWT (JSON Web Token) per l'autorizzazione.

    L'ID provider è uguale all'ID progetto Google Cloud. Consulta la guida rapida di Fleet Engine per ulteriori informazioni.

    Nell'esempio seguente viene implementato un provider di token di accesso:

    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
    

    Crea un'istanza RidesharingDriverAPI

    Per ottenere un'istanza GMTDVehicleReporter, devi prima creare un'istanza GMTDRidesharingDriverAPI utilizzando providerID, VehicleID, driverContext e accessTokenProvider. L'ID provider è uguale all'ID progetto Google Cloud. Inoltre, puoi accedere all'istanza GMTDVehicleReporter direttamente dall'API Driver.

    L'esempio seguente crea un'istanza 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];
    }
    

    (Facoltativo) Ascolta gli eventi VehicleReporter

    GMTDVehicleReporter aggiorna periodicamente il veicolo quando locationTrackingEnabled è true. Per rispondere a questi aggiornamenti periodici, qualsiasi oggetto può sottoscrivere eventi GMTDVehicleReporter conformi al protocollo GMTDVehicleReporterListener.

    Puoi gestire i seguenti eventi:

    • vehicleReporter(_:didSucceed:)

      Comunica all'app Driver che i servizi di backend hanno ricevuto correttamente la posizione del veicolo e l'aggiornamento dello stato.

    • vehicleReporter(_:didFail:withError:)

      Comunica al listener che un aggiornamento del veicolo non è riuscito. Finché il monitoraggio della posizione è abilitato, GMTDVehicleReporter continua a inviare i dati più recenti al backend di Fleet Engine.

    L'esempio seguente gestisce questi eventi:

    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
    

    Aggiungi GMTD VehicleReporter come listener a GMSRoadSnappedLocationProvider

    Per fornire aggiornamenti di posizione all'SDK Driver, è necessario impostare GMTDVehicleReporter come listener per 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
    

    Attiva il monitoraggio della posizione

    Per attivare il monitoraggio della posizione, la tua app può impostare locationTrackingEnabled su true su GMTDVehicleReporter. GMTDVehicleReporter invia automaticamente gli aggiornamenti sulla posizione. Una volta che i servizi corrispondono e assegnano il veicolo a una corsa, GMTDVehicleReporter invia automaticamente gli aggiornamenti del percorso quando GMSNavigator è in modalità di navigazione (quando una destinazione è impostata tramite setDestinations).

    Il percorso impostato durante l'aggiornamento della corsa sarà lo stesso percorso dal conducente durante la sessione di navigazione. Di conseguenza, affinché la condivisione del percorso funzioni correttamente, il waypoint impostato tramite setDestinations deve corrispondere alla destinazione impostata nel backend di Fleet Engine.

    Se il criterio locationTrackingEnabled è impostato su true, gli aggiornamenti sulla corsa e sul veicolo vengono inviati al backend di Fleet Engine a intervalli regolari in base al valore impostato per locationUpdateInterval. Se il criterio locationTrackingEnabled è impostato su false, gli aggiornamenti si interrompono e viene inviata una richiesta finale di aggiornamento del veicolo al backend di Fleet Engine per impostare lo stato del veicolo su GMTDVehicleState.offline. Consulta updateVehicleState per considerazioni speciali sulla gestione degli errori quando locationTrackingEnabled è impostato su false.

    L'esempio seguente abilita il monitoraggio della posizione:

    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
    

    Per impostazione predefinita, l'intervallo di report è di 10 secondi, ma l'intervallo di report può essere modificato con locationUpdateInterval. L'intervallo di aggiornamento minimo supportato è di 5 secondi. L'intervallo di aggiornamento massimo supportato è di 60 secondi. Aggiornamenti più frequenti possono rallentare le richieste e gli errori.

    Aggiorna lo stato del veicolo

    L'esempio seguente mostra come impostare lo stato del veicolo su ONLINE. Per informazioni dettagliate, visita la pagina 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
    

    Quando la maschera è vuota, può verificarsi un errore update_mask e in genere si verifica per il primo aggiornamento dopo l'avvio. L'esempio seguente mostra come gestire questo errore:

    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
    

    Disattiva gli aggiornamenti della posizione e porta il veicolo offline

    La tua app può disattivare gli aggiornamenti e mettere il veicolo offline. Ad esempio, quando termina il turno di un conducente, la tua app può impostare locationTrackingEnabled su false. La disabilitazione degli aggiornamenti imposta anche lo stato del veicolo su OFFLINE nel backend di Fleet Engine.

    Swift

    vehicleReporter.locationTrackingEnabled = false
    

    Objective-C

    _vehicleReporter.locationTrackingEnabled = NO;