Primeiros passos com o SDK do driver para iOS

Você pode usar o SDK do Driver para oferecer navegação e rastreamento aprimorados ao aplicativo de progresso de viagem e pedido. O SDK do Driver fornece atualizações de tarefas e localização de veículos ao Fleet Engine da solução de viagens e entregas sob demanda.

O SDK do Driver mantém os serviços do Fleet Engine e seus serviços personalizados cientes da localização e do estado do veículo. Por exemplo, o veículo pode ser ONLINE ou OFFLINE, e a localização do veículo muda conforme a viagem.

Também é possível consultar os apps de exemplo para iOS ou exemplos combinados como um exemplo concreto.

Requisitos mínimos do sistema

O dispositivo móvel precisa ter o iOS 14 ou mais recente.

Xcode versão 15 ou mais recente.

Pré-requisitos

Este guia presume que seu app já implementa o SDK de navegação e que o back-end do Fleet Engine está configurado e disponível. No entanto, o código de exemplo fornece uma amostra de como configurar o SDK do Navigation.

Também é necessário ativar o SDK do Maps para iOS no seu projeto do Google Cloud e gerar uma chave de API.

Configuração do projeto

Gerenciador de pacotes do Swift

O SDK do Driver pode ser instalado pelo Swift Package Manager. Para adicionar o SDK, remova todas as dependências atuais do SDK do Driver.

Importante: estas instruções consideram o uso do Xcode 15 ou mais recente, mas são semelhantes às versões anteriores.

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

1. Abra o Xcode project ou workspace e acesse File > Add Package Dependencies.
2. Digite https://github.com/googlemaps/ios-driver-sdk como o URL, pressione Enter para extrair o pacote e clique em "Adicionar pacote".
3. Para instalar um version específico, defina o campo Regra de dependência como uma das opções baseadas em versão. Para novos projetos, recomendamos especificar a versão mais recente e usar a opção "Versão exata". Quando terminar, clique em "Adicionar pacote".
4. Na janela Choose Package Products, verifique se GoogleRidesharingDriver será adicionado ao destino main designado. 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. Você também pode ver a seção "Package Dependencies" do "Project Navigator" para verificar o pacote e a versão dele.

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, remova as seguintes dependências: GoogleMapsBase, GoogleMapsCore e GoogleMapsM4B após o upgrade. Não remova a dependência de GoogleMaps. Para mais informações, consulte as Notas de lançamento da versão 9.0.0.

   Nas configurações do 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 > Packages > Update To latest Package Versions".
3. Para verificar sua instalação, vá para a seção Package Dependencies do Project Navigator para conferir o pacote e a versão dele.

Importante:às vezes, os artefatos não podem ser resolvidos ou podem ocorrer erros. Nesse caso, selecione "File > Packages > reset Package Cache".

Para remover as dependências atuais do SDK do Driver 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 workspace do Xcode se não os usar para algo diferente do CocoaPods.

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

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

   • GoogleRidesharingDriver.xcframework

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

CocoaPods

Para configurar o SDK do driver usando o CocoaPods, são necessários os seguintes itens:

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

   sudo gem install cocoapods

1. Crie um Podfile para o SDK do driver e use-o para instalar a API e as dependências dela. Crie um arquivo chamado Podfile no diretório do projeto. Esse arquivo define as dependências do seu projeto. Edite o Podfile e adicione as dependências. Confira um exemplo que inclui as dependências:

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

   Confira um exemplo que inclui os pods Alfa e Beta do SDK do Driver como dependências:

   source "https://cpdc-eap.googlesource.com/ridesharing-driver-sdk.git"
   source "https://github.com/CocoaPods/Specs.git"
   
   target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
     pod 'GoogleRidesharingDriver'
   end
   

2. 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". Assim, as APIs especificadas no Podfile e as respectivas dependências serão instaladas.

   pod install
   

4. Feche o Xcode e clique duas vezes no arquivo .xcworkspace do seu projeto para iniciá-lo. A partir desse momento, você precisará usar o arquivo .xcworkspace para abrir o projeto.

Observação: execute o pod outdated periodicamente para detectar quando há uma versão mais recente do SDK. Para mais informações, consulte SDK do driver para versões do iOS.

Consulte o Guia de iniciação do CocoaPods para mais detalhes.

Instalação manual

