Introduzione all'SDK Consumer per iOS

Puoi utilizzare l'SDK consumer per creare ed eseguire un'app consumer di base integrata con i servizi di backend On-demand Rides and Deliveries Solution. Puoi creare un'app Trip and Order Progress che può visualizzare una corsa attiva, rispondere agli aggiornamenti della corsa e gestire gli errori di corsa.

Poiché l'SDK Consumer ha un'architettura modulare, puoi utilizzare le parti dell'API che vuoi utilizzare per una determinata app e integrarle con le tue API, con i servizi di backend forniti da Fleet Engine e con le API aggiuntive di Google Maps Platform.

Requisiti minimi di sistema

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

    Gestione pacchetti Swift

    L'SDK consumer può essere installato tramite Swift Package Manager. Per aggiungere l'SDK, assicurati di aver rimosso tutte le dipendenze dell'SDK consumer 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-consumer-sdk come URL, premi Invio per estrarre il pacchetto, quindi 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 GoogleRidesharingConsumer 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 consumer 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 consumer 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:

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

    CocoaPods

    Per configurare l'SDK consumer utilizzando CocoaPods, devi disporre di quanto segue:

    • Lo strumento CocoaPods: per installare questo strumento, apri il terminale ed esegui questo comando.

      sudo gem install cocoapods
      

    Per ulteriori dettagli, consulta la guida introduttiva di CocoaPods.

    1. Creare un podfile per l'SDK consumer e utilizzarlo per installare l'API e le sue dipendenze. Per prima cosa, crea un file denominato Podfile nella directory del progetto. Questo file definisce le dipendenze del progetto. Quindi 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 'GoogleRidesharingConsumer'
        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 e apri (doppio clic) il file .xcworkspace del progetto per avviare Xcode. Per aprire il progetto in un secondo momento, utilizza il file .xcworkspace.

    Installazione manuale

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

    Scarica il programma binario e le risorse dell'SDK:

    1. Apri i file compressi 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 consumer, trascina il file GoogleRidesharingConsumer.xcframework nel progetto in Framework, librerie e contenuti incorporati. Quando richiesto, seleziona Copia elementi se necessario.

    5. Trascina l'elemento GoogleRidesharingConsumer.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
      • CoreData.framework
      • CoreGraphics.framework
      • CoreImage.framework
      • CoreLocation.framework
      • CoreTelephony.framework
      • CoreText.framework
      • GLKit.framework
      • ImageIO.framework
      • libc++.tbd
      • libz.tbd
      • Metal.framework
      • OpenGLES.framework
      • QuartzCore.framework
      • SystemConfiguration.framework
      • UIKit.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 del manifest per la privacy per l'SDK Consumer per iOS: GoogleRidesharingConsumerPrivacy.
    2. Estrai il file per accedere a GoogleRidesharingConsumerPrivacy.bundle.
    3. Aggiungi GoogleRidesharingConsumerPrivacy.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.

    Integrazione di applicazioni

    Fornisci il token di autenticazione

    Quando l'app consumer richiede aggiornamenti sulle corse a Fleet Engine, le richieste devono includere token di accesso validi. Per autorizzare e autenticare queste richieste, l'SDK consumer chiama l'oggetto in conformità al protocollo GMTCAuthorization. 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. Per ulteriori informazioni, consulta la Guida introduttiva a Fleet Engine.

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

    Swift

    /*
    
        *   SampleAccessTokenProvider.swift
     */
    import GoogleRidesharingConsumer
    
    private let providerURL = "INSERT_YOUR_TOKEN_PROVIDER_URL"
    
    class SampleAccessTokenProvider: NSObject, GMTCAuthorization {
      private struct AuthToken {
        // The cached trip token.
        let token: String
        // Keep track of when the token expires for caching.
        let expiration: TimeInterval
        // Keep track of the trip ID the cached token is for.
        let tripID: String
      }
    
      enum AccessTokenError: Error {
        case missingAuthorizationContext
        case missingData
      }
    
      private var authToken: AuthToken?
    
      func fetchToken(
        with authorizationContext: GMTCAuthorizationContext?,
        completion: @escaping GMTCAuthTokenFetchCompletionHandler
      ) {
        // Get the trip ID from the authorizationContext. This is set by the Consumer SDK.
        guard let authorizationContext = authorizationContext else {
          completion(nil, AccessTokenError.missingAuthorizationContext)
          return
        }
        let tripID = authorizationContext.tripID
    
        // If appropriate, use the cached token.
        if let authToken = authToken,
          authToken.expiration > Date.now.timeIntervalSince1970 && authToken.tripID == tripID
        {
          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 tripTokenKey = "TRIP_TOKEN_KEY"
          let tokenExpirationKey = "TOKEN_EXPIRATION"
          guard let data = data,
            let fetchData = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
            let token = fetchData[tripTokenKey] as? String,
            let expiration = fetchData[tokenExpirationKey] as? Double
          else {
            completion(nil, AccessTokenError.missingData)
            return
          }
    
          strongSelf.authToken = AuthToken(token: token, expiration: expiration, tripID: tripID)
          completion(token, nil)
        }
        task.resume()
      }
    }
    

    Objective-C

    /*
    
        *   SampleAccessTokenProvider.h
     */
    #import <Foundation/Foundation.h>
    #import <GoogleRidesharingConsumer/GoogleRidesharingConsumer.h>
    
    NS_ASSUME_NONNULL_BEGIN
    
    @interface SampleAccessTokenProvider : NSObject <GMTCAuthorization>
    
    @end
    
    NS_ASSUME_NONNULL_END
    
    /*
    
        *   SampleAccessTokenProvider.m
     */
    #import "SampleAccessTokenProvider.h"
    #import "GoogleRidesharingConsumer/GoogleRidesharingConsumer.h"
    
    static NSString *const PROVIDER_URL = @"INSERT_YOUR_TOKEN_PROVIDER_URL";
    
    // SampleAccessTokenProvider.m
    @implementation SampleAccessTokenProvider {
      // The cached token with claims to the current trip.
      NSString *_cachedTripToken;
      // Keep track of the Trip ID the cached token is for.
      NSString *_lastKnownTripID;
      // Keep track of when tokens expire for caching.
      NSTimeInterval _tokenExpiration;
    }
    
    -   (void)fetchTokenWithContext:(nullable GMTCAuthorizationContext *)authorizationContext
                       completion:(nonnull GMTCAuthTokenFetchCompletionHandler)completion {
      // Get the trip ID from the authorizationContext. This is set by the Consumer SDK.
      NSString *tripID = authorizationContext.tripID;
    
      // Clear cached trip token if trip ID has changed.
      if (![_lastKnownTripID isEqual:tripID]) {
        _tokenExpiration = 0.0;
        _cachedTripToken = nil;
      }
      _lastKnownTripID = tripID;
    
      // Clear cached tripToken if it has expired.
      if ([[NSDate date] timeIntervalSince1970] > _tokenExpiration) {
        _cachedTripToken = nil;
      }
    
      // If appropriate, use the cached token.
      if (_cachedTripToken) {
        completion(_cachedTripToken, 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 *tripTokenKey = @"TRIP_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->_cachedTripToken = JSONResponse[tripTokenKey];
              completion(JSONResponse[tripTokenKey], 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
    

    Inizializzazione dell'applicazione

    Swift

    /*
    
        *   AppDelegate.swift
     */
    import GoogleRidesharingConsumer
    import GoogleMaps
    
    @UIApplicationMain
    class AppDelegate: UIResponder, UIApplicationDelegate {
    
      func application(_ application: UIApplication,
          didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        // Register your API key for GMSServices.
        GMSServices.provideAPIKey(yourMapsAPIKey)
    
        // Set the instance of the SampleAccessTokenProvider.
        GMTCServices.setAccessTokenProvider(SampleAccessTokenProvider(), providerID: yourProviderID)
    
        // Other initialization code ...
        return true
      }
    }
    

    Objective-C

    /*
    
        *   AppDelegate.m
     */
    #import <GoogleMaps/GoogleMaps.h>
    #import <GoogleRidesharingConsumer/GoogleRidesharingConsumer.h>
    
    @implementation AppDelegate
    
    -   (BOOL)application:(UIApplication *)application
        didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
      //Register your API key for GMSServices.
      [GMSServices provideAPIKey:yourMapsAPIKey];
    
      //Set the instance of the AccessTokenFactory.
      [GMTCServices setAccessTokenProvider:[[SampleAccessTokenProvider alloc] init]
                                providerID:yourProviderID];
    
      // Other initialization code ...
      return YES;
    }
    
    @end
    

    Integrazione della visualizzazione mappa

    Inizializzare la visualizzazione mappa

    Nell'esempio seguente viene illustrato come inizializzare GMTCMapView.

    Swift

    /*
    
        *   MapViewController.swift
     */
    class ViewController: UIViewController, GMTCMapViewDelegate {
      private var rideSharingMap: GMTCMapView?
    
      override func viewDidLoad() {
        super.viewDidLoad()
    
        self.rideSharingMap = GMTCMapView(frame: UIScreen.main.bounds)
        self.rideSharingMap.delegate = self
        self.rideSharingMap?.settings.myLocationButton = true
        self.view.addSubview(self.rideSharingMap!)
        ...
      }
    

    Objective-C

    /*
    
        *   MapViewController.h
     */
    @interface MapViewController : UIViewController<GMTCMapViewDelegate>
    ...
    @end
    
    /*
    
        *   MapViewController.m
     */
    @implementation MapViewController
    
    -   (void)viewDidLoad {
      [super viewDidLoad];
      ...
      self.mapView = [[GMTCMapView alloc] initWithFrame:CGRectZero];
      self.mapView.settings.myLocationButton = YES;
      self.mapView.delegate = self;
      ...
    }
    
    ...
    
    @end
    

    Gestire gli eventi di visualizzazione mappa

    L'esempio seguente mostra come implementare un delegato per gestire gli eventi relativi allo stato dei clienti.

    Swift

    func mapViewDidInitialize(_ mapview: GMTCMapView) {
      // Handle the update to the state of the map view to browsing.
    }
    
    func mapView(_ mapView: GMSMapView, didTapConsumerMarker mapMarker: GMSMarker, markerType: GMTCMapViewMarkerType) -> Bool {
      // Handle the mapView marker was tapped.
    }
    

    Objective-C

    /*
    
        *   MapViewController.m
     */
    #pragma mark - GMTCMapViewDelegate implementation
    
    // Handle state update of map view.
    
    -   (void)mapViewDidInitializeCustomerState:(GMTCMapView *)mapview {
      // Handle the update to the state of the map view to browsing.
    }
    
    -   (void)mapView:(GMSMapView *)mapView
        didTapConsumerMarker:(nonnull GMSMarker *)mapMarker
                  markerType:(GMTCMapViewMarkerType)markerType {
      // Handle the mapView marker was tapped.
    }
    

    Condivisione del percorso

    Inizia un nuovo percorso dopo il caricamento della visualizzazione

    L'esempio seguente mostra come iniziare un percorso di condivisione subito dopo il caricamento della vista. Puoi raccogliere tutti gli input utente, come i punti di consegna e di ritiro da un ViewController, e poi creare un nuovo ViewController per iniziare direttamente la condivisione del percorso.

    Swift

    /*
    
        *   MapViewController.swift
     */
    override func viewDidLoad() {
      super.viewDidLoad()
      ...
      self.mapView = GMTCMapView(frame: UIScreen.main.bounds)
      self.mapView.delegate = self
      self.view.addSubview(self.mapView)
    }
    
    func mapViewDidInitializeCustomerState(_: GMTCMapView) {
      self.mapView.pickupLocation = self.selectedPickupLocation
      self.mapView.dropoffLocation = self.selectedDropoffLocation
    
      self.startConsumerMatchWithLocations(
        pickupLocation: self.mapView.pickupLocation!,
        dropoffLocation: self.mapView.dropoffLocation!
      ) { [weak self] (tripName, error) in
        guard let strongSelf = self else { return }
        if error != nil {
          // print error message.
          return
        }
        let tripService = GMTCServices.shared().tripService
        // Create a tripModel instance for listening the update of the trip
        // specified by this trip name.
        let tripModel = tripService.tripModel(forTripName: tripName)
        // Create a journeySharingSession instance based on the tripModel
        let journeySharingSession = GMTCJourneySharingSession(tripModel: tripModel)
        // Add the journeySharingSession instance on the mapView for UI updating.
        strongSelf.mapView.show(journeySharingSession)
        // Register for the trip update events.
        tripModel.register(strongSelf)
    
        strongSelf.currentTripModel = tripModel
        strongSelf.currentJourneySharingSession = journeySharingSession
        strongSelf.hideLoadingView()
      }
    
      self.showLoadingView()
    }
    

    Objective-C

    /*
    
        *   MapViewController.m
     */
    -   (void)viewDidLoad {
      [super viewDidLoad];
      ...
      self.mapView = [[GMTCMapView alloc] initWithFrame:CGRectZero];
      self.mapView.delegate = self;
      [self.view addSubview:self.mapView];
    }
    
    // Handle the callback when the GMTCMapView did initialized.
    
    -   (void)mapViewDidInitializeCustomerState:(GMTCMapView *)mapview {
      self.mapView.pickupLocation = self.selectedPickupLocation;
      self.mapView.dropoffLocation = self.selectedDropoffLocation;
    
      __weak __typeof(self) weakSelf = self;
      [self startTripBookingWithPickupLocation:self.selectedPickupLocation
                               dropoffLocation:self.selectedDropoffLocation
                                    completion:^(NSString *tripName, NSError *error) {
                                      __typeof(self) strongSelf = weakSelf;
                                      GMTCTripService *tripService = [GMTCServices sharedServices].tripService;
                                      // Create a tripModel instance for listening to updates to the trip specified by this trip name.
                                      GMTCTripModel *tripModel = [tripService tripModelForTripName:tripName];
                                      // Create a journeySharingSession instance based on the tripModel.
                                      GMTCJourneySharingSession *journeySharingSession =
                                        [[GMTCJourneySharingSession alloc] initWithTripModel:tripModel];
                                      // Add the journeySharingSession instance on the mapView for updating the UI.
                                      [strongSelf.mapView showMapViewSession:journeySharingSession];
                                      // Register for trip update events.
                                      [tripModel registerSubscriber:self];
    
                                      strongSelf.currentTripModel = tripModel;
                                      strongSelf.currentJourneySharingSession = journeySharingSession;
                                      [strongSelf hideLoadingView];
                                    }];
        [self showLoadingView];
    }
    

    Annulla la corsa attiva

    L'esempio seguente mostra come reimpostare la corsa attualmente attiva.

    Swift

    /*
    
        *   MapViewController.swift
     */
    func cancelCurrentActiveTrip() {
      // Stop the tripModel
      self.currentTripModel.unregisterSubscriber(self)
    
      // Remove the journey sharing session from the mapView's UI stack.
      self.mapView.hide(journeySharingSession)
    }
    

    Objective-C

    /*
    
        *   MapViewController.m
     */
    -   (void)cancelCurrentActiveTrip {
      // Stop the tripModel
      [self.currentTripModel unregisterSubscriber:self];
    
      // Remove the journey sharing session from the mapView's UI stack.
      [self.mapView hideMapViewSession:journeySharingSession];
    }
    

    Ascoltare gli aggiornamenti sulla corsa

    L'esempio seguente mostra come registrare il callback tripModel.

    Swift

    /*
    
        *   MapViewController.swift
     */
    override func viewDidLoad() {
      super.viewDidLoad()
      // Register for trip update events.
      self.currentTripModel.register(self)
    }
    

    Objective-C

    /*
    
        *   MapViewController.m
     */
    -   (void)viewDidLoad {
      [super viewDidLoad];
      // Register for trip update events.
      [self.currentTripModel registerSubscriber:self];
      ...
    }
    

    L'esempio seguente mostra come annullare la registrazione del callback tripModel.

    Swift

    /*
    
        *   MapViewController.swift
     */
    deinit {
      self.currentTripModel.unregisterSubscriber(self)
    }
    

    Objective-C

    /*
    
        *   MapViewController.m
     */
    -   (void)dealloc {
      [self.currentTripModel unregisterSubscriber:self];
      ...
    }
    

    L'esempio seguente mostra come implementare il protocollo GMTCTripModelSubscriber per la gestione dei callback quando viene aggiornato lo stato della corsa.

    Swift

    /*
    
        *   MapViewController.swift
     */
    func tripModel(_: GMTCTripModel, didUpdate trip: GMTSTrip?, updatedPropertyFields: GMTSTripPropertyFields) {
      // Update the UI with the new `trip` data.
      self.updateUI(with: trip)
    }
    
    func tripModel(_: GMTCTripModel, didUpdate tripStatus: GMTSTripStatus) {
      // Handle trip status did change.
    }
    
    func tripModel(_: GMTCTripModel, didUpdateActiveRouteRemainingDistance activeRouteRemainingDistance: Int32) {
      // Handle remaining distance of active route did update.
    }
    
    func tripModel(_: GMTCTripModel, didUpdateActiveRoute activeRoute: [GMTSLatLng]?) {
      // Handle trip active route did update.
    }
    
    func tripModel(_: GMTCTripModel, didUpdate vehicleLocation: GMTSVehicleLocation?) {
      // Handle vehicle location did update.
    }
    
    func tripModel(_: GMTCTripModel, didUpdatePickupLocation pickupLocation: GMTSTerminalLocation?) {
      // Handle pickup location did update.
    }
    
    func tripModel(_: GMTCTripModel, didUpdateDropoffLocation dropoffLocation: GMTSTerminalLocation?) {
      // Handle drop off location did update.
    }
    
    func tripModel(_: GMTCTripModel, didUpdatePickupETA pickupETA: TimeInterval) {
      // Handle the pickup ETA did update.
    }
    
    func tripModel(_: GMTCTripModel, didUpdateDropoffETA dropoffETA: TimeInterval) {
      // Handle the drop off ETA did update.
    }
    
    func tripModel(_: GMTCTripModel, didUpdateRemaining remainingWaypoints: [GMTSTripWaypoint]?) {
      // Handle updates to the pickup, dropoff or intermediate destinations of the trip.
    }
    
    func tripModel(_: GMTCTripModel, didFailUpdateTripWithError error: Error?) {
      // Handle the error.
    }
    
    func tripModel(_: GMTCTripModel, didUpdateIntermediateDestinations intermediateDestinations: [GMTSTerminalLocation]?) {
      // Handle the intermediate destinations being updated.
    }
    
    func tripModel(_: GMTCTripModel, didUpdateActiveRouteTraffic activeRouteTraffic: GMTSTrafficData?) {
      // Handle trip active route traffic being updated.
    }
    

    Objective-C

    /*
    
        *   MapViewController.m
     */
    #pragma mark - GMTCTripModelSubscriber implementation
    
    -   (void)tripModel:(GMTCTripModel *)tripModel
                didUpdateTrip:(nullable GMTSTrip *)trip
        updatedPropertyFields:(enum GMTSTripPropertyFields)updatedPropertyFields {
      // Update the UI with the new `trip` data.
      [self updateUIWithTrip:trip];
      ...
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel didUpdateTripStatus:(enum GMTSTripStatus)tripStatus {
      // Handle trip status did change.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel
        didUpdateActiveRouteRemainingDistance:(int32_t)activeRouteRemainingDistance {
       // Handle remaining distance of active route did update.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel
        didUpdateActiveRoute:(nullable NSArray<GMTSLatLng *> *)activeRoute {
      // Handle trip active route did update.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel
        didUpdateVehicleLocation:(nullable GMTSVehicleLocation *)vehicleLocation {
      // Handle vehicle location did update.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel
        didUpdatePickupLocation:(nullable GMTSTerminalLocation *)pickupLocation {
      // Handle pickup location did update.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel
        didUpdateDropoffLocation:(nullable GMTSTerminalLocation *)dropoffLocation {
      // Handle drop off location did update.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel didUpdatePickupETA:(NSTimeInterval)pickupETA {
      // Handle the pickup ETA did update.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel
        didUpdateRemainingWaypoints:(nullable NSArray<GMTSTripWaypoint *> *)remainingWaypoints {
      // Handle updates to the pickup, dropoff or intermediate destinations of the trip.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel didUpdateDropoffETA:(NSTimeInterval)dropoffETA {
      // Handle the drop off ETA did update.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel didFailUpdateTripWithError:(nullable NSError *)error {
      // Handle the error.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel
        didUpdateIntermediateDestinations:
            (nullable NSArray<GMTSTerminalLocation *> *)intermediateDestinations {
      // Handle the intermediate destinations being updated.
    }
    
    -   (void)tripModel:(GMTCTripModel *)tripModel
        didUpdateActiveRouteTraffic:(nullable GMTSTrafficData *)activeRouteTraffic {
      // Handle trip active route traffic being updated.
    }
    

    Gestione degli errori

    Se hai sottoscritto l'abbonamento a tripModel e si verifica un errore, puoi ottenere il callback di tripModel implementando il metodo delegato tripModel(_:didFailUpdateTripWithError:). Fleet Engine ha generato il messaggio di errore che segue lo standard Google Cloud Error. Per la definizione dei messaggi di errore dettagliati e tutti i codici di errore, consulta la documentazione relativa agli errori di Google Cloud.

    In particolare, per il monitoraggio delle corse, richiede la fornitura di un token di autenticazione valido. 401 UNAUTHENTICATED verrà generato se non esistono credenziali di autenticazione valide, ad esempio se il token è scaduto.403 PERMISSION_DENIED verrà generato se il chiamante non ha l'autorizzazione a chiamare un'API specifica (ad esempio, un utente con il ruolo di consumatore cerca di chiamare updateTrip) o se la richiesta non ha Vehicle_id/trip_id validi nel token JWT.

    Per ulteriori informazioni, consulta la sezione Gestione degli errori dell'SDK consumer.

    Personalizzazione dell'interfaccia utente

    Ottieni e imposta opzioni personalizzate per la polilinea

    L'esempio seguente mostra come impostare opzioni UI personalizzate per le polilinee.

    Swift

    /** MapViewController.swift */
    
    func updatePolylineUIOptions() {
      // The polyline type that you would like to set custom UI options for.
      let customizablePolylineType = GMTCPolylineType.activeRoute
    
      let polylineStyleOptions = GMTCMutablePolylineStyleOptions()
      polylineStyleOptions.strokeWidth = 8.0
      polylineStyleOptions.strokeColor = .blue
      polylineStyleOptions.isVisible = true
      polylineStyleOptions.zIndex = 1000
      polylineStyleOptions.isGeodesic = true
      let coordinator = self.mapView.consumerMapStyleCoordinator
      coordinator.setPolylineStyleOptions(polylineStyleOptions, polylineType:customizablePolylineType)
    }
    

    Objective-C

    /** MapViewController.m */
    
    -   (void)updatePolylineUIOptions {
      // The polyline type that you would like to set custom UI options for.
      GMTCPolylineType customizablePolylineType = GMTCPolylineTypeActiveRoute;
    
      GMTCMutablePolylineStyleOptions *polylineStyleOptions =
          [[GMTCMutablePolylineStyleOptions alloc] init];
      polylineStyleOptions.strokeWidth = 8.0;
      polylineStyleOptions.strokeColor = [UIColor blueColor];
      polylineStyleOptions.isVisible = YES;
      polylineStyleOptions.zIndex = 1000;
      polylineStyleOptions.isGeodesic = YES;
      [[_mapView consumerMapStyleCoordinator] setPolylineStyleOptions:polylineStyleOptions
                                                    polylineType:customizablePolylineType];
    }
    

    Visualizza e imposta le opzioni dell'interfaccia utente per gli indicatori personalizzati

    L'esempio seguente mostra come impostare opzioni UI personalizzate per gli indicatori.

    Swift

    /** MapViewController.swift */
    
    func updateMarkerUIOptions() {
      let customizableMarkerType = GMTCCustomizableMarkerType.tripVehicle
      let markerStyleOptions = GMTCMutableMarkerStyleOptions()
      markerStyleOptions.groundAnchor = groundAnchor
      markerStyleOptions.isVisible = true
      markerStyleOptions.icon = icon
      markerStyleOptions.zIndex = 100
      markerStyleOptions.isFlat = false
      let coordinator = self.mapView.consumerMapStyleCoordinator
      coordinator.setMarkerStyleOptions(markerStyleOptions, markerType: customizableMarkerType)
    }
    

    Objective-C

    /** MapViewController.m */
    
    -   (void)updateMarkerUIOptions {
      // The marker type that you would like to set custom UI options for.
      GMTCCustomizableMarkerType customizableMarkerType = GMTCCustomizableMarkerTypeTripVehicle;
    
      GMTCMutableMarkerStyleOptions *markerStyleOptions =
          [[GMTCMutableMarkerStyleOptions alloc] init];
      markerStyleOptions.groundAnchor = groundAnchor;
      markerStyleOptions.isVisible = YES;
      markerStyleOptions.icon = icon;
      markerStyleOptions.zIndex = 100;
      markerStyleOptions.isFlat = NO;
    
      [[_mapView consumerMapStyleCoordinator] setMarkerStyleOptions:markerStyleOptions markerType:customizableMarkerType];
    }
    

    Regolare lo zoom della fotocamera

    Il pulsante La mia posizione in Maps SDK for iOS centra la fotocamera sulla posizione del dispositivo.

    Se è attiva una sessione di condivisione del percorso, puoi centrare la fotocamera in modo che si concentri sul percorso anziché solo sulla posizione del dispositivo.

    L'SDK per i consumatori fornisce una funzionalità della fotocamera automatica attivata per impostazione predefinita. Lo zoom della fotocamera mette a fuoco il percorso che condivide il percorso e la tappa successiva.

    AutoCamera

    Se hai bisogno di un maggiore controllo sul comportamento della videocamera, puoi disattivare o attivare la funzionalità automatica della fotocamera utilizzando la proprietà isAllowCameraAutoUpdate.

    Per ulteriori personalizzazioni della fotocamera, consulta la pagina relativa a SDK di Maps per lo spostamento della fotocamera.