On-demand Rides and Deliveries Solution is currently available only to select partners.

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 Ride & Deliveries di On-demand. Puoi creare un'app Trip and Order Progress che può mostrare una corsa attiva, rispondere agli aggiornamenti e gestire gli errori.

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

Requisiti minimi di sistema

  • Sul dispositivo mobile deve essere installato iOS 13 o una versione successiva.
  • Xcode 14 o versioni successive.
  • Configurazione progetto

    Puoi configurare l'SDK consumer utilizzando CocoaPods.

    Utilizzare CocoaPods

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

    • Strumento CocoaPods: per installare questo strumento, apri il terminale ed esegui questo comando. shell sudo gem install cocoapods Per ulteriori dettagli, consulta la Guida introduttiva a 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 podfile:

      cd <path-to-project>
      
    3. Esegui il comando di installazione del pod. Verranno installate le API specificate nel podfile, insieme alle eventuali dipendenze.

      pod install
      
    4. Chiudi Xcode e apri (fai doppio clic) il file .xcworkspace del progetto per avviare Xcode. Per aprire il progetto in un secondo momento, utilizza il file .xcworkspace.

    Installa XCFramework

    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 XCFramework contenente l'SDK Consumer e configurare le impostazioni di build in Xcode.

    1. Decomprimi i file di origine che hai ricevuto da Google.

    2. Avvia Xcode e apri un progetto esistente oppure creane uno nuovo. Se non hai mai utilizzato iOS, crea un nuovo progetto e seleziona il modello dell'app per iOS.

    3. Crea un gruppo di framework nel gruppo di progetto se non ne esiste già uno.

    4. Trascina il file gRPCCertificates.bundle incluso nella directory Resources del file ZIP contenente l'elemento XCFramework nella directory di primo livello del tuo progetto Xcode. Quando richiesto, seleziona Copia elementi, se necessario.

    5. Per installare l'SDK Consumer, trascina il file GoogleRidesharingConsumer.xcframework nel tuo progetto in Frameworks, Libraries, and Embedded Content. Quando richiesto, seleziona Copia elementi, se necessario.

    6. Seleziona il progetto nella barra di navigazione del progetto e scegli il target dell'applicazione.

    7. Apri la scheda Fasi di build e, in Link Binary with Libraries, 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é un target specifico e apri la scheda Impostazioni build. Nella sezione Altri linker, aggiungi ‑ObjC sia per il debug sia per la release. Se queste impostazioni non sono visibili, modifica il filtro nella barra Impostazioni build da Di base a Tutte.

    Versioni SDK alpha/beta

    Per configurare le versioni alpha o beta dell'SDK Consumer utilizzando CocoaPods per iOS, devi disporre dei seguenti elementi:

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

      sudo gem install cocoapods
      

      Per ulteriori dettagli, consulta la Guida introduttiva a CocoaPods.

    • Il tuo account di sviluppo nell'elenco di accesso di Google. Il repository di pod delle versioni alpha e beta dell'SDK non è di origine pubblica. Per accedere a queste versioni, contatta il Customer Engineer di Google. Il tecnico aggiunge il tuo account di sviluppo all'elenco per gli accessi e poi imposta un cookie per l'autenticazione.

    Una volta che il progetto è nell'elenco di accesso, puoi accedere al pod.

    1. Creare un Podfile per l'SDK Consumer per iOS e utilizzarlo 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 tue dipendenze. Ecco un esempio che include le dipendenze:

      source "https://cpdc-eap.googlesource.com/ridesharing-consumer-sdk"
      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 podfile:

      cd <path-to-project>
      
    3. Esegui il comando di installazione del pod. Verranno installate le API specificate nel podfile, insieme alle eventuali dipendenze.

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

    Integrazione delle applicazioni

    Fornisci token di autenticazione

    Quando l'app consumer richiede gli aggiornamenti della corsa da Fleet Engine, le richieste devono includere token di accesso validi. Per autorizzare e autenticare queste richieste, l'SDK Consumer chiama il tuo oggetto conforme al protocollo GMTCAuthorization. L'oggetto è responsabile della fornitura del token di accesso richiesto.

    In qualità di sviluppatore dell'app, scegli come generare i token. L'implementazione deve offrire la possibilità di:

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

    Per informazioni dettagliate sui token previsti dal server Fleet Engine, consulta Creazione di un token web JSON (JWT) per l'autorizzazione.

    L'ID provider è uguale all'ID progetto Google Cloud. Per ulteriori informazioni, consulta la guida introduttiva a Fleet Engine.

    L'esempio seguente implementa 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 delle applicazioni

    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

    L'esempio seguente mostra 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] init];
      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 di 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 percorso

    Inizia un nuovo viaggio quando è stata caricata la visualizzazione

    L'esempio seguente mostra come iniziare una condivisione del percorso subito dopo il caricamento della visualizzazione. Puoi raccogliere tutti gli input degli utenti, ad esempio punti di consegna e ritiro, da un ViewController e poi creare un nuovo ViewController per avviare 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] init];
      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 il viaggio attivo

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

    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 sulle corse

    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'attributo tripModel e si verifica un errore, puoi ricevere il callback di tripModel implementando il metodo Delega tripModel(_:didFailUpdateTripWithError:). Fleet Engine ha generato il messaggio di errore conforme allo standard Google Cloud Error. Per la definizione di un messaggio di errore dettagliato e per tutti i codici di errore, consulta la documentazione relativa agli errori di Google Cloud.

    In particolare, per il monitoraggio delle corse, è necessario fornire un token di autenticazione valido. Il valore 401 UNAUTHENTICATED verrà generato se non sono presenti credenziali di autenticazione valide, ad esempio quando il token è scaduto.403 PERMISSION_DENIED verrà aumentato se il chiamante non dispone dell'autorizzazione per chiamare un'API specifica, ad esempio l'utente con ruolo consumer tenta di chiamare updateTrip o la richiesta non ha un valore Vehicle_id/trip_id valido nel token JWT.

    Per ulteriori informazioni, consulta Gestione degli errori degli SDK per i consumatori.

    Personalizzazione dell'interfaccia utente

    Ottieni/imposta opzioni UI di polilinea personalizzate

    L'esempio seguente mostra come impostare le opzioni di 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];
    }
    

    Ottieni/Imposta opzioni UI indicatori personalizzati

    L'esempio seguente mostra come impostare le opzioni di 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];
    }
    

    Regolazione dello zoom della fotocamera

    Il pulsante La mia posizione nell'SDK di Maps per iOS mette la fotocamera in posizione centrale sulla posizione del dispositivo.

    Se è attiva una sessione di condivisione del percorso, puoi centrare la fotocamera per concentrarti sul percorso anziché solo sulla posizione del dispositivo.

    L'SDK consumer dispone di una funzionalità della fotocamera automatica attiva per impostazione predefinita. La videocamera aumenta lo zoom per mettere a fuoco il percorso di condivisione del percorso e il tappa successiva.

    Macchina fotografica automatica

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

    Per ulteriori personalizzazioni della fotocamera, consulta la sezione SDK di Maps per iOS in movimento della fotocamera.