Atenção: como prática recomendada, use o Cocoapods para instalar o SDK do driver sempre que possível. Antes de seguir este guia, verifique se você fez o download do XCFramework.

Um XCFramework é um pacote binário usado para instalar o SDK do driver. É possível usar esse pacote em várias plataformas, incluindo máquinas com Apple silicon. Este guia mostra como adicionar manualmente o XCFramework que contém o SDK do driver ao projeto e definir as configurações de build no Xcode.

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

• GoogleRidesharingDriver.xcframework
• GoogleRidesharingDriver.bundle

Importante: antes de usar este guia, instale o SDK do Navigation.

1. Extraia os arquivos para acessar o XCFramework e os recursos.

2. Inicie o Xcode e abra um projeto existente ou crie um novo. Se você é novo no iOS, crie um novo projeto e selecione o modelo de app iOS.

3. Crie um grupo do Frameworks no grupo do projeto, se ainda não houver um.

4. Para instalar o SDK do driver, arraste o arquivo GoogleRidesharingDriver.xcframework para o projeto em Frameworks, bibliotecas e conteúdo incorporado. Quando solicitado, selecione "Copy items" se necessário.

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

6. Selecione o projeto no Navegador de projetos e escolha o destino do aplicativo.

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

   • Accelerate.framework
   • AudioToolbox.framework
   • AVFoundation.framework
   • CoreData.framework
   • CoreGraphics.framework
   • CoreLocation.framework
   • CoreTelephony.framework
   • CoreText.framework
   • GLKit.framework
   • ImageIO.framework
   • libc++.tbd
   • libxml2.tbd
   • libz.tbd
   • LocalAuthentication.framework
   • OpenGLES.framework
   • QuartzCore.framework
   • SystemConfiguration.framework
   • UIKit.framework
   • WebKit.framework

8. Escolha seu projeto, em vez de um destino específico, e abra a guia Build Settings. Na seção Outras sinalizações do vinculador, adicione -ObjC para depuração e lançamento. Se essas configurações não estiverem visíveis, mude o filtro na barra de configurações do build de Basic para All.

Adicionar o arquivo de 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.

Importante: estas instruções para o arquivo de manifesto de privacidade da Apple se aplicam apenas à versão mais recente do SDK.

1. Faça o download do pacote de manifesto de privacidade para o SDK do Driver para iOS: GoogleRidesharingDriverPrivacy (em inglês).
2. Extraia o arquivo para acessar GoogleRidesharingDriverPrivacy.bundle.
3. Adicione GoogleRidesharingDriverPrivacy.bundle ao navegador do projeto do Xcode usando um destes métodos. Verifique se a caixa "Add to targets" está marcada para o destino do seu app. Depois de adicionado, o arquivo PrivacyInfo vai aparecer no navegador do projeto, e você poderá inspecionar os valores.

4. Verifique se o manifesto de privacidade foi adicionado criando um arquivo do seu app e gerando um relatório de privacidade no arquivo.

Implementar autorização e autenticação

Quando o app do driver gera e envia atualizações ao back-end do Fleet Engine, as solicitações precisam incluir tokens de acesso válidos. Para autorizar e autenticar essas solicitações, o SDK do Driver chama o objeto em conformidade com o protocolo GMTDAuthorization. O objeto é responsável por fornecer o token de acesso necessário.

Como desenvolvedor de apps, você escolhe como os tokens são gerados. Sua implementação precisa fornecer a capacidade de fazer o seguinte:

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

Saiba mais sobre os tokens esperados pelo servidor do Fleet Engine em Como criar um JSON Web Token (JWT) para autorização.

O ID do provedor é igual ao ID do projeto do Google Cloud. Consulte o Guia de início rápido do Fleet Engine para mais informações.

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

Swift

import GoogleRidesharingDriver

private let providerURL = "INSERT_YOUR_TOKEN_PROVIDER_URL"

class SampleAccessTokenProvider: NSObject, GMTDAuthorization {
  private struct AuthToken {
    // The cached vehicle token.
    let token: String
    // Keep track of when the token expires for caching.
    let expiration: TimeInterval
    // Keep track of the vehicle ID the cached token is for.
    let vehicleID: String
  }

  enum AccessTokenError: Error {
    case missingAuthorizationContext
    case missingData
  }

  private var authToken: AuthToken?

