Primeiros passos com o SDK do consumidor para iOS

É possível usar o SDK para o consumidor para criar e executar um aplicativo para o consumidor integrado aos serviços de back-end da solução de viagens e entregas sob demanda. Você pode criar um aplicativo Trip and Order Progress para exibir uma viagem ativa; responder a atualizações de viagens e lidar com erros de viagens.

Como o SDK do consumidor tem uma arquitetura modular, você usar as partes da API que quiser usar para seu aplicativo específico e integrando-os às suas próprias APIs, serviços de back-end fornecidos pela frota Engine e outras APIs da Plataforma Google Maps.

Requisitos mínimos do sistema

  • O dispositivo móvel precisa ter o iOS 14 ou mais recente.
  • Xcode versão 15 ou mais recente.

    • Configuração do projeto

    Gerenciador de pacotes do Swift

    O SDK para o consumidor pode ser instalado via Gerenciador de pacotes do Swift (em inglês). Para adicionar o SDK, verifique se você tem removeu todas as dependências existentes do SDK do consumidor.

    Para adicionar o SDK a um projeto novo ou existente, siga estas etapas:

    1. Abra seu Xcode project ou workspace e acesse File > Adicionar dependências de pacote.
    2. Digite https://github.com/googlemaps/ios-consumer-sdk como o URL e pressione Enter. para extrair o pacote e clicar em "Adicionar pacote".
    3. Para instalar um version específico, defina o campo Regra de dependência como um dos as opções baseadas em versão. Para novos projetos, recomendamos especificar a versão mais recente e usando a "versão exata" é a melhor opção. Quando terminar, clique em "Adicionar pacote".
    4. Na janela Choose Package Products, verifique se GoogleRidesharingConsumer será adicionado a sua meta de main designada. Quando terminar, clique em "Adicionar pacote".
    5. Para verificar sua instalação, navegue até o painel General do destino. Em Frameworks, bibliotecas e conteúdo incorporado, você verá os pacotes instalados. Também é possível consultar a página "Package Dependencies" do "Navegador do projeto" para verificar o pacote e sua versão.

    Para atualizar o package de um projeto existente, siga estas etapas:

    1. Se você estiver fazendo upgrade de uma versão anterior à 9.0.0, será necessário remover das seguintes dependências: GoogleMapsBase, GoogleMapsCore e GoogleMapsM4B após o upgrade. Não remova a dependência de GoogleMaps: Para mais informações, consulte a Notas de lançamento da versão 9.0.0.

      Nas configurações do seu projeto do Xcode, localize Frameworks, bibliotecas, e conteúdo incorporado. Use o sinal de menos(-) para remover o seguinte framework:

      • GoogleMapsBase (apenas para upgrades de versões anteriores à 9.0.0)
      • GoogleMapsCore (apenas para upgrades de versões anteriores à 9.0.0)
      • GoogleMapsM4B (apenas para upgrades de versões anteriores à 9.0.0)
    2. No Xcode, acesse "File > Pacotes > Atualize para as versões mais recentes do pacote".
    3. Para verificar a instalação, vá para a seção Package Dependencies do Project Navigator para verificar o pacote e sua versão.
    .

    Para remover as dependências do SDK do consumidor adicionadas usando CocoaPods, siga estas etapas:

    1. Feche seu espaço de trabalho do Xcode. Abra o terminal e execute o seguinte comando: 
      sudo gem install cocoapods-deintegrate cocoapods-clean 
