Pierwsze kroki ze sterownikiem SDK na iOS

Za pomocą pakietu Driver SDK możesz zapewnić ulepszoną nawigację i śledzenie w aplikacji Podróż i postęp realizacji zamówienia. Pakiet Driver SDK udostępnia aktualizacje lokalizacji pojazdu i zadań we flocie rozwiązań na żądanie w ramach usługi przejazdy i dostawy na żądanie.

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

Minimalne wymagania systemowe

  • Urządzenie mobilne musi mieć zainstalowany system iOS 14 lub nowszy.
  • Xcode w wersji 15 lub nowszej.

    • Wymagania wstępne

    W tym przewodniku przyjęto założenie, że Twoja aplikacja korzysta już z pakietu Navigation SDK, a backend Fleet Engine jest skonfigurowany i dostępny. Przykładowy kod zawiera jednak przykład konfiguracji pakietu Navigation SDK.

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

    Konfiguracja projektu

    Menedżer pakietów Swift

    Pakiet Driver SDK możesz zainstalować za pomocą menedżera pakietów Swift. Aby dodać pakiet SDK, musisz usunąć wszystkie zależności od pakietu Driver SDK.

    Aby dodać pakiet SDK do nowego lub istniejącego projektu, wykonaj te czynności:

    1. Otwórz project lub workspace Xcode, a następnie wybierz File > Add Package Dependencies (Plik > Dodaj zależności pakietu).
    2. Jako URL wpisz https://github.com/googlemaps/ios-driver-sdk, naciśnij Enter, aby pobrać pakiet, i kliknij „Dodaj pakiet”.
    3. Aby zainstalować określony element version, w polu Reguła zależności ustaw jedną z opcji zależnych od wersji. W przypadku nowych projektów zalecamy określenie najnowszej wersji i użycie opcji „Dokładna wersja”. Gdy skończysz, kliknij „Dodaj pakiet”.
    4. W oknie Wybierz produkty w pakiecie sprawdź, czy GoogleRidesharingDriver zostanie dodany do wyznaczonego main celu. Gdy skończysz, kliknij „Dodaj pakiet”.
    5. Aby sprawdzić instalację, przejdź do panelu General środowiska docelowego. W obszarze Frameworks, biblioteki i umieszczona treść powinny być widoczne zainstalowane pakiety. Możesz też wyświetlić sekcję „Zależności pakietów” w „Nawigatorze projektu”, aby sprawdzić pakiet i jego wersję.

    Aby zaktualizować package w istniejącym projekcie, wykonaj te czynności:

    1. Jeśli uaktualniasz aplikację z wersji wcześniejszej niż 9.0.0, po uaktualnieniu musisz usunąć te zależności: GoogleMapsBase, GoogleMapsCore i GoogleMapsM4B. Nie usuwaj zależności dla: GoogleMaps. Więcej informacji znajdziesz w informacjach o wersji 9.0.0.

      W ustawieniach konfiguracji projektu Xcode znajdź Frameworks, biblioteki i Embedded Content. Aby usunąć strukturę, użyj znaku minusa(-):

      • GoogleMapsBase (tylko w przypadku uaktualnień z wersji starszych niż 9.0.0)
      • GoogleMapsCore (tylko w przypadku uaktualnień z wersji starszych niż 9.0.0)
      • GoogleMapsM4B (tylko w przypadku uaktualnień z wersji starszych niż 9.0.0)
    2. W Xcode wybierz „File > Packages > Update to Latest Package Versions” (Plik > Pakiety> Aktualizuj do najnowszych wersji pakietu).
    3. Aby sprawdzić instalację, przejdź do sekcji Zależności pakietów w narzędziu Project Navigator i sprawdź pakiet i jego wersję.

    Aby usunąć istniejące zależności Drive SDK dodane za pomocą CocoaPods, wykonaj te czynności:

    1. Zamknij obszar roboczy Xcode. Otwórz terminal i wykonaj to polecenie:
      sudo gem install cocoapods-deintegrate cocoapods-clean 
