Pierwsze kroki ze sterownikiem SDK na iOS

Możesz użyć pakietu Driver SDK, aby zapewnić lepszą nawigację i śledzenie w aplikacjach Podróż i Postępy zamówienia. Pakiet Driver SDK zapewnia aktualizacje lokalizacji pojazdów i zadań w Fleet Engine na żądanie.

Pakiet Driver SDK informuje usługi Fleet Engine i usługi niestandardowe o lokalizacji i stanie pojazdu. Może to być na przykład ONLINE lub OFFLINE, a lokalizacja pojazdu zmienia się w miarę postępów podróży.

Minimalne wymagania systemowe

  • Na urządzeniu mobilnym musi być zainstalowany iOS 13 lub nowszy.
  • Xcode w wersji 14 lub nowszej.

    • Wymagania wstępne

    W tym przewodniku zakładamy, że Twoja aplikacja korzysta już z nawigacji SDK oraz że backend Fleet Engine jest skonfigurowany i dostępny. Ten przykładowy kod pokazuje jednak, jak skonfigurować pakiet SDK nawigacji.

    Musisz też włączyć w projekcie Google Cloud pakiet SDK Map Google na iOS i uzyskać klucz interfejsu API.

    Konfiguracja projektu

    Możesz skonfigurować pakiet SDK sterownika za pomocą CocoaPods.

    Korzystanie z CocoaPods

    Aby skonfigurować pakiet SDK sterownika za pomocą CocoaPods, potrzebujesz tych elementów:

    1. Utwórz plik Podfile dla pakietu Driver SDK i użyj go do zainstalowania interfejsu API i jego zależności: utwórz w katalogu projektu plik o nazwie Podfile. Ten plik określa zależności w projekcie. Edytuj plik Podfile i dodaj zależności. Oto przykład uwzględniający zależności:

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

target 'YOUR_APPLICATION_TARGET_NAME_HERE' do
  pod 'GoogleRidesharingDriver'
end

      Oto przykład, który obejmuje pody w wersji alfa i beta pakietu SDK sterowników jako zależności:

      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. Zapisz plik Podfile. Otwórz terminal i przejdź do katalogu z plikiem Podfile:

      cd <path-to-project>

    3. Uruchom polecenie instalacji podów. Spowoduje to zainstalowanie interfejsów API określonych w pliku Podfile oraz wszystkich ich zależności.

      pod install

    4. Zamknij Xcode, a następnie otwórz (dwukrotnie) plik .xcworkspace swojego projektu, by uruchomić Xcode. Od tej pory projekt będzie można otwierać tylko za pomocą pliku .xcworkspace.

    Instalowanie XCFramework

    XCFramework to pakiet binarny służący do instalacji pakietu Driver SDK. Możesz używać tego pakietu na wielu platformach, w tym na komputerach korzystających z Apple Silicon. Ten przewodnik pokazuje, jak ręcznie dodać XCFramework zawierający pakiet SDK sterowników do projektu i skonfigurować ustawienia kompilacji w Xcode.

    1. Rozpakuj pliki źródłowe otrzymane od Google.

    2. Uruchom Xcode i otwórz istniejący projekt lub utwórz nowy. Jeśli dopiero zaczynasz korzystać z iOS, utwórz nowy projekt i wybierz szablon aplikacji na iOS.

    3. W grupie projektów utwórz grupę Platformy (jeśli jeszcze nie istnieje).

    4. Przeciągnij plik gRPCCertificates.bundle znajdujący się w katalogu Resources pliku ZIP zawierającego XCFramework do katalogu najwyższego poziomu projektu Xcode. Po wyświetleniu monitu w razie potrzeby wybierz Kopiuj elementy.

    5. Aby zainstalować pakiet SDK sterownika, przeciągnij plik GoogleRidesharingDriver.xcframework do projektu pod nagłówkiem Frameworks, Libraries, and Embedded Content. Po wyświetleniu monitu w razie potrzeby wybierz Kopiuj elementy.

    6. Kliknij prawym przyciskiem myszy GoogleRidesharingDriver.xcframework w projekcie i wybierz Show In Finder.

    7. Przeciągnij plik GoogleRidesharingDriver.bundle z folderu ios-arm64_x86_64-simulator/GoogleRidesharingDriver.framework/Resources do katalogu najwyższego poziomu projektu Xcode. Gdy pojawi się prośba, upewnij się, że pole Copy items if needed nie jest zaznaczone.

    8. Wybierz projekt w usłudze Project Navigator i wskaż miejsce docelowe aplikacji.

    9. Otwórz kartę Etapy kompilacji, a w sekcji Link Binary with Libraries dodaj następujące platformy i biblioteki, jeśli jeszcze ich nie ma:

      • 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

    10. Wybierz projekt zamiast konkretnego celu i otwórz kartę Ustawienia kompilacji. W sekcji Inne flagi tagu łączącego dodaj parametr ‑ObjC zarówno do debugowania, jak i publikowania. Jeśli nie widzisz tych ustawień, zmień filtr na pasku ustawień kompilacji z Podstawowe na Wszystkie.

    Wersje pakietu SDK alfa i beta

    Aby skonfigurować wersję alfa lub beta pakietu Driver SDK na iOS, potrzebujesz tych elementów:

    • Narzędzie CocoaPods: aby zainstalować to narzędzie, otwórz terminal i uruchom to polecenie.

      sudo gem install cocoapods

      Więcej informacji znajdziesz w przewodniku dla początkujących.

    • Twoje konto programisty jest na liście dostępu Google. Repozytorium poda wersji alfa i beta pakietu SDK nie jest publicznym źródłem. Aby uzyskać dostęp do tych wersji, skontaktuj się z inżynierem Google ds. obsługi klienta. Inżynier dodaje Twoje konto dewelopera do listy dostępu, a następnie ustawia plik cookie do uwierzytelniania.

    Gdy projekt znajdzie się na liście dostępu, uzyskasz dostęp do poda.

    1. Utwórz plik Podfile dla pakietu Delivery SDK na iOS i użyj go do zainstalowania interfejsu API i jego zależności: utwórz w katalogu projektu plik o nazwie Podfile. Ten plik określa zależności w projekcie. Edytuj plik Podfile i dodaj zależności. Oto przykład uwzględniający zależności:

      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. Zapisz plik Podfile. Otwórz terminal i przejdź do katalogu z plikiem Podfile:

      cd <path-to-project>

    3. Uruchom polecenie instalacji podów. Polecenie to instaluje interfejsy API określone w pliku Podfile oraz wszystkie ich zależności.

      pod install

    4. Zamknij Xcode, a następnie otwórz (dwukrotnie) plik .xcworkspace swojego projektu, by uruchomić Xcode. Od tej pory projekt będzie można otwierać tylko za pomocą pliku .xcworkspace.

    Wdrażanie autoryzacji i uwierzytelniania

    Gdy aplikacja sterownika generuje i wysyła aktualizacje do backendu Fleet Engine, żądania muszą zawierać prawidłowe tokeny dostępu. Aby autoryzować i uwierzytelnić te żądania, pakiet SDK sterownika wywołuje obiekt zgodnie z protokołem GMTDAuthorization. Obiekt odpowiada za udostępnienie wymaganego tokena dostępu.

    Jako deweloper aplikacji możesz wybrać sposób generowania tokenów. Implementacja powinna umożliwiać:

    • Wygeneruj token dostępu w formacie JSON z serwera HTTPS.
    • Przeanalizuj i zapisz token w pamięci podręcznej.
    • Odśwież token, gdy straci ważność.

    Informacje o tokenach, których oczekuje serwer Fleet Engine, znajdziesz w sekcji Tworzenie tokena internetowego JSON (JWT) do autoryzacji.

    Identyfikator dostawcy jest taki sam jak identyfikator projektu Google Cloud. Więcej informacji znajdziesz w krótkim wprowadzeniu do Fleet Engine.

    Oto przykład implementowania dostawcy tokena dostępu:

    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

    Tworzenie instancji RidesharingDriverAPI

    Aby pobrać instancję GMTDVehicleReporter, musisz najpierw utworzyć instancję GMTDRidesharingDriverAPI przy użyciu identyfikatorów providerID, vehicleID, sterownikContext i accessTokenProvider. Identyfikator dostawcy jest taki sam jak identyfikator projektu Google Cloud. Dostęp do instancji GMTDVehicleReporter możesz uzyskać bezpośrednio za pomocą interfejsu Drive API.

    Ten przykład tworzy instancję 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];
}

    Opcjonalnie nasłuchiwanie zdarzeń VehicleReporter

    GMTDVehicleReporter okresowo aktualizuje pojazd, gdy locationTrackingEnabled ma wartość true. W odpowiedzi na te okresowe aktualizacje każdy obiekt może subskrybować zdarzenia GMTDVehicleReporter zgodnie z protokołem GMTDVehicleReporterListener.

    Możesz obsługiwać te zdarzenia:

    • vehicleReporter(_:didSucceed:)

      Informuje aplikację sterownika, że usługi backendu pomyślnie otrzymały aktualizację lokalizacji i stanu pojazdu.

    • vehicleReporter(_:didFail:withError:)

      Informuje detektor, że aktualizacja pojazdu nie powiodła się. Dopóki śledzenie lokalizacji jest włączone, GMTDVehicleReporter nadal wysyła najnowsze dane do backendu Fleet Engine.

    Ten przykład obsługuje te zdarzenia:

    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

    Dodaj GMTDVehicleReporter jako detektor obiektu GMSRoadSnappedLocationProvider

    Aby udostępniać aktualizacje lokalizacji do pakietu Driver SDK, musisz ustawić GMTDVehicleReporter jako detektor GMSRoadSnappedLocationProvider.

    Swift

    import GoogleRidesharingDriver