pod deintegrate 
pod cache clean --all
    2. Remova Podfile, Podfile.resolved e Xcode workspace, se você não estiver usando para algo diferente do CocoaPods.

    Para remover o SDK do consumidor instalado manualmente, siga estas etapas:

    1. Nas configurações do projeto do Xcode, localize Frameworks, bibliotecas e conteúdo incorporado. Use o sinal de menos(-) para remover a seguinte estrutura:

      • GoogleRidesharingConsumer.xcframework

    2. No diretório de nível superior do seu projeto Xcode, remova o Pacote GoogleRidesharingConsumer.

    CocoaPods

    Para configurar o SDK do consumidor usando CocoaPods, você precisará dos seguintes itens:

    • Ferramenta CocoaPods: para instalar esta ferramenta, abra o terminal e execute o comando a seguir.

      sudo gem install cocoapods

    Consulte os Primeiros passos do CocoaPods guia para saber mais detalhes.

    1. Criar e usar um Podfile para o SDK do consumidor para instalar a API e as dependências dela. Primeiro, crie um arquivo chamado Podfile no diretório do projeto. Esse arquivo define as especificações dependências. Em seguida, edite o Podfile e adicione as dependências. Aqui está Um exemplo que inclui as dependências:

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

  target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
    pod 'GoogleRidesharingConsumer'
  end

    2. Salve o Podfile. Abra um terminal e acesse o diretório que contém o Podfile:

      cd <path-to-project>

    3. Execute o comando "pod install". Isso instalará as APIs especificadas no o Podfile e as respectivas dependências.

      pod install

    4. Feche o Xcode e clique duas vezes no arquivo .xcworkspace do seu projeto. para iniciar o Xcode. Para abrir o projeto mais tarde, use o arquivo .xcworkspace .

    .

    Instalação manual

    Um XCFramework é um pacote binário usado para instalar a SDK do consumidor. Você pode usar esse pacote em várias incluindo máquinas que usam o chipset M1. Este guia mostra como adicione manualmente o XCFramework que contém ao seu projeto e configure de build no Xcode.

    Faça o download do binário e dos recursos do SDK:

    1. Descompacte os arquivos compactados para acessar o XCFramework e os recursos.

    2. Inicie o Xcode e abra um projeto existente ou crie um novo projeto. Se você não tem experiência com o iOS, crie um novo projeto e selecione a Modelo de app.

    3. Criar um grupo do Frameworks no grupo do projeto, caso não exista um já.

    4. Para instalar o SDK do consumidor, arraste o arquivo GoogleRidesharingConsumer.xcframework para seu projeto em Frameworks, bibliotecas e conteúdo incorporado. Quando solicitado, selecione Copiar itens, se necessário.

    5. Arraste o GoogleRidesharingConsumer.bundle baixado para o diretório de nível superior do seu projeto Xcode. Quando solicitado, selecione Copy items if needed.

    6. Selecione seu projeto no Project Navigator e escolha seu de destino do aplicativo.

    7. Abra a guia "Fases de build" e, em "Vincular binário com bibliotecas", adicione a seguintes frameworks e bibliotecas, se ainda não estiverem presentes:

      • 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. Escolha seu projeto, em vez de um destino específico, e abra o Build Configurações. Na seção Outras sinalizações do vinculador, adicione -ObjC para depurar e lançar. Se essas configurações não estiverem visíveis, altere filtro na barra "Build Settings" de Básico para Todos.

    Inspecionar o arquivo do Manifesto de privacidade da Apple

    A Apple exige detalhes de privacidade de apps na App Store. Acesse a página de detalhes de privacidade da App Store da Apple para atualizações e mais informações.

    O arquivo do Manifesto de privacidade da Apple está incluído no pacote de recursos do SDK. Para verificar se o arquivo do manifesto de privacidade foi incluído e inspecionar o conteúdo dele, crie um arquivo do seu app e gere um relatório de privacidade.

    Integração de aplicativos

    Fornecer token de autenticação

    Quando o app para consumidor solicita atualizações de viagem do Fleet Engine, as solicitações devem incluir tokens de acesso válidos. Para autorizar e autenticar essas solicitações, o SDK do consumidor chama seu objeto de acordo com protocolo GMTCAuthorization. O objeto é responsável por fornecer token de acesso exigido.

    Como desenvolvedor de apps, você escolhe como os tokens são gerados. Sua implementação precisa permitir as seguintes ações:

    • Busque um token de acesso, possivelmente no formato JSON, em um servidor HTTPS.
    • Analisar e armazenar em cache o token.
    • Atualizar o token quando ele expirar.

    Para detalhes sobre os tokens esperados pelo servidor do Fleet Engine, consulte Como criar um JSON Web Token (JWT) para autorização.

    O ID do provedor é igual ao ID do projeto do Google Cloud. Para mais informações, consulte Primeiros passos com a frota Engine.

    O exemplo a seguir implementa um provedor de token de acesso:

    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

    Inicialização do aplicativo

    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

    Integração da visualização de mapa

    Inicializar a visualização de mapa

    O exemplo abaixo mostra como inicializar 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

    Processar eventos de visualização de mapa

    O exemplo a seguir mostra como implementar um delegado para processar o estado do cliente eventos.

    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.
}

    Compartilhamento da jornada

    Iniciar um novo trajeto quando a visualização for carregada

    O exemplo a seguir mostra como iniciar um compartilhamento de jornada imediatamente após a é carregada. É possível coletar todas as entradas do usuário, como locais de desembarque e embarque em uma ViewController e depois crie uma nova ViewController para iniciar a compartilhar jornadas diretamente.

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

    Cancelar a viagem ativa

    O exemplo a seguir mostra como redefinir a viagem ativa no momento.

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

    Ouvir atualizações de viagem

    O exemplo a seguir mostra como registrar o 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];
  ...
}

    O exemplo a seguir mostra como cancelar o registro do tripModel o retorno de chamada.

    Swift

    /*

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

    Objective-C

    /*

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

    O exemplo abaixo mostra como implementar o GMTCTripModelSubscriber. para tratar callbacks quando o estado da viagem é atualizado.

    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.
}

    Tratamento de erros

    Se você se inscreveu no tripModel e ocorre um erro, é possível receber o retorno de chamada do tripModel implementando o método delegado tripModel(_:didFailUpdateTripWithError:): O Fleet Engine gerou o erro que segue o padrão Google Cloud Error. Para o erro de detalhe a definição da mensagem e todos os códigos de erro se referem à página Erros do Google Cloud Documentação.

    Especificamente para o monitoramento de viagens, é necessário fornecer uma autenticação válida com base no token correto anterior. 401 UNAUTHENTICATED será gerado se não houver autenticação válida credenciais, como o token expirado.403 PERMISSION_DENIED será gerado se o o autor da chamada não tem permissão para chamar uma API específica (por exemplo, usuário com contas papel tenta chamar updateTrip), ou a solicitação não tem o campovehicle_id/trip_id válido no token JWT.

    Para mais informações, consulte Erro do SDK do consumidor. Manuseio.

    Personalização da interface

    Acessar e definir opções personalizadas de interface de polilinha

    O exemplo a seguir mostra como definir opções de interface personalizadas para polilinhas.

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

    Acessar e definir opções personalizadas da interface do marcador

    O exemplo a seguir mostra como definir opções personalizadas de IU para marcadores.

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

    Como ajustar o zoom da câmera

    A página Meu local botão no SDK do Maps para iOS, centraliza a câmera no local do dispositivo.

    Se houver uma sessão de Compartilhamento de jornada ativa, você poderá centralizar a câmera para: se concentrem no caminho, e não apenas no local do dispositivo.

    O SDK para consumidores fornece um recurso de câmera automática que é ativada por padrão. A câmera aumenta o zoom para focar na rota de compartilhamento da jornada e o próximo ponto de referência da viagem.

    AutoCamera

    Para controlar melhor o comportamento da câmera, desative ou ative o recurso de câmera automática usando o isAllowCameraAutoUpdate .

    Para mais personalizações de câmera, consulte Como mover o SDK do Maps para iOS câmera.