pod deintegrate 
pod cache clean --all
    2. Usuń Podfile, Podfile.resolved i Xcode workspace, jeśli nie używasz ich do niczego innego niż CocoaPods.

    Aby ręcznie usunąć zainstalowany pakiet Driver SDK, wykonaj te czynności:

    1. W ustawieniach konfiguracji projektu Xcode znajdź Frameworks, Library, and Embedded Content (Tworzenie ramek, biblioteki i osadzone treści). Użyj znaku minusa(-), aby usunąć tę strukturę:

      • GoogleRidesharingDriver.xcframework

    2. Z katalogu najwyższego poziomu projektu Xcode usuń pakiet GoogleRidesharingDriver.

    CocoaPods

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

    • Narzędzie CocoaPods: aby zainstalować to narzędzie, otwórz Terminal i uruchom następujące polecenie.
       sudo gem install cocoapods

    1. Utwórz plik Podfile dla pakietu Driver SDK i użyj go do zainstalowania interfejsu API oraz jego zależności: utwórz plik o nazwie Podfile w katalogu projektu. Ten plik definiuje zależności projektu. Edytuj plik Podfile i dodaj zależności. Oto przykład zawierają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 jako zależności pody alfa i beta dla pakietu Driver SDK:

      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 zawierającego plik Podfile:

      cd <path-to-project>

    3. Uruchom polecenie instalacji poda. Spowoduje to zainstalowanie interfejsów API określonych w pliku Podfile wraz ze wszystkimi ich zależnościami.

      pod install

    4. Zamknij Xcode, a następnie otwórz (kliknij dwukrotnie) plik .xcworkspace swojego projektu, aby uruchomić Xcode. Od tej pory do otwierania projektu musisz używać pliku .xcworkspace.

    Więcej informacji znajdziesz w wprowadzeniu do CocoaPods.

    Instalacja ręczna

    XCFramework to pakiet binarny używany do instalowania pakietu Driver SDK. Możesz korzystać z tego pakietu na wielu platformach, w tym na komputerach korzystających z technologii Apple Silicon. Z tego przewodnika dowiesz się, jak ręcznie dodać do projektu pakiet XCFramework zawierający pakiet Driver SDK i skonfigurować ustawienia kompilacji w Xcode.

    Pobierz plik binarny i zasoby pakietu SDK:

    1. Rozpakuj pliki, aby uzyskać dostęp do XCFramework i zasobów.

    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. Jeśli grupa projektów jeszcze nie istnieje, utwórz w niej grupę projektów.

    4. Aby zainstalować pakiet Driver SDK, przeciągnij plik GoogleRidesharingDriver.xcframework do swojego projektu w sekcji Ramki, biblioteki i umieszczone treści. Gdy pojawi się odpowiedni komunikat, wybierz Kopiuj elementy.

    5. Przeciągnij pobrany plik GoogleRidesharingDriver.bundle do katalogu najwyższego poziomu w projekcie Xcode. Gdy pojawi się odpowiedni komunikat, wybierz Copy items if needed.

    6. Wybierz projekt w narzędziu Project Navigator, a potem wskaż miejsce docelowe aplikacji.

    7. Otwórz kartę Etapy kompilacji i w sekcji Połącz plik binarny z bibliotekami dodaj te 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

    8. Wybierz projekt zamiast konkretnego środowiska docelowego i otwórz kartę Build Settings (Ustawienia kompilacji). W sekcji Inne flagi łączące dodaj -ObjC do debugowania i wersji. Jeśli te ustawienia nie są widoczne, zmień filtr na pasku ustawień kompilacji z Podstawowe na Wszystkie.

    Dodaj plik manifestu prywatności Apple

    Apple wymaga podania informacji o ochronie prywatności w aplikacjach z App Store. Aktualizacje i inne informacje znajdziesz na stronie z informacjami o ochronie prywatności w Apple App Store.

    1. Pobierz pakiet manifestu prywatności dla Driver SDK na iOS: GoogleRidesharingDriverPrivacy.
    2. Rozpakuj plik, aby uzyskać dostęp do: GoogleRidesharingDriverPrivacy.bundle.
    3. Dodaj GoogleRidesharingDriverPrivacy.bundle do nawigatora projektów Xcode za pomocą jednej z tych metod. Upewnij się, że w przypadku środowiska docelowego aplikacji zaznaczone jest pole „Dodaj do celów”. Po dodaniu pliku PrivacyInfo pojawi się w nawigatorze projektów i będzie można przeglądać jego wartości.
      4. Zrzut ekranu z informacjami o prywatności Xcode
    4. Sprawdź, czy plik manifestu prywatności został dodany. W tym celu utwórz archiwum aplikacji i wygeneruj raport dotyczący prywatności z archiwum.

    Wdrażanie autoryzacji i uwierzytelniania

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

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

    • Pobierz token dostępu, prawdopodobnie w formacie JSON, z serwera HTTPS.
    • Przeanalizuj token i zapisz go w pamięci podręcznej.
    • Odśwież token po jego wygaśnięciu.

    Szczegółowe informacje o tokenach oczekiwanych przez serwer Fleet Engine znajdziesz w artykule Tworzenie tokena internetowego JSON (JWT) na potrzeby autoryzacji.

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

    Poniższy przykład implementuje dostawcę 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 identyfikatora dostawcy, identyfikatora pojazdu, driverContext i accessTokenProvider. Identyfikator dostawcy jest taki sam jak identyfikator projektu Google Cloud. Masz też dostęp do instancji GMTDVehicleReporter bezpośrednio z interfejsu API sterownika.

    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 możesz nasłuchiwać zdarzeń VehicleReporter

    GMTDVehicleReporter okresowo aktualizuje pojazd, gdy locationTrackingEnabled ma wartość true. Aby reagować na te okresowe aktualizacje, każdy obiekt może subskrybować zdarzenia GMTDVehicleReporter, spełniając wymagania protokołu GMTDVehicleReporterListener.

    Możesz obsługiwać te zdarzenia:

    • vehicleReporter(_:didSucceed:)

      Informuje aplikację sterownika, że usługi backendu odebrały aktualizację lokalizacji i stanu pojazdu.

    • vehicleReporter(_:didFail:withError:)

      Informują detektora o niepowodzeniu aktualizacji pojazdu. Dopóki śledzenie lokalizacji jest włączone, GMTDVehicleReporter 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 GMSRoadSnappedLocationProvider

    Aby przekazywać 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, Twoja aplikacja może ustawić wartość locationTrackingEnabled na true w: GMTDVehicleReporter. GMTDVehicleReporter automatycznie wysyła aktualizacje lokalizacji. Po dopasowaniu usług i przypisaniu pojazdu do podróży GMTDVehicleReporter wysyła aktualizacje trasy automatycznie, gdy GMSNavigator jest w trybie nawigacji (gdy miejsce docelowe jest ustawione w setDestinations).

    Trasa ustawiona w trakcie aktualizacji podróży będzie tą samą trasą, do której przechodzi kierowca podczas sesji nawigacji. Dlatego, aby udostępnianie przejazdów działało prawidłowo, punkt pośredni ustawiony przez setDestinations powinien być zgodny z miejscem docelowym w backendzie Fleet Engine.

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

    Poniższy 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ślny interwał raportowania wynosi 10 sekund, ale można go zmienić za pomocą funkcji locationUpdateInterval. Minimalny obsługiwany odstęp czasu aktualizacji to 5 sekund. Maksymalny obsługiwany interwał aktualizacji to 60 sekund. Częstsze aktualizacje mogą powodować wolniejsze wykonywanie żądań i błędy.

    Zaktualizuj stan pojazdu

    Przykład poniżej pokazuje, jak ustawić stan pojazdu na ONLINE. Więcej informacji znajdziesz na stronie 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

    Gdy maska jest pusta, może wystąpić błąd update_mask. Zwykle występuje przy pierwszej aktualizacji po uruchomieniu. Poniższy przykład pokazuje, jak naprawić ten błąd:

    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 włącz pojazd offline

    Aplikacja może wyłączyć aktualizacje i przełączyć pojazd w tryb offline. Na przykład po zakończeniu zmiany kierowcy aplikacja może ustawić właściwość locationTrackingEnabled na false. Wyłączenie aktualizacji ustawia też stan pojazdu na OFFLINE w backendzie Fleet Engine.

    Swift

    vehicleReporter.locationTrackingEnabled = false

    Objective-C

    _vehicleReporter.locationTrackingEnabled = NO;