  func fetchToken(
    with authorizationContext: GMTDAuthorizationContext?,
    completion: @escaping GMTDAuthTokenFetchCompletionHandler
  ) {
    // Get the vehicle ID from the authorizationContext. This is set by the Driver SDK.
    guard let authorizationContext = authorizationContext else {
      completion(nil, AccessTokenError.missingAuthorizationContext)
      return
    }
    let vehicleID = authorizationContext.vehicleID

    // If appropriate, use the cached token.
    if let authToken = authToken,
      authToken.expiration > Date.now.timeIntervalSince1970 && authToken.vehicleID == vehicleID
    {
      completion(authToken.token, nil)
      return
    }

    // Otherwise, try to fetch a new token from your server.
    let request = URLRequest(url: URL(string: providerURL))
    let task = URLSession.shared.dataTask(with: request) { [weak self] data, _, error in
      guard let strongSelf = self else { return }
      guard error == nil else {
        completion(nil, error)
        return
      }

      // Replace the following key values with the appropriate keys based on your
      // server's expected response.
      let vehicleTokenKey = "VEHICLE_TOKEN_KEY"
      let tokenExpirationKey = "TOKEN_EXPIRATION"
      guard let data = data,
        let fetchData = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
        let token = fetchData[vehicleTokenKey] as? String,
        let expiration = fetchData[tokenExpirationKey] as? Double
      else {
        completion(nil, AccessTokenError.missingData)
        return
      }

      strongSelf.authToken = AuthToken(
        token: token, expiration: expiration, vehicleID: vehicleID)
      completion(token, nil)
    }
    task.resume()
  }
}

Objective-C

#import "SampleAccessTokenProvider.h"
#import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>

// SampleAccessTokenProvider.h
@interface SampleAccessTokenProvider : NSObject<GMTDAuthorization>
@end

static NSString *const PROVIDER_URL = @"INSERT_YOUR_TOKEN_PROVIDER_URL";

// SampleAccessTokenProvider.m
@implementation SampleAccessTokenProvider{
  // The cached vehicle token.
  NSString *_cachedVehicleToken;
  // Keep track of the vehicle ID the cached token is for.
  NSString *_lastKnownVehicleID;
  // Keep track of when tokens expire for caching.
  NSTimeInterval _tokenExpiration;
}

-   (void)fetchTokenWithContext:(nullable GMTDAuthorizationContext *)authorizationContext
                   completion:(nonnull GMTDAuthTokenFetchCompletionHandler)completion {
  // Get the vehicle ID from the authorizationContext. This is set by the Driver SDK.
  NSString *vehicleID = authorizationContext.vehicleID;
  if (!vehicleID) {
    NSAssert(NO, @"Vehicle ID is missing from authorizationContext.");
    return;
  }

  // Clear cached vehicle token if vehicle ID has changed.
  if (![_lastKnownVehicleID isEqual:vehicleID]) {
    _tokenExpiration = 0.0;
    _cachedVehicleToken = nil;
  }
  _lastKnownVehicleID = vehicleID;

  // Clear cached vehicletoken if it has expired.
  if ([[NSDate date] timeIntervalSince1970] > _tokenExpiration) {
    _cachedVehicleToken = nil;
  }

  // If appropriate, use the cached token.
  if (_cachedVehicleToken) {
    completion(_cachedVehicleToken, nil);
    return;
  }
  // Otherwise, try to fetch a new token from your server.
  NSURL *requestURL = [NSURL URLWithString:PROVIDER_URL];
  NSMutableURLRequest *request =
      [[NSMutableURLRequest alloc] initWithURL:requestURL];
  request.HTTPMethod = @"GET";
  // Replace the following key values with the appropriate keys based on your
  // server's expected response.
  NSString *vehicleTokenKey = @"VEHICLE_TOKEN_KEY";
  NSString *tokenExpirationKey = @"TOKEN_EXPIRATION";
  __weak typeof(self) weakSelf = self;
  void (^handler)(NSData *_Nullable data, NSURLResponse *_Nullable response,
                  NSError *_Nullable error) =
      ^(NSData *_Nullable data, NSURLResponse *_Nullable response, NSError *_Nullable error) {
        typeof(self) strongSelf = weakSelf;
        if (error) {
          completion(nil, error);
          return;
        }

        NSError *JSONError;
        NSMutableDictionary *JSONResponse =
            [NSJSONSerialization JSONObjectWithData:data options:kNilOptions error:&JSONError];

        if (JSONError) {
          completion(nil, JSONError);
          return;
        } else {
          // Sample code only. No validation logic.
          id expirationData = JSONResponse[tokenExpirationKey];
          if ([expirationData isKindOfClass:[NSNumber class]]) {
            NSTimeInterval expirationTime = ((NSNumber *)expirationData).doubleValue;
            strongSelf->_tokenExpiration = [[NSDate date] timeIntervalSince1970] + expirationTime;
          }
          strongSelf->_cachedVehicleToken = JSONResponse[vehicleTokenKey];
          completion(JSONResponse[vehicleTokenKey], nil);
        }
      };
  NSURLSessionConfiguration *config = [NSURLSessionConfiguration defaultSessionConfiguration];
  NSURLSession *mainQueueURLSession =
      [NSURLSession sessionWithConfiguration:config delegate:nil
                               delegateQueue:[NSOperationQueue mainQueue]];
  NSURLSessionDataTask *task = [mainQueueURLSession dataTaskWithRequest:request completionHandler:handler];
  [task resume];
}

@end

Criar uma instância da RidesharingDriverAPI

Para ter uma instância de GMTDVehicleReporter, primeiro você precisa criar uma instância de GMTDRidesharingDriverAPI usando o providerID, o ID do veículo, o driverContext e o accessTokenProvider. O providerID é o mesmo que o ID do projeto do Google Cloud. E você pode acessar a instância GMTDVehicleReporter diretamente na API do driver.

O exemplo a seguir cria uma instância GMTDRidesharingDriverAPI:

Swift

import GoogleRidesharingDriver

private let providerID = "INSERT_YOUR_PROVIDER_ID"

class SampleViewController: UIViewController {
  private let mapView: GMSMapView

  override func viewDidLoad() {
    super.viewDidLoad()

    let vehicleID = "INSERT_CREATED_VEHICLE_ID"
    let accessTokenProvider = SampleAccessTokenProvider()
    let driverContext = GMTDDriverContext(
      accessTokenProvider: accessTokenProvider,
      providerID: providerID,
      vehicleID: vehicleID,
      navigator: mapView.navigator)
    let ridesharingDriverAPI = GMTDRidesharingDriverAPI(driverContext: driverContext)
  }
}

Objective-C

#import "SampleViewController.h"
#import "SampleAccessTokenProvider.h"
#import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>

static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";

@implementation SampleViewController {
  GMSMapView *_mapView;
}

-   (void)viewDidLoad {
  NSString *vehicleID = @"INSERT_CREATED_VEHICLE_ID";
  SampleAccessTokenProvider *accessTokenProvider =
                                [[SampleAccessTokenProvider alloc] init];
  GMTDDriverContext *driverContext =
    [[GMTDDriverContext alloc] initWithAccessTokenProvider:accessTokenProvider
                                                providerID:PROVIDER_ID
                                                 vehicleID:vehicleID
                                                 navigator:_mapView.navigator];

  GMTDRidesharingDriverAPI *ridesharingDriverAPI = [[GMTDRidesharingDriverAPI alloc] initWithDriverContext:driverContext];
}

Como opção, detectar eventos de VehicleReporter

GMTDVehicleReporter atualiza o veículo periodicamente quando locationTrackingEnabled é true. Para responder a essas atualizações periódicas, qualquer objeto pode se inscrever em eventos GMTDVehicleReporter em conformidade com o protocolo GMTDVehicleReporterListener.

É possível processar os seguintes eventos:

• vehicleReporter(_:didSucceed:)

  Informa ao app do motorista que os serviços de back-end receberam a atualização do local e do estado do veículo.

• vehicleReporter(_:didFail:withError:)

  Informa o listener que houve uma falha na atualização do veículo. Enquanto o rastreamento de local estiver ativado, o GMTDVehicleReporter vai continuar enviando os dados mais recentes para o back-end do Fleet Engine.

O exemplo a seguir lida com esses eventos:

Swift

import GoogleRidesharingDriver

private let providerID = "INSERT_YOUR_PROVIDER_ID"

class SampleViewController: UIViewController, GMTDVehicleReporterListener {
  private let mapView: GMSMapView

  override func viewDidLoad() {
    // Assumes you have implemented the sample code up to this step.
    ridesharingDriverAPI.vehicleReporter.add(self)
  }

  func vehicleReporter(_ vehicleReporter: GMTDVehicleReporter, didSucceed vehicleUpdate: GMTDVehicleUpdate) {
    // Handle update succeeded.
  }

  func vehicleReporter(_ vehicleReporter: GMTDVehicleReporter, didFail vehicleUpdate: GMTDVehicleUpdate, withError error: Error) {
    // Handle update failed.
  }
}

Objective-C

/*

    *   SampleViewController.h
 */
@interface SampleViewController : UIViewController<GMTDVehicleReporterListener>
@end

/*

    *   SampleViewController.m
 */
#import "SampleViewController.h"
#import "SampleAccessTokenProvider.h"
#import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>

static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";

@implementation SampleViewController {
  GMSMapView *_mapView;
}

-   (void)viewDidLoad {
  // Assumes you have implemented the sample code up to this step.
  [ridesharingDriverAPI.vehicleReporter addListener:self];
}

-   (void)vehicleReporter:(GMTDVehicleReporter *)vehicleReporter didSucceedVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate {
  // Handle update succeeded.
}

-   (void)vehicleReporter:(GMTDVehicleReporter *)vehicleReporter didFailVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate withError:(NSError *)error {
  // Handle update failed.
}

@end

Adicionar GMTDVehicleReporter como um listener para GMSRoadSnappedLocationProvider

Para fornecer atualizações de localização ao SDK do driver, GMTDVehicleReporter precisa ser definido como um listener para o GMSRoadSnappedLocationProvider.

Observação: como uma otimização pretendida, talvez o GMSRoadSnappedLocationProvider não envie atualizações de local continuamente se o dispositivo não tiver sido movido desde a última atualização. Isso acontece quando um motorista fica parado no carro. Se houver situações em que GMTDVehicleReporter é definido como listener depois de startUpdatingLocation em GMSRoadSnappedLocationProvider ter sido chamado, pare e inicie GMSRoadSnappedLocationProvider para garantir que uma nova atualização de local seja enviada.

Swift

import GoogleRidesharingDriver

private let providerID = "INSERT_YOUR_PROVIDER_ID"

class SampleViewController: UIViewController, GMTDVehicleReporterListener {
  private let mapView: GMSMapView

  override func viewDidLoad() {
    // Assumes you have implemented the sample code up to this step.
    if let roadSnappedLocationProvider = mapView.roadSnappedLocationProvider {
      roadSnappedLocationProvider.add(ridesharingDriverAPI.vehicleReporter)
      roadSnappedLocationProvider.startUpdatingLocation()
    }
  }
}

Objective-C

/*

    *   SampleViewController.h
 */
@interface SampleViewController : UIViewController<GMTDVehicleReporterListener>
@end

/*

    *   SampleViewController.m
 */
#import "SampleViewController.h"
#import "SampleAccessTokenProvider.h"
#import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>

static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";

@implementation SampleViewController {
  GMSMapView *_mapView;
}

-   (void)viewDidLoad {
  // Assumes you have implemented the sample code up to this step.
  [_mapView.roadSnappedLocationProvider addListener:ridesharingDriverAPI.vehicleReporter];
  [_mapView.roadSnappedLocationProvider startUpdatingLocation];
}

@end

Ativar rastreamento de localização

Para ativar o rastreamento de localização, seu app pode definir locationTrackingEnabled como true em GMTDVehicleReporter. GMTDVehicleReporter envia automaticamente atualizações de localização. Depois que os serviços correspondem e atribuem o veículo a uma viagem, o GMTDVehicleReporter envia atualizações de trajeto automaticamente quando o GMSNavigator está no modo de navegação (quando um destino é definido pelo setDestinations).

O trajeto definido durante a atualização da viagem é o mesmo que o motorista está percorrendo durante a sessão de navegação. Assim, para que o compartilhamento de jornada funcione corretamente, o waypoint definido pelo setDestinations precisa corresponder ao destino definido no back-end do Fleet Engine.

Se locationTrackingEnabled for definido como true, as atualizações de viagens e veículos serão enviadas ao back-end do Fleet Engine em um intervalo regular com base no valor definido para locationUpdateInterval. Se locationTrackingEnabled for definido como false, as atualizações serão interrompidas e uma solicitação final de atualização do veículo será enviada ao back-end do Fleet Engine para definir o estado do veículo como GMTDVehicleState.offline. Consulte updateVehicleState para conferir considerações especiais sobre como lidar com falhas quando locationTrackingEnabled é definido como false.

O exemplo a seguir ativa o rastreamento de localização:

Swift

import GoogleRidesharingDriver

private let providerID = "INSERT_YOUR_PROVIDER_ID"

class SampleViewController: UIViewController, GMTDVehicleReporterListener {
  private let mapView: GMSMapView

  override func viewDidLoad() {
    // Assumes you have implemented the sample code up to this step.
    ridesharingDriverAPI.vehicleReporter.locationTrackingEnabled = true
  }
}

Objective-C

/*
    *   SampleViewController.m
 */
#import "SampleViewController.h"
#import "SampleAccessTokenProvider.h"
#import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>

static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";

@implementation SampleViewController {
  GMSMapView *_mapView;
}

-   (void)viewDidLoad {
  // Assumes you have implemented the sample code up to this step.
  ridesharingDriverAPI.vehicleReporter.locationTrackingEnabled = YES;
}

@end

Por padrão, o intervalo do relatório é de 10 segundos, mas pode ser alterado com locationUpdateInterval. O intervalo mínimo de atualização permitido é de cinco segundos. O intervalo máximo de atualização permitido é de 60 segundos. Atualizações mais frequentes podem resultar em solicitações e erros mais lentos.

Atualizar o estado do veículo

O exemplo abaixo mostra como definir o estado do veículo como ONLINE. Consulte updateVehicleState para mais detalhes.

Swift

import GoogleRidesharingDriver

private let providerID = "INSERT_YOUR_PROVIDER_ID"

class SampleViewController: UIViewController, GMTDVehicleReporterListener {
  private let mapView: GMSMapView

  override func viewDidLoad() {
    // Assumes you have implemented the sample code up to this step.
    ridesharingDriverAPI.vehicleReporter.update(.online)
  }
}

Objective-C

#import "SampleViewController.h"
#import "SampleAccessTokenProvider.h"
#import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>

static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";

@implementation SampleViewController {
  GMSMapView *_mapView;
}

-   (void)viewDidLoad {
  // Assumes you have implemented the sample code up to this step.
  [ridesharingDriverAPI.vehicleReporter
                                   updateVehicleState:GMTDVehicleStateOnline];
}

@end

Um erro update_mask pode ocorrer quando a máscara está vazia e geralmente ocorre na primeira atualização após a inicialização. O exemplo abaixo mostra como lidar com esse erro:

Swift

import GoogleRidesharingDriver

class VehicleReporterListener: NSObject, GMTDVehicleReporterListener {
  func vehicleReporter(
    _ vehicleReporter: GMTDVehicleReporter,
    didFail vehicleUpdate: GMTDVehicleUpdate,
    withError error: Error
  ) {
    let fullError = error as NSError
    if let innerError = fullError.userInfo[NSUnderlyingErrorKey] as? NSError {
      let innerFullError = innerError as NSError
      if innerFullError.localizedDescription.contains("update_mask cannot be empty") {
        emptyMaskUpdates += 1
        return
      }
    }
    failedUpdates += 1
  }

  override init() {
    emptyMaskUpdates = 0
    failedUpdates = 0
  }
}

Objective-C

#import "VehicleReporterListener.h"
#import <GoogleRidesharingDriver/GoogleRidesharingDriver.h>

@implementation VehicleReporterListener {
  NSInteger emptyMaskUpdates = 0;
  NSInteger failedUpdates = 0;
}

-   (void)vehicleReporter:(GMTDVehicleReporter *)vehicleReporter
   didFailVehicleUpdate:(GMTDVehicleUpdate *)vehicleUpdate
              withError:(NSError *)error {
  for (NSError *underlyingError in error.underlyingErrors) {
    if ([underlyingError.localizedDescription containsString:@"update_mask cannot be empty"]) {
      emptyMaskUpdates += 1;
      return;
    }
  }
  failedUpdates += 1
}

@end

Desativar atualizações de localização e deixar o veículo off-line

Seu app pode desativar as atualizações e deixar o veículo off-line. Por exemplo, quando o turno de um motorista termina, seu app pode definir locationTrackingEnabled como false. Desativar atualizações também define o status do veículo como OFFLINE no back-end do Fleet Engine.

Swift

vehicleReporter.locationTrackingEnabled = false

Objective-C

_vehicleReporter.locationTrackingEnabled = NO;