private let providerID = "INSERT_YOUR_PROVIDER_ID"

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

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

    Objective-C

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

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

static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";

@implementation SampleViewController {
  GMSMapView *_mapView;
}

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

@end

    Włącz śledzenie lokalizacji

    Aby włączyć śledzenie lokalizacji, ustaw locationTrackingEnabled na true w aplikacji GMTDVehicleReporter. GMTDVehicleReporter automatycznie wysyła aktualizacje lokalizacji. Gdy usługi będą się zgadzać i przypisać pojazd do podróży, GMTDVehicleReporter automatycznie wyśle aktualizacje trasy, gdy GMSNavigator będzie w trybie nawigacji (gdy miejsce docelowe zostanie ustawione w setDestinations).

    Trasa ustawiona podczas aktualizacji podróży będzie tą samą trasą, którą kierowca porusza się podczas sesji nawigacji. Aby udostępnianie podróży działało prawidłowo, punkt pośredni ustawiony przez setDestinations powinien być zgodny z miejscem docelowym ustawionym w backendzie Fleet Engine.

    Jeśli zasada locationTrackingEnabled ma wartość true, aktualizacje dotyczące podróży i pojazdu są wysyłane do backendu Fleet Engine w regularnych odstępach czasu na podstawie wartości ustawionej w locationUpdateInterval. Jeśli locationTrackingEnabled ma wartość false, aktualizacje są zatrzymywane, a ostateczne żądanie aktualizacji pojazdu jest wysyłane do backendu Fleet Engine w celu ustawienia stanu pojazdu na GMTDVehicleState.offline. W sekcji updateVehicleState znajdziesz specjalne informacje na temat obsługi błędów, gdy locationTrackingEnabled ma wartość false.

    Ten przykład umożliwia włączenie śledzenia lokalizacji:

    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

    Domyślnie interwał raportowania wynosi 10 sekund, ale można go zmienić za pomocą locationUpdateInterval. Minimalny obsługiwany interwał aktualizacji to 5 sekund. Maksymalny obsługiwany interwał aktualizacji to 60 sekund. Częstsze aktualizacje mogą powodować wolniejsze żądania i błędy.

    Aktualizowanie stanu pojazdu

    Z przykładu poniżej dowiesz się, jak ustawić stan pojazdu na ONLINE. Więcej informacji: updateVehicleState.

    Swift

    import GoogleRidesharingDriver

private let providerID = "INSERT_YOUR_PROVIDER_ID"

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

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

    Objective-C

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

static NSString *const PROVIDER_ID = @"INSERT_YOUR_PROVIDER_ID";

@implementation SampleViewController {
  GMSMapView *_mapView;
}

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

@end

    Błąd update_mask może wystąpić, gdy maska jest pusta, i zwykle występuje przy pierwszej aktualizacji po uruchomieniu. Z przykładu poniżej dowiesz się, jak poradzić sobie z tym błędem:

    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

    Wyłącz aktualizacje lokalizacji i przełącz pojazd do trybu offline

    Aplikacja może wyłączyć aktualizacje i przełączyć pojazd w tryb offline. Na przykład, gdy kończy się zmiana kierowcy, aplikacja może ustawić locationTrackingEnabled na false. Wyłączenie aktualizacji powoduje też ustawienie stanu pojazdu na OFFLINE w backendzie Fleet Engine.

    Swift

    vehicleReporter.locationTrackingEnabled = false

    Objective-C

    _vehicleReporter.locationTrackingEnabled